type-plus 7.6.2 → 8.0.0-beta.2

package/ts/testing/stub.ts

@@ -1,80 +0,0 @@
-import { requiredDeep } from 'unpartial'
-import type { AnyFunction } from '../function/any_function.js'
-import type { RecursivePartial } from '../object/recursive_partial.js'
-import type { NoInfer } from '../type/no_infer.js'
-
-/**
- * stub a value.
- *
- * If the value is a function, it will be passed through as-is.
- *
- * 🦴 `utilities`
- */
-export function stub<T extends AnyFunction>(stub: T): T
-export function stub<T>(stub: RecursivePartial<NoInfer<T>>): T
-export function stub<T>(stub: unknown): T {
-	return stub as T
-}
-
-/**
- * builds a stub function
- */
-function build<T>(
-	init: RecursivePartial<T> | ((stub?: RecursivePartial<T>) => RecursivePartial<T>)
-): (stub?: RecursivePartial<T>) => T
-function build<T>(init: RecursivePartial<T> | ((stub?: RecursivePartial<T>) => RecursivePartial<T>)) {
-	return builder(init).create()
-}
-
-/**
- * Create a builder for a stub function of type T.
- *
- * The builder contains two methods:
- *
- * `.with()`: adds additional handler or partial stub.
- * `.create()`: creates the final stub function.
- *
- * @example
- * ```ts
- * const b = stub.builder<{ a: number; b: string }>({ a: 1 }).with({ b: 'b' }).create()
- * b({ a: 2 }) // { a: 2, b: 'b' }
- * ```
- */
-function builder<T>(init: RecursivePartial<T> | ((stub?: RecursivePartial<T>) => RecursivePartial<T>)) {
-	return builderInternal([init])
-}
-
-function builderInternal<T>(
-	initializers: Array<RecursivePartial<T> | ((stub?: RecursivePartial<T>) => RecursivePartial<T>)>
-) {
-	const builder = {
-		/**
-		 * Adds an init object or handler to the builder.
-		 *
-		 * If `init` is an object, it will be merged with the stub object.
-		 * If `init` is a function, it will be called with the stub object.
-		 *
-		 * @return {Builder<T>} The builder instance.
-		 */
-		with(init: RecursivePartial<T> | ((stub?: RecursivePartial<T>) => RecursivePartial<T>)) {
-			return builderInternal([...initializers, init])
-		},
-		/**
-		 * Creates the resulting stub function.
-		 */
-
-		create() {
-			return (stub?: RecursivePartial<T>) => {
-				return initializers.reduce((acc, init) => {
-					if (typeof init === 'function') {
-						return init(acc)
-					}
-					return requiredDeep<RecursivePartial<T>>(init, acc)
-				}, stub) as T
-			}
-		}
-	}
-	return builder
-}
-stub.build = build
-stub.builder = builder

package/ts/testing/test_type.ts

