inferred-types 0.37.0 → 0.37.2

package/src/types/alphabetic/KebabCase.ts

@@ -1,13 +0,0 @@
-import { Dasherize } from "./Dasherize";
-
-/**
- * **KebabCase<T>** is an _alias_ for **Dasherize<T>**.
- * ```ts
- * // "foo-bar"
- * type Kebab = KebabCase<"foo_bar">;
- * type Kebab = KebabCase<"fooBar">;
- * type Kebab = KebabCase<"FooBar">;
- * // "\n  foo-bar \t"
- * type Kebab = KebabCase<"\n  foo bar \t">;
- * ``` */
-export type KebabCase<T extends string> = Dasherize<T>;

package/src/types/alphabetic/LowerAllCaps.ts

@@ -1,5 +0,0 @@
-import { AllCaps } from "./AllCaps";
-
-/** 
- * If **ALL CAPS** it converts to all lowercase; if not then it does nothing */
-export type LowerAllCaps<T extends string> = AllCaps<T> extends true ? Lowercase<T> : T;

package/src/types/alphabetic/PascalCase.ts

@@ -1,29 +0,0 @@
-/* eslint @typescript-eslint/no-unused-vars: "off" */
-
-import { Trim } from "../string-literals";
-import { LowerAllCaps } from "./LowerAllCaps";
-
-type Delimiter = "_" | "-" | " ";
-
-/** convert all delimiters to dashes */
-type DashDelim<T extends string> = T extends `${infer Begin}${" "}${infer Rest}`
-  ? DashDelim<`${Begin}-${Rest}`>
-  : T extends `${infer Begin}${"_"}${infer Rest}`
-  ? DashDelim<`${Begin}-${Rest}`>
-  : T;
-
-/**
- * Converts a string literal type to a **PascalCase** representation.
- * ```ts
- * // "FooBar"
- * type T = PascalCase<"fooBar">;
- * type T = PascalCase<"foo-bar">;
- * type T = PascalCase<"foo_bar">;
- * type T = PascalCase<"\n foo_bar \t">;
- * ```
- */
-export type PascalCase<S extends string> = string extends S
-  ? string
-  : Trim<DashDelim<LowerAllCaps<S>>> extends `${infer Begin}${Delimiter}${infer Rest}`
-  ? PascalCase<`${Capitalize<Begin>}${Capitalize<Rest>}`>
-  : Capitalize<Trim<LowerAllCaps<S>>>;

package/src/types/alphabetic/PathJoin.ts

@@ -1,54 +0,0 @@
-import { IfLiteral } from "../boolean-logic";
-import { AfterFirst, First } from "../lists";
-import { StripTrailing } from "./StripTrailing";
-import { StripLeading } from "./StripLeading";
-
-/**
- * **PathJoin**`<T,U>`
- *
- * Type utility meant to bring 2 or more "path" strings together into
- * a valid "path". Where a "path" is represented as nothing more than
- * string characters delimited by a Posix `\` character.
- *
- * Note that the first part of the path will retain it's `\` if present
- * and the last one will preserve it's `\` character if present. You can
- * combine this utility with `EnsureTrailing<T>`, `StripTrailing<T>`,
- * `EnsureStarting<T>`, and `StripStarting<T>` to further shape
- * the type.
- */
-export type PathJoin<
-  // leading string
-  T extends string,
-  // trailing string or strings
-  U extends string | readonly string[]
-> = [] extends U
-  ? T
-  : U extends readonly string[]
-  ? // eslint-disable-next-line no-use-before-define
-    PathMultiJoin<PathJoin<T, "">, [...U]>
-  : U extends string
-  ? IfLiteral<
-      T,
-      // Literal T guaranteed
-      IfLiteral<
-        // conditional
-        U,
-        `${StripTrailing<T, "/">}/${StripLeading<U, "/">}`,
-        `${StripTrailing<T, "/">}/${string}`
-      >,
-      // wide `T` encountered
-      IfLiteral<U, `${string}${U}`, string>
-    >
-  : never;
-
-type PathMultiJoin<
-  TProcessed extends string,
-  TRemaining extends readonly string[]
-> = [] extends TRemaining
-  ? TProcessed
-  : PathMultiJoin<
-      // add to the TProcessed string
-      PathJoin<TProcessed, First<TRemaining>>,
-      // remaining elements after extracting head element
-      AfterFirst<TRemaining>
-    >;

