type-plus 5.5.2 → 6.0.0

package/ts/object/split.ts

@@ -5,199 +5,197 @@ 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> = {
-  [k in keyof S]-?: S[k] extends undefined ? T[k] : NonNullable<T[k]> | S[k]
+	[k in keyof S]-?: S[k] extends undefined ? T[k] : NonNullable<T[k]> | S[k]
 }
 
 /**
  * Split an object into multiple objects.
  * @returns [...entries, remaining]
  */
+export function split<T extends AnyRecord, S1 extends Splitter<T>>(
+	target: T,
+	split1: S1
+): [Split<T, S1>, Omit<T, keyof S1>]
+export function split<T extends AnyRecord, S1 extends Splitter<T>, S2 extends Splitter<T>>(
+	target: T,
+	split1: S1,
+	split2: S2
+): [Split<T, S1>, Split<T, S2>, Omit<T, keyof S1 | keyof S2>]
 export function split<
-  T extends AnyRecord,
-  S1 extends Splitter<T>
->(target: T, split1: S1): [
-    Split<T, S1>,
-    Omit<T, keyof S1>
-  ]
+	T extends AnyRecord,
+	S1 extends Splitter<T>,
+	S2 extends Splitter<T>,
+	S3 extends Splitter<T>
+>(
+	target: T,
+	splitter1: S1,
+	splitter2: S2,
+	splitter3: S3
+): [Split<T, S1>, Split<T, S2>, Split<T, S3>, Omit<T, keyof S1 | keyof S2 | keyof S3>]
 export function split<
-  T extends AnyRecord,
-  S1 extends Splitter<T>,
-  S2 extends Splitter<T>,
-  >(target: T, split1: S1, split2: S2): [
-    Split<T, S1>,
-    Split<T, S2>,
-    Omit<T, keyof S1 | keyof S2>
-  ]
-export function split<
-  T extends AnyRecord,
-  S1 extends Splitter<T>,
-  S2 extends Splitter<T>,
-  S3 extends Splitter<T>,
-  >(target: T, splitter1: S1, splitter2: S2, splitter3: S3): [
-    Split<T, S1>,
-    Split<T, S2>,
-    Split<T, S3>,
-    Omit<T, keyof S1 | keyof S2 | keyof S3>
-  ]
-export function split<
-  T extends AnyRecord,
-  S1 extends Splitter<T>,
-  S2 extends Splitter<T>,
-  S3 extends Splitter<T>,
-  S4 extends Splitter<T>,
-  >(target: T,
-    splitter1: S1,
-    splitter2: S2,
-    splitter3: S3,
-    splitter4: S4,
+	T extends AnyRecord,
+	S1 extends Splitter<T>,
+	S2 extends Splitter<T>,
+	S3 extends Splitter<T>,
+	S4 extends Splitter<T>
+>(
+	target: T,
+	splitter1: S1,
+	splitter2: S2,
+	splitter3: S3,
+	splitter4: S4
 ): [
-    Split<T, S1>,
-    Split<T, S2>,
-    Split<T, S3>,
-    Split<T, S4>,
-    Omit<T, keyof S1 | keyof S2 | keyof S3 | keyof S4>
-  ]
+	Split<T, S1>,
+	Split<T, S2>,
+	Split<T, S3>,
+	Split<T, S4>,
+	Omit<T, keyof S1 | keyof S2 | keyof S3 | keyof S4>
+]
 export function split<