@@ -1,317 +0,0 @@
-import type { IsAny } from '../any/any_type.js'
-import type { IsArray } from '../array/array_type.js'
-import type { IsBigint } from '../bigint/bigint_type.js'
-import type { IsStrictBigint } from '../bigint/strict_bigint_type.js'
-import type { IsBoolean } from '../boolean/boolean_type.js'
-import type { IsFalse } from '../boolean/false_type.js'
-import type { IsStrictBoolean } from '../boolean/strict_boolean_type.js'
-import type { IsTrue } from '../boolean/true_type.js'
-import type { IsEqual } from '../equal/equal.js'
-import type { IsFunction } from '../function/function_type.js'
-import type { IsStrictFunction } from '../function/strict_function_type.js'
-import type { IsNever } from '../never/never_type.js'
-import type { IsNull } from '../null/null_type.js'
-import type { IsNumber } from '../number/number_type.js'
-import type { IsStrictNumber } from '../number/strict_number_type.js'
-import type { IsObject } from '../object/object_type.js'
-import type { CanAssign, StrictCanAssign } from '../predicates/CanAssign.js'
-import type { IsStrictString } from '../string/strict_string_type.js'
-import type { IsString } from '../string/string_type.js'
-import type { IsSymbol } from '../symbol/symbol_type.js'
-import type { IsTuple } from '../tuple/tuple_type.js'
-import type { IsUndefined } from '../undefined/undefined_type.js'
-import type { IsUnknown } from '../unknown/unknown_type.js'
-import type { IsVoid } from '../void/void_type.js'
-
-export namespace testType {
-	export interface TestType {
-		/**
-		 * Check if type `A` is equal to type `B` and `C`.
-		 *
-		 * @return `expected` as `A` for type inspection.
-		 */
-		equal<A, B, C>(expected: IsEqual<A, B> & IsEqual<A, C>): A,
-		/**
-		 * Check if type `A` is equal to type `B`.
-		 *
-		 * @return `expected` as `A` for type inspection.
-		 */
-		equal<A, B>(expected: IsEqual<A, B>): A,
-		/**
-		 * Check if `A` can assign to `B`.
-		 *
-		 * If `A` is a union,
-		 * the check is distributive.
-		 *
-		 * Meaning the result can be `boolean`,
-		 * meaning both `true` and `false` will pass.
-		 *
-		 * If you want to avoid the distributivity,
-		 * use `testType.strictCanAssign()` instead.
-		 *
-		 * @example
-		 * ```ts
-		 * testType.canAssign<123, number> // true
-		 *
-		 * testType.canAssign<number | string, number> // boolean
-		 * ```
-		 *
-		 * @return `expected` as `A` for type inspection.
-		 */
-		canAssign<A, B>(expected: CanAssign<A, B>): A,
-		/**
-		 * Check if `A` can fully assign to `B`.
-		 *
-		 * This checks all branches in an union `A` are assignable to `B`.
-		 *
-		 * @example
-		 * ```ts
-		 * testType.strictCanAssign<number | string, number | string> // true
-		 *
-		 * testType.strictCanAssign<number | string, number> // false
-		 * ```
-		 *
-		 * @return `expected` as `A` for type inspection.
-		 */
-		strictCanAssign<A, B>(expected: StrictCanAssign<A, B>): A,
-		/**
-		 * Check if type `T` is exactly `any`.
-		 *
-		 * @return `expected` as `T` for type inspection.
-		 */
-		any<T>(expected: IsAny<T>): T,
-		/**
-		 * Check if type `T` is exactly `array`.
-		 *
-		 * @return `expected` as `T` for type inspection.
-		 */
-		array<T>(expected: IsArray<T>): T,
-		/**
-		 * Check if type `T` is exactly `bigint`.
-		 *
-		 * @return `expected` as `T` for type inspection.
-		 */
-		strictBigint<T>(expected: IsStrictBigint<T>): T,
-		/**
-		 * Check if type `T` is `bigint` or bigint literals.
-		 *
-		 * @return `expected` as `T` for type inspection.
-		 */
-		bigint<T>(expected: IsBigint<T>): T,
-		/**
-		 * Check if type `T` is exactly `boolean`.
-		 *
-		 * @return `expected` as `T` for type inspection.
-		 */
-		strictBoolean<T>(expected: IsStrictBoolean<T>): T,
-		/**
-		 * Check if type `T` is `boolean` and boolean literals.
-		 *
-		 * @return `expected` as `T` for type inspection.
-		 */
-		boolean<T>(expected: IsBoolean<T>): T,
-		/**
-		 * Check if type `T` is exactly `true`.
-		 *
-		 * @return `expected` as `T` for type inspection.
-		 */
-		true<T>(expected: IsTrue<T>): T,
-		/**
-		 * Check if type `T` is exactly `false`.
-		 *
-		 * @return `expected` as `T` for type inspection.
-		 */
-		false<T>(expected: IsFalse<T>): T,
-		/**
-		 * Check if type `T` is exactly `boolean`.
-		 *
-		 * @return `expected` as `T` for type inspection.
-		 */
-		strictFunction<T>(expected: IsStrictFunction<T>): T,
-		/**
-		 * Check if type `T` is `boolean` and boolean literals.
-		 *
-		 * @return `expected` as `T` for type inspection.
-		 */
-		function<T>(expected: IsFunction<T>): T,
-		/**
-		 * Check if type `T` is exactly `never`.
-		 *
-		 * @return `expected` as `T` for type inspection.
-		 */
-		never<T>(expected: IsNever<T>): T,
-		/**
-		 * Check if type `T` is exactly `null`.
-		 *
-		 * @return `expected` as `T` for type inspection.
-		 */
-		null<T>(expected: IsNull<T>): T,
-		/**
-		 * Check if type `T` is exactly `number`.
-		 *
-		 * @return `expected` as `T` for type inspection.
-		 */
-		strictNumber<T>(expected: IsStrictNumber<T>): T,
-		/**
-		 * Check if type `T` is `number` or number literals.
-		 *
-		 * @return `expected` as `T` for type inspection.
-		 */
-		number<T>(expected: IsNumber<T>): T,
-		/**
-		 * Check if type `T` is `object`.
-		 *
-		 * Note that `Function`, `Array`, and *tuple* are also `object`.
-		 *
-		 * @return `expected` as `T` for type inspection.
-		 */
-		object<T>(expected: IsObject<T>): T,
-		/**
-		 * Check if type `T` is exactly `string`.
-		 *
-		 * @return `expected` as `T` for type inspection.
-		 */
-		strictString<T>(expected: IsStrictString<T>): T,
-		/**
-		 * Check if type `T` is `string` or string literals.
-		 *
-		 * @return `expected` as `T` for type inspection.
-		 */
-		string<T>(expected: IsString<T>): T,
-		/**
-		 * Check if type `T` is a `symbol`.
-		 *
-		 * @return `expected` as `T` for type inspection.
-		 */
-		symbol<T>(expected: IsSymbol<T>): T,
-		/**
-		 * Check if type `T` is a *tuple*.
-		 *
-		 * @return `expected` as `T` for type inspection.
-		 */
-		tuple<T>(expected: IsTuple<T>): T,
-		/**
-		 * Check if type `T` is exactly `undefined`.
-		 *
-		 * @return `expected` as `T` for type inspection.
-		 */
-		undefined<T>(expected: IsUndefined<T>): T,
-		// hasUndefined<T>(expected: CanAssign<T, undefined>): T
-		/**
-		 * Check if type `T` is exactly `unknown`.
-		 *
-		 * @return `expected` as `T` for type inspection.
-		 */
-		unknown<T>(expected: IsUnknown<T>): T,
-		/**
-		 * Check if type `T` is exactly `void`.
-		 *
-		 * @return `expected` as `T` for type inspection.
-		 */
-		void<T>(expected: IsVoid<T>): T,
-		/**
-		 * A quick way to inspect a type.
-		 *
-		 * The handler receives a `InspectedType` object.
-		 * It contains `value` which is typed to `T`,
-		 * and many other properties to inspect the behavior of `T`.
-		 *
-		 * The handler is not being call,
-		 * it is use to hold the type in value for inspection.
-		 *
-		 * 🧪 *testing*
-		 * 🦴 *utilities*
-		 *
-		 * @example
-		 * ```ts
-		 * testType.inspect<SomeType>(t => {
-		 *   type T = typeof t.value // resolve and inspect the type `T`
-		 *   t.extend_boolean // result of `T extends boolean`
-		 * })
-		 * ```
-		 *
-		 * After trying out the type, remove the line.
-		 */
-		inspect<T>(handler: (t: InspectedType<T>) => unknown): T
-	}
-
-	export type InspectedType<T> = {
-		type: T,
-		extends<R>(): T extends R ? true : false,
-		extends_any: T extends any ? true : false,
-		extends_unknown: T extends unknown ? true : false,
-		extends_void: T extends void ? true : false,
-		extends_never: T extends never ? true : false,
-		extends_undefined: T extends undefined ? true : false,
-		extends_null: T extends null ? true : false,
-		extends_boolean: T extends boolean ? true : false,
-		extends_true: T extends true ? true : false,
-		extends_false: T extends false ? true : false,
-		extends_number: T extends number ? true : false,
-		extends_1: T extends 1 ? true : false,
-		extends_bigint: T extends bigint ? true : false,
-		extends_1n: T extends 1n ? true : false,
-		extends_string: T extends string ? true : false,
-		extends_a: T extends 'a' ? true : false,
-		extends_symbol: T extends symbol ? true : false,
-		extends_object: T extends object ? true : false,
-		extends_function: T extends Function ? true : false,
-		extends_array_unknown: T extends unknown[] ? true : false,
-		extends_tuple_empty: T extends [] ? true : false,
-		union<R>(): T | R,
-		union_any: T | any,
-		union_unknown: T | unknown,
-		union_void: T | void,
-		union_never: T | never,
-		union_undefined: T | undefined,
-		union_null: T | null,
-		union_boolean: T | boolean,
-		union_true: T | true,
-		union_false: T | false,
-		union_number: T | number,
-		union_1: T | 1,
-		union_bigint: T | bigint,
-		union_1n: T | 1n,
-		union_string: T | string,
-		union_a: T | 'a',
-		union_symbol: T | symbol,
-		union_object: T | object,
-		union_function: T | Function,
-		union_array_unknown: T | unknown[],
-		union_tuple_empty: T | [],
-		intersect<R>(): T & R,
-		intersect_any: T & any,
-		intersect_unknown: T & unknown,
-		intersect_void: T & void,
-		intersect_never: T & never,
-		intersect_undefined: T & undefined,
-		intersect_null: T & null,
-		intersect_boolean: T & boolean,
-		intersect_true: T & true,
-		intersect_false: T & false,
-		intersect_number: T & number,
-		intersect_1: T & 1,
-		intersect_bigint: T & bigint,
-		intersect_1n: T & 1n,
-		intersect_string: T & string,
-		intersect_a: T & 'a',
-		intersect_symbol: T & symbol,
-		intersect_object: T & object,
-		intersect_function: T & Function,
-		intersect_array_unknown: T & unknown[],
-		intersect_tuple_empty: T & []
-	}
-}
-
-/**
- * Test utilities for types.
- *
- * This is designed specifically for testing.
- * The return value is the input `expected` parameter asserted as the first type parameter,
- * so that the type can be further inspected.
- */
-export const testType = new Proxy({} as testType.TestType, {
-	get(_target, _prop, _receiver) {
-		return (expected: unknown) => expected
-	}
-})

