type-plus 7.5.0 → 8.0.0-beta.0

package/ts/mix_types/merge.ts

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

@@ -38,3 +38,37 @@ 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

@@ -61,10 +61,10 @@ export namespace NeverType {
 	 * Type options when input type is `never`.
 	 */
 	export interface Options {
-		caseNever?: unknown
+		$never?: unknown
 	}
 
 	export interface DefaultOptions {
-		caseNever: never
+		$never: never
 	}
 }

package/ts/object/ANotB.ts

@@ -1,5 +1,5 @@
 import type { IsEqual } from '../equal/equal.js'
-import type { AnyRecord } from './AnyRecord.js'
+import type { AnyRecord } from './any_record.js'
 import type { IsDisjoint } from './IsDisjoint.js'
 import type { KeysWithDiffType } from './KeysWithDiffType.js'
 

package/ts/object/IsDisjoint.ts

@@ -1,5 +1,5 @@
 import type { And, Not } from '../predicates/index.js'
-import type { AnyRecord } from './AnyRecord.js'
+import type { AnyRecord } from './any_record.js'
 import type { HasKey } from './hasKey.js'
 
 /**

package/ts/object/KeysWithDiffType.ts

@@ -1,9 +1,9 @@
 import type { ValueOf } from './ValueOf.js'
 import type { IsDisjoint } from './IsDisjoint.js'
-import type { AnyRecord } from './AnyRecord.js'
+import type { AnyRecord } from './any_record.js'
 
 export type KeysWithDiffType<A extends AnyRecord, B extends AnyRecord> = IsDisjoint<A, B> extends true
 	? never
 	: ValueOf<{
-			[k in keyof A & keyof B]: A[k] extends B[k] ? never : k
-	  }>
+		[k in keyof A & keyof B]: A[k] extends B[k] ? never : k
+	}>

package/ts/object/KnownKeys.ts

@@ -8,10 +8,10 @@ import type { PrimitiveTypes } from '../primitive.js'
 export type KnownKeys<T> = T extends PrimitiveTypes
 	? never
 	: {
-			[K in keyof T]: string extends K ? never : number extends K ? never : K
-	  } extends { [_ in keyof T]: infer U }
+		[K in keyof T]: string extends K ? never : number extends K ? never : K
+	} extends { [_ in keyof T]: infer U }
 	? // eslint-disable-next-line @typescript-eslint/ban-types
-	  {} extends U
-		? never
-		: U
+	{} extends U
+	? never
+	: U
 	: never

package/ts/object/RecursiveIntersect.ts

@@ -1,4 +1,4 @@
-import type { AnyRecord } from './AnyRecord.js'
+import type { AnyRecord } from './any_record.js'
 
 /**
  * Intersect type recursively.
@@ -16,10 +16,10 @@ export type RecursiveIntersect<T, U> = T &
 		? Array<Y & U> & U
 		: T extends AnyRecord
 		? {
-				[P in keyof T]: T[P] extends Array<infer R>
-					? Array<RecursiveIntersect<R, U>> & U
-					: T[P] extends AnyRecord
-					? RecursiveIntersect<T[P], U>
-					: T[P] & U
-		  } & U
+			[P in keyof T]: T[P] extends Array<infer R>
+			? Array<RecursiveIntersect<R, U>> & U
+			: (T[P] extends AnyRecord
+				? RecursiveIntersect<T[P], U>
+				: T[P] & U)
+		} & U
 		: U)

package/ts/object/RecursiveRequired.ts

@@ -1,4 +1,4 @@
-import type { AnyRecord } from './AnyRecord.js'
+import type { AnyRecord } from './any_record.js'
 
 export type RecursiveRequired<T> = {
 	[P in keyof T]-?: T[P] extends (infer U)[]

package/ts/object/facade.ts

@@ -1,4 +1,4 @@
-import type { AnyRecord } from './AnyRecord.js'
+import type { AnyRecord } from './any_record.js'
 
 /**
  * creates a facade of the subject.

package/ts/object/hasKey.ts

@@ -1,4 +1,4 @@
-import type { AnyRecord } from './AnyRecord.js'
+import type { AnyRecord } from './any_record.js'
 
 export type HasKey<T, K, Then = true, Else = false> = K extends keyof T ? Then : Else
 

package/ts/object/index.ts

@@ -1,5 +1,5 @@
 export type { ANotB, BNotA } from './ANotB.js'
-export type { AnyRecord } from './AnyRecord.js'
+export type { AnyRecord } from './any_record.js'
 export type { ExcludePropType } from './ExcludePropType.js'
 export type { IsDisjoint } from './IsDisjoint.js'
 export type { IsRecord } from './IsRecord.js'

package/ts/object/is_strict_object.ts

@@ -0,0 +1,14 @@
+import type { IdentityEqual } from '../equal/identity_equal.js'
+import type { IsNever } from '../never/never_type.js'
+import type { IsObject } from './object_type.js'
+
+/**
+ * 🎭 *validate*
+ *
+ * Validate that `T` is strictly the `object` type.
+ */
+export type IsStrictObject<T, Then = true, Else = false> = IsObject<
+	T,
+	IdentityEqual<T, {}, Else, IsNever<keyof T, Then, Else>>,
+	Else
+>

package/ts/object/left_join.ts

@@ -1,5 +1,5 @@
 import type { IsEqual } from '../equal/equal.js'
-import type { AnyRecord } from './AnyRecord.js'
+import type { AnyRecord } from './any_record.js'
 import type { IsDisjoint } from './IsDisjoint.js'
 import type { KeysWithDiffType } from './KeysWithDiffType.js'
 import type { Properties } from './properties.js'

package/ts/object/mapProperties.ts

@@ -1,4 +1,4 @@
-import type { AnyRecord } from './AnyRecord.js'
+import type { AnyRecord } from './any_record.js'
 import { reduceByKey } from './reduceKey.js'
 import type { ValueOf } from './ValueOf.js'
 

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)