type-plus 7.6.2 → 8.0.0-beta.10

package/src/object/is_not_object.ts

@@ -0,0 +1,146 @@
+import type { $ResolveOptions } from '../$type/$resolve_options.js'
+import type { $InputOptions } from '../$type/branch/$input_options.js'
+import type { $ResolveBranch } from '../$type/branch/$resolve_branch.js'
+import type { $Else, $Selection, $Then } from '../$type/branch/$selection.js'
+import type { $Distributive } from '../$type/distributive/$distributive.js'
+import type { $Exact } from '../$type/exact/$exact.js'
+import type { $Any } from '../$type/special/$any.js'
+import type { $Never } from '../$type/special/$never.js'
+import type { $Special } from '../$type/special/$special.js'
+import type { $Unknown } from '../$type/special/$unknown.js'
+import type { $Void } from '../$type/special/$void.js'
+import type { $MergeOptions } from '../$type/utils/$merge_options.js'
+import type { IdentityEqual } from '../equal/identity_equal.js'
+import type { IsNever } from '../never/is_never.js'
+import type { NotAssignable } from '../predicates/not_assignable.js'
+
+/**
+ * Is `T` not an `object`.
+ *
+ * Note that `Function` is also an `object`.
+ *
+ * ```ts
+ * type R = IsNotObject<{}> // false
+ * type R = IsNotObject<{ a: 1 }> // false
+ * type R = IsNotObject<Function> // false
+ *
+ * type R = IsNotObject<number> // true
+ * ```
+ */
+/**
+ * 🎭 *predicate*
+ *
+ * Validate if `T` is not an `object` nor object literals.
+ *
+ * Note that `Function`, `Array`, and *tuple* are also objects.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotObject<object> // false
+ * type R = IsNotObject<{}> // false
+ * type R = IsNotObject<{ a: 1 }> // false
+ * type R = IsNotObject<Function> // false
+ *
+ * type R = IsNotObject<never> // true
+ * type R = IsNotObject<unknown> // true
+ * type R = IsNotObject<number> // true
+ *
+ * type R = IsNotObject<{} | bigint> // boolean
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Filter to ensure `T` is not an `object` nor object literals, otherwise returns `never`.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotObject<{}, { selection: 'filter' }> // never
+ * type R = IsNotObject<{ a: 1 }, { selection: 'filter' }> // never
+ * type R = IsNotObject<Function, { selection: 'filter' }> // never
+ *
+ * type R = IsNotObject<never, { selection: 'filter' }> // never
+ * type R = IsNotObject<unknown, { selection: 'filter' }> // unknown
+ *
+ * type R = IsNotObject<{} | bigint> // bigint
+ * ```
+ *
+ * 🔢 *customize*:
+ *
+ * Validate if `T` is not exactly `object`.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotObject<object, { exact: true }> // false
+ * type R = IsNotObject<{}, { exact: true }> // true
+ * ```
+ *
+ * 🔢 *customize*:
+ *
+ * Disable distribution of union types.
+ *
+ * ```ts
+ * type R = IsNotObject<{} | 1> // boolean
+ * type R = IsNotObject<{} | 1, { distributive: false }> // true
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Use unique branch identifiers to allow precise processing of the result.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotObject<{}, $SelectionBranch> // $Else
+ * type R = IsNotObject<string, $SelectionBranch> // $Then
+ * ```
+ */
+export type IsNotObject<T, $O extends IsNotObject.$Options = {}> = $Special<
+	T,
+	$MergeOptions<
+		$O,
+		{
+			$then: $ResolveBranch<$O, [$Then], T>
+			$else: IsNotObject.$<T, $O>
+		}
+	>
+>
+export namespace IsNotObject {
+	export type $Options = $Selection.Options &
+		$Distributive.Options &
+		$Exact.Options &
+		$InputOptions<$Any | $Unknown | $Never | $Void>
+	export type $Branch<$O extends $Options = {}> = $Selection.Branch<$O>
+
+	/**
+	 * 🧰 *type util*
+	 *
+	 * Validate if `T` is `object` or `object` literals.
+	 *
+	 * 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
+		? $Distributive.Parse<$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<$O, [$Then], T>,
+				IsNever<
+					keyof T,
+					{
+						$then: $ResolveBranch<$O, [$Else]>
+						$else: $ResolveBranch<$O, [$Then], T>
+					}
+				>
+			>
+		: $ResolveBranch<$O, [$Then], T>
+
+	export type _N<T, $O extends $UtilOptions> = [T] extends [object & infer U]
+		? U extends object
+			? $ResolveBranch<$O, [$Then], T>
+			: $ResolveBranch<$O, [$Else]>
+		: $ResolveBranch<$O, [$Then], T>
+}

package/src/object/is_object.ts

@@ -0,0 +1,134 @@
+import type { $ResolveOptions } from '../$type/$resolve_options.js'
+import type { $InputOptions } from '../$type/branch/$input_options.js'
+import type { $ResolveBranch } from '../$type/branch/$resolve_branch.js'
+import type { $Else, $Selection, $Then } from '../$type/branch/$selection.js'
+import type { $Distributive } from '../$type/distributive/$distributive.js'
+import type { $Exact } from '../$type/exact/$exact.js'
+import type { $Any } from '../$type/special/$any.js'
+import type { $Never } from '../$type/special/$never.js'
+import type { $Special } from '../$type/special/$special.js'
+import type { $Unknown } from '../$type/special/$unknown.js'
+import type { $Void } from '../$type/special/$void.js'
+import type { $MergeOptions } from '../$type/utils/$merge_options.js'
+import type { IdentityEqual } from '../equal/identity_equal.js'
+import type { IsNever } from '../never/is_never.js'
+import type { Assignable } from '../predicates/assignable.js'
+
+/**
+ * 🎭 *predicate*
+ *
+ * Validate if `T` is an `object` or object literals.
+ *
+ * Note that `Function`, `Array`, and *tuple* are also objects.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotObject<object> // true
+ * type R = IsObject<{}> // true
+ * type R = IsObject<{ a: 1 }> // true
+ * type R = IsObject<Function> // true
+ *
+ * type R = IsObject<never> // false
+ * type R = IsObject<unknown> // false
+ * type R = IsObject<number> // false
+ *
+ * type R = IsObject<{} | bigint> // boolean
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Filter to ensure `T` is an `object` or object literals, otherwise returns `never`.
+ *
+ * @example
+ * ```ts
+ * type R = IsObject<{}, { selection: 'filter' }> // {}
+ * type R = IsObject<{ a: 1 }, { selection: 'filter' }> // { a: 1 }
+ * type R = IsObject<Function, { selection: 'filter' }> // Function
+ *
+ * type R = IsObject<never, { selection: 'filter' }> // never
+ * type R = IsObject<unknown, { selection: 'filter' }> // never
+ *
+ * type R = IsObject<{} | bigint> // {}
+ * ```
+ *
+ * 🔢 *customize*:
+ *
+ * Validate if `T` is exactly `object`.
+ *
+ * @example
+ * ```ts
+ * type R = IsObject<object, { exact: true }> // true
+ * type R = IsObject<{}, { exact: true }> // false
+ * ```
+ *
+ * 🔢 *customize*:
+ *
+ * Disable distribution of union types.
+ *
+ * ```ts
+ * type R = IsObject<{} | 1> // boolean
+ * type R = IsObject<{} | 1, { distributive: false }> // false
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Use unique branch identifiers to allow precise processing of the result.
+ *
+ * @example
+ * ```ts
+ * type R = IsObject<{}, $SelectionBranch> // $Then
+ * type R = IsObject<string, $SelectionBranch> // $Else
+ * ```
+ */
+export type IsObject<T, $O extends IsObject.$Options = {}> = $Special<
+	T,
+	$MergeOptions<
+		$O,
+		{
+			$then: $ResolveBranch<$O, [$Else]>
+			$else: IsObject.$<T, $O>
+		}
+	>
+>
+
+export namespace IsObject {
+	export type $Options = $Selection.Options &
+		$Distributive.Options &
+		$Exact.Options &
+		$InputOptions<$Any | $Unknown | $Never | $Void>
+	export type $Branch<$O extends $Options = {}> = $Selection.Branch<$O>
+
+	/**
+	 * 🧰 *type util*
+	 *
+	 * Validate if `T` is `object` or `object` literals.
+	 *
+	 * 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
+		? $Distributive.Parse<$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<$O, [$Else]>,
+				IsNever<
+					keyof T,
+					{
+						$then: $ResolveBranch<$O, [$Then], T>
+						$else: $ResolveBranch<$O, [$Else]>
+					}
+				>
+			>
+		: $ResolveBranch<$O, [$Else]>
+
+	export type _N<T, $O extends $UtilOptions> = [T] extends [object & infer U]
+		? U extends object
+			? $ResolveBranch<$O, [$Else]>
+			: $ResolveBranch<$O, [$Then], T>
+		: $ResolveBranch<$O, [$Else]>
+}

package/src/object/left_join.ts

@@ -0,0 +1,10 @@
+import type { IsEqual } from '../equal/is_equal.js'
+import type { AnyRecord } from './any_record.js'
+import type { IsDisjoint } from './IsDisjoint.js'
+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] }>

package/src/object/mapKey.ts

@@ -0,0 +1,11 @@
+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,
+): R[] {
+	return Object.keys(subject).map(function (this: T, k, i, a) {
+		return predicate.apply(this, [k, i, a, subject])
+	}, thisArg)
+}

package/src/object/mapProperties.ts

@@ -0,0 +1,22 @@
+import type { AnyRecord } from './any_record.js'
+import { reduceByKey } from './reduceKey.js'
+import type { ValueOf } from './ValueOf.js'
+
+/**
+ * An Object-specific version of `map`.
+ * Original source:
+ * <https://stackoverflow.com/questions/53964071/how-to-dynamically-create-mapped-type-in-typescript>
+ *
+ * `ramda` has a similar function (`mapObjIndexed()`) with different parameter order.
+ * I keep this parameter order because this parameter order provides better type inference.
+ */
+export function mapProperties<Subject extends AnyRecord, ResultProp>(
+	subject: Subject,
+	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 },
+	)
+}

