inferred-types 0.51.1 → 0.51.2

package/src/types/sets/UniqueKeys.ts

@@ -1,36 +0,0 @@
-import { AsNumberWhenPossible, Container, LeftRight, UnionToTuple } from "inferred-types/dist/types/index";
-
-/**
- * **UniqueKeys**`<L,R>`
- *
- * Provides a **LeftRight** tuple which articulates the
- * _unique_ keys to each container's keys.
- *
- * The keys for each sides unique values are represented
- * a tuple of values.
- *
- * ```ts
- * type Foo = { foo: 1; bar: 2 };
- * type Baz = { bar: 5; baz: 42, extra: "why not?" };
- * // LeftRight<["foo"], ["baz", "extra"]>
- * type U = UniqueKeys<Foo,Baz>;
- * ```
- * - the example above with an _object_ container is the primary use case
- * but it can be used with array's too but please note it is primarily used
- * in this case to identify how the "longer" array has additional keys:
- * ```ts
- * type Short = [1,2]; // length 2
- * type Long = [3,4,5,6,7,8,9,10]; // length 8
- * // LeftRight<[], [2,3,4,5,6,7]>
- * type U = UniqueKeys<Short,Long>;
- * ```
- *
- * **Related:** `UniqueKeysUnion`
- */
-export type UniqueKeys<
-  L extends Container,
-  R extends Container
-> = LeftRight<
-  AsNumberWhenPossible<UnionToTuple<Exclude<keyof L, keyof R>>>,
-  AsNumberWhenPossible<UnionToTuple<Exclude<keyof R, keyof L>>>
->;

package/src/types/sets/UniqueKeysUnion.ts

@@ -1,27 +0,0 @@
-import { Container, LeftRight } from "inferred-types/dist/types/index";
-
-/**
- * **UniqueKeysUnion**`<L,R>`
- *
- * Provides a **LeftRight** tuple which articulates the
- * _unique_ keys to each container's keys.
- *
- * The keys for each sides unique values are represented
- * as a union type.
- *
- * ```ts
- * type Foo = { foo: 1; bar: 2 };
- * type Baz = { bar: 5; baz: 42, extra: "why not?" };
- * // [ "foo", "baz" | "extra" ]
- * type U = UniqueKeys<Foo,Baz>;
- * ```
- *
- * **Related:** `UniqueKeys`
- */
-export type UniqueKeysUnion<
-  L extends Container,
-  R extends Container
-> = LeftRight<
-  Exclude<keyof L, keyof R>,
-  Exclude<keyof R, keyof L>
->;

package/src/types/sets/UniqueKv.ts

@@ -1,17 +0,0 @@
-import { AnyObject, LeftRight } from "inferred-types/dist/types/index";
-
-/**
- * **UniqueKv**`<L,R>`
- *
- * Returns a `LeftRight` tuple containing the unique KV pairs found in `L` and `R`. Both `L` and `R` are expect to be an
- * object type of some sort.
- *
- * - this means that if _both_ `L` and `R` have a shared property but the values
- * are different then they are considered "unique" for each list.
- *
- * **Related:** `Unique`, `UniqueKeys`
- */
-export type UniqueKv<L extends AnyObject, R extends AnyObject> = LeftRight<
-  Exclude<L, keyof (L & R)>,
-  Exclude<R, keyof (L & R)>
->;

package/src/types/sets/index.ts

@@ -1,9 +0,0 @@
-
-export * from "./Intersection";
-export * from "./IntersectingKeys";
-export * from "./SetCandidate";
-export * from "./Unique";
-export * from "./Relate";
-export * from "./UniqueKeys";
-export * from "./UniqueKv";
-export * from "./UniqueKeysUnion";

package/src/types/string-literals/AfterFirstChar.ts