package/ts/tuple/common_prop_keys.ts

@@ -1,41 +0,0 @@
-import type { CommonPropKeys as ArrayCommonPropKeys } from '../array/array_plus.common_prop_keys.js'
-import type { KeyTypes } from '../object/KeyTypes.js'
-import type { CommonPropKeys as TupleCommonPropKeys } from './tuple_plus.common_prop_keys.js'
-
-/**
- * ⚗️ *transform*
- * 🔢 *customization*
- *
- * Gets the common property keys of the elements in tuple or array `T`.
- *
- * @example
- * ```ts
- * import { CommonPropKeys } from 'type-plus'
- *
- * type R = CommonPropKeys<[{ a: number }, { b: number }]> // never
- * type R = CommonPropKeys<[{ a: number, c: 1 }, { b: number, c: 2 }]> // 'c'
- * ```
- *
- * @typeParam Options['caseNever'] Return type when `T` is `never`.
- * Default to `never`.
- */
-export type CommonPropKeys<
-	T extends Record<KeyTypes, unknown>[],
-	Options extends CommonPropKeys.Options = CommonPropKeys.DefaultOptions
-> = number extends T['length'] ? ArrayCommonPropKeys<T> : TupleCommonPropKeys<T, Options>
-
-
-export namespace CommonPropKeys {
-	export interface Options extends TupleCommonPropKeys.Options {
-	}
-
-	export interface DefaultOptions extends TupleCommonPropKeys.DefaultOptions {
-	}
-}
-
-/**
- * Gets the common property keys of the elements in `A`.
- *
- * @deprecated Please use `CommonPropKeys` instead.
- */
-export type CommonKeys<A extends Record<KeyTypes, any>[]> = CommonPropKeys<A>

