inferred-types 0.51.0 → 0.51.1

package/src/types/literals/Choices.ts

@@ -0,0 +1,251 @@
+/* eslint-disable no-use-before-define */
+import {
+  Dictionary,
+  If,
+  IsTrue,
+  HandleDoneFn,
+  AfterFirst,
+  First,
+  ExpandRecursively,
+  ShapeCallback,
+  AsString,
+  EmptyObject,
+  Scalar,
+  MergeObjects,
+  As,
+} from "inferred-types/dist/types/index";
+
+
+/**
+ * **createChoice**(name, [value])
+ *
+ * Creates a "choice" for a Choice API. Values may be:
+ *
+ * - any `Scalar` value
+ * - a callback of the form `s => s.literal(42)`
+ * - or if left _undefined_ the value will be set to the name
+ */
+export type CreateChoice = <
+  TName extends string,
+  TValue extends ChoiceValue
+>(name: TName, value?: TValue) => Choice;
+
+export type ChoiceCallback = (cb: CreateChoice) => Choice;
+
+
+export type Choice<
+  K extends string = string,
+  V = unknown
+> = { name: K; value: V };
+
+export type ChoiceValue = ShapeCallback | Scalar | Dictionary | undefined;
+
+/**
+ * **AsChoice**
+ *
+ * Converts a name/value pairing from createChoice() into a Choice.
+ */
+export type AsChoice<
+  TName extends string = string,
+  TValue extends ChoiceValue = ChoiceValue
+> = [TValue] extends [ShapeCallback]
+? {name: TName; value: HandleDoneFn<ReturnType<TValue>>}
+: [TValue] extends [Scalar | Dictionary]
+  ? {name: TName; value: TValue }
+  : {name: TName; value: TName};
+
+type ProcessChoices<
+  T extends string | [string, Scalar] | Choice | ChoiceCallback
+> = T extends string
+? Choice<T,T>
+: T extends [string, Scalar]
+? Choice<T[0],T[1]>
+: T extends Choice
+? T
+: T extends ChoiceCallback
+? ReturnType<ChoiceCallback>
+: never;
+
+export type ToChoices<
+  T extends readonly (string | [string, Scalar] | Choice | ChoiceCallback)[]
+> = {
+  [K in keyof T]: ProcessChoices<T[K]>
+}
+
+export type ChoiceApiOptions = {
+  /**
+   * A choice may only be chosen once
+   */
+  unique: boolean;
+  max: number | null;
+  /**
+   * the API style as it's presented after configuration
+   */
+  style: "fn" | "object";
+}
+
+export type ChoiceApi<
+  _TChoices extends readonly Choice[],
+  _TOptions extends ChoiceApiOptions
+> = EmptyObject;
+
+
+export type ChoiceApiConfig<
+  TChoices extends readonly Choice[],
+  TOptions extends ChoiceApiOptions
+> = {
+  done: () => ChoiceApi<TChoices, TOptions>;
+  allowChoicesToBeUsedOnlyOnce: () => ChoiceApiConfig<
+    TChoices,
+    As<MergeObjects<TOptions, {unique: true}>, ChoiceApiOptions>
+  >;
+  /**
+   * configured choices can be _reused_ multiple times
+   */
+  allowChoicesToBeUsedMultipleTimes: () => ChoiceApiConfig<
+    TChoices,
+    As<MergeObjects<TOptions, {unique: false}>, ChoiceApiOptions>
+  >;
+  setStyle: <TStyle extends "fn" | "object">(style: TStyle) => ChoiceApiConfig<
+    TChoices,
+    As<MergeObjects<TOptions, {style: TStyle}>, ChoiceApiOptions>
+  >;
+  /**
+   * set a maximum number of choices that should be allowed
+   */
+  maximumChoices: <TMax extends number>(max: TMax) => ChoiceApiConfig<
+    TChoices,
+    As<MergeObjects<TOptions, {max: TMax}>, ChoiceApiOptions>
+  >;
+}
+
+
+
+// /**
+//  * **Choice**`<T>`
+//  *
+//  * Type utility which receives one of many _choice representations_
+//  * (from `ChoiceRepresentation`) and converts it into a simple key/value pair.
+//  */
+// export type Choice<
+//   T extends ChoiceRepresentation = ChoiceRepresentation
+// > = T extends {name: string; type: Fn}
+//   ? ReturnType<T["type"]> extends { done: Fn }
+//       ? Record<
+//           T["name"],
+//           ReturnType<ReturnType<T["type"]>["done"]>
+//         >
+//       : Record<T["name"], ReturnType<T["type"]>>
+
+//   : T extends {name: string; value: unknown}
+//     ? Record<T["name"], T["value"]>
+//   : T extends string
+//     ? Record<T,T>
+//   : T extends [name: string, value: unknown]
+//     ? If<
+//         IsFunction<T[1]>,
+//         Record<T[0], ReturnType<AsFunction<T[1]>>>,
+//         Record<T[0], T[1]>
+//       >
+//     : never;
+
+
+// type ToLookup<
+// TInput extends readonly (ChoiceRepresentation|AsChoice)[],
+// TOutput extends {[key:string]: unknown} = NonNullable<unknown>
+// > = [] extends TInput
+// ? ExpandRecursively<TOutput>
+// : ToLookup<
+//     AfterFirst<TInput>,
+//     First<TInput> extends ChoiceRepresentation
+//       ? AsChoice<First<TInput>> & TOutput
+//       : First<TInput> extends Record<string, unknown>
+//         ? First<TInput> & TOutput
+//         : never
+//   >
+
+// /**
+//  *  **Choices**`<TInput>`
+//  *
+//  * Converts an tuple of `ChoiceRepresentation` elements into a lookup table
+//  * of name/values.
+//  */
+// export type AsChoices<
+//   TInput extends readonly (ChoiceRepresentation|AsChoice)[] = readonly ChoiceRepresentation[],
+// > = ToLookup<TInput>;
+
+export type MultipleChoice<
+  TChoices extends Dictionary<string> = Dictionary<string>,
+  TForceUnique extends boolean = boolean,
+  TState extends readonly unknown[] = [],
+  TExclude extends string = never
+> = {
+  selected: TState;
+  forceUnique: TForceUnique;
+  choices: TChoices;
+  <T extends string & Exclude<keyof TChoices, TExclude>>(s: T ):
+    MultipleChoice<
+      TChoices,
+      TForceUnique,
+      [
+        ...TState,
+        T extends keyof TChoices
+          ? TChoices[T]
+          : never
+      ],
+      AsString<If<
+        IsTrue<TForceUnique>,
+        TExclude | T,
+        TExclude
+      >>
+    >;
+  /** return the selected choices */
+  done: () => TState;
+};
+
+/**
+ * **MultiChoiceCallback**`<TApi>`
+ *
+ * Provides the typing so that you can easily incorporate a "choice"
+ * as a parameter to your functions.
+ *
+ * It is intended to be used with the runtime utility `handleDoneFn()`
+ * so that if a user doesn't terminate their callback with a call to
+ * `.done()` then this is done for them.
+ */
+export type MultiChoiceCallback<TApi extends MultipleChoice> = <
+  CB extends ((c: TApi) => unknown)
+>(cb: CB) =>  HandleDoneFn<ReturnType<CB>>;
+
+
+type MergeKVs<
+  TInput extends readonly Dictionary[],
+  TOutput extends Dictionary = EmptyObject
+> = [] extends TInput
+  ? ExpandRecursively<TOutput>
+: MergeKVs<
+    AfterFirst<TInput>,
+    First<TInput> extends keyof TOutput
+    ? TOutput
+    : TOutput & First<TInput>
+  >;
+
+/**
+ * **ChoiceBuilder**
+ *
+ * Builds a Choice API surface:
+ */
+export type ChoiceBuilder= <
+  TChoices extends readonly Choice[]
+>(...choices: TChoices) => ({
+  chooseMany: <
+    TForce extends boolean
+  >(force: TForce) =>
+  MultipleChoice<
+     MergeKVs<TChoices> extends Dictionary<string>
+     ? MergeKVs<TChoices>
+     : never,
+    TForce
+  >;
+});
+

