inferred-types 0.51.1 → 0.51.3

package/src/types/numeric-literals/Delta.ts

@@ -1,70 +0,0 @@
-import {
-  If,
-  AsNegativeNumber,
-  HaveSameNumericSign,
-  AsNumber,
-  Abs,
-  Add,
-  NumberLike,
-  IsGreaterThan,
-  ParseInt,
-  StartsWith
-} from "inferred-types/dist/types/index";
-
-
-type Process<
-A extends NumberLike,
-B extends NumberLike
-> = If<
-  HaveSameNumericSign<A,B>,
-  If<
-    IsGreaterThan<Abs<A>,Abs<B>>,
-    Add<Abs<A>, AsNegativeNumber<B>>,
-    Add<Abs<B>, AsNegativeNumber<A>>
-  >,
-  // one of the params is negative, one positive
-  Add<Abs<A>,Abs<B>>
->;
-
-/**
- * **Delta**`<A,B>`
- *
- * Provides the _delta_ between two numbers (including
- * between negative numbers).
- */
-export type Delta<
-A extends NumberLike,
-B extends NumberLike
-> = A extends `${number}`
-? Process<A,B>
-: AsNumber<Process<A,B>>
-
-
-type AsLit<T extends NumberLike> = T extends `${number}`
-? T
-: T extends number
-  ? `${T}`
-  : never;
-
-
-type ProcessNeg<
-A extends `${number}`,
-B extends `${number}`
-> = Delta<A,B> extends `${infer Num extends number}`
-  ? StartsWith<Num, "-"> extends true
-    ? `${Num}`
-    : `-${Num}`
-  : never;
-
-export type NegDelta<
-A extends NumberLike,
-B extends NumberLike
-> = A extends number
-? ParseInt<ProcessNeg<
-    AsLit<A>,
-    AsLit<B>
-  >>
-: ProcessNeg<
-    AsLit<A>,
-    AsLit<B>
-  >;

package/src/types/numeric-literals/Digit.ts

@@ -1,10 +0,0 @@
-import { NUMERIC_DIGIT } from "inferred-types/dist/constants/index";
-
-/**
- * **Digit**
- *
- * A single numeric digit.
- *
- * **Related:** `NumericChar`
- */
-export type Digit = typeof NUMERIC_DIGIT[number];

package/src/types/numeric-literals/DigitNonZero.ts

@@ -1,8 +0,0 @@
-import { Digit } from "inferred-types/dist/types/index";
-
-/**
- * **DigitNonZero**
- *
- * A non-zero based digit (aka, 1-9).
- */
-export type DigitNonZero = Exclude<Digit, 0>;

package/src/types/numeric-literals/Digitize.ts

@@ -1,42 +0,0 @@
-import {
-    NumericChar,
-    NumericSign,
-    NumberLike,
-    Chars,
-    ToNumericArray,
-    Digit,
-    Or,
-    IsEqual
-} from "inferred-types/dist/types/index";
-
-type Pos<T extends NumberLike, N extends `${number}`> = [
-  "+",
-  T extends string ? Chars<N> : ToNumericArray<Chars<N>>
-];
-
-type Neg<T extends NumberLike, N extends `${number}`> = [
-  "-",
-  T extends string ? Chars<N> : ToNumericArray<Chars<N>>
-];
-
-/**
- * **Digitize**`<T>`
- *
- * Takes a literal value of a number -- either a numeric literal or a string literal
- * is accepted -- and converts into a tuple: `[ NumericSign, Digits[] ]`
- * ```ts
- * // ["+", readonly [1,2,3] ]
- * type N = Digitize<123>;
- * // ["-", readonly ["1","2","3"] ]
- * type S = Digitize<"-123">;
- * ```
- */
-export type Digitize<
-  T extends NumberLike
-> = Or<[IsEqual<T,number>, IsEqual<T,`${number}`>]> extends true
-? [ sign: NumericSign, digits: T extends string ? NumericChar[] : Digit[] ]
-: `${T}` extends `-${infer Rest extends `${number}`}`
-? Neg<T, Rest>
-: `${T}` extends `${"+" |""}${infer Rest extends `${number}`}`
-? Pos<T, Rest>
-: never

package/src/types/numeric-literals/Increment.ts

