type-plus 7.6.2 → 8.0.0-beta.2

package/ts/object/record.ts

@@ -1,23 +0,0 @@
-import type { Widen } from '../utils/index.js'
-import type { AnyRecord } from './AnyRecord.js'
-import type { KeyTypes } from './KeyTypes.js'
-
-/**
- * Creates a `Record<Key, Value>` or your custom record.
- * By default,
- * `record()` will widen the keys (`K`) you specified in the `value` to form `Record<Widen<K>, V>`.
- *
- * You can also override it by specifying a custom record, e.g.:
- * `record<{ a: number }>()`
- */
-export function record<K extends KeyTypes, V>(value?: Record<K, V>): Record<Widen<K>, V>
-export function record<R extends Record<any, any>>(value?: R): R
-export function record(value?: any) {
-	const r = Object.create(null) as AnyRecord
-	return (value ? Object.assign(r, value) : r) as AnyRecord
-}
-
-/**
- * Gets the value type `T` from `Record<any, T>`.
- */
-export type RecordValue<R extends Record<any, any>> = R extends Record<any, infer T> ? T : never

package/ts/object/recursive_partial.ts

@@ -1,39 +0,0 @@
-// 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 './AnyRecord.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
-}

package/ts/object/replaceProperty.ts

@@ -1,11 +0,0 @@
-import type { AnyRecord } from './AnyRecord.js'
-
-export type ReplaceProperty<T extends AnyRecord, K extends keyof T, V> = Omit<T, K> & { [P in K]: V }
-
-export function replaceProperty<T extends AnyRecord, K extends keyof T, V>(
-	subject: T,
-	key: K,
-	value: V
-): ReplaceProperty<T, K, V> {
-	return { ...subject, [key]: value }
-}

package/ts/object/split.ts

@@ -1,203 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-import type { AnyRecord } from './AnyRecord.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]

package/ts/string/string_plus.ts

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

package/ts/string/string_type.ts

@@ -1,61 +0,0 @@
-import type { IsAnyOrNever } from '../mix_types/any_or_never_type.js'
-
-/**
- * Check if the type `T` is `string` or string literals.
- *
- * ```ts
- * type R = StringType<string> // string
- * type R = StringType<''> // ''
- * type R = StringType<'1'> // '1'
- *
- * type R = StringType<string | boolean> // never
- * type R = StringType<never> // never
- * type R = StringType<unknown> // never
- * ```
- */
-export type StringType<T, Then = T, Else = never> = IsAnyOrNever<T, Else, [T] extends [string] ? Then : Else>
-
-/**
- * Is the type `T` `string` or string literals.
- *
- * ```ts
- * type R = IsString<string> // true
- * type R = IsString<''> // true
- * type R = IsString<'a'> // true
- *
- * type R = IsString<string | boolean> // false
- * type R = IsString<never> // false
- * type R = IsString<unknown> // false
- * ```
- */
-export type IsString<T, Then = true, Else = false> = StringType<T, Then, Else>
-
-/**
- * Check if the type `T` is not `string` nor string literals.
- *
- * ```ts
- * type R = NotStringType<string> // never
- * type R = NotStringType<''> // ''
- * type R = NotStringType<'a'> // 'a'
- *
- * type R = NotStringType<string | boolean> // string | boolean
- * type R = NotStringType<never> // never
- * type R = NotStringType<unknown> // unknown
- * ```
- */
-export type NotStringType<T, Then = T, Else = never> = StringType<T, Else, Then>
-
-/**
- * Is the type `T` not `string` nor string literals.
- *
- * ```ts
- * type R = IsNotString<string> // false
- * type R = IsNotString<''> // false
- * type R = IsNotString<'a'> // false
- *
- * type R = IsNotString<string | boolean> // true
- * type R = IsNotString<never> // true
- * type R = IsNotString<unknown> // true
- * ```
- */
-export type IsNotString<T, Then = true, Else = false> = StringType<T, Else, Then>

package/ts/symbol/symbol_type.ts

@@ -1,53 +0,0 @@
-import type { IsAnyOrNever } from '../mix_types/any_or_never_type.js'
-
-/**
- * Check if the type `T` is exactly `symbol`.
- *
- * ```ts
- * type R = SymbolType<symbol> // symbol
- *
- * type R = SymbolType<never> // never
- * type R = SymbolType<unknown> // never
- * type R = SymbolType<symbol | boolean> // never
- * ```
- */
-export type SymbolType<T, Then = T, Else = never> = IsAnyOrNever<T, Else, [T] extends [symbol] ? Then : Else>
-
-/**
- * Is the type `T` exactly `symbol`.
- *
- * ```ts
- * type R = IsSymbol<symbol> // true
- *
- * type R = IsSymbol<never> // false
- * type R = IsSymbol<unknown> // false
- * type R = IsSymbol<symbol | boolean> // false
- * ```
- */
-export type IsSymbol<T, Then = true, Else = false> = SymbolType<T, Then, Else>
-
-/**
- * Check if the type `T` is not `symbol`.
- *
- * ```ts
- * type R = NotSymbolType<symbol> // never
- *
- * type R = NotSymbolType<never> // never
- * type R = NotSymbolType<unknown> // unknown
- * type R = NotSymbolType<symbol | boolean> // symbol | boolean
- * ```
- */
-export type NotSymbolType<T, Then = T, Else = never> = SymbolType<T, Else, Then>
-
-/**
- * Is the type `T` not `symbol`.
- *
- * ```ts
- * type R = IsNotSymbol<symbol> // false
- *
- * type R = IsNotSymbol<never> // true
- * type R = IsNotSymbol<unknown> // true
- * type R = IsNotSymbol<symbol | boolean> // true
- * ```
- */
-export type IsNotSymbol<T, Then = true, Else = false> = SymbolType<T, Else, Then>