package/src/types/literals/Color.ts

@@ -0,0 +1,54 @@
+
+// https://www.w3schools.com/colors/colors_groups.asp
+
+import { HexadecimalChar } from "inferred-types/dist/types/index";
+
+export type NamedColor_Pink = "Pink" | "LightPink" | "HotPink" | "DeepPink" | "PaleVioletRed" | "MediumVioletRed";
+export type NamedColor_Purple = "Lavender" | "Thistle" | "Plum" | "Orchid" | "Violet" | "Fuchsia" | "Magenta" | "MediumOrchid" | "DarkOrchid" | "DarkViolet" | "BlueViolet" | "DarkMagenta" | "Purple" | "MediumPurple" | "MediumSlateBlue" | "SlateBlue" | "DarkSlateBlue" | "RebeccaPurple" | "Indigo";
+export type NamedColor_Red = "LightSalmon" | "Salmon" | "DarkSalmon" | "LightCoral" | "IndianRed" | "Crimson" | "Red" | "FireBrick" | "DarkRed" | "Maroon";
+export type NamedColor_Orange = "Orange" | "DarkOrange" | "Coral" | "Tomato" | "OrangeRed";
+export type NamedColor_Yellow = "Gold" | "Yellow" | "LightYellow" | "LemonChiffon" | "LightGoldenRodYellow" | "PapayaWhip" | "Moccasin" | "PeachPuff" | "PaleGoldenRod" | "Khaki" | "DarkKhaki";
+export type NamedColor_Green = "GreenYellow" | "Chartreuse" | "LawnGreen" | "Lime" | "LimeGreen" | "PaleGreen" | "LightGreen" | "MediumSpringGreen" | "SpringGreen" | "MediumSpringGreen" | "SeaGreen" | "ForestGreen" | "Green" | "DarkGreen" | "YellowGreen" | "OliveDrab" | "DarkOliveGreen" | "MediumOliveGreen" | "MediumAquaMarine" | "DarkSeeGreen" | "LightSeaGreen" | "DarkCyan" | "Teal";
+export type NamedColor_Cyan = "Aqua" | "Cyan" | "LightCyan" | "PaleTurquoise" | "Aquamarine" | "Turquoise" | "MediumTurquoise" | "DarkTurquoise";
+export type NamedColor_Blue = "CadetBlue" | "SteelBlue" | "LightSteelBlue" | "LightBlue" | "PowerBlue" | "LightSkyBlue" | "SkyBlue" | "CornflowerBlue" | "DeepSkyBlue" | "DodgerBlue" | "RoyalBlue" | "Blue" | "MediumBlue" | "DarkBlue" | "MidnightBlue";
+export type NamedColor_Brown = "Cornsilk" | "BlanchedAlmond" | "Bisque" | "NavajoWhite" | "White" | "BurlyWood" | "Tan" | "RosyBrown" | "SandyBrown" | "GoldenRod" | "DarkGoldenRod" | "Peru" | "Chocolate" | "Olive" | "SaddleBrown" | "Sienna" | "Brown";
+export type NamedColor_White = "White" | "Snow" | "HoneyDew" | "MintCream" | "Azure" | "AliceBlue" | "GhostWhite" | "WhiteSmoke" | "SeaShell" | "Beige" | "OldLace" | "FloralWhite" | "Ivory" | "AntiqueWhite" | "Linen" | "LavenderBlush" | "MintyRose";
+export type NamedColor_Gray = "Gainsboro" | "LightGray" | "Silver" | "DarkGray" | "DimGray" | "Gray" | `LightSlateGray` | "SlateGray" | "DarkSlateGray" | "Black";
+
+/**
+ * **NamedColor**
+ *
+ * Most if not all CSS/HTML _named_ colors
+ */
+export type NamedColor = NamedColor_Gray | NamedColor_White | NamedColor_Brown | NamedColor_Blue | NamedColor_Cyan | NamedColor_Green | NamedColor_Yellow | NamedColor_Orange | NamedColor_Red | NamedColor_Purple | NamedColor_Pink;
+
+/**
+ * **NamedColorMinimal**
+ *
+ * A minimal set of _named_ colors recognized by CSS and HTML.
+ */
+export type NamedColorMinimal = "Gray" | "SlateGray" | "DarkSlateGray" | "Black" | "White" | "AliceBlue" | "WhiteSmoke" | "GhostWhite" | "Brown" | "Tan" | "Cornsilk" | "Blue" | "CadetBlue" | "SteelBlue" | "PowerBlue" | "DodgerBlue" | "DarkBlue" | "Cyan" | "Turquoise" | "Aquamarine" | "Teal" | "Gold" | "Yellow" | "LightYellow" | "Moccasin" | "Orange" | "DarkOrange" | "Tomato" | "Salmon" | "Red" | "FireBrick" | "DarkRed" | "Maroon" | "Plum" | "Violet" | "Purple" | "SlateBlue" | "DarkSlateBlue" | "Indigo";
+
+/**
+ * **HexColor**
+ *
+ * A color value based in hexadecimal format
+ */
+export type HexColor = `#${HexadecimalChar}${HexadecimalChar}${string}`;
+
+
+/**
+ * **RgbColor**
+ *
+ * Type to enforce an `rgb()` color definition
+ */
+export type RgbColor = `rgb(${string},${string},${string})`;
+
+
+/**
+ * **RgbaColor**
+ *
+ * Type to enforce an `rgba()` color definition
+ */
+export type RgbaColor = `rgba(${string},${string},${string},${string})`;
+

