type-plus 6.2.0 → 6.4.0

package/ts/array_plus/pad_left.ts

@@ -1,16 +0,0 @@
-import type { IsAny } from '../any_plus/any.js'
-import type { Equal } from '../predicates/index.js'
-import type { CreateTuple } from './create_tuple.js'
-import type { UnionOfValues } from './union_of_values.js'
-
-export type PadLeft<A extends any[], Total extends number, PadWith = any> = number extends A['length']
-	? IsAny<UnionOfValues<A>> extends true
-		? A
-		: Equal<UnionOfValues<A>, PadWith> extends true
-		? A
-		: PadLeft<[...CreateTuple<Total, PadWith>, ...A], Total, PadWith>
-	: CreateTuple<Total, any> extends [...infer U, ...A]
-	? number extends U['length']
-		? A
-		: [...CreateTuple<U['length'], PadWith>, ...A]
-	: A

package/ts/array_plus/some.ts

@@ -1,33 +0,0 @@
-import type { Equal } from '../predicates/index.js'
-import type { Tail } from './tail.js'
-import type { UnionOfValues } from './union_of_values.js'
-
-export type Some<
-	A extends any[],
-	Criteria,
-	Mode extends 'strict' | 'loose' = 'loose',
-	Then = true,
-	Else = false
-> = Mode extends 'strict'
-	? Some.Strict<A, Criteria, Then, Else>
-	: number extends A['length']
-	? UnionOfValues<A> extends Criteria
-		? Then
-		: Else
-	: A['length'] extends 0
-	? Else
-	: A[0] extends Criteria
-	? Then
-	: Some<Tail<A>, Criteria, 'loose', Then, Else>
-
-export namespace Some {
-	export type Strict<A extends any[], Criteria, Then, Else> = number extends A['length']
-		? Equal<UnionOfValues<A>, Criteria> extends true
-			? Then
-			: Else
-		: A['length'] extends 0
-		? Else
-		: Equal<A[0], Criteria> extends true
-		? Then
-		: Strict<Tail<A>, Criteria, Then, Else>
-}

package/ts/assertion/assertType.ts

