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

package/esm/type_plus/branch/$selection_options.d.ts

@@ -1,37 +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;
-};
-//# sourceMappingURL=$selection_options.d.ts.map

package/esm/type_plus/branch/$selection_options.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"$selection_options.d.ts","sourceRoot":"","sources":["../../../src/type_plus/branch/$selection_options.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC/B;;;;;;;;;OASG;IACH,SAAS,CAAC,EAAE,WAAW,GAAG,QAAQ,GAAG,SAAS,CAAA;IAC9C,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,KAAK,CAAC,EAAE,OAAO,CAAA;CACf,CAAA"}

package/esm/type_plus/branch/$selection_options.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=$selection_options.js.map

package/esm/type_plus/branch/$selection_options.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"$selection_options.js","sourceRoot":"","sources":["../../../src/type_plus/branch/$selection_options.ts"],"names":[],"mappings":""}

package/esm/unknown/unknown.d.ts

@@ -1,55 +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 declare 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
-     * }
-     * ```
-     */
-    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
-     * ```
-     */
-    type $Branch = {
-        $unknown: $Unknown;
-    };
-}
-//# sourceMappingURL=unknown.d.ts.map

package/esm/unknown/unknown.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"unknown.d.ts","sourceRoot":"","sources":["../../src/unknown/unknown.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAA;AAE7D;;;;GAIG;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC,CAAA;AAE1C,yBAAiB,QAAQ,CAAC;IACzB;;;;;;;;;;;;;;;;;OAiBG;IACH,KAAY,QAAQ,GAAG;QACtB,QAAQ,CAAC,EAAE,OAAO,CAAA;KAClB,CAAA;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,KAAY,OAAO,GAAG;QACrB,QAAQ,EAAE,QAAQ,CAAA;KAClB,CAAA;CACD"}

package/esm/unknown/unknown.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=unknown.js.map

package/esm/unknown/unknown.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"unknown.js","sourceRoot":"","sources":["../../src/unknown/unknown.ts"],"names":[],"mappings":""}

package/src/any/any.ts

@@ -1,46 +0,0 @@
-import type { $Branch } from '../type_plus/branch/$branch.js'
-
-export type $Any = $Branch<'$any'>
-
-export namespace $Any {
-	/**
-	 * 🧰 *type util*
-	 *
-	 * Options for specifically handling the type `any`.
-	 *
-	 * @example
-	 * ```ts
-	 * type YourType<
-	 *   T,
-	 *   $Options extends YourType.$Options = YourType.$Default
-	 * > = ...
-	 *
-	 * namespace YourType {
-	 *   export type $Options = $AnyOptions
-	 * }
-	 * ```
-	 */
-	export type $Options = { $any?: unknown }
-	/**
-	 * 🧰 *type util*
-	 *
-	 * Branch option for specifically handling the type `any`.
-	 *
-	 * 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 = $Any.$Options
-	 *   export type $Branch = $Any.$Branch
-	 * }
-	 *
-	 * type R = YourType<T, YourType.$Branch> extends $Any ? HandleAny : HandleOthers
-	 * ```
-	 */
-	export type $Branch = { $any: $Any }
-}

package/src/binary/Bit.ts

@@ -1,6 +0,0 @@
-export type Bit = 0 | 1
-
-export type BitNot<X extends Bit> = X extends 0 ? 1 : 0
-export type BitAnd<A extends Bit, B extends Bit> = A extends 1 ? (B extends 1 ? 1 : 0) : 0
-export type BitOr<A extends Bit, B extends Bit> = A extends 1 ? 1 : B extends 1 ? 1 : 0
-export type BitXor<A extends Bit, B extends Bit> = A extends 1 ? BitNot<B> : B

package/src/binary/index.ts

@@ -1,2 +0,0 @@
-export * as B from './_binary.js'
-export * as Bit from './_binary.js'

package/src/never/never.ts

