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

package/ts/object/omit.ts

@@ -1,222 +0,0 @@
-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 T
-	? (keyof T extends K
-		? {}
-		: 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/ts/object/optional_key.ts

@@ -1,38 +0,0 @@
-
-import type { AnyRecord } from './any_record.js'
-import type { KeyTypes } from './KeyTypes.js'
-
-/**
- * Validate if the key `K` in `T` is optional.
- *
- * 🎭 *validate*
- *
- * @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/ts/object/split.ts

@@ -1,203 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-import type { AnyRecord } from './any_record.js'
-import type { Omit } from './omit.js'
-import { reduceByKey } from './reduceKey.js'
-import type { Partial } from './Partial.js'
-import type { NonUndefined } from '../utils/NonUndefined.js'
-
-type Splitter<T extends AnyRecord> = Partial<{ [k in keyof T]: T[k] | undefined }>
-export type Split<T extends AnyRecord, S extends AnyRecord> = {
-	[k in keyof S]-?: S[k] extends undefined ? T[k] : NonNullable<T[k]> | NonUndefined<S[k]>
-}
-
-/**
- * Split an object into multiple objects.
- * @returns [...entries, remaining]
- */
-export function split<T extends AnyRecord, S1 extends Splitter<T>>(
-	target: T,
-	split1: S1
-): [Split<T, S1>, Omit<T, keyof S1>]
-export function split<T extends AnyRecord, S1 extends Splitter<T>, S2 extends Splitter<T>>(
-	target: T,
-	split1: S1,
-	split2: S2
-): [Split<T, S1>, Split<T, S2>, Omit<T, keyof S1 | keyof S2>]
-export function split<
-	T extends AnyRecord,
-	S1 extends Splitter<T>,
-	S2 extends Splitter<T>,
-	S3 extends Splitter<T>
->(
-	target: T,
-	splitter1: S1,
-	splitter2: S2,
-	splitter3: S3
-): [Split<T, S1>, Split<T, S2>, Split<T, S3>, Omit<T, keyof S1 | keyof S2 | keyof S3>]
-export function split<
-	T extends AnyRecord,
-	S1 extends Splitter<T>,
-	S2 extends Splitter<T>,
-	S3 extends Splitter<T>,
-	S4 extends Splitter<T>
->(
-	target: T,
-	splitter1: S1,
-	splitter2: S2,
-	splitter3: S3,
-	splitter4: S4
-): [
-	Split<T, S1>,
-	Split<T, S2>,
-	Split<T, S3>,
-	Split<T, S4>,
-	Omit<T, keyof S1 | keyof S2 | keyof S3 | keyof S4>
-]
-export function split<
-	T extends AnyRecord,
-	S1 extends Splitter<T>,
-	S2 extends Splitter<T>,
-	S3 extends Splitter<T>,
-	S4 extends Splitter<T>,
-	S5 extends Splitter<T>
->(
-	target: T,
-	splitter1: S1,
-	splitter2: S2,
-	splitter3: S3,
-	splitter4: S4,
-	splitter5: S5
-): [
-	Split<T, S1>,
-	Split<T, S2>,
-	Split<T, S3>,
-	Split<T, S4>,
-	Split<T, S5>,
-	Omit<T, keyof S1 | keyof S2 | keyof S3 | keyof S4 | keyof S5>
-]
-export function split<
-	T extends AnyRecord,
-	S1 extends Splitter<T>,
-	S2 extends Splitter<T>,
-	S3 extends Splitter<T>,
-	S4 extends Splitter<T>,
-	S5 extends Splitter<T>,
-	S6 extends Splitter<T>
->(
-	target: T,
-	splitter1: S1,
-	splitter2: S2,
-	splitter3: S3,
-	splitter4: S4,
-	splitter5: S5,
-	splitter6: S6
-): [
-	Split<T, S1>,
-	Split<T, S2>,
-	Split<T, S3>,
-	Split<T, S4>,
-	Split<T, S5>,
-	Split<T, S6>,
-	Omit<T, keyof S1 | keyof S2 | keyof S3 | keyof S4 | keyof S5 | keyof S6>
-]
-export function split<
-	T extends AnyRecord,
-	S1 extends Splitter<T>,
-	S2 extends Splitter<T>,
-	S3 extends Splitter<T>,
-	S4 extends Splitter<T>,
-	S5 extends Splitter<T>,
-	S6 extends Splitter<T>,
-	S7 extends Splitter<T>
->(
-	target: T,
-	splitter1: S1,
-	splitter2: S2,
-	splitter3: S3,
-	splitter4: S4,
-	splitter5: S5,
-	splitter6: S6,
-	splitter7: S7
-): [
-	Split<T, S1>,
-	Split<T, S2>,
-	Split<T, S3>,
-	Split<T, S4>,
-	Split<T, S5>,
-	Split<T, S6>,
-	Split<T, S7>,
-	Omit<T, keyof S1 | keyof S2 | keyof S3 | keyof S4 | keyof S5 | keyof S6 | keyof S7>
-]
-export function split<
-	T extends AnyRecord,
-	S1 extends Splitter<T>,
-	S2 extends Splitter<T>,
-	S3 extends Splitter<T>,
-	S4 extends Splitter<T>,
-	S5 extends Splitter<T>,
-	S6 extends Splitter<T>,
-	S7 extends Splitter<T>,
-	S8 extends Splitter<T>
->(
-	target: T,
-	splitter1: S1,
-	splitter2: S2,
-	splitter3: S3,
-	splitter4: S4,
-	splitter5: S5,
-	splitter6: S6,
-	splitter7: S7,
-	splitter8: S8
-): [
-	Split<T, S1>,
-	Split<T, S2>,
-	Split<T, S3>,
-	Split<T, S4>,
-	Split<T, S5>,
-	Split<T, S6>,
-	Split<T, S7>,
-	Split<T, S8>,
-	Omit<T, keyof S1 | keyof S2 | keyof S3 | keyof S4 | keyof S5 | keyof S6 | keyof S7 | keyof S8>
-]
-export function split<
-	T extends AnyRecord,
-	S1 extends Splitter<T>,
-	S2 extends Splitter<T>,
-	S3 extends Splitter<T>,
-	S4 extends Splitter<T>,
-	S5 extends Splitter<T>,
-	S6 extends Splitter<T>,
-	S7 extends Splitter<T>,
-	S8 extends Splitter<T>,
-	S9 extends Splitter<T>
->(
-	target: T,
-	splitter1: S1,
-	splitter2: S2,
-	splitter3: S3,
-	splitter4: S4,
-	splitter5: S5,
-	splitter6: S6,
-	splitter7: S7,
-	splitter8: S8,
-	splitter9: S9
-): [
-	Split<T, S1>,
-	Split<T, S2>,
-	Split<T, S3>,
-	Split<T, S4>,
-	Split<T, S5>,
-	Split<T, S6>,
-	Split<T, S7>,
-	Split<T, S8>,
-	Split<T, S9>,
-	Omit<T, keyof S1 | keyof S2 | keyof S3 | keyof S4 | keyof S5 | keyof S6 | keyof S7 | keyof S8 | keyof S9>
-]
-export function split(target: AnyRecord, ...splitters: AnyRecord[]): AnyRecord[] {
-	const keyMap: AnyRecord = {}
-	const s = splitters.map(s =>
-		reduceByKey(s, (p, k) => ((keyMap[k] = true), (p[k] = target[k] ?? s[k]), p), {} as AnyRecord)
-	)
-	const r = reduceByKey(target, (p, k) => (keyMap[k] ? p : ((p[k] = target[k]), p)), {} as AnyRecord)
-	return [...s, r]
-}

package/ts/object/typeOverrideIncompatible.ts

@@ -1,10 +0,0 @@
-import type { ANotB, AnyRecord } from './index.js'
-
-export function typeOverrideIncompatible<A extends AnyRecord>() {
-	return function <B extends AnyRecord>(source: B, override: ANotB<A, B>): A {
-		return {
-			...source,
-			...override
-		}
-	}
-}

package/ts/predicates/CanAssign.ts

@@ -1,71 +0,0 @@
-import type { NotExtendable } from './Extends.js'
-import type { IsEmptyObject } from './IsEmptyObject.js'
-
-/**
- * Can `A` assign to `B`
- *
- * Note that when union is involved, the assignability is measured distributively.
- * Meaning the result can be `Then | Else` (i.e. `boolean` by default),
- * instead of distinctive `Then` (`true`) or `Else` (`false`).
- *
- * This is the correct behavior.
- *
- * @example
- * ```ts
- * CanAssign<number | string, number> // boolean
- * ```
- *
- * We are checking can `A` assign to `B`.
- * Since `A` is `number | string`,
- * `A` can assign to `B` when `A` is number` (true), and
- * `A` cannot assign to `B` when `A` is string` (false).
- * So the result is `true | false = boolean`.
- *
- * If you want to make sure all branches are assignable,
- * use `StrictCanAssign<A, B>`.
- */
-export type CanAssign<A, B, Then = true, Else = false> = IsEmptyObject<A> extends true
-	? Record<string, unknown> extends B
-		? Then
-		: Else
-	: boolean extends A
-	? boolean extends B
-		? Then
-		: Else
-	: A extends B
-	? Then
-	: Else
-
-/**
- * Can `A` strictly assign to `B`.
- *
- * All branches in an union `A` are assignable to `B`.
- *
- * @example
- * ```ts
- * StrictCanAssign<number | string, number> // false
- * StrictCanAssign<number | string, number | string> // true
- * ```
- */
-export type StrictCanAssign<A, B, Then = true, Else = false> = IsEmptyObject<A> extends true
-	? Record<string, unknown> extends B
-		? Then
-		: Else
-	: boolean extends A
-	? boolean extends B
-		? Then
-		: Else
-	: [A] extends [B]
-	? Then
-	: Else
-
-/**
- * @deprecated use `CanAssign` instead
- */
-export type IsAssign<A, B, Then = true, Else = false> = CanAssign<A, B, Then, Else>
-
-export function canAssign<T>(canAssign: false): <S>(subject: NotExtendable<S, T>) => true
-export function canAssign<T>(): <S extends T>(subject: S) => CanAssign<S, T>
-export function canAssign<T>(): <S extends T>(subject: S) => any {
-	return () => true
-}

package/ts/predicates/Extends.ts

@@ -1,4 +0,0 @@
-export type Extendable<A, B, Then = A, Else = never> = A extends B ? Then : Else
-export type NotExtendable<A, B, Then = A, Else = never> = A extends B ? Else : Then
-export type IsExtend<A, B, Then = true, Else = false> = A extends B ? Then : Else
-export type IsNotExtend<A, B, Then = true, Else = false> = A extends B ? Else : Then

package/ts/predicates/index.ts

@@ -1,7 +0,0 @@
-export * from './CanAssign.js'
-export type { Extendable, IsExtend, IsNotExtend, NotExtendable } from './Extends.js'
-export type { If } from './If.js'
-export type { IsEmptyObject } from './IsEmptyObject.js'
-export type { IsLiteral } from './literal.js'
-export type { And, Not, Or, Xor } from './logical.js'
-

package/ts/predicates/literal.ts

@@ -1,35 +0,0 @@
-/**
- * Validate if specified type is a scalar literal.
- *
- * 🎭 *validate*
- *
- * @example
- * ```ts
- * type R = IsLiteral<string> // false
- * type R = IsLiteral<number> // false
- * type R = IsLiteral<boolean> // false
- * type R = IsLiteral<bigint> // false
- * type R = IsLiteral<symbol> // false
- *
- * type R = IsLiteral<'a'> // true
- * type R = IsLiteral<1> // true
- * type R = IsLiteral<true> // true
- * type R = IsLiteral<1n> // true
- * type R = IsLiteral<typeof someSymbol> // true
- * ```
- */
-export type IsLiteral<
-	T extends number | boolean | bigint | string | symbol,
-	Then = true,
-	Else = false
-> = number extends T
-	? Else
-	: string extends T
-	? Else
-	: boolean extends T
-	? Else
-	: symbol extends T
-	? Else
-	: bigint extends T
-	? Else
-	: Then

package/ts/promise/index.ts

@@ -1,5 +0,0 @@
-export * from './isPromise.js'
-export * from './mapSeries.js'
-export * from './MaybePromise.js'
-export type { PromiseValue, AwaitedProp } from './PromiseValue.js'
-export type { PromiseValueMerge } from './PromiseValueMerge.js'

package/ts/string/strict_string_type.ts

@@ -1,65 +0,0 @@
-import type { IsAny } from '../any/any_type.js'
-
-/**
- * Check if the type `T` is exactly `string`.
- *
- * ```ts
- * type R = StrictStringType<string> // string
- *
- * type R = StrictStringType<''> // never
- * type R = StrictStringType<'1'> // never
- * type R = StrictStringType<string | boolean> // never
- * type R = StrictStringType<never> // never
- * type R = StrictStringType<unknown> // never
- * ```
- */
-export type StrictStringType<T, Then = T, Else = never> = IsAny<
-	T,
-	Else,
-	[T, string] extends [string, T] ? Then : Else
->
-
-/**
- * Is the type `T` exactly `string`.
- *
- * ```ts
- * type R = IsStrictString<string> // true
- *
- * type R = IsStrictString<''> // false
- * type R = IsStrictString<'a'> // false
- * type R = IsStrictString<string | boolean> // false
- * type R = IsStrictString<never> // false
- * type R = IsStrictString<unknown> // false
- * ```
- */
-export type IsStrictString<T, Then = true, Else = false> = StrictStringType<T, Then, Else>
-
-/**
- * Check if the type `T` is not exactly `string`.
- *
- * ```ts
- * type R = NotStrictStringType<string> // never
- *
- * type R = NotStrictStringType<''> // ''
- * type R = NotStrictStringType<'a'> // 'a'
- * type R = NotStrictStringType<string | boolean> // string | boolean
- * type R = NotStrictStringType<never> // never
- * type R = NotStrictStringType<unknown> // unknown
- * ```
- */
-export type NotStrictStringType<T, Then = T, Else = never> = StrictStringType<T, Else, Then>
-
-/**
- * Is the type `T` not exactly `string`.
- *
- * ```ts
- * type R = IsNotStrictString<string> // false
- *
- * type R = IsNotStrictString<''> // true
- * type R = IsNotStrictString<'a'> // true
- * type R = IsNotStrictString<string | boolean> // true
- * type R = IsNotStrictString<never> // true
- * type R = IsNotStrictString<unknown> // true
- * ```
- */
-export type IsNotStrictString<T, Then = true, Else = false> = StrictStringType<T, Else, Then>

package/ts/string/string.ts

@@ -1,36 +0,0 @@
-/**
- * Check if `Subject` includes `Search`.
- * If either of them is not a string, returns `Else`.
- *
- * ```ts
- * type R = StringIncludes<'abc', 'a'> // true
- *
- * type R = StringIncludes<'abc', 'd'> // false
- * ```
- */
-export type StringIncludes<
-	Subject extends string,
-	Search extends string,
-	Then = true,
-	Else = false
-> = Subject extends `${infer _}${Search}${infer _}` ? Then : Else
-
-/**
- * Split a string into substrings using the specified separator,
- * and return them as an array.
- *
- * ```ts
- * type R = StringSplit<'abc', ''> // ['a', 'b', 'c']
- * type R = StringSplit<'abc', 'a'> // ['', 'bc']
- * type R = StringSplit<'abc', 'b'> // ['a', 'c']
- * type R = StringSplit<'abc', 'c'> // ['ab', '']
- * ```
- */
-export type StringSplit<
-	Subject extends string,
-	Seperator extends string
-> = Subject extends `${infer A}${Seperator}${infer B}`
-	? [A, ...StringSplit<B, Seperator>]
-	: Seperator extends ''
-	? []
-	: [Subject]