@@ -1,34 +0,0 @@
-import { AsArray, AfterFirst, AsString,  Concat, Chars } from "inferred-types/dist/types/index";
-
-type Iterate<
-  TInput extends readonly string[]
-> = {
-  [K in keyof TInput]: TInput[K] extends string
-    ? Concat<AfterFirst<AsArray<Chars<TInput[K]>>>>
-    : never
-};
-
-/**
- * **RemainingChar**`<TContent>`
- *
- * Receives either a string or a tuple of strings. Based on the input
- * it is converted to:
- *
- * - **String:**
- *    - when a string is received it will return the string with the first
- * character removed
- *    - when a wide string type is provided it will return the _never_ type.
- * - **Tuple<string>:**
- *    - when a tuple of strings is received it will process
- * each element in the array independently and return each element's _remaining characters_
- * after the first character has been removed
- *    - any wide strings encountered will be ignored in the returned array
- */
-export type AfterFirstChar<
-  TContent extends string | readonly string[]
-> = TContent extends readonly string[]
-  ? Iterate<AsArray<TContent>>
-  : TContent extends string
-    ? Concat<AfterFirst<AsArray<Chars<AsString<TContent>>>>>
-    : never;
-

package/src/types/string-literals/Cardinality.ts

@@ -1,82 +0,0 @@
-import { First, UnionToTuple } from "inferred-types/dist/types/index";
-
-export type OneToOne = `1:1`;
-export type OneToMany = `1:M`;
-export type OneToZero = `1:0`;
-export type ZeroToOne = `0:1`;
-export type ZeroToMany = `0:M`;
-export type ZeroToZero = `0:0`;
-export type ManyToMany = "M:M";
-export type ManyToOne = "M:1";
-export type ManyToZero = "M:0";
-
-export type CardinalityNode = "0" | "1" | "M";
-
-/**
- * Cardinality which expects a singular input and requires
- * 1 or many outputs.
- *
- * Note: choose `CardinalityFilter1` if you want to allow output
- * to have no outputs.
- */
-export type Cardinality1 = OneToOne | OneToMany;
-
-/**
- * Cardinality which expects a singular input and maps to 0,
- * 1, or many outputs.
- */
-export type CardinalityFilter1 = OneToOne | OneToMany | OneToZero;
-
-/**
- * Cardinality which expects a singular input which is allowed to be
- * _undefined_ or the expected type.
- */
-export type Cardinality0 = ZeroToOne | ZeroToMany | OneToOne | OneToMany;
-
-/**
- * Cardinality which expects a singular input -- which is allowed to be
- * _undefined_ -- and maps to 0,
- * 1, or many outputs.
- */
-export type CardinalityFilter0 =
-  | ZeroToOne
-  | ZeroToMany
-  | OneToOne
-  | OneToMany
-  | OneToZero
-  | ZeroToZero;
-
-export type CardinalityExplicit = `${number}:${number}`;
-
-/**
- * Cardinality of any sort between two types
- */
-export type Cardinality =
-  | CardinalityFilter0
-  | CardinalityFilter1
-  | ManyToMany
-  | ManyToOne
-  | ManyToZero
-  | CardinalityExplicit;
-
-
-/**
- * The first or _input_ part of the Cardinality relationship
- */
-export type CardinalityIn<T extends Cardinality> = T extends `${infer IN}:${string}` ? IN : never;
-
-/**
- * The second or _output_ part of the Cardinality relationship
- */
-export type CardinalityOut<T extends Cardinality> = T extends `${string}:${infer OUT}`
-  ? OUT
-  : never;
-
-export type CardinalityInput<
-  T,
-  C extends Cardinality
-> = UnionToTuple<C> extends readonly unknown[]
-  ? First<UnionToTuple<C>> extends 1
-    ? T
-    : T[]
-  : T | undefined;

package/src/types/string-literals/Chars.ts

