inferred-types 0.51.1 → 0.51.2

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

@@ -1,69 +0,0 @@
-import { If } from "../boolean-logic";
-import { AfterFirst, First } from "../lists";
-import { Chars } from "./Chars";
-
-type Process<
-  TChars extends readonly string[],
-  TOp extends "is" | "not",
-  TComparator extends string,
-  TInclude extends boolean = false,
-  TResult extends string = "",
-> = [] extends TChars
-? TResult
-: First<TChars> extends TComparator
-  ? TOp extends "is"
-    ? Process<
-        AfterFirst<TChars>,
-        TOp,
-        TComparator,
-        TInclude,
-        `${TResult}${First<TChars>}`
-      >
-    : If<TInclude, `${TResult}${First<TChars>}` ,  TResult >
-  : TOp extends "is"
-    ? If<TInclude, `${TResult}${First<TChars>}` ,  TResult >
-    : Process<
-        AfterFirst<TChars>,
-        TOp,
-        TComparator,
-        TInclude,
-        `${TResult}${First<TChars>}`
-      >;
-
-/**
- * **RetainUntil**`<TContent,TComparator>`
- *
- * Proxies the content of `TContent` character-by-character _until_
- * a character _extends_ `TComparator`.
- *
- * ```ts
- * // "1984"
- * type Num = RetainUntil<"1984 is a number", WhiteSpace>;
- * ```
- *
- * **Related:** `RetainWhile`
- */
-export type RetainUntil<
-  TContent extends string,
-  TComparator extends string,
-  TInclude extends boolean = false
-> = Process<Chars<TContent>,"not",TComparator, TInclude>;
-
-
-/**
- * **RetainWhile**`<TContent,TComparator>`
- *
- * Proxies the content of `TContent` character-by-character _until_
- * a character _does not extend_ `TComparator`.
- *
- * ```ts
- * // "1984"
- * type Num = RetainWhile<"1984 is a number", NumericChar>;
- * ```
- *
- * **Related:** `RetainUntil`
- */
-export type RetainWhile<
-  TContent extends string,
-  TComparator extends string,
-> = Process<Chars<TContent>,"is",TComparator>;

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

@@ -1,113 +0,0 @@
-import {
-  AfterFirst,
-  BeforeLast,
-  Chars,
-  Filter,
-  First,
-  IsUnion,
-  IsStringLiteral,
-  IsWideType,
-  Last,
-  TupleToUnion,
-  UnionToTuple,
-  As,
-} from "inferred-types/dist/types/index";
-
-type UnionPolicy = "omit" | "include";
-
-
-type UnionSplit<
-  TContent extends readonly string[],
-  TSep extends string,
-  TUnionPolicy extends UnionPolicy,
-  TResult extends readonly string[] = []
-> = [] extends TContent
-? TResult
-: // recurse
-  UnionSplit<
-    AfterFirst<TContent>, // advance to next character
-    TSep,
-    TUnionPolicy,
-    First<TContent> extends TSep
-      ? // split mark
-        [
-          ...TResult,
-          ...(
-            TUnionPolicy extends "omit"
-              ? [""]
-              : [First<TContent>]
-          )
-        ]
-      : // add to existing
-        Last<TResult,""> extends string
-          ? First<TContent> extends string
-            ? BeforeLast<TResult> extends readonly string[]
-              ? [
-                ...BeforeLast<TResult>,
-                `${Last<TResult>}${First<TContent>}`
-              ]
-              : never
-            : never
-          : never
->;
-
-type LiteralSplit<
-  TContent extends string,
-  TSep extends string,
-  TUnionPolicy extends UnionPolicy = "omit",
-  TResults extends readonly string[] = []
-> = TContent extends `${infer Block}${TSep}${infer Rest}`
-? LiteralSplit<
-    Rest,
-    TSep,
-    TUnionPolicy,
-    [
-      ...TResults,
-      TUnionPolicy extends "omit" ? Block : `${Block}${TSep}`
-    ]
-  >
-: Filter<[...TResults, TContent], "">;
-
-type Process<
-  TContent extends string,
-  TSep extends string | readonly string[],
-  TUnionPolicy extends UnionPolicy = "omit"
-> = IsWideType<TContent> extends true
-? string
-: TSep extends readonly string[]
-    ? TupleToUnion<TSep> extends string
-      ? Chars<TContent> extends readonly string[]
-        ? UnionSplit<Chars<TContent>,TupleToUnion<TSep>,TUnionPolicy>
-        : never
-      : never
-    : TSep extends string
-      ? LiteralSplit<TContent,TSep,TUnionPolicy>
-      : never;
-
-type PreProcess<TContent extends string,
-TSep extends string | readonly string[],
-TUnionPolicy extends UnionPolicy = "omit"
-> = IsUnion<TSep> extends true
-  ? UnionToTuple<TSep> extends readonly string[]
-    ? Process<TContent, UnionToTuple<TSep>, TUnionPolicy>
-    : never
-  : Process<TContent,TSep,TUnionPolicy>;
-
-
-/**
- * **Split**`<TContent,TSep,[TPolicy]>`
- *
- * Type conversion utility which receives a string `TContent`,
- * and _splits_ it into multiple string elements based on `TSep`.
- *
- * - `TSep` can be a _string_, a _union_ of string literals, or a tuple of strings
- * - typically you want to have the `TSep` _omitted_ from the result elements
- * but you can opt to include them by changing `TPolicy` to "include"
- */
-export type Split<
-  TContent extends string,
-  TSep extends string | readonly string[],
-  TPolicy extends UnionPolicy = "omit"
-> = IsStringLiteral<TContent> extends true
-  ? As<PreProcess<TContent,TSep,TPolicy>, readonly string[]>
-  : string[];

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

