inferred-types 0.37.6 → 0.40.1

package/dist/constants/src/constants/TypeComparisons.d.ts

@@ -0,0 +1,230 @@
+/**
+ * **TYPE_COMPARISONS**
+ *
+ * A dictionary of all _comparison_ operations along with their `RefType`, description,
+ * and `Params`.
+ */
+export declare const TYPE_COMPARISONS: {
+    readonly Extends: [unknown, "extends the type", [(t: {
+        readonly boolean: () => boolean;
+        readonly string: () => string;
+        readonly number: () => number;
+        readonly symbol: () => symbol;
+        readonly null: () => null;
+        readonly function: () => (...args: unknown[]) => unknown;
+        readonly tuple: () => readonly unknown[];
+        readonly singularTuple: () => [readonly unknown[]];
+        readonly object: () => Record<never, unknown> | Record<string | symbol, unknown>;
+        readonly emptyObject: () => Record<never, unknown>;
+        readonly undefined: () => undefined;
+        readonly unknown: () => unknown;
+        readonly nothing: () => null | undefined;
+        readonly something: () => {};
+    }) => unknown]];
+    readonly NotExtends: [unknown, "does not extent the type", [(t: {
+        readonly boolean: () => boolean;
+        readonly string: () => string;
+        readonly number: () => number;
+        readonly symbol: () => symbol;
+        readonly null: () => null;
+        readonly function: () => (...args: unknown[]) => unknown;
+        readonly tuple: () => readonly unknown[];
+        readonly singularTuple: () => [readonly unknown[]];
+        readonly object: () => Record<never, unknown> | Record<string | symbol, unknown>;
+        readonly emptyObject: () => Record<never, unknown>;
+        readonly undefined: () => undefined;
+        readonly unknown: () => unknown;
+        readonly nothing: () => null | undefined;
+        readonly something: () => {};
+    }) => unknown]];
+    readonly Equals: [unknown, "equals the type", [(t: {
+        readonly boolean: () => boolean;
+        readonly string: () => string;
+        readonly number: () => number;
+        readonly symbol: () => symbol;
+        readonly null: () => null;
+        readonly function: () => (...args: unknown[]) => unknown;
+        readonly tuple: () => readonly unknown[];
+        readonly singularTuple: () => [readonly unknown[]];
+        readonly object: () => Record<never, unknown> | Record<string | symbol, unknown>;
+        readonly emptyObject: () => Record<never, unknown>;
+        readonly undefined: () => undefined;
+        readonly unknown: () => unknown;
+        readonly nothing: () => null | undefined;
+        readonly something: () => {};
+    }) => unknown]];
+    readonly NotEqual: [unknown, "does not equal the type", [(t: {
+        readonly boolean: () => boolean;
+        readonly string: () => string;
+        readonly number: () => number;
+        readonly symbol: () => symbol;
+        readonly null: () => null;
+        readonly function: () => (...args: unknown[]) => unknown;
+        readonly tuple: () => readonly unknown[];
+        readonly singularTuple: () => [readonly unknown[]];
+        readonly object: () => Record<never, unknown> | Record<string | symbol, unknown>;
+        readonly emptyObject: () => Record<never, unknown>;
+        readonly undefined: () => undefined;
+        readonly unknown: () => unknown;
+        readonly nothing: () => null | undefined;
+        readonly something: () => {};
+    }) => unknown]];
+    readonly Truthy: [unknown, "must be a truthy value", []];
+    readonly Falsy: [unknown, "must be a falsy value", []];
+    readonly IsSomething: [unknown, "must be 'something' (aka, not null or undefined)", []];
+    readonly IsNothing: [unknown, "must be 'nothing' (aka, null or undefined)", []];
+    readonly IsString: [string, "must extend a string type", []];
+    readonly IsNumber: [number, "must extend a number type", []];
+    readonly IsBoolean: [boolean, "must extend a boolean type", []];
+    readonly GreaterThan: [number, "must be a numeric literal greater than [[0]]", [(t: {
+        readonly boolean: () => boolean;
+        readonly string: () => string;
+        readonly number: () => number;
+        readonly symbol: () => symbol;
+        readonly null: () => null;
+        readonly function: () => (...args: unknown[]) => unknown;
+        readonly tuple: () => readonly unknown[];
+        readonly singularTuple: () => [readonly unknown[]];
+        readonly object: () => Record<never, unknown> | Record<string | symbol, unknown>;
+        readonly emptyObject: () => Record<never, unknown>;
+        readonly undefined: () => undefined;
+        readonly unknown: () => unknown;
+        readonly nothing: () => null | undefined;
+        readonly something: () => {};
+    }) => number]];
+    readonly LessThan: [number, "must be a numeric literal less than [[0]]", [(t: {
+        readonly boolean: () => boolean;
+        readonly string: () => string;
+        readonly number: () => number;
+        readonly symbol: () => symbol;
+        readonly null: () => null;
+        readonly function: () => (...args: unknown[]) => unknown;
+        readonly tuple: () => readonly unknown[];
+        readonly singularTuple: () => [readonly unknown[]];
+        readonly object: () => Record<never, unknown> | Record<string | symbol, unknown>;
+        readonly emptyObject: () => Record<never, unknown>;
+        readonly undefined: () => undefined;
+        readonly unknown: () => unknown;
+        readonly nothing: () => null | undefined;
+        readonly something: () => {};
+    }) => number]];
+    readonly StartsWith: [string, "must be a string literal that starts with '[[0]]'", [(t: {
+        readonly boolean: () => boolean;
+        readonly string: () => string;
+        readonly number: () => number;
+        readonly symbol: () => symbol;
+        readonly null: () => null;
+        readonly function: () => (...args: unknown[]) => unknown;
+        readonly tuple: () => readonly unknown[];
+        readonly singularTuple: () => [readonly unknown[]];
+        readonly object: () => Record<never, unknown> | Record<string | symbol, unknown>;
+        readonly emptyObject: () => Record<never, unknown>;
+        readonly undefined: () => undefined;
+        readonly unknown: () => unknown;
+        readonly nothing: () => null | undefined;
+        readonly something: () => {};
+    }) => string]];
+    readonly EndsWith: [string, "must be a string literal that ends with '[[0]]'", [(t: {
+        readonly boolean: () => boolean;
+        readonly string: () => string;
+        readonly number: () => number;
+        readonly symbol: () => symbol;
+        readonly null: () => null;
+        readonly function: () => (...args: unknown[]) => unknown;
+        readonly tuple: () => readonly unknown[];
+        readonly singularTuple: () => [readonly unknown[]];
+        readonly object: () => Record<never, unknown> | Record<string | symbol, unknown>;
+        readonly emptyObject: () => Record<never, unknown>;
+        readonly undefined: () => undefined;
+        readonly unknown: () => unknown;
+        readonly nothing: () => null | undefined;
+        readonly something: () => {};
+    }) => string]];
+    readonly Includes: [string, "must be a string literal that includes the substring '[[0]]'", [(t: {
+        readonly boolean: () => boolean;
+        readonly string: () => string;
+        readonly number: () => number;
+        readonly symbol: () => symbol;
+        readonly null: () => null;
+        readonly function: () => (...args: unknown[]) => unknown;
+        readonly tuple: () => readonly unknown[];
+        readonly singularTuple: () => [readonly unknown[]];
+        readonly object: () => Record<never, unknown> | Record<string | symbol, unknown>;
+        readonly emptyObject: () => Record<never, unknown>;
+        readonly undefined: () => undefined;
+        readonly unknown: () => unknown;
+        readonly nothing: () => null | undefined;
+        readonly something: () => {};
+    }) => string]];
+    readonly ReturnsSomething: [(...args: unknown[]) => unknown, "must be a function which returns 'something' (aka, not null or undefined)", []];
+    readonly ReturnsNothing: [(...args: unknown[]) => unknown, "must be a function which returns 'nothing' (aka, null or undefined)", []];
+    readonly ReturnsTrue: [(...args: unknown[]) => unknown, "must be a function which returns 'true'", []];
+    readonly ReturnsFalse: [(...args: unknown[]) => unknown, "must be a function which returns 'false'", []];
+    readonly ReturnsTruthy: [(...args: unknown[]) => unknown, "must be a function which returns a 'truthy' value", []];
+    readonly ReturnsFalsy: [(...args: unknown[]) => unknown, "must be a function which returns a 'falsy' value", []];
+    readonly ReturnsExtends: [unknown, "must be a function which returns a value which extends [[0]]", [(t: {
+        readonly boolean: () => boolean;
+        readonly string: () => string;
+        readonly number: () => number;
+        readonly symbol: () => symbol;
+        readonly null: () => null;
+        readonly function: () => (...args: unknown[]) => unknown;
+        readonly tuple: () => readonly unknown[];
+        readonly singularTuple: () => [readonly unknown[]];
+        readonly object: () => Record<never, unknown> | Record<string | symbol, unknown>;
+        readonly emptyObject: () => Record<never, unknown>;
+        readonly undefined: () => undefined;
+        readonly unknown: () => unknown;
+        readonly nothing: () => null | undefined;
+        readonly something: () => {};
+    }) => unknown]];
+    readonly ReturnsEquals: [unknown, "must be a function which returns a value which equals [[0]]", [(t: {
+        readonly boolean: () => boolean;
+        readonly string: () => string;
+        readonly number: () => number;
+        readonly symbol: () => symbol;
+        readonly null: () => null;
+        readonly function: () => (...args: unknown[]) => unknown;
+        readonly tuple: () => readonly unknown[];
+        readonly singularTuple: () => [readonly unknown[]];
+        readonly object: () => Record<never, unknown> | Record<string | symbol, unknown>;
+        readonly emptyObject: () => Record<never, unknown>;
+        readonly undefined: () => undefined;
+        readonly unknown: () => unknown;
+        readonly nothing: () => null | undefined;
+        readonly something: () => {};
+    }) => unknown]];
+    readonly Contains: [readonly unknown[], "must be a tuple and have elements that extends the value [[0]]", [(t: {
+        readonly boolean: () => boolean;
+        readonly string: () => string;
+        readonly number: () => number;
+        readonly symbol: () => symbol;
+        readonly null: () => null;
+        readonly function: () => (...args: unknown[]) => unknown;
+        readonly tuple: () => readonly unknown[];
+        readonly singularTuple: () => [readonly unknown[]];
+        readonly object: () => Record<never, unknown> | Record<string | symbol, unknown>;
+        readonly emptyObject: () => Record<never, unknown>;
+        readonly undefined: () => undefined;
+        readonly unknown: () => unknown;
+        readonly nothing: () => null | undefined;
+        readonly something: () => {};
+    }) => unknown]];
+    readonly ContainsSome: [readonly unknown[], "must be a tuple and have elements that extends the value [[0]]", [(t: {
+        readonly boolean: () => boolean;
+        readonly string: () => string;
+        readonly number: () => number;
+        readonly symbol: () => symbol;
+        readonly null: () => null;
+        readonly function: () => (...args: unknown[]) => unknown;
+        readonly tuple: () => readonly unknown[];
+        readonly singularTuple: () => [readonly unknown[]];
+        readonly object: () => Record<never, unknown> | Record<string | symbol, unknown>;
+        readonly emptyObject: () => Record<never, unknown>;
+        readonly undefined: () => undefined;
+        readonly unknown: () => unknown;
+        readonly nothing: () => null | undefined;
+        readonly something: () => {};
+    }) => [readonly unknown[]]]];
+};
+//# sourceMappingURL=TypeComparisons.d.ts.map