@@ -1,27 +0,0 @@
-import {  IsStringLiteral,  IsEqual } from "inferred-types/dist/types/index";
-
-type Process<
-  TStr extends string,
-  TResult extends readonly string[] = []
-> = IsStringLiteral<TStr> extends true
-  ? IsEqual<TStr["length"], 0> extends true
-    ? []
-    : TStr extends `${infer Char}${infer Rest}`
-      ? Process<
-          Rest,
-          [...TResult, Char]
-        >
-      : TResult
-  : string;
-
-
-/**
- * **Chars**`<TStr>`
- *
- * Takes a literal string and converts it to an array of characters.
- */
-export type Chars<TStr extends string> = IsStringLiteral<TStr> extends true
-  ? Process<TStr> extends readonly string[]
-    ? Process<TStr>
-    : never
-  : readonly string[]

package/src/types/string-literals/Concat.ts

@@ -1,45 +0,0 @@
-import {
-  AfterFirst,
-  First,
-  Tuple,
-  IsStringLiteral,
-  IsNumericLiteral,
-  IsBooleanLiteral
-} from "inferred-types/dist/types/index";
-
-type ElementLiteral<T> = [T] extends [string]
-  ? IsStringLiteral<T> extends true ? T : string
-  : [T] extends [number]
-  ? IsNumericLiteral<T> extends true ? T : `${number}`
-  : [T] extends [boolean]
-  ? IsBooleanLiteral<T> extends true ? T : `${boolean}`
-  : never;
-
-type Process<
-  T extends Tuple,
-  Result extends string = ""
-> = [] extends T
-  ? Result
-  : Process<
-      AfterFirst<T>,
-      `${Result}${ElementLiteral<First<T>>}`
-    >;
-
-/**
- * **Concat**`<T>`
- *
- * A type utility which converts an array of strings into a
- * _concatenated_ string type.
- *
- * ```ts
- * // `${string}-${string}`
- * type T1 = Concat<string, "-", string>;
- * // `foo-bar-baz`
- * type T2 = Concat<"foo", "-", "bar", "-", "baz">;
- * ```
- *
- * **Related:** `Join<TArr,TWith>`
- */
-export type Concat<
-  T extends readonly unknown[]
-> = Process<T>;

package/src/types/string-literals/Date.ts

