inferred-types 0.51.1 → 0.51.3

package/src/types/literals/Narrowable.ts

@@ -1,9 +0,0 @@
-/**
- * **Narrowable**
- * 
- * A union of types which when used as a generic's base value helps to extract
- * the most narrow definition available.
- * 
- * **Related:** `NarrowableDefined`, `NarrowableScalar`
- */
-export type Narrowable = string | number | boolean | symbol | object | undefined | void | null;

package/src/types/literals/NarrowableDefined.ts

@@ -1,11 +0,0 @@
-import { EmptyObject } from "../base-types";
-
-
-/**
- * **NarrowableDefined**
- *
- * Precisely the same as the `Narrowable` type but without _undefined_ as an option
- *
- * **Related:** `Narrowable`, `NarrowableScalar`
- */
-export type NarrowableDefined = string | number | boolean | symbol | object | void | null | EmptyObject;

package/src/types/literals/NarrowableScalar.ts

@@ -1,14 +0,0 @@
-/**
- * **NarrowableScalar**
- * 
- * A union of all types which are not "containers" (aka, objects and arrays) so that
- * properties like `{}` and `object` causing conflicts.
- */
-export type NarrowableScalar = string 
-  | number 
-  | boolean 
-  | symbol 
-  | undefined 
-  | void 
-  | null;
-

package/src/types/literals/OptRequired.ts

@@ -1,4 +0,0 @@
-/**
- * Expresses whether an option is "opt" (optional) or "req" (required)
- */
-export type OptRequired = "opt" | "req";

package/src/types/literals/RuntimeUnion.ts

@@ -1,16 +0,0 @@
-import { TupleToUnion } from "../type-conversion";
-
-/** 
- * **RuntimeUnion**`<T>`
- * 
- * Represents a _union type_ at runtime where the `ReturnType` is the
- * union type of the member in the `members` array.
- */
-export type RuntimeUnion<
-  T extends readonly unknown[]
-> = {
-  kind: "Union"; 
-  members: T; 
-  type: TupleToUnion<T>;
-  includes: (v: unknown) => boolean;
-}

package/src/types/literals/Unset.ts

@@ -1,14 +0,0 @@
-
-
-/**
- * **Unset**
- *
- * The **Unset** type allows you to specify a _parameter_ which
- * has **not** been set yet but then allows a user to choose any
- * value they like.
- *
- * **Related:** `unset()`
- */
-export type Unset = {
-  kind: "Unset";
-};

package/src/types/literals/VueComputedRef.ts

@@ -1,41 +0,0 @@
-/**
- * **VueComputedRef**
- * 
- * The goal of this type is to _appear_ to the runtime and type systems
- * to be a `ComputedRef` (aka, **Computed** property). 
- * 
- * None of the functionality is provided by this but it allows us to create 
- * _types_ and _type guards_ which can respond to this structure without 
- * needing to have `Vue` but a dependency on this package.
- */
- 
-export type VueComputedRef<T = any> = {
-  value: T;
-  effect: any;
-}
-
-
-/**
- * **IsComputedRef**`<T>`
- * 
- * Boolean operator which determines whether `T` is seen to be a `ComputedRef`
- * property from **VueJS**.
- */
-export type IsComputedRef<T> = T extends { value: unknown; effect: object } 
-? true
-: false;
-
-
-/**
- * **AsVueComputedRef**
- * 
- * Narrowing type that takes an _unknown_ `T` and tests to see if is
- * a **VueJS** `ComputedRef` property. If it is then the narrowed type
- * is returned, otherwise `never`.
- * 
- * **Related:** `VueComputedRef`, `IsVueComputedRef`
- */
-export type AsVueComputedRef<T> = T extends VueComputedRef
-? T & VueComputedRef
-: never;
-

package/src/types/literals/VueRef.ts

@@ -1,23 +0,0 @@
- 
-
-/**
- * **VueRef**`<T>`
- * 
- * Intended to be the same type as VueJS's `Ref<T>` but without the need
- * to include any of the VueJS framework in deps.
- * 
- * **Notes:**
- * 
- *  - a real `Ref<T>` has both the `value` property and a _private_ symbol
- * exposed to the runtime as a type (but the type is intentionally not exported).
- *  - whenever using this type, please use it with `IsRef()`,`isRef()` utils
- * 
- * **Related:**
- * 
- * - `IsRef<T>`, `isRef()`, `VueComputedRef<T>`
- */
-export type VueRef<T = any> = {
-  value: T;
-};
-
-