package/src/types/alphabetic/Pluralize.ts

@@ -1,112 +0,0 @@
-/* eslint @typescript-eslint/no-unused-vars: "off" */
-
-type Consonant =
-  | "b"
-  | "c"
-  | "d"
-  | "f"
-  | "g"
-  | "h"
-  | "j"
-  | "k"
-  | "l"
-  | "m"
-  | "n"
-  | "p"
-  | "q"
-  | "r"
-  | "s"
-  | "t"
-  | "v"
-  | "w"
-  | "x"
-  | "z"
-  | "y";
-
-type Exceptions =
-  | "photo => photos"
-  | "piano => pianos"
-  | "halo => halos"
-  | "foot => feet"
-  | "man => men"
-  | "woman => women"
-  | "person => people"
-  | "mouse => mice"
-  | "series => series"
-  | "sheep => sheep"
-  | "money => monies"
-  | "deer => deer";
-
-// @ts-ignore
-type SingularException<T = Exceptions> = T extends `${infer SINGULAR} => ${infer PLURAL}`
-  ? SINGULAR
-  : never;
-
-// @ts-ignore
-type PluralException<
-  T extends SingularException,
-  E extends Exceptions = Exceptions
-> = E extends `${T} => ${infer PLURAL}` ? PLURAL : never;
-
-type SingularNoun = "s" | "sh" | "ch" | "x" | "z" | "o";
-type F = "f" | "fe";
-type Y = `${Consonant}y`;
-
-type RemoveTrailingY<T> = T extends `${infer HEAD}y` ? HEAD : T;
-
-/** validates that a word ends with a pluralization exception */
-type isException<T extends string> = T extends SingularException ? T : never;
-
-/** validates that a string literal ends in "is" */
-// @ts-ignore
-type EndsIn_IS<T extends string> = T extends `${infer HEAD}is` ? T : never;
-
-/** validates that a string literal is a singular noun */
-// @ts-ignore
-type EndsInSingularNoun<T extends string> = T extends `${infer HEAD}${SingularNoun}` ? T : never;
-
-/** validates that a string literal ends in "f" or "fe" */
-// @ts-ignore
-type EndsIn_F<T extends string> = T extends `${infer HEAD}${F}` ? T : never;
-
-/** validates that a string literal ends a consonant followed by "y" */
-// @ts-ignore
-type EndsIn_Y<T extends string> = T extends `${infer HEAD}${Y}` ? T : never;
-
-/**
- * strings which end in the letters "is" should have an "es" added to the end
- */
-type PluralizeEndingIn_IS<T extends string> = T extends `${infer HEAD}is` ? `${HEAD}ises` : T;
-
-/**
- * singular nouns should have "es" added to the end
- */
-// @ts-ignore
-type PluralizeEndingSingularNoun<T extends string> = T extends `${infer HEAD}${SingularNoun}`
-  ? `${T}es`
-  : T;
-
-/**
- * strings which end in the letters "f" or "fe" should have "ves" replace the ending
- */
-type PluralizeEnding_F<T extends string> = T extends `${infer HEAD}${F}` ? `${HEAD}ves` : T;
-
-/**
- * singular nouns should have "es" added to the end
- */
-// @ts-ignore
-type PluralizeEndingIn_Y<T extends string> = T extends `${infer HEAD}${Y}`
-  ? `${RemoveTrailingY<T>}ies`
-  : T;
-
-export type Pluralize<T extends string> = T extends isException<T>
-  ? PluralException<T>
-  : T extends EndsIn_IS<T>
-    ? PluralizeEndingIn_IS<T>
-    : T extends EndsInSingularNoun<T>
-      ? PluralizeEndingSingularNoun<T>
-      : T extends EndsIn_F<T>
-        ? PluralizeEnding_F<T>
-        : T extends EndsIn_Y<T>
-          ? PluralizeEndingIn_Y<T>
-          : `${T}s`;

