type-plus 7.6.0 → 8.0.0-beta.0

package/ts/object/merge.ts

@@ -0,0 +1,122 @@
+import type { IsAny } from '../any/any_type.js'
+import type { NonComposableTypes } from '../composable_types.js'
+import type { IsNever, NotNeverType } from '../never/never_type.js'
+import type { IsLiteral } from '../predicates/literal.js'
+import type { Or } from '../predicates/logical.js'
+import type { $Never } from '../type_plus/cases.js'
+import type { AnyRecord } from './any_record.js'
+import type { IsDisjoint } from './IsDisjoint.js'
+import type { KeyTypes } from './KeyTypes.js'
+import type { OptionalKeys } from './OptionalKeys.js'
+
+/**
+ * ⚗️ *transform*
+ * 🔢 *customizable*
+ *
+ * Merges type `A` and type `B`.
+ *
+ * This type performs the same operations as `{ ...a, ...b }` but at the type level.
+ *
+ * It handles cases like A or B are `Record`,
+ * joining between required and optional props, etc.
+ */
+export type Merge<A extends AnyRecord, B extends AnyRecord, Options = Merge.DefaultOptions> = Or<
+	IsAny<A>,
+	IsAny<B>,
+	any,
+	Or<
+		IsNever<A>,
+		IsNever<B>,
+		never,
+		IsDisjoint<A, B> extends true
+		? A & B
+		: ([keyof A, keyof B] extends [infer KA extends KeyTypes, infer KB extends KeyTypes]
+			? (IsLiteral<KA> extends true
+				? (IsLiteral<KB> extends true
+					? ([OptionalKeys<A>, OptionalKeys<B>] extends [infer PKA extends KeyTypes, infer PKB extends KeyTypes]
+						?
+						// property is optional when both A[k] and B[k] are optional
+						NotNeverType<
+							PKA & PKB,
+							{ [k in PKA & PKB]?: A[k] | B[k] },
+							unknown
+						> &
+						// properties only in A excluding partials is A[k]
+						NotNeverType<
+							Exclude<KA, PKA | KB>,
+							{ [k in Exclude<KA, PKA | KB>]: A[k] },
+							unknown
+						> &
+						// properties only in B excluding partials is B[k]
+						NotNeverType<
+							Exclude<KB, PKB>,
+							{ [k in Exclude<KB, PKB>]: B[k] },
+							unknown
+						> &
+						// properties is required in A but optional in B is unionized without undefined
+						NotNeverType<
+							Exclude<KA & PKB, PKA>,
+							{ [k in Exclude<KA & PKB, PKA>]: A[k] | Exclude<B[k], undefined> },
+							unknown
+						>
+						: never)
+					:
+					NotNeverType<
+						Exclude<KA, KA & KB>,
+						{ [k in Exclude<KA, KA & KB>]: A[k] },
+						unknown
+					> &
+					NotNeverType<
+						Exclude<KB, KA & KB>,
+						{ [k in Exclude<KB, KA & KB>]: B[k] },
+						unknown
+					> &
+					NotNeverType<
+						KA & KB,
+						{ [k in KA & KB]: A[k] | B[k] },
+						unknown
+					>
+				)
+				: (
+					IsLiteral<KB> extends true
+					? { [k in Exclude<KA, KB>]: A[k] } & { [k in keyof B]: B[k] }
+					:
+					NotNeverType<
+						Exclude<KA, KA & KB>,
+						{ [k in Exclude<KA, KA & KB>]: A[k] },
+						unknown
+					> &
+					NotNeverType<
+						Exclude<KB, KA & KB>,
+						{ [k in Exclude<KB, KA & KB>]: B[k] },
+						unknown
+					> &
+					NotNeverType<
+						KA & KB,
+						{ [k in KA & KB]: A[k] | B[k] },
+						unknown
+					>
+				))
+			: never)
+	>
+>
+
+export namespace Merge {
+	export type JoinProps<A, B> = A extends NonComposableTypes
+		? B
+		: (B extends NonComposableTypes
+			? A
+			: A & B)
+
+	export type Options = {
+		$never?: undefined
+	}
+
+	export interface DefaultOptions {
+		$never: never
+	}
+
+	export type Cases = {
+		$never: $Never
+	}
+}