package/src/types/literals/ContainerBlockKey.ts

@@ -0,0 +1,22 @@
+import { Container,  Tuple } from "inferred-types/dist/types/index";
+
+
+/**
+ * **ContainerBlockKey**`<TContainer,TKey>`
+ *
+ * Returns the `TContainer` value intersected with a guarantee that the
+ * `TKey` key value exists.
+ * ```ts
+ * // { foo: 1; bar: unknown }
+ * type TO = ContainerBlockKey<{foo: 1}, "bar">;
+ * // number[] & readonly [unknown,unknown,unknown]
+ * type TA = ContainerBlockKey<number[], 2>;
+ * ```
+ */
+export type ContainerBlockKey<
+  TContainer extends Container,
+  TKey extends PropertyKey
+> = TContainer extends Tuple
+  ? TContainer & [...Tuple<unknown, TKey & number>, never]
+  : Exclude<TContainer, TKey>;
+

package/src/types/literals/ContainerKeyGuarantee.ts

@@ -0,0 +1,26 @@
+import { Container, ExpandRecursively,  Tuple } from "inferred-types/dist/types/index";
+
+
+/**
+ * **ContainerKeyGuarantee**`<TContainer,TKey,[TType]>`
+ *
+ * Returns the `TContainer` value intersected with a guarantee that the
+ * `TKey` key value exists.
+ * ```ts
+ * // { foo: 1; bar: unknown }
+ * type TO = ContainerKeyGuarantee<{foo: 1}, "bar">;
+ * // number[] & readonly [unknown,unknown,unknown]
+ * type TA = ContainerKeyGuarantee<number[], 2>;
+ * ```
+ *
+ * - by default the guarantee is provided by assigning the `unknown`
+ * type but you can override this by setting `TType`
+ */
+export type ContainerKeyGuarantee<
+  TContainer extends Container,
+  TKey extends PropertyKey,
+  TType = unknown
+> = TContainer extends Tuple
+  ? TContainer & Readonly<[...Tuple<unknown, TKey & number>, TType]>
+  : ExpandRecursively<TContainer & Record<TKey, TType>>;
+