@@ -1,78 +0,0 @@
-import type { $Branch } from '../type_plus/branch/$branch.js'
-
-/**
- * 🧰 *type util*
- *
- * A special branch type to indicate the type is `never`.
- */
-export type $Never = $Branch<'$never'>
-
-export namespace $Never {
-	/**
-	 * 🧰 *type util*
-	 *
-	 * `$Never.$Options` enables customizing the behavior of the `$never` branch.
-	 *
-	 * The `$never` branch is used to handle when the input type is `never`.
-	 *
-	 * @example
-	 * ```ts
-	 * type YourType<
-	 *   T,
-	 *   $Options extends YourType.$Options = YourType.$Default
-	 * > = ...
-	 *
-	 * namespace YourType {
-	 *   export type $Options = $Never.$Options
-	 *   export type $Branch = $Never.$Branch
-	 * }
-	 * ```
-	 */
-	export type $Options = {
-		$never?: unknown
-	}
-	/**
-	 * 🧰 *type util*
-	 *
-	 * `$Never.$Branch` is the branch option for the `$never` branch.
-	 *
-	 * It sets the value to `$Never`,
-	 * so that the branch can be uniquely identified and handled.
-	 *
-	 * Use this to allow the consumer to customize the behavior of your type.
-	 *
-	 * @example
-	 * ```ts
-	 * type YourType<T, $O extends $NeverOptions> = NeverType<T> extends infer R
-	 *   ? R extends $Never
-	 *     ? $ResolveOptions<[$O['$never'], never]>
-	 *     : HandleOtherBranches<R> // R is narrowed
-	 *   : never
-	 *
-	 * type R = YourType<T, $Never.$Branch> extends $Never ? HandleNever : HandleOthers
-	 * ```
-	 */
-	export type $Branch = {
-		$never: $Never
-	}
-
-	/**
-	 * 🧰 *type util*
-	 *
-	 * Default option for the `$never` branch.
-	 *
-	 * Unsurprisingly, defaulting `$never` to `never`.
-	 */
-	export type $Default = {
-		$never: never
-	}
-}
-
-/**
- * 🧰 *type util*
- *
- * `$NotNever` is a special branch type to indicate the type is not `never`.
- *
- * It is used in [`NeverType`](./never_type.ts).
- */
-export type $NotNever = $Branch<'$not_never'>

package/src/predicates/logical.ts

@@ -1,19 +0,0 @@
-export type And<A extends boolean, B extends boolean, Then = true, Else = false> = A extends true
-	? B extends true
-		? Then
-		: Else
-	: Else
-
-export type Or<A extends boolean, B extends boolean, Then = true, Else = false> = A extends true
-	? Then
-	: B extends true
-		? Then
-		: Else
-
-export type Not<X extends boolean, Then = true, Else = false> = X extends true ? Else : Then
-
-export type Xor<A extends boolean, B extends boolean, Then = true, Else = false> = A extends Then
-	? Not<B>
-	: B extends true
-		? Then
-		: Else

package/src/type/readme.md

@@ -1,36 +0,0 @@
-# type
-
-General type utilities.
-
-## Failed
-
-`Failed<Msg>` is a type to describe a failure.
-
-Use the same concept to create your own failure types.
-
-```ts
-import { type Failed } from 'type-plus'
-
-type YourComplexType<A,B,C> = A extends B ?
-  ... // and many more hard work later...
-  : Failed<'you are doing something wrong!'>
-```
-
-[![Just Code: I failed][failed-type]][failed-type-url]
-
-## NoInfer
-
-`NoInfer<T>` is a type to prevent type inference.
-
-```ts
-import { type NoInfer } from 'type-plus'
-
- function assertEqual<T>(a: T, b: NoInfer<T>) {
-   return a === b
- }
-
- function stub<T>(v: RecursivePartial<NoInfer<T>>): T { return v }
-```
-
-[failed-type]: https://img.youtube.com/vi/3pEXVe6KJO4/0.jpg
-[failed-type-url]: https://www.youtube.com/live/3pEXVe6KJO4

package/src/type_plus/$equality.ts

