type-plus 8.0.0-beta.6 → 8.0.0-beta.7

package/src/type_plus/branch/$select_invert.ts

@@ -1,83 +0,0 @@
-import type { $Any } from '../../any/any.js'
-import type { $Never } from '../../never/never.js'
-import type { $Unknown } from '../../unknown/unknown.js'
-import type { $SpecialType } from '../$special_type.js'
-import type { $DistributiveDefault, $DistributiveOptions } from './$distributive.js'
-import type { $InputOptions } from './$input_options.js'
-import type { $IsDistributive } from './$is_distributive.js'
-import type { $ResolveBranch } from './$resolve_branch.js'
-import type { $Else, $SelectionBranch, $SelectionPredicate, $Then } from './$selection.js'
-import type { $SelectionOptions } from './$selection_options.js'
-
-/**
- * 🎭 *predicate*
- * ㊙️ *internal*
- *
- * Validate if `T` is `U`.
- *
- * @example
- * ```ts
- * type R = $SelectInvert<undefined, undefined> // true
- *
- * type R = $SelectInvert<never, undefined> // false
- * type R = $SelectInvert<unknown, undefined> // false
- * type R = $SelectInvert<string | boolean, undefined> // false
- *
- * type R = $SelectInvert<string | undefined, undefined> // boolean
- * ```
- *
- * 🔢 *customize*
- *
- * Filter to ensure `T` is `U`, otherwise returns `never`.
- *
- * @example
- * ```ts
- * type R = $SelectInvert<undefined, undefined, { selection: 'filter' }> // undefined
- *
- * type R = $SelectInvert<never, undefined, { selection: 'filter' }> // never
- * type R = $SelectInvert<unknown, undefined, { selection: 'filter' }> // never
- * type R = $SelectInvert<string | boolean, undefined, { selection: 'filter' }> // never
- *
- * type R = $SelectInvert<string | undefined, undefined> // undefined
- * ```
- *
- * 🔢 *customize*:
- *
- * Disable distribution of union types.
- *
- * ```ts
- * type R = $SelectInvert<undefined | 1, undefined> // boolean
- * type R = $SelectInvert<undefined | 1, undefined, { distributive: false }> // false
- * ```
- *
- * 🔢 *customize*
- *
- * Use unique branch identifiers to allow precise processing of the result.
- *
- * @example
- * ```ts
- * type R = $SelectInvert<undefined, undefined, $SelectionBranch> // $Then
- * type R = $SelectInvert<string, undefined, $SelectionBranch> // $Else
- * ```
- */
-export type $SelectInvert<T, U, $O extends $SelectInvert.$Options = {}> = $SpecialType<
-	T,
-	{
-		$any: $ResolveBranch<T, $O, [$Any, $Then]>
-		$unknown: $ResolveBranch<T, $O, [$Unknown, $Then]>
-		$never: $ResolveBranch<T, $O, [$Never, $Then]>
-		$else: $IsDistributive<$O> extends true ? $SelectInvert._D<T, U, $O> : $SelectInvert._N<T, U, $O>
-	}
->
-
-export namespace $SelectInvert {
-	export type $Options = $SelectionOptions & $DistributiveOptions & $InputOptions<$Any | $Unknown | $Never>
-	export type $Default = $SelectionPredicate & $DistributiveDefault
-	export type $Branch = $SelectionBranch & $DistributiveDefault
-	export type _D<T, U, $O extends $SelectInvert.$Options> = T extends U
-		? $ResolveBranch<T, $O, [$Else]>
-		: $ResolveBranch<T, $O, [$Then]>
-	export type _N<T, U, $O extends $SelectInvert.$Options> = [T] extends [U]
-		? $ResolveBranch<T, $O, [$Else]>
-		: $ResolveBranch<T, $O, [$Then]>
-}

package/src/type_plus/branch/$select_invert_strict.ts

