type-plus 7.6.2 → 8.0.0-beta.2

package/ts/function/strict_function_type.ts

@@ -1,53 +0,0 @@
-import type { IsAnyOrNever } from '../mix_types/any_or_never_type.js'
-
-/**
- * Check if `T` is exactly `Function`.
- *
- * ```ts
- * type R = StrictFunctionType<Function> // Function
- *
- * type R = StrictFunctionType<() => void> // never
- * type R = StrictFunctionType<Function & { a: 1 }> // never
- * ```
- */
-export type StrictFunctionType<T, Then = T, Else = never> = IsAnyOrNever<
-	T,
-	Else,
-	[T, Function] extends [Function, T] ? Then : Else
->
-
-/**
- * Check if `T` is not exactly `Function`.
- *
- * ```ts
- * type R = NotStrictFunctionType<Function> // never
- * type R = NotStrictFunctionType<() => void> // () => void
- *
- * type R = NotStrictFunctionType<Function & { a: 1 }> // Function & { a: 1 }
- * ```
- */
-export type NotStrictFunctionType<T, Then = T, Else = never> = StrictFunctionType<T, Else, Then>
-
-/**
- * Is `T` exactly `Function`.
- *
- * ```ts
- * type R = IsStrictFunction<Function> // true
- *
- * type R = IsStrictFunction<() => void> // false
- * type R = IsStrictFunction<(() => void) & { a: 1 }> // false
- * ```
- */
-export type IsStrictFunction<T, Then = true, Else = false> = StrictFunctionType<T, Then, Else>
-
-/**
- * Is `T` not exactly `Function`.
- *
- * ```ts
- * type R = IsNotStrictFunction<Function> // false
- *
- * type R = IsNotStrictFunction<() => void> // true
- * type R = IsNotStrictFunction<(() => void) & { a: 1 }> // true
- * ```
- */
-export type IsNotStrictFunction<T, Then = true, Else = false> = StrictFunctionType<T, Else, Then>

package/ts/functional/Maybe.ts

@@ -1,22 +0,0 @@
-import type { Brand } from '../nominal/index.js'
-import type { IsEqual } from '../equal/equal.js'
-import type { Widen } from '../utils/index.js'
-
-export type Maybe<T> = Just<T> | None<T>
-export type Just<T> = Brand<'maybe', T> & { unwrap(): T }
-export type None<T> = Brand<'maybe', void> & { unwrap(): T }
-
-export function just<T>(
-	value: T
-): IsEqual<T, undefined | null> extends true ? None<T> : Just<Widen<NonNullable<T>>> {
-	// eslint-disable-next-line @typescript-eslint/no-unsafe-return
-	return {
-		unwrap() {
-			return value
-		}
-	} as any
-}
-
-export function none<T>(): None<T> {
-	return { unwrap() {} } as None<T>
-}

package/ts/functional/compose.ts

@@ -1,17 +0,0 @@
-import type { Head } from '../array/head.js'
-import type { Last } from '../array/last.js'
-import type { AnyFunction } from '../function/any_function.js'
-
-/**
- * Compose functions to produce a new function.
- * @params args functions to be composed.
- * Each function will receive the return value of the previous function as its parameters.
- * @return The composed function will expect the parameters of the first function,
- * and return the result of the last function.
- */
-export function compose<FS extends AnyFunction[]>(
-	...fns: FS
-): (...args: Parameters<Head<FS>>) => ReturnType<Last<FS>> {
-	// eslint-disable-next-line @typescript-eslint/no-unsafe-return
-	return (...args: any[]) => fns.reduce((args, fn) => [fn(...args)], args)[0]
-}

package/ts/functional/context.ts

@@ -1,66 +0,0 @@
-import type { LeftJoin } from '../object/index.js'
-
-export type ContextBaseShape = Record<string | symbol, any>
-
-/**
- * Extends the context with new props.
- * @param context the current context.
- * @return an additional context with new properties.
- */
-export type ContextExtender<Current, Additional> = (context: Current) => Additional
-
-export type ContextBuilder<Init extends ContextBaseShape, Ctx extends ContextBaseShape> = {
-	/**
-	 * Extends the context using an extender.
-	 *
-	 * @type Additional The additional context to be added by the `extender`.
-	 * By default this is inferred by the `extender`.
-	 * But you can also explicitly specify it,
-	 * if the type is a superset of the actual return type of the `extender`.
-	 * @param extender function that add new props to the context.
-	 *
-	 * The extender only need to return a new object with additional properties.
-	 * The builder will merge that with the current context.
-	 *
-	 * If the extender specify an existing property,
-	 * it overrides the existing value.
-	 */
-	extend<Additional extends ContextBaseShape = ContextBaseShape>(
-		extender: ContextExtender<Ctx, Additional>
-	): ContextBuilder<Init, LeftJoin<Ctx, Additional>>,
-	/**
-	 * Build and return the context.
-	 */
-	build(): Ctx
-}
-
-/**
- * Creates a context builder.
- *
- * @param init The initial context or an context initializer.
- * @return the context builder where you can
- * use `extend()` to add context, and
- * use `build()` to build the context.
- */
-export function context<Init extends ContextBaseShape, Ctx extends ContextBaseShape = Init>(
-	init?: Init | (() => Init)
-): ContextBuilder<Init, Ctx> {
-	// eslint-disable-next-line @typescript-eslint/no-unsafe-return
-	return typeof init === 'function' ? contextBuilder({}, [[init]]) : (contextBuilder(init ?? {}, []) as any)
-}
-
-/* eslint-disable */
-function contextBuilder(init: ContextBaseShape, extenders: Array<[ContextExtender<any, any> | any]>) {
-	return {
-		extend(extender: ContextExtender<any, any>) {
-			return contextBuilder(init, extenders.concat([[extender]]))
-		},
-		build() {
-			return extenders.reduce((p, [t], i) => {
-				const v = typeof t === 'function' ? (extenders[i]![0] = t(p)) : t
-				return { ...p, ...v }
-			}, init)
-		}
-	}
-}
-/* eslint-enable */