@@ -1,12 +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 { $DistributiveOptions } from './branch/$distributive.js'
-import type { $InputOptions } from './branch/$input_options.js'
-import type { $SelectionBranch } from './branch/$selection.js'
-import type { $SelectionOptions } from './branch/$selection_options.js'
-
-export namespace $Equality {
-	export type $Options = $SelectionOptions & $DistributiveOptions & $InputOptions<$Any | $Unknown | $Never>
-	export type $Branch<$O extends $SelectionOptions = {}> = $SelectionBranch<$O>
-}

package/src/type_plus/$error.ts

@@ -1,8 +0,0 @@
-import type { $Type } from './$type.js'
-
-/**
- * 🧰 *type util*
- *
- * A basic type-level error.
- */
-export type $Error<M extends string, T = unknown> = M extends any ? $Type<'error', M, T> : never

package/src/type_plus/$merge_options.ts

@@ -1,8 +0,0 @@
-/**
- * 🧰 *type util*
- *
- * Merge type options.
- */
-export type $MergeOptions<$O extends Record<string, any>, $V extends { [k in keyof $O]?: unknown }> = {
-	[k in Exclude<keyof $O, keyof $V>]: $O[k]
-} & $V

package/src/type_plus/$special_type.ts

@@ -1,26 +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 { $BranchOptions } from './branch/$branch.js'
-import type { $InputOptions } from './branch/$input_options.js'
-import type { $ResolveBranch } from './branch/$resolve_branch.js'
-import type { $Else, $SelectionBranch, $Then } from './branch/$selection.js'
-import type { $SelectionOptions } from './branch/$selection_options.js'
-
-/**
- * 🧰 *type util*
- *
- * A type utility to handle special types: `any`, `unknown`, and `never`.
- */
-export type $SpecialType<T, $O extends $SpecialType.$Options> = 0 extends 1 & T
-	? $ResolveBranch<T, $O, [$Any, $Then]>
-	: [T, unknown] extends [unknown, T]
-		? $ResolveBranch<T, $O, [$Unknown, $Then]>
-		: [T, never] extends [never, T]
-			? $ResolveBranch<T, $O, [$Never, $Then]>
-			: $ResolveBranch<T, $O, [$Else]>
-
-export namespace $SpecialType {
-	export type $Options = $SelectionOptions & $InputOptions<$Any | $Unknown | $Never>
-	export type $Branch = $SelectionBranch & $BranchOptions<$Any | $Unknown | $Never>
-}

package/src/type_plus/$type.ts

@@ -1,10 +0,0 @@
-/**
- * 🧰 *type util*
- *
- * Special `type-plus` interface to represent unique types with messages.
- */
-export interface $Type<T extends string, M extends string = '', V = unknown> {
-	type: T
-	message: M
-	value: V
-}

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

@@ -1,19 +0,0 @@
-/**
- * 🧰 *type util*
- *
- * Options for to control if the type is distributive.
- */
-export type $DistributiveOptions = {
-	distributive?: boolean | undefined
-}
-
-/**
- * 🧰 *type util*
- *
- * Default options for `distributive` behavior.
- *
- * By default it is `true`.
- */
-export type $DistributiveDefault = {
-	distributive: true
-}

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

@@ -1,28 +0,0 @@
-import type { $ResolveOptions } from '../$resolve_options.js'
-import type { $InputOptions } from './$input_options.js'
-import type { $Else, $Then } from './$selection.js'
-
-/**
- * 🧰 *type util*
- *
- * `$Exact.$Options` enables customizing the behavior of the `$exact` branch.
- *
- * The `$exact` branch is used to handle when it is an exact comparison.
- */
-export type $ExactOptions = {
-	exact?: boolean | undefined
-}
-
-export type $ExactDefault = {
-	exact: false
-}
-
-export type $IsExact<$Opt extends $ExactOptions, $O extends $InputOptions<$Then | $Else> = {}> = $ResolveOptions<
-	[$Opt['exact'], $ExactDefault]
-> extends true
-	? '$then' extends keyof $O
-		? $O['$then']
-		: true
-	: '$else' extends keyof $O
-		? $O['$else']
-		: false

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