-  T extends AnyRecord,
-  S1 extends Splitter<T>,
-  S2 extends Splitter<T>,
-  S3 extends Splitter<T>,
-  S4 extends Splitter<T>,
-  S5 extends Splitter<T>,
-  >(target: T,
-    splitter1: S1,
-    splitter2: S2,
-    splitter3: S3,
-    splitter4: S4,
-    splitter5: S5,
+	T extends AnyRecord,
+	S1 extends Splitter<T>,
+	S2 extends Splitter<T>,
+	S3 extends Splitter<T>,
+	S4 extends Splitter<T>,
+	S5 extends Splitter<T>
+>(
+	target: T,
+	splitter1: S1,
+	splitter2: S2,
+	splitter3: S3,
+	splitter4: S4,
+	splitter5: S5
 ): [
-    Split<T, S1>,
-    Split<T, S2>,
-    Split<T, S3>,
-    Split<T, S4>,
-    Split<T, S5>,
-    Omit<T, keyof S1 | keyof S2 | keyof S3 | keyof S4 | keyof S5>
-  ]
+	Split<T, S1>,
+	Split<T, S2>,
+	Split<T, S3>,
+	Split<T, S4>,
+	Split<T, S5>,
+	Omit<T, keyof S1 | keyof S2 | keyof S3 | keyof S4 | keyof S5>
+]
 export function split<
-  T extends AnyRecord,
-  S1 extends Splitter<T>,
-  S2 extends Splitter<T>,
-  S3 extends Splitter<T>,
-  S4 extends Splitter<T>,
-  S5 extends Splitter<T>,
-  S6 extends Splitter<T>,
-  >(target: T,
-    splitter1: S1,
-    splitter2: S2,
-    splitter3: S3,
-    splitter4: S4,
-    splitter5: S5,
-    splitter6: S6,
+	T extends AnyRecord,
+	S1 extends Splitter<T>,
+	S2 extends Splitter<T>,
+	S3 extends Splitter<T>,
+	S4 extends Splitter<T>,
+	S5 extends Splitter<T>,
+	S6 extends Splitter<T>
+>(
+	target: T,
+	splitter1: S1,
+	splitter2: S2,
+	splitter3: S3,
+	splitter4: S4,
+	splitter5: S5,
+	splitter6: S6
 ): [
-    Split<T, S1>,
-    Split<T, S2>,
-    Split<T, S3>,
-    Split<T, S4>,
-    Split<T, S5>,
-    Split<T, S6>,
-    Omit<T, keyof S1 | keyof S2 | keyof S3 | keyof S4 | keyof S5 | keyof S6>
-  ]
+	Split<T, S1>,
+	Split<T, S2>,
+	Split<T, S3>,
+	Split<T, S4>,
+	Split<T, S5>,
+	Split<T, S6>,
+	Omit<T, keyof S1 | keyof S2 | keyof S3 | keyof S4 | keyof S5 | keyof S6>
+]
 export function split<
-  T extends AnyRecord,
-  S1 extends Splitter<T>,
-  S2 extends Splitter<T>,
-  S3 extends Splitter<T>,
-  S4 extends Splitter<T>,
-  S5 extends Splitter<T>,
-  S6 extends Splitter<T>,
-  S7 extends Splitter<T>,
-  >(target: T,
-    splitter1: S1,
-    splitter2: S2,
-    splitter3: S3,
-    splitter4: S4,
-    splitter5: S5,
-    splitter6: S6,
-    splitter7: S7,
+	T extends AnyRecord,
+	S1 extends Splitter<T>,
+	S2 extends Splitter<T>,
+	S3 extends Splitter<T>,
+	S4 extends Splitter<T>,
+	S5 extends Splitter<T>,
+	S6 extends Splitter<T>,
+	S7 extends Splitter<T>
+>(
+	target: T,
+	splitter1: S1,
+	splitter2: S2,
+	splitter3: S3,
+	splitter4: S4,
+	splitter5: S5,
+	splitter6: S6,
+	splitter7: S7
 ): [
-    Split<T, S1>,
-    Split<T, S2>,
-    Split<T, S3>,
-    Split<T, S4>,
-    Split<T, S5>,
-    Split<T, S6>,
-    Split<T, S7>,
-    Omit<T, keyof S1 | keyof S2 | keyof S3 | keyof S4 | keyof S5 | keyof S6 | keyof S7>
-  ]
+	Split<T, S1>,
+	Split<T, S2>,
+	Split<T, S3>,
+	Split<T, S4>,
+	Split<T, S5>,
+	Split<T, S6>,
+	Split<T, S7>,
+	Omit<T, keyof S1 | keyof S2 | keyof S3 | keyof S4 | keyof S5 | keyof S6 | keyof S7>
+]
 export function split<