@@ -1,107 +0,0 @@
-import { tersify } from 'tersify'
-import { isConstructor, type AnyConstructor } from '../class/index.js'
-import type { AnyFunction } from '../function/index.js'
-
-/**
- * assert the subject satisfies the specified type T
- * @type T the type to check against.
- */
-export function assertType<T>(subject: T): asserts subject is T
-export function assertType<T>(subject: unknown, validator: (s: T) => boolean): asserts subject is T
-export function assertType<T extends new (...args: any) => any>(
-	subject: unknown,
-	constructor: T
-): asserts subject is InstanceType<T>
-export function assertType(subject: unknown, validator?: (s: any) => boolean) {
-	if (validator) {
-		if ((isConstructor(validator) && !(subject instanceof validator)) || !validator(subject))
-			throw new TypeError(`subject fails to satisfy ${tersify(validator)}`)
-	}
-	return
-}
-
-assertType.isUndefined = function (subject: undefined): asserts subject is undefined {
-	if (typeof subject !== 'undefined') throw TypeError(`subject is not undefined`)
-}
-assertType.noUndefined = function <S>(subject: Exclude<S, undefined>): void {
-	if (typeof subject === 'undefined') throw TypeError(`subject is undefined`)
-}
-
-assertType.isNull = function (subject: null): asserts subject is null {
-	if (subject !== null) throw TypeError(`subject is not null`)
-}
-assertType.noNull = function <S>(subject: Exclude<S, null>): void {
-	if (subject === null) throw TypeError(`subject is null`)
-}
-
-assertType.isNumber = function (subject: number): asserts subject is number {
-	if (typeof subject !== 'number') throw TypeError(`subject is not number`)
-}
-assertType.noNumber = function <S>(subject: Exclude<S, number>): void {
-	if (typeof subject === 'number') throw TypeError(`subject is number`)
-}
-
-assertType.isBoolean = function (subject: boolean): asserts subject is boolean {
-	if (typeof subject !== 'boolean') throw TypeError(`subject is not boolean`)
-}
-assertType.noBoolean = function <S>(subject: Exclude<S, boolean>): void {
-	if (typeof subject === 'boolean') throw TypeError(`subject is boolean`)
-}
-
-assertType.isTrue = function (subject: true): asserts subject is true {
-	if (subject !== true) throw TypeError(`subject is not true`)
-}
-assertType.noTrue = function <S>(subject: Exclude<S, true>): void {
-	// @ts-ignore
-	if (subject === true) throw TypeError(`subject is true`)
-}
-
-assertType.isFalse = function (subject: false): asserts subject is false {
-	if (subject !== false) throw TypeError(`subject is not false`)
-}
-assertType.noFalse = function <S>(subject: Exclude<S, false>): void {
-	// @ts-ignore
-	if (subject === false) throw TypeError(`subject is false`)
-}
-
-assertType.isString = function (subject: string): asserts subject is string {
-	if (typeof subject !== 'string') throw TypeError(`subject is not string`)
-}
-assertType.noString = function <S>(subject: Exclude<S, string>): void {
-	if (typeof subject === 'string') throw TypeError(`subject is string`)
-}
-
-assertType.isFunction = function (subject: AnyFunction): asserts subject is AnyFunction {
-	if (typeof subject !== 'function') throw TypeError(`subject is not function`)
-}
-assertType.noFunction = function <S>(subject: Exclude<S, AnyFunction>): void {
-	if (typeof subject === 'function') throw TypeError(`subject is function`)
-}
-
-assertType.isConstructor = function (subject: AnyConstructor): asserts subject is AnyConstructor {
-	if (!isConstructor(subject)) throw TypeError(`subject is not a constructor`)
-}
-
-assertType.isError = function (subject: Error): asserts subject is Error {
-	if (!(subject instanceof Error)) throw TypeError(`subject is not an Error`)
-}
-assertType.noError = function <S>(subject: Exclude<S, Error>): void {
-	if (subject instanceof Error) throw TypeError(`subject is an Error`)
-}
-
-assertType.isNever = function (subject: never): asserts subject is never {}
-
-/**
- * creates a custom assertion function with standard TypeError.
- * Currently this requires explicity type annotation,
- * thus making it hard to use:
- * https://github.com/microsoft/TypeScript/issues/41047
- */
-assertType.custom = function <T>(validator: (s: T) => boolean): (subject: unknown) => asserts subject is T {
-	return function (subject) {
-		if (!validator(subject as any)) throw new TypeError(`subject fails to satisfy ${tersify(validator)}`)
-		return
-	}
-}
-
-assertType.as = function <T>(subject: unknown): asserts subject is T {}

package/ts/assertion/index.ts

@@ -1 +0,0 @@
-export * from './assertType.js'

package/ts/function/ExtractFunction.ts

@@ -1,20 +0,0 @@
-import type { AnyFunction } from './AnyFunction.js'
-
-/**
- * Extract the function signature from a composite type T.
- *
- * It works with interact of functions, but not on function overloads and union.
- * @note does not work with function overloads.
- */
-export type ExtractFunction<T extends AnyFunction> = T extends AnyFunction<infer P, infer R>
-	? (...args: P) => R
-	: never
-
-/**
- * Extract the function signature from a composite function.
- *
- * @note does not work with function overloads.
- */
-export function extractFunction<T extends AnyFunction>(fn: T) {
-	return fn as any as ExtractFunction<T>
-}

package/ts/function/index.ts

@@ -1,2 +0,0 @@
-export type { AnyFunction } from './AnyFunction.js'
-export * from './ExtractFunction.js'

package/ts/nominal-types/Brand.ts

@@ -1,34 +0,0 @@
-// By Drew Colthorp, <https://spin.atomicobject.com/2018/01/15/typescript-flexible-nominal-typing/#comment-604580>
-// <https://gist.github.com/dcolthorp/aa21cf87d847ae9942106435bf47565d>
-
-import { Widen } from '../utils/index.js'
-import { typeSym, valueSym } from './types.js'
-
-/**
- * Create a "branded" version of a type.
- * TypeScript won't allow implicit conversion to this type
- */
-export type Brand<B extends string, T> = T extends object
-	? T & { [typeSym]: B }
-	: { [typeSym]: B; [valueSym]: T }
-
-/**
- * Creates a brand creator with the specified type.
- */
-export function brand<B extends string>(type: B): <T>(subject: T) => Brand<B, Widen<T>>
-/**
- * Creates a branded value of specified type.
- */
-export function brand<B extends string, T>(type: B, subject: T): Brand<B, Widen<T>>
-export function brand(type: string, subject?: unknown) {
-	if (subject === undefined)
-		return function <T>(subject: T) {
-			return brand(type, subject)
-		}
-
-	if (typeof subject === 'object' && subject !== null) {
-		// if subject is not an object, the branding will exist only in type-level.
-		;(subject as { [typeSym]: string })[typeSym] = type
-	}
-	return subject
-}