@@ -1,17 +0,0 @@
-import { Tuple } from "inferred-types/dist/types/index";
-
-type Compute<
-  TStr extends string,
-  TLen extends Tuple = []
-> = TStr extends `${infer _Char}${infer Rest}`
-  ? Compute<Rest, [...TLen, unknown]>
-  : TLen["length"];
-
-/**
- * **StrLen**`<T>`
- *
- * Provides the length of a string if T is a string literal,
- * otherwise just returns `number` type.
- */
-export type StrLen<T extends string> = Compute<T>;
-

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

@@ -1,24 +0,0 @@
-import {  IsStringLiteral } from "inferred-types/dist/types/index";
-
-/**
- * **StripAfter**`<TStr, TBreak>`
- *
- * Receives a string `TStr` and truncates all characters in
- * the first occurrence of `TBreak` and all remaining chars.
- *
- * ### Example
- * ```ts
- * // "hello"
- * type T = StripAfter<"hello world", " ">;
- * ```
- */
-export type StripAfter<
-  TStr extends string,
-  TBreak extends string
-> = IsStringLiteral<TStr> extends true
-  ? IsStringLiteral<TBreak> extends true
-    ? TStr extends `${infer Before}${TBreak}${string}`
-      ? Before
-      : TStr
-    : string
-  : string;

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

@@ -1,24 +0,0 @@
-import { IsStringLiteral } from "inferred-types/dist/types/index";
-
-/**
- * **StripBefore**`<TStr, TBreak>`
- *
- * Receives a string `TStr` and truncates all characters in
- * the first occurrence of `TBreak` and all remaining chars.
- *
- * ### Example
- * ```ts
- * // "world"
- * type T = StripBefore<"hello world", " ">;
- * ```
- */
-export type StripBefore<
-  TStr extends string,
-  TBreak extends string
-> = IsStringLiteral<TStr> extends true
-  ? IsStringLiteral<TBreak> extends true
-    ? TStr extends `${string}${TBreak}${infer REST}`
-      ? `${REST}`
-      : TStr
-    : string
-  : string

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