package/ts/object/object_plus.ts

@@ -0,0 +1 @@
+export * from './merge.js'

package/ts/object/omit.ts

@@ -1,5 +1,5 @@
 import type { UnionKeys } from '../union_keys.js'
-import type { AnyRecord } from './AnyRecord.js'
+import type { AnyRecord } from './any_record.js'
 import type { Pick } from './pick.js'
 import { record } from './record.js'
 import { reduceByKey } from './reduceKey.js'
@@ -8,10 +8,9 @@ import { reduceByKey } from './reduceKey.js'
 // https://github.com/microsoft/TypeScript/issues/28339#issuecomment-463577347
 // type-zoo
 export type Omit<T, K extends UnionKeys<T>> = T extends T
-	? keyof T extends K
-		? // eslint-disable-next-line @typescript-eslint/ban-types
-		  {}
-		: Pick<T, Exclude<keyof T, K>>
+	? (keyof T extends K
+		? {}
+		: Pick<T, Exclude<keyof T, K>>)
 	: never
 
 /**

package/ts/object/optional_key.ts

@@ -1,5 +1,5 @@
 
-import type { AnyRecord } from './AnyRecord.js'
+import type { AnyRecord } from './any_record.js'
 import type { KeyTypes } from './KeyTypes.js'
 
 /**

package/ts/object/pick.ts

@@ -1,5 +1,5 @@
 import type { UnionKeys } from '../union_keys.js'
-import type { AnyRecord } from './AnyRecord.js'
+import type { AnyRecord } from './any_record.js'
 import { record } from './record.js'
 import { reduceByKey } from './reduceKey.js'
 

package/ts/object/readme.md

@@ -58,6 +58,20 @@ import type { OptionalProps } from 'type-plus'
 type R = OptionalProps<{ a?: number; b: string }> // { a?: number }
 ```
 
+## [ObjectPlus.Merge](./merge.ts)
+
+`Merge<A, B, Options = { }>`
+
+⚗️ *transform*
+🔢 *customizable*
+
+Merges type `A` and type `B`.
+
+This type performs the same operations as `{ ...a, ...b }` but at the type level.
+
+It handles cases like A or B are `Record`,
+joining between required and optional props, etc.
+
 ## References
 
 - [Handbook]

package/ts/object/record.ts

@@ -1,5 +1,5 @@
 import type { Widen } from '../utils/index.js'
-import type { AnyRecord } from './AnyRecord.js'
+import type { AnyRecord } from './any_record.js'
 import type { KeyTypes } from './KeyTypes.js'
 
 /**

package/ts/object/recursive_partial.ts

@@ -2,7 +2,7 @@
 
 import type { AnyFunction } from '../function/any_function.js'
 import type { ExtractFunction } from '../index.js'
-import type { AnyRecord } from './AnyRecord.js'
+import type { AnyRecord } from './any_record.js'
 import type { Properties } from './properties.js'
 
 /**

package/ts/object/replaceProperty.ts

@@ -1,4 +1,4 @@
-import type { AnyRecord } from './AnyRecord.js'
+import type { AnyRecord } from './any_record.js'
 
 export type ReplaceProperty<T extends AnyRecord, K extends keyof T, V> = Omit<T, K> & { [P in K]: V }
 

package/ts/object/split.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-import type { AnyRecord } from './AnyRecord.js'
+import type { AnyRecord } from './any_record.js'
 import type { Omit } from './omit.js'
 import { reduceByKey } from './reduceKey.js'
 import type { Partial } from './Partial.js'

package/ts/tuple/common_prop_keys.ts

@@ -16,7 +16,7 @@ import type { CommonPropKeys as TupleCommonPropKeys } from './tuple_plus.common_
  * type R = CommonPropKeys<[{ a: number, c: 1 }, { b: number, c: 2 }]> // 'c'
  * ```
  *
- * @typeParam Options['caseNever'] Return type when `T` is `never`.
+ * @typeParam Options['$never'] Return type when `T` is `never`.
  * Default to `never`.
  */
 export type CommonPropKeys<

