type-plus 8.0.0-beta.0 → 8.0.0-beta.2

package/ts/mix_types/box.ts

@@ -1,62 +0,0 @@
-import type { IsBigint } from '../bigint/bigint_type.js'
-import type { IsBoolean } from '../boolean/boolean_type.js'
-import type { IsFunction } from '../function/function_type.js'
-import type { IsNumber } from '../number/number_type.js'
-import type { IsStrictObject } from '../object/is_strict_object.js'
-import type { IsString } from '../string/string_type.js'
-import type { IsSymbol } from '../symbol/symbol_type.js'
-
-/**
- * ⚗️ *transform*
- * 🔢 *customizable*
- *
- * Converts primitive types to their boxed types.
- *
- * @typeParam Options['$notBoxable'] return type when `T` is not boxable. Defaults to `never`.
- *
- * @example
- * ```ts
- * Box<number> // Number
- * Box<object> // Object
- * Box<string>  // String
- * Box<'abc'>  // String
- *
- * Box<undefined> // never
- * ```
- */
-export type Box<T, Options extends Box.Options = Box.DefaultOptions> =
-	IsFunction<
-		T,
-		Function,
-		IsStrictObject<
-			T,
-			Object,
-			T extends Record<any, any> ? T :
-			IsBoolean<
-				T,
-				Boolean,
-				IsNumber<
-					T,
-					Number,
-					IsString<
-						T,
-						String,
-						IsSymbol<
-							T,
-							Symbol,
-							IsBigint<T, BigInt, Options['$notBoxable']>
-						>
-					>
-				>
-			>
-		>
-	>
-
-export namespace Box {
-	export type Options = {
-		$notBoxable?: unknown
-	}
-	export interface DefaultOptions {
-		$notBoxable: never
-	}
-}

package/ts/mix_types/merge.ts

@@ -1,61 +0,0 @@
-import type { Box } from './box.js'
-import type { IsNever } from '../never/never_type.js'
-import type { IsNull } from '../null/null_type.js'
-import type { Merge as ObjectMerge } from '../object/merge.js'
-import type { Or } from '../predicates/logical.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'
-
-/**
- * ⚗️ *transform*
- * 🔢 *customizable*
- *
- * Merges type `A` and type `B`.
- *
- * This type performs the same operations as `{ ...a, ...b }` but at the type level.
- *
- * This is a more general type then `ObjectPlus.Merge<A, B>`,
- * which constraints `A` and `B` to be `Record`.
- *
- * This type does not have such restrictions, and tries to handle the other types accordingly.
- */
-export type Merge<A, B> =
-	Or<
-		IsNever<A>,
-		IsNever<B>,
-		never,
-		Or<
-			IsVoid<A>,
-			IsVoid<B>,
-			A & B,
-			Or<
-				IsUnknown<A>,
-				Or<IsUndefined<A>, IsNull<A>>,
-				B,
-				Or<
-					IsUnknown<B>,
-					Or<IsUndefined<B>, IsNull<B>>,
-					A,
-					ObjectMerge<
-						Box<A, { $notBoxable: {} }>,
-						Box<B, { $notBoxable: {} }>
-					>
-				>
-			>
-		>
-	>
-
-/**
-* Left join `a` with `b`.
-*
-* This returns the proper type of `{ ...a, ...b }`
-*
-* @example
-* ```ts
-* merge({ a: 1 }, {} as { a?: string | undefined }) // { a: number | string }
-* ```
-*/
-export function merge<A, B>(a: A, b: B): Merge<A, B> {
-	return { ...a, ...b } as any
-}

package/ts/mix_types/readme.md