package/src/object/merge.ts

@@ -0,0 +1,102 @@
+import type { $Never } from '../$type/special/$never.js'
+import type { IsAny } from '../any/is_any.js'
+import type { NonComposableTypes } from '../composable_types.js'
+import type { Or } from '../logical/logical.js'
+import type { IsNever } from '../never/is_never.js'
+import type { IsNotNever } from '../never/is_not_never.js'
+import type { IsLiteral } from '../predicates/literal.js'
+import type { AnyRecord } from './any_record.js'
+import type { IsDisjoint } from './IsDisjoint.js'
+import type { KeyTypes } from './KeyTypes.js'
+import type { OptionalKeys } from './optional_key.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,
+	// biome-ignore lint/correctness/noUnusedVariables: FIXME
+	Options = Merge.DefaultOptions,
+> = Or<
+	IsAny<A>,
+	IsAny<B>,
+	{
+		$then: any
+		$else: Or<
+			IsNever<A>,
+			IsNever<B>,
+			{
+				$then: never
+				$else: 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
+								? { [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
+			}
+		>
+	}
+>
+
+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/src/object/object_plus.ts

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

package/src/object/omit.ts

@@ -0,0 +1,211 @@
+import type { UnionKeys } from '../union_keys.js'
+import type { AnyRecord } from './any_record.js'
+import type { Pick } from './pick.js'
+import { record } from './record.js'
+import { reduceByKey } from './reduceKey.js'
+
+/**
+ * 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`
+ */
+export type Except<T, K extends keyof T> = Omit<T, K>
+
+export function omit<T extends AnyRecord, P1 extends UnionKeys<T>>(subject: T, prop1: P1): Omit<T, P1>
+export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>>(
+	subject: T,
+	prop1: P1,
+	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>,
+	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,
+	P1 extends UnionKeys<T>,
+	P2 extends UnionKeys<T>,
+	P3 extends UnionKeys<T>,
+	P4 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,
+	P1 extends UnionKeys<T>,
+	P2 extends UnionKeys<T>,
+	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>
+export function omit<
+	T extends AnyRecord,
+	P1 extends UnionKeys<T>,
+	P2 extends UnionKeys<T>,
+	P3 extends UnionKeys<T>,
+	P4 extends UnionKeys<T>,
+	P5 extends UnionKeys<T>,
+	P6 extends UnionKeys<T>,
+	P7 extends UnionKeys<T>,
+>(
+	subject: T,
+	prop1: P1,
+	prop2: P2,
+	prop3: P3,
+	prop4: P4,
+	prop5: P5,
+	prop6: P6,
+	prop7: P7,
+): Omit<T, P1 | P2 | P3 | P4 | P5 | P6 | P7>
+export function omit<
+	T extends AnyRecord,
+	P1 extends UnionKeys<T>,
+	P2 extends UnionKeys<T>,
+	P3 extends UnionKeys<T>,
+	P4 extends UnionKeys<T>,
+	P5 extends UnionKeys<T>,
+	P6 extends UnionKeys<T>,
+	P7 extends UnionKeys<T>,
+	P8 extends UnionKeys<T>,
+>(
+	subject: T,
+	prop1: P1,
+	prop2: P2,
+	prop3: P3,
+	prop4: P4,
+	prop5: P5,
+	prop6: P6,
+	prop7: P7,
+	prop8: P8,
+): Omit<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8>
+export function omit<
+	T extends AnyRecord,
+	P1 extends UnionKeys<T>,
+	P2 extends UnionKeys<T>,
+	P3 extends UnionKeys<T>,
+	P4 extends UnionKeys<T>,
+	P5 extends UnionKeys<T>,
+	P6 extends UnionKeys<T>,
+	P7 extends UnionKeys<T>,
+	P8 extends UnionKeys<T>,
+	P9 extends UnionKeys<T>,
+>(
+	subject: T,
+	prop1: P1,
+	prop2: P2,
+	prop3: P3,
+	prop4: P4,
+	prop5: P5,
+	prop6: P6,
+	prop7: P7,
+	prop8: P8,
+	prop9: P9,
+): Omit<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9>
+export function omit<
+	T extends AnyRecord,
+	P1 extends UnionKeys<T>,
+	P2 extends UnionKeys<T>,
+	P3 extends UnionKeys<T>,
+	P4 extends UnionKeys<T>,
+	P5 extends UnionKeys<T>,
+	P6 extends UnionKeys<T>,
+	P7 extends UnionKeys<T>,
+	P8 extends UnionKeys<T>,
+	P9 extends UnionKeys<T>,
+	P10 extends UnionKeys<T>,
+>(
+	subject: T,
+	prop1: P1,
+	prop2: P2,
+	prop3: P3,
+	prop4: P4,
+	prop5: P5,
+	prop6: P6,
+	prop7: P7,
+	prop8: P8,
+	prop9: P9,
+	prop10: P10,
+): Omit<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10>
+export function omit<
+	T extends AnyRecord,
+	P1 extends UnionKeys<T>,
+	P2 extends UnionKeys<T>,
+	P3 extends UnionKeys<T>,
+	P4 extends UnionKeys<T>,
+	P5 extends UnionKeys<T>,
+	P6 extends UnionKeys<T>,
+	P7 extends UnionKeys<T>,
+	P8 extends UnionKeys<T>,
+	P9 extends UnionKeys<T>,
+	P10 extends UnionKeys<T>,
+	P11 extends UnionKeys<T>,
+>(
+	subject: T,
+	prop1: P1,
+	prop2: P2,
+	prop3: P3,
+	prop4: P4,
+	prop5: P5,
+	prop6: P6,
+	prop7: P7,
+	prop8: P8,
+	prop9: P9,
+	prop10: P10,
+	prop11: P11,
+): Omit<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10 | P11>
+export function omit<
+	T extends AnyRecord,
+	P1 extends UnionKeys<T>,
+	P2 extends UnionKeys<T>,
+	P3 extends UnionKeys<T>,
+	P4 extends UnionKeys<T>,
+	P5 extends UnionKeys<T>,
+	P6 extends UnionKeys<T>,
+	P7 extends UnionKeys<T>,
+	P8 extends UnionKeys<T>,
+	P9 extends UnionKeys<T>,
+	P10 extends UnionKeys<T>,
+	P11 extends UnionKeys<T>,
+	P12 extends UnionKeys<T>,
+>(
+	subject: T,
+	prop1: P1,
+	prop2: P2,
+	prop3: P3,
+	prop4: P4,
+	prop5: P5,
+	prop6: P6,
+	prop7: P7,
+	prop8: P8,
+	prop9: P9,
+	prop10: P10,
+	prop11: P11,
+	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>(subject: T, ...props: Array<UnionKeys<T>>) {
+	return reduceByKey(
+		subject,
+		(p, k) => {
+			if (props.indexOf(k) === -1) p[k] = subject[k]
+			return p
+		},
+		Object.getPrototypeOf(subject) === null ? record() : {},
+	)
+}

package/src/object/optional_key.ts

@@ -0,0 +1,35 @@
+import type { AnyRecord } from './any_record.js'
+import type { KeyTypes } from './KeyTypes.js'
+
+/**
+ * Validate if the key `K` in `T` is optional.
+ *
+ * 🎭 *predicate*
+ *
+ * @example
+ * ```ts
+ * IsOptionalKey({ a: 1 }, 'a') // false
+ * IsOptionalKey({ a?: 1 }, 'a') // true
+ * ```
+ */
+export type IsOptionalKey<T, K, Then = true, Else = false> = K extends OptionalKeys<T> ? Then : Else
+
+/**
+ * Gets the optional keys of `T`.
+ *
+ * 🦴 *utilities*
+ *
+ * @example
+ * ```ts
+ * OptionalKeys<{ a: 1 }> // never
+ * OptionalKeys<{ a?: 1, b: number }> // 'a'
+ * ```
+ */
+export type OptionalKeys<T> = T extends unknown
+	? { [k in keyof T]-?: Record<KeyTypes, any> extends Pick<T, k> ? k : never }[keyof T]
+	: never
+
+/**
+ * Parse `T` to keep only the optional properties.
+ */
+export type OptionalProps<T extends AnyRecord> = T extends unknown ? { [k in OptionalKeys<T>]?: T[k] } : never