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

package/src/object/forEachKey.ts

@@ -3,7 +3,7 @@ import type { KeyTypes } from './KeyTypes.js'
 export function forEachKey<S extends Record<KeyTypes, any>, T = any>(
 	subject: S,
 	predicate: (this: T, key: keyof S, index: number, obj: Array<keyof S>) => void,
-	thisArg?: T
+	thisArg?: T,
 ): void {
 	Object.keys(subject).forEach(predicate, thisArg)
 }

package/src/object/getField.ts

@@ -1,20 +1,17 @@
 import type { UnionKeys } from '../union_keys.js'
 
-export function getField<T, TX extends Exclude<T, undefined | null>, K extends UnionKeys<TX>>(
-	subject: T,
-	key: K
-): TX[K]
+export function getField<T, TX extends Exclude<T, undefined | null>, K extends UnionKeys<TX>>(subject: T, key: K): TX[K]
 export function getField<
 	T,
 	TX extends Exclude<T, undefined | null>,
 	K extends UnionKeys<TX>,
-	DV extends Exclude<TX[K], undefined>
+	DV extends Exclude<TX[K], undefined>,
 >(subject: T, key: K, defaultValue: DV): DV
 export function getField<
 	T,
 	TX extends Exclude<T, undefined | null>,
 	K extends UnionKeys<TX>,
-	DV extends Exclude<TX[K], undefined>
+	DV extends Exclude<TX[K], undefined>,
 >(subject: T, key: K, defaultValue?: DV) {
 	return (subject && (subject as unknown as { [k in K]: TX[K] | DV })[key]) || defaultValue
 }

package/src/object/hasKey.ts

@@ -3,5 +3,5 @@ import type { AnyRecord } from './any_record.js'
 export type HasKey<T, K, Then = true, Else = false> = K extends keyof T ? Then : Else
 
 export function hasKey<T extends AnyRecord, K extends string>(subject: T, ...keys: K[]): HasKey<T, K> {
-	return !keys.some(key => !subject[key]) as unknown as HasKey<T, K>
+	return !keys.some((key) => !subject[key]) as unknown as HasKey<T, K>
 }

package/src/object/is_not_object.ts

@@ -89,10 +89,12 @@ import type { $Else, $Then } from '../type_plus/branch/$selection.js'
  * type R = IsNotObject<string, $SelectionBranch> // $Then
  * ```
  */
-export type IsNotObject<T, $O extends IsNotObject.$Options = {}> = $SpecialType<T,
-	$MergeOptions<$O,
+export type IsNotObject<T, $O extends IsNotObject.$Options = {}> = $SpecialType<
+	T,
+	$MergeOptions<
+		$O,
 		{
-			$then: $ResolveBranch<T, $O, [$Then]>,
+			$then: $ResolveBranch<T, $O, [$Then]>
 			$else: IsNotObject.$<T, $O>
 		}
 	>
@@ -109,24 +111,29 @@ export namespace IsNotObject {
 	 * This is a type util for building custom types.
 	 * It does not check against special types.
 	 */
-	export type $<T, $O extends $UtilOptions> =
-		$ResolveOptions<[$O['exact'], $Exact.$Default]> extends true
-		? $IsDistributive<$O, { $then: _D<T, $O>, $else: _N<T, $O> }>
+	export type $<T, $O extends $UtilOptions> = $ResolveOptions<[$O['exact'], $Exact.$Default]> extends true
+		? $IsDistributive<$O, { $then: _D<T, $O>; $else: _N<T, $O> }>
 		: NotAssignable.$<T, object, $O>
 	export type $UtilOptions = NotAssignable.$UtilOptions & $Exact.$Options
 
 	export type _D<T, $O extends $UtilOptions> = T extends object
-		? IdentityEqual<T, {},
-			$ResolveBranch<T, $O, [$Then]>,
-			IsNever<keyof T, {
-				$then: $ResolveBranch<T, $O, [$Else]>,
-				$else: $ResolveBranch<T, $O, [$Then]>
-			}>>
+		? IdentityEqual<
+				T,
+				{},
+				$ResolveBranch<T, $O, [$Then]>,
+				IsNever<
+					keyof T,
+					{
+						$then: $ResolveBranch<T, $O, [$Else]>
+						$else: $ResolveBranch<T, $O, [$Then]>
+					}
+				>
+			>
 		: $ResolveBranch<T, $O, [$Then]>
 
-	export type _N<T, $O extends $UtilOptions> =
-		[T] extends [object & infer U] ?
-		U extends object ? $ResolveBranch<T, $O, [$Then]>
-		: $ResolveBranch<T, $O, [$Else]>
+	export type _N<T, $O extends $UtilOptions> = [T] extends [object & infer U]
+		? U extends object
+			? $ResolveBranch<T, $O, [$Then]>
+			: $ResolveBranch<T, $O, [$Else]>
 		: $ResolveBranch<T, $O, [$Then]>
 }

package/src/object/is_object.ts

@@ -76,10 +76,12 @@ import type { $Else, $Then } from '../type_plus/branch/$selection.js'
  * type R = IsObject<string, $SelectionBranch> // $Else
  * ```
  */
