inferred-types 0.51.1 → 0.51.2

package/src/types/runtime-types/TypeToken.ts

@@ -1,384 +0,0 @@
-import {
-  Split,
-  AfterFirst,
-  First,
-  AsNumber,
-  AnyFunction,
-  Dictionary,
-  IsNever,
-  Throw,
-  Contains,
-  If,
-} from "inferred-types/dist/types/index";
-import type {
-  TT_Atomics,
-  TT_Containers,
-  TT_Functions,
-  TT_SEP,
-  TT_START,
-  TT_STOP,
-  TT_Singletons,
-  TT_Sets,
-  SIMPLE_SCALAR_TOKENS,
-  SIMPLE_UNION_TOKENS,
-  SIMPLE_OPT_SCALAR_TOKENS,
-  SIMPLE_DICT_TOKENS,
-  SIMPLE_ARRAY_TOKENS,
-  SIMPLE_MAP_TOKENS,
-  SIMPLE_SET_TOKENS
-} from "inferred-types/dist/constants/index";
-
-
-/**
- * **SimpleToken**
- *
- * An enumeration of string values which point to _types_ in the
- * the type system.
- *
- * **Related:**
- * - `SimpleScalarToken`, `SimpleContainerToken`, `SimpleUnionToken`,
- * - `TypeToken`
- */
-export type SimpleToken =
-| SimpleScalarToken
-| SimpleArrayToken
-| SimpleDictToken
-| SimpleMapToken
-| SimpleSetToken
-| SimpleUnionToken;
-
-/**
- * the _optional_ variants of the `SimpleScalarToken` type
- */
-export type OptionalSimpleScalarTokens = typeof SIMPLE_OPT_SCALAR_TOKENS[number];
-
-/**
- * the _required_ variants of the `SimpleScalarToken` type
- */
-export type RequiredSimpleScalarTokens = typeof SIMPLE_SCALAR_TOKENS[number];
-
-/**
- * **SimpleScalarToken**
- *
- * A subset of the `SimpleToken` which may be more useful for building
- * simple string literal values.
- *
- * **Note:** this includes both `RequiredSimpleScalarTokens` and `OptionalSimpleScalarTokens`.
- */
-export type SimpleScalarToken =
-| RequiredSimpleScalarTokens
-| OptionalSimpleScalarTokens;
-
-
-
-/**
- * **SimpleUnionToken**
- *
- * A subset of `SimpleToken` which represents union types.
- */
-export type SimpleUnionToken = typeof SIMPLE_UNION_TOKENS[number];
-
-/**
- * **BaseTypeToken**
- *
- * A very simple structure for `TypeTokens` to fit into.
- *
- * Use this type if you need to preserve type simplicity, otherwise
- * prefer `TypeToken` (or subsets like `AtomicToken`, `SingletonToken`, etc.)
- */
-export type BaseTypeToken = `${TypeTokenStart}${string}${TypeTokenStop}`
-
-/**
- * a subset of `SimpleContainerToken`
- */
-export type SimpleDictToken = typeof SIMPLE_DICT_TOKENS[number];
-
-/**
- * a subset of `SimpleContainerToken`
- */
-export type SimpleArrayToken = typeof SIMPLE_ARRAY_TOKENS[number];
-
-/**
- * a subset of `SimpleContainerToken`
- */
-export type SimpleMapToken = typeof SIMPLE_MAP_TOKENS[number];
-
-/**
- * a subset of `SimpleContainerToken`
- */
-export type SimpleSetToken = typeof SIMPLE_SET_TOKENS[number];
-
-/**
- * **SimpleContainerToken**
- *
- * A subset of `SimpleToken` which provides shortcut's for expressing
- * _container_ types via a simple token.
- */
-export type SimpleContainerToken =
-| SimpleDictToken
-| SimpleArrayToken
-| SimpleMapToken
-| SimpleArrayToken;
-
-
-/**
- * TypeTokenAtomics
- *
- * The token names which are considered "atomic"
- */
-export type TypeTokenAtomics = typeof TT_Atomics[number];
-
-/**
- * **AtomicToken**
- *
- * A fully formed `TypeToken` of the "atomic" type.
- */
-export type AtomicToken = `<<${TypeTokenAtomics}>>`
-
-// type KvToken = `{ "key": "${string}", "value": ${SimpleToken} }`
-
-export type TypeTokenContainers = typeof TT_Containers[number];
-
-export type ContainerToken = `<<${TypeTokenContainers}${string}>>`
-
-// TODO
-export type UnionToken<_TEls extends readonly unknown[] = unknown[]> = `<<union::[ ${string} ]>>`
-
-/**
- * **UnionSetToken**
- *
- * - static `<<union-set::`, then
- * - set _name_ `${string}`, then
- * - static `::[ `, then
- * - set _parameters_ `${string}`, then
- * - static ` ]>>`
- */
-export type UnionSetToken = `<<union-set::${string}::[ ${string} ]>>`
-
-export type ObjectToken = `<<obj::{ ${string} }>>`;
-export type TupleToken = `<<tuple::[ ${string} ]>>`;
-export type ArrayToken = `<<arr::${BaseTypeToken}>>`;
-export type RecordToken = `<<rec::${BaseTypeToken}::${BaseTypeToken}>>`
-
-export type SetToken = `<<set::${BaseTypeToken}>>`
-export type MapToken = `<<map::${BaseTypeToken}::${BaseTypeToken}>>`
-export type WeakMapToken = `<<weak::${BaseTypeToken}::${BaseTypeToken}>>`
-
-export type FnToken = `<<fn::${string}::${BaseTypeToken}>>`
-export type GeneratorToken = `<<gen::${string}::${BaseTypeToken}>>`
-
-
-
-export type TypeTokenFunctions = typeof TT_Functions[number];
-export type TypeTokenSingletons = typeof TT_Singletons[number];
-
-/**
- * **SingletonToken**
- *
- * Shapes:
- * - Wide: `<<string>>` or `<<number>>`
- * - Literal: `<<string::{string}>` or `<number::{number}>`
- * - Union Literal: `<<string::{UnionToken}>>`
- * - Sets: `<<string-set::[set]::[...params]>`
- */
-export type SingletonToken =
-| `<<${TypeTokenSingletons}>>`
-| `<<${TypeTokenSingletons}::${string}>>`
-| `<<${TypeTokenSingletons}::${UnionToken}>>`
-| `<<string-set::${string}::[${string}]>>`
-| `<<number-set::${string}::[${string}]>>`;
-
-
-export type TypeTokenSets = typeof TT_Sets[number];
-
-/**
- * **TypeTokenKind**
- *
- * The full set of _type token_ kinds (aka, the first and
- * identifying part of the string token after the initial
- * token identifier)
- */
-export type TypeTokenKind =
-  | TypeTokenAtomics
-  | TypeTokenContainers
-  | TypeTokenFunctions
-  | TypeTokenSets
-  | TypeTokenSingletons;
-
-
-/**
- * string which indicates the start of a `TypeToken`
- */
-export type TypeTokenStart = typeof TT_START;
-/**
- * string which indicates the end of a `TypeToken`
- */
-export type TypeTokenStop = typeof TT_STOP;
-
-export type TypeTokenSeparator = typeof TT_SEP;
-
-/**
- * **TypeToken**
- *
- *
- */
-export type TypeToken<
-  T extends TypeTokenKind = TypeTokenKind
-> =`${TypeTokenStart}${T}${"" | `::${string}`}${TypeTokenStop}`;
-
-type Parse<T extends TypeToken> = T extends `${TypeTokenStart}${infer Data}${TypeTokenStop}`
-? If<
-    Contains<Data, TypeTokenSeparator>,
-    Split<Data, TypeTokenSeparator>,
-    [ Data ]
-  >
-: never;
-
-type Kind<T extends TypeToken> = Parse<T>[0] extends TypeTokenKind
-  ? Parse<T>[0]
-  : never;
-
-type Data<T extends TypeToken> = AfterFirst<Parse<T>>;
-
-type Categories = "atomics" | "containers" | "functions" | "singletons";
-
-type Category<T extends TypeToken> = Kind<T> extends TypeTokenAtomics
-  ? "atomics"
-  : Kind<T> extends TypeTokenContainers
-  ? "containers"
-  : Kind<T> extends TypeTokenFunctions
-  ? "functions"
-  : Kind<T> extends TypeTokenSingletons
-  ? "singletons"
-  : never;
-
-type GetAtomic<T extends TypeTokenKind> = T extends "undefined"
-? undefined
-: T extends "null"
-? null
-: T extends [boolean, "true"]
-? true
-: T extends [boolean, "false"]
-? false
-: never;
-
-type GetSingleton<T extends TypeTokenKind, D extends readonly string[]> =
-  T extends "string"
-    ? D["length"] extends 0
-      ? string
-      : First<D> extends string
-        ? [string, First<D>]
-        : never
-  : T extends "number"
-    ? D["length"] extends 0
-      ? number
-      : First<D> extends `${number}`
-        ? [number, AsNumber<First<D>>]
-        : never
-  : never;
-
-type GetFunction<T extends TypeTokenKind, _D extends readonly string[]> =
-  T extends "fn"
-  ? AnyFunction
-  : T extends "gen"
-  ? Generator
-  : never;
-
-type GetContainer<
-  T extends TypeTokenKind,
-  _D extends readonly string[]
-> = T extends "obj"
-? Dictionary
-: T extends "arr"
-? unknown[]
-: T extends "set"
-? Set<unknown>
-: T extends "map"
-? Map<unknown,unknown>
-: T extends "weak"
-? WeakMap<object, unknown>
-: never;
-
-type Type<
-  TCat extends Categories,
-  TKind extends TypeTokenKind,
-  TData extends readonly string[]
-> = TCat extends "atomics" ? GetAtomic<TKind>
-: TCat extends "singletons" ? GetSingleton<TKind, TData>
-: TCat extends "functions" ? GetFunction<TKind, TData>
-: TCat extends "containers" ? GetContainer<TKind, TData>
-: never;
-
-
-
-type TypeHelper<
-  T
-> = IsNever<T> extends true
-? {baseType: never}
-: T extends readonly [infer First, infer Second]
-  ? { baseType: First; literalType: Second }
-  : { baseType: T }
-
-
-/**
- * **ParseToken**`<T>`
- *
- * Attempts to parses the passed in string in `T` as a
- * `TypeToken` and if successful returns meta characteristics:
- *
- * - `token` - the raw token in `T`
- * - `kind` - the specific _kind_ of token; which uniquely identifies the token
- * - `category` - the category of token (e.g., atomic, singleton, etc.)
- * - `baseType` - the broad / base type of the token
- * - _`literal`_ - where appropriate, the _literal_ type of the token
- *
- * **Notes:**
- * - deeper type analysis must be done at runtime.
- * - if `T` is not a valid token then an `ErrorCondition<"invalid-token">`
- * will be raised.
- */
-export type ParseToken<T extends string> = T extends TypeToken
-? {
-    /** the raw token text */
-    token: T;
-    /** the _kind_ or _token name_ for this type */
-    kind: Kind<T>;
-    /** the category of type this is (atomics, singleton, etc.) */
-    category: Category<T>;
-    /** data/config parameters available for this token */
-    data: Data<T>;
-  } & TypeHelper<Type<Category<T>, Kind<T>, Data<T>>>
-: Throw<
-    "invalid-token",
-    `Call to ParseToken<T> with an invalid token: ${T}`,
-    "ParseToken",
-    {library: "inferred-types"}
-  >
-
-/**
- * **TokenKind**`<T>`
- *
- * Reveals the _kind_ of a given `TypeToken`
- */
-export type TokenKind<T extends TypeToken> = Kind<T>;
-
-/**
- * **TokenBaseType**`<T>`
- *
- * Reveals the _base_ type of a given `TypeToken`
- */
-export type TokenBaseType<T extends TypeToken> = ParseToken<T>["baseType"];
-
-
-export type TokenLiteralType<T extends TypeToken> = "literal" extends keyof ParseToken<T>
-? ParseToken<T>["literal"]
-: never;
-
-
-export type IsTypeToken<T> = T extends string
-  ? T extends TypeToken
-    ? true
-    : false
-  : false;
-
-

