type-plus 6.3.0 → 6.4.0

package/ts/index.ts

@@ -1,27 +1,98 @@
-// import * as types from './types/index.js'
 export { required, requiredDeep, unpartial } from 'unpartial'
-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 * from './any_plus/index.js'
-export * as ArrayPlus from './array_plus/array_plus.js'
-export * from './array_plus/index.js'
-export * from './assertion/index.js'
+export type { IsAnyOrNever } from './any/any_or_never.js'
+export type { AnyType, IsAny, IsNotAny, NotAnyType } from './any/any_type.js'
+export type { At, Concat } from './array/array.js'
+export * as ArrayPlus from './array/array_plus.js'
+export type { ArrayType, IsArray, IsNotArray, NotArrayType } from './array/array_type.js'
+export * from './array/index.js'
+export * from './assertion/assert_type.js'
+export type { BigintType, IsBigint, IsNotBigint, NotBigintType } from './bigint/bigint_type.js'
+export type {
+	IsNotStrictBigint,
+	IsStrictBigint,
+	NotStrictBigintType,
+	StrictBigintType
+} from './bigint/strict_bigint_type.js'
+export type { BooleanType, IsBoolean, IsNotBoolean, NotBooleanType } from './boolean/boolean_type.js'
+export type { FalseType, IsFalse, IsNotFalse, NotFalseType } from './boolean/false_type.js'
+export type {
+	IsNotStrictBoolean,
+	IsStrictBoolean,
+	NotStrictBooleanType,
+	StrictBooleanType
+} from './boolean/strict_boolean_type.js'
+export type { IsNotTrue, IsTrue, NotTrueType, TrueType } from './boolean/true_type.js'
 export * from './class/index.js'
-export * from './function/index.js'
+export type { ComposableTypes, NonComposableTypes } from './composable_types.js'
+export type { Equal, NotEqual } from './equal/equal.js'
+export type { AnyFunction } from './function/any_function.js'
+export * from './function/extract_function.js'
+export type { FunctionType, IsFunction, IsNotFunction, NotFunctionType } from './function/function_type.js'
+export type {
+	IsNotStrictFunction,
+	IsStrictFunction,
+	NotStrictFunctionType,
+	StrictFunctionType
+} from './function/strict_function_type.js'
 export * from './functional/index.js'
-export type * from './math/index.js'
+export type { JSONArray, JSONObject, JSONPrimitive, JSONTypes } from './json.js'
+export type {
+	Abs,
+	Add,
+	Decrement,
+	Digit,
+	DigitArray,
+	GreaterThan,
+	Increment,
+	Max,
+	Subtract
+} from './math/index.js'
+export type { IsNever, IsNotNever, Is_Never, NeverType, NotNeverType, Not_Never } from './never/never_type.js'
 export * from './nodejs/index.js'
-export * from './nominal-types/index.js'
-export * from './number_plus/index.js'
-export * as NumberPlus from './number_plus/number_plus.js'
+export * from './nominal/index.js'
+export type { IsNotNull, IsNull, NotNullType, NullType } from './null/null_type.js'
+export type { Integer, IsInteger, IsNotInteger, IsWhole, NotInteger } from './number/integer.js'
+export type { IsNegative, IsNotNegative, Negative, NotNegative } from './number/negative.js'
+export * as NumberPlus from './number/number_plus.js'
+export type { IsNotNumber, IsNumber, NotNumberType, NumberType } from './number/number_type.js'
+export type {
+	IsNotNumeric,
+	IsNumeric,
+	NotNumericType,
+	Numeric,
+	NumericType,
+	Zero
+} from './number/numeric_type.js'
+export type { IsNotPositive, IsPositive, NonPositive, Positive } from './number/positive.js'
+export type {
+	IsNotStrictNumber,
+	IsStrictNumber,
+	NotStrictNumberType,
+	StrictNumberType
+} from './number/strict_number_type.js'
 export * from './object/index.js'
+export type { IsNotObject, IsObject, NotObjectType, ObjectType } from './object/object_type.js'
 export * from './predicates/index.js'
+export type { PrimitiveTypes } from './primitive.js'
 export * from './promise/index.js'
