type-plus 4.5.0 → 4.6.0

package/ts/array/CreateTuple.ts

@@ -1,12 +1,35 @@
-import type { IsPositive } from '../math'
+import {
+  // Digit,
+  IsPositive
+} from '../math'
+
+// export type CreateTuple<L extends number, T = any> =
+//   number extends L ? T[] : IsPositive<L> extends true
+//   ? [...Digit.ToTuple<T>[L]]
+//   : never
+
+type BuildPowersOf2LengthArrays<N extends number, R extends never[][]> =
+  R[0][N] extends never ? R : BuildPowersOf2LengthArrays<N, [[...R[0], ...R[0]], ...R]>
+
+type ConcatLargestUntilDone<N extends number, R extends never[][], B extends never[]> =
+  B['length'] extends N ? B : [...R[0], ...B][N] extends never
+  ? ConcatLargestUntilDone<N, R extends [R[0], ...infer U] ? U extends never[][] ? U : never : never, B>
+  : ConcatLargestUntilDone<N, R extends [R[0], ...infer U] ? U extends never[][] ? U : never : never, [...R[0], ...B]>
+
+type Replace<R extends any[], T> = { [K in keyof R]: T }
 
 /**
  * Creates `Tuple<T>` with `L` number of elements.
+ * @note The original implementation hits recursive limit.
+ * Updated implementation based on below by @lazytype
+ * @see https://github.com/microsoft/TypeScript/issues/26223#issuecomment-674514787
+ * @see https://github.com/microsoft/TypeScript/issues/47874#issuecomment-1039157322
  */
 export type CreateTuple<L extends number, T = any> =
-  IsPositive<L> extends true ? CreateTuple.Device<[], L, T> : never
-
-export namespace CreateTuple {
-  export type Device<R extends any[], L extends number, T> =
-    R['length'] extends L ? R : Device<[T, ...R], L, T>
-}
+  number extends L ? T[] : IsPositive<L> extends true
+  ? {
+    [K in L]: BuildPowersOf2LengthArrays<K, [[never]]> extends infer U
+    ? (U extends never[][] ? Replace<ConcatLargestUntilDone<K, U, []>, T> : never)
+    : never
+  }[L]
+  : never

package/ts/array/DropMatch.spec.ts

@@ -0,0 +1,113 @@
+import { DropMatch, isType } from '..'
+
+describe('DropMatch<A, C>', () => {
+  describe('A is array', () => {
+    test('drop all types gets never[]', () => {
+      type A = DropMatch<Array<string>, string>
+      isType.equal<true, never[], A>()
+
+      type B = DropMatch<Array<string | boolean>, string | boolean>
+      isType.equal<true, never[], B>()
+    })
+
+    test('drop undefined and null from array', () => {
+      type A = DropMatch<Array<string | undefined>, undefined>
+      isType.equal<true, string[], A>()
+
+      type B = DropMatch<Array<string | number | undefined>, undefined>
+      isType.equal<true, Array<string | number>, B>()
+
+      type C = DropMatch<Array<string | number | undefined | null>, undefined | null>
+      isType.equal<true, Array<string | number>, C>()
+    })
+
+    test('can get undefined and null array when other types dropped', () => {
+      type A = DropMatch<Array<string | undefined>, string>
+      isType.equal<true, undefined[], A>()
+
+      type B = DropMatch<Array<string | number | null>, string>
+      isType.equal<true, Array<number | null>, B>()
+    })
+
+    test('unmatched criteria returns original', () => {
+      type Actual = DropMatch<Array<string | undefined>, number>
+
+      isType.equal<true, Array<string | undefined>, Actual>()
+    })
+  })
+
+  describe('A is Tuple', () => {
+    test('empty tuple', () => {
+      type A = DropMatch<[], undefined>
+      isType.equal<true, [], A>()
+
+      type B = DropMatch<[1, undefined], undefined>
+      isType.equal<true, [1], B>()
+
+      type C = DropMatch<[1, undefined, 3], undefined>
+      isType.equal<true, [1, 3], C>()
+
+      type D = DropMatch<[1, string | undefined, 3], undefined>
+      isType.equal<true, [1, string, 3], D>()
+    })
+
+    test('drop undefined from tuple', () => {
+      type A = DropMatch<[undefined], undefined>
+      isType.equal<true, [], A>()
+
+      type B = DropMatch<[1, undefined], undefined>
+      isType.equal<true, [1], B>()
+
+      type C = DropMatch<[1, undefined, 3], undefined>
+      isType.equal<true, [1, 3], C>()
+
+      type D = DropMatch<[1, string | undefined, 3], undefined>
+      isType.equal<true, [1, string, 3], D>()
+    })
+
+    test('get original if not matched', () => {
+      type A = DropMatch<[1], undefined>
+      isType.equal<true, [1], A>()
+
+      type B = DropMatch<[1], undefined | string>
+      isType.equal<true, [1], B>()
+
+      type C = DropMatch<[1, 2, 3, 4], 5>
+      isType.equal<true, [1, 2, 3, 4], C>()
+    })
+
+    test('drop narrow type', () => {
+      type C = DropMatch<[1], number>
+      isType.equal<true, [], C>()
+    })
+
+    test('keep widen type', () => {
+      type D = DropMatch<[number], 1>
+      isType.equal<true, [number], D>()
+    })
+
+    test('drop type from tuple', () => {
+      type A = DropMatch<[1], 1>
+      isType.equal<true, [], A>()
+
+      type B = DropMatch<[number | string], number>
+      isType.equal<true, [string], B>()
+
+      type C = DropMatch<[1, undefined, 3], 1>
+      isType.equal<true, [undefined, 3], C>()
+
+      type D = DropMatch<[1, string | undefined, 3], 3>
+      isType.equal<true, [1, string | undefined], D>()
+    })
+
+    test('drop multiple types', () => {
+      type Actual = DropMatch<[1, 2, 3, 4], 2 | 4>
+      isType.equal<true, [1, 3], Actual>()
+    })
+
+    test('drop undefined and null', () => {
+      type Actual = DropMatch<[1, undefined, 3, null], undefined | null>
+      isType.equal<true, [1, 3], Actual>()
+    })
+  })
+})