-  T extends AnyRecord,
-  S1 extends Splitter<T>,
-  S2 extends Splitter<T>,
-  S3 extends Splitter<T>,
-  S4 extends Splitter<T>,
-  S5 extends Splitter<T>,
-  S6 extends Splitter<T>,
-  S7 extends Splitter<T>,
-  S8 extends Splitter<T>,
-  >(target: T,
-    splitter1: S1,
-    splitter2: S2,
-    splitter3: S3,
-    splitter4: S4,
-    splitter5: S5,
-    splitter6: S6,
-    splitter7: S7,
-    splitter8: S8,
+	T extends AnyRecord,
+	S1 extends Splitter<T>,
+	S2 extends Splitter<T>,
+	S3 extends Splitter<T>,
+	S4 extends Splitter<T>,
+	S5 extends Splitter<T>,
+	S6 extends Splitter<T>,
+	S7 extends Splitter<T>,
+	S8 extends Splitter<T>
+>(
+	target: T,
+	splitter1: S1,
+	splitter2: S2,
+	splitter3: S3,
+	splitter4: S4,
+	splitter5: S5,
+	splitter6: S6,
+	splitter7: S7,
+	splitter8: S8
 ): [
-    Split<T, S1>,
-    Split<T, S2>,
-    Split<T, S3>,
-    Split<T, S4>,
-    Split<T, S5>,
-    Split<T, S6>,
-    Split<T, S7>,
-    Split<T, S8>,
-    Omit<T, keyof S1 | keyof S2 | keyof S3 | keyof S4 | keyof S5 | keyof S6 | keyof S7 | keyof S8>
-  ]
+	Split<T, S1>,
+	Split<T, S2>,
+	Split<T, S3>,
+	Split<T, S4>,
+	Split<T, S5>,
+	Split<T, S6>,
+	Split<T, S7>,
+	Split<T, S8>,
+	Omit<T, keyof S1 | keyof S2 | keyof S3 | keyof S4 | keyof S5 | keyof S6 | keyof S7 | keyof S8>
+]
 export function split<
-  T extends AnyRecord,
-  S1 extends Splitter<T>,
-  S2 extends Splitter<T>,
-  S3 extends Splitter<T>,
-  S4 extends Splitter<T>,
-  S5 extends Splitter<T>,
-  S6 extends Splitter<T>,
-  S7 extends Splitter<T>,
-  S8 extends Splitter<T>,
-  S9 extends Splitter<T>,
-  >(target: T,
-    splitter1: S1,
-    splitter2: S2,
-    splitter3: S3,
-    splitter4: S4,
-    splitter5: S5,
-    splitter6: S6,
-    splitter7: S7,
-    splitter8: S8,
-    splitter9: S9,
+	T extends AnyRecord,
+	S1 extends Splitter<T>,
+	S2 extends Splitter<T>,
+	S3 extends Splitter<T>,
+	S4 extends Splitter<T>,
+	S5 extends Splitter<T>,
+	S6 extends Splitter<T>,
+	S7 extends Splitter<T>,
+	S8 extends Splitter<T>,
+	S9 extends Splitter<T>
+>(
+	target: T,
+	splitter1: S1,
+	splitter2: S2,
+	splitter3: S3,
+	splitter4: S4,
+	splitter5: S5,
+	splitter6: S6,
+	splitter7: S7,
+	splitter8: S8,
+	splitter9: S9
 ): [
-    Split<T, S1>,
-    Split<T, S2>,
-    Split<T, S3>,
-    Split<T, S4>,
-    Split<T, S5>,
-    Split<T, S6>,
-    Split<T, S7>,
-    Split<T, S8>,
-    Split<T, S9>,
-    Omit<T, keyof S1 | keyof S2 | keyof S3 | keyof S4 | keyof S5 | keyof S6 | keyof S7 | keyof S8 | keyof S9>
-  ]
+	Split<T, S1>,
+	Split<T, S2>,
+	Split<T, S3>,
+	Split<T, S4>,
+	Split<T, S5>,
+	Split<T, S6>,
+	Split<T, S7>,
+	Split<T, S8>,
+	Split<T, S9>,
+	Omit<T, keyof S1 | keyof S2 | keyof S3 | keyof S4 | keyof S5 | keyof S6 | keyof S7 | keyof S8 | keyof S9>
+]
 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),