package/src/types/literals/DoneFnTuple.ts

@@ -0,0 +1,31 @@
+import { IsTrue, If, FnWithDescription, FnDefn, TupleToUnion, Narrow} from "inferred-types/dist/types/index";
+
+
+/**
+ * **DoneFnTuple**`<[TTuple],[TMakeUnion],[TFns]>`
+ *
+ * This type utility quickly builds the types you'll need for an
+ * API surface with the `done()` command returning the stored state
+ * as either a **Tuple** or a **Union** of the tuple state.
+ *
+ * **Related:** `HasDoneFn`, `Narrow`, `DoneFnKv`, `createDoneTupleFn`
+ */
+export type DoneFnTuple<
+TFns extends {[key: string]: FnDefn} = {
+  add: [
+    <TAdd extends Narrow>(a: TAdd) => boolean,
+    "add a value to the tuple/union"
+  ];
+},
+TMakeUnion extends boolean = false,
+TState extends readonly Narrow[] = Narrow[],
+> = {
+  [K in keyof TFns]: FnWithDescription<TFns[K]>
+} & {
+  state: TState;
+  type_as_union: TMakeUnion;
+  done: FnWithDescription<[
+    () => If<IsTrue<TMakeUnion>, TupleToUnion<TState>, TState>,
+    "exits the API surface with the state which has been accumulated so far"
+  ]>;
+}