package/ts/array/DropMatch.ts

@@ -0,0 +1,53 @@
+import { Equal } from '../predicates'
+
+type ExcludeUnionOfEmptyTuple<A> = Equal<A, []> extends true ? A : Exclude<A, []>
+
+/**
+ * drops entries matching `Criteria` in array or tuple `A`.
+ */
+export type DropMatch<A extends Array<any>, Criteria> =
+  number extends A['length']
+  // array
+  ? (A[0] extends Criteria
+    // criteria matches: DropAll<string[], string>
+    ? never[]
+    : (undefined extends Criteria
+      ? Array<NonNullable<A[0]>>
+      // TODO: A[0] extends Criteria?
+      : (Criteria extends A[0] ? Array<Exclude<A[0], Criteria>> : A))
+  )
+  : DropMatchTuple<A, Criteria>
+
+type DropMatchTuple<A extends Array<any>, Criteria> =
+  (A['length'] extends 0
+    // empty tuple
+    ? A
+    : (A extends [infer Head, ...infer Tail]
+      ? (Tail['length'] extends 0
+        // single element tuple
+        ? (undefined extends Criteria
+          ? (Head extends Criteria
+            ? []
+            : [Head])
+          : ExcludeUnionOfEmptyTuple<(Head extends Criteria ? [] : [Head])>
+        )
+        // multiple elements
+        : (Exclude<Head, Criteria> extends never
+          ? DropMatch<Tail, Criteria>
+          : [Exclude<Head, Criteria>, ...DropMatch<Tail, Criteria>]
+        ))
+      : never[]))
+  // : (undefined extends Criteria
+  //   ? (Head extends undefined
+  //     ? DropAll<Tail, Criteria>
+  //     : [NonNullable<Head>, ...DropAll<Tail, Criteria>])
+  //   : []
+  // ))
+  // : (Head extends Criteria
+  //   ? (undefined extends Criteria
+  //     ? [1, 2, 3]// [NonNullable<Head>, ...Filter<Tail, Criteria>]
+  //     : [2, 3]// [Head, ...Filter<Tail, Criteria>]
+  //   )
+  //   : [2]//Filter<Tail, Criteria>
+  // ))
+  // : 2[]))

package/ts/array/Filter.spec.ts