package/ts/index.ts

@@ -1,121 +0,0 @@
-export type { AnyType, IsAny, IsNotAny, NotAnyType } from './any/any_type.js'
-export type { At } from './array/array.at.js'
-export type { FindLast } from './array/array.find_last.js'
-export type { Some } from './array/array.some.js'
-export type { Concat } from './array/array_plus.concat.js'
-export * as ArrayPlus from './array/array_plus.js'
-export type { ArrayType, IsArray, IsNotArray, NotArrayType } from './array/array_type.js'
-export type { Filter, KeepMatch } from './array/filter.js'
-export type { FindFirst } from './array/find_first.js'
-export type { Head } from './array/head.js'
-export type { IntersectOfProps, MapToProp } from './array/intersect_of_props.js'
-export type { Last } from './array/last.js'
-export { literalArray } from './array/literal_array.js'
-export type { PadStart } from './array/pad_start.js'
-export { reduceWhile } from './array/reduce_while.js'
-export type { Reverse } from './array/reverse.js'
-export type { PropUnion, UnionOfProps } from './array/union_of_props.js'
-export type { UnionOfValues } from './array/union_of_values.js'
-export { assertType } from './assertion/assert_type.js'
-export type { BigintType, IsBigint, IsNotBigint, NotBigintType } from './bigint/bigint_type.js'
-export type { StringToBigint } from './bigint/cast.js'
-export type {
-	IsNotStrictBigint,
-	IsStrictBigint,
-	NotStrictBigintType,
-	StrictBigintType
-} from './bigint/strict_bigint_type.js'
-export type { BooleanType, IsBoolean, IsNotBoolean, NotBooleanType } from './boolean/boolean_type.js'
-export type { FalseType, IsFalse, IsNotFalse, NotFalseType } from './boolean/false_type.js'
-export type {
-	IsNotStrictBoolean,
-	IsStrictBoolean,
-	NotStrictBooleanType,
-	StrictBooleanType
-} from './boolean/strict_boolean_type.js'
-export type { IsNotTrue, IsTrue, NotTrueType, TrueType } from './boolean/true_type.js'
-export * from './class/index.js'
-export type { ComposableTypes, NonComposableTypes } from './composable_types.js'
-export type { Equal, IsEqual, IsNotEqual, NotEqual } from './equal/equal.js'
-export type { AnyFunction } from './function/any_function.js'
-export * from './function/extract_function.js'
-export type { FunctionType, IsFunction, IsNotFunction, NotFunctionType } from './function/function_type.js'
-export type {
-	IsNotStrictFunction,
-	IsStrictFunction,
-	NotStrictFunctionType,
-	StrictFunctionType
-} from './function/strict_function_type.js'
-export * from './functional/index.js'
-export type { JSONArray, JSONObject, JSONPrimitive, JSONTypes } from './json.js'
-export type { Abs, Add, Decrement, GreaterThan, Increment, Max, Multiply, Subtract } from './math/index.js'
-export * as MathPlus from './math/math_plus.js'
-export type { AnyOrNeverType, IsAnyOrNever } from './mix_types/any_or_never_type.js'
-export type { IsNever, IsNotNever, Is_Never, NeverType, NotNeverType, Not_Never } from './never/never_type.js'
-export * from './nodejs/index.js'
-export * from './nominal/index.js'
-export type { IsNotNull, IsNull, NotNullType, NullType } from './null/null_type.js'
-export type { StringToNumber } from './number/cast.js'
-export * as NumberPlus from './number/number_plus.js'
-export type { IsNotNumber, IsNumber, NotNumberType, NumberType } from './number/number_type.js'
-export type {
-	IsNotStrictNumber,
-	IsStrictNumber,
-	NotStrictNumberType,
-	StrictNumberType
-} from './number/strict_number_type.js'
-export type { NumericToString, StringToNumeric } from './numeric/cast.js'
-export type { Integer, IsInteger, IsNotInteger, IsWhole, NotInteger } from './numeric/integer.js'
-export type { IsNegative, IsNotNegative, Negative, NotNegative } from './numeric/negative.js'
-export * as NumericPlus from './numeric/numeric_plus.js'
-export type {
-	IsNotNumeric,
-	IsNumeric,
-	NotNumericType,
-	Numeric,
-	NumericType,
-	Zero
-} from './numeric/numeric_type.js'
-export type { IsNotPositive, IsPositive, NonPositive, Positive } from './numeric/positive.js'
-export type { Required, RequiredExcept, RequiredPick } from './object/Required.js'
-export * from './object/index.js'
-export type { IsNotObject, IsObject, NotObjectType, ObjectType } from './object/object_type.js'
-export * from './predicates/index.js'
-export type { PrimitiveTypes } from './primitive.js'
-export * from './promise/index.js'
-export type {
-	IsNotStrictString,
-	IsStrictString,
-	NotStrictStringType,
-	StrictStringType
-} from './string/strict_string_type.js'
-export type { StringIncludes, StringSplit } from './string/string.js'
-export type { StringPlus } from './string/string_plus.js'
-export type { IsNotString, IsString, NotStringType, StringType } from './string/string_type.js'
-export type { IsNotSymbol, IsSymbol, NotSymbolType, SymbolType } from './symbol/symbol_type.js'
-export * from './testing/stub.js'
-export * from './testing/test_type.js'
-export type { CommonKeys, CommonPropKeys } from './tuple/common_prop_keys.js'
-export * from './tuple/create_tuple.js'
-export { drop } from './tuple/drop.js'
-export type { DropFirst, DropLast, DropMatch, DropNull, DropNullable, DropUndefined } from './tuple/drop.js'
-export type { Tail } from './tuple/tail.js'
-export * as TuplePlus from './tuple/tuple_plus.js'
-export type { IsNotTuple, IsTuple, NotTupleType, TupleType } from './tuple/tuple_type.js'
-export * from './type-guard/is_type.js'
-export type { Failed, FailedT } from './type/failed.js'
-export type { NoInfer } from './type/no_infer.js'
-export type {
-	IsNotUndefined,
-	IsUndefined,
-	NotUndefinedType,
-	UndefinedType
-} from './undefined/undefined_type.js'
-export type { IsUnion, UnionType } from './union/union.js'
-export type { UnionKeys } from './union_keys.js'
-export type { IsNotUnknown, IsUnknown, NotUnknownType, UnknownType } from './unknown/unknown_type.js'
-export * from './unpartial.js'
-export * from './utils/index.js'
-export type { MergeOptions as MergeCases } from './utils/options.js'
-export type { IsNotVoid, IsVoid, NotVoidType, VoidType } from './void/void_type.js'
-