-    {} as AnyRecord))
-  const r = reduceByKey(target, (p, k) => keyMap[k] ? p : (p[k] = target[k], p), {} as AnyRecord)
-  return [...s, r]
+	const keyMap: AnyRecord = {}
+	const s = splitters.map(s =>
+		reduceByKey(s, (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 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,
-    }
-  }
+	return function <B extends AnyRecord>(source: B, override: ANotB<A, B>): A {
+		return {
+			...source,
+			...override
+		}
+	}
 }

package/ts/predicates/CanAssign.ts

@@ -4,18 +4,22 @@ import type { IsEmptyObject } from './IsEmptyObject.js'
 /**
  * Can `A` assign to `B`
  */
-export type CanAssign<A, B, Then = true, Else = false> =
-  IsEmptyObject<A> extends true
-  ? Record<string, unknown> extends B ? Then : Else
-  : boolean extends A
-  ? (boolean extends B ? Then : Else)
-  : A extends B ? Then : Else
-
+export type CanAssign<A, B, Then = true, Else = false> = IsEmptyObject<A> extends true
+	? Record<string, unknown> extends B
+		? Then
+		: Else
+	: boolean extends A
+	? boolean extends B
+		? Then
+		: Else
+	: A extends B
+	? Then
+	: Else
 
 export type IsAssign<A, B, Then = true, Else = false> = CanAssign<A, B, Then, Else>
 
 export function canAssign<T>(canAssign: false): <S>(subject: NotExtendable<S, T>) => true
 export function canAssign<T>(): <S extends T>(subject: S) => CanAssign<S, T>
 export function canAssign<T>(): <S extends T>(subject: S) => any {
-  return () => true
+	return () => true
 }

package/ts/predicates/Equal.ts

@@ -5,10 +5,8 @@ import type { And, Or } from './logical.js'
  * Checks if the two types are equal.
  */
 export type Equal<A, B, Then = true, Else = false> = [A, B] extends [B, A]
-  ? And<IsAny<A>, IsAny<B>,
-    Then,
-    Or<IsAny<A>, IsAny<B>, Else, Then>>
-  : Else
+	? And<IsAny<A>, IsAny<B>, Then, Or<IsAny<A>, IsAny<B>, Else, Then>>
+	: Else
 
 /**
  * Checks if the two types are equal.

package/ts/predicates/Extends.ts

@@ -1,4 +1,4 @@
-export type Extendable<A, B> = A extends B ? A : never
-export type NotExtendable<A, B> = A extends B ? never : A
-export type IsExtend<A, B, Then = true, Else = false> = A extends B ? Then : Else
-export type IsNotExtend<A, B, Then = true, Else = false> = A extends B ? Else : Then
+export type Extendable<A, B> = A extends B ? A : never
+export type NotExtendable<A, B> = A extends B ? never : A
+export type IsExtend<A, B, Then = true, Else = false> = A extends B ? Then : Else
+export type IsNotExtend<A, B, Then = true, Else = false> = A extends B ? Else : Then

package/ts/predicates/If.ts

@@ -1,5 +1 @@
-export type If<
-  Condition extends boolean,
-  Then = true,
-  Else = false
-  > = Condition extends true ? Then : Else
+export type If<Condition extends boolean, Then = true, Else = false> = Condition extends true ? Then : Else

package/ts/predicates/IsEmptyObject.ts

@@ -1,2 +1,2 @@
-/* eslint-disable @typescript-eslint/ban-types */
-export type IsEmptyObject<T> = T extends {} ? {} extends T ? true : false : false
+/* eslint-disable @typescript-eslint/ban-types */
+export type IsEmptyObject<T> = T extends {} ? ({} extends T ? true : false) : false

