type-plus 7.4.0 → 7.5.0

package/ts/testing/test_type.ts

@@ -23,215 +23,284 @@ import type { IsUndefined } from '../undefined/undefined_type.js'
 import type { IsUnknown } from '../unknown/unknown_type.js'
 import type { IsVoid } from '../void/void_type.js'
 
-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 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 & []
+	}
 }
 
 /**
@@ -241,75 +310,8 @@ interface TestType {
  * 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, {
+export const testType = new Proxy({} as testType.TestType, {
 	get(_target, _prop, _receiver) {
 		return (expected: unknown) => expected
 	}
 })
-
-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 & []
-}

package/ts/tuple/common_prop_keys.ts

@@ -1,51 +1,37 @@
-import type { NotNeverType } from '../never/never_type.js'
+import type { CommonPropKeys as ArrayCommonPropKeys } from '../array/array_plus.common_prop_keys.js'
 import type { KeyTypes } from '../object/KeyTypes.js'
-import type { Tail } from './tail.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 `T`.
+ * 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>[],
-	Cases extends {
-		array?: unknown,
-		no_common_keys?: unknown
-	} = {
-		array: T extends Array<infer R extends Record<KeyTypes, unknown>> ? keyof R : never,
-		no_common_keys: never
+	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 {
 	}
-> = number extends T['length']
-	? Cases['array']
-	: (
-		T['length'] extends 0
-		? Cases['no_common_keys']
-		: (
-			T['length'] extends 1
-			? keyof T[0]
-			: (
-				T['length'] extends 2
-				? (
-					keyof T[0] & keyof T[1] extends infer R
-					? NotNeverType<R, R, Cases['no_common_keys']>
-					: never
-				)
-				: (
-					keyof T[0] & keyof T[1] & CommonPropKeys<Tail<Tail<T>>> extends infer R
-					? NotNeverType<R, R, Cases['no_common_keys']>
-					: never
-				)
-			)
-		)
-	)
+}
 
 /**
  * Gets the common property keys of the elements in `A`.