inferred-types 0.51.1 → 0.51.2

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

@@ -1,174 +0,0 @@
-import { ComparatorOperation, Compare } from "../boolean-logic";
-import { AfterFirst, First, Last } from "../lists";
-import { Increment } from "../numeric-literals";
-import { Chars } from "./Chars";
-
-type _FindIndexes<
-  TContent extends readonly unknown[],
-  TFind,
-  TOp extends ComparatorOperation = "extends",
-  TIdx extends number = 0,
-  TResults extends readonly number[] = []
-> = [] extends TContent
-? TResults
-: _FindIndexes<
-    AfterFirst<TContent>,
-    TFind,
-    TOp,
-    Increment<TIdx>,
-    Compare<First<TContent>, TOp, TFind> extends true
-      ? [
-          ...TResults,
-          TIdx
-        ]
-      : TResults
-  >;
-
-
-
-
-/**
- * **FindIndexes**
- *
- * Utility which returns all _indexes_ in `TContent`
- * where `TFind` is found.
- *
- * - by default, the comparision operation is "extends" but
- * you can change this with `TOp`.
- * - the content (`TContent`) can be either a string or a tuple
- *
- * **Related:** `FindFirstIndex`, `FindLastIndex`, `FindIndexesWithMeta`
- */
-export type FindIndexes<
-  TContent extends string | readonly unknown[],
-  TFind,
-  TOp extends ComparatorOperation = "extends"
-> = TContent extends string
-? _FindIndexes<
-    Chars<TContent>,
-    TFind,
-    TOp
-  >
-: TContent extends readonly unknown[]
-  ? _FindIndexes<TContent,TFind,TOp>
-  : never;
-
-/**
- * **FindFirstIndex**`<TContent,TFind,[TOp]>`
- *
- * Utility which returns the _first_ index in the content
- * which matches the
- */
-export type FindFirstIndex<
-TContent extends string | readonly unknown[],
-  TFind,
-  TOp extends ComparatorOperation = "extends"
-> = First<FindIndexes<TContent,TFind,TOp>>;
-
-
-export type FindLastIndex<
-TContent extends string | readonly unknown[],
-  TFind,
-  TOp extends ComparatorOperation = "extends"
-> = Last<FindIndexes<TContent,TFind,TOp>>;
-
-
-
-export type FindIndexMetaOfString = {
-  start: number;
-  end: number;
-  break: unknown;
-}
-
-export type FindIndexMetaOfTuple = {
-  index: number;
-
-  break: unknown;
-}
-
-
-type _FindIndexesWithMeta__String<
-TOriginal extends readonly unknown[],
-TContent extends readonly unknown[],
-TFind,
-TOp extends ComparatorOperation = "extends",
-TIdx extends number = 0,
-TResults extends readonly FindIndexMetaOfString[] | [] = []
-> = [] extends TContent
-? TResults
-: _FindIndexesWithMeta__String<
-  TOriginal,
-  AfterFirst<TContent>,
-  TFind,
-  TOp,
-  Increment<TIdx>,
-  Compare<First<TContent>, TOp, TFind> extends true
-    ? [
-        ...TResults,
-        {
-          start: TIdx,
-          end: Increment<TIdx>,
-          break: TOriginal[TIdx]
-        }
-      ]
-    : TResults
->;
-
-type _FindIndexesWithMeta__Tuple<
-  TOriginal extends readonly unknown[],
-  TContent extends readonly unknown[],
-  TFind,
-  TOp extends ComparatorOperation = "extends",
-  TIdx extends number = 0,
-  TResults extends readonly FindIndexMetaOfTuple[] | [] = []
-> = [] extends TContent
-? TResults
-: _FindIndexesWithMeta__Tuple<
-  TOriginal,
-  AfterFirst<TContent>,
-  TFind,
-  TOp,
-  Increment<TIdx>,
-  Compare<First<TContent>, TOp, TFind> extends true
-    ? [
-        ...TResults,
-        {
-          index: TIdx,
-          break: TOriginal[TIdx]
-        }
-      ]
-    : TResults
->;
-
-
-/**
- * **FindIndexesWithMeta**
- *
- * Utility which returns all _indexes_ in `TContent`
- * where `TFind` is found.
- *
- * - by default, the comparision operation is "extends" but
- * you can change this with `TOp`.
- * - the content (`TContent`) can be either a string or a tuple
- *
- * **Related:** `FindFirstIndex`, `FindLastIndex`
- */
-export type FindIndexesWithMeta<
-  TContent extends string | readonly unknown[],
-  TFind,
-  TOp extends ComparatorOperation = "extends"
-> = TContent extends string
-? _FindIndexesWithMeta__String<
-    Chars<TContent>,
-    Chars<TContent>,
-    TFind,
-    TOp
-  >
-: TContent extends readonly unknown[]
-  ? _FindIndexesWithMeta__Tuple<
-      TContent,
-      TContent,
-      TFind,
-      TOp
-    >
-  : never;

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