package/ts/predicates/index.ts

@@ -7,8 +7,10 @@ export type { IsEmptyObject } from './IsEmptyObject.js'
 export * from './isType.js'
 export type { And, Not, Or, Xor } from './logical.js'
 
-export type IsLiteral<T extends number | string, Then = true, Else = false> = number extends T ?
-  Else :
-  string extends T ? Else : Then
+export type IsLiteral<T extends number | string, Then = true, Else = false> = number extends T
+	? Else
+	: string extends T
+	? Else
+	: Then
 
 export type IsBoolean<T, Then = true, Else = false> = boolean extends T ? Then : Else

package/ts/predicates/isType.ts

@@ -9,20 +9,34 @@ export function isType<T>(subject: T): subject is T
  */
 export function isType<T>(subject: unknown, validator: (s: T) => unknown): subject is T
 export function isType(subject: unknown, validator?: (s: unknown) => unknown) {
-  return validator ? !!validator(subject) : true
+	return validator ? !!validator(subject) : true
 }
 
 isType.t = function <T extends true>(subject?: T) {
-  return subject === undefined || subject === true
+	return subject === undefined || subject === true
 }
 isType.f = function <T extends false>(subject?: T) {
-  return subject === undefined || subject === false
+	return subject === undefined || subject === false
 }
 
+/**
+ * Check is the type `never`
+ */
+function isNever<S extends never>(): unknown
+/**
+ * Check is the value is type `never`
+ */
+function isNever(subject: never): subject is never
+function isNever(subject?: unknown): subject is never {
+	return true
+}
+
+isType.never = isNever
+
 /**
  * Are types A and B equals/not equals.
  * Easier to use than `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>() { }
+isType.equal = function <C extends Equal<A, B>, A, B>() {}

package/ts/predicates/logical.ts

@@ -1,26 +1,19 @@
-export type And<
-  A extends boolean,
-  B extends boolean,
-  Then = true,
-  Else = false
-> = A extends true ? B extends true ? Then : Else : Else
+export type And<A extends boolean, B extends boolean, Then = true, Else = false> = A extends true
+	? B extends true
+		? Then
+		: Else
+	: Else
 
-export type Or<
-  A extends boolean,
-  B extends boolean,
-  Then = true,
-  Else = false
-> = A extends true ? Then : B extends true ? Then : Else
+export type Or<A extends boolean, B extends boolean, Then = true, Else = false> = A extends true
+	? Then
+	: B extends true
+	? Then
+	: Else
 
-export type Not<
-  X extends boolean,
-  Then = true,
-  Else = false
-> = X extends true ? Else : Then
+export type Not<X extends boolean, Then = true, Else = false> = X extends true ? Else : Then
 
-export type Xor<
-  A extends boolean,
-  B extends boolean,
-  Then = true,
-  Else = false
-> = A extends Then ? Not<B> : B extends true ? Then : Else
+export type Xor<A extends boolean, B extends boolean, Then = true, Else = false> = A extends Then
+	? Not<B>
+	: B extends true
+	? Then
+	: Else

package/ts/promise/MaybePromise.ts

@@ -18,11 +18,14 @@ export function transformMaybePromise<T, R>(value: Promise<T>, transformer: (val
  * @return the transformed result,
  * or if the value is a promise, a new promse with the transformed result.
  */