-export * from './testing/index.js'
-export * from './tuple/index.js'
+export type {
+	IsNotStrictString,
+	IsStrictString,
+	NotStrictStringType,
+	StrictStringType
+} from './string/strict_string_type.js'
+export type { IsNotString, IsString, NotStringType, StringType } from './string/string_type.js'
+export type { IsNotSymbol, IsSymbol, NotSymbolType, SymbolType } from './symbol/symbol_type.js'
+export * from './testing/stub.js'
+export * from './testing/test_type.js'
+export type { IsNotTuple, IsTuple, NotTupleType, TupleType } from './tuple/tuple_type.js'
+export type {
+	IsNotUndefined,
+	IsUndefined,
+	NotUndefinedType,
+	UndefinedType
+} from './undefined/undefined_type.js'
+export type { UnionKeys } from './union_keys.js'
+export type { IsNotUnknown, IsUnknown, NotUnknownType, UnknownType } from './unknown/unknown_type.js'
 export * from './utils/index.js'
-// export { types, types as T }
+export type { IsNotVoid, IsVoid, NotVoidType, VoidType } from './void/void_type.js'

package/ts/math/Add.ts

@@ -1,6 +1,7 @@
-import type { PadLeft } from '../array_plus/index.js'
+import type { PadLeft } from '../array/index.js'
+import type { IsInteger } from '../number/integer.js'
+import type { IsPositive } from '../number/positive.js'
 import type { And } from '../predicates/index.js'
-import type { IsPositive, IsWhole } from '../number_plus/number.js'
 import type { Digit, DigitArray } from './Digit.js'
 import type { Max } from './Max.js'
 
@@ -8,8 +9,8 @@ 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>>
+	And<IsPositive<A>, IsInteger<A>>,
+	And<IsPositive<B>, IsInteger<B>>
 > extends false
 	? Fail
 	: DigitArray.FromNumber<A> extends infer DA

package/ts/math/Digit.ts