package/src/types/runtime-types/TypeTuple.ts

@@ -1,22 +0,0 @@
-import { Narrowable , TypeGuard } from "inferred-types/dist/types/index";
-
-/**
- * **TypeTuple**`<TType>`
- *
- * The Tuple containing:
- *  - a type _representation_
- *  - a type guard to validate
- *  - (optionally) a textual description of the type
- *
- * This provides a simple shorthand way of defining a type in a way
- * which can be used in the tooling for `Type` and `TypeDefn` but does
- * not represent a full-fledged `Type<T>`.
- */
-export type TypeTuple<
-  TType extends Narrowable = Narrowable,
-  TDesc extends string = string
-> = [
-  type: TType,
-  guard: TypeGuard<TType>,
-  desc: TDesc
-];

package/src/types/runtime-types/index.ts

@@ -1,12 +0,0 @@
-
-export * from "./Type";
-export * from "./TypeOf";
-export * from "./StringLiteralToken";
-export * from "./FromLiteralTokens";
-export * from "./TokenizeStringLiteral";
-export * from "./TypeToken";
-export * from "./TypeTuple";
-export * from "./Dict";
-export * from "./SimpleType";
-export * from "./AsType";
-export * from "./Shape";

package/src/types/sets/IntersectingKeys.ts