@@ -1,83 +0,0 @@
-import type { $Any } from '../../any/any.js'
-import type { $Never } from '../../never/never.js'
-import type { $Unknown } from '../../unknown/unknown.js'
-import type { $SpecialType } from '../$special_type.js'
-import type { $DistributiveDefault, $DistributiveOptions } from './$distributive.js'
-import type { $InputOptions } from './$input_options.js'
-import type { $IsDistributive } from './$is_distributive.js'
-import type { $ResolveBranch } from './$resolve_branch.js'
-import type { $Else, $SelectionBranch, $SelectionPredicate, $Then } from './$selection.js'
-import type { $SelectionOptions } from './$selection_options.js'
-
-/**
- * 🎭 *predicate*
- * ㊙️ *internal*
- *
- * Validate if `T` is `U`.
- *
- * @example
- * ```ts
- * type R = $SelectInvertStrict<undefined, undefined> // true
- *
- * type R = $SelectInvertStrict<never, undefined> // false
- * type R = $SelectInvertStrict<unknown, undefined> // false
- * type R = $SelectInvertStrict<string | boolean, undefined> // false
- *
- * type R = $SelectInvertStrict<string | undefined, undefined> // boolean
- * ```
- *
- * 🔢 *customize*
- *
- * Filter to ensure `T` is `U`, otherwise returns `never`.
- *
- * @example
- * ```ts
- * type R = $SelectInvertStrict<undefined, undefined, { selection: 'filter' }> // undefined
- *
- * type R = $SelectInvertStrict<never, undefined, { selection: 'filter' }> // never
- * type R = $SelectInvertStrict<unknown, undefined, { selection: 'filter' }> // never
- * type R = $SelectInvertStrict<string | boolean, undefined, { selection: 'filter' }> // never
- *
- * type R = $SelectInvertStrict<string | undefined, undefined> // undefined
- * ```
- *
- * 🔢 *customize*:
- *
- * Disable distribution of union types.
- *
- * ```ts
- * type R = $SelectInvertStrict<undefined | 1, undefined> // boolean
- * type R = $SelectInvertStrict<undefined | 1, undefined, { distributive: false }> // false
- * ```
- *
- * 🔢 *customize*
- *
- * Use unique branch identifiers to allow precise processing of the result.
- *
- * @example
- * ```ts
- * type R = $SelectInvertStrict<undefined, undefined, $SelectionBranch> // $Then
- * type R = $SelectInvertStrict<string, undefined, $SelectionBranch> // $Else
- * ```
- */
-export type $SelectInvertStrict<T, U, $O extends $SelectInvertStrict.$Options = {}> = $SpecialType<
-	T,
-	{
-		$any: $ResolveBranch<T, $O, [$Any, $Then]>
-		$unknown: $ResolveBranch<T, $O, [$Unknown, $Then]>
-		$never: $ResolveBranch<T, $O, [$Never, $Then]>
-		$else: $IsDistributive<$O> extends true ? $SelectInvertStrict._D<T, U, $O> : $SelectInvertStrict._N<T, U, $O>
-	}
->
-
-export namespace $SelectInvertStrict {
-	export type $Options = $SelectionOptions & $DistributiveOptions & $InputOptions<$Any | $Unknown | $Never>
-	export type $Default = $SelectionPredicate & $DistributiveDefault
-	export type $Branch = $SelectionBranch & $DistributiveDefault
-	export type _D<T, U, $O extends $SelectInvertStrict.$Options> = T extends U
-		? $ResolveBranch<T, $O, [$Else]>
-		: $ResolveBranch<T, $O, [$Then]>
-	export type _N<T, U, $O extends $SelectInvertStrict.$Options> = [T, U] extends [U, T]
-		? $ResolveBranch<T, $O, [$Else]>
-		: $ResolveBranch<T, $O, [$Then]>
-}

package/src/type_plus/branch/$select_strict.ts