@@ -1,33 +0,0 @@
-import {   First, Chars } from "inferred-types/dist/types/index";
-
-type Process<TContent extends string> = First<Chars<TContent>>;
-
-type Iterate<TContent extends readonly string[]> = {
-  [K in keyof TContent]: Process<TContent[K]>
-}
-
-
-/**
- * **FirstChar**`<TContent>`
- *
- * When `TContent` extends a _string_:
- *   - will return the first character in a string literal
- *   - returns `string` when a wide type is encountered
- *   - returns `never` when an empty string is passed in
- *
- * When `TContent` is a tuple of strings:
- *   - each item will be processed as described above
- *
- * **Related:** `LastChar`, `AfterFirstChar`
- */
-export type FirstChar<
-  TContent extends string | readonly string[]
-> = TContent extends readonly string[]
-? Iterate<TContent>
-: TContent extends string
-  ? string extends TContent
-    ? string
-    : Process<TContent>
-  : never;
-
-

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

@@ -1,16 +0,0 @@
-import { UpperAlphaChar } from "inferred-types/dist/types/index";
-
-/**
- * Indicates whether `T` has uppercase characters in it.
- * ```ts
- * // true
- * type T = HasUppercase<"Foobar">;
- * // false
- * type T = HasUppercase<"foobar">;
- * // "unknown"
- * type T = HasUppercase<string>;
- * ```
- */
-export type HasUppercase<T extends string> = string extends T
-  ? "unknown"
-  : T extends `${string}${UpperAlphaChar}${string}` ? true : false;

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

@@ -1,18 +0,0 @@
-/**
- * Returns true or false value based on whether the string literal is capitalized.
- * ```ts
- * // true
- * type T2 = IsCapitalized<"One">;
- * // false
- * type T1 = IsCapitalized<"one">;
- * // "unknown"
- * const a: string = "Hi";
- * type T3 = IsCapitalized<typeof a>;
- * ```
- * 
- * Note: _if the value passed in is a "string" then the result will be "unknown"_
- */
-export type IsCapitalized<T extends string> = string extends T
-  ? "unknown"
-  : T extends Capitalize<T> ? true : false;
-

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

@@ -1,64 +0,0 @@
-import {
-  IsGreaterThan,
-  AfterFirst,
-  First,
-  ToStringArray,
-  TakeFirst
-} from "inferred-types/dist/types/index";
-
-
-type Process<
-  TTuple extends readonly string[],
-  TSeparator extends string,
-  TResult extends string = ""
-> = [] extends TTuple
-? TResult
-: Process<
-    AfterFirst<TTuple>,
-    TSeparator,
-    TResult extends ""
-    ? First<TTuple> extends ""
-      ? TResult
-      : `${First<TTuple>}`
-    : First<TTuple> extends ""
-      ? TResult
-      : `${TResult}${TSeparator}${First<TTuple>}`
-  >;
-
-type Slicer<
-  TTuple extends readonly unknown[],
-  TMax extends number | null,
-  TEllipsis extends string | false
-> = TMax extends number
-? TakeFirst<TTuple,TMax> extends readonly unknown[]
-  ? TEllipsis extends string
-    ? ToStringArray<[...TakeFirst<TTuple,TMax>, TEllipsis]>
-    : ToStringArray<TakeFirst<TTuple,TMax>>
-  : never
-: ToStringArray<TTuple>;
-
-/**
- * **Join**`<TArr,[TSeparator],[TMax]>`
- *
- * Joins together an array of items into a string.
- *
- * - the _separator_ between items defaults to an empty string this can be
- * changed to whatever is needed
- * - non-string types will be converted to strings as best as possible
- * - specifying a value for `TMax` will truncate tuples which are greater
- * than the specified length and add an ellipsis marker as the last element
- *
- * **Related:** `Concat<TArr>`
- */
-export type Join<
-  TTuple extends readonly unknown[],
-  TSeparator extends string = "",
-  TMax extends number | null = null,
-  TEllipsis extends string | false = "..."
-> = ToStringArray<TTuple> extends readonly string[]
-? TMax extends number
-  ? IsGreaterThan<TTuple["length"], TMax> extends true
-    ? Process<Slicer<TTuple,TMax,TEllipsis>, TSeparator>
-    : Process<ToStringArray<TTuple>, TSeparator>
-  : Process<ToStringArray<TTuple>, TSeparator>
-: never;

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

