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

package/ts/array/array_type.ts

@@ -1,75 +0,0 @@
-import type { IsNever } from '../never/never_type.js'
-import type { StrictNumberType } from '../number/strict_number_type.js'
-
-/**
- * 🌪️ *filter*
- *
- * Filter `T` to ensure it is an array, excluding tuple.
- *
- * @example
- * ```ts
- * type R = ArrayType<number[]> // number[]
- *
- * type R = ArrayType<[1]> // never
- * type R = ArrayType<number[] | 1> // never
- * type R = ArrayType<number[] & { a: 1 }> // never
- * ```
- */
-export type ArrayType<T, Then = T, Else = never> = IsNever<
-	T,
-	Else,
-	[never[]] extends [T]
-	? ([T] extends [readonly any[]]
-		? StrictNumberType<T['length'], Then, Else>
-		: Else)
-	: Else
->
-
-/**
- * 🎭 *validate*
- *
- * Validate that `T` is an array, excluding tuple.
- *
- * @example
- * ```ts
- * type R = IsArray<number[]> // true
- *
- * type R = IsArray<number> // false
- * type R = IsArray<[1]> // false
- * ```
- */
-export type IsArray<T, Then = true, Else = false> = ArrayType<T, Then, Else>
-
-/**
- * 🌪️ *filter*
- *
- * Filter `T` to ensure it is not an array, excluding tuple.
- *
- * i.e. *tuple* will pass through this filter.
- *
- * @example
- * ```ts
- * type R = NotArrayType<number[]> // never
- *
- * type R = NotArrayType<number> // number
- * type R = NotArrayType<[1]> // [1]
- * ```
- */
-export type NotArrayType<T, Then = T, Else = never> = ArrayType<T, Else, Then>
-
-/**
- * 🎭 *validate*
- *
- * Validate that `T` is not an array, excluding tuple.
- *
- * i.e. *tuple* will pass through this filter.
- *
- * @example
- * ```ts
- * type R = IsNotArray<number[]> // false
- *
- * type R = IsNotArray<number> // true
- * type R = IsNotArray<[1]> // true
- * ```
- */
-export type IsNotArray<T, Then = true, Else = false> = ArrayType<T, Else, Then>

package/ts/array/find_first.ts

@@ -1,71 +0,0 @@
-import type { TupleType } from '../tuple/tuple_type.js'
-import type { Find as TupleFind } from '../tuple/tuple_plus.find.js'
-import type { Find as ArrayFind } from './array_plus.find.js'
-
-/**
- * 🦴 *utilities*
- * 🔢 *customizable*
- *
- * Find the first type in the array or tuple `A` that matches `Criteria`.
- *
- * If the `Criteria` is not met, it will return `never'.
- *
- * @example
- * ```ts
- * type R = FindFirst<[true, 1, 'x', 3], string> // 'x'
- * type R = FindFirst<[true, 1, 'x', 3], number> // 1
- * type R = FindFirst<[string, number, 1], 1> // widen: 1 | undefined
- * type R = FindFirst<[true, number | string], string> // unionMiss: string | undefined
- * type R = FindFirst<Array<string>, string> // string
- * type R = FindFirst<Array<1 | 2 | 'x'>, number> // 1 | 2 | undefined
- * type R = FindFirst<Array<string | number>, number | string> // string | number
- * type R = FindFirst<Array<number>, 1> // widen: 1 | undefined
- * type R = FindFirst<Array<string | number>, number> // unionMiss: number | undefined
- *
- * type R = FindFirst<[true, 1, 'x'], 2> // never
- * type R = FindFirst<string[], number> // never
- * ```
- *
- * @typeParam Options['widen'] performs widen match.
- * Default to `true`.
- * With widen match, a narrowed type will match its widen type.
- * e.g. matching `1` against `number` yields `1 | undefined`
- *
- * The widen behavior can be customized by `Options['$widen']`
- *
- * @typeParam Options['caseEmptyTuple'] return type when `A` is an empty tuple.
- * Default to `never`.
- *
- * @typeParam Options['$never'] return type when `A` is `never`. Default to `never`.
- *
- * @typeParam Options['$noMatch'] Return value when `T` does not match `Criteria`.
- * Default to `never`.
- *
- * @typeParam Options['$widen'] return type when `T` in `A` is a widen type of `Criteria`.
- * Default to `Criteria | undefined`.
- * Set it to `never` for a more type-centric behavior
- *
- * @typeParam Options['$unionMiss'] Return value when a branch of the union `T` does not match `Criteria`.
- * Default to `undefined`.
- * Since it is a union, the result will be join to the matched branch as union.
- */
-export type FindFirst<
-	A extends readonly unknown[],
-	Criteria, Options extends FindFirst.Options = FindFirst.DefaultOptions<Criteria>
-> = TupleType<
-	A,
-	TupleFind<A, Criteria, Options>,
-	ArrayFind<A, Criteria, Options>
->
-
-export namespace FindFirst {
-	export interface Options extends ArrayFind.Options, TupleFind.Options { }
-	export interface DefaultOptions<Criteria>
-		extends ArrayFind.DefaultOptions<Criteria>, TupleFind.DefaultOptions<Criteria> { }
-}
-
-
-/**
- * @deprecated use FindFirst
- */
-export type First<A extends any[], Criteria> = FindFirst<A, Criteria>