package/dist/constants/src/constants/TypeComparisons.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypeComparisons.d.ts","sourceRoot":"","sources":["../../../../src/constants/TypeComparisons.ts"],"names":[],"mappings":"AAuBA;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCnB,CAAC"}

package/dist/constants/src/constants/TypeComparisons.js

@@ -0,0 +1,47 @@
+import { WideAssignment } from "./Wide";
+const wide = WideAssignment;
+const entry = (refType, desc, ...params) => [
+    refType(wide),
+    desc,
+    params.map(i => typeof (i) === "function"
+        ? i(wide)
+        : i),
+];
+/**
+ * **TYPE_COMPARISONS**
+ *
+ * A dictionary of all _comparison_ operations along with their `RefType`, description,
+ * and `Params`.
+ */
+export const TYPE_COMPARISONS = {
+    "Extends": entry(t => t.unknown(), "extends the type", t => t.unknown()),
+    "NotExtends": entry(t => t.unknown(), "does not extent the type", t => t.unknown()),
+    "Equals": entry(t => t.unknown(), "equals the type", t => t.unknown()),
+    "NotEqual": entry(t => t.unknown(), "does not equal the type", t => t.unknown()),
+    "Truthy": entry(t => t.unknown(), "must be a truthy value"),
+    "Falsy": entry(t => t.unknown(), "must be a falsy value"),
+    "IsSomething": entry(t => t.unknown(), "must be 'something' (aka, not null or undefined)"),
+    "IsNothing": entry(t => t.unknown(), "must be 'nothing' (aka, null or undefined)"),
+    "IsString": entry(t => t.string(), "must extend a string type"),
+    "IsNumber": entry(t => t.number(), "must extend a number type"),
+    "IsBoolean": entry(t => t.boolean(), "must extend a boolean type"),
+    // numeric
+    "GreaterThan": entry(t => t.number(), "must be a numeric literal greater than [[0]]", t => t.number()),
+    "LessThan": entry(t => t.number(), "must be a numeric literal less than [[0]]", t => t.number()),
+    // string
+    "StartsWith": entry(t => t.string(), "must be a string literal that starts with '[[0]]'", t => t.string()),
+    "EndsWith": entry(t => t.string(), "must be a string literal that ends with '[[0]]'", t => t.string()),
+    "Includes": entry(t => t.string(), "must be a string literal that includes the substring '[[0]]'", t => t.string()),
+    // function
+    "ReturnsSomething": entry(t => t.function(), "must be a function which returns 'something' (aka, not null or undefined)"),
+    "ReturnsNothing": entry(t => t.function(), "must be a function which returns 'nothing' (aka, null or undefined)"),
+    "ReturnsTrue": entry(t => t.function(), "must be a function which returns 'true'"),
+    "ReturnsFalse": entry(t => t.function(), "must be a function which returns 'false'"),
+    "ReturnsTruthy": entry(t => t.function(), "must be a function which returns a 'truthy' value"),
+    "ReturnsFalsy": entry(t => t.function(), "must be a function which returns a 'falsy' value"),
+    "ReturnsExtends": entry(t => t.unknown(), "must be a function which returns a value which extends [[0]]", t => t.unknown()),
+    "ReturnsEquals": entry(t => t.unknown(), "must be a function which returns a value which equals [[0]]", t => t.unknown()),
+    "Contains": entry(t => t.tuple(), "must be a tuple and have elements that extends the value [[0]]", t => t.unknown()),
+    // TODO: get the below working`
+    "ContainsSome": entry(t => t.tuple(), "must be a tuple and have elements that extends the value [[0]]", t => t.singularTuple()),
+};