package/src/types/alphabetic/SnakeCase.ts

@@ -1,27 +0,0 @@
-/* eslint @typescript-eslint/no-unused-vars: "off" */
-
-import { Trim } from "../string-literals";
-import { DashUppercase } from "./DashUppercase";
-import { LowerAllCaps } from "./LowerAllCaps";
-
-/** convert space to dash */
-type SpaceToDash<T extends string> = T extends `${infer Begin}${" "}${infer Rest}`
-  ? SpaceToDash<`${Begin}-${Rest}`>
-  : T;
-
-/**
- * Converts a string literal type to _snake_case_.
- * ```ts
- * // "foo_bar"
- * type T = SnakeCase<"fooBar">;
- * type T = SnakeCase<"FooBar">;
- * type T = SnakeCase<"foo-bar">;
- * type T = SnakeCase<"\n foo bar \t">;
- * ``` */
-export type SnakeCase<S extends string> = string extends S
-  ? string
-  : DashUppercase<
-      Uncapitalize<SpaceToDash<Trim<LowerAllCaps<S>>>>
-    > extends `${infer Begin}${"-"}${infer Rest}`
-  ? SnakeCase<`${Lowercase<Begin>}_${Rest}`>
-  : Lowercase<DashUppercase<Uncapitalize<Trim<LowerAllCaps<S>>>>>;

package/src/types/alphabetic/StripLeading.ts

@@ -1,23 +0,0 @@
-import { IfLiteral } from "../boolean-logic/IsLiteral";
-
-/**
- * **StripStarting**`<T, U>`
- *
- * Will strip off of `T` the starting string defined by `U` when
- * both are string literals.
- * ```ts
- * type T = "Hello World";
- * type U = "Hello ";
- * // "World"
- * type R = StripStarting<T,U>;
- * ```
- */
-export type StripLeading<T extends string, U extends string> = IfLiteral<
-  // can only operate on literal strings
-  T,
-  // this path represents successful strip opp
-  // but we must never accept `U` being wide
-  string extends U ? never : T extends `${U}${infer After}` ? After : T,
-  // here we must stay wide
-  string
->;

package/src/types/alphabetic/StripTrailing.ts

@@ -1,23 +0,0 @@
-import { IfLiteral } from "../boolean-logic/IsLiteral";
-
-/**
- * **StripEnding**`<T, U>`
- *
- * Will strip off of `T` the ending defined by `U` when
- * both are string literals.
- * ```ts
- * type T = "Hello World";
- * type U = " World";
- * // "Hello"
- * type R = StripEnding<T,U>;
- * ```
- */
-export type StripTrailing<T extends string, U extends string> = IfLiteral<
-  // can only operate on literal strings
-  T,
-  // this path represents successful strip opp
-  // but we must never accept `U` being wide
-  string extends U ? never : T extends `${infer Before}${U}` ? Before : T,
-  // here we must stay wide
-  string
->;

package/src/types/alphabetic/Url.ts

@@ -1,29 +0,0 @@
-import { AlphaNumeric, Ipv4, VariableName } from "./alpha-characters";
-
-export type NetworkProtocol = "http" | "https" | "file" | "ws" | "wss";
-
-/**
- * A literal variant of _string_ which is meant to represent a domain name
- * (e.g., `www.someplace.com`, etc.)
- */
-export type DomainName =
-  | `${AlphaNumeric}${string}.${AlphaNumeric}${string}`
-  | `${AlphaNumeric}${string}.${AlphaNumeric}${string}.${string}`
-  | `${AlphaNumeric}${string}.${AlphaNumeric}${string}.${string}.${string}`;
-
-export type RelativeUrl = `${VariableName | "/"}`;
-
-/**
- * A literal variant of _string_ which forces a string to follow conventions
- * for a fully qualified URL like `https://google.com`. It can't ensure the
- * type is fully valid but does help to avoid some typos.
- */
-export type FullyQualifiedUrl = `${NetworkProtocol}://${Ipv4 | DomainName}/${string}`;
-
-export type UrlBuilder =
-  | (<P extends NetworkProtocol, D extends DomainName, B extends RelativeUrl>(
-      protocol: P,
-      domain: D,
-      basePath: B
-    ) => `${P}://${D}/${B}`)
-  | (<U extends RelativeUrl>(url: U) => U);