package/ts/array/head.ts

@@ -1,40 +0,0 @@
-import type { NeverType } from '../never/never_type.js'
-
-/**
- * 🦴 *utilities*
- * 🔢 *customizable*
- *
- * Gets the first entry in the tuple or the type of array `T`.
- *
- * @example
- * ```ts
- * type R = Head<[1, 2, 3]> // 1
- * type R = Head<string[]> // string
- *
- * type R = Head<[]> // never
- * ```
- *
- * @typeParam Options['$never'] Return type when `T` is `never`.
- * Default to `never`.
- *
- * @typeParam Options['caseEmptyTuple'] Return type when `T` is `[]`.
- * Default to `never`.
- */
-export type Head<
-	T extends readonly unknown[],
-	Options extends Head.Options = Head.DefaultOptions
-> = NeverType<
-	T,
-	Options['$never'],
-	T['length'] extends 0 ? Options['caseEmptyTuple'] : T[0]
->
-
-export namespace Head {
-	export interface Options extends NeverType.Options {
-		caseEmptyTuple?: unknown
-	}
-
-	export interface DefaultOptions extends NeverType.DefaultOptions {
-		caseEmptyTuple: never
-	}
-}

package/ts/array/last.ts

@@ -1,40 +0,0 @@
-import type { NeverType } from '../never/never_type.js'
-
-/**
- * 🦴 *utilities*
- *
- * Gets the last entry in the tuple or the type of array `T`.
- *
- * @example
- * ```ts
- * type R = Last<[1, 2, 3]> // 3
- * type R = Last<string[]> // string
- *
- * type R = Last<[]> // never
- * ```
- *
- * @typeParam Options['$never'] Return type when `T` is `never`.
- * Default to `never`.
- *
- * @typeParam Options['caseEmptyTuple'] Return type when `T` is `[]`.
- * Default to `never`.
- */
-export type Last<
-	T extends readonly unknown[],
-	Options extends Last.Options = Last.DefaultOptions
-> = NeverType<T,
-	Options['$never'],
-	T['length'] extends 0
-	? Options['caseEmptyTuple']
-	: T extends readonly [...unknown[], infer R] ? R : T[0]
->
-
-export namespace Last {
-	export interface Options extends NeverType.Options {
-		caseEmptyTuple?: unknown
-	}
-
-	export interface DefaultOptions extends NeverType.DefaultOptions {
-		caseEmptyTuple: never
-	}
-}

package/ts/array/loose_array_type.ts

@@ -1,69 +0,0 @@
-import type { IsAnyOrNever } from '../mix_types/any_or_never_type.js'
-
-/**
- * 🌪️ *filter*
- * 🚧 *temporary*
- *
- * Filter `T` to ensure it is an array or tuple.
- *
- * This is a temporary type before `ArrayType` is adjusted to loose check in the next version.
- *
- * @example
- * ```ts
- * type R = LooseArrayType<number[]> // number[]
- * type R = LooseArrayType<[1]> // [1]
- * type R = LooseArrayType<number[] | 1> // number[]
- * type R = LooseArrayType<number[] & 1> // number[]s
- *
- * type R = LooseArrayType<string> // never
- * ```
- */export type LooseArrayType<T, Then = T, Else = never> = IsAnyOrNever<
-	T,
-	Else,
-	T extends readonly any[] ? Then : Else
->
-
-/**
- * 🎭 *validate*
- *
- * Validate that `T` is an array or tuple.
- *
- * @example
- * ```ts
- * type R = IsLooseArray<number[]> // true
- * type R = IsLooseArray<[1]> // true
- *
- * type R = IsLooseArray<number> // false
- * ```
- */
-export type IsLooseArray<T, Then = true, Else = false> = LooseArrayType<T, Then, Else>
-
-/**
- * 🌪️ *filter*
- *
- * Filter `T` to ensure it is not an array nor tuple.
- *
- * @example
- * ```ts
- * type R = NotLooseArrayType<number[]> // never
- * type R = NotLooseArrayType<[1]> // never
- *
- * type R = NotLooseArrayType<number> // number
- * ```
- */
-export type NotLooseArrayType<T, Then = T, Else = never> = LooseArrayType<T, Else, Then>
-
-/**
- * 🎭 *validate*
- *
- * Validate that `T` is not an array nor tuple.
- *
- * @example
- * ```ts
- * type R = IsNotLooseArray<number[]> // false
- * type R = IsNotLooseArray<[1]> // false
- *
- * type R = IsNotLooseArray<number> // true
- * ```
- */
-export type IsNotLooseArray<T, Then = true, Else = false> = LooseArrayType<T, Else, Then>