package/src/types/literals/index.ts

@@ -1,19 +0,0 @@
-export * from "./OptRequired";
-export * from "./Color";
-export * from "./ExpandRecursively";
-export * from "./Narrowable";
-export * from "./Narrow";
-export * from "./NarrowableDefined";
-export * from "./NarrowableScalar";
-export * from "./Box";
-export * from "./VueRef";
-export * from "./VueComputedRef";
-export * from "./ContainerKeyGuarantee";
-export * from "./ContainerBlockKey";
-export * from "./RuntimeUnion"
-export * from "./DoneFnTuple";
-export * from "./Choices";
-export * from "./FromDefn";
-export * from "./FromTokenNames";
-export * from "./Unset";
-export * from "./BooleanLike";

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

@@ -1,31 +0,0 @@
-import {
-  NumberLike,
-  AsNumber,
-  StripLeading,
-  IsStringLiteral,
-  If
-} from "inferred-types/dist/types/index";
-
-type Process<T extends `${number}`> = If<
-  IsStringLiteral<T>,
-  StripLeading<T, "-">,
-  string
->;
-
-
-/**
- * **Abs**`<T>`
- *
- * Converts any literal numeric into the **absolute value** of the number.
- *
- * - you can pass in a numeric string literal and it perform ABS func while
- * preserving string literal type
- */
-export type Abs<T extends NumberLike> = T extends number
-? AsNumber<
-    Process<`${T}`>
-  >
-: T extends `${number}`
-  ? Process<T>
-  : never;
-

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

@@ -1,21 +0,0 @@
-import {  ToNumber,  StripLeading, If, Or, IsNumericLiteral, IsStringLiteral, AsString } from "inferred-types/dist/types/index";
-
-/**
- * **AbsMaybe**`<T>`
- *
- * Converts any literal numeric into the **absolute value** of the number.
- *
- * - you can pass in a numeric string literal and it perform ABS func while
- * preserving string literal type
- * - if a wide numeric type is used for `T` this utility will resolve to `number`
- * as the absolute value can not be known at design time; if you'd prefer to
- * block any wide types then use `Abs` instead
- */
-export type AbsMaybe<T extends number | `${number}`> = If<
-  Or<[IsNumericLiteral<T>, IsStringLiteral<T>]>,
-  T extends string
-    ? StripLeading<T,"-">
-    : ToNumber<StripLeading<AsString<T>,"-">>
-  ,
-  number
->;

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