@@ -1,15 +0,0 @@
-import type { $ResolveOptions } from '../$resolve_options.js'
-import type { $DistributiveDefault, $DistributiveOptions } from './$distributive.js'
-import type { $InputOptions } from './$input_options.js'
-import type { $Else, $Then } from './$selection.js'
-
-export type $IsDistributive<
-	$Options extends $DistributiveOptions,
-	$O extends $InputOptions<$Then | $Else> = {},
-> = $ResolveOptions<[$Options['distributive'], $DistributiveDefault['distributive']]> extends true
-	? '$then' extends keyof $O
-		? $O['$then']
-		: true
-	: '$else' extends keyof $O
-		? $O['$else']
-		: false

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

@@ -1,22 +0,0 @@
-import type { $Type } from '../$type.js'
-
-/**
- * 🧰 *type util*
- *
- * A utility type to override the behavior of a branch.
- *
- * ```ts
- * type R = IsString<any, { $any: DoThisInstead }> // DoThisInstead
- * type R = IsString<any, { $any: $Override<DoThisInstead> }> // use DoThisInstead as the sole branch logic
- * ```
- */
-export type $Override<T> = $Type<'override', 'override', T>
-
-export namespace $Override {
-	/**
-	 * 🧰 *type util*
-	 *
-	 * A utility type to unwrap an override.
-	 */
-	export type $Unwrap<T> = T extends $Override<infer U> ? U : T
-}

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

@@ -1,71 +0,0 @@
-import type { $Branch } from './$branch.js'
-import type { $Override } from './$override.js'
-import type { $Else, $Then } from './$selection.js'
-
-/**
- * 🧰 *type util*
- *
- * Resolve option value based on list of branches.
- * It returns the first branch value that is specified in the option,
- * otherwise will return the default value.
- *
- * Since this is an type utility,
- * it does not perform extensive validations.
- * Please check the description of each input below for information.
- *
- * @typeparam $O Should be a Record, not any, unknown, or never
- * @typeparam $B Tuple of branches with at least one entry.
- * @typeparam $D When specified, resolve the branch in override mode.
- * If no branch in `$B` is resolved to `$Override<X>`, `$D` will be returned.
- */
-export type $ResolveBranch<
-	T,
-	$O extends Record<string, any>,
-	$B extends Array<$Branch<any> | unknown>,
-	$D = unknown,
-> = [unknown, $D] extends [$D, unknown]
-	? $B extends [infer B]
-		? $ResolveBranch._Last<T, $O, B>
-		: $B extends [infer B, ...infer Bs extends Array<$Branch<any> | unknown>]
-			? $ResolveBranch._<$ResolveBranch<T, $O, Bs>, $O, B>
-			: never
-	: $ResolveBranch._Override<$D, $O, $B>
-
-export namespace $ResolveBranch {
-	export type _Override<$D, $O extends Record<string, any>, $B extends Array<$Branch<any> | unknown>> = $B extends [
-		infer B,
-	]
-		? _OLast<$D, $O, B>
-		: $B extends [infer B, ...infer Bs extends Array<$Branch<any> | unknown>]
-			? _OLast<_Override<$D, $O, Bs>, $O, B>
-			: never
-
-	export type _OLast<$D, $O extends Record<string, any>, $B extends $Branch<any> | unknown> = $B extends $Branch<any>
-		? $B['value'] extends keyof $O
-			? $O[$B['value']] extends infer R extends $Override<any>
-				? [R, never] extends [never, R]
-					? $D
-					: R['value']
-				: $D
-			: $D
-		: $D
-
-	export type _<T, $O extends Record<string, any>, $B> = $B extends $Branch<any>
-		? $B['value'] extends keyof $O
-			? $Override.$Unwrap<$O[$B['value']]>
-			: T
-		: T
-	export type _Last<T, $O extends Record<string, any>, $B> = $B extends $Then
-		? '$then' extends keyof $O
-			? $Override.$Unwrap<$O['$then']>
-			: $O['selection'] extends 'filter'
-				? T
-				: true
-		: $B extends $Else
-			? '$else' extends keyof $O
-				? $Override.$Unwrap<$O['$else']>
-				: $O['selection'] extends 'filter'
-					? never
-					: false
-			: _<T, $O, $B>
-}

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

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