@@ -1,48 +0,0 @@
-import {
-  And,
-  AsNumber,
-  AsStringUnion,
-  IsStringLiteral
-} from "inferred-types/dist/types/index";
-
-type Process<
-  TContent extends string,
-  TStrip extends string
-> = And<[ IsStringLiteral<TContent>, IsStringLiteral<TStrip>]> extends true
-  ? TContent extends `${TStrip & string}${infer After}`
-    ? After
-    : TContent
-  : string;
-
-/**
- * **StripLeading**`<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 = StripLeading<T,U>;
- * ```
- *
- * Note:
- *   - if `T` is a non-string type then no transformation will be done
- *   - same applies to `U`
- */
-export type StripLeading<
-  TContent extends string|number,
-  TStrip extends string|number
-> = TContent extends number
-? AsNumber<
-    Process<
-      `${TContent}`,
-      AsStringUnion<TStrip>
-    >
-  >
-: TContent extends string
-  ? Process<
-    TContent,
-    AsStringUnion<TStrip>
-  >
-  : never

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

@@ -1,34 +0,0 @@
-import { AsNumber, AsStringUnion, IsWideType } from "inferred-types/dist/types/index"
-
-type Process<
-  TContent extends string,
-  TSurround extends string
-> = TContent extends `${TSurround}${infer REMAIN}`
-  ? REMAIN extends `${infer LEADING}${TSurround}`
-    ? LEADING
-    : REMAIN
-  : TContent extends `${infer LEADING}${TSurround}`
-    ? LEADING
-    : TContent;
-
-/**
- * **StripSurround**`<TContent, TSurround>`
- *
- * Strips the content found in `TSurround` from the leading or trailing
- * edge of the content passed in as `TContent`.
- *
- * ```ts
- * // "Hi there"
- * type Hello = StripSurround<"(Hi there)", "(" | ")">;
- * ```
- */
-export type StripSurround<
-  TContent extends string | number,
-  TSurround extends string | number
-> = IsWideType<TContent> extends true
-? TContent
-: TContent extends string
-  ? Process<TContent, AsStringUnion<TSurround>>
-  : AsNumber<
-      Process<`${TContent}`, AsStringUnion<TSurround>>
-    >;

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

@@ -1,51 +0,0 @@
-import type {  And,  IsStringLiteral,  AsNumber } from "inferred-types/dist/types/index";
-
-
-type Process<
-  TContent extends string,
-  TStrip extends string
-> = And<[ IsStringLiteral<TContent>, IsStringLiteral<TStrip>]> extends true
-  ? TContent extends `${infer Before}${TStrip}`
-    ? Before
-    : TContent
-  : string;
-
-/**
- * **StripEnding**`<TContent, TStrip>`
- *
- * Will strip off `TStrip` from the ending of `TContent` when
- * it is found.
- *
- * ```ts
- * type T = "Hello World";
- * type U = " World";
- * // "Hello"re
- * type R = StripEnding<T,U>;
- * ```
- */
-export type StripTrailing<
-  TContent extends string|number,
-  TStrip extends string|number
-> = TContent extends number
-? AsNumber<
-    Process<
-      `${TContent}`,
-      `${TStrip}`
-    > extends `${number}`
-      ? Process<
-          `${TContent}`,
-          `${TStrip}`
-        >
-      : never
-  >
-: TContent extends string
-  ? Process<
-      `${TContent}`,
-      `${TStrip}`
-    > extends string
-      ? Process<
-          `${TContent}`,
-          `${TStrip}`
-        >
-      : never
-  : never;

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

@@ -1,56 +0,0 @@
-import { AfterFirst, First, Shift,Chars } from "inferred-types/dist/types/index";
-
-
-type Process<
-  TChars extends readonly string[],
-  TOp extends "is" | "not",
-  TComparator extends string,
-  TResult extends string
-> = [] extends TChars
-? TResult
-: First<TChars> extends TComparator
-  ? TOp extends "is"
-    ? Process<
-        AfterFirst<TChars>,
-        TOp,
-        TComparator,
-        Shift<TResult> extends string
-          ? Shift<TResult>
-          : ""
-      >
-    : TResult
-  : TOp extends "is"
-    ? TResult
-    : Process<
-        AfterFirst<TChars>,
-        TOp,
-        TComparator,
-        Shift<TResult> extends string
-        ? Shift<TResult>
-        : ""
-      >;
-
-
-/**
- * **StripUntil**`<TContent,TComparator>`
- *
- * Strip characters from the start of `TContent` _until_ a
- * character extends `TComparator`.
- */
-export type StripUntil<
-  TContent extends string,
-  TComparator extends string,
-> = Process<Chars<TContent>,"not",TComparator, TContent>;
-
-
-
-/**
- * **StripWhile**`<TContent,TComparator>`
- *
- * Strip characters from the start of `TContent` _while_ those
- * characters extend `TComparator`.
- */
-export type StripWhile<
-  TContent extends string,
-  TComparator extends string
-> = Process<Chars<TContent>,"is",TComparator, TContent>;

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