@@ -1,179 +0,0 @@
-import { IsString, IsNegativeNumber, If, Or, And, IsWideType, As } from "../boolean-logic";
-import { AfterFirst } from "../lists/AfterFirst";
-import { NumericChar } from "../string-literals/character-sets/NumericChar";
-import { FixedLengthArray } from "../tuples/FixedLengthArray";
-import { AsNumber } from "../type-conversion/AsNumber";
-import { AsString } from "../type-conversion/AsString";
-import { Abs } from "./Abs";
-import { Decrement } from "./Decrement";
-import { NumberLike } from "./NumberLike";
-
-type Either<left extends boolean, right extends boolean> =
-  left extends true ? true : right extends true ? true : false;
-
-type DecrementDigit<digit extends NumericChar> =
-  digit extends "1" ? "0"
-  : digit extends "2" ? "1"
-  : digit extends "3" ? "2"
-  : digit extends "4" ? "3"
-  : digit extends "5" ? "4"
-  : digit extends "6" ? "5"
-  : digit extends "7" ? "6"
-  : digit extends "8" ? "7"
-  : digit extends "9" ? "8"
-  : digit extends "10" ? "9"
-  : never;
-
-type IncrementDigit<digit extends NumericChar> =
-  digit extends "0" ? { result: "1"; carry: false}
-  : digit extends "1" ? { result: "2"; carry: false }
-  : digit extends "2" ? { result: "3"; carry: false }
-  : digit extends "3" ? { result: "4"; carry: false }
-  : digit extends "4" ? { result: "5"; carry: false }
-  : digit extends "5" ? { result: "6"; carry: false }
-  : digit extends "6" ? { result: "7"; carry: false }
-  : digit extends "7" ? { result: "8"; carry: false }
-  : digit extends "8" ? { result: "9"; carry: false }
-  : digit extends "9" ? { result: "0"; carry: true }
-  : never;
-
-type SingleDigitSumResult<
-  result extends NumericChar,
-  carry extends boolean
-> = { result: result; carry: carry };
-
-type SumSingleDigits<
-  left extends NumericChar,
-  right extends NumericChar,
-  carryIn extends boolean = false,
-  carryOut extends boolean = false
-> = carryIn extends true
-    ? IncrementDigit<left> extends SingleDigitSumResult<infer leftIncremented, infer carryOutFromIncrement>
-      ? SumSingleDigits<leftIncremented, right, false, carryOutFromIncrement>
-      : never
-    : right extends "0"
-      ? { result: left; carry: carryOut }
-      : IncrementDigit<left> extends SingleDigitSumResult<infer leftIncremented, infer carryOutFromIncrement>
-        ? SumSingleDigits<leftIncremented, DecrementDigit<right>, false, Either<carryOut, carryOutFromIncrement>>
-        : never;
-
-type RightMostDigitResult<rest extends string, digit extends NumericChar> = { rest: rest; digit: digit };
-
-type RightMostDigit<s extends string> =
-  s extends `${infer rest}${NumericChar}`
-    ? s extends `${rest}${infer digit}`
-      ? { rest: rest; digit: digit }
-      : never
-    : never;
-
-type SumStrings<
-  left extends string,
-  right extends string,
-  accumulatedResultDigits extends string = "",
-  carry extends boolean = false
-> =
-  "" extends left
-    // Left is empty
-    ? "" extends right
-      // Right is empty
-      ? carry extends true ? `1${accumulatedResultDigits}` : accumulatedResultDigits
-      // Right has value
-      : RightMostDigit<right> extends RightMostDigitResult<infer remainingRight, infer rightDigit>
-        ? SumSingleDigits<"0", rightDigit, carry> extends SingleDigitSumResult<infer resultDigit, infer resultCarry>
-          ? SumStrings<"", remainingRight, `${resultDigit}${accumulatedResultDigits}`, resultCarry>
-          : never
-        : never
-    // Left has value
-    : "" extends right
-      // Right has no value
-      ? RightMostDigit<left> extends RightMostDigitResult<infer remainingLeft, infer leftDigit>
-        ? SumSingleDigits<"0", leftDigit, carry> extends SingleDigitSumResult<infer resultDigit, infer resultCarry>
-          ? SumStrings<remainingLeft, "", `${resultDigit}${accumulatedResultDigits}`, resultCarry>
-          : never
-        : never
-      // Right has value
-      : RightMostDigit<left> extends RightMostDigitResult<infer remainingLeft, infer leftDigit>
-        ? RightMostDigit<right> extends RightMostDigitResult<infer remainingRight, infer rightDigit>
-          ? SumSingleDigits<leftDigit, rightDigit, carry> extends SingleDigitSumResult<infer resultDigit, infer resultCarry>
-            ? SumStrings<remainingLeft, remainingRight, `${resultDigit}${accumulatedResultDigits}`, resultCarry>
-            : never
-          : never
-        : never;
-
-type _Subtract<
-  TValue extends `${number}`,
-  TCountArr extends readonly unknown[]
-> = [] extends TCountArr
-? TValue
-: _Subtract<Decrement<TValue>, AfterFirst<TCountArr>>;
-
-type AddNegatives<
-  A extends `${number}`,
-  B extends `${number}`
-> = SumStrings<A,B>;
-
-
-type Process<
-  A extends `${number}`,
-  B extends `${number}`
-> = And<[ IsNegativeNumber<A>, IsNegativeNumber<B> ]> extends true
-  // Both operands are negative
-  ? `-${AddNegatives<Abs<A>,Abs<B>>}`
-  : IsNegativeNumber<B> extends true
-    ? FixedLengthArray<unknown, AsNumber<Abs<B>>> extends readonly unknown[]
-      ? _Subtract<A,FixedLengthArray<unknown, AsNumber<Abs<B>>>>
-      : never
-    : IsNegativeNumber<A> extends true
-      ? FixedLengthArray<unknown, AsNumber<Abs<A>>> extends readonly unknown[]
-        ? _Subtract<B,FixedLengthArray<unknown, AsNumber<Abs<A>>>>
-        : never
-      : SumStrings<A,B>;
-
-type CheckWide<
-A extends NumberLike,
-B extends NumberLike
-> = IsWideType<A> extends true
-? true
-: IsWideType<B> extends true
-? true
-: false;
-
-
-type PreProcess<
-A extends NumberLike,
-B extends NumberLike
-> = CheckWide<A,B> extends true
-? Or<[IsString<A>,IsString<A>]> extends true
-?  string
-:  number
-: Or<[IsWideType<A>,IsWideType<B>]> extends true
-// wide types found
-? If<IsString<A>, string, number>
-// both are literals
-: A extends `${number}`
-  ? B extends `${number}`
-    ? As<Process<A,B>, `${number}`>
-    : As<Process<A,AsString<B>>, `${number}`>
-: A extends number
-  ? B extends number
-   ? AsNumber<Process<`${A}`,`${B}`>>
-   : AsNumber<Process<`${A}`, As<B, `${number}`> >>
-: never;
-
-
-/**
- * **Add**`<A,B>`
- *
- * Adds two `NumberLike` values together and returns the appropriate numeric type:
- *
- * - if either or both `A` and `B` are a `${number}` then a `${number}` type is returned
- * - if both are numeric values than the type is `number`.
- */
-export type Add<
-A extends NumberLike,
-B extends NumberLike
-> = A extends number
-  ? As<PreProcess<A,B>, number>
-  : A extends `${number}`
-  ? As<PreProcess<A,B>, `${number}`>
-  : never;

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