@@ -1,156 +0,0 @@
-import {
-  NumericChar,
-  NonZeroNumericChar,
-} from "inferred-types/dist/types/index";
-import  { MONTH_ABBR, MONTH_NAME}  from "inferred-types/dist/constants/index";
-
-export type Year<
-  T extends "strong" | "simple" = "strong"
-> = T extends "strong"
-? `${"1" | "2"}${NumericChar}${NumericChar}${NumericChar}`
-: `${"1" | "2"}${number}`;
-
-type ZeroThenDigit = `0${NumericChar}`;
-
-/**
- * **MonthName**
- *
- * The month of the year represented as a full string name.
- */
-export type MonthName = typeof MONTH_NAME[number];
-
-
-/**
- * **MonthAbbr**
- *
- * The month of the year represented in an abbreviated string format.
- */
-export type MonthAbbr = typeof MONTH_ABBR[number];
-
-/**
- * **MonthNumeric**
- *
- * The month of the year represented in a numeric format.
- */
-export type MonthNumeric =  "10" | "11" | "12" | `${"0" | ""}${NonZeroNumericChar}`;
-
-/**
- * **MonthDay**
- *
- * The numeric day in the month.
- */
-export type MonthDay = ZeroThenDigit | `${"" | "1" | "2"}${NumericChar}` | `3${"0" | "1"}`;
-
-export type DateSeparator = "-" | "/" | ".";
-
-
-/**
- * **YMD**`<[TSep]>
- * A date format for `YYYY-MM-DD` which is used as a component of the ISO8601 standard.
- *
- * > Note: you may optionally change the DateSeparator to suit your needs
- */
-export type YMD<
-  TSep extends DateSeparator = "-"
-> =  `${"1" | "2"}${number}${TSep}${MonthNumeric}${TSep}${number}`;
-
-/**
- * **DateThenMonth**
- *
- * The day of the month followed by an abbreviated string representation
- * of the month (e.g., `4 July`)
- */
-export type DateThenMonth = `${MonthDay} ${MonthAbbr}`;
-
-/**
- * **DateThenMonthThenYear**
- *
- * The day of the month followed by an abbreviated string representation
- * of the month and finishing with the year (e.g., `4 July 2021`)
- */
-export type DateThenMonthThenYear = `${MonthDay} ${MonthAbbr}${` ${Year<"simple">}`}`;
-
-
-export type MonthPostfix = "" | "st" | "rd" | "th";
-
-/**
- * **MonthThenDateThenYear**
- *
- * The month's name -- either abbreviate or full -- followed by the
- * day in the month (e.g., `July 28, 1970`, or `July 28th, 1970`)
- */
-export type MonthThenDateThenYear = `${MonthAbbr | MonthName} ${MonthDay}${MonthPostfix}${`, ${Year<"simple">}`}`;
-
-/**
- * **MonthThenDate**
- *
- * The month's name -- either abbreviate or full -- followed by the
- * day in the month (e.g., `July 28`, `July 28th`)
- */
-export type MonthThenDate = `${MonthAbbr | MonthName} ${MonthDay}${MonthPostfix}`;
-
-
-export type MonthThenDate_Simple = ``;
-
-/**
- * **MonthAbbrThenDate**
- *
- * The month's name -- in abbreviated form -- followed by the
- * day in the month. You may optionally add a `MonthPostfix` descriptor.
- *
- * ```ts
- * const date: MonthAbbrThenDate[] = ["Jun 6", "Jun 06", "Jun 6th"]
- * ```
- */
-export type MonthAbbrThenDate = `${MonthAbbr} ${MonthDay}${MonthPostfix}`;
-
-/**
- * **MonthAbbrThenDateAndYear**
- *
- * The month's name -- in abbreviated form -- followed by the
- * day in the month and the year.
- *
- * - you may optionally add a `MonthPostfix` descriptor
- * - the year must be preceded by `, `
- *
- * ```ts
- * const date: MonthAbbrThenDateAndYear[] = ["Jun 6, 2020", "Jun 06, 2020", "Jun 6th, 2020"]
- * ```
- */
-export type MonthAbbrThenDateAndYear = `${MonthAbbr} ${MonthDay}${MonthPostfix}${`, ${Year<"simple">}`}`;
-
-/**
- * **FullDate**
- *
- * Allows the representation of a date using one of several representations:
- *
- * 1. `YYYY-MM-DD` / `YYYY.MM.DD` / `YYYY/MM/DD`
- * 2. `13 Jun 2020`
- * 3. `July 4th, 2019`
- *
- * Note: to keep types as simple as possible, the `YMD` type has been replaced
- * with just the `YMD_Simple` type. If you really need stronger typing use
- * the `FullDateStrong` type.
- */
-export type FullDate = YMD | DateThenMonthThenYear | MonthThenDateThenYear;
-
-/**
- * **ShortDate**
- *
- * Represent the month and day of month in one of two structural formats:
- *
- * 1. `13 Jun`
- * 2. `Jun 13` or `Jun 13th` or `June 13th`
- *
- * **Note:** the year is _not_ representable using this type
- */
-export type ShortDate = DateThenMonth | MonthThenDate;
-
-
-/**
- * **Date**
- *
- * An [ISO8601](https://www.iso.org/iso-8601-date-and-time-format.html#:~:text=Therefore%2C%20the%20order%20of%20the,27%2018%3A00%3A00.000.)
- * date format which looks like `YYYY-MM-DD`.
- */
-export type Date = YMD;

package/src/types/string-literals/DateTime.ts