package/ts/tuple/drop.ts

@@ -17,7 +17,7 @@ import type { DropMatch as TupleDropMatch } from './tuple_plus.drop_match.js'
  * type R = DropFirst<string[]> // string[]
  * ```
  *
- * @typeParam Options['caseArray'] Return type when `T` is `Array`.
+ * @typeParam Options['$array'] Return type when `T` is `Array`.
  * Default to `T`.
  *
  * @typeParam Options['caseEmptyTuple'] Return type when `T` is an empty tuple.
@@ -27,7 +27,7 @@ export type DropFirst<
 	T extends unknown[],
 	Options extends DropFirst.Options = DropFirst.DefaultOptions<T>
 > = number extends T['length']
-	? Options['caseArray']
+	? Options['$array']
 	: T['length'] extends 0
 	? Options['caseEmptyTuple']
 	: T['length'] extends 1
@@ -38,11 +38,11 @@ export type DropFirst<
 
 export namespace DropFirst {
 	export interface Options {
-		caseArray?: unknown,
+		$array?: unknown,
 		caseEmptyTuple?: unknown,
 	}
 	export interface DefaultOptions<T> {
-		caseArray: T,
+		$array: T,
 		caseEmptyTuple: []
 	}
 }
@@ -63,7 +63,7 @@ export namespace DropFirst {
  * type R = DropLast<string[]> // string[]
  * ```
  *
- * @typeParam Options['caseArray'] Return type when `T` is `Array`.
+ * @typeParam Options['$array'] Return type when `T` is `Array`.
  * Default to `T`.
  *
  * @typeParam Options['caseEmptyTuple'] Return type when `T` is an empty tuple.
@@ -73,7 +73,7 @@ export type DropLast<
 	T extends unknown[],
 	Cases extends DropLast.Options = DropLast.DefaultOptions<T>
 > = number extends T['length']
-	? Cases['caseArray']
+	? Cases['$array']
 	: T['length'] extends 0
 	? Cases['caseEmptyTuple']
 	: T['length'] extends 1
@@ -85,11 +85,11 @@ export type DropLast<
 
 export namespace DropLast {
 	export interface Options {
-		caseArray?: unknown,
+		$array?: unknown,
 		caseEmptyTuple?: unknown,
 	}
 	export interface DefaultOptions<T> {
-		caseArray: T,
+		$array: T,
 		caseEmptyTuple: []
 	}
 }

package/ts/tuple/readme.md

@@ -106,7 +106,7 @@ Overridable cases:
 
 ## [CommonPropKeys](./common_prop_keys.ts#l22)
 
-`CommonPropKeys<T extends Record[], Options = { caseNever }>`
+`CommonPropKeys<T extends Record[], Options = { $never }>`
 
 ⚗️ *transform*
 🔢 *customizable*
@@ -120,15 +120,15 @@ type R = CommonPropKeys<[{ a: 1, c: 1 }, { b: 1, c: 2 }]> // 'c'
 type R = CommonPropKeys<[{ a: 1 }, { b: 1 }]> // never
 type R = CommonPropKeys<Array<{ a: 1, b: 1 } | { a: 1, c: 1 }>> // 'a'
 type R = CommonPropKeys<[{ a: 1 }, { b: 1 }]> // never
-type R = CommonPropKeys<never> // caseNever: never
+type R = CommonPropKeys<never> // $never: never
 
 // customization