@@ -1,32 +0,0 @@
-import {
-  AsNumber,
-  EnsureLeading,
-  NumberLike,
-  Zero
-} from "inferred-types/dist/types/index"
-
-
-type Process<
-T extends `${number}`
-> = EnsureLeading<T, "-">
-
-/**
- * **AsNegativeNumber**
- *
- * Ensures that the number-like value for `T` is a negative number.
- *
- * **Related**: `Abs`, `InvertNumericSign`
- */
-export type AsNegativeNumber<
-  T extends NumberLike
-> = T extends Zero
-? T
-: T extends number
-  ? AsNumber<Process<`${T}`>> extends number
-    ? AsNumber<Process<`${T}`>>
-    : never
-  : T extends `${number}`
-  ? Process<T> extends `${number}`
-    ? Process<T>
-    : never
-  : never;

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

@@ -1,41 +0,0 @@
-import { If, IsUnion , ToNumber, TupleToUnion, UnionToTuple } from "inferred-types/dist/types/index";
-
-
-type Convert<T> = T extends `${number}`
-  ? ToNumber<T>
-  : T;
-
-
-type ConvertTuple<T> = T extends unknown[]
-? {
-  [K in keyof T]: Convert<T[K]>
-}
-: never;
-
-
-type ConvertUnion<T> = If<
-  IsUnion<T>,
-  TupleToUnion<ConvertTuple<UnionToTuple<T>>>,
-  never
->;
-
-/**
- * **AsNumberWhenPossible**`<T>`
- *
- * Takes any value `T` and either returns `T` as an _identity value_ or where
- * it finds a string literal which can be converted to a number it will convert
- * it to that number value.
- *
- * - if an array of values is passed in then the values are iterated over and
- * the same process is applied to each.
- * - if the type of `T` is a _union type_ then any numeric string literal in the
- * literal values will be converted to a numeric literal but the return type will
- * still be a _union_.
- */
-export type AsNumberWhenPossible<T> = If<
-  IsUnion<T>,
-  ConvertUnion<T>,
-  T extends readonly unknown[]
-    ? ConvertTuple<T>
-    : Convert<T>
->;

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