@@ -1,21 +1,107 @@
-import { assertType, Equal, Filter } from '..'
-
-test('array matching criteria gets itself', () => {
-  type Actual = Filter<string[], string>
-  assertType.isTrue(true as Equal<string[], Actual>)
-})
-
-test('array not matching criteria gets never[]', () => {
-  type Actual = Filter<string[], number>
-  assertType.isTrue(true as Equal<never[], Actual>)
-})
-
-test('tuple filters to those matching criteria', () => {
-  type Actual = Filter<[1, 2, 3, 4], 2 | 4>
-  assertType.isTrue(true as Equal<[2, 4], Actual>)
-})
-
-test('tuple not value match criteria gets never[]', () => {
-  type Actual = Filter<[1, 2, 3, 4], 5>
-  assertType.isTrue(true as Equal<never[], Actual>)
-})
+import { Filter, isType, KeepMatch } from '..'
+
+describe('Filter<A, C>', () => {
+  describe('A is array', () => {
+    test('array matching criteria gets itself', () => {
+      type Actual = Filter<string[], string>
+      isType.equal<true, string[], Actual>()
+    })
+
+    test('array not matching criteria gets never[]', () => {
+      type Actual = Filter<string[], number>
+      isType.equal<true, never[], Actual>()
+    })
+
+    test('remove unmatched type form array', () => {
+      type Actual = Filter<Array<string | number>, string>
+
+      isType.equal<true, string[], Actual>()
+    })
+
+    test('remove undefined and null', () => {
+      type Actual = Filter<Array<string | undefined | null>, string>
+      isType.equal<true, string[], Actual>()
+    })
+
+    test('can filter with undefined and null', () => {
+      type Actual = Filter<Array<string | undefined | null>, undefined | null>
+      // Array<undefined | null> is destructured to undefined[] | null[] by TypeScript
+      isType.equal<true, undefined[] | null[], Actual>()
+    })
+
+    test('work with never[]', () => {
+      type Actual = Filter<never[], undefined>
+      isType.equal<true, never[], Actual>()
+    })
+  })
+
+  describe(`A is Tuple`, () => {
+    test('matching criteria', () => {
+      type Actual = Filter<[1, 2, 3, 4], 2 | 4>
+      isType.equal<true, [2, 4], Actual>()
+    })
+
+    test('no match gets never[]', () => {
+      type Actual = Filter<[1, 2, 3, 4], 5>
+      isType.equal<true, never[], Actual>()
+    })
+
+    test('matching undefined and null', () => {
+      type Actual = Filter<[1, undefined, 3, null], undefined | null>
+      isType.equal<true, [undefined, null], Actual>()
+    })
+  })
+})
+
+describe('KeepMatch<A, C>', () => {
+  describe('A is array', () => {
+    test('array matching criteria gets itself', () => {
+      type Actual = KeepMatch<string[], string>
+      isType.equal<true, string[], Actual>()
+    })
+
+    test('array not matching criteria gets never[]', () => {
+      type Actual = KeepMatch<string[], number>
+      isType.equal<true, never[], Actual>()
+    })
+
+    test('remove unmatched type form array', () => {
+      type Actual = KeepMatch<Array<string | number>, string>
+
+      isType.equal<true, string[], Actual>()
+    })
+
+    test('remove undefined and null', () => {
+      type Actual = KeepMatch<Array<string | undefined | null>, string>
+      isType.equal<true, string[], Actual>()
+    })
+
+    test('can filter with undefined and null', () => {
+      type Actual = KeepMatch<Array<string | undefined | null>, undefined | null>
+      // Array<undefined | null> is destructured to undefined[] | null[] by TypeScript
+      isType.equal<true, undefined[] | null[], Actual>()
+    })
+
+    test('work with never[]', () => {
+      type Actual = KeepMatch<never[], undefined>
+      isType.equal<true, never[], Actual>()
+    })
+  })
+
+  describe(`A is Tuple`, () => {
+    test('matching criteria', () => {
+      type Actual = KeepMatch<[1, 2, 3, 4], 2 | 4>
+      isType.equal<true, [2, 4], Actual>()
+    })
+
+    test('no match gets never[]', () => {
+      type Actual = KeepMatch<[1, 2, 3, 4], 5>
+      isType.equal<true, never[], Actual>()
+    })
+
+    test('matching undefined and null', () => {
+      type Actual = KeepMatch<[1, undefined, 3, null], undefined | null>
+      isType.equal<true, [undefined, null], Actual>()
+    })
+  })
+})