@@ -1,17 +0,0 @@
-import { AsRecord, Container, UnionToTuple } from "inferred-types/dist/types/index";
-
-
-/**
- * **IntersectingKeys**`<A,B>`
- *
- * Provides a tuple of keys which are shared between the two
- * containers passed in `A` and `B`.
- */
-export type IntersectingKeys<
-  L extends Container | object,
-  R extends Container | object,
-> = UnionToTuple<
-  (keyof AsRecord<L>) & (keyof AsRecord<R>)
->;
-
-

package/src/types/sets/Intersection.ts

@@ -1,151 +0,0 @@
-import type {
-  GetEach,
-  IsNull,
-  Container,
-  RemoveNever,
-  Contains,
-  If,
-  RemoveMarked,
-  NarrowlyContains,
-  Throw,
-} from "inferred-types/dist/types/index";
-import  { MARKED } from "inferred-types/dist/constants/index";
-
-type Marked = typeof MARKED;
-
-type _NoDeref<
-  A extends readonly unknown[],
-  B extends readonly unknown[],
-> = RemoveNever<{
-  [K in keyof A]: If<
-    Contains<B, A[K]>,
-    A[K],
-    never
-  >
-}>;
-
-type DerefNoReport<
-  AValues extends readonly unknown[],
-  BValues extends readonly unknown[],
-> = RemoveNever<{
-  [K in keyof AValues]: If<
-    Contains<BValues, AValues[K]>,
-    AValues[K],
-    never
-  >
-}>;
-
-type DerefWithReport<
-  A extends readonly Container[],
-  B extends readonly Container[],
-  TKeys extends readonly PropertyKey[],
-  TDeref
-> = [
-  // left
-  RemoveMarked<{
-    [K in keyof A]: TDeref extends keyof A[K]
-    ? If<
-        NarrowlyContains<TKeys, A[K][TDeref]>,
-        A[K],
-        Marked
-      >
-    : never
-  }>,
-  // right
-  RemoveMarked<{
-    [K in keyof B]: TDeref extends keyof B[K]
-    ? If<
-        NarrowlyContains<TKeys, B[K][TDeref]>,
-        B[K],
-        Marked
-      >
-    : Marked
-  }>
-];
-
-
-type _WithDeref<
-  A extends readonly Container[],
-  B extends readonly Container[],
-  AValues extends readonly unknown[],
-  BValues extends readonly unknown[],
-  TDeref extends string,
-  TReport extends boolean
-> = TReport extends false
-? DerefNoReport<AValues,BValues>
-: DerefNoReport<AValues,BValues> extends readonly PropertyKey[]
-  ? DerefWithReport<A,B,DerefNoReport<AValues,BValues>, TDeref>
-  : never;
-
-
-type HandleDeref<
-  A extends readonly unknown[],
-  B extends readonly unknown[],
-  TDeref extends string,
-  TReport extends boolean = false
-> =
-A extends readonly Container[]
-? B extends readonly Container[]
-  ? GetEach<A, TDeref> extends readonly unknown[]
-    ? GetEach<B, TDeref> extends readonly unknown[]
-      ? _WithDeref<
-          A,
-          B,
-          GetEach<A, TDeref>,
-          GetEach<B, TDeref>,
-          TDeref,
-          TReport
-        >
-      : never
-    : never
-  : Throw<
-      "invalid-container-tuple",
-      "In Intersection<A,B> the B set was not Container[] tuple!",
-      "Intersection",
-      { ctx: {a: A; b: B} }
-    >
-: Throw<
-    "invalid-container-tuple",
-    "In Intersection<A,B> the A set was not Container[] tuple!",
-    "Intersection",
-    { ctx: {a: A; b: B} }
-  >;
-
-/**
-  * **Intersection**`<A,B, [TDeref]>`
-  *
-  * Takes two tuple sets `A` and `B` and returns each of their _value intersections_.
-  *
-  * - this behavior is modified when the `deref` property is provided
-  *   - the expectation now is that both A and B contain _containers_ and their
-  * "value" is based on the offset provided by `TDref`
-  *   - in this mode, all _scalar_ values in `A` or `B` will be ignored
-  *   - the `TReport` property is by default set to _false_ but if changed to
-  * _true_ then this changes the reporting structure to:
-  * ```ts
-  * [A: values[], B: values[]]
-  * ```
-  * where the left side contains all containers -- in their entirety -- which
-  * intersect based on the `TDeref` property values.
-  *
-  * **Related:** `Unique`, `IntersectingKeys`
-  */
-export type Intersection<
-  A extends readonly unknown[],
-  B extends readonly unknown[],
-  TDeref extends string | null = null,
-  TReport extends boolean = false
-> = If<
-  IsNull<TDeref>,
-  // no dereferencing
-  _NoDeref<A,B>,
-  // dereference the array elements
-  TDeref extends PropertyKey
-    ? HandleDeref<A,B,TDeref,TReport>
-    : Throw<
-        "invalid-deref",
-        "The TDeref property was set but must be extended from a PropertyKey!",
-        "Intersection",
-        { index: TDeref  }
-      >
->;