@@ -1,52 +0,0 @@
-import type {
-  Filter,
-  IsString ,
-  IsStringLiteral,
-  ScalarNotSymbol,
-  TupleToUnion,
-  ToStringArray
-} from "inferred-types/dist/types/index";
-
-type SuggestString<
-T extends string | number | readonly string[] | readonly number[]
-> = //
-T extends string | number | readonly string[] | readonly number[]
-? T extends readonly string[]
-? TupleToUnion<Filter<T, string, "equals">> | (string & {})
-: T extends readonly number[]
-  ? ToStringArray<T> | (string & {})
-: [IsStringLiteral<T>] extends [true]
-  ? IsString<T> extends true ? T | (string & {}) : `${T & number}` | (string & {})
-  : IsString<T> extends true ? string : `${number}`
-: never;
-
-
-/**
- * **Suggest**`<T>`
- *
- * Type utility that helps to build a enumerated set
- * of string literals which _could_ be the value for
- * a string based property but _allows_ a string that
- * is not part of the suggestion to be typed in too.
- *
- * - `T` can be a _union_ of string literals or an
- * _array_ of string literals.
- * - If T is a wide string then we must return
- * just a wide string as no suggestions are possible
- */
-export type Suggest<
-  T extends ScalarNotSymbol | readonly unknown[]
-> = T extends string | number | readonly string[] | readonly number[]
-? SuggestString<T>
-: never;
-
-/**
- * **SuggestNumeric**`<T>`
- *
- * Type utility that helps to build a enumerated set
- * of numeric literals which _could_ be the value for
- * a number based property but _allows_ a number that
- * is not part of the suggestion to be typed in too.
- */
-export type SuggestNumeric<T extends number> = T | (number & {});
-

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

@@ -1,48 +0,0 @@
-import {  ToStringArray } from "inferred-types/dist/types/index";
-
-type Process<
-  TContent extends string,
-  TPrefix extends string,
-  TPostfix extends string,
-> = `${TPrefix}${TContent}${TPostfix}`
-
-type ProcessEach<
-  TContent extends readonly string[],
-  TPrefix extends string,
-  TPostfix extends string
-> = {
-  [K in keyof TContent]: Process<TContent[K], TPrefix, TPostfix>
-}
-
-/**
- * **Surround**`<TContent,TPrefix,TPostfix>`
- *
- * Receives content -- either a string or an array of strings -- and then
- * proceeds to _surround_ the content with the prefix and postfix content.
- *
- * ```ts
- * // "(hi)"
- * type T1 = Surround<"hi", "(", ")">;
- * // [ "<one>", "<two>" ]
- * type T2 = Surround<["one","two"], "<",">">;
- * ```
- */
-export type Surround<
-  TContent extends string | number | readonly (string| number)[],
-  TPrefix extends string,
-  TPostfix extends string
-> = TContent extends number
-? Surround<`${TContent}`, TPrefix, TPostfix>
-: TContent extends readonly unknown[]
-  ? TContent extends readonly string[]
-    ? ProcessEach<TContent, TPrefix, TPostfix>
-    : ProcessEach<
-        ToStringArray<TContent> extends readonly string[]
-          ? ToStringArray<TContent>
-          : never,
-        TPrefix,
-        TPostfix
-      >
-  : TContent extends string
-    ? Process<TContent, TPrefix, TPostfix>
-    : never;