package/ts/tuple/create_tuple.ts

@@ -1,42 +0,0 @@
-import type { DigitArray } from '../math/numeric_struct.js'
-import type { IsInteger } from '../numeric/integer.js'
-import type { IsPositive } from '../numeric/positive.js'
-
-/**
- * Creates `Tuple<T>` with `L` number of elements.
- * @note Other cool implementations by @lazytype, @jcalz:
- * @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 = unknown, Fail = never> = number extends L
-	? T[]
-	: IsPositive<L> extends true
-	? IsInteger<L> extends true
-		? ToTuple<[], DigitArray.FromString<`${L}`>, T>
-		: Fail
-	: Fail
-export type ToTuple<R extends any[], S extends number[], X = any> = S['length'] extends 0
-	? R
-	: S['length'] extends 1
-	? [...R, ...DigitToTuple<X>[S[0]]]
-	: S extends [any, ...infer T]
-	? T extends any[]
-		? ToTuple<Multi10<[...R, ...DigitToTuple<X>[S[0]]]>, T>
-		: never
-	: never
-
-type DigitToTuple<T = 1> = {
-	[k in number]: any[]
-} & {
-	0: [],
-	1: [T],
-	2: [T, T],
-	3: [T, T, T],
-	4: [T, T, T, T],
-	5: [T, T, T, T, T],
-	6: [T, T, T, T, T, T],
-	7: [T, T, T, T, T, T, T],
-	8: [T, T, T, T, T, T, T, T],
-	9: [T, T, T, T, T, T, T, T, T]
-}
-type Multi10<C extends any[]> = [...C, ...C, ...C, ...C, ...C, ...C, ...C, ...C, ...C, ...C]

package/ts/tuple/drop.ts

@@ -1,125 +0,0 @@
-import type { DropMatch as ArrayDropMatch } from '../array/array_plus.drop_match.js'
-import type { DropMatch as TupleDropMatch } from './tuple_plus.drop_match.js'
-
-/**
- * ⚗️ *transform*
- * 🔢 *customizable*
- *
- * Drops the first entry in the tuple `T`.
- *
- * If the type is an array, the same array will be returned.
- *
- * @example
- * ```ts
- * type R = DropFirst<[1, 2, 3]> // [2, 3]
- * type R = DropFirst<[string]> // []
- * type R = DropFirst<[]> // []
- * type R = DropFirst<string[]> // string[]
- * ```
- *
- * @typeParam Options['caseArray'] Return type when `T` is `Array`.
- * Default to `T`.
- *
- * @typeParam Options['caseEmptyTuple'] Return type when `T` is an empty tuple.
- * Default to `[]`.
- */
-export type DropFirst<
-	T extends unknown[],
-	Options extends DropFirst.Options = DropFirst.DefaultOptions<T>
-> = number extends T['length']
-	? Options['caseArray']
-	: T['length'] extends 0
-	? Options['caseEmptyTuple']
-	: T['length'] extends 1
-	? []
-	: T extends [any, ...infer Tail]
-	? Tail
-	: never
-
-export namespace DropFirst {
-	export interface Options {
-		caseArray?: unknown,
-		caseEmptyTuple?: unknown,
-	}
-	export interface DefaultOptions<T> {
-		caseArray: T,
-		caseEmptyTuple: []
-	}
-}
-
-/**
- * ⚗️ *transform*
- * 🔢 *customizable*
- *
- * Drops the last entry in the tuple `T`.
- *
- * If the type is an array, the same array will be returned.
- *
- * @example
- * ```ts
- * type R = DropLast<[1, 2, 3]> // [2, 3]
- * type R = DropLast<[string]> // []
- * type R = DropLast<[]> // []
- * type R = DropLast<string[]> // string[]
- * ```
- *
- * @typeParam Options['caseArray'] Return type when `T` is `Array`.
- * Default to `T`.
- *
- * @typeParam Options['caseEmptyTuple'] Return type when `T` is an empty tuple.
- * Default to `[]`.
- */
-export type DropLast<
-	T extends unknown[],
-	Cases extends DropLast.Options = DropLast.DefaultOptions<T>
-> = number extends T['length']
-	? Cases['caseArray']
-	: T['length'] extends 0
-	? Cases['caseEmptyTuple']
-	: T['length'] extends 1
-	? []
-	: T extends [...infer Heads, any]
-	? Heads
-	: never
-
-
-export namespace DropLast {
-	export interface Options {
-		caseArray?: unknown,
-		caseEmptyTuple?: unknown,
-	}
-	export interface DefaultOptions<T> {
-		caseArray: T,
-		caseEmptyTuple: []
-	}
-}
-
-
-/**
- * ⚗️ *transform*
- *
- * Drops entries matching `Criteria` in array or tuple `A`.
- *
- * @example
- * ```ts
- * type R = DropMatch<Array<string | undefined>, undefined> // string[]
- * type R = DropMatch<Array<string>, string> // never[]
- * type R = DropMatch<Array<1 | 2>, number> // never[]
- * ```
- */
-export type DropMatch<A extends Readonly<Array<unknown>>, Criteria> =	number extends A['length']
-	? ArrayDropMatch<A, Criteria>
-	: TupleDropMatch<A, Criteria>
-
-export type DropNull<A extends Array<any>> = DropMatch<A, null>
-export type DropNullable<A extends Array<any>> = DropMatch<A, null | undefined>
-export type DropUndefined<A extends Array<any>> = DropMatch<A, undefined>
-
-/**
- * drop a particular value from an array.
- *
- * 💀 *deprecated* the type does not sufficiently cover the use cases.
- */
-export function drop<A extends Readonly<unknown[]>, const C>(array: A, value: C): DropMatch<A, C> {
-	return array.filter(v => v !== value) as DropMatch<A, C>
-}