@@ -1,35 +0,0 @@
-import {
-  Last,
-  Chars,
-} from "inferred-types/dist/types/index";
-
-type Process<TContent extends string> = Last<Chars<TContent>>;
-
-type Iterate<TContent extends readonly string[]> = {
-  [K in keyof TContent]: Process<TContent[K]>
-}
-
-
-
-/**
- * **LastChar**`<TContent>`
- *
- * When `TContent` extends a _string_:
- *   - will return the last character in a string literal
- *   - returns `string` when a wide type is encountered
- *   - returns `never` when an empty string is passed in
- *
- * When `TContent` is a tuple of strings:
- *   - each item will be processed as described above
- *
- * **Related:** `FirstChar`, `AfterFirstChar`
- */
-export type LastChar<
-  TContent extends string | readonly string[]
-> = TContent extends readonly string[]
-  ? Iterate<TContent>
-  : TContent extends string
-    ? string extends TContent
-      ? string
-      : Process<TContent>
-    : never;

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

@@ -1,55 +0,0 @@
-import {
-  Join,
-  First,
-  Last,
-} from "inferred-types/dist/types/index";
-
-
-export type StripSlash<
-  T extends readonly string[]
-> = {
-  [K in keyof T]: T[K] extends `/${infer Middle}/`
-    ? Middle
-    : T[K] extends `/${infer Trailing}`
-    ? Trailing
-    : T[K] extends `${infer Leading}/`
-    ? Leading
-    : T[K]
-}
-
-type Process<
-  TPath extends string,
-  TFirst extends string,
-  TLast extends string
-> =
-TFirst extends `/${string}`
-  ? TLast extends `${string}/`
-    ? `/${TPath}/`
-    : `/${TPath}`
-  : TLast extends `${string}/`
-    ? `${TPath}/`
-    : TPath;
-
-
-/**
- * **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<
-  TSegments extends readonly string[]
-> = StripSlash<TSegments> extends readonly string[]
-? Process<
-  Join<StripSlash<TSegments>, "/">,
-  First<TSegments>,
-  Last<TSegments>
->
-: never;

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

@@ -1,107 +0,0 @@
-/* eslint @typescript-eslint/no-unused-vars: "off" */
-
-import { PLURAL_EXCEPTIONS } from "inferred-types/dist/constants/index";
-import {
-  Consonant,
-  IsStringLiteral,
-  EnsureTrailing,
-  StripTrailing,
-  Whitespace,
-  TrimRight,
-  Join,
-  RightWhitespace,
-} from "inferred-types/dist/types/index";
-
-type ExceptionLookup = typeof PLURAL_EXCEPTIONS;
-
-type SingularNoun = "s" | "sh" | "ch" | "x" | "z" | "o";
-type F = "f" | "fe";
-type Y = `${Consonant}y`;
-
-type IsException<T extends string> = T extends keyof ExceptionLookup ? true : false;
-
-/**
- * Looks up a singular word `T` as a possible singular exception and converts it
- * to the plural equivalent. Will return `never` if `T` is not an exception.
- */
-type PluralException<
-  T extends string
-> = T extends keyof ExceptionLookup
-  ? ExceptionLookup[T]
-  : never;
-
-/** validates that a string literal ends in "is" */
-type EndsIn_IS<T extends string> = T extends `${string}is` ? T : never;
-
-/** validates that a string literal is a singular noun */
-type EndsInSingularNoun<T extends string> = T extends `${string}${SingularNoun}` ? T : never;
-
-/** validates that a string literal ends in "f" or "fe" */
-type EndsIn_F<T extends string> = T extends `${string}${F}` ? T : never;
-
-/** validates that a string literal ends a consonant followed by "y" */
-type EndsIn_Y<T extends string> = T extends `${string}${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
- */
-type PluralizeEndingSingularNoun<
-  T extends string
-> = EnsureTrailing<T, "es">;
-
-/**
- * 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
- */
-type PluralizeEndingIn_Y<
-  T extends string
-> = EnsureTrailing<StripTrailing<T,"y">, "ies">;
-
-
-type _Pluralize<
-  T extends string
-> = IsException<T> extends true
-    ? 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`
-
-
-
-/**
- * **Pluralize**`<T>`
- *
- * Pluralizes the word `T`, using _language rules_ on pluralization for English as well as
- * leveraging many known exceptions to the linguistic rules.
- */
-export type Pluralize<
-  T extends string
-> = IsStringLiteral<T> extends true
-? T extends `${string}${Whitespace}`
-  ? Join<[
-      _Pluralize< TrimRight<T> >,
-      RightWhitespace<T>
-  ]>
-  : _Pluralize<T>
-: string;
-
-

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

