From c42bad020115d05c3e42e6c26c9a32dfde03d35f Mon Sep 17 00:00:00 2001
From: silverwind <me@silverwind.io>
Date: Thu, 8 Aug 2024 19:25:28 +0200
Subject: [PATCH] Add `EmptyArray` and `IsEmptyArray` types

Fixes: https://github.com/sindresorhus/type-fest/issues/929
---
 index.d.ts              |  1 +
 readme.md               |  2 ++
 source/empty-array.d.ts | 32 ++++++++++++++++++++++++++++++++
 test-d/empty-array.ts   | 39 +++++++++++++++++++++++++++++++++++++++
 4 files changed, 74 insertions(+)
 create mode 100644 source/empty-array.d.ts
 create mode 100644 test-d/empty-array.ts

diff --git a/index.d.ts b/index.d.ts
index 8c1588260..60e92332c 100644
--- a/index.d.ts
+++ b/index.d.ts
@@ -9,6 +9,7 @@ export type {KeysOfUnion} from './source/keys-of-union';
 export type {DistributedOmit} from './source/distributed-omit';
 export type {DistributedPick} from './source/distributed-pick';
 export type {EmptyObject, IsEmptyObject} from './source/empty-object';
+export type {EmptyArray, IsEmptyArray} from './source/empty-array';
 export type {IfEmptyObject} from './source/if-empty-object';
 export type {NonEmptyObject} from './source/non-empty-object';
 export type {UnknownRecord} from './source/unknown-record';
diff --git a/readme.md b/readme.md
index 231804811..0f62c51cf 100644
--- a/readme.md
+++ b/readme.md
@@ -128,6 +128,7 @@ Click the type names for complete docs.
 - [`EmptyObject`](source/empty-object.d.ts) - Represents a strictly empty plain object, the `{}` value.
 - [`NonEmptyObject`](source/non-empty-object.d.ts) - Represents an object with at least 1 non-optional key.
 - [`UnknownRecord`](source/unknown-record.d.ts) - Represents an object with `unknown` value. You probably want this instead of `{}`.
+- [`EmptyArray`](source/empty-array.d.ts) - Represents a strictly empty array, the `[]` value.
 - [`UnknownArray`](source/unknown-array.d.ts) - Represents an array with `unknown` value.
 - [`Except`](source/except.d.ts) - Create a type from an object type without certain keys. This is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/utility-types.html#omittype-keys).
 - [`Writable`](source/writable.d.ts) - Create a type that strips `readonly` from the given type. Inverse of `Readonly<T>`.
@@ -242,6 +243,7 @@ type ShouldBeNever = IfAny<'not any', 'not never', 'never'>;
 - [`IsNever`](source/is-never.d.ts) - Returns a boolean for whether the given type is `never`. (Conditional version: [`IfNever`](source/if-never.d.ts))
 - [`IsUnknown`](source/is-unknown.d.ts) - Returns a boolean for whether the given type is `unknown`. (Conditional version: [`IfUnknown`](source/if-unknown.d.ts))
 - [`IsEmptyObject`](source/empty-object.d.ts) - Returns a boolean for whether the type is strictly equal to an empty plain object, the `{}` value. (Conditional version: [`IfEmptyObject`](source/if-empty-object.d.ts))
+- [`IsEmptyArray`](source/empty-array.d.ts) - Returns a `boolean` for whether the type is strictly equal to an empty array, the `[]` value.
 - [`IsNull`](source/is-null.d.ts) - Returns a boolean for whether the given type is `null`. (Conditional version: [`IfNull`](source/if-null.d.ts))
 
 ### JSON
diff --git a/source/empty-array.d.ts b/source/empty-array.d.ts
new file mode 100644
index 000000000..2be962a47
--- /dev/null
+++ b/source/empty-array.d.ts
@@ -0,0 +1,32 @@
+/**
+Represents a strictly empty array, the `[]` value.
+
+@example
+```
+import type {EmptyArray} from 'type-fest';
+
+const bar1: EmptyArray = []; // Pass
+const bar2: EmptyArray = {}; // Fail
+const bar3: EmptyArray = null; // Fail
+```
+
+@category Array
+*/
+export type EmptyArray = never[];
+
+/**
+Returns a `boolean` for whether the type is strictly equal to an empty array, the `[]` value.
+
+@example
+```
+import type {IsEmptyArray} from 'type-fest';
+
+type Pass = IsEmptyArray<[]>; //=> true
+type Fail = IsEmptyArray<{}>; //=> false
+type Fail = IsEmptyArray<null>; //=> false
+```
+
+@see EmptyArray
+@category Array
+*/
+export type IsEmptyArray<T> = T extends EmptyArray ? true : false;
diff --git a/test-d/empty-array.ts b/test-d/empty-array.ts
new file mode 100644
index 000000000..755f2ac89
--- /dev/null
+++ b/test-d/empty-array.ts
@@ -0,0 +1,39 @@
+import {expectAssignable, expectNotAssignable, expectType} from 'tsd';
+import type {EmptyArray, IsEmptyArray} from '../index';
+
+declare let foo: EmptyArray;
+
+expectAssignable<EmptyArray>([]);
+expectNotAssignable<EmptyArray>([1]);
+expectNotAssignable<EmptyArray>([undefined]);
+expectNotAssignable<EmptyArray>({});
+
+foo = [];
+foo = [...[]]; // eslint-disable-line unicorn/no-useless-spread
+foo = [...new Set([])];
+foo.slice(1);
+foo.splice(1);
+const _length = foo.length;
+
+// @ts-expect-error
+foo.push(1);
+// @ts-expect-error
+foo.fill(1);
+// @ts-expect-error
+foo.unshift(1);
+// @ts-expect-error
+foo = [1];
+// @ts-expect-error
+foo = [...[1]]; // eslint-disable-line unicorn/no-useless-spread
+// @ts-expect-error
+foo = [...new Set([1])];
+// @ts-expect-error
+foo = null;
+// @ts-expect-error
+foo.bar = 42;
+// @ts-expect-error
+foo.bar = [];
+
+expectType<IsEmptyArray<[]>>(true);
+expectType<IsEmptyArray<[1]>>(false);
+expectType<IsEmptyArray<typeof foo>>(true);