package/dist/constants/src/constants/TypeOf.d.ts

@@ -0,0 +1,7 @@
+/**
+ * **TYPE_OF**
+ *
+ * The set of values which are possible results of the `typeof` command in Javascript.
+ */
+export declare const TYPE_OF: readonly ["string", "number", "boolean", "undefined", "symbol", "bigint", "function", "object"];
+//# sourceMappingURL=TypeOf.d.ts.map

package/dist/constants/src/constants/TypeOf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypeOf.d.ts","sourceRoot":"","sources":["../../../../src/constants/TypeOf.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,OAAO,iGAAkG,CAAC"}

package/dist/constants/src/constants/TypeOf.js

@@ -0,0 +1,6 @@
+/**
+ * **TYPE_OF**
+ *
+ * The set of values which are possible results of the `typeof` command in Javascript.
+ */
+export const TYPE_OF = ["string", "number", "boolean", "undefined", "symbol", "bigint", "function", "object"];

package/dist/constants/src/constants/TypeTokens.d.ts

@@ -0,0 +1,24 @@
+/**
+ * `TypeToken` names whose name provides the full definition
+ * for the type.
+ */
+export declare const TYPE_TOKEN_IDENTITIES: readonly ["string", "number", "numericString", "booleanString", "null", "undefined", "boolean", "true", "false", "space", "whitespace", "object", "emptyObject", "function", "array"];
+/**
+ * `TypeToken` names which need a _string_ parameter to fully qualify
+ */
+export declare const TYPE_TOKEN_PARAM_STR: readonly ["explicitClass", "startsWith", "endsWith", "ensureLeading", "stripLeading", "ensureTrailing", "stripTrailing", "camelCase", "pascalCase", "snakeCase", "kebabCase", "explicitType"];
+/**
+ * `TypeToken` names which need a _CSV_ parameter to fully qualify
+ */
+export declare const TYPE_TOKEN_PARAM_CSV: readonly ["stringLiteral", "numericLiteral", "objectLiteral", "tuple", "union"];
+/**
+ * `TypeToken` names which need a _datetime_ parameter to fully qualify
+ */
+export declare const TYPE_TOKEN_PARAM_DATETIME: readonly ["datetime"];
+/**
+ * `TypeToken` names which need a _datetime_ parameter to fully qualify
+ */
+export declare const TYPE_TOKEN_PARAM_DATE: readonly ["ymd", "monthThenDate", "dateThenMonth"];
+export declare const TYPE_TOKEN_PARAM_TIME: readonly ["timeInMinutes", "timeInSeconds", "militaryTimeInMinutes", "militaryTimeInSeconds", "militaryTimeInMilliseconds", "civilianTimeInMinutes"];
+export declare const TYPE_TOKEN_ALL: readonly ["string", "number", "numericString", "booleanString", "null", "undefined", "boolean", "true", "false", "space", "whitespace", "object", "emptyObject", "function", "array", "stringLiteral", "numericLiteral", "objectLiteral", "tuple", "union", "ymd", "monthThenDate", "dateThenMonth", "datetime", "explicitClass", "startsWith", "endsWith", "ensureLeading", "stripLeading", "ensureTrailing", "stripTrailing", "camelCase", "pascalCase", "snakeCase", "kebabCase", "explicitType", "timeInMinutes", "timeInSeconds", "militaryTimeInMinutes", "militaryTimeInSeconds", "militaryTimeInMilliseconds", "civilianTimeInMinutes"];
+//# sourceMappingURL=TypeTokens.d.ts.map

