type-plus 7.6.2 → 8.0.0-beta.2

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,117 @@
+import type { IsAny } from '../any/is_any.js'
+import type { NonComposableTypes } from '../composable_types.js'
+import type { IsNever } from '../never/is_never.js'
+import type { IsNotNever } from '../never/is_not_never.js'
+import type { $Never } from '../never/never.js'
+import type { IsLiteral } from '../predicates/literal.js'
+import type { Or } from '../predicates/logical.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>,
+		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
+						? { [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,220 @@
+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'
+
+// 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
+
+/**
+ * @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,38 @@
+
+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

package/src/object/pick.ts

@@ -0,0 +1,220 @@
+import type { UnionKeys } from '../union_keys.js'
+import type { AnyRecord } from './any_record.js'
+import { record } from './record.js'
+import { reduceByKey } from './reduceKey.js'
+
+export function pick<T extends AnyRecord, P1 extends UnionKeys<T>>(subject: T, prop1: P1): Pick<T, P1>
+export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>>(
+	subject: T,
+	prop1: P1,
+	prop2: P2
+): Pick<T, P1 | P2>
+export function pick<
+	T extends AnyRecord,
+	P1 extends UnionKeys<T>,
+	P2 extends UnionKeys<T>,
+	P3 extends UnionKeys<T>
+>(subject: T, prop1: P1, prop2: P2, prop3: P3): Pick<T, P1 | P2 | P3>
+export function pick<
+	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): Pick<T, P1 | P2 | P3 | P4>
+export function pick<
+	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): Pick<T, P1 | P2 | P3 | P4 | P5>
+export function pick<
+	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
+): Pick<T, P1 | P2 | P3 | P4 | P5 | P6>
+export function pick<
+	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
+): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7>
+export function pick<
+	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
+): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8>
+export function pick<
+	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
+): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9>
+export function pick<
+	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
+): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10>
+export function pick<
+	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
+): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10 | P11>
+export function pick<
+	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
+): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10 | P11 | P12>
+export function pick<T extends AnyRecord, Props extends UnionKeys<T>>(
+	subject: T,
+	...props: Props[]
+): Pick<T, Props>
+export function pick<T extends AnyRecord>(subject: T, ...props: Array<UnionKeys<T>>) {
+	return reduceByKey(
+		subject,
+		(p, k) => {
+			if (props.indexOf(k) >= 0) p[k] = subject[k]
+			return p
+		},
+		Object.getPrototypeOf(subject) === null ? record() : {}
+	)
+}
+
+/**
+ * Pick properties `K` from `T`.
+ * Works with union.
+ *
+ * Original type by Titian Cernicova-Dragomir
+ * @see <https://github.com/microsoft/TypeScript/issues/28339#issuecomment-463577347>
+ */
+export type Pick<T, K extends UnionKeys<T>> = T extends unknown ? Pick._<T, keyof T & K> : never
+
+export namespace Pick {
+	export type _<T, K extends keyof T> = { [P in K]: T[P] }
+}

package/src/object/readme.md

@@ -0,0 +1,79 @@
+# object
+
+## Type Checking
+
+The `ObjectType<T>` and friends are used to check if a type is `object` or object types.
+
+Note that `Function` are also considered `object` in TypeScript.
+
+```ts
+import type { ObjectType } from 'type-plus'
+
+type R = ObjectType<object> // object
+type R = ObjectType<{}> // {}
+type R = ObjectType<{ a: number }> // { a: number }
+
+type R = ObjectType<1> // never
+```
+
+- [`ObjectType<T, Then = T, Else = never>`](object_type.ts#L16): check if `T` is `object`.
+- [`IsObject<T, Then = true, Else = false`](object_type.ts#L33): is `T` `object`.
+- [`NotObjectType<T, Then = T, Else = never>`](object_type.ts#L48): check if `T` is not `object`.
+- [`IsNotObject<T, Then = true, Else = false>`](object_type.ts#L65): is `T` not `object`.
+
+## IsOptionalKey
+
+> `IsOptionalKey<T, K, Then = true, Else = false>`
+
+Validate if the key `K` in `T` is optional.
+
+```ts
+import type { IsOptionalKey } from 'type-plus'
+
+type R = IsOptionalKey<{ a?: number }, 'a'> // true
+type R = IsOptionalKey<{ a: number }, 'a'> // false
+```
+
+## OptionalKeys
+
+> `OptionalKeys<T>`
+
+Gets the optional keys of `T`.
+
+```ts
+import type { OptionalKeys } from 'type-plus'
+
+type R = OptionalKeys<{ a?: number; b: string }> // 'a'
+```
+
+## OptionalProps
+
+> `OptionalProps<T>`
+
+Gets the optional properties of `T`.
+
+```ts
+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]
+
+[handbook]: https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#object-types