-export type IsObject<T, $O extends IsObject.$Options = {}> = $SpecialType<T,
-	$MergeOptions<$O,
+export type IsObject<T, $O extends IsObject.$Options = {}> = $SpecialType<
+	T,
+	$MergeOptions<
+		$O,
 		{
-			$then: $ResolveBranch<T, $O, [$Else]>,
+			$then: $ResolveBranch<T, $O, [$Else]>
 			$else: IsObject.$<T, $O>
 		}
 	>
@@ -97,23 +99,29 @@ export namespace IsObject {
 	 * This is a type util for building custom types.
 	 * It does not check against special types.
 	 */
-	export type $<T, $O extends $UtilOptions> =
-		$ResolveOptions<[$O['exact'], $Exact.$Default]> extends true
-		? $IsDistributive<$O, { $then: _D<T, $O>, $else: _N<T, $O> }>
+	export type $<T, $O extends $UtilOptions> = $ResolveOptions<[$O['exact'], $Exact.$Default]> extends true
+		? $IsDistributive<$O, { $then: _D<T, $O>; $else: _N<T, $O> }>
 		: Assignable.$<T, object, $O>
 	export type $UtilOptions = Assignable.$UtilOptions & $Exact.$Options
 
 	export type _D<T, $O extends $UtilOptions> = T extends object
-		? IdentityEqual<T, {},
-			$ResolveBranch<T, $O, [$Else]>,
-			IsNever<keyof T, {
-				$then: $ResolveBranch<T, $O, [$Then]>,
-				$else: $ResolveBranch<T, $O, [$Else]>
-			}>>
+		? IdentityEqual<
+				T,
+				{},
+				$ResolveBranch<T, $O, [$Else]>,
+				IsNever<
+					keyof T,
+					{
+						$then: $ResolveBranch<T, $O, [$Then]>
+						$else: $ResolveBranch<T, $O, [$Else]>
+					}
+				>
+			>
 		: $ResolveBranch<T, $O, [$Else]>
 
-	export type _N<T, $O extends $UtilOptions> = [T] extends [object & infer U] ?
-		U extends object ? $ResolveBranch<T, $O, [$Else]>
-		: $ResolveBranch<T, $O, [$Then]>
+	export type _N<T, $O extends $UtilOptions> = [T] extends [object & infer U]
+		? U extends object
+			? $ResolveBranch<T, $O, [$Else]>
+			: $ResolveBranch<T, $O, [$Then]>
 		: $ResolveBranch<T, $O, [$Else]>
 }

package/src/object/left_join.ts

@@ -6,5 +6,5 @@ import type { Properties } from './properties.js'
 export type LeftJoin<A extends AnyRecord, B extends AnyRecord> = IsEqual<A, B> extends true
 	? A
 	: IsDisjoint<A, B> extends true
-	? A & B
-	: Properties<{ [k in Exclude<keyof A, keyof B>]: A[k] } & { [k in keyof B]: B[k] }>
+		? A & B
+		: Properties<{ [k in Exclude<keyof A, keyof B>]: A[k] } & { [k in keyof B]: B[k] }>

package/src/object/mapKey.ts