@@ -1,26 +0,0 @@
-import {
-  Tuple,
-  FixedLengthArray,
-  ToString,
-  AsNumber
-} from "inferred-types/dist/types/index";
-
-type Push<T extends Tuple> = [...T, unknown]["length"];
-
-/**
- * **Increment**`<T>`
- *
- * Allows a number -- or a string literal of a number -- to be _incremented_
- * by one.
- * ```ts
- * // 2
- * type T = Increment<1>;
- * // "2"
- * type T = Increment<"1">;
- * ```
- */
-export type Increment<T extends number | `${number}`> = T extends number
-  ? Push<FixedLengthArray<unknown, T>>
-  : T extends `${number}`
-    ? ToString<Increment<AsNumber<T>>>
-    : never;

package/src/types/numeric-literals/InvertNumericSign.ts

@@ -1,18 +0,0 @@
-import {
-  AsNegativeNumber,
-  IsNegativeNumber,
-  Abs,
-  NumberLike
- } from "inferred-types/dist/types/index";
-
-
-/**
- * **InvertNumericSign**`<T>`
- *
- * Inverts the numeric symbol of the value `T` passed in (aka, negative numbers become
- * positive and visa versa).
- */
-export type InvertNumericSign<T extends NumberLike> = IsNegativeNumber<T> extends true
-? Abs<T>
-: AsNegativeNumber<T>;
-

package/src/types/numeric-literals/LessThan.ts

@@ -1,23 +0,0 @@
-type Calc<
-A extends number,
-B extends number,
-Count extends 1[] = []
-> = Count["length"] extends B
-? false
-: Count["length"] extends A
-  ? true
-  : Calc<A,B, [...Count, 1]>;
-
-/**
- * **LessThan**`<A,B>`
- * 
- * Boolean operator which checks whether `A` is 
- * _less than_ `B`.
- * 
- * - Note: this solution is cheap and cheerful and doesn't
- * try to address negative numbers or other edge cases
- */  
-export type LessThan<
-  A extends number,
-  B extends number
-> = Calc<A,B>;

package/src/types/numeric-literals/LessThanOrEqual.ts

@@ -1,24 +0,0 @@
-import { IsEqual } from "inferred-types/dist/types/index";
-
-type Calc<
-A extends number,
-B extends number,
-Count extends 1[] = []
-> = Count["length"] extends B
-? false
-: Count["length"] extends A
-  ? true
-  : IsEqual<A,B> extends true
-    ? true
-    : Calc<A,B, [...Count, 1]>;
-
-/**
- * **LessThanOrEqual**`<A,B>`
- *
- * Boolean operator which checks whether `A` is
- * _less than_ `B`.
- *
- * - Note: this solution is cheap and cheerful and doesn't
- * try to address negative numbers or other edge cases
- */
-export type LessThanOrEqual<A extends number,B extends number> = Calc<A,B>;

package/src/types/numeric-literals/Negative.ts

@@ -1,12 +0,0 @@
-import { AsNumber, AsString, IsNegativeNumber } from "inferred-types/dist/types/index";
-
-/**
- * **Negative**`<T>`
- *
- * Ensures that the number represented by `T` is a _negative_ number.
- */
-export type Negative<T extends number | `${number}`> = T extends `${number}`
-  ? AsString<Negative<AsNumber<T>>>
-  : IsNegativeNumber<T> extends true
-    ? T
-    : AsNumber<AsString<`-${T}`>>;

package/src/types/numeric-literals/NextDigit.ts

@@ -1,35 +0,0 @@
-import {
-  Digit,
-  ToString,
-  NumericChar,
-  AsNumber
-} from "inferred-types/dist/types/index";
-
-/**
- * **NextDigit**`<T>`
- *
- * Given a numeric digit, this utility provides the next numeric digit in sequence.
- *
- * - this includes the overflow condition of `9` -> `0`
- * - a string literal digit can be passed in as well and the next string literal
- * digit will be returned
- * ```ts
- * // 5
- * type N = NextDigit<4>;
- * // "5"
- * type S = NextDigit<"4">;
- * ```
- */
-export type NextDigit<T extends Digit | NumericChar> = T extends `${NumericChar}`
-? ToString<NextDigit<AsNumber<T>>>
-: T extends 0 ? 1
-: T extends 1 ? 2
-: T extends 2 ? 3
-: T extends 3 ? 4
-: T extends 4 ? 5
-: T extends 5 ? 6
-: T extends 6 ? 7
-: T extends 7 ? 8
-: T extends 8 ? 9
-: T extends 9 ? 0
-: never;

package/src/types/numeric-literals/NumberLike.ts