@@ -1,164 +0,0 @@
-
-import { If, IsEqual } from "../boolean-logic";
-import { AsNumber } from "../type-conversion";
-import { NumberLike } from "./NumberLike";
-
-
-type Tighten<
-  T extends string
-> = T extends ` ${infer Rest extends string}`
-? T extends `  ${infer Double extends string}`
-  ? Double
-  : Rest
-: T;
-
-
-type Process<
-  T extends string,
-  Result extends readonly unknown[] = []
-> = T extends `${infer Element},${infer Rest}`
-? Process<
-    Rest,
-    [
-      ...Result,
-      Tighten<Element> extends NumberLike
-        ? AsNumber<Tighten<Element>>
-        : Tighten<Element>
-    ]
-  >
-: [
-    ...Result,
-    Tighten<T> extends NumberLike
-        ? AsNumber<Tighten<T>>
-        : Tighten<T>
-];
-
-type ProcessJsonTuple<
-  T extends string,
-  Result extends readonly unknown[] = []
-> = T extends `${infer Element},${infer Rest}`
-? ProcessJsonTuple<
-    Rest,
-    [
-      ...Result,
-      Tighten<Element> extends NumberLike
-        ? AsNumber<Tighten<Element>>
-        : If<
-            IsEqual<Tighten<Element>, "true">,
-            true,
-            If<
-              IsEqual<Tighten<Element>, "false">,
-              false,
-              Tighten<`"${Element}"`>
-            >
-          >
-    ]
-  >
-: [
-    ...Result,
-    Tighten<T> extends NumberLike
-        ? AsNumber<Tighten<T>>
-        : If<
-            IsEqual<Tighten<T>, "true">,
-            true,
-            If<
-              IsEqual<Tighten<T>, "false">,
-              false,
-              Tighten<`"${T}"`>
-            >
-          >
-];
-
-
-
-type ProcessStr<
-  T extends string,
-  Result extends readonly unknown[] = []
-> = T extends `${infer Element},${infer Rest}`
-? ProcessStr<
-    Rest,
-    [
-      ...Result,
-      Tighten<Element>
-    ]
-  >
-: [
-    ...Result,
-    Tighten<T>
-  ];
-
-type ProcessUnion<
-  T extends string,
-  Result extends string | number = never
-> = T extends `${infer Element},${infer Rest}`
-? ProcessUnion<
-    Rest,
-    Tighten<Element> extends NumberLike
-        ? Result | AsNumber<Tighten<Element>>
-        : Result | Tighten<Element>
-  >
-: Tighten<T> extends NumberLike
-        ? Result | AsNumber<Tighten<T>>
-        : Result | Tighten<T>;
-
-type ProcessUnionStr<
-  T extends string,
-  Result extends string | number = never
-> = T extends `${infer Element},${infer Rest}`
-? ProcessUnionStr<
-    Rest,
-    Result | Tighten<Element>
-  >
-: Result | Tighten<T>;
-
-/**
- * **CsvToTuple**`<T>`
- *
- * Converts a CSV string into a tuple with both numbers
- * and string literals extracted.
- *
- * **Related:** `CsvToTupleStr`, `CsvToUnion`
- */
-export type CsvToTuple<T extends string> = Process<T>;
-
-
-/**
- * **CsvToTupleStr**`<T>`
- *
- * Converts a CSV string into a tuple of string literals.
- *
- * **Related:** `CsvToTuple`
- */
-export type CsvToTupleStr<T extends string> = ProcessStr<T>;
-
-
-/**
- * **CsvToUnion**`<T>`
- *
- * Converts a CSV string into a union of string and/or numeric literals.
- *
- * **Related:** `CsvToTuple`, `CsvToStrUnion`
- */
-export type CsvToUnion<T extends string> = ProcessUnion<T>;
-
-
-/**
- * **CsvToStrUnion**`<T>`
- *
- * Converts a CSV string into a union of string literals.
- *
- * **Related:** `CsvToTuple`, `CsvToUnion`
- */
-export type CsvToStrUnion<T extends string> = ProcessUnionStr<T>;
-
-/**
- * **CsvToTuple**`<T>`
- *
- * Converts a CSV string into a tuple with both numbers
- * and string literals but for the string literals it ensures
- * -- just like you find with JSON strings -- that there are
- * explicit double quotes around the string.
- *
- * **Related:** `CsvToTuple`, `CsvToTupleStr`, `CsvToUnion`
- */
-export type CsvToJsonTuple<T extends string> = ProcessJsonTuple<T>;

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

@@ -1,21 +0,0 @@
-import { Tuple, Length, FixedLengthArray } from "inferred-types/dist/types/index";
-
-type Pop<T extends Tuple> = Length<T> extends 0
-  ? 0
-  : T extends [unknown, ...(infer Rest)]
-    ? Length<Rest>
-    : never;
-
-/**
- * **Decrement**`<T>`
- *
- * Allows a number -- or a string literal of a number -- to be _decremented_
- * by one.
- *
- * - Once reaching zero the Decrement<T> utility will stay at 0
- */
-export type Decrement<T extends number | `${number}`> = T extends number
-  ? Pop<FixedLengthArray<unknown, T>>
-  : T extends `${infer Num extends number}`
-    ? `${Decrement<Num>}`
-    : never;