package/dist/constants/src/constants/TypeTokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypeTokens.d.ts","sourceRoot":"","sources":["../../../../src/constants/TypeTokens.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,qBAAqB,uLAgBxB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,oBAAoB,+LAavB,CAAC;AAGX;;GAEG;AACH,eAAO,MAAM,oBAAoB,iFAMvB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,yBAAyB,uBAE5B,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,qBAAqB,oDAIxB,CAAC;AAEX,eAAO,MAAM,qBAAqB,sJAOxB,CAAC;AAEX,eAAO,MAAM,cAAc,inBAOjB,CAAC"}

package/dist/constants/src/constants/TypeTokens.js

@@ -0,0 +1,78 @@
+/**
+ * `TypeToken` names whose name provides the full definition
+ * for the type.
+ */
+export const TYPE_TOKEN_IDENTITIES = [
+    "string",
+    "number",
+    "numericString",
+    "booleanString",
+    "null",
+    "undefined",
+    "boolean",
+    "true",
+    "false",
+    "space",
+    "whitespace",
+    "object",
+    "emptyObject",
+    "function",
+    "array"
+];
+/**
+ * `TypeToken` names which need a _string_ parameter to fully qualify
+ */
+export const TYPE_TOKEN_PARAM_STR = [
+    "explicitClass",
+    "startsWith",
+    "endsWith",
+    "ensureLeading",
+    "stripLeading",
+    "ensureTrailing",
+    "stripTrailing",
+    "camelCase",
+    "pascalCase",
+    "snakeCase",
+    "kebabCase",
+    "explicitType"
+];
+/**
+ * `TypeToken` names which need a _CSV_ parameter to fully qualify
+ */
+export const TYPE_TOKEN_PARAM_CSV = [
+    "stringLiteral",
+    "numericLiteral",
+    "objectLiteral",
+    "tuple",
+    "union"
+];
+/**
+ * `TypeToken` names which need a _datetime_ parameter to fully qualify
+ */
+export const TYPE_TOKEN_PARAM_DATETIME = [
+    "datetime",
+];
+/**
+ * `TypeToken` names which need a _datetime_ parameter to fully qualify
+ */
+export const TYPE_TOKEN_PARAM_DATE = [
+    "ymd",
+    "monthThenDate",
+    "dateThenMonth"
+];
+export const TYPE_TOKEN_PARAM_TIME = [
+    "timeInMinutes",
+    "timeInSeconds",
+    "militaryTimeInMinutes",
+    "militaryTimeInSeconds",
+    "militaryTimeInMilliseconds",
+    "civilianTimeInMinutes"
+];
+export const TYPE_TOKEN_ALL = [
+    ...TYPE_TOKEN_IDENTITIES,
+    ...TYPE_TOKEN_PARAM_CSV,
+    ...TYPE_TOKEN_PARAM_DATE,
+    ...TYPE_TOKEN_PARAM_DATETIME,
+    ...TYPE_TOKEN_PARAM_STR,
+    ...TYPE_TOKEN_PARAM_TIME
+];