package/ts/math/abs.ts

@@ -1,18 +0,0 @@
-import type { IsBigint } from '../bigint/bigint_type.js'
-import type { IsNumber } from '../number/number_type.js'
-
-/*
- * Returns the absolute value of a number or bigint `N`.
- *
- * @example
- * ```ts
- * Abs<-5> // 5
- * Abs<5> // 5
- * Abs<-1n> // 1n  // Where `1n` is a bigint
- * ```
- */
-export type Abs<N extends number | bigint, Fail = never> = IsNumber<
-	N,
-	[number] extends [N] ? Fail : `${N}` extends `-${infer P extends number}` ? P : N,
-	IsBigint<N, [bigint] extends [N] ? Fail : `${N}` extends `-${infer P extends bigint}` ? P : N, Fail>
->

package/ts/math/greater_than.ts

@@ -1,12 +0,0 @@
-import type { IsPositive } from '../numeric/positive.js'
-import type { Subtract } from './subtract.js'
-
-export type GreaterThan<A extends number | bigint, B extends number | bigint, Fail = never> = Subtract<
-	A,
-	B,
-	'fail'
-> extends infer R extends number
-	? R extends 0
-		? false
-		: IsPositive<R>
-	: Fail

package/ts/math/index.ts

@@ -1,7 +0,0 @@
-export type { Abs } from './abs.js'
-// export type { Digit, DigitArray } from './Digit.js'
-export type { GreaterThan } from './greater_than.js'
-export type { Max } from './max.js'
-export type { Add, Increment } from './add.js'
-export type { Multiply } from './multiply.js'
-export type { Decrement, Subtract } from './subtract.js'

package/ts/math/max.ts

@@ -1,13 +0,0 @@
-import type { IsNever } from '../never/never_type.js'
-import type { GreaterThan } from './greater_than.js'
-
-export type Max<A extends number | bigint, B extends number | bigint, Fail = never> = GreaterThan<
-	A,
-	B
-> extends infer Result
-	? IsNever<Result> extends true
-		? Fail
-		: Result extends true
-		? A
-		: B
-	: never