package/ts/array/Filter.ts

@@ -1,12 +1,26 @@
-export type Filter<A extends Array<any>, Criteria> =
-  number extends A['length']
-  ? (A[0] extends Criteria ? A : never[])
-  : (A['length'] extends 0
-    ? never
-    : (A extends [infer Head, ...infer Tail]
-      ? (Tail['length'] extends 0
-        ? (Head extends Criteria ? [Head] : never[])
-        : (Head extends Criteria
-          ? [Head, ...Filter<Tail, Criteria>]
-          : Filter<Tail, Criteria>))
-      : never))
+/**
+ * filter the array or tuple `A`, keeping entries satisfying `Criteria`.
+ * @deprecated renaming to `KeepMatch`
+ */
+export type Filter<A extends Array<any>, Criteria> =
+  number extends A['length']
+  // array
+  ? (A[0] extends Criteria
+    ? A
+    : (Criteria extends A[0] ? Array<Criteria> : never[])
+  )
+  // tuple
+  : (A['length'] extends 0
+    ? never
+    : (A extends [infer Head, ...infer Tail]
+      ? (Tail['length'] extends 0
+        ? (Head extends Criteria ? [Head] : never[])
+        : (Head extends Criteria
+          ? [Head, ...Filter<Tail, Criteria>]
+          : Filter<Tail, Criteria>))
+      : never))
+
+/**
+ * keeps entries satisfying `Criteria` in array or tuple `A`.
+ */
+export type KeepMatch<A extends Array<any>, Criteria> = Filter<A, Criteria>

package/ts/array/index.ts

@@ -3,7 +3,8 @@ export type { Concat } from './Concat'
 export type { CreateTuple } from './CreateTuple'
 export type { DropFirst } from './DropFirst'
 export type { DropLast } from './DropLast'
-export type { Filter } from './Filter'
+export type { DropMatch } from './DropMatch'
+export type { Filter, KeepMatch } from './Filter'
 export type { FindFirst, First } from './FindFirst'
 export type { FindLast } from './FindLast'
 export type { Head } from './Head'

package/ts/math/Add.spec.ts