@@ -1,7 +0,0 @@
-/**
- * **NumberLike**
- *
- * A type which represents a number whether it be a _number_ or
- * a string literal shaped as a number (aka, `${string}`).
- */
-export type NumberLike = number | `${number}`  ;

package/src/types/numeric-literals/NumericRange.ts

@@ -1,17 +0,0 @@
-type Process<L, C extends unknown[] = [], R = L> = 
-  C["length"] extends L
-      ? R
-      : Process<L, [...C, 0], C["length"] | R>;
-
-/**
- * **NumericRange**`<TLow,THigh>`
- * 
- * Creates a union type of numbers between `TLow` and `THigh`
- * 
- * ```ts
- * // 2 | 3 | 4 | 5 | 6 | 7
- * type Range = NumericRange<2,7>;
- * ```
- */
-export type NumericRange<TLow, THigh> = TLow | Exclude<Process<THigh>, Process<TLow>>;
-

package/src/types/numeric-literals/PriorDigit.ts

@@ -1,35 +0,0 @@
-import {
-  Digit,
-  NumericChar,
-  ToString,
-  AsNumber
-} from "inferred-types/dist/types/index";
-
-/**
- * **PriorDigit**`<T>`
- *
- * Given a numeric digit, this utility provides the next numeric digit in sequence.
- *
- * - this includes the overflow condition of `0` -> `9`
- * - a string literal digit can be passed in as well and the next string literal
- * digit will be returned
- * ```ts
- * // 4
- * type N = PriorDigit<5>;
- * // "4"
- * type S = PriorDigit<"5">;
- * ```
- */
-export type PriorDigit<T extends Digit | NumericChar> = T extends `${NumericChar}`
-? ToString<PriorDigit<AsNumber<T>>>
-: T extends 0 ? 9
-: T extends 1 ? 0
-: T extends 2 ? 1
-: T extends 3 ? 2
-: T extends 4 ? 3
-: T extends 5 ? 4
-: T extends 6 ? 5
-: T extends 7 ? 6
-: T extends 8 ? 7
-: T extends 9 ? 8
-: never;

package/src/types/numeric-literals/Subtract.ts

@@ -1,84 +0,0 @@
-import {
-  Delta,
-  IsNegativeNumber,
-  NumberLike,
-  AsNegativeNumber,
-  HaveSameNumericSign,
-  Add,
-  Abs,
-  ParseInt,
-  As,
-  IsWideType,
-  Or,
-  IsGreaterThanOrEqual,
-  NegDelta
-} from "inferred-types/dist/types/index";
-
-
-type ConvertNumber<
-  A extends number,
-  B extends number
-> = HaveSameNumericSign<A,B> extends true
-? IsNegativeNumber<A> extends true
-  ? Add<Abs<A>,Abs<B>> extends NumberLike
-    ? AsNegativeNumber< Add<Abs<A>,Abs<B>> >
-    : never
-  : IsNegativeNumber<B> extends true
-    ? Add<A,B>
-    : IsNegativeNumber<A> extends true
-      ? IsGreaterThanOrEqual<Abs<B>,Abs<A>> extends true
-        ? Delta<A,B>
-        : Add<B,A>
-      : IsGreaterThanOrEqual<Abs<B>,Abs<A>> extends true
-        ? NegDelta<A,B>
-        : Delta<A,B>
-: never;
-
-type SummedStrings<
-  A extends number,
-  B extends number
-> = AsNegativeNumber<Add<A,B>>;
-
-type ConvertString<
-  A extends `${number}`,
-  B extends `${number}`
-> = HaveSameNumericSign<A,B> extends true
-? IsNegativeNumber<A> extends true
-  ? Add<Abs<A>,Abs<B>> extends NumberLike
-    ? SummedStrings<ParseInt<Abs<A>>, ParseInt<Abs<B>>>
-    : never
-  : IsNegativeNumber<B> extends true
-  ? Add<A,B>
-  : IsNegativeNumber<A> extends true
-    ? IsGreaterThanOrEqual<Abs<B>,Abs<A>> extends true
-      ? Delta<A,B>
-      : Add<B,A>
-    : IsGreaterThanOrEqual<Abs<B>,Abs<A>> extends true
-      ? NegDelta<A,B>
-      : Delta<A,B>
-: never;
-
-type Process<
-A extends NumberLike,
-B extends NumberLike
-> = A extends number
-? B extends number
-? ConvertNumber<A,B>
-: ConvertNumber<A,ParseInt<B>>
-: A extends `${number}`
-? B extends `${number}`
-  ? ConvertString<A,B>
-  : ConvertString<A,`${As<B, number>}`>
-: never;
-
-/**
- * **Subtract**`<A,B>`
- *
- * Subtracts the value of `B` _from_ `A`.
- */
-export type Subtract<
-  A extends NumberLike,
-  B extends NumberLike
-> = Or<[IsWideType<A>, IsWideType<B>]> extends true
-? A extends number ? number : `${number}`
-: Process<A,B>;

