type-plus 8.0.0-beta.0 → 8.0.0-beta.3

package/src/object/left_join.ts

@@ -0,0 +1,10 @@
+import type { IsEqual } from '../equal/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/merge.ts

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

package/src/object/pick.ts

@@ -0,0 +1,209 @@
+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/recursive_partial.ts

@@ -0,0 +1,39 @@
+// Source: https://stackoverflow.com/questions/41980195/recursive-partialt-in-typescript-2-1
+
+import type { AnyFunction } from '../function/any_function.js'
+import type { ExtractFunction } from '../index.js'
+import type { AnyRecord } from './any_record.js'
+import type { Properties } from './properties.js'
+
+/**
+ * Creates a recursive partial type of type T.
+ *
+ * @example
+ * ```ts
+ * interface Foo {
+ *   bar: number;
+ *   baz: {
+ *     qux: string
+ *   }
+ * }
+ *
+ * type PartialFoo = RecursivePartial<Foo>
+ * // {
+ * //   bar?: number | undefined;
+ * //   baz?: {
+ * //     qux?: string | undefined
+ * //   } | undefined
+ * // }
+ * ```
+ */
+export type RecursivePartial<T> = {
+	[P in keyof T]?: T[P] extends (infer U)[]
+		? RecursivePartial<U>[] | undefined
+		: T[P] extends infer F extends AnyFunction
+			? [keyof T[P]] extends [undefined]
+				? T[P] | undefined
+				: ExtractFunction<F> & RecursivePartial<Properties<T[P]>>
+			: T[P] extends AnyRecord
+				? RecursivePartial<T[P]> | undefined
+				: T[P] | undefined
+}