package/src/types/alphabetic/alpha-characters.ts

@@ -1,81 +0,0 @@
-export type LowerAlpha =
-  | "a"
-  | "b"
-  | "c"
-  | "d"
-  | "e"
-  | "f"
-  | "g"
-  | "h"
-  | "i"
-  | "j"
-  | "k"
-  | "l"
-  | "m"
-  | "n"
-  | "o"
-  | "p"
-  | "q"
-  | "r"
-  | "s"
-  | "t"
-  | "u"
-  | "v"
-  | "w"
-  | "x"
-  | "y"
-  | "z";
-
-/** Uppercase alphabetic character */
-export type UpperAlpha = Uppercase<LowerAlpha>;
-
-/**
- * Alphabetical characters (upper and lower)
- */
-export type Alpha = UpperAlpha | LowerAlpha;
-
-export type Whitespace = " " | "\n" | "\t";
-
-export type Punctuation = "." | "," | ";" | "!" | "?";
-/**
- * Characters which typically are used to separate words (but not including a space)
- */
-export type StringDelimiter = "_" | "-" | "/" | "\\";
-
-export type OpeningBracket = "(" | "[" | "{";
-export type ClosingBracket = ")" | "]" | "}";
-
-/**
- * Opening and closing parenthesis
- */
-export type Parenthesis = "(" | ")";
-
-/**
- * Opening and closing brackets
- */
-export type Bracket = OpeningBracket | ClosingBracket;
-
-/**
- * Numeric string characters
- */
-export type NumericString = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
-
-/**
- * Any alphabetic or numeric string character
- */
-export type AlphaNumeric = Alpha | NumericString;
-
-/**
- * Allows alphanumeric characters and some special characters typically allowed
- * in variable names.
- */
-export type VariableName = AlphaNumeric | "_" | "." | "-";
-
-export type SpecialCharacters = "@" | "~" | "^" | "#" | "&" | "*";
-
-/**
- * Non-alphabetic characters including whitespace, string numerals, and
- */
-export type NonAlpha = Whitespace | Punctuation | NumericString | Bracket | SpecialCharacters;
-
-export type Ipv4 = `${number}.${number}.${number}.${number}`;

package/src/types/alphabetic/index.ts

@@ -1,32 +0,0 @@
-// #autoindex, exclude: Alpha
-// #region auto-indexed files
-// index last changed at: 8th Aug, 2022, 09:51 AM ( GMT-7 )
-// hash-code: b32382ed
-
-// file exports
-export * from "./AllCaps";
-export * from "./CamelCase";
-export * from "./CapitalizeWords";
-export * from "./DashToSnake";
-export * from "./DashUppercase";
-export * from "./Cardinality";
-export * from "./Dasherize";
-export * from "./HasUppercase";
-export * from "./EnsureLeading";
-export * from "./EnsureTrailing";
-export * from "./IsCapitalized";
-export * from "./KebabCase";
-export * from "./LowerAllCaps";
-export * from "./PascalCase";
-export * from "./PathJoin";
-export * from "./Pluralize";
-export * from "./SnakeCase";
-export * from "./StripLeading";
-export * from "./StripTrailing";
-export * from "./alpha-characters";
-export * from "./Url";
-
-// #endregion auto-indexed files
-
-// see https://github.com/inocan-group/do-devops/docs/autoindex.md
-// for more info

package/src/types/append-types.ts

@@ -1,10 +0,0 @@
-export type AppendToObject<T, U extends keyof any, V> = {
-  [K in keyof T | U]: K extends keyof T ? T[K] : V;
-};
-
-/**
- * Appends a new Key/Value to an existing dictionary <T>
- */
-export type AppendToDictionary<TDict, TKey extends string, TValue> = {
-  [K in keyof TDict | TKey]: K extends keyof TDict ? TDict[K] : TValue;
-};