package/src/types/numeric-literals/ToInteger.ts

@@ -1,45 +0,0 @@
-import { If, Extends, Increment, ToNumber } from "inferred-types/dist/types/index";
-
-export type ToIntegerOp = "truncate" | "round";
-
-type Truncate<T extends `${number}`> =
-T extends `${number}.${number}`
-  ? T extends `${infer Q}.${number}`
-    ? Q & `${number}`
-    : never
-  : T;
-
-type Round<T extends `${number}`> = T extends `${number}.${number}`
-  ? T extends `${infer Q}.${infer D}${number}`
-    ? If<
-        Extends<D, "0" | "1" | "2" | "3" | "4">,
-        Q & `${number}`,
-        Increment<Q & `${number}`>
-      >
-    : never
-  : T;
-
-type EnsureKind<
-  TKind extends number | `${number}`,
-  TVal extends `${number}`
-> = TKind extends number
-  ? ToNumber<TVal>
-  : TVal;
-
-/**
- * **ToInteger**`<T>`
- *
- * Type utility which converts a _number_ (or numeric string
- * literal) to an _integer_ value.
- *
- * - the optional `TOp` generic provides methods for converting
- * a float to integer but the default is just to remove the
- * decimal value from the number (aka, "truncate").
- */
-export type ToInteger<
-  TVal extends number | `${number}`,
-  TOp extends ToIntegerOp = "truncate"
-> = TOp extends "truncate"
-  ? EnsureKind<TVal, Truncate<`${TVal}` & `${number}`>>
-  : EnsureKind<TVal, Round<`${TVal}` & `${number}`>>;
-

package/src/types/numeric-literals/ToNumericArray.ts

@@ -1,27 +0,0 @@
-
-import { Tuple,  IsReadonlyArray, IsNonEmptyContainer, ToNumber} from "inferred-types/dist/types/index";
-
-type _Convert<
-  TInput extends Tuple
-> = IsNonEmptyContainer<TInput> extends true
-  ? {
-    [K in keyof TInput]: ToNumber<TInput[K]>
-  }
-  : number[];
-
-/**
- * **ToNumericArray**`<TList>`
- *
- * Utility which accepts an array of numeric values _or_ a numeric
- * string literal and ensures that each element is made into a numeric value.
- *
- * - wide `number` types are fine and will be preserved as such
- * - numeric string literals will be converted to a narrow numeric type if
- * possible
- */
-export type ToNumericArray<
-  TList extends Tuple
-> = IsReadonlyArray<TList> extends true
-  ? Readonly<_Convert<TList>>
-  : _Convert<TList>;
-

package/src/types/numeric-literals/Zero.ts

@@ -1,8 +0,0 @@
-
-/**
- * **Zero**
- *
- * A representation of **zero**; either as the number zero or
- * the string literal equivalent.
- */
-export type Zero = 0 | `0`;

package/src/types/numeric-literals/index.ts

@@ -1,24 +0,0 @@
-;export * from "./Add";
-export * from "./Abs";
-export * from "./AbsMaybe";
-export * from "./AsNumberWhenPossible";
-export * from "./Decrement";
-export * from "./Digit";
-export * from "./Digitize";
-export * from "./DigitNonZero";
-export * from "./Increment";
-export * from "./LessThan";
-export * from "./LessThanOrEqual";
-export * from "./Negative";
-export * from "./NumericRange";
-export * from "./PriorDigit";
-export * from "./Subtract";
-export * from "./ToInteger";
-export * from "./ToNumericArray";
-export * from "./NextDigit";
-export * from "./NumberLike";
-export * from "./CSV";
-export * from "./InvertNumericSign";
-export * from "./Delta";
-export * from "./AsNegativeNumber";
-export * from "./Zero";

package/src/types/queues/FifoQueue.ts