package/dist/constants/src/constants/TypeTransforms.d.ts

@@ -0,0 +1,38 @@
+/**
+ * **TYPE_TRANSFORMS**
+ *
+ * A lookup table keyed with the available conversions `ConversionOp` and where
+ * each row provides:
+ *
+ * 1. Reference Type
+ * 2. Parameters
+ * 3. Description
+ */
+export declare const TYPE_TRANSFORMS: {
+    readonly Identity: readonly [unknown, readonly [], "a transform which returns the same value passed in"];
+    readonly ToNever: readonly [unknown, readonly [], "converts all incoming types to the Never type"];
+    readonly ToString: readonly [unknown, readonly [], "ensures that any incoming type is converted to a string variant of that value"];
+    readonly ToBoolean: readonly [unknown, readonly [], "uses Javascript's \"truthiness\" to convert inputs to a boolean value; with functions it will use the return type"];
+    readonly Trim: readonly [string, readonly [], "Trims whitespace from start and end of string"];
+    readonly TrimStart: readonly [string, readonly [], "Trims whitespace from start of string"];
+    readonly TrimEnd: readonly [string, readonly [], "Trims whitespace from end of string"];
+    readonly Capitalize: readonly [string, readonly [], "Converts a string input to a capitalized variant"];
+    readonly UnCapitalize: readonly [string, readonly [], "Converts a string input to a un-capitalized variant"];
+    readonly AllCaps: readonly [string, readonly [], "Converts a string input to all uppercase characters"];
+    readonly Lowercase: readonly [string, readonly [], "Converts a string input to all lowercase characters"];
+    readonly ToCamelCase: readonly [string, readonly [], "Converts a string to use the camelCase naming convention"];
+    readonly ToKebabCase: readonly [string, readonly [], "Converts a string to use the kebab-case naming convention"];
+    readonly ToPascalCase: readonly [string, readonly [], "Converts a string to use the PascalCase naming convention"];
+    readonly ToSnakeCase: readonly [string, readonly [], "Converts a string to use the snake_case naming convention"];
+    readonly StripLeading: readonly [string, readonly [string], "Strips a string literal from the beginning of a string (if it exists)"];
+    readonly StripTrailing: readonly [string, readonly [string], "Strips a string literal from the end of a string (if it exists)"];
+    readonly EnsureLeading: readonly [string, readonly [string], "Ensures a string literal is at the beginning of a string (with no change if it already was)"];
+    readonly EnsureTrailing: readonly [string, readonly [string], "Ensures a string literal is at the end of a string (with no change if it already was)"];
+    readonly ToPlural: readonly [string, readonly [], "Pluralizes a word"];
+    readonly Surround: readonly [string, readonly [string, string], "Surrounds a string literal with a pre and post character or set of characters"];
+    readonly Prepend: readonly [string | readonly unknown[], readonly [unknown], "Takes a string or tuple and prepends a value to the start."];
+    readonly Append: readonly [string | readonly unknown[], readonly [unknown], "Takes a string or tuple and appends a value to the end."];
+    readonly Increment: readonly [number, readonly [], "Increments a numeric value by one"];
+    readonly Decrement: readonly [number, readonly [], "Decrements a numeric value by one"];
+};
+//# sourceMappingURL=TypeTransforms.d.ts.map