package/src/types/literals/ExpandRecursively.ts

@@ -0,0 +1,68 @@
+/* eslint-disable no-use-before-define */
+import { AfterFirst, AnyFunction, AsLiteralFn, AsNarrowingFn, Decrement, Dictionary, First, FnProps, IsNarrowingFn, IsUnion, Tuple, TupleToUnion, TypedFunction, UnionToTuple } from "inferred-types/dist/types/index";
+
+type _ExpandTuple<
+  TLength extends number,
+  TContent extends Tuple,
+  TTuple extends Tuple = []
+> = TLength extends 0
+  ? Readonly<TTuple>
+  : _ExpandTuple<
+      Decrement<TLength>,
+      AfterFirst<TContent>,
+      [...TTuple, First<TContent>]
+  >;
+
+type ExpandParameters<
+  TFn extends TypedFunction,
+  TParams extends readonly unknown[],
+  TResults extends readonly unknown[] = []
+> = [] extends TParams
+? IsNarrowingFn<TFn> extends true
+  ? AsNarrowingFn<TResults,ReturnType<TFn>,ExpandDictionary<FnProps<TFn>>>
+  : AsLiteralFn<TResults,ReturnType<TFn>,ExpandDictionary<FnProps<TFn>>>
+: ExpandParameters<
+    TFn,
+    AfterFirst<TParams>,
+    [
+      ...TResults,
+      First<TParams> extends Dictionary
+        ? ExpandDictionary<First<TParams>>
+        : First<TParams>
+    ]
+  >;
+
+export type ExpandTuple<T> = T extends Tuple
+? _ExpandTuple<T["length"],T>
+: T;
+
+export type ExpandUnion<T> = IsUnion<T> extends true
+? TupleToUnion<
+    ExpandTuple<UnionToTuple<T>>
+  >
+: T
+;
+
+/**
+ * Recursively goes over an object based structure and tries to reduce
+ * it down to just a simple key/value type.
+ */
+export type ExpandRecursively<T> = T extends Dictionary
+  ? { [K in keyof T]: T[K] extends AnyFunction
+      ? T[K] extends TypedFunction
+        ? ExpandParameters<T[K], Parameters<T[K]>>
+        : T[K]
+      : ExpandRecursively<T[K]>
+    }
+  : T;
+
+/**
+ * Recursively goes over an object based structure and tries to reduce
+ * it down to just a simple key/value type.
+ */
+export type ExpandDictionary<T> = T extends Dictionary
+  ? { [K in keyof T]: T[K] extends AnyFunction
+      ? T[K]
+      : ExpandRecursively<T[K]>
+    }
+  : T;