package/src/types/boolean-logic/EndsWith.ts

@@ -1,40 +0,0 @@
-import { IsStringLiteral } from "src/types/boolean-logic";
-import { Narrowable } from "../Narrowable";
-
-/**
- * **EndsWith**<T,U>
- *
- * A type utility which checks whether `T` _ends with_ the string literal `U`.
- *
- * If both `T` and `U` are string literals then the type system will resolve
- * to a literal `true` or `false` but if either is not a literal that it will
- * just resolve to `boolean` as the value can not be known at design time..
- */
-export type EndsWith<
-  TValue extends string,
-  TEndsWith extends string
-> = IsStringLiteral<TEndsWith> extends true
-  ? IsStringLiteral<TValue> extends true // both literals
-    ? TValue extends `${string}${TEndsWith}`
-      ? true
-      : false
-    : boolean
-  : boolean;
-
-/**
- * **IfEndsWith**<TValue, TEndsWith, IF, ELSE, MAYBE>
- *
- * Type utility which converts type to `IF` type _if_ `TValue` _ends with_ `TEndsWith` but
- * otherwise converts type to `ELSE`. If there are wide types in the mix then the type will
- * result in the union of IF and ELSE.
- */
-export type IfEndsWith<
-  TValue extends string,
-  TEndsWith extends string,
-  IF extends Narrowable,
-  ELSE extends Narrowable
-> = EndsWith<TValue, TEndsWith> extends true
-  ? IF
-  : EndsWith<TValue, TEndsWith> extends false
-  ? ELSE
-  : IF | ELSE;

package/src/types/boolean-logic/Extends.ts

@@ -1,22 +0,0 @@
-import { Narrowable } from "../Narrowable";
-
-/**
- * **Extends**`<T, EXTENDS>`
- *
- * Boolean type utility which returns `true` if `T` _extends_ `EXTENDS`.
- */
-export type Extends<T extends Narrowable, EXTENDS extends Narrowable> = T extends EXTENDS
-  ? true
-  : false;
-/**
- * **IfExtends**
- *
- * Branching type utility which returns type `IF` when `E` _extends_ `T`; otherwise
- * it will return the type `ELSE`.
- */
-export type IfExtends<
-  T extends Narrowable,
-  EXTENDS extends Narrowable,
-  IF extends Narrowable,
-  ELSE extends Narrowable
-> = Extends<T, EXTENDS> extends true ? IF : ELSE;

package/src/types/boolean-logic/HasParameters.ts

@@ -1,21 +0,0 @@
-import { AnyFunction } from "src/runtime";
-import { Length } from "../Length";
-import { Narrowable } from "../Narrowable";
-import { IsEqual } from "./equivalency";
-
-/**
- * **HasParameters**`<T>`
- *
- * Type utility which detects if `T` is both a function and whether that
- * function has at least one type parameter.
- * ```ts
- * const fn = (foo: string) => `${foo}bar`;
- * // true
- * type P = HasParameters<typeof fn>;
- * ```
- */
-export type HasParameters<T extends Narrowable> = T extends AnyFunction
-  ? IsEqual<Length<Parameters<T>>, 0> extends true
-    ? false
-    : true
-  : false;

package/src/types/boolean-logic/Includes.ts

@@ -1,33 +0,0 @@
-import { TupleToUnion } from "../type-conversion";
-import { IsLiteral, IsStringLiteral } from "./IsLiteral";
-
-/**
- * **Includes**`<TSource, TValue>`
- *
- * Type utility which returns `true` or `false` based on whether `TValue` is found
- * in `TSource`. Where `TSource` can be a string literal or an array of string literals.
- *
- * **Note:** if the source is a _wide_ type (aka, `string` or `string[]`) then there is
- * no way to know at design-time whether the value includes `TValue` and so it will return
- * a type of `boolean`.
- */
-export type Includes<
-  TSource extends string | readonly string[],
-  TValue extends string
-> = TSource extends string[]
-  ? IsStringLiteral<TupleToUnion<TSource>> extends true
-    ? IsLiteral<TValue> extends true
-      ? TValue extends TupleToUnion<TSource>
-        ? true
-        : false
-      : boolean
-    : boolean
-  : TSource extends string
-  ? IsLiteral<TSource> extends true
-    ? IsLiteral<TValue> extends true
-      ? TSource extends `${string}${TValue}${string}`
-        ? true
-        : false
-      : boolean
-    : boolean
-  : boolean;