-type R = CommonPropKeys<never, { caseNever: 1 }> // 1
+type R = CommonPropKeys<never, { $never: 1 }> // 1
 ```
 
 ## [DropFirst](./drop.ts#l26)
 
-`DropFirst<T extends unknown[], Options = { caseArray, caseEmptyTuple }>`
+`DropFirst<T extends unknown[], Options = { $array, caseEmptyTuple }>`
 
 ⚗️ *transform*
 🔢 *customizable*
@@ -140,11 +140,11 @@ import { DropFirst } from 'type-plus'
 
 type R = DropFirst<[1, 2, 3]> // [2, 3]
 type R = DropFirst<[string]> // []
-type R = DropFirst<string[]> // caseArray: string[]
+type R = DropFirst<string[]> // $array: string[]
 type R = DropFirst<[]> // caseEmptyTuple: []
 
 // customization
-type R = DropFirst<string[], { caseArray: 1 }> // 1
+type R = DropFirst<string[], { $array: 1 }> // 1
 type R = DropFirst<[], { caseEmptyTuple: 1 }> // 1
 ```
 
@@ -162,11 +162,11 @@ import { DropLast } from 'type-plus'
 
 type R = DropLast<[1, 2, 3]> // [2, 3]
 type R = DropLast<[string]> // []
-type R = DropLast<string[]> // caseArray: string[]
+type R = DropLast<string[]> // $array: string[]
 type R = DropLast<[]> // caseEmptyTuple: []
 
 // customization
-type R = DropLast<string[], { caseArray: 1 }> // 1
+type R = DropLast<string[], { $array: 1 }> // 1
 type R = DropLast<[], { caseEmptyTuple: 1 }> // 1
 ```
 
@@ -191,7 +191,7 @@ The input type are not checked and assumed to be *tuple*.
 
 ## [TuplePlus.CommonPropKeys](./tuple_plus.common_prop_keys.ts#l22)
 
-`TuplePlus.CommonPropKeys<T extends Record[], Options = { caseNever }>`
+`TuplePlus.CommonPropKeys<T extends Record[], Options = { $never }>`
 
 ⚗️ *transform*
 🔢 *customizable*
@@ -205,10 +205,10 @@ type R = TuplePlus.CommonPropKeys<[{ a: 1, c: 1 }, { b: 1, c: 2 }]> // 'c'
 type R = TuplePlus.CommonPropKeys<[{ a: 1 }, { b: 1 }]> // never
 type R = TuplePlus.CommonPropKeys<Array<{ a: 1, b: 1 } | { a: 1, c: 1 }>> // 'a'
 type R = TuplePlus.CommonPropKeys<[{ a: 1 }, { b: 1 }]> // never
-type R = TuplePlus.CommonPropKeys<never> // caseNever: never
+type R = TuplePlus.CommonPropKeys<never> // $never: never
 
 // customization
-type R = TuplePlus.CommonPropKeys<never, { caseNever: 1 }> // 1
+type R = TuplePlus.CommonPropKeys<never, { $never: 1 }> // 1
 ```
 
 ### [TuplePlus.Filter](./tuple_plus.filter.ts)
@@ -227,7 +227,7 @@ type R = TuplePlus.Filter<[1, 2, '3'], number> // [1, 2]
 
 ### [`TuplePlus.Find`](./tuple_plus.find.ts#l51)
 
-`TuplePlus.Find<A, Criteria, Options { widen, caseArray, caseEmptyTuple, caseNever, caseNotMatch, caseWiden, caseUnionNotMatch }>`
+`TuplePlus.Find<A, Criteria, Options { widen, $array, caseEmptyTuple, $never, $notMatch, $widen, $unionNotMatch }>`
 
 🦴 *utilities*
 🔢 *customizable*
@@ -246,12 +246,12 @@ type R = TuplePlus.Find<[true, 1, 'x'], 2> // never
 
 // customization
 type R = TuplePlus.Find<[number], 1, { widen: false }> // never