@@ -1,88 +0,0 @@
-import type { $Any } from '../../any/any.js'
-import type { $Never } from '../../never/never.js'
-import type { $Unknown } from '../../unknown/unknown.js'
-import type { $SpecialType } from '../$special_type.js'
-import type { $DistributiveDefault, $DistributiveOptions } from './$distributive.js'
-import type { $InputOptions } from './$input_options.js'
-import type { $IsDistributive } from './$is_distributive.js'
-import type { $ResolveBranch } from './$resolve_branch.js'
-import type { $Else, $SelectionBranch, $SelectionPredicate, $Then } from './$selection.js'
-import type { $SelectionOptions } from './$selection_options.js'
-
-/**
- * 🎭 *predicate*
- * ㊙️ *internal*
- *
- * Validate if `T` is `U`.
- *
- * @example
- * ```ts
- * type R = $SelectStrict<undefined, undefined> // true
- *
- * type R = $SelectStrict<never, undefined> // false
- * type R = $SelectStrict<unknown, undefined> // false
- * type R = $SelectStrict<string | boolean, undefined> // false
- *
- * type R = $SelectStrict<string | undefined, undefined> // boolean
- * ```
- *
- * 🔢 *customize*
- *
- * Filter to ensure `T` is `U`, otherwise returns `never`.
- *
- * @example
- * ```ts
- * type R = $SelectStrict<undefined, undefined, { selection: 'filter' }> // undefined
- *
- * type R = $SelectStrict<never, undefined, { selection: 'filter' }> // never
- * type R = $SelectStrict<unknown, undefined, { selection: 'filter' }> // never
- * type R = $SelectStrict<string | boolean, undefined, { selection: 'filter' }> // never
- *
- * type R = $SelectStrict<string | undefined, undefined> // undefined
- * ```
- *
- * 🔢 *customize*:
- *
- * Disable distribution of union types.
- *
- * ```ts
- * type R = $SelectStrict<undefined | 1, undefined> // boolean
- * type R = $SelectStrict<undefined | 1, undefined, { distributive: false }> // false
- * ```
- *
- * 🔢 *customize*
- *
- * Use unique branch identifiers to allow precise processing of the result.
- *
- * @example
- * ```ts
- * type R = $SelectStrict<undefined, undefined, $SelectionBranch> // $Then
- * type R = $SelectStrict<string, undefined, $SelectionBranch> // $Else
- * ```
- */
-export type $SelectStrict<T, U, $O extends $SelectStrict.$Options = {}> = $SpecialType<
-	T,
-	{
-		$any: $ResolveBranch<T, $O, [$Any, $Else]>
-		$unknown: $ResolveBranch<T, $O, [$Unknown, $Else]>
-		$never: $ResolveBranch<T, $O, [$Never, $Else]>
-		$else: $SelectStrict._Else<T, U, $O>
-	}
->
-
-export namespace $SelectStrict {
-	export type $Options = $SelectionOptions & $DistributiveOptions & $InputOptions<$Any | $Unknown | $Never>
-	export type $Default = $SelectionPredicate & $DistributiveDefault
-	export type $Branch = $SelectionBranch & $DistributiveDefault
-	export type _Else<T, U, $O extends $SelectStrict.$Options> = $IsDistributive<$O> extends true
-		? _D<T, U, $O>
-		: _N<T, U, $O>
-	export type _D<T, U, $O extends $SelectStrict.$Options> = T extends U
-		? U extends T
-			? $ResolveBranch<T, $O, [$Then]>
-			: $ResolveBranch<T, $O, [$Else]>
-		: $ResolveBranch<T, $O, [$Else]>
-	export type _N<T, U, $O extends $SelectStrict.$Options> = [T, U] extends [U, T]
-		? $ResolveBranch<T, $O, [$Then]>
-		: $ResolveBranch<T, $O, [$Else]>
-}

package/src/type_plus/branch/$selection.ts

@@ -1,134 +0,0 @@
-import type { $Branch } from './$branch.js'
-import type { $SelectionOptions } from './$selection_options.js'
-
-export type $Then = $Branch<'$then'>
-export type $Else = $Branch<'$else'>
-
-export namespace $Then {
-	export type $Branch = {
-		$else: $Then
-	}
-}
-
-export namespace $Else {
-	export type $Branch = {
-		$else: $Else
-	}
-}
-
-/**
- * 🧰 *type util*
- *
- * Invert the selection branch.
- *
- * i.e.
- * - `$Then` -> `$Else`
- * - `$Else` -> `$Then`
- */
-export type $InvertSelection<Branch extends $Then | $Else> = Branch extends $Then ? $Else : $Then
-
-/**
- * 🧰 *type util*
- *
- * Branch option for selection logic.
- * It allows finely customizing the behavior of your type.
- *
- * Using this as the default value of your `$Options` is the recommended best practice.
- *
- * This encourage consumer of your type to use conditional type to avoid performance issues.
- *
- * @example
- * ```ts
- * type YourType<
- *   T,
- *   $Options extends YourType.$Options = YourType.$Branch
- * > = ...
- *
- * namespace YourType {
- *   export type $Options = $SelectionOptions
- *   export type $Branch = $SelectionBranch
- * }
- *
- * type R = YourType<T> extends infer R
- *   ? R extends $Then ? HandleThen
- *   : R extends $Else ? HandleElse
- *   : never
- * ```
- */
-export type $SelectionBranch<$O extends $SelectionOptions = {}> = {
-	$then: $Then
-	$else: $Else
-} & $O
-
-/**
- * 🧰 *type util*
- *
- * Default Options for filter selection logic.
- *
- * `filter` means the logic returns `T` when the condition is met,
- * and returns `never` otherwise.
- *
- * @example
- * ```ts
- * type YourType<
- *   T,
- *   Options extends YourType.$Options = YourType.$Default> = ...
- *
- * namespace YourType {
- *   export type $Options = $SelectionOptions
- *   export type $Default = $SelectionFilter
- * }
- *
- * type R = YourType<ThenType> // ThenType
- * type X = YourType<ElseType> // never
- * ```
- */
-export type $SelectionFilter<T> = {
-	selection: 'filter'
-	$then: T
-	$else: never
-}
-
-/**
- * 🧰 *type util*
- *
- * Default Options for predicate selection logic.
- *
- * `predicate` means the logic returns `true` or `false` depending on the condition.
- *
- * @example
- * ```ts
- * type YourType<
- *   T,
- *   Options extends YourType.$Options = YourType.$Default> = ...
- *
- * namespace YourType {
- *   export type $Options = $SelectionOptions
- *   export type $Default = $SelectionPredicate
- * }
- *
- * type R = YourType<ThenType> // true
- * type X = YourType<ElseType> // false
- * ```
- */
-export type $SelectionPredicate = {
-	$then: true
-	$else: false
-}
-
-/**
- * 🧰 *type util*
- *
- * Flip the selection options.
- *
- * @example
- * ```ts
- * type IsBoolean<T, $Options = $SelectionOptions> = ...
- *
- * type IsNotBoolean<T, $Options = $SelectionOptions> = IsBoolean<T, $FlipSelection<$Options>>
- * ```
- */
-export type $FlipSelection<$Options extends $SelectionOptions> = {
-	$then: $Options['$else']
-	$else: $Options['$then']
-} & Omit<$Options, '$then' | '$else'>