@@ -1,5 +1,6 @@
-import type { Tail } from '../array_plus/index.js'
-import type { IsPositive, IsWhole } from '../number_plus/number.js'
+import type { Tail } from '../array/tail.js'
+import type { IsInteger } from '../number/integer.js'
+import type { IsPositive } from '../number/positive.js'
 import type { And } from '../predicates/index.js'
 
 export namespace Digit {
@@ -66,7 +67,7 @@ export namespace DigitArray {
 	export type FromNumberAbs<N extends number> = FromString<TrimMinusSign<`${N}`>>
 	export type TrimMinusSign<N extends string> = N extends `-${infer rest}` ? rest : N
 
-	export type NumberToString<N extends number> = And<IsPositive<N>, IsWhole<N>> extends true ? `${N}` : never
+	export type NumberToString<N extends number> = And<IsPositive<N>, IsInteger<N>> extends true ? `${N}` : never
 
 	export type FromString<S extends string> = S extends `1${infer L}`
 		? [1, ...FromString<L>]

package/ts/math/GreaterThan.ts

@@ -1,12 +1,14 @@
-import type { Head, PadLeft, Tail } from '../array_plus/index.js'
-import type { IsPositive, IsWhole } from '../number_plus/number.js'
-import type { And, Equal, Or, Xor } from '../predicates/index.js'
+import type { Head, PadLeft, Tail } from '../array/index.js'
+import type { Equal } from '../equal/equal.js'
+import type { IsInteger } from '../number/integer.js'
+import type { IsPositive } from '../number/positive.js'
+import type { And, Or, Xor } from '../predicates/index.js'
 import type { Digit, DigitArray } from './Digit.js'
 import type { Max } from './Max.js'
 
 export type GreaterThan<A extends number, B extends number, Fail = never> = And<
-	IsWhole<A>,
-	IsWhole<B>
+	IsInteger<A>,
+	IsInteger<B>
 > extends false
 	? Fail
 	: number extends A

package/ts/math/Max.ts

@@ -1,4 +1,4 @@
-import type { Equal } from '../predicates/index.js'
+import { Equal } from '../equal/equal.js'
 import type { GreaterThan } from './GreaterThan.js'
 
 export type Max<A extends number, B extends number, Fail = never> = GreaterThan<A, B> extends infer Result

package/ts/math/Subtract.ts

@@ -1,13 +1,13 @@
-import type { PadLeft, Some, Tail } from '../array_plus/index.js'
+import type { PadLeft, Some, Tail } from '../array/index.js'
+import type { IsInteger } from '../number/integer.js'
+import type { IsPositive } from '../number/positive.js'
 import type { And } from '../predicates/index.js'
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-import type { IsPositive, IsWhole } from '../number_plus/number.js'
 import type { Digit, DigitArray } from './Digit.js'
 import type { Max } from './Max.js'
 
 export type Subtract<A extends number, B extends number, Fail = never> = And<
-	And<IsPositive<A>, IsWhole<A>>,
-	And<IsPositive<B>, IsWhole<B>>
+	And<IsPositive<A>, IsInteger<A>>,
+	And<IsPositive<B>, IsInteger<B>>
 > extends true
 	? DigitArray.Shift10<DigitArray.FromNumber<A>> extends infer DA
 		? DA extends number[]

package/ts/never/never_type.ts

@@ -0,0 +1,65 @@
+import type { Brand } from '../nominal/brand.js'
+
+
+/**
+ * This is a unique type used in the `Else` branch of `NeverType`.
+ */
+export type Not_Never = Brand<'not_never', symbol>
+
+/**
+ * This is a unique type used in the `Else` branch of `NotNeverType`.
+ */
+export type Is_Never = Brand<'is_never', symbol>
+
+/**
+ * Check if `T` is `never`.
+ * If it is not, returns `Not_Never`.
+ *
+ * ```ts
+ * import type { NeverType } from 'type-plus'
+ *
+ * type R = NeverType<never> // never
+ *
+ * type R = NeverType<1> // 'not never'
+ * ```
+ */
+export type NeverType<T, Then = T, Else = Not_Never> = [T, never] extends [never, T] ? Then : Else
+
+/**
+ * Check if `T` is not `never`.
+ * If it is not, returns `Is_Never`.
+ *
+ * ```ts
+ * import type { NotNeverType } from 'type-plus'
+ *
+ * type R = NotNeverType<1> // 1
+ *
+ * type R = NotNeverType<never> // 'is_never'
+ * ```
+ */
+export type NotNeverType<T, Then = T, Else = Is_Never> = NeverType<T, Else, Then>
+
+/**
+ * Is `T` `never`.
+ *
+ * ```
+ * import type { IsNever } from 'type-plus'
+ *
+ * type R = IsNever<never> // true
+ *
+ * type R = IsNever<1> // false
+ * ```
+ */
+export type IsNever<T, Then = true, Else = false> = NeverType<T, Then, Else>
+
+/**
+ * Is `T` not `never`.
+ *
+ * ```
+ * import type { IsNotNever } from 'type-plus'
+ *
+ * type R = IsNotNever<1> // true
+ *
+ * type R = IsNotNever<never> // false
+ */
+export type IsNotNever<T, Then = true, Else = false> = NeverType<T, Else, Then>

package/ts/never/readme.md

@@ -0,0 +1,37 @@
+# never
+
+`never` is a bottom type in TypeScript.
+That means it is a subtype of all other types.
+
+## Type Checking
+
+The `NeverType<T>` and friends are used to check if a type is exactly `never`.
+
+Filter normally returns `never` in the `Else` clause.
+But since we are checking for `never` here,
+they have to return something other than `never`.
+
+Therefore, `NeverType<T>` will return the `Not_Never` symbol when `T` is not `never`,
+and `NotNeverType<T>` will return the `Is_Never` symbol when `T` is `never`.
+
+```ts
+import type { NeverType } from 'type-plus'
+
+type R = NeverType<never> // never
+
+type R = NeverType<true> // Not_Never
+type R = NeverType<false> // Not_Never
+```
+
+- [`NeverType<T, Then = T, Else = Not_Never>`](never_type.ts#L16): check if `T` is exactly `never`.
+- [`IsNever<T, Then = true, Else = false`](never_type.ts#L50): is `T` exactly `never`.
+- [`NotNeverType<T, Then = T, Else = Is_Never>`](never_type.ts#L35): check if `T` is not exactly `never`.
+- [`IsNotNever<T, Then = true, Else = false>`](never_type.ts#L65): is `T` not exactly `never`.
+
+## References
+
+- [Handbook]
+- [TypeScript Deep Dive][deep_dive]
+
+[deep_dive]: https://basarat.gitbook.io/typescript/type-system/never
+[handbook]: https://www.typescriptlang.org/docs/handbook/2/functions.html#never

package/ts/nominal/brand.ts

@@ -0,0 +1,35 @@
+// By Drew Colthorp, <https://spin.atomicobject.com/2018/01/15/typescript-flexible-nominal-typing/#comment-604580>
+// <https://gist.github.com/dcolthorp/aa21cf87d847ae9942106435bf47565d>
+
+import { isType } from '../predicates/isType.js'
+import type { Widen } from '../utils/index.js'
+import { typeSym, valueSym } from './types.js'
+
+/**
+ * Create a "branded" version of a type.
+ * TypeScript won't allow implicit conversion to this type
+ */
+export type Brand<B extends string, T> = T extends object
+	? T & { [typeSym]: B }
+	: { [typeSym]: B; [valueSym]: T }
+
+/**
+ * Creates a brand creator with the specified type.
+ */
+export function brand<B extends string>(type: B): <T>(subject: T) => Brand<B, Widen<T>>
+/**
+ * Creates a branded value of specified type.
+ */
+export function brand<B extends string, T>(type: B, subject: T): Brand<B, Widen<T>>
+export function brand(type: string, subject?: unknown) {
+	if (subject === undefined)
+		return function <T>(subject: T) {
+			return brand(type, subject)
+		}
+
+	if (isType<{ [typeSym]: string }>(subject, s => typeof s === 'object' && s !== null)) {
+		// if subject is not an object, the branding will exist only in type-level.
+		subject[typeSym] = type
+	}
+	return subject
+}

package/ts/nominal/flavor.ts

@@ -0,0 +1,38 @@
+// By Drew Colthorp, <https://spin.atomicobject.com/2018/01/15/typescript-flexible-nominal-typing/#comment-604580>
+// <https://gist.github.com/dcolthorp/aa21cf87d847ae9942106435bf47565d>
+
+import { isType } from '../predicates/isType.js'
+import type { Widen } from '../utils/index.js'
+import { typeSym } from './types.js'
+
+/**
+ * Create a "flavored" version of a type.
+ * TypeScript will disallow mixing flavors,
+ * but will allow unflavored values of that type to be passed in where a flavored version is expected.
+ * This is a less restrictive form of branding.
+ */
+export type Flavor<F extends string, T> = T & {
+	[typeSym]?: F
+}
+
+/**
+ * Creates a brand creator with the specified type.
+ */
+export function flavor<F extends string>(type: F): <T>(subject: T) => Flavor<F, Widen<T>>
+/**
+ * Creates a branded value of specified type.
+ */
+export function flavor<F extends string, T>(type: F, subject: T): Flavor<F, Widen<T>>
+export function flavor(type: string, subject?: unknown) {
+	if (subject === undefined)
+		return function <T>(subject: T) {
+			return flavor(type, subject)
+		}
+
+	if (isType<{ [typeSym]: string }>(subject, s => typeof s === 'object' && s !== null)) {
+		// if subject is not an object, the branding will exist only in type-level.
+		subject[typeSym] = type
+	}
+
+	return subject
+}

package/ts/nominal/index.ts

@@ -0,0 +1,3 @@
+export * from './brand.js'
+export * from './flavor.js'
+export * from './nominal_match.js'

package/ts/nominal/nominal_match.ts

@@ -0,0 +1,22 @@
+import type { Brand } from './brand.js'
+import type { Flavor } from './flavor.js'
+import { typeSym } from './types.js'
+
+export function nominalMatch<A extends string, B extends A>(
+	a: Brand<A, unknown>,
+	b: Brand<B, unknown>
+): boolean
+export function nominalMatch<A extends string, B extends A>(
+	a: Flavor<A, unknown>,
+	b: Flavor<B, unknown>
+): boolean
+export function nominalMatch<A extends string, B extends A>(
+	a: Brand<A, unknown> | Flavor<A, unknown>,
+	b: Brand<B, unknown> | Flavor<B, unknown>
+) {
+	if (typeof a === 'object' && a !== null && typeof b === 'object' && b !== null)
+		return a[typeSym] === b[typeSym]
+	else {
+		return true
+	}
+}

package/ts/null/null_type.ts

@@ -0,0 +1,61 @@
+import type { IsAny } from '../any/any_type.js'
+
+/**
+ * Check if the type `T` is exactly `null`.
+ *
+ * ```
+ * import type { NullType } from 'type-plus'
+ *
+ * type R = NullType<null> // null
+ *
+ * type R = NullType<never> // never
+ * type R = NullType<unknown> // never
+ * type R = NullType<string | boolean> // never
+ * ```
+ */
+export type NullType<T, Then = T, Else = never> = IsAny<T, Else, [T, null] extends [null, T] ? Then : Else>
+
+/**
+ * Is the type `T` exactly `null`.
+ *
+ * ```
+ * import type { IsNull } from 'type-plus'
+ *
+ * type R = IsNull<null> // true
+ *
+ * type R = IsNull<never> // false
+ * type R = IsNull<unknown> // false
+ * type R = IsNull<string | boolean> // false
+ * ```
+ */
+export type IsNull<T, Then = true, Else = false> = NullType<T, Then, Else>
+
+/**
+ * Check if the type `T` is not exactly `null`.
+ *
+ * ```
+ * import type { NotNullType } from 'type-plus'
+ *
+ * type R = NotNullType<null> // never
+ *
+ * type R = NotNullType<never> // never
+ * type R = NotNullType<unknown> // unknown
+ * type R = NotNullType<string | boolean> // string | boolean
+ * ```
+ */
+export type NotNullType<T, Then = T, Else = never> = NullType<T, Else, Then>
+
+/**
+ * Is the type `T` not exactly `null`.
+ *
+ * ```
+ * import type { IsNotNull } from 'type-plus'
+ *
+ * type R = IsNotNull<null> // false
+ *
+ * type R = IsNotNull<never> // true
+ * type R = IsNotNull<unknown> // true
+ * type R = IsNotNull<string | boolean> // true
+ * ```
+ */
+export type IsNotNull<T, Then = true, Else = false> = NullType<T, Else, Then>

package/ts/null/readme.md

@@ -0,0 +1,24 @@
+# null
+
+## Type Checking
+
+The `NullType<T>` and friends are used to check if a type is `null` or not.
+
+```ts
+import type { NullType } from 'type-plus'
+
+type R = NullType<null> // null
+
+type R = NullType<1> // never
+```
+
+- [`NullType<T, Then = T, Else = never>`](null_type.ts#L16): check if `T` is `null`.
+- [`IsNull<T, Then = true, Else = false`](null_type.ts#L31): is `T` `null`.
+- [`NotNullType<T, Then = T, Else = never>`](null_type.ts#L46): check if `T` is not `null`.
+- [`IsNotNull<T, Then = true, Else = false>`](null_type.ts#L61): is `T` not `null`.
+
+## References
+
+- [Handbook]
+
+[handbook]: https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#null-and-undefined

package/ts/number/integer.ts

@@ -0,0 +1,81 @@
+import type { IsAnyOrNever } from '../any/any_or_never.js'
+import type { Numeric } from './numeric_type.js'
+
+/**
+ * Check if T is an integer, including bigint.
+ *
+ * ```ts
+ * import type { Integer } from 'type-plus'
+ *
+ * type R = Integer<0> // 0
+ * type R = Integer<1n> // 1n
+ *
+ * type R = Integer<1.1> // never
+ * type R = Integer<number> // never as it contains non-integer
+ * ```
+ */
+export type Integer<T, Then = T, Else = never> = IsAnyOrNever<
+	T,
+	Else,
+	[T] extends [Numeric] ? (`${T}` extends `${bigint}` ? Then : Else) : Else
+>
+
+/**
+ * Is T an integer, including bigint.
+ *
+ * ```ts
+ * import type { IsInteger } from 'type-plus'
+ *
+ * type R = IsInteger<0> // true
+ * type R = IsInteger<1n> // true
+ *
+ * type R = IsInteger<1.1> // false
+ * type R = IsInteger<number> // false as it contains non-integer
+ * ```
+ */
+export type IsInteger<T, Then = true, Else = false> = Integer<T, Then, Else>
+
+/**
+ * Check if T is not an integer, including bigint.
+ *
+ * ```ts
+ * import type { NotInteger } from 'type-plus'
+ *
+ * type R = NotInteger<1.1> // 1.1
+ * type R = NotInteger<number> // number as it contains non-integer
+ *
+ * type R = NotInteger<0> // never
+ * type R = NotInteger<1n> // never
+ * ```
+ */
+export type NotInteger<T, Then = T, Else = never> = Integer<T, Else, Then>
+
+/**
+ * Is T not an integer, including bigint.
+ *
+ * ```ts
+ * import type { IsNotInteger } from 'type-plus'
+ *
+ * type R = IsNotInteger<1.1> // true
+ * type R = IsNotInteger<number> // true as it contains non-integer
+ *
+ * type R = IsNotInteger<0> // false
+ * type R = IsNotInteger<1n> // false
+ * ```
+ */
+export type IsNotInteger<T, Then = true, Else = false> = NotInteger<T, Else, Then>
+
+/**
+ * Check if T is an integer, including bigint.
+ *
+ * ```
+ * import type { IsWhole } from 'type-plus'
+ *
+ * type R = IsWhole<0> // 0
+ * type R = IsWhole<1n> // 1n
+ *
+ * type R = IsWhole<1.1> // never
+ * type R = IsWhole<number> // never as it contains non-integer
+ * ```
+ */
+export type IsWhole<N, Then = true, Else = false> = Integer<N, Then, Else>