@@ -1,39 +0,0 @@
-import { FixedLengthArray } from "inferred-types/dist/types/index";
-
-
-/**
- * A "First In, First out" queue (**FIFO**)
- */
-export type FifoQueue<
-  TType
-> = {
-  queue: TType[];
-  size: number;
-  /**
-   * reports back a boolean value to indicate whether the queue is empty or not
-   */
-  isEmpty(): boolean;
-  /**
-   * pushes additional items into the queue
-   */
-  push<T extends TType[]>(...add: T): void;
-  /**
-   * Drop a number of items from the top of the queue; if
-   * quantity is not provided then 1 item will be dropped.
-   */
-  drop<T extends number>(quantity?: T): void;
-
-  /** clears the values in the queue */
-  clear(): void;
-  /** similar to `clear()` but returns the current queue items before clearing */
-  drain(): TType[];
-  /**
-   * Take 1 or more values from the top of the queue.
-   */
-  take<T extends number | undefined>(quantity?: T): FixedLengthArray<
-    TType,
-    T extends undefined ? 1 : T
-  >;
-
-  [Symbol.iterator](): Iterator<TType>
-}

package/src/types/queues/LifoQueue.ts

@@ -1,39 +0,0 @@
-import { FixedLengthArray } from "inferred-types/dist/types/index";
-
-
-/**
- * A "Last In, First out" queue (**LIFO**)
- */
-export type LifoQueue<
-  TType
-> = {
-  queue: TType[];
-  size: number;
-  /**
-   * reports back a boolean value to indicate whether the queue is empty or not
-   */
-  isEmpty(): boolean;
-  /**
-   * pushes additional items into the queue
-   */
-  push<T extends TType[]>(...add: T): void;
-  /**
-   * Drop a number of items from the top of the queue; if
-   * quantity is not provided then 1 item will be dropped.
-   */
-  drop<T extends number>(quantity?: T): void;
-
-  /** clears the values in the queue */
-  clear(): void;
-  /** similar to `clear()` but returns the current queue items before clearing */
-  drain(): TType[];
-  /**
-   * Take 1 or more values from the top of the queue.
-   */
-  take<T extends number | undefined>(quantity?: T): FixedLengthArray<
-    TType,
-    T extends undefined ? 1 : T
-  >;
-
-  [Symbol.iterator](): Iterator<TType>
-}

package/src/types/queues/index.ts

@@ -1,3 +0,0 @@
-export * from "./LifoQueue";
-export * from "./FifoQueue";
-

package/src/types/runtime-types/AsType.ts

@@ -1,65 +0,0 @@
-import { AfterFirst, First } from "../lists";
-import {
-  SimpleType,
-  SimpleTypeMap,
-  SimpleTypeDict,
-  SimpleTypeSet,
-  SimpleTypeArray,
-  SimpleTypeScalar,
-  SimpleTypeUnion
-} from "./SimpleType";
-import {
-  SimpleDictToken,
-  SimpleMapToken,
-  SimpleSetToken,
-  SimpleArrayToken,
-  SimpleScalarToken,
-  SimpleToken,
-  SimpleUnionToken,
-  TypeToken
-} from "./TypeToken";
-
-type ProcessSimple<T extends SimpleToken | TypeToken> = T extends SimpleToken
-  ? SimpleType<T>
-  : never;
-
-type Iterate<
-  T extends readonly SimpleToken[],
-  TResult = never
-> = [] extends T
-? TResult
-: Iterate<
-    AfterFirst<T>,
-    TResult & (
-      First<T> extends SimpleScalarToken
-        ? SimpleTypeScalar<First<T>>
-        : First<T> extends SimpleDictToken
-        ? SimpleTypeDict<First<T>>
-        : First<T> extends SimpleMapToken
-        ? SimpleTypeMap<First<T>>
-        : First<T> extends SimpleSetToken
-        ? SimpleTypeSet<First<T>>
-        : First<T> extends SimpleArrayToken
-        ? SimpleTypeArray<First<T>>
-        : First<T> extends SimpleUnionToken
-        ? SimpleTypeUnion<First<T>>
-        : never
-    )
-  >
-
-
-/**
- * **AsType**`<T>`
- *
- * converts either a `SimpleToken` or a `TypeToken` into the
- * _type_ it represents.
- *
- * NOTE: only implemented for `SimpleToken` at the moment.
- */
-export type AsType<
-  T extends SimpleToken | readonly SimpleToken[] | TypeToken
-> =  T extends readonly SimpleToken[]
-? Iterate<T>
-: T extends SimpleToken
-? ProcessSimple<T>
-: never;