type-plus 4.8.2 → 4.10.0

package/ts/object/split.ts

@@ -1,6 +1,7 @@
-import { AnyRecord } from './AnyRecord'
-import { Omit } from './omit'
-import { reduceByKey } from './reduceKey'
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import type { AnyRecord } from './AnyRecord.js'
+import type { Omit } from './omit.js'
+import { reduceByKey } from './reduceKey.js'
 
 type Splitter<T extends AnyRecord> = Partial<{ [k in keyof T]: T[k] | undefined }>
 export type Split<T extends AnyRecord, S extends AnyRecord> = {
@@ -195,7 +196,7 @@ export function split(target: AnyRecord, ...splitters: AnyRecord[]): AnyRecord[]
   const keyMap: AnyRecord = {}
   const s = splitters.map(s => reduceByKey(
     s,
-    (p, k) => (keyMap[k] = true, p[k] = target[k]  ?? s[k], p),
+    (p, k) => (keyMap[k] = true, p[k] = target[k] ?? s[k], p),
     {} as AnyRecord))
   const r = reduceByKey(target, (p, k) => keyMap[k] ? p : (p[k] = target[k], p), {} as AnyRecord)
   return [...s, r]

package/ts/object/typeOverrideIncompatible.ts

@@ -1,10 +1,10 @@
-import { ANotB, AnyRecord } from '.'
-
-export function typeOverrideIncompatible<A extends AnyRecord>() {
-  return function <B extends AnyRecord>(source: B, override: ANotB<A, B>): A {
-    return {
-      ...source,
-      ...override,
-    }
-  }
-}
+import type { ANotB, AnyRecord } from './index.js'
+
+export function typeOverrideIncompatible<A extends AnyRecord>() {
+  return function <B extends AnyRecord>(source: B, override: ANotB<A, B>): A {
+    return {
+      ...source,
+      ...override,
+    }
+  }
+}

package/ts/predicates/CanAssign.ts

@@ -1,5 +1,5 @@
-import { NotExtendable } from './Extends'
-import { IsEmptyObject } from './IsEmptyObject'
+import type { NotExtendable } from './Extends.js'
+import type { IsEmptyObject } from './IsEmptyObject.js'
 
 /**
  * Can `A` assign to `B`

package/ts/predicates/index.ts

@@ -1,12 +1,12 @@
-export * from './CanAssign'
-export type { Equal, IsEqual, IsNotEqual, NotEqual } from './Equal'
-export type { Extendable, IsExtend, IsNotExtend, NotExtendable } from './Extends'
-export type { If } from './If'
-export * from './isType'
-export type { And, Not, Or, Xor } from './logical'
-export type { IsEmptyObject } from './IsEmptyObject'
+export * from './CanAssign.js'
+export type { Equal, IsEqual, IsNotEqual, NotEqual } from './Equal.js'
+export type { Extendable, IsExtend, IsNotExtend, NotExtendable } from './Extends.js'
+export type { If } from './If.js'
+export * from './isType.js'
+export type { And, Not, Or, Xor } from './logical.js'
+export type { IsEmptyObject } from './IsEmptyObject.js'
 
-import { IsExtend } from './Extends'
+import type { IsExtend } from './Extends.js'
 
 export type IsLiteral<T extends number | string, Then = true, Else = false> = number extends T ?
   Else :

package/ts/predicates/isType.ts

@@ -1,30 +1,30 @@
-import { AnyConstructor, isConstructor } from '../class'
-import { Equal } from './Equal'
-
-export function isType<T>(subject: T): subject is T
-export function isType<T>(subject: unknown, validator: (s: T) => boolean): subject is T
-export function isType<T extends AnyConstructor>(subject: unknown, constructor: T): subject is InstanceType<T>
-export function isType(subject: unknown, validator?: AnyConstructor | ((s: unknown) => boolean)) {
-  if (validator) {
-    if (isConstructor(validator))
-      return subject instanceof validator
-    else
-      return validator(subject)
-  }
-  return true
-}
-
-isType.t = function <T extends true>(subject?: T) {
-  return subject === undefined || subject === true
-}
-isType.f = function <T extends false>(subject?: T) {
-  return subject === undefined || subject === false
-}
-
-/**
- * are types A and B equals/not equals.
- * Slightly easier to use then `isType.t<>()` and `isType.f<>()`,
- * when doing type level only equality comparison as you don't have to import `Equal<>`.
- */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-isType.equal = function <C extends Equal<A, B>, A, B>() { }
+import { AnyConstructor, isConstructor } from '../class/index.js'
+import type { Equal } from './Equal.js'
+
+export function isType<T>(subject: T): subject is T
+export function isType<T>(subject: unknown, validator: (s: T) => boolean): subject is T
+export function isType<T extends AnyConstructor>(subject: unknown, constructor: T): subject is InstanceType<T>
+export function isType(subject: unknown, validator?: AnyConstructor | ((s: unknown) => boolean)) {
+  if (validator) {
+    if (isConstructor(validator))
+      return subject instanceof validator
+    else
+      return validator(subject)
+  }
+  return true
+}
+
+isType.t = function <T extends true>(subject?: T) {
+  return subject === undefined || subject === true
+}
+isType.f = function <T extends false>(subject?: T) {
+  return subject === undefined || subject === false
+}
+
+/**
+ * are types A and B equals/not equals.
+ * Slightly easier to use then `isType.t<>()` and `isType.f<>()`,
+ * when doing type level only equality comparison as you don't have to import `Equal<>`.
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+isType.equal = function <C extends Equal<A, B>, A, B>() { }

package/ts/promise/PromiseValueMerge.ts

@@ -1,4 +1,4 @@
-import { PromiseValue } from './PromiseValue'
+import type { PromiseValue } from './PromiseValue.js'
 
 /**
  * Merging value types from multiple promises.

package/ts/promise/index.ts

@@ -1,4 +1,4 @@
-export * from './isPromise'
-export type { PromiseValue } from './PromiseValue'
-export type { PromiseValueMerge } from './PromiseValueMerge'
-export * from './mapSeries'
+export * from './isPromise.js'
+export type { PromiseValue } from './PromiseValue.js'
+export type { PromiseValueMerge } from './PromiseValueMerge.js'
+export * from './mapSeries.js'

package/ts/testing/index.ts

@@ -1 +1 @@
-export * from './stub'
+export * from './stub.js'

package/ts/testing/stub.ts

@@ -1,6 +1,6 @@
 import { requiredDeep } from 'unpartial'
-import { AnyFunction } from '../function'
-import { RecursivePartial } from '../object'
+import type { AnyFunction } from '../function/index.js'
+import type { RecursivePartial } from '../object/index.js'
 
 export namespace stub {
   export type Param<T> = T extends AnyFunction ? T : RecursivePartial<T>

package/ts/utils/index.ts

@@ -1,4 +1,4 @@
-export * from './as'
-export type { NonNull } from './NonNull'
-export type { NonUndefined } from './NonUndefined'
-export type { Widen } from './Widen'
+export * from './as.js'
+export type { NonNull } from './NonNull.js'
+export type { NonUndefined } from './NonUndefined.js'
+export type { Widen } from './Widen.js'

package/ts/ComposableTypes.spec.ts

@@ -1,29 +0,0 @@
-import { assertType, canAssign, ComposableTypes, NonComposableTypes } from '.'
-
-test('ComposableTypes includes object, array, and function', () => {
-  assertType<ComposableTypes>({})
-  assertType<ComposableTypes>([])
-  // function is composable because you can do
-  // `Object.assign(fn, { ... })
-  assertType<ComposableTypes>(() => { })
-
-  assertType.isTrue(canAssign<ComposableTypes>(false)(null))
-  assertType.isTrue(canAssign<ComposableTypes>(false)(undefined))
-  assertType.isTrue(canAssign<ComposableTypes>(false)(1))
-  assertType.isTrue(canAssign<ComposableTypes>(false)(true))
-  assertType.isTrue(canAssign<ComposableTypes>(false)(''))
-  assertType.isTrue(canAssign<ComposableTypes>(false)(Symbol()))
-})
-
-test('NonComposableType excludes object, array, and function', () => {
-  assertType<NonComposableTypes>(null)
-  assertType<NonComposableTypes>(undefined)
-  assertType<NonComposableTypes>(true)
-  assertType<NonComposableTypes>(1)
-  assertType<NonComposableTypes>('')
-  assertType<NonComposableTypes>(Symbol())
-
-  assertType.isTrue(canAssign<NonComposableTypes>(false)({}))
-  assertType.isTrue(canAssign<NonComposableTypes>(false)([]))
-  assertType.isTrue(canAssign<NonComposableTypes>(false)(() => { }))
-})

package/ts/JSONTypes.spec.ts

@@ -1,43 +0,0 @@
-import { assertType } from './assertion'
-import { JSONObject, JSONTypes } from './JSONTypes'
-import { isType } from './predicates'
-
-test('empty object', () => {
-  assertType<JSONTypes>({})
-})
-
-test('empty array', () => {
-  assertType<JSONTypes>([])
-})
-
-test('string array', () => {
-  assertType<JSONTypes>(['a'])
-})
-
-test('JSONObject', () => {
-  isType<JSONObject>({})
-})
-
-describe('JSONTypes.get', () => {
-  test('cast to T | undefined without props', () => {
-    const a = JSONTypes.get<string>('abc')
-    isType<string | undefined>(a)
-    expect(a).toBe('abc')
-  })
-  test('get object props', () => {
-    const a = JSONTypes.get<string>({ a: { b: 'abc' } }, 'a', 'b')
-    isType<string | undefined>(a)
-    expect(a).toBe('abc')
-  })
-
-  test('get array entry', () => {
-    const a = JSONTypes.get<string>(['abc'], 0)
-    isType<string | undefined>(a)
-    expect(a).toBe('abc')
-  })
-  test('nested', () => {
-    const a = JSONTypes.get<string>({ a: { b: [{ c: 'abc' }] } }, 'a', 'b', 0, 'c')
-    isType<string | undefined>(a)
-    expect(a).toBe('abc')
-  })
-})

package/ts/array/CommonPropKeys.spec.ts

@@ -1,20 +0,0 @@
-import { assertType, CommonPropKeys, Equal } from '..'
-
-test('no common key returns never', () => {
-  type S = [{ a: number }, { b: number }]
-  type A = CommonPropKeys<S>
-  assertType.isTrue(true as Equal<A, never>)
-})
-
-test('single common key', () => {
-  type S = [{ a: number, c: number }, { a: number, b: number }]
-  type A = CommonPropKeys<S>
-  assertType.isTrue(true as Equal<A, 'a'>)
-})
-
-test('multiple common keys', () => {
-  type S = [{ a: number, b: number }, { a: number, b: number }]
-
-  type A = CommonPropKeys<S>
-  assertType.isTrue(true as Equal<A, 'a' | 'b'>)
-})

package/ts/array/Concat.spec.ts

@@ -1,21 +0,0 @@
-import { Concat, Equal, isType } from '..'
-
-test('concat array', () => {
-  type A = Concat<string[], boolean[]>
-  isType.t<Equal<Array<string | boolean>, A>>()
-})
-
-test('concat tuples', () => {
-  type A = Concat<[1, 2, 3], [4, 5]>
-  isType.t<Equal<[1, 2, 3, 4, 5], A>>()
-})
-
-test('concat array to tuple', () => {
-  type A = Concat<string[], [1, 2, 3]>
-  isType.t<Equal<Array<string | 1 | 2 | 3>, A>>()
-})
-
-test('concat tuple to array', () => {
-  type A = Concat<[1, 2, 3], string[]>
-  isType.t<Equal<[1, 2, 3, ...string[]], A>>()
-})

package/ts/array/CreateTuple.spec.ts

@@ -1,46 +0,0 @@
-import { CreateTuple, isType } from '..'
-
-test('create empty tuple', () => {
-  isType.equal<true, [], CreateTuple<0>>()
-})
-
-test('single element', () => {
-  isType.equal<true, [any], CreateTuple<1>>()
-})
-
-test('multiple elements', () => {
-  type A = CreateTuple<3>
-  isType.equal<true, [any, any, any], A>()
-})
-
-test('override element type', () => {
-  type A = CreateTuple<5, 1>
-  isType.equal<true, [1, 1, 1, 1, 1], A>()
-})
-
-test('negative length gets never', () => {
-  isType.equal<true, never, CreateTuple<-1>>()
-})
-
-test('Can create tuple up to 7000', () => {
-  type A = CreateTuple<7000>['length']
-
-  isType.equal<true, 7000, A>()
-})
-
-test('L = number gets array', () => {
-  type A = CreateTuple<number, 1>
-  isType.equal<true, 1[], A>()
-})
-
-test('Non whole number gets never', () => {
-  type A = CreateTuple<1.2>
-
-  isType.equal<true, never, A>()
-})
-
-test('can specify fail type', () => {
-  type A = CreateTuple<1.2, 1, null>
-
-  isType.equal<true, null, A>()
-})

package/ts/array/DropFirst.spec.ts

@@ -1,21 +0,0 @@
-import { DropFirst, isType } from '..'
-
-test('drop from empty gets itself', () => {
-  isType.equal<true, string[], DropFirst<string[]>>()
-})
-
-test('drop first value type from tuple', () => {
-  type Actual = DropFirst<[true, 1, 'x', 3]>
-  isType.equal<true, [1, 'x', 3], Actual>()
-})
-
-test('drop only value gets never[]', () => {
-  type Actual = DropFirst<['x']>
-  isType.equal<true, never[], Actual>()
-})
-
-test('array type gets itself', () => {
-  const s: string[] = ['a', 'b', 'c']
-  type Actual = DropFirst<typeof s>
-  isType.equal<true, string[], Actual>()
-})

package/ts/array/DropLast.spec.ts

@@ -1,21 +0,0 @@
-import { DropLast, isType } from '..'
-
-test('drop from empty gets itself', () => {
-  isType.equal<true, string[], DropLast<string[]>>()
-})
-
-test('drop first value type from tuple', () => {
-  type Actual = DropLast<[true, 1, 'x', 3]>
-  isType.equal<true, [true, 1, 'x'], Actual>()
-})
-
-test('drop only value gets never[]', () => {
-  type Actual = DropLast<['x']>
-  isType.equal<true, never[], Actual>()
-})
-
-test('array type gets itself', () => {
-  const s: string[] = ['a', 'b', 'c']
-  type Actual = DropLast<typeof s>
-  isType.equal<true, string[], Actual>()
-})

package/ts/array/DropMatch.spec.ts

@@ -1,234 +0,0 @@
-import { drop, DropMatch, DropNull, DropNullable, DropUndefined, 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>()
-    })
-
-    test('drop all narrow types', () => {
-      type A = DropMatch<Array<1 | 2 | 3>, number>
-      isType.equal<true, never[], A>()
-
-      type B = DropMatch<Array<1 | 2 | 3 | string>, number>
-      isType.equal<true, string[], B>()
-    })
-
-
-    test('will not drop widen type', () => {
-      type A = DropMatch<Array<number>, 1>
-      isType.equal<true, number[], A>()
-
-      type B = DropMatch<Array<string | 'foo'>, 'foo'>
-      isType.equal<true, string[], B>()
-
-      // C is currently `string[] | string[]` (TypeScript 4.6.2)
-      // It does not collapse to `string[]`
-      // type C = DropMatch<Array<string | 'foo'>, 'foo' | 'boo'>
-      // Here `string[] | string[]` literal collapses to `string[]`
-      // commenting this out as it will likely be improved in future versions of TypeScript
-      // isType.equal<true, string[] | string[], C>()
-    })
-  })
-
-  describe('A is Tuple', () => {
-    test('empty tuple', () => {
-      type A = DropMatch<[], undefined>
-      isType.equal<true, [], A>()
-    })
-
-    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('drop undefined from readonly tuple', () => {
-      type A = DropMatch<readonly [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('drop undefined keep null', () => {
-      type A = DropMatch<[undefined | null], undefined>
-      isType.equal<true, [null], A>()
-    })
-
-    test('drop null keep undefined', () => {
-      type A = DropMatch<[undefined | null], null>
-      isType.equal<true, [undefined], A>()
-    })
-
-    test('drop both null and undefined', () => {
-      type A = DropMatch<[undefined | null], null | undefined>
-      isType.equal<true, [], A>()
-
-      type B = DropMatch<[undefined | null | string], null | undefined>
-      isType.equal<true, [string], B>()
-    })
-
-    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>()
-    })
-  })
-})
-
-describe('DropUndefined<A>', () => {
-  test('drop from array type', () => {
-    type A = DropUndefined<Array<string | undefined>>
-    isType.equal<true, string[], A>()
-
-    type B = DropUndefined<Array<string | number>>
-    isType.equal<true, Array<string | number>, B>()
-
-    type C = DropUndefined<Array<string | number | undefined | null>>
-    isType.equal<true, Array<string | number | null>, C>()
-  })
-
-  test('drop from tuple type', () => {
-    type A = DropUndefined<[string, undefined, number, null]>
-    isType.equal<true, [string, number, null], A>()
-  })
-})
-
-describe('DropNull<A>', () => {
-  test('drop from array type', () => {
-    type A = DropNull<Array<string | null>>
-    isType.equal<true, string[], A>()
-
-    type B = DropNull<Array<string | number>>
-    isType.equal<true, Array<string | number>, B>()
-
-    type C = DropNull<Array<string | number | undefined | null>>
-    isType.equal<true, Array<string | number | undefined>, C>()
-  })
-
-  test('drop from tuple type', () => {
-    type A = DropNull<[string, undefined, number, null]>
-    isType.equal<true, [string, undefined, number], A>()
-  })
-})
-
-describe('DropNullable<A>', () => {
-  test('drop from array type', () => {
-    type A = DropNullable<Array<string | null>>
-    isType.equal<true, string[], A>()
-
-    type B = DropNullable<Array<string | number>>
-    isType.equal<true, Array<string | number>, B>()
-
-    type C = DropNullable<Array<string | number | undefined | null>>
-    isType.equal<true, Array<string | number>, C>()
-  })
-
-  test('drop from tuple type', () => {
-    type A = DropNullable<[string, undefined, number, null]>
-    isType.equal<true, [string, number], A>()
-  })
-})
-
-
-describe('drop()', () => {
-  test('array', () => {
-    const a = drop([1, 'a', 3, 4], 'a')
-    expect(a).toEqual([1, 3, 4])
-    isType.equal<true, number[], typeof a>()
-  })
-  test('tuple', () => {
-    const a = drop([1, 2, 3, 4] as const, 1 as const)
-    expect(a).toEqual([2, 3, 4])
-    isType.equal<true, [2, 3, 4], typeof a>()
-  })
-
-  test('drop undefined from tuple', () => {
-    const a = drop([1, undefined, 3, undefined, 4] as const, undefined)
-    expect(a).toEqual([1, 3, 4])
-    isType.equal<true, [1, 3, 4], typeof a>()
-  })
-})