package/src/types/literals/FromDefn.ts

@@ -0,0 +1,151 @@
+import { Constant } from "inferred-types/dist/constants/index";
+import { EmptyObject,
+  Dictionary,
+  ObjectKey,
+  Tuple,
+  IsEqual,
+  Contains,
+  Keys,
+  Values,
+  HandleDoneFn,
+  AfterFirst,
+  First,
+  AsDictionary,
+  TupleToUnion,
+  ExpandDictionary,
+  NarrowableScalar,
+  ShapeCallback,
+  UnionElDefn,
+  SimpleToken,
+  AsType
+ } from "inferred-types/dist/types/index";
+
+type HandleObject<
+  TObj extends Dictionary,
+  TKeys extends readonly unknown[],
+  TResult extends Dictionary = EmptyObject
+> = [] extends TKeys
+? ExpandDictionary<TResult>
+: HandleObject<
+    TObj,
+    AfterFirst<TKeys>,
+    First<TKeys> extends keyof TObj
+      ? TObj[First<TKeys>] extends ShapeCallback
+        ? Record<
+            First<TKeys>,
+            HandleDoneFn<ReturnType< TObj[First<TKeys>] >>
+          > & TResult
+        : TObj[First<TKeys>] extends SimpleToken
+          ? Record<
+            First<TKeys>,
+            AsType<TObj[First<TKeys>]>
+          > & TResult
+          : Record<
+              First<TKeys>,
+              TObj[First<TKeys>]
+            > & TResult
+      : never
+  >;
+
+
+type ProcessUnion<
+  T extends UnionElDefn
+> = T extends Tuple
+    ? TupleToUnion<T>
+    : T extends ShapeCallback
+      ? HandleDoneFn<ReturnType<T>>
+        : never;
+type IterateUnion<T extends readonly UnionElDefn[]> = {
+  [K in keyof T]: ProcessUnion<T[K]>
+}
+
+/**
+ * **AsUnion**
+ *
+ * Receives a `UnionTokenSet`, a `ShapeCallback` or just a tuple of values
+ * and makes this into _union type_.
+ */
+export type AsUnion<T extends UnionElDefn | readonly [UnionElDefn, ...UnionElDefn[]]> = T extends UnionElDefn[]
+? TupleToUnion<IterateUnion<T>>
+: T extends UnionElDefn
+? ProcessUnion<T>
+: never;
+
+export type IsDictionaryDefinition<T> = T extends Dictionary
+? Contains<Values<T>, ShapeCallback>
+: false;
+
+/**
+ * converts non-tuple definition types to actual type
+ */
+type ToType<
+  T,
+  TElse
+> = [T] extends [ShapeCallback]
+  ? HandleDoneFn<ReturnType<T>>
+: [IsDictionaryDefinition<T>] extends [true]
+  ? HandleObject<AsDictionary<T>, Keys<AsDictionary<T>>>
+: T extends SimpleToken
+  ? AsType<T>
+: IsEqual<TElse, Constant<"not-set">> extends true
+  ? T
+  : TElse extends SimpleToken
+    ? AsType<TElse>
+    : TElse;
+
+
+
+/**
+ * iterates over tuple definition types to convert into real types
+ */
+type IterateOverDefinitions<
+  T extends readonly unknown[],
+  TElse
+> = {
+  [K in keyof T]: ToType<T[K], TElse>;
+}
+
+export type TypeDefinition = NarrowableScalar | ShapeCallback;
+
+
+/**
+ * **DictShapeDefn**`<T>`
+ *
+ * A _dictionary_ shape which provides direct value input or use of
+ * the `ShapeCallback` API to any of the dictionaries values.
+ *
+ * Use of the generic `T` is not required but adding it as a separate
+ * generic will increase the narrowness of your types.
+ */
+export type DictTypeDefinition<
+  V extends TypeDefinition = TypeDefinition
+> = Record<
+  ObjectKey,
+  V
+>;
+
+
+/**
+ * **FromDefn**`<T, [TElse]>`
+ *
+ * Takes either a singular `T` or a tuple of values for `T` and
+ * looks for any cases where a `ShapeCallback` is found:
+ *
+ * - where it is found, it will resolve the type
+ * - if the type is a `SimpleToken` then this too is resolved
+ * - in other cases it simply proxies the values through
+ * - if `TElse` is set you can redirect values which don't use
+ * the ShapeCallback API to a specific type.
+ *
+ * Note: when dictionary objects are found the _values_ will be
+ * interrogated for ShapeCallback's.
+ */
+export type FromDefn<
+  T,
+  TElse = Constant<"not-set">
+> = T extends readonly unknown[]
+? IterateOverDefinitions<T,TElse>
+: ToType<T,TElse>;
+
+
+