package/dist/constants/src/constants/TypeTransforms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypeTransforms.d.ts","sourceRoot":"","sources":["../../../../src/constants/TypeTransforms.ts"],"names":[],"mappings":"AAOA;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BlB,CAAC"}

package/dist/constants/src/constants/TypeTransforms.js

@@ -0,0 +1,42 @@
+const t_unknown = "<<unknown>>";
+const t_string = "<<string>>";
+const t_number = "<<number>>";
+const t_union_string_tuple = "<<union:string,tuple>>";
+// const t_numeric_array = "<<numeric-array>>" as unknown as readonly (number | `${number}`)[];
+/**
+ * **TYPE_TRANSFORMS**
+ *
+ * A lookup table keyed with the available conversions `ConversionOp` and where
+ * each row provides:
+ *
+ * 1. Reference Type
+ * 2. Parameters
+ * 3. Description
+ */
+export const TYPE_TRANSFORMS = {
+    Identity: [t_unknown, [], "a transform which returns the same value passed in"],
+    ToNever: [t_unknown, [], "converts all incoming types to the Never type"],
+    ToString: [t_unknown, [], "ensures that any incoming type is converted to a string variant of that value"],
+    ToBoolean: [t_unknown, [], "uses Javascript's \"truthiness\" to convert inputs to a boolean value; with functions it will use the return type"],
+    Trim: [t_string, [], "Trims whitespace from start and end of string"],
+    TrimStart: [t_string, [], "Trims whitespace from start of string"],
+    TrimEnd: [t_string, [], "Trims whitespace from end of string"],
+    Capitalize: [t_string, [], "Converts a string input to a capitalized variant"],
+    UnCapitalize: [t_string, [], "Converts a string input to a un-capitalized variant"],
+    AllCaps: [t_string, [], "Converts a string input to all uppercase characters"],
+    Lowercase: [t_string, [], "Converts a string input to all lowercase characters"],
+    ToCamelCase: [t_string, [], "Converts a string to use the camelCase naming convention"],
+    ToKebabCase: [t_string, [], "Converts a string to use the kebab-case naming convention"],
+    ToPascalCase: [t_string, [], "Converts a string to use the PascalCase naming convention"],
+    ToSnakeCase: [t_string, [], "Converts a string to use the snake_case naming convention"],
+    StripLeading: [t_string, [t_string], "Strips a string literal from the beginning of a string (if it exists)"],
+    StripTrailing: [t_string, [t_string], "Strips a string literal from the end of a string (if it exists)"],
+    EnsureLeading: [t_string, [t_string], "Ensures a string literal is at the beginning of a string (with no change if it already was)"],
+    EnsureTrailing: [t_string, [t_string], "Ensures a string literal is at the end of a string (with no change if it already was)"],
+    ToPlural: [t_string, [], "Pluralizes a word"],
+    Surround: [t_string, [t_string, t_string], "Surrounds a string literal with a pre and post character or set of characters"],
+    Prepend: [t_union_string_tuple, [t_unknown], "Takes a string or tuple and prepends a value to the start."],
+    Append: [t_union_string_tuple, [t_unknown], "Takes a string or tuple and appends a value to the end."],
+    Increment: [t_number, [], "Increments a numeric value by one"],
+    Decrement: [t_number, [], "Decrements a numeric value by one"],
+}; // satisfies Record<TransformOp, 