package/src/types/sets/Relate.ts

@@ -1,20 +0,0 @@
-import { Container,  IntersectingKeys, LeftRight, Length, UniqueKeys } from "inferred-types/dist/types/index";
-
-/**
- * **Relate**`<L,R>`
- *
- * Provides the relationship between two sets:
- *
- * - **sameLength**: boolean flag
- * - **sharedKeys**: the shared keys between the two sets
- * - **uniqueKeys**: the unique keys _per_ list in a `LeftRight` struct.
- */
-export type Relate<
-  L extends Container,
-  R extends Container
-> = {
-  length: LeftRight<Length<L>,Length<R>>;
-  sharedKeys: IntersectingKeys<L,R>;
-  uniqueKeys: UniqueKeys<L,R>;
-};
-

package/src/types/sets/SetCandidate.ts

@@ -1,9 +0,0 @@
-import { Narrowable } from "inferred-types/dist/types/index";
-
-/**
- * **SetCandidate**
- *
- * A _set candidate_ is the base type for a type which can be converted
- * into a "set" (and have set operations applied).
- */
-export type SetCandidate = readonly unknown[] | Narrowable;

package/src/types/sets/Unique.ts

@@ -1,87 +0,0 @@
-import {
-  AfterFirst,
-  First,
-  IfNever,
-  Contains,
-  Push,
-  Container,
-  Not,
-  GetEach,
-  IsScalar,
-  TupleToUnion,
-  UnionToTuple,
-  AsString,
-  IsNever,
-  As,
-} from "inferred-types/dist/types/index";
-
-type Get<
-  TValue,
-  TDeref extends PropertyKey | never,
-> = IfNever<
-  TDeref,
-  TValue, // just proxy value back
-  TDeref extends keyof TValue
-    ? TValue[TDeref]
-    : TValue extends Container
-      ? never
-      : TValue
->
-
-type Process<
-  TValues extends readonly unknown[],
-  TDeref extends string |number | never,
-  TResults extends readonly unknown[] = []
-> = [] extends TValues
-? TResults
-: Process<
-    AfterFirst<TValues>,
-    TDeref,
-    // push new value into TResults if unique
-    Push<
-      TResults,
-      First<TResults>,
-      IsScalar<First<TValues>> extends true
-        // a scalar value should/can ignore the deref setting
-        ? Not<Contains<TResults, First<TValues>>>
-        // a non-scalar must consider deref setting
-        : Not<Contains<
-          As<
-            IsNever<TDeref> extends true
-              ? TResults
-              : GetEach<TResults, AsString<TDeref>>,
-            string | number | readonly unknown[]
-          >,
-          Get<First<TValues>,TDeref>
-        >>
-      >
->;
-
-/**
- * **Unique**`<TList, [TDeref]>`
- *
- * Given a tuple of values, this utility will reduce the tuple to
- * _unique_ values in the set.
- *
- * - If the values are containers themselves, you can provide a `TDeref`
- * to point to a property which represents the "identity" of that container
- * - If you're comparing containers _without_ a `TDeref` property
- * then the full type signature will be used in deduplication
- *
- * ```ts
- * // ["foo", "bar"]
- * type FooBar = Unique<["foo","foo","bar"]>;
- * ```
- */
-export type Unique<
-  TList extends readonly unknown[],
-  TDeref extends string | number | never = never
-> = IfNever<
-  TDeref,
-  UnionToTuple<TupleToUnion<TList>>,
-
-  Process<
-    TList,
-    TDeref
-  >
->