package/ts/nominal-types/Flavor.ts

@@ -1,35 +0,0 @@
-// By Drew Colthorp, <https://spin.atomicobject.com/2018/01/15/typescript-flexible-nominal-typing/#comment-604580>
-// <https://gist.github.com/dcolthorp/aa21cf87d847ae9942106435bf47565d>
-
-import type { Widen } from '../utils/index.js'
-import { typeSym } from './types.js'
-
-/**
- * Create a "flavored" version of a type.
- * TypeScript will disallow mixing flavors,
- * but will allow unflavored values of that type to be passed in where a flavored version is expected.
- * This is a less restrictive form of branding.
- */
-export type Flavor<F extends string, T> = T & {
-	[typeSym]?: F
-}
-
-/**
- * Creates a brand creator with the specified type.
- */
-export function flavor<F extends string>(type: F): <T>(subject: T) => Flavor<F, Widen<T>>
-/**
- * Creates a branded value of specified type.
- */
-export function flavor<F extends string, T>(type: F, subject: T): Flavor<F, Widen<T>>
-export function flavor(type: string, subject?: unknown) {
-	if (subject === undefined)
-		return function <T>(subject: T) {
-			return flavor(type, subject)
-		}
-	if (typeof subject === 'object' && subject !== null) {
-		// if subject is not an object, the branding will exist only in type-level.
-		;(subject as { [typeSym]: string })[typeSym] = type
-	}
-	return subject
-}

package/ts/nominal-types/index.ts

@@ -1,3 +0,0 @@
-export * from './Brand.js'
-export * from './Flavor.js'
-export * from './nominalMatch.js'

package/ts/nominal-types/nominalMatch.ts

@@ -1,22 +0,0 @@
-import type { Brand } from './Brand.js'
-import type { Flavor } from './Flavor.js'
-import { typeSym } from './types.js'
-
-export function nominalMatch<A extends string, B extends A>(
-	a: Brand<A, unknown>,
-	b: Brand<B, unknown>
-): boolean
-export function nominalMatch<A extends string, B extends A>(
-	a: Flavor<A, unknown>,
-	b: Flavor<B, unknown>
-): boolean
-export function nominalMatch<A extends string, B extends A>(
-	a: Brand<A, unknown> | Flavor<A, unknown>,
-	b: Brand<B, unknown> | Flavor<B, unknown>
-) {
-	if (typeof a === 'object' && a !== null && typeof b === 'object' && b !== null)
-		return a[typeSym] === b[typeSym]
-	else {
-		return true
-	}
-}

package/ts/number_plus/index.ts

@@ -1 +0,0 @@
-export type * from './number.js'

package/ts/number_plus/number.ts