@@ -1,74 +0,0 @@
-# Mix Types
-
-This folder contains types and utilities that work across multiple types.
-
-## [AnyOrNeverType](./any_or_never_type.ts)
-
-`AnyOrNeverType<T, Then = T, Else = never>` 🎭 🩳
-
-Filter `T` to ensure it is either exactly `any` or exactly `never`.
-
-🌪️ *filter*
-🩳 *shortcut*
-
-```ts
-import type { AnyOrNeverType } from 'type-plus'
-
-type R = AnyOrNeverType<any> // any
-type R = AnyOrNeverType<never> // never
-type R = AnyOrNeverType<never, 1, 2> // 1
-
-type R = AnyOrNeverType<unknown, 1, 2> // 2
-```
-
-## [IsAnyOrNever](./any_or_never_type.ts)
-
-`IsAnyOrNever<T, Then = true, Else = false>` 🎭 🩳
-
-Validate if `T` is either exactly `any` or exactly `never`.
-
-🎭 *validate*
-🩳 *shortcut*
-
-```ts
-import type { IsAnyOrNever } from 'type-plus'
-
-type R = IsAnyOrNever<any> // true
-type R = IsAnyOrNever<never> // true
-
-type R = IsAnyOrNever<unknown> // false
-```
-
-## [Box](./box.ts)
-
-`Box<T, Options = { $notBoxable }>`
-
-⚗️ *transform*
-🔢 *customizable*
-
-Converts primitive types to their boxed types.
-
-`$notBoxable`: return type when `T` is not boxable. Defaults to `never`.
-
-```ts
-Box<number> // Number
-Box<object> // Object
-Box<string>  // String
-Box<'abc'>  // String
-
-Box<undefined> // never
-```
-
-## [Merge](./merge.ts)
-
-⚗️ *transform*
-🔢 *customizable*
-
-Merges type `A` and type `B`.
-
-This type performs the same operations as `{ ...a, ...b }` but at the type level.
-
-This is a more general type then `ObjectPlus.Merge<A, B>`,
-which constraints `A` and `B` to be `Record`.
-
-This type does not have such restrictions, and tries to handle the other types accordingly.

package/ts/never/never_type.ts

@@ -1,70 +0,0 @@
-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
- * 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
- * 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`.
- *
- * ```ts
- * 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`.
- *
- * ```ts
- * type R = IsNotNever<1> // true
- *
- * type R = IsNotNever<never> // false
- */
-export type IsNotNever<T, Then = true, Else = false> = NeverType<T, Else, Then>
-
-export namespace NeverType {
-	/**
-	 * Type options when input type is `never`.
-	 */
-	export interface Options {
-		$never?: unknown
-	}
-
-	export interface DefaultOptions {
-		$never: never
-	}
-}

package/ts/never/readme.md

@@ -1,37 +0,0 @@
-# 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