package/src/types/literals/FromTokenNames.ts

@@ -0,0 +1,81 @@
+import { ObjectKey } from "../base-types/ObjectKey";
+import { IsNever } from "../boolean-logic/operators/IsNever";
+
+export type WideTokenNames = "string" 
+| "number" 
+| "boolean" 
+| "null" 
+| "undefined" 
+| "never" 
+| "unknown" 
+| "string[]" 
+| "number[]" 
+| "boolean[]" 
+| "unknown[]";
+
+
+export type ConvertWideTokenNames<T extends WideTokenNames> = T extends "string"
+? string
+: T extends "number"
+? number
+: T extends "boolean"
+? boolean
+: T extends "null"
+? null
+: T extends "undefined"
+? undefined
+: T extends "never"
+? never
+: T extends "unknown"
+? unknown
+: T extends "string[]"
+? string[]
+: T extends "number[]"
+? number[]
+: T extends "boolean[]"
+? boolean[]
+: T extends "unknown[]"
+? unknown[]
+: never;
+
+
+export type WideContainerNames = "object"
+| "Dictionary"
+| "Map"
+| "Set"
+| "WeakMap";
+
+type ConvertWideContainerNames<T extends WideContainerNames> = T extends "object"
+? object
+: T extends "Dictionary"
+? Record<ObjectKey,unknown>
+: T extends "Map"
+? Map<unknown,unknown>
+: T extends "Set"
+? Set<unknown>
+: T extends "WeakMap"
+? WeakMap<object, unknown>
+: never;
+
+/**
+ * **FromWideTokens**`<T, [TElse]>`
+ * 
+ * Looks for `WideContainerNames` or `WideTokenNames` and converts them to
+ * the type they describe. If it is `T` is not any of these tokens it is
+ * simply proxied through.
+ * 
+ * If you'd prefer to setup a different type for when no token is matched
+ * you can add it under `TElse`.
+ */
+export type FromWideTokens<
+  T,
+  TElse = never
+> = T extends WideTokenNames | WideContainerNames
+? T extends WideTokenNames
+  ? ConvertWideTokenNames<T>
+  : T extends WideContainerNames
+  ? ConvertWideContainerNames<T>
+  : never
+: IsNever<TElse> extends true
+  ? T
+  : TElse

package/src/types/literals/Narrow.ts

@@ -0,0 +1,10 @@
+import { Narrowable } from "./Narrowable";
+
+/**
+ * **Narrow**
+ * 
+ * Just like the `Narrowable` type, this type is used in the _extends_
+ * clause during runtime to extract the narrowest types possible. Unlike
+ * the `Narrowable` type, **Narrow** _excludes_ **symbols**.
+ */
+export type Narrow = Exclude<Narrowable, symbol>;