@@ -1,82 +1,82 @@
-import { Add, Increment, isType } from '..'
-
-describe('Add<A, B>', () => {
-  test('fractional A gets never', () => {
-    isType.equal<true, never, Add<1.1, 1>>()
-  })
-
-  test('negative A gets never', () => {
-    isType.equal<true, never, Add<-1, 1>>()
-  })
-
-  test('fractional B gets never', () => {
-    isType.equal<true, never, Add<1, 1.2>>()
-  })
-
-  test('negative B gets never', () => {
-    isType.equal<true, never, Add<1, -1>>()
-  })
-
-  test('number gets Fail', () => {
-    isType.equal<true, never, Add<number, 1>>()
-    isType.equal<true, never, Add<1, number>>()
-
-    isType.equal<true, number, Add<number, 1, number>>()
-    isType.equal<true, number, Add<1, number, number>>()
-  })
-
-  describe('single digit', () => {
-    test('0 + n = n', () => {
-      isType.equal<true, 0, Add<0, 0>>()
-      isType.equal<true, 1, Add<0, 1>>()
-      isType.equal<true, 2, Add<0, 2>>()
-      isType.equal<true, 3, Add<0, 3>>()
-      isType.equal<true, 4, Add<0, 4>>()
-      isType.equal<true, 5, Add<0, 5>>()
-      isType.equal<true, 6, Add<0, 6>>()
-      isType.equal<true, 7, Add<0, 7>>()
-      isType.equal<true, 8, Add<0, 8>>()
-      isType.equal<true, 9, Add<0, 9>>()
-    })
-    test('9 + n', () => {
-      isType.equal<true, 9, Add<9, 0>>()
-      isType.equal<true, 10, Add<9, 1>>()
-      isType.equal<true, 11, Add<9, 2>>()
-      isType.equal<true, 12, Add<9, 3>>()
-      isType.equal<true, 13, Add<9, 4>>()
-      isType.equal<true, 14, Add<9, 5>>()
-      isType.equal<true, 15, Add<9, 6>>()
-      isType.equal<true, 16, Add<9, 7>>()
-      isType.equal<true, 17, Add<9, 8>>()
-      isType.equal<true, 18, Add<9, 9>>()
-    })
-  })
-
-  test('1 + 2 digits', () => {
-    isType.equal<true, 16, Add<3, 13>>()
-    isType.equal<true, 108, Add<9, 99>>()
-  })
-
-  test('2 + 1 digits', () => {
-    isType.equal<true, 16, Add<13, 3>>()
-    isType.equal<true, 108, Add<99, 9>>()
-  })
-
-  test('2 + 2 digits', () => {
-    isType.equal<true, 20, Add<10, 10>>()
-    isType.equal<true, 38, Add<19, 19>>()
-  })
-
-  test('n + n digits', () => {
-    isType.equal<true, 7777, Add<1234, 6543>>()
-  })
-})
-
-describe('Increment<A>', () => {
-  test('add 1', () => {
-    isType.equal<true, 1, Increment<0>>()
-  })
-  test('work with large number', () => {
-    isType.equal<true, 7777, Increment<7776>>()
-  })
-})
+import { Add, Increment, isType } from '..'
+
+describe('Add<A, B>', () => {
+  test('fractional A gets never', () => {
+    isType.equal<true, never, Add<1.1, 1>>()
+  })
+
+  test('negative A gets never', () => {
+    isType.equal<true, never, Add<-1, 1>>()
+  })
+
+  test('fractional B gets never', () => {
+    isType.equal<true, never, Add<1, 1.2>>()
+  })
+
+  test('negative B gets never', () => {
+    isType.equal<true, never, Add<1, -1>>()
+  })
+
+  test('number gets Fail', () => {
+    isType.equal<true, never, Add<number, 1>>()
+    isType.equal<true, never, Add<1, number>>()
+
+    isType.equal<true, number, Add<number, 1, number>>()
+    isType.equal<true, number, Add<1, number, number>>()
+  })
+
+  describe('single digit', () => {
+    test('0 + n = n', () => {
+      isType.equal<true, 0, Add<0, 0>>()
+      isType.equal<true, 1, Add<0, 1>>()
+      isType.equal<true, 2, Add<0, 2>>()
+      isType.equal<true, 3, Add<0, 3>>()
+      isType.equal<true, 4, Add<0, 4>>()
+      isType.equal<true, 5, Add<0, 5>>()
+      isType.equal<true, 6, Add<0, 6>>()
+      isType.equal<true, 7, Add<0, 7>>()
+      isType.equal<true, 8, Add<0, 8>>()
+      isType.equal<true, 9, Add<0, 9>>()
+    })
+    test('9 + n', () => {
+      isType.equal<true, 9, Add<9, 0>>()
+      isType.equal<true, 10, Add<9, 1>>()
+      isType.equal<true, 11, Add<9, 2>>()
+      isType.equal<true, 12, Add<9, 3>>()
+      isType.equal<true, 13, Add<9, 4>>()
+      isType.equal<true, 14, Add<9, 5>>()
+      isType.equal<true, 15, Add<9, 6>>()
+      isType.equal<true, 16, Add<9, 7>>()
+      isType.equal<true, 17, Add<9, 8>>()
+      isType.equal<true, 18, Add<9, 9>>()
+    })
+  })
+
+  test('1 + 2 digits', () => {
+    isType.equal<true, 16, Add<3, 13>>()
+    isType.equal<true, 108, Add<9, 99>>()
+  })
+
+  test('2 + 1 digits', () => {
+    isType.equal<true, 16, Add<13, 3>>()
+    isType.equal<true, 108, Add<99, 9>>()
+  })
+
+  test('2 + 2 digits', () => {
+    isType.equal<true, 20, Add<10, 10>>()
+    isType.equal<true, 38, Add<19, 19>>()
+  })
+
+  test('n + n digits', () => {
+    isType.equal<true, 7777, Add<1234, 6543>>()
+  })
+})
+
+describe('Increment<A>', () => {
+  test('add 1', () => {
+    isType.equal<true, 1, Increment<0>>()
+  })
+  test('work with large number', () => {
+    isType.equal<true, 7777, Increment<7776>>()
+  })
+})