package/src/type_plus/branch/$selection_options.ts

@@ -1,36 +0,0 @@
-/**
- * 🧰 *type util*
- *
- * Options for selection (if-then-else) logic.
- *
- * The word "selection" refers to the basic elements in structural programming:
- * sequence, selection, and iteration.
- *
- * @example
- * ```ts
- * type YourType<
- *   T,
- *   $Options extends YourType.$Options = YourType.$Branch
- * > = ...
- *
- * namespace YourType {
- *   export type $Options = $SelectionOptions
- *   export type $Branch = $SelectionBranch
- * }
- * ```
- */
-export type $SelectionOptions = {
-	/**
-	 * Specifies which default selection logic to use.
-	 *
-	 * `filter` returns `T` when the condition is met,
-	 * and returns `never` otherwise.
-	 *
-	 * `predicate` returns boolean depends on the condition.
-	 *
-	 * Note that setting `$then` and `$else` overrides the default selection logic.
-	 */
-	selection?: 'predicate' | 'filter' | undefined
-	$then?: unknown
-	$else?: unknown
-}

package/src/type_plus/readme.md

@@ -1,25 +0,0 @@
-# type-plus utilities
-
-This folder contains utilities that is used within [type-plus].
-
-## [$Type](./type.ts)
-
-`$Type<T, M = '', V = unknown>`
-
-🧰 *type util*
-
-Special `type-plus` interface to represent unique types with messages.
-
-This is used in [type-plus] for errors, branches, etc.
-
-## [$Error](./error.ts)
-
-`$Error<M, V = unknown>`
-
-🧰 *type util*
-
-A basic type-level error.
-
-You can use this for some ad-hoc errors.
-
-[type-plus]: https://github.com/unional/type-plus

package/src/unknown/unknown.ts

@@ -1,57 +0,0 @@
-import type { $Branch } from '../type_plus/branch/$branch.js'
-
-/**
- * 🧰 *type util*
- *
- * A special branch for `unknown` check to represent the value is `unknown`.
- */
-export type $Unknown = $Branch<'$unknown'>
-
-export namespace $Unknown {
-	/**
-	 * 🧰 *type util*
-	 *
-	 * Options for specifically handling the type `unknown`.
-	 *
-	 * @example
-	 * ```ts
-	 * type YourType<
-	 *   T,
-	 *   $Options extends YourType.$Options = YourType.$Default
-	 * > = ...
-	 *
-	 * namespace YourType {
-	 *   export type $Options = $Unknown.$Options
-	 *   export type $Branch = $Unknown.$Branch
-	 * }
-	 * ```
-	 */
-	export type $Options = {
-		$unknown?: unknown
-	}
-
-	/**
-	 * 🧰 *type util*
-	 *
-	 * Branch option for specifically handling the type `unknown`.
-	 *
-	 * Use this to finely customize the behavior of your type.
-	 *
-	 * ```ts
-	 * type YourType<
-	 *   T,
-	 *   $Options extends YourType.$Options = YourType.$Default
-	 * > = ...
-	 *
-	 * namespace YourType {
-	 *   export type $Options = $Unknown.$Options
-	 *   export type $Branch = $Unknown.$Branch
-	 * }
-	 *
-	 * type R = YourType<T, YourType.$Branch> extends $Unknown ? HandleUnknown : HandleOthers
-	 * ```
-	 */
-	export type $Branch = {
-		$unknown: $Unknown
-	}
-}