@@ -1,17 +0,0 @@
-import { AsString } from "inferred-types/dist/types/index";
-
-/**
- * **Prepend**`<TStr, TPrepend>`
- *
- * Prepends the string `TPrepend` prior to existing `TStr` string.
- * ```ts
- * // "Bob, you're the best"
- * type T = Prepend<"you're the best", "Bob, ">;
- * ```
- *
- * **Related:** `EnsureLeading`
- */
-export type Prepend<
-  TStr extends string,
-  TPrepend extends string | number | boolean
-> = `${AsString<TPrepend>}${TStr}`;

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

@@ -1,18 +0,0 @@
-import { AfterFirst, AsString, First } from "inferred-types/dist/types/index";
-
-type PrependAcc<
-  TList extends readonly string[],
-  TPrepend extends string,
-  TResults extends string[] = []
-> = [] extends TList
-  ? TResults
-  : PrependAcc<
-      AfterFirst<TList>,
-      TPrepend,
-      [...TResults, `${TPrepend}${First<TList>}`]
-    >;
-
-export type PrependAll<
-  TList extends readonly string[],
-  TPrepend extends string | number | boolean
-> = PrependAcc<TList, AsString<TPrepend>>;

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

@@ -1,6 +0,0 @@
-import { PROXMOX_CT_STATE } from "inferred-types/dist/constants/index";
-
-/**
- * the _states_ a Proxmox LXC container can be in
- */
-export type ProxmoxCtState = typeof PROXMOX_CT_STATE[number];

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

@@ -1,14 +0,0 @@
-import { IsNegativeNumber , FixedLengthArray , Concat } from "inferred-types/dist/types/index";
-
-/**
- * **Repeat**`<TStr,TCount>`
- *
- * Creates a string literal by repeating a given string `TStr`, `TCount` times.
- */
-export type Repeat<
-  TStr extends string,
-  TCount extends number
-> = IsNegativeNumber<TCount> extends true
-? ""
-: Concat<FixedLengthArray<TStr,TCount>>;
-

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

@@ -1,68 +0,0 @@
-import {
-  If,
-  IfAllLiteral,
-  IsNever,
-  IsTrue,
-  IsUnion,
-  MaxLength,
-  UnionToTuple
-} from "inferred-types/dist/types/index";
-
-type _RetainAfter<
-  TStr extends string,
-  TBreak extends string,
-  TInclude extends boolean = false
-> = IfAllLiteral<
-[TStr, TBreak],
-TBreak extends any
-? TStr extends `${string}${TBreak}${infer Rest}`
-  ? If<
-      IsTrue<TInclude>,
-      `${TBreak}${Rest}`,
-      Rest
-    >
-  : never
-: never,
-string
->
-
-/**
- * **RetainAfter**`<TStr, TBreak, [TInclude]>`
- *
- * Receives a string `TStr` and _retains_ characters after
- * the first occurrence of `TBreak` is found.
- *
- * By default the first `TBreak` found will _not_ be included
- * in the returned string but you can set `TInclude` to true
- * to reverse this behavior.
- *
- * ### Example
- * ```ts
- * // "blue green"
- * type T = RetainAfter<"red blue green", " ">;
- * // " blue green"
- * type T2 = RetainAfter<"red blue green", " ", true>;
- * ```
- */
-export type RetainAfter<
-  TStr extends string,
-  TBreak extends string,
-  TInclude extends boolean = false
-> = IsNever<_RetainAfter<TStr,TBreak,TInclude>> extends true
-? ""
-: IsUnion<_RetainAfter<TStr,TBreak,TInclude>> extends true
-? MaxLength<UnionToTuple<_RetainAfter<TStr,TBreak,TInclude>>>
-: _RetainAfter<TStr,TBreak,TInclude>;
-
-
-export type RetainAfterLast<
-  TStr extends string,
-  TBreak extends string,
-  TInclude extends boolean = false
-> = IfAllLiteral<
-  [TStr, TBreak],
-  TStr extends `${string}${infer Break extends TBreak}${infer REST}`
-    ? If<IsTrue<TInclude>, `${Break}${REST}`, `${REST}`>
-    : TStr,
-  string
->