@@ -1,56 +0,0 @@
-import {
-  DateSeparator,
-  HoursMinutes,
-  HoursMinutesSeconds,
-  TZ,
-  Time,
-  YMD,
-  TypeRequired,
-  TimeNomenclature,
-  TimeResolution
-} from "inferred-types/dist/types/index";
-
-
-/**
- * **DateTimeMinutes**
- *
- * The date and time with time resolution of minutes.
- */
-export type DateTimeMinutes<
-  S extends DateSeparator = DateSeparator
-> = `${YMD<S>} ${HoursMinutes<{strength: "simple"}>}`;
-
-export type DateTimeSeconds<
-  S extends DateSeparator = DateSeparator
-> = `${YMD<S>} ${HoursMinutesSeconds<{strength: "simple"}>}`;
-
-/**
- * **DateTime**`<S>`
- *
- * A simplified way of representing any supported representation
- * of a `DateTime` string.
- *
- * **Note:** the most common and best choice is often the `Iso8601`
- * datetime representation.
- */
-export type DateTime<
-  TResolution extends TimeResolution = "HH:MM:SS",
-  TNomenclature extends TimeNomenclature = "military",
-  TTimezone extends TypeRequired = "exclude",
-  TSep extends DateSeparator = "-"
-> = `${YMD<TSep>} ${Time<TResolution,TNomenclature,{timezone: TTimezone; strength: "simple"}>}`;
-
-
-/**
- * **Iso8601**<TStrength>
- *
- * Creates typing for the [**ISO8601**](https://en.wikipedia.org/wiki/ISO_8601)
- * datetime format.
- *
- * - the strength/complexity of the type can be set with `TStrength`
- * - a timezone is optional by default but can be isolated to "required" or "excluded"
- */
-export type Iso8601<
-  TTimezone extends TypeRequired = "optional"
-> = `${number}-${number}-${number}T${number}:${number}:${number}.${number}${TZ<TTimezone>}`
-

package/src/types/string-literals/EmptyString.ts

@@ -1,7 +0,0 @@
-/**
- * **EmptyString**
- * 
- * A string literal of an _empty_ string;
- */
-export type EmptyString = "";
-

package/src/types/string-literals/EmptyStringOr.ts

@@ -1,12 +0,0 @@
-import { TupleToUnion , EmptyString } from "inferred-types/dist/types/index";
-
-/**
- * **EmptyStringOr**`<T>`
- *
- * A type utility to build a union between an empty string
- * _or_ the string literal `T`.
- */
-export type EmptyStringOr<T extends string | readonly string[]> =
-  T extends readonly string[]
-    ? EmptyString | TupleToUnion<T & readonly string[]>
-    : EmptyString | (T & string);

package/src/types/string-literals/EnsureLeading.ts

@@ -1,70 +0,0 @@
-
-import {As, AsNumber, AsStringUnion, IsString, IsWideType } from "inferred-types/dist/types/index";
-
-type Process<
-  TContent extends string,
-  TLeading extends string
->= TContent extends `${TLeading}${string}`
-? TContent
-: `${TLeading}${TContent}`;
-
-type IterateOver<
-  TContent extends readonly (string | number)[],
-  TLeading extends string | number
-> = {
-  [K in keyof TContent]: TContent[K] extends string
-    ? Process<TContent[K], AsStringUnion<TLeading>>
-    : TContent[K] extends number
-    ? AsNumber<Process<`${TContent[K]}`, AsStringUnion<TLeading>>>
-    : never
-}
-
-type WideContent<
-  TContent extends string | number,
-  TLeading extends string | number
-> = IsString<TContent> extends true
-? `${TLeading}${string}`
-: number;
-
-type WideLeading<
-  TContent extends string | number,
-  TLeading extends string | number
-> = TContent extends string
-? `${TLeading}${TContent}`
-: number;
-
-/**
- * **EnsureLeading**`<TContent, TLeading>`
- *
- * Will ensure that `TContent` _starts with_ the `TLeading`; adding
- * it when it wasn't present or proxying the value through when it was.
- *
- * **Note:**
- * - you can use both _string_ or _numeric_ values for both
- * parameters.
- * - you can provide a tuple for content and each item will be processed
- * separately
- *
- * ```ts
- * type T = "World";
- * type U = "Hello ";
- * // "Hello World"
- * type R = EnsureLeading<T,U>;
- * ```
- *
- * **Related:** `EnsureLeadingEvery`, `EnsureTrailing`, `EnsureSurround`, `Surround`
- */
-export type EnsureLeading<
-  TContent extends string | number | readonly (string|number)[],
-  TLeading extends string | number
-> = TContent extends readonly (string|number)[]
-? IterateOver<TContent,TLeading>
-: IsWideType<TContent> extends true
-? WideContent<As<TContent, string|number>, TLeading>
-: IsWideType<TLeading> extends true
-? WideLeading<As<TContent, string|number>, TLeading>
-: TContent extends string
-  ? Process<TContent,AsStringUnion<TLeading>>
-  : TContent extends number
-  ? AsNumber<Process<`${TContent}`, AsStringUnion<TLeading>>>
-  : never;