package/dist/constants/src/constants/Types.d.ts

@@ -0,0 +1,10 @@
+export declare const FALSY_TYPE_KINDS: readonly ["undefined", "null"];
+export declare const LITERAL_TYPE_KINDS: readonly ["true", "false", "stringLiteral", "numericLiteral"];
+export declare const WIDE_TYPE_KINDS: readonly ["string", "number", "boolean"];
+export declare const NARROW_CONTAINER_TYPE_KINDS: readonly ["object", "explicitFunctions", "fnType", "fnWithDict", "tuple", "union", "intersection", "arrayOf"];
+export declare const WIDE_CONTAINER_TYPE_KINDS: readonly ["anyArray", "anyObject", "unknownObject", "anyFunction", "emptyObject"];
+/**
+ * A full list of the _types_ of types we have within the `Type` namespace.
+ */
+export declare const TYPE_KINDS: readonly ["undefined", "null", "string", "number", "boolean", "true", "false", "stringLiteral", "numericLiteral", "object", "explicitFunctions", "fnType", "fnWithDict", "tuple", "union", "intersection", "arrayOf", "anyArray", "anyObject", "unknownObject", "anyFunction", "emptyObject"];
+//# sourceMappingURL=Types.d.ts.map

package/dist/constants/src/constants/Types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Types.d.ts","sourceRoot":"","sources":["../../../../src/constants/Types.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,gCAEnB,CAAC;AAEX,eAAO,MAAM,kBAAkB,+DAErB,CAAC;AAEX,eAAO,MAAM,eAAe,0CAElB,CAAC;AAEX,eAAO,MAAM,2BAA2B,+GAG9B,CAAC;AAEX,eAAO,MAAM,yBAAyB,mFAE5B,CAAC;AAGX;;GAEG;AACH,eAAO,MAAM,UAAU,+RAMb,CAAC"}

package/dist/constants/src/constants/Types.js

