type-plus 4.9.1 → 4.10.2

package/ts/object/pick.ts

@@ -1,35 +1,35 @@
-import { UnionKeys } from '../UnionKeys'
-import { AnyRecord } from './AnyRecord'
-import { reduceByKey } from './reduceKey'
-
-export function pick<T extends AnyRecord, P1 extends UnionKeys<T>>(subject: T, prop1: P1): Pick<T, P1>
-export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2): Pick<T, P1 | P2>
-export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3): Pick<T, P1 | P2 | P3>
-export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4): Pick<T, P1 | P2 | P3 | P4>
-export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5): Pick<T, P1 | P2 | P3 | P4 | P5>
-export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6): Pick<T, P1 | P2 | P3 | P4 | P5 | P6>
-export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7>
-export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8>
-export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9>
-export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<T>, P10 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9, prop10: P10): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10>
-export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<T>, P10 extends UnionKeys<T>, P11 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9, prop10: P10, prop11: P11): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10 | P11>
-export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<T>, P10 extends UnionKeys<T>, P11 extends UnionKeys<T>, P12 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9, prop10: P10, prop11: P11, prop12: P12): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10 | P11 | P12>
-export function pick<T extends AnyRecord>(subject: T, ...props: Array<UnionKeys<T>>) {
-  return reduceByKey(subject, (p, k) => {
-    if (props.indexOf(k) >= 0) p[k] = subject[k]
-    return p
-  }, {} as T)
-}
-
-/**
- * Pick properties `K` from `T`.
- * Works with union.
- *
- * Original type by Titian Cernicova-Dragomir
- * @see <https://github.com/microsoft/TypeScript/issues/28339#issuecomment-463577347>
- */
-export type Pick<T, K extends UnionKeys<T>> = T extends unknown ? Pick._<T, keyof T & K> : never
-
-export namespace Pick {
-  export type _<T, K extends keyof T> = { [P in K]: T[P] }
-}
+import { UnionKeys } from '../UnionKeys.js'
+import type { AnyRecord } from './AnyRecord.js'
+import { reduceByKey } from './reduceKey.js'
+
+export function pick<T extends AnyRecord, P1 extends UnionKeys<T>>(subject: T, prop1: P1): Pick<T, P1>
+export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2): Pick<T, P1 | P2>
+export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3): Pick<T, P1 | P2 | P3>
+export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4): Pick<T, P1 | P2 | P3 | P4>
+export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5): Pick<T, P1 | P2 | P3 | P4 | P5>
+export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6): Pick<T, P1 | P2 | P3 | P4 | P5 | P6>
+export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7>
+export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8>
+export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9>
+export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<T>, P10 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9, prop10: P10): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10>
+export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<T>, P10 extends UnionKeys<T>, P11 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9, prop10: P10, prop11: P11): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10 | P11>
+export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<T>, P10 extends UnionKeys<T>, P11 extends UnionKeys<T>, P12 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9, prop10: P10, prop11: P11, prop12: P12): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10 | P11 | P12>
+export function pick<T extends AnyRecord>(subject: T, ...props: Array<UnionKeys<T>>) {
+  return reduceByKey(subject, (p, k) => {
+    if (props.indexOf(k) >= 0) p[k] = subject[k]
+    return p
+  }, {} as T)
+}
+
+/**
+ * Pick properties `K` from `T`.
+ * Works with union.
+ *
+ * Original type by Titian Cernicova-Dragomir
+ * @see <https://github.com/microsoft/TypeScript/issues/28339#issuecomment-463577347>
+ */
+export type Pick<T, K extends UnionKeys<T>> = T extends unknown ? Pick._<T, keyof T & K> : never
+
+export namespace Pick {
+  export type _<T, K extends keyof T> = { [P in K]: T[P] }
+}

package/ts/object/record.ts

@@ -1,6 +1,6 @@
-import { KeyTypes } from 'type-plus'
-import { Widen } from '../utils'
-import { AnyRecord } from './AnyRecord'
+import { Widen } from '../utils/index.js'
+import type { AnyRecord } from './AnyRecord.js'
+import { KeyTypes } from './KeyTypes.js'
 
 /**
  * Creates a `Record<Key, Value>`

package/ts/object/reduceKey.ts

@@ -1,4 +1,4 @@
-import { KeyTypes } from './KeyTypes'
+import type { KeyTypes } from './KeyTypes.js'
 
 export function reduceByKey<S extends Record<KeyTypes, any>, T>(
   subject: S,

package/ts/object/replaceProperty.ts

@@ -1,4 +1,4 @@
-import { AnyRecord } from './AnyRecord'
+import type { AnyRecord } from './AnyRecord.js'
 
 export type ReplaceProperty<
   T extends AnyRecord,

package/ts/object/someKey.ts

@@ -1,4 +1,4 @@
-import { KeyTypes } from './KeyTypes'
+import type { KeyTypes } from './KeyTypes.js'
 
 export function someKey<S extends Record<KeyTypes, any>, T = any>(
   subject: S,

package/ts/object/split.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-import { AnyRecord } from './AnyRecord'
-import { Omit } from './omit'
-import { reduceByKey } from './reduceKey'
+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> = {

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>()
-})