-export function transformMaybePromise<T, R>(value: T, transformer: (value: T) => R): T extends Promise<any> ? Promise<R> : R
+export function transformMaybePromise<T, R>(
+	value: T,
+	transformer: (value: T) => R
+): T extends Promise<any> ? Promise<R> : R
 export function transformMaybePromise<T, R>(value: MaybePromise<T>, transformer: (value: T) => R) {
-  return isPromise(value) ? value.then(transformer) : transformer(value)
+	return isPromise(value) ? value.then(transformer) : transformer(value)
 }
 
 export const MaybePromise = {
-  transform: transformMaybePromise
+	transform: transformMaybePromise
 }

package/ts/promise/PromiseValue.ts

@@ -9,4 +9,6 @@ export type PromiseValue<P extends Promise<any>> = P extends Promise<infer T> ?
 /**
  * Await on specific props V on type T
  */
-export type AwaitedProp<T extends AnyRecord, K extends keyof T> = { [k in keyof T]: k extends K ? Awaited<T[k]> : T[k] }
+export type AwaitedProp<T extends AnyRecord, K extends keyof T> = {
+	[k in keyof T]: k extends K ? Awaited<T[k]> : T[k]
+}

package/ts/promise/PromiseValueMerge.ts

@@ -4,23 +4,23 @@ import type { PromiseValue } from './PromiseValue.js'
  * Merging value types from multiple promises.
  */
 export type PromiseValueMerge<
-  P1 extends Promise<any>,
-  P2 extends Promise<any>,
-  P3 extends Promise<any> = any,
-  P4 extends Promise<any> = any,
-  P5 extends Promise<any> = any,
-  P6 extends Promise<any> = any,
-  P7 extends Promise<any> = any,
-  P8 extends Promise<any> = any,
-  P9 extends Promise<any> = any
-  > = Promise<
-    PromiseValue<P1> &
-    PromiseValue<P2> &
-    PromiseValue<P3> &
-    PromiseValue<P4> &
-    PromiseValue<P5> &
-    PromiseValue<P6> &
-    PromiseValue<P7> &
-    PromiseValue<P8> &
-    PromiseValue<P9>
-  >
+	P1 extends Promise<any>,
+	P2 extends Promise<any>,
+	P3 extends Promise<any> = any,
+	P4 extends Promise<any> = any,
+	P5 extends Promise<any> = any,
+	P6 extends Promise<any> = any,
+	P7 extends Promise<any> = any,
+	P8 extends Promise<any> = any,
+	P9 extends Promise<any> = any
+> = Promise<
+	PromiseValue<P1> &
+		PromiseValue<P2> &
+		PromiseValue<P3> &
+		PromiseValue<P4> &
+		PromiseValue<P5> &
+		PromiseValue<P6> &
+		PromiseValue<P7> &
+		PromiseValue<P8> &
+		PromiseValue<P9>
+>

package/ts/promise/isPromise.ts

@@ -1,4 +1,4 @@
-export function isPromise<R = any>(subject: unknown): subject is Promise<R> {
-  // @ts-ignore
-  return !!subject && typeof subject['then'] === 'function'
-}
+export function isPromise<R = any>(subject: unknown): subject is Promise<R> {
+	// @ts-ignore
+	return !!subject && typeof subject['then'] === 'function'
+}

package/ts/promise/mapSeries.ts

@@ -1,5 +1,3 @@
-export function mapSeries<R, T = any>(values: T[], fn: (value: T) => Promise<R>): Promise<R[]> {
-  return values.reduce(
-    (p, v) => p.then(r => fn(v).then(v => (r.push(v), r))),
-    Promise.resolve<R[]>([]))
-}
+export function mapSeries<R, T = any>(values: T[], fn: (value: T) => Promise<R>): Promise<R[]> {
+	return values.reduce((p, v) => p.then(r => fn(v).then(v => (r.push(v), r))), Promise.resolve<R[]>([]))
+}