@@ -0,0 +1,26 @@
+export const FALSY_TYPE_KINDS = [
+    "undefined", "null",
+];
+export const LITERAL_TYPE_KINDS = [
+    "true", "false", "stringLiteral", "numericLiteral",
+];
+export const WIDE_TYPE_KINDS = [
+    "string", "number", "boolean",
+];
+export const NARROW_CONTAINER_TYPE_KINDS = [
+    "object", "explicitFunctions", "fnType", "fnWithDict", "tuple",
+    "union", "intersection", "arrayOf"
+];
+export const WIDE_CONTAINER_TYPE_KINDS = [
+    "anyArray", "anyObject", "unknownObject", "anyFunction", "emptyObject"
+];
+/**
+ * A full list of the _types_ of types we have within the `Type` namespace.
+ */
+export const TYPE_KINDS = [
+    ...FALSY_TYPE_KINDS,
+    ...WIDE_TYPE_KINDS,
+    ...LITERAL_TYPE_KINDS,
+    ...NARROW_CONTAINER_TYPE_KINDS,
+    ...WIDE_CONTAINER_TYPE_KINDS
+];

package/dist/constants/src/constants/Wide.d.ts

@@ -0,0 +1,28 @@
+type AnyObject = Record<never, unknown> | Record<string | symbol, unknown>;
+/**
+ * **wide**
+ *
+ * Provides a dictionary of _wide_ types; in most cases you should
+ * prefer the **kind** API.
+ */
+export declare const WideAssignment: {
+    readonly boolean: () => boolean;
+    readonly string: () => string;
+    readonly number: () => number;
+    readonly symbol: () => symbol;
+    readonly null: () => null;
+    readonly function: () => (...args: unknown[]) => unknown;
+    readonly tuple: () => readonly unknown[];
+    readonly singularTuple: () => [readonly unknown[]];
+    readonly object: () => AnyObject;
+    readonly emptyObject: () => Record<never, unknown>;
+    readonly undefined: () => undefined;
+    /**
+     * run-time value is a type token for `unknown` and type is of course `unknown`
+     */
+    readonly unknown: () => unknown;
+    readonly nothing: () => null | undefined;
+    readonly something: () => {};
+};
+export {};
+//# sourceMappingURL=Wide.d.ts.map

package/dist/constants/src/constants/Wide.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Wide.d.ts","sourceRoot":"","sources":["../../../../src/constants/Wide.ts"],"names":[],"mappings":"AACA,KAAK,SAAS,GAAG,MAAM,CAAC,KAAK,EAAC,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,GAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAUxE;;;;;GAKG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;IAYzB;;OAEG;;4BAEU,IAAI,GAAG,SAAS;;CAGrB,CAAC"}

package/dist/constants/src/constants/Wide.js

@@ -0,0 +1,26 @@
+/**
+ * **wide**
+ *
+ * Provides a dictionary of _wide_ types; in most cases you should
+ * prefer the **kind** API.
+ */
+export const WideAssignment = {
+    boolean: () => "<<boolean>>",
+    string: () => "<<string>>",
+    number: () => "<<number>>",
+    symbol: () => "<<symbol>>",
+    null: () => "<<null>>",
+    function: () => "<<function>>",
+    tuple: () => "<<tuple>>",
+    singularTuple: () => ["<<tuple>>"],
+    object: () => "<<object>>",
+    emptyObject: () => "<<empty-object>>",
+    undefined: () => "<<undefined>>",
+    /**
+     * run-time value is a type token for `unknown` and type is of course `unknown`
+     */
+    unknown: () => "<<unknown>>",
+    nothing: () => "<<nothing>>",
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    something: () => "<<something>>"
+};

package/dist/constants/src/constants/createConstant.d.ts

@@ -0,0 +1,8 @@
+import { Constant } from "src/constants";
+/**
+ * **createConstant**(kind)
+ *
+ * Creates a `Constant<TKind>` type.
+ */
+export declare function createConstant<TKind extends string>(kind: TKind): Constant<TKind>;
+//# sourceMappingURL=createConstant.d.ts.map

package/dist/constants/src/constants/createConstant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createConstant.d.ts","sourceRoot":"","sources":["../../../../src/constants/createConstant.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,SAAS,MAAM,EAAE,IAAI,EAAE,KAAK,mBAK/D"}

package/dist/constants/src/constants/createConstant.js

@@ -0,0 +1,11 @@
+/**
+ * **createConstant**(kind)
+ *
+ * Creates a `Constant<TKind>` type.
+ */
+export function createConstant(kind) {
+    return {
+        _type: "Constant",
+        kind
+    };
+}