@@ -1,43 +0,0 @@
-// 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 '../type-guard/is_type.js'
-import type { Widen } from '../utils/index.js'
-import { typeSym, valueSym } from './constants.js'
-
-/**
- * Create a "branded" version of a type.
- * TypeScript won't allow implicit conversion to this type
- */
-export type Brand<B extends string, T = never> = [T] extends [null] | [undefined] | [symbol] | [void]
-	? Branded<B, T>
-	: Branded<B, T> & T
-
-/**
- * A branded type of `B` with value of `T`.
- */
-export interface Branded<B extends string, T> {
-	[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(typeInput: string, subject?: unknown) {
-	if (subject === undefined)
-		return function <T>(subject: T) {
-			return brand(typeInput, 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] = typeInput
-	}
-	return subject
-}

package/ts/nominal/flavor.ts

@@ -1,53 +0,0 @@
-// 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 '../type-guard/is_type.js'
-import type { Widen } from '../utils/index.js'
-import { typeSym, valueSym } from './constants.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] extends [null] | [undefined] | [symbol] | [void]
-	? FlavoredUnit<F, T>
-	: Flavored<F> & T
-
-/**
- * A flavored type of `F`
- */
-export interface Flavored<F extends string> {
-	[typeSym]?: F
-}
-
-/**
- * A special flavored type for special types.
- */
-export interface FlavoredUnit<F extends string, T> {
-	[typeSym]?: F,
-	[valueSym]: T
-}
-
-/**
- * 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/nominal_match.ts

@@ -1,22 +0,0 @@
-import type { Brand } from './brand.js'
-import type { Flavor } from './flavor.js'
-import { typeSym } from './constants.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

@@ -1,53 +0,0 @@
-import type { IsAny } from '../any/any_type.js'
-
-/**
- * Check if the type `T` is exactly `null`.
- *
- * ```ts
- * 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`.
- *
- * ```ts
- * 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`.
- *
- * ```ts
- * 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`.
- *
- * ```ts
- * 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

@@ -1,24 +0,0 @@
-# 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/number_plus.ts

@@ -1,20 +0,0 @@
-export type { Integer, IsInteger, IsNotInteger, IsWhole, NotInteger } from '../numeric/integer.js'
-export type { IsNegative, IsNotNegative, Negative, NotNegative } from '../numeric/negative.js'
-export type {
-	IsNotNumeric,
-	IsNumeric,
-	NotNumericType,
-	Numeric,
-	NumericType,
-	Zero
-} from '../numeric/numeric_type.js'
-export type { IsNotPositive, IsPositive, NonPositive, Positive } from '../numeric/positive.js'
-// export type { Sum } from './number_array.js'
-export type { IsNotNumber, IsNumber, NotNumberType, NumberType } from './number_type.js'
-export type {
-	IsNotStrictNumber,
-	IsStrictNumber,
-	NotStrictNumberType,
-	StrictNumberType
-} from './strict_number_type.js'
-

package/ts/number/number_type.ts

@@ -1,53 +0,0 @@
-import type { IsAnyOrNever } from '../mix_types/any_or_never_type.js'
-
-/**
- * Check if the type `T` is `number`.
- *
- * ```ts
- * type R = NumberType<number> // true
- * type R = NumberType<1> // true
- *
- * type R = NumberType<never> // false
- * type R = NumberType<unknown> // false
- * ```
- */
-export type NumberType<T, Then = T, Else = never> = IsAnyOrNever<T, Else, [T] extends [number] ? Then : Else>
-
-/**
- * Is the type `T` is `number`.
- *
- * ```ts
- * type R = IsNumber<number> // true
- * type R = IsNumber<1> // true
- *
- * type R = IsNumber<never> // false
- * type R = IsNumber<unknown> // false
- * ```
- */
-export type IsNumber<T, Then = true, Else = false> = NumberType<T, Then, Else>
-
-/**
- * Check if the type `T` is not `number`.
- *
- * ```ts
- * type R = NotNumberType<number> // false
- * type R = NotNumberType<1> // false
- *
- * type R = NotNumberType<never> // true
- * type R = NotNumberType<unknown> // true
- * ```
- */
-export type NotNumberType<T, Then = T, Else = never> = NumberType<T, Else, Then>
-
-/**
- * Is the type `T` not `number`.
- *
- * ```ts
- * type R = IsNotNumber<number> // false
- * type R = IsNotNumber<1> // false
- *
- * type R = IsNotNumber<never> // true
- * type R = IsNotNumber<unknown> // true
- * ```
- */
-export type IsNotNumber<T, Then = true, Else = false> = NumberType<T, Else, Then>

package/ts/number/readme.md

@@ -1,47 +0,0 @@
-# number
-
-## Type Checking
-
-The `NumberType<T>` and friends are used to check if `T` is `number` or number literals.
-
-```ts
-import type { NumberType } from 'type-plus'
-
-type R = NumberType<number> // number
-type R = NumberType<1> // 1
-
-type R = NumberType<bigint> // never
-type R = NumberType<1n> // never
-type R = NumberType<never> // never
-type R = NumberType<unknown> // never
-```
-
-- [`NumberType<T, Then = T, Else = never>`](number_type.ts#L16): check if `T` is `number` or number literals.
-- [`IsNumber<T, Then = true, Else = false`](number_type.ts#L35): is `T` `number` or number literals.
-- [`NotNumberType<T, Then = T, Else = never>`](number_type.ts#L46): check if `T` is not `number` nor number literals.
-- [`IsNotNumber<T, Then = true, Else = false>`](number_type.ts#L61): is `T` not `number` nor number literals.
-
----
-
-The `StrictNumberType<T>` and friends are used to check if `T` is exactly `number`.
-
-```ts
-import type { StrictNumberType } from 'type-plus'
-
-type R = StrictNumberType<number> // number
-
-type R = StrictNumberType<1> // never
-type R = StrictNumberType<never> // never
-type R = StrictNumberType<unknown> // never
-```
-
-- [`StrictNumberType<T, Then = T, Else = never>`](strict_number_type.ts#L16): check if `T` is `number`.
-- [`IsStrictNumber<T, Then = true, Else = false`](strict_number_type.ts#L35): is `T` `number`.
-- [`NotStrictNumberType<T, Then = T, Else = never>`](strict_number_type.ts#L50): check if `T` is not `number`.
-- [`IsNotStrictNumber<T, Then = true, Else = false>`](strict_number_type.ts#L65): is `T` not `number`.
-
-## References
-
-- [Handbook]
-
-[handbook]: https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#the-primitives-string-number-and-boolean