@@ -3,7 +3,7 @@ import type { KeyTypes } from './KeyTypes.js'
 export function mapKey<R, S extends Record<KeyTypes, any>, T = any>(
 	subject: S,
 	predicate: (this: T, key: keyof S, index: number, obj: Array<keyof S>, subject: S) => R,
-	thisArg?: T
+	thisArg?: T,
 ): R[] {
 	return Object.keys(subject).map(function (this: T, k, i, a) {
 		return predicate.apply(this, [k, i, a, subject])

package/src/object/mapProperties.ts

@@ -12,11 +12,11 @@ import type { ValueOf } from './ValueOf.js'
  */
 export function mapProperties<Subject extends AnyRecord, ResultProp>(
 	subject: Subject,
-	callbackfn: (value: ValueOf<Subject>, key: keyof Subject, obj: Subject) => ResultProp
+	callbackfn: (value: ValueOf<Subject>, key: keyof Subject, obj: Subject) => ResultProp,
 ): { [K in keyof Subject]: ResultProp } {
 	return reduceByKey(
 		subject,
 		(p, key) => ((p[key] = callbackfn(subject[key], key, subject)), p),
-		{} as { [K in keyof Subject]: ResultProp }
+		{} as { [K in keyof Subject]: ResultProp },
 	)
 }

package/src/object/merge.ts

@@ -25,83 +25,64 @@ export type Merge<
 	A extends AnyRecord,
 	B extends AnyRecord,
 	// biome-ignore lint/correctness/noUnusedVariables: FIXME
-	Options = Merge.DefaultOptions> = Or<
-		IsAny<A>,
-		IsAny<B>,
-		any,
-		Or<
-			IsNever<A>,
-			IsNever<B>,
-			never,
-			IsDisjoint<A, B> extends true
+	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
-							(IsNotNever<
-								PKA & PKB,
-								{ selection: 'filter' }
-							> extends infer R extends KeyTypes ? { [k in R]?: A[k] | B[k] } : unknown) &
-							// properties only in A excluding partials is A[k]
-							(IsNotNever<
-								Exclude<KA, PKA | KB>,
-								{ selection: 'filter' }
-							> extends infer R extends KeyTypes ? { [k in R]: A[k] } : unknown) &
-							// properties only in B excluding partials is B[k]
-							(IsNotNever<
-								Exclude<KB, PKB>,
-								{ selection: 'filter' }
-							> extends infer R extends KeyTypes ? { [k in R]: B[k] } : unknown) &
-							// properties is required in A but optional in B is unionized without undefined
-							(IsNotNever<
-								Exclude<KA & PKB, PKA>,
-								{ selection: 'filter' }
-							> extends infer R extends KeyTypes ? { [k in R]: A[k] | Exclude<B[k], undefined> } : unknown)
-							: never)
-						:
-						(IsNotNever<
-							Exclude<KA, KA & KB>,
-							{ selection: 'filter' }
-						> extends infer R extends KeyTypes ? { [k in R]: A[k] } : unknown) &
-						(IsNotNever<
-							Exclude<KB, KA & KB>,
-							{ selection: 'filter' }
-						> extends infer R extends KeyTypes ? { [k in R]: B[k] } : unknown) &
-						(IsNotNever<
-							KA & KB,
-							{ selection: 'filter' }
-						> extends infer R extends KeyTypes ? { [k in R]: A[k] | B[k] } : unknown)
-					)
-					: (
-						IsLiteral<KB> extends true
+			: [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
+								(IsNotNever<PKA & PKB, { selection: 'filter' }> extends infer R extends KeyTypes
+									? { [k in R]?: A[k] | B[k] }
+									: unknown) &
+									// properties only in A excluding partials is A[k]
+									(IsNotNever<Exclude<KA, PKA | KB>, { selection: 'filter' }> extends infer R extends KeyTypes
+										? { [k in R]: A[k] }
+										: unknown) &
+									// properties only in B excluding partials is B[k]
+									(IsNotNever<Exclude<KB, PKB>, { selection: 'filter' }> extends infer R extends KeyTypes
+										? { [k in R]: B[k] }
+										: unknown) &
+									// properties is required in A but optional in B is unionized without undefined
+									(IsNotNever<Exclude<KA & PKB, PKA>, { selection: 'filter' }> extends infer R extends KeyTypes
+										? { [k in R]: A[k] | Exclude<B[k], undefined> }
+										: unknown)
+							: never
+						: (IsNotNever<Exclude<KA, KA & KB>, { selection: 'filter' }> extends infer R extends KeyTypes
+								? { [k in R]: A[k] }
+								: unknown) &
+								(IsNotNever<Exclude<KB, KA & KB>, { selection: 'filter' }> extends infer R extends KeyTypes
+									? { [k in R]: B[k] }
+									: unknown) &
+								(IsNotNever<KA & KB, { selection: 'filter' }> extends infer R extends KeyTypes
+									? { [k in R]: A[k] | B[k] }
+									: unknown)
+					: IsLiteral<KB> extends true
 						? { [k in Exclude<KA, KB>]: A[k] } & { [k in keyof B]: B[k] }
-						:
-						(IsNotNever<
-							Exclude<KA, KA & KB>,
-							{ selection: 'filter' }
-						> extends infer R extends KeyTypes ? { [k in R]: A[k] } : unknown) &
-						(IsNotNever<
-							Exclude<KB, KA & KB>,
-							{ selection: 'filter' }
-						> extends infer R extends KeyTypes ? { [k in R]: B[k] } : unknown) &
-						(IsNotNever<
-							KA & KB,
-							{ selection: 'filter' }
-						> extends infer R extends KeyTypes ? { [k in R]: A[k] | B[k] } : unknown)
-					))
-				: never)
-		>
+						: (IsNotNever<Exclude<KA, KA & KB>, { selection: 'filter' }> extends infer R extends KeyTypes
+								? { [k in R]: A[k] }
+								: unknown) &
+								(IsNotNever<Exclude<KB, KA & KB>, { selection: 'filter' }> extends infer R extends KeyTypes
+									? { [k in R]: B[k] }
+									: unknown) &
+								(IsNotNever<KA & KB, { selection: 'filter' }> extends infer R extends KeyTypes
+									? { [k in R]: 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 JoinProps<A, B> = A extends NonComposableTypes ? B : B extends NonComposableTypes ? A : A & B
 
 	export type Options = {
 		$never?: undefined

package/src/object/omit.ts

@@ -4,12 +4,14 @@ import type { Pick } from './pick.js'
 import { record } from './record.js'
 import { reduceByKey } from './reduceKey.js'
 
-// by Titian Cernicova-Dragomir
-// https://github.com/microsoft/TypeScript/issues/28339#issuecomment-463577347
-// type-zoo
-export type Omit<T, K extends UnionKeys<T>> = T extends unknown
-? Pick<T, Exclude<keyof T, K>>
-: never
+/**
+ * Omit properties from a type.
+ *
+ * @origin [typescript#28339](https://github.com/microsoft/TypeScript/issues/28339#issuecomment-463577347)
+ * @originAuthor Titian Cernicova-Dragomir
+ * @alternative [type-zoo](https://github.com/pelotom/type-zoo)
+ */
+export type Omit<T, K extends UnionKeys<T>> = T extends unknown ? Pick<T, Exclude<keyof T, K>> : never
 
 /**
  * @deprecated replaced by `Omit`
@@ -20,20 +22,20 @@ export function omit<T extends AnyRecord, P1 extends UnionKeys<T>>(subject: T, p
 export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>>(
 	subject: T,
 	prop1: P1,
-	prop2: P2
+	prop2: P2,
 ): Omit<T, P1 | P2>
-export function omit<
-	T extends AnyRecord,
-	P1 extends UnionKeys<T>,
-	P2 extends UnionKeys<T>,
-	P3 extends UnionKeys<T>
->(subject: T, prop1: P1, prop2: P2, prop3: P3): Omit<T, P1 | P2 | P3>
+export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>>(
+	subject: T,
+	prop1: P1,
+	prop2: P2,
+	prop3: P3,
+): Omit<T, P1 | P2 | P3>
 export function omit<
 	T extends AnyRecord,
 	P1 extends UnionKeys<T>,
 	P2 extends UnionKeys<T>,
 	P3 extends UnionKeys<T>,
-	P4 extends UnionKeys<T>
+	P4 extends UnionKeys<T>,
 >(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4): Omit<T, P1 | P2 | P3 | P4>
 export function omit<
 	T extends AnyRecord,
@@ -41,7 +43,7 @@ export function omit<
 	P2 extends UnionKeys<T>,
 	P3 extends UnionKeys<T>,
 	P4 extends UnionKeys<T>,
-	P5 extends UnionKeys<T>
+	P5 extends UnionKeys<T>,
 >(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5): Omit<T, P1 | P2 | P3 | P4 | P5>
 export function omit<
 	T extends AnyRecord,
@@ -50,16 +52,8 @@ export function omit<
 	P3 extends UnionKeys<T>,
 	P4 extends UnionKeys<T>,
 	P5 extends UnionKeys<T>,
-	P6 extends UnionKeys<T>
->(
-	subject: T,
-	prop1: P1,
-	prop2: P2,
-	prop3: P3,
-	prop4: P4,
-	prop5: P5,
-	prop6: P6
-): Omit<T, P1 | P2 | P3 | P4 | P5 | P6>
+	P6 extends UnionKeys<T>,
+>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6): Omit<T, P1 | P2 | P3 | P4 | P5 | P6>
 export function omit<
 	T extends AnyRecord,
 	P1 extends UnionKeys<T>,
@@ -68,7 +62,7 @@ export function omit<
 	P4 extends UnionKeys<T>,
 	P5 extends UnionKeys<T>,
 	P6 extends UnionKeys<T>,
-	P7 extends UnionKeys<T>
+	P7 extends UnionKeys<T>,
 >(
 	subject: T,
 	prop1: P1,
@@ -77,7 +71,7 @@ export function omit<
 	prop4: P4,
 	prop5: P5,
 	prop6: P6,
-	prop7: P7
+	prop7: P7,
 ): Omit<T, P1 | P2 | P3 | P4 | P5 | P6 | P7>
 export function omit<
 	T extends AnyRecord,
@@ -88,7 +82,7 @@ export function omit<
 	P5 extends UnionKeys<T>,
 	P6 extends UnionKeys<T>,
 	P7 extends UnionKeys<T>,
-	P8 extends UnionKeys<T>
+	P8 extends UnionKeys<T>,
 >(
 	subject: T,
 	prop1: P1,
@@ -98,7 +92,7 @@ export function omit<
 	prop5: P5,
 	prop6: P6,
 	prop7: P7,
-	prop8: P8
+	prop8: P8,
 ): Omit<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8>
 export function omit<
 	T extends AnyRecord,
@@ -110,7 +104,7 @@ export function omit<
 	P6 extends UnionKeys<T>,
 	P7 extends UnionKeys<T>,
 	P8 extends UnionKeys<T>,
-	P9 extends UnionKeys<T>
+	P9 extends UnionKeys<T>,
 >(
 	subject: T,
 	prop1: P1,
@@ -121,7 +115,7 @@ export function omit<
 	prop6: P6,
 	prop7: P7,
 	prop8: P8,
-	prop9: P9
+	prop9: P9,
 ): Omit<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9>
 export function omit<
 	T extends AnyRecord,
@@ -134,7 +128,7 @@ export function omit<
 	P7 extends UnionKeys<T>,
 	P8 extends UnionKeys<T>,
 	P9 extends UnionKeys<T>,
-	P10 extends UnionKeys<T>
+	P10 extends UnionKeys<T>,
 >(
 	subject: T,
 	prop1: P1,
@@ -146,7 +140,7 @@ export function omit<
 	prop7: P7,
 	prop8: P8,
 	prop9: P9,
-	prop10: P10
+	prop10: P10,
 ): Omit<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10>
 export function omit<
 	T extends AnyRecord,
@@ -160,7 +154,7 @@ export function omit<
 	P8 extends UnionKeys<T>,
 	P9 extends UnionKeys<T>,
 	P10 extends UnionKeys<T>,
-	P11 extends UnionKeys<T>
+	P11 extends UnionKeys<T>,
 >(
 	subject: T,
 	prop1: P1,
@@ -173,7 +167,7 @@ export function omit<
 	prop8: P8,
 	prop9: P9,
 	prop10: P10,
-	prop11: P11
+	prop11: P11,
 ): Omit<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10 | P11>
 export function omit<
 	T extends AnyRecord,
@@ -188,7 +182,7 @@ export function omit<
 	P9 extends UnionKeys<T>,
 	P10 extends UnionKeys<T>,
 	P11 extends UnionKeys<T>,
-	P12 extends UnionKeys<T>
+	P12 extends UnionKeys<T>,
 >(
 	subject: T,
 	prop1: P1,
@@ -202,12 +196,9 @@ export function omit<
 	prop9: P9,
 	prop10: P10,
 	prop11: P11,
-	prop12: P12
+	prop12: P12,
 ): Omit<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10 | P11 | P12>
-export function omit<T extends AnyRecord, Props extends UnionKeys<T>>(
-	subject: T,
-	...props: Props[]
-): Omit<T, Props>
+export function omit<T extends AnyRecord, Props extends UnionKeys<T>>(subject: T, ...props: Props[]): Omit<T, Props>
 export function omit<T extends AnyRecord>(subject: T, ...props: Array<UnionKeys<T>>) {
 	return reduceByKey(
 		subject,
@@ -215,6 +206,6 @@ export function omit<T extends AnyRecord>(subject: T, ...props: Array<UnionKeys<
 			if (props.indexOf(k) === -1) p[k] = subject[k]
 			return p
 		},
-		Object.getPrototypeOf(subject) === null ? record() : {}
+		Object.getPrototypeOf(subject) === null ? record() : {},
 	)
 }

package/src/object/optional_key.ts

@@ -1,4 +1,3 @@
-
 import type { AnyRecord } from './any_record.js'
 import type { KeyTypes } from './KeyTypes.js'
 
@@ -33,6 +32,4 @@ export type OptionalKeys<T> = T extends unknown
 /**
  * Parse `T` to keep only the optional properties.
  */
-export type OptionalProps<T extends AnyRecord> = T extends unknown
-	? { [k in OptionalKeys<T>]?: T[k] }
-	: never
+export type OptionalProps<T extends AnyRecord> = T extends unknown ? { [k in OptionalKeys<T>]?: T[k] } : never