type-plus 5.5.2 → 6.0.0

package/ts/assertion/assertType.ts

@@ -8,86 +8,88 @@ import type { AnyFunction } from '../function/index.js'
  */
 export function assertType<T>(subject: T): asserts subject is T
 export function assertType<T>(subject: unknown, validator: (s: T) => boolean): asserts subject is T
-export function assertType<T extends new (...args: any) => any>(subject: unknown, constructor: T): asserts subject is InstanceType<T>
+export function assertType<T extends new (...args: any) => any>(
+	subject: unknown,
+	constructor: T
+): asserts subject is InstanceType<T>
 export function assertType(subject: unknown, validator?: (s: any) => boolean) {
-  if (validator) {
-    if ((isConstructor(validator) && !(subject instanceof validator)) || !validator(subject))
-      throw new TypeError(`subject fails to satisfy ${tersify(validator)}`)
-  }
-  return
+	if (validator) {
+		if ((isConstructor(validator) && !(subject instanceof validator)) || !validator(subject))
+			throw new TypeError(`subject fails to satisfy ${tersify(validator)}`)
+	}
+	return
 }
 
 assertType.isUndefined = function (subject: undefined): asserts subject is undefined {
-  if (typeof subject !== 'undefined') throw TypeError(`subject is not undefined`)
+	if (typeof subject !== 'undefined') throw TypeError(`subject is not undefined`)
 }
 assertType.noUndefined = function <S>(subject: Exclude<S, undefined>): void {
-  if (typeof subject === 'undefined') throw TypeError(`subject is undefined`)
+	if (typeof subject === 'undefined') throw TypeError(`subject is undefined`)
 }
 
 assertType.isNull = function (subject: null): asserts subject is null {
-  if (subject !== null) throw TypeError(`subject is not null`)
+	if (subject !== null) throw TypeError(`subject is not null`)
 }
 assertType.noNull = function <S>(subject: Exclude<S, null>): void {
-  if (subject === null) throw TypeError(`subject is null`)
+	if (subject === null) throw TypeError(`subject is null`)
 }
 
 assertType.isNumber = function (subject: number): asserts subject is number {
-  if (typeof subject !== 'number') throw TypeError(`subject is not number`)
+	if (typeof subject !== 'number') throw TypeError(`subject is not number`)
 }
 assertType.noNumber = function <S>(subject: Exclude<S, number>): void {
-  if (typeof subject === 'number') throw TypeError(`subject is number`)
+	if (typeof subject === 'number') throw TypeError(`subject is number`)
 }
 
 assertType.isBoolean = function (subject: boolean): asserts subject is boolean {
-  if (typeof subject !== 'boolean') throw TypeError(`subject is not boolean`)
+	if (typeof subject !== 'boolean') throw TypeError(`subject is not boolean`)
 }
 assertType.noBoolean = function <S>(subject: Exclude<S, boolean>): void {
-  if (typeof subject === 'boolean') throw TypeError(`subject is boolean`)
+	if (typeof subject === 'boolean') throw TypeError(`subject is boolean`)
 }
 
 assertType.isTrue = function (subject: true): asserts subject is true {
-  if (subject !== true) throw TypeError(`subject is not true`)
+	if (subject !== true) throw TypeError(`subject is not true`)
 }
 assertType.noTrue = function <S>(subject: Exclude<S, true>): void {
-  // @ts-ignore
-  if (subject === true) throw TypeError(`subject is true`)
+	// @ts-ignore
+	if (subject === true) throw TypeError(`subject is true`)
 }
 
 assertType.isFalse = function (subject: false): asserts subject is false {
-  if (subject !== false) throw TypeError(`subject is not false`)
+	if (subject !== false) throw TypeError(`subject is not false`)
 }
 assertType.noFalse = function <S>(subject: Exclude<S, false>): void {
-  // @ts-ignore
-  if (subject === false) throw TypeError(`subject is false`)
+	// @ts-ignore
+	if (subject === false) throw TypeError(`subject is false`)
 }
 
 assertType.isString = function (subject: string): asserts subject is string {
-  if (typeof subject !== 'string') throw TypeError(`subject is not string`)
+	if (typeof subject !== 'string') throw TypeError(`subject is not string`)
 }
 assertType.noString = function <S>(subject: Exclude<S, string>): void {
-  if (typeof subject === 'string') throw TypeError(`subject is string`)
+	if (typeof subject === 'string') throw TypeError(`subject is string`)
 }
 
 assertType.isFunction = function (subject: AnyFunction): asserts subject is AnyFunction {
-  if (typeof subject !== 'function') throw TypeError(`subject is not function`)
+	if (typeof subject !== 'function') throw TypeError(`subject is not function`)
 }
 assertType.noFunction = function <S>(subject: Exclude<S, AnyFunction>): void {
-  if (typeof subject === 'function') throw TypeError(`subject is function`)
+	if (typeof subject === 'function') throw TypeError(`subject is function`)
 }
 
 assertType.isConstructor = function (subject: AnyConstructor): asserts subject is AnyConstructor {
-  if (!isConstructor(subject)) throw TypeError(`subject is not a constructor`)
+	if (!isConstructor(subject)) throw TypeError(`subject is not a constructor`)
 }
 
 assertType.isError = function (subject: Error): asserts subject is Error {
-  if (!(subject instanceof Error)) throw TypeError(`subject is not an Error`)
+	if (!(subject instanceof Error)) throw TypeError(`subject is not an Error`)
 }
 assertType.noError = function <S>(subject: Exclude<S, Error>): void {
-  if (subject instanceof Error) throw TypeError(`subject is an Error`)
+	if (subject instanceof Error) throw TypeError(`subject is an Error`)
 }
 