package/src/types/string-literals/EnsureLeadingEvery.ts

@@ -1,22 +0,0 @@
-import {  AsString, EnsureLeading,  UnionToTuple } from "inferred-types/dist/types/index";
-
-
-/**
- * **EnsureLeadingEvery**`<TList, TLeader>`
- *
- * Ensures that each item in `TList` starts with `TLeader`.
- *
- * - `TList` can be made up of strings or numbers
- * - `TLeader` can be made up of string, number, or boolean values
- * - all non-string values are converted to string with `ToString`
- *
- * **Related:** `EnsureLeading`, `EnsureTrailing`
- */
-export type EnsureLeadingEvery<
-  TList extends readonly (string | number | boolean)[],
-  TLeader extends string
-> = UnionToTuple< {
-  [K in keyof TList]: AsString<TList[K]> extends string
-    ? EnsureLeading<AsString<TList[K]>, TLeader>
-    : never
-}[number]>;

package/src/types/string-literals/EnsureSurround.ts

@@ -1,17 +0,0 @@
-import { EnsureLeading, EnsureTrailing } from "inferred-types/dist/types/index";
-
-/**
- * **EnsureSurround**
- *
- * Ensures that `TInput` is _surrounded_ by `TPrefix` and `TPostfix`
- *
- * **Related:** `Surround`
- */
-export type EnsureSurround<
-  TInput extends string,
-  TPrefix extends string,
-  TPostfix extends string
-> = EnsureTrailing<
-  EnsureLeading<TInput, TPrefix>,
-  TPostfix
->;

package/src/types/string-literals/EnsureTrailing.ts

@@ -1,60 +0,0 @@
-import {
-  AsNumber,
-  AsString,
-  IsString,
-  IsWideType,
-} from "inferred-types/dist/types/index";
-
-
-type P<
-  TContent extends string,
-  TTrailing extends string
-> = TContent extends `${string}${TTrailing}`
-? TContent
-: `${TContent}${TTrailing}`;
-
-
-
-type IterateOver<
-  TContent extends readonly unknown[],
-  TTrailing extends string
-> = {
-  [K in keyof TContent]: TContent[K] extends string
-    ? P<TContent[K], TTrailing>
-    : TContent[K] extends number
-      ? AsNumber<P<`${TContent[K]}`, TTrailing>>
-    : P<`${AsString<TContent[K]>}`, TTrailing>
-}
-
-/**
- * **EnsureTrailing**`<TContent, TTrailing>`
- *
- * Will ensure that `T` ends with the substring `U` when
- * both are string literals.
- *
- * ```ts
- * type T = "Hello";
- * type U = " World";
- * // "Hello World"
- * type R = EnsureTrailing<T,U>;
- * ```
- */
-export type EnsureTrailing<
-  TContent extends string | number | readonly (string|number)[],
-  TTrailing extends string | number
-> = IsWideType<TContent> extends true
-? IsWideType<TTrailing> extends true
-  ? TContent
-  : `${string}${TTrailing}`
-: IsWideType<TTrailing> extends true
-  ? IsString<TContent> extends true
-    ? `${AsString<TContent>}${string}`
-    : never
-: TContent extends number
-? AsNumber<P<`${TContent}`, `${TTrailing}`>>
-: TContent extends string
-? P<TContent, `${TTrailing}`>
-: TContent extends readonly unknown[]
-? IterateOver<TContent, `${TTrailing}`>
-: never;
-