@@ -1,149 +0,0 @@
-import type { IsNever } from '../PrimitiveTypes.js'
-import type { IsAny } from '../any_plus/any.js'
-
-/**
- * Either number or bigint.
- */
-export type Numeric = number | bigint
-
-/**
- * The value 0 in number or bigint.
- */
-export type Zero = 0 | 0n
-
-/**
- * Check if the value is an integer.
- *
- * ```
- * import type { Integer } from 'type-plus'
- *
- * type R = Integer<0> // 0
- * type R = Integer<1.1> // never
- * type R = Integer<number> // never as it contains non-integer
- *
- * type R = Integer<0, true, false> // true
- * type R = Integer<1.1, true, false> // false
- * ```
- */
-export type Integer<N extends Numeric, Then = N, Else = never> = IsNever<
-	N,
-	Else,
-	`${N}` extends `${bigint}` ? Then : Else
->
-/**
- * Check if the value is an integer.
- *
- * ```
- * import type { IsInteger } from 'type-plus'
- *
- * type R = IsInteger<0> // 0
- * type R = IsInteger<1.1> // never
- * type R = IsInteger<number> // never as it contains non-integer
- *
- * type R = IsInteger<0, true, false> // true
- * type R = IsInteger<1.1, true, false> // false
- * ```
- */
-export type IsInteger<N extends Numeric, Then = true, Else = false> = Integer<N, Then, Else>
-
-/**
- * Check if the value is an integer.
- *
- * ```
- * import type { IsWhole } from 'type-plus'
- *
- * type R = IsWhole<0> // 0
- * type R = IsWhole<1.1> // never
- * type R = IsWhole<number> // never as it contains non-integer
- *
- * type R = IsWhole<0, true, false> // true
- * type R = IsWhole<1.1, true, false> // false
- * ```
- */
-export type IsWhole<N extends Numeric, Then = true, Else = false> = Integer<N, Then, Else>
-
-/**
- * Check if the value is a negative number.
- *
- * ```
- * import type { Negative } from 'type-plus'
- *
- * type R = Negative<-1> // -1
- * type R = Negative<0> // never
- *
- * type R = Negative<-1, true, false> // true
- * type R = Negative<1, true, false> // false
- * ```
- */
-export type Negative<N extends Numeric, Then = N, Else = never> = IsNever<
-	N,
-	Else,
-	N extends Zero ? Else : `${N}` extends `-${string}` ? Then : Else
->
-
-/**
- * Check if the value it not a negative number.
- *
- * ```
- * import type { NonNegative } from 'type-plus'
- *
- * type R = NonNegative<-1> // never
- * type R = NonNegative<0> // 0
- *
- * type R = NonNegative<-1, true, false> // false
- * type R = NonNegative<1, true, false> // true
- * ```
- */
-export type NonNegative<N extends Numeric, Then = N, Else = never> = Negative<N, Else, Then>
-
-/**
- * Check if the type `T` is exactly the type `number` and not numeric literals.
- *
- * ```
- * import type { NumberType } from 'type-plus'
- *
- * type R = NumberType<number> // true
- * type R = NumberType<1> // false
- * ```
- */
-export type NumberType<T, Then = T, Else = never> = IsAny<
-	T,
-	Else,
-	[number, T] extends [T, number] ? Then : Else
->
-
-/**
- * Check if the value is a positive number.
- *
- * ```
- * import type { Positive } from 'type-plus'
- *
- * type R = Positive<1> // 1
- * type R = Positive<0> // never
- * type R = Positive<-1> // never
- *
- * type R = Positive<1, true, false> // true
- * type R = Positive<-1, true, false> // false
- * ```
- */
-export type Positive<N extends Numeric, Then = N, Else = never> = IsNever<
-	N,
-	Else,
-	number extends N ? Else : N extends Zero ? Then : `${N}` extends `-${string}` ? Else : Then
->
-
-/**
- * Is the value `N` a positive number.
- *
- * ```
- * import type { IsPositive } from 'type-plus'
- *
- * type R = IsPositive<1> // true
- * type R = IsPositive<0> // false
- * type R = IsPositive<-1> // false
- *
- * type R = IsPositive<1, 'good', 'bad'> // 'good'
- * type R = IsPositive<-1, 'good', 'bad> // 'bad'
- * ```
- */
-export type IsPositive<N extends Numeric, Then = true, Else = false> = Positive<N, Then, Else>

package/ts/number_plus/number_plus.ts

@@ -1 +0,0 @@
-export type * from './number.js'

package/ts/predicates/Equal.ts

@@ -1,24 +0,0 @@
-import type { IsAny } from '../any_plus/any.js'
-import type { And, Or } from './logical.js'
-
-/**
- * Checks if the two types are equal.
- */
-export type Equal<A, B, Then = true, Else = false> = [A, B] extends [B, A]
-	? And<IsAny<A>, IsAny<B>, Then, Or<IsAny<A>, IsAny<B>, Else, Then>>
-	: Else
-
-/**
- * Checks if the two types are equal.
- */
-export type IsEqual<A, B, Then = true, Else = false> = Equal<A, B, Then, Else>
-
-/**
- * Check if the two types are not equal
- */
-export type NotEqual<A, B, Then = true, Else = false> = Equal<A, B, Else, Then>
-
-/**
- * Check if the two types are not equal
- */
-export type IsNotEqual<A, B, Then = true, Else = false> = NotEqual<A, B, Then, Else>

package/ts/testing/index.ts

@@ -1 +0,0 @@
-export * from './stub.js'