package/src/types/boolean-logic/IsLiteral.ts

@@ -1,101 +0,0 @@
-import { Narrowable } from "../Narrowable";
-import { IsBooleanLiteral } from "./boolean";
-
-/**
- * **IsStringLiteral**
- *
- * Type utility which returns true/false if the string a _string literal_ versus
- * just the _string_ type.
- */
-export type IsStringLiteral<T extends Narrowable> = [T] extends [string]
-  ? string extends T
-    ? false
-    : true
-  : false;
-
-/**
- * **IfStringLiteral**
- *
- * Branch utility which returns `IF` type when `T` is a string literal and `ELSE` otherwise
- */
-export type IfStringLiteral<T extends string, IF extends Narrowable, ELSE extends Narrowable> = [
-  IsStringLiteral<T>
-] extends [true]
-  ? IF
-  : ELSE;
-
-/**
- * **IsNumericLiteral**
- *
- * Type utility which returns true/false if the numeric value a _numeric literal_ versus
- * just the _number_ type.
- */
-export type IsNumericLiteral<T extends number> = number extends T ? false : true;
-
-/**
- * **IfNumericLiteral**
- *
- * Branch utility which returns `IF` type when `T` is a numeric literal and `ELSE` otherwise
- */
-export type IfNumericLiteral<
-  T extends number,
-  IF extends Narrowable,
-  ELSE extends Narrowable
-> = IsNumericLiteral<T> extends true ? IF : ELSE;
-
-// [note on handling of boolean](https://stackoverflow.com/questions/74213646/detecting-type-literals-works-in-isolation-but-not-when-combined-with-other-lite/74213713#74213713)
-
-/**
- * **IsLiteral**
- *
- * Type utility which returns true/false if the value passed -- a form of a
- * string, number, or boolean -- is a _literal_ value of that type (true) or
- * the more generic wide type (false).
- */
-export type IsLiteral<T> = [T] extends [string]
-  ? IsStringLiteral<T>
-  : [T] extends [boolean]
-  ? IsBooleanLiteral<T>
-  : [T] extends [number]
-  ? IsNumericLiteral<T>
-  : false;
-
-/**
- * **IsOptionalLiteral**
- *
- * Type utility which returns true/false if the value passed -- a form of a
- * string, number, or boolean -- is a _literal_ value of that type (true) or
- * the more generic wide type (false).
- *
- * This type also strips off _undefined_ from any possible union type to evaluate
- * to `true` even when a literal value is in union with _undefined_. If you don't
- * want to test for the union with _undefined_ use the `IsOptional` utility instead.
- */
-export type IsOptionalLiteral<T> = [Exclude<T, undefined>] extends [string]
-  ? IsStringLiteral<Exclude<T, undefined>>
-  : [Exclude<T, undefined>] extends [boolean]
-  ? IsBooleanLiteral<Exclude<T, undefined>>
-  : [Exclude<T, undefined>] extends [number]
-  ? IsNumericLiteral<Exclude<T, undefined>>
-  : false;
-
-/**
- * **IfLiteral**
- *
- * Branch type utility with return `IF` when `T` is a _literal_ value and `ELSE` otherwise
- */
-export type IfLiteral<T, IF extends Narrowable, ELSE extends Narrowable> = IsLiteral<T> extends true
-  ? IF
-  : ELSE;
-
-/**
- * **IfOptionalLiteral**
- *
- * Branch type utility with return `IF` when `T` is a _literal_ value (with possibly
- * the inclusion of _undefined_); otherwise returns the type `ELSE`
- */
-export type IfOptionalLiteral<
-  T,
-  IF extends Narrowable,
-  ELSE extends Narrowable
-> = IsOptionalLiteral<T> extends true ? IF : ELSE;