-type R = TuplePlus.Find<[number], 1, { caseWiden: never }> // never
-type R = TuplePlus.Find<string[], 1, { caseArray: 2 }> // 2
+type R = TuplePlus.Find<[number], 1, { $widen: never }> // never
+type R = TuplePlus.Find<string[], 1, { $array: 2 }> // 2
 type R = TuplePlus.Find<[], 1, { caseEmptyTuple: 2 }> // 2
-type R = TuplePlus.Find<never, 1, { caseNever: 2 }> // 2
-type R = TuplePlus.Find<[string], number, { caseNotMatch: 2 }> // 2
-type R = TuplePlus.Find<[string | number], number, { caseUnionNotMatch: undefined }> // number | undefined
+type R = TuplePlus.Find<never, 1, { $never: 2 }> // 2
+type R = TuplePlus.Find<[string], number, { $notMatch: 2 }> // 2
+type R = TuplePlus.Find<[string | number], number, { $unionNotMatch: undefined }> // number | undefined
 ```
 
 ### [TuplePlus.PadStart](./tuple_plus.pad_start.ts)

package/ts/tuple/tail.ts

@@ -3,10 +3,8 @@ import type { UnionOfValues } from '../array/union_of_values.js'
 /**
  * Gets the types of a tuple except the first entry.
  */
-export type Tail<T extends any[]> = T['length'] extends 0
+export type Tail<T extends readonly unknown[]> = T['length'] extends 0
 	? never
-	: T extends [any, ...infer Tail]
-	? Tail extends UnionOfValues<T>[]
-		? Tail
-		: never
-	: T
+	: (T extends readonly [any, ...infer Tail]
+		? Tail extends UnionOfValues<T>[] ? Tail : never
+		: T)

package/ts/tuple/tuple_plus.common_prop_keys.ts

@@ -16,7 +16,7 @@ import type { Tail } from './tail.js'
  * type R = TuplePlus.CommonPropKeys<[{ a: number, c: 1 }, { b: number, c: 2 }]> // 'c'
  * ```
  *
- * @typeParam Options['caseNever'] Return type when `T` is `never`.
+ * @typeParam Options['$never'] Return type when `T` is `never`.
  * Default to `never`.
  */
 export type CommonPropKeys<
@@ -24,7 +24,7 @@ export type CommonPropKeys<
 	Options extends CommonPropKeys.Options = CommonPropKeys.DefaultOptions
 > = NeverType<
 	T,