-assertType.isNever = function (subject: never): asserts subject is never {
-}
+assertType.isNever = function (subject: never): asserts subject is never {}
 
 /**
  * creates a custom assertion function with standard TypeError.
@@ -95,13 +97,11 @@ assertType.isNever = function (subject: never): asserts subject is never {
  * thus making it hard to use:
  * https://github.com/microsoft/TypeScript/issues/41047
  */
-assertType.custom = function <T>(
-  validator: (s: T) => boolean
-): (subject: unknown) => asserts subject is T {
-  return function (subject) {
-    if (!validator(subject as any)) throw new TypeError(`subject fails to satisfy ${tersify(validator)}`)
-    return
-  }
+assertType.custom = function <T>(validator: (s: T) => boolean): (subject: unknown) => asserts subject is T {
+	return function (subject) {
+		if (!validator(subject as any)) throw new TypeError(`subject fails to satisfy ${tersify(validator)}`)
+		return
+	}
 }
 
 assertType.as = function <T>(subject: unknown): asserts subject is T {}

package/ts/assertion/index.ts

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

package/ts/binary/Bit.ts

@@ -1,6 +1,6 @@
 export type Bit = 0 | 1
 
 export type BitNot<X extends Bit> = X extends 0 ? 1 : 0
-export type BitAnd<A extends Bit, B extends Bit> = A extends 1 ? B extends 1 ? 1 : 0 : 0
+export type BitAnd<A extends Bit, B extends Bit> = A extends 1 ? (B extends 1 ? 1 : 0) : 0
 export type BitOr<A extends Bit, B extends Bit> = A extends 1 ? 1 : B extends 1 ? 1 : 0
 export type BitXor<A extends Bit, B extends Bit> = A extends 1 ? BitNot<B> : B

package/ts/class/isConstructor.ts

@@ -12,21 +12,23 @@ import type { AnyConstructor } from './AnyConstructor.js'
  * Thus this function is not safe to use.
  */
 export function isConstructor(subject: unknown): subject is AnyConstructor {
-  try {
-    new (subject as AnyConstructor)()
-  }
-  catch (err: any) {
-    const msg = err?.message as string | undefined
-    if (msg && msg.indexOf('is not a constructor') >= 0) {
-      return false
-    }
-  }
-  return true
+	try {
+		new (subject as AnyConstructor)()
+	} catch (err: any) {
+		const msg = err?.message as string | undefined
+		if (msg && msg.indexOf('is not a constructor') >= 0) {
+			return false
+		}
+	}
+	return true
 }
 
 /**
  * instanceof type guard for unknown value.
  */
-export function isInstanceof<T extends AnyConstructor>(subject: unknown, constructor: T): subject is InstanceType<T> {
-  return subject instanceof constructor
+export function isInstanceof<T extends AnyConstructor>(
+	subject: unknown,
+	constructor: T
+): subject is InstanceType<T> {
+	return subject instanceof constructor
 }

package/ts/function/AnyFunction.ts

@@ -1,3 +1 @@
-export type AnyFunction<
-  Params extends any[] = any[],
-  Result = any> = (...args: Params) => Result
+export type AnyFunction<Params extends any[] = any[], Result = any> = (...args: Params) => Result

package/ts/function/ExtractFunction.ts

@@ -7,7 +7,8 @@ import type { AnyFunction } from './AnyFunction.js'
  * @note does not work with function overloads.
  */
 export type ExtractFunction<T extends AnyFunction> = T extends AnyFunction<infer P, infer R>
-  ? (...args: P) => R : never
+	? (...args: P) => R
+	: never
 
 /**
  * Extract the function signature from a composite function.
@@ -15,5 +16,5 @@ export type ExtractFunction<T extends AnyFunction> = T extends AnyFunction<infer
  * @note does not work with function overloads.
  */
 export function extractFunction<T extends AnyFunction>(fn: T) {
-  return fn as any as ExtractFunction<T>
+	return fn as any as ExtractFunction<T>
 }

package/ts/functional/Maybe.ts

@@ -6,14 +6,17 @@ export type Maybe<T> = Just<T> | None<T>
 export type Just<T> = Brand<'maybe', T> & { unwrap(): T }
 export type None<T> = Brand<'maybe', void> & { unwrap(): T }
 
-export function just<T>(value: T):
-  Equal<T, undefined | null> extends true ?
-  None<T> :
-  Just<Widen<NonNullable<T>>> {
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-  return { unwrap() { return value } } as any
+export function just<T>(
+	value: T
+): Equal<T, undefined | null> extends true ? None<T> : Just<Widen<NonNullable<T>>> {
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-return
+	return {
+		unwrap() {
+			return value
+		}
+	} as any
 }
 
 export function none<T>(): None<T> {
-  return { unwrap() { } } as None<T>
+	return { unwrap() {} } as None<T>
 }

package/ts/functional/compose.ts

@@ -1,4 +1,4 @@
-import type { Head, Last } from '../array/index.js'
+import type { Head, Last } from '../array_plus/index.js'
 import type { AnyFunction } from '../function/AnyFunction.js'
 
 /**
@@ -8,7 +8,9 @@ import type { AnyFunction } from '../function/AnyFunction.js'
  * @return The composed function will expect the parameters of the first function,
  * and return the result of the last function.
  */
-export function compose<FS extends AnyFunction[]>(...fns: FS): (...args: Parameters<Head<FS>>) => ReturnType<Last<FS>> {
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-  return (...args: any[]) => fns.reduce((args, fn) => [fn(...args)], args)[0]
+export function compose<FS extends AnyFunction[]>(
+	...fns: FS
+): (...args: Parameters<Head<FS>>) => ReturnType<Last<FS>> {
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-return
+	return (...args: any[]) => fns.reduce((args, fn) => [fn(...args)], args)[0]
 }

package/ts/functional/context.ts

@@ -7,38 +7,31 @@ export type ContextBaseShape = Record<string | symbol, any>
  * @param context the current context.
  * @return an additional context with new properties.
  */
-export type ContextExtender<
-  Current,
-  Additional
-> = ((context: Current) => Additional)
+export type ContextExtender<Current, Additional> = (context: Current) => Additional
 
-export type ContextBuilder<
-  Init extends ContextBaseShape,
-  Ctx extends ContextBaseShape
-> = {
-  /**
-   * Extends the context using an extender.
-   *
-   * @type Additional The additional context to be added by the `extender`.
-   * By default this is inferred by the `extender`.
-   * But you can also explicitly specify it,
-   * if the type is a superset of the actual return type of the `extender`.
-   * @param extender function that add new props to the context.
-   *
-   * The extender only need to return a new object with additional properties.
-   * The builder will merge that with the current context.
-   *
-   * If the extender specify an existing property,
-   * it overrides the existing value.
-   */
-  extend<
-    Additional extends ContextBaseShape = ContextBaseShape
-  >(extender: ContextExtender<Ctx, Additional>)
-    : ContextBuilder<Init, LeftJoin<Ctx, Additional>>,
-  /**
-   * Build and return the context.
-   */
-  build(): Ctx
+export type ContextBuilder<Init extends ContextBaseShape, Ctx extends ContextBaseShape> = {
+	/**
+	 * Extends the context using an extender.
+	 *
+	 * @type Additional The additional context to be added by the `extender`.
+	 * By default this is inferred by the `extender`.
+	 * But you can also explicitly specify it,
+	 * if the type is a superset of the actual return type of the `extender`.
+	 * @param extender function that add new props to the context.
+	 *
+	 * The extender only need to return a new object with additional properties.
+	 * The builder will merge that with the current context.
+	 *
+	 * If the extender specify an existing property,
+	 * it overrides the existing value.
+	 */
+	extend<Additional extends ContextBaseShape = ContextBaseShape>(
+		extender: ContextExtender<Ctx, Additional>
+	): ContextBuilder<Init, LeftJoin<Ctx, Additional>>
+	/**
+	 * Build and return the context.
+	 */
+	build(): Ctx
 }
 
 /**
@@ -49,28 +42,25 @@ export type ContextBuilder<
  * use `extend()` to add context, and
  * use `build()` to build the context.
  */
-export function context<
-  Init extends ContextBaseShape,
-  Ctx extends ContextBaseShape = Init
->(init?: Init | (() => Init)): ContextBuilder<Init, Ctx> {
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-  return typeof init === 'function'
-    ? contextBuilder({}, [[init]])
-    : contextBuilder(init ?? {}, []) as any
+export function context<Init extends ContextBaseShape, Ctx extends ContextBaseShape = Init>(
+	init?: Init | (() => Init)
+): ContextBuilder<Init, Ctx> {
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-return
+	return typeof init === 'function' ? contextBuilder({}, [[init]]) : (contextBuilder(init ?? {}, []) as any)
 }
 
 /* eslint-disable */
 function contextBuilder(init: ContextBaseShape, extenders: Array<[ContextExtender<any, any> | any]>) {
-  return {
-    extend(extender: ContextExtender<any, any>) {
-      return contextBuilder(init, extenders.concat([[extender]]))
-    },
-    build() {
-      return extenders.reduce((p, [t], i) => {
-        const v = typeof t === 'function' ? extenders[i][0] = t(p) : t
-        return { ...p, ...v }
-      }, init)
-    }
-  }
+	return {
+		extend(extender: ContextExtender<any, any>) {
+			return contextBuilder(init, extenders.concat([[extender]]))
+		},
+		build() {
+			return extenders.reduce((p, [t], i) => {
+				const v = typeof t === 'function' ? (extenders[i][0] = t(p)) : t
+				return { ...p, ...v }
+			}, init)
+		}
+	}
 }
 /* eslint-enable */

package/ts/index.ts

@@ -1,22 +1,37 @@
 // import * as types from './types/index.js'
 export { required, requiredDeep, unpartial } from 'unpartial'
-export * from './array/index.js'
+export type { ComposableTypes, NonComposableTypes } from './ComposableTypes.js'
+export type { JSONArray, JSONObject, JSONPrimitive, JSONTypes } from './JSONTypes.js'
+export type { IsNever, PrimitiveTypes } from './PrimitiveTypes.js'
+// export * from './types/optional.js'
+// export * from './types/required.js'
+export type { UnionKeys } from './UnionKeys.js'
+export * as ArrayPlus from './array_plus/_plus.js'
+export * from './array_plus/index.js'
 export * from './assertion/index.js'
 export * from './class/index.js'
-export type { ComposableTypes, NonComposableTypes } from './ComposableTypes.js'
 export * from './function/index.js'
 export * from './functional/index.js'
-export type { JSONArray, JSONObject, JSONPrimitive, JSONTypes } from './JSONTypes.js'
-export type { Abs, Add, Decrement, Digit, DigitArray, GreaterThan, Increment, IsPositive, IsWhole, Max, Subtract } from './math/index.js'
+export type {
+	Abs,
+	Add,
+	Decrement,
+	Digit,
+	DigitArray,
+	GreaterThan,
+	Increment,
+	IsPositive,
+	IsWhole,
+	Max,
+	Subtract
+} from './math/index.js'
 export * from './nodejs/index.js'
 export * from './nominal-types/index.js'
+export * as NumberPlus from './number_plus/_plus.js'
+export * from './number_plus/index.js'
 export * from './object/index.js'
 export * from './predicates/index.js'
-export type { PrimitiveTypes, IsNever } from './PrimitiveTypes.js'
 export * from './promise/index.js'
 export * from './testing/index.js'
-// export * from './types/optional.js'
-// export * from './types/required.js'
-export type { UnionKeys } from './UnionKeys.js'
 export * from './utils/index.js'
 // export { types, types as T }

package/ts/math/Abs.ts

@@ -1,4 +1,7 @@
 import type { DigitArray } from './Digit.js'
 
-export type Abs<N extends number, Fail = never> = number extends N ? Fail :
-  `${N}` extends `-${infer P}` ? DigitArray.ToNumber<DigitArray.FromString<P>> : N
+export type Abs<N extends number, Fail = never> = number extends N
+	? Fail
+	: `${N}` extends `-${infer P}`
+	? DigitArray.ToNumber<DigitArray.FromString<P>>
+	: N

package/ts/math/Add.ts

@@ -1,4 +1,4 @@
-import type { PadLeft } from '../array/index.js'
+import type { PadLeft } from '../array_plus/index.js'
 import type { And } from '../predicates/index.js'
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 import type { Digit, DigitArray } from './Digit.js'
@@ -9,42 +9,49 @@ import type { Max } from './Max.js'
 /**
  * Add two number literals.
  */
-export type Add<A extends number, B extends number, Fail = never> =
-  And<
-    And<IsPositive<A>, IsWhole<A>>,
-    And<IsPositive<B>, IsWhole<B>>
-  > extends false ? Fail :
-  DigitArray.FromNumber<A> extends infer DA ? DA extends number[] ?
-  DigitArray.FromNumber<B> extends infer DB ? DB extends number[] ?
-  Max<DA['length'], DB['length']> extends infer M ? M extends number ?
-  PadLeft<DA, M, 0> extends infer PDA ? PDA extends number[] ?
-  PadLeft<DB, M, 0> extends infer PDB ? PDB extends number[] ?
-  DigitArray.ToNumber<Add.DigitArray<PDA, PDB>>
-  : Fail : Fail
-  : Fail : Fail
-  : Fail : Fail
-  : Fail : Fail
-  : Fail : Fail
+export type Add<A extends number, B extends number, Fail = never> = And<
+	And<IsPositive<A>, IsWhole<A>>,
+	And<IsPositive<B>, IsWhole<B>>
+> extends false
+	? Fail
+	: DigitArray.FromNumber<A> extends infer DA
+	? DA extends number[]
+		? DigitArray.FromNumber<B> extends infer DB
+			? DB extends number[]
+				? Max<DA['length'], DB['length']> extends infer M
+					? M extends number
+						? PadLeft<DA, M, 0> extends infer PDA
+							? PDA extends number[]
+								? PadLeft<DB, M, 0> extends infer PDB
+									? PDB extends number[]
+										? DigitArray.ToNumber<Add.DigitArray<PDA, PDB>>
+										: Fail
+									: Fail
+								: Fail
+							: Fail
+						: Fail
+					: Fail
+				: Fail
+			: Fail
+		: Fail
+	: Fail
 
 export namespace Add {
-  export type DigitArray<A extends number[], B extends number[]> = (
-    A extends [any, ...infer ATail]
-    ? (ATail extends number[]
-      ? (B extends [any, ...infer BTail]
-        ? (BTail extends number[]
-          ? [Digit<A[0], B[0]>, ...DigitArray<ATail, BTail>]
-          : [])
-        : [A[0], ...DigitArray<[], ATail>])
-      : [])
-    : (B extends [any, ...infer BTail]
-      ? (BTail extends number[]
-        ? [B[0], ...DigitArray<[], BTail>]
-        : [])
-      : [])
-  )
+	export type DigitArray<A extends number[], B extends number[]> = A extends [any, ...infer ATail]
+		? ATail extends number[]
+			? B extends [any, ...infer BTail]
+				? BTail extends number[]
+					? [Digit<A[0], B[0]>, ...DigitArray<ATail, BTail>]
+					: []
+				: [A[0], ...DigitArray<[], ATail>]
+			: []
+		: B extends [any, ...infer BTail]
+		? BTail extends number[]
+			? [B[0], ...DigitArray<[], BTail>]
+			: []
+		: []
 
-  export type Digit<A extends number, B extends number> =
-    [...Digit.ToTuple[A], ...Digit.ToTuple[B]]['length']
+	export type Digit<A extends number, B extends number> = [...Digit.ToTuple[A], ...Digit.ToTuple[B]]['length']
 }
 /**
  * Increment `A` by 1.