-	Options['caseNever'],
+	Options['$never'],
 	(T['length'] extends 0
 		? never
 		: (

package/ts/tuple/tuple_plus.filter.ts

@@ -9,10 +9,10 @@
  * type R = Filter<[1, 2, '3'], true> // []
  * ```
  */
-export type Filter<T extends unknown[], Criteria> = T['length'] extends 0
+export type Filter<T extends readonly unknown[], Criteria = true> = T['length'] extends 0
 	? []
 	: (
-		T extends [infer Head, ...infer Tail]
+		T extends readonly [infer Head, ...infer Tail]
 		? (
 			Tail['length'] extends 0
 			? (

package/ts/tuple/tuple_plus.find.ts

@@ -1,6 +1,6 @@
 import type { ElementMatch } from '../array/array_plus.element_match.js'
 import type { NeverType } from '../never/never_type.js'
-import type { MergeOptions } from '../utils/options.js'
+import type { TypePlusOptions } from '../utils/options.js'
 import type { TupleType } from './tuple_type.js'
 
 /**
@@ -24,23 +24,23 @@ import type { TupleType } from './tuple_type.js'
  * With widen match, a narrowed type will match its widen type.
  * e.g. matching `1` against `number` yields `1 | undefined`
  *
- * The widen behavior can be customized by `Options['caseWiden']`
+ * The widen behavior can be customized by `Options['$widen']`
  *
- * @typeParam Options['caseArray'] return type when `A` is an array. Default to `not supported` message.
+ * @typeParam Options['$array'] return type when `A` is an array. Default to `not supported` message.
  *
  * @typeParam Options['caseEmptyTuple'] return type when `A` is an empty tuple.
  * Default to `never`.
  *
- * @typeParam Options['caseNever'] return type when `A` is `never`. Default to `never`.
+ * @typeParam Options['$never'] return type when `A` is `never`. Default to `never`.
  *
- * @typeParam Options['caseNotMatch'] Return value when `T` does not match `Criteria`.
+ * @typeParam Options['$notMatch'] Return value when `T` does not match `Criteria`.
  * Default to `never`.
  *
- * @typeParam Options['caseWiden'] return type when `T` in `A` is a widen type of `Criteria`.
+ * @typeParam Options['$widen'] return type when `T` in `A` is a widen type of `Criteria`.
  * Default to `Criteria | undefined`.
  * Set it to `never` for a more type-centric behavior
  *
- * @typeParam Options['caseUnionNotMatch'] Return value when a branch of the union `T` does not match `Criteria`.
+ * @typeParam Options['$unionNotMatch'] Return value when a branch of the union `T` does not match `Criteria`.
  * Default to `never`.
  *
  * If you want the type to behave more like JavaScript,
@@ -49,40 +49,40 @@ import type { TupleType } from './tuple_type.js'
  * Since it is a union, the result will be joined to the matched branch as union.
  */
 export type Find<
-	A extends unknown[],
+	A extends readonly unknown[],
 	Criteria,
 	Options extends Find.Options = Find.DefaultOptions<Criteria>
-> = MergeOptions<Options, Find.DefaultOptions<Criteria>> extends infer O extends Find.Options
+> = TypePlusOptions.Merge<Options, Find.DefaultOptions<Criteria>> extends infer O extends Find.Options
 	? TupleType<
 		A,
 		A['length'] extends 0
-		? O['caseEmptyTuple']
+		? O['$emptyTuple']
 		: Find.Device<A, Criteria, O>,
-		O['caseArray'],
+		O['$array'],
 		O
 	>
 	: never
 export namespace Find {
 	export type Device<
-		A extends unknown[],
+		A extends readonly unknown[],
 		Criteria,
 		Options extends Find.Options
 	> = A['length'] extends 0
-		? Options['caseNotMatch']
-		: (A extends [infer Head, ...infer Tail]
+		? Options['$notMatch']
+		: (A extends readonly [infer Head, ...infer Tail]
 			? ElementMatch<
 				Head,
 				Criteria,
-				MergeOptions<{ caseNotMatch: Device<Tail, Criteria, Options> }, Options>
+				TypePlusOptions.Merge<{ $notMatch: Device<Tail, Criteria, Options> }, Options>
 			>
 			: never)
 	export interface Options extends ElementMatch.Options, NeverType.Options {
-		caseArray?: unknown,
-		caseEmptyTuple?: unknown,
+		$array?: unknown,
+		$emptyTuple?: unknown,
 	}
 
 	export interface DefaultOptions<Criteria> extends ElementMatch.DefaultOptions<Criteria>, NeverType.DefaultOptions {
-		caseArray: 'does not support array. Please use `FindFirst` or `ArrayPlus.Find` instead.',
-		caseEmptyTuple: never,
+		$array: 'does not support array. Please use `FindFirst` or `ArrayPlus.Find` instead.',
+		$emptyTuple: never,
 	}
 }

package/ts/tuple/tuple_plus.pad_start.ts

@@ -17,16 +17,19 @@
  * PadStart<[1, 2, 3], 5> // [unknown, unknown, 1, 2, 3]
  * ```
  */
-export type PadStart<Tuple extends unknown[], MaxLength extends number, PadWith = unknown> = PadStart.Device<
-	Tuple,
-	MaxLength,
-	PadWith,
-	[]
->
+export type PadStart<
+	Tuple extends readonly unknown[],
+	MaxLength extends number,
+	PadWith = unknown> = PadStart.Device<
+		Tuple,
+		MaxLength,
+		PadWith,
+		[]
+	>
 
 export namespace PadStart {
 	export type Device<
-		Source extends unknown[],
+		Source extends readonly unknown[],
 		MaxLength extends number,
 		PadWith,
 		Result extends unknown[]
@@ -36,7 +39,7 @@ export namespace PadStart {
 			Source extends []
 			? Result
 			: (
-				Source extends [...infer Head, infer Tail]
+				Source extends readonly [...infer Head, infer Tail]
 				? (
 					[Tail, ...Result] extends infer R extends unknown[]
 					? Device<Head, R['length'], PadWith, R>
@@ -49,7 +52,7 @@ export namespace PadStart {
 			Source extends []
 			? Device<Source, MaxLength, PadWith, [PadWith, ...Result]>
 			: (
-				Source extends [...infer Head, infer Tail]
+				Source extends readonly [...infer Head, infer Tail]
 				? Device<Head, MaxLength, PadWith, [Tail, ...Result]>
 				: Source
 			)

package/ts/tuple/tuple_type.ts

@@ -5,7 +5,7 @@ import type { IsNever, NeverType } from '../never/never_type.js'
  *
  * Filter `T` to ensure it is a tuple, excluding array.
  *
- * @typeParam Cases['never'] Return type when `T` is `never`. Default to `Else`.
+ * @typeParam Cases['$never'] Return type when `T` is `never`. Default to `Else`.
  *
  * @example
  * ```ts
@@ -25,8 +25,8 @@ export type TupleType<
 	Options extends TupleType.Options = TupleType.DefaultOptions<Else>
 > = IsNever<
 	T,
-	Options['caseNever'],
-	[T] extends [any[]] ? (number extends T['length'] ? Else : Then) : Else
+	Options['$never'],
+	[T] extends [readonly any[]] ? (number extends T['length'] ? Else : Then) : Else
 >
 
 export namespace TupleType {
@@ -34,7 +34,7 @@ export namespace TupleType {
 	}
 
 	export interface DefaultOptions<Else> {
-		caseNever: Else
+		$never: Else
 	}
 }
 

package/ts/type_plus/cases.ts

@@ -0,0 +1,14 @@
+const $then = Symbol('then')
+export type $Then = typeof $then
+
+const $else = Symbol('else')
+export type $Else = typeof $else
+
+const $never = Symbol('never')
+export type $Never = typeof $never
+
+const $error = Symbol('error')
+export interface $Error<M extends string> {
+	type: typeof $error,
+	message: M
+}

package/ts/utils/options.ts

@@ -1,10 +1,29 @@
+export namespace TypePlusOptions {
+	/**
+	 * 🦴 *utilities*
+	 * ㊙️ *internal*
+	 *
+	 * Merge the input Options `I` with the default Options `D`.
+	 */
+	export type Merge<I, D> = {
+		[k in keyof D]: k extends keyof I ? I[k] : D[k]
+	}
 
-/**
- * 🦴 *utilities*
- * ㊙️ *internal*
- *
- * Merge the input Options `I` with the default Options `D`.
- */
-export type MergeOptions<I, D> = {
-	[k in keyof D]: k extends keyof I ? I[k] : D[k]
+	/**
+	 * 🦴 *utilities*
+	 * ㊙️ *internal*
+	 *
+	 * Selection (if-then-else) options.
+	 *
+	 * The word "selection" refers to the basic elements in structural programming:
+	 * sequence, selection, and iteration.
+	 */
+	export interface Selection {
+		$then?: unknown,
+		$else?: unknown,
+	}
+
+	export interface NotArray {
+		$notArray?: unknown
+	}
 }