inferred-types 0.37.5 → 0.40.1

package/dist/runtime/src/runtime/literals/toCamelCase.d.ts

@@ -0,0 +1,13 @@
+import type { CamelCase } from "src/types";
+/**
+ * **toCamelCase**(str)
+ *
+ * Converts a string into `camelCase` while preserving literal strings.
+ *
+ * **Note:** _by default it also removes surrounding white space (if it exists) but it
+ * can be preserved if you change the `preserveWhitespace` flag._
+ *
+ * **Related:** `toKebabCase`, `toPascalCase`, `toSnakeCase`
+ */
+export declare function toCamelCase<TString extends string, TPreserve extends boolean = false>(input: TString, preserveWhitespace?: TPreserve): CamelCase<TString, TPreserve>;
+//# sourceMappingURL=toCamelCase.d.ts.map

package/dist/runtime/src/runtime/literals/toCamelCase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toCamelCase.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/literals/toCamelCase.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAG3C;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CACzB,OAAO,SAAS,MAAM,EACtB,SAAS,SAAS,OAAO,GAAG,KAAK,EACjC,KAAK,EAAE,OAAO,EAAE,kBAAkB,CAAC,EAAE,SAAS,GAAG,SAAS,CAAC,OAAO,EAAE,SAAS,CAAC,CAW/E"}

package/dist/runtime/src/runtime/literals/toCamelCase.js

@@ -0,0 +1,19 @@
+import { toPascalCase } from "src/runtime";
+/**
+ * **toCamelCase**(str)
+ *
+ * Converts a string into `camelCase` while preserving literal strings.
+ *
+ * **Note:** _by default it also removes surrounding white space (if it exists) but it
+ * can be preserved if you change the `preserveWhitespace` flag._
+ *
+ * **Related:** `toKebabCase`, `toPascalCase`, `toSnakeCase`
+ */
+export function toCamelCase(input, preserveWhitespace) {
+    const pascal = preserveWhitespace ? toPascalCase(input, preserveWhitespace) : toPascalCase(input);
+    const [_, preWhite, focus, postWhite] = /^(\s*)(.*?)(\s*)$/.exec(pascal);
+    const camel = (preserveWhitespace ? preWhite : "") +
+        focus.replace(/^.*?([0-9]*?[a-z|A-Z]{1})/s, (_, p1) => p1.toLowerCase()) +
+        (preserveWhitespace ? postWhite : "");
+    return camel;
+}

package/dist/runtime/src/runtime/literals/toKebabCase.d.ts

@@ -0,0 +1,13 @@
+import { KebabCase } from "src/types";
+/**
+ * **toKebabCase**(str)
+ *
+ * Converts a string into `kebab-case` while preserving literal strings.
+ *
+ * **Note:** _by default it also removes surrounding white space (if it exists) but it
+ * can be preserved if you change the `preserveWhitespace` flag._
+ *
+ * **Related:** `toPascalCase`, `toCamelCase`, `toSnakeCase`
+ */
+export declare function toKebabCase<S extends string, P extends boolean = false>(input: S, _preserveWhitespace?: P): KebabCase<S, P>;
+//# sourceMappingURL=toKebabCase.d.ts.map

package/dist/runtime/src/runtime/literals/toKebabCase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toKebabCase.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/literals/toKebabCase.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAEtC;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CACzB,CAAC,SAAS,MAAM,EAChB,CAAC,SAAS,OAAO,GAAG,KAAK,EACzB,KAAK,EAAE,CAAC,EAAE,mBAAmB,CAAC,EAAE,CAAC,mBAelC"}

package/dist/runtime/src/runtime/literals/toKebabCase.js

@@ -0,0 +1,20 @@
+/**
+ * **toKebabCase**(str)
+ *
+ * Converts a string into `kebab-case` while preserving literal strings.
+ *
+ * **Note:** _by default it also removes surrounding white space (if it exists) but it
+ * can be preserved if you change the `preserveWhitespace` flag._
+ *
+ * **Related:** `toPascalCase`, `toCamelCase`, `toSnakeCase`
+ */
+export function toKebabCase(input, _preserveWhitespace) {
+    const [_, preWhite, focus, postWhite] = /^(\s*)(.*?)(\s*)$/.exec(input);
+    const replaceWhitespace = (i) => i.replace(/\s/gs, "-");
+    const replaceUppercase = (i) => i.replace(/[A-Z]/g, (c) => `-${c[0].toLowerCase()}`);
+    const replaceLeadingDash = (i) => i.replace(/^-/s, "");
+    const replaceTrailingDash = (i) => i.replace(/-$/s, "");
+    const replaceUnderscore = (i) => i.replace(/_/g, "-");
+    const removeDupDashes = (i) => i.replace(/-+/g, "-");
+    return removeDupDashes(`${preWhite}${replaceUnderscore(replaceTrailingDash(replaceLeadingDash(removeDupDashes(replaceWhitespace(replaceUppercase(focus))))))}${postWhite}`);
+}

package/dist/runtime/src/runtime/literals/toLowercase.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Converts a string to the "all lowercase" equivalent.
+ *
+ * Note: non-alpha characters are left "as is"
+ */
+export declare function toLowercase<T extends string>(str: T): Lowercase<T>;
+//# sourceMappingURL=toLowercase.d.ts.map

package/dist/runtime/src/runtime/literals/toLowercase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toLowercase.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/literals/toLowercase.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAKlE"}

package/dist/runtime/src/runtime/literals/toLowercase.js

@@ -0,0 +1,12 @@
+import { lowercase, ifLowercaseChar } from "src/runtime";
+/**
+ * Converts a string to the "all lowercase" equivalent.
+ *
+ * Note: non-alpha characters are left "as is"
+ */
+export function toLowercase(str) {
+    return str
+        .split("")
+        .map(i => ifLowercaseChar(i, v => lowercase(v), v => v))
+        .join("");
+}

package/dist/runtime/src/runtime/literals/toNumericArray.d.ts

@@ -0,0 +1,3 @@
+import { ToNumericArray } from "src/types";
+export declare const toNumericArray: <T extends readonly unknown[]>(arr: T) => ToNumericArray<T>;
+//# sourceMappingURL=toNumericArray.d.ts.map

package/dist/runtime/src/runtime/literals/toNumericArray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toNumericArray.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/literals/toNumericArray.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAS,MAAM,WAAW,CAAC;AAElD,eAAO,MAAM,cAAc,6DAE1B,CAAC"}

package/dist/runtime/src/runtime/literals/toNumericArray.js

@@ -0,0 +1,3 @@
+export const toNumericArray = (arr) => {
+    return arr.map(i => Number(i));
+};

package/dist/runtime/src/runtime/literals/toPascalCase.d.ts

@@ -0,0 +1,13 @@
+import { PascalCase, LeftWhitespace, RightWhitespace } from "src/types";
+/**
+ * **toPascalCase**(str)
+ *
+ * Converts a string into `PascalCase` while preserving literal strings.
+ *
+ * **Note:** _by default it also removes surrounding white space (if it exists) but it
+ * can be preserved if you change the `preserveWhitespace` flag._
+ *
+ * **Related:** `toKebabCase`, `toCamelCase`, `toSnakeCase`
+ */
+export declare function toPascalCase<S extends string, P extends boolean | undefined = undefined>(input: S, preserveWhitespace?: P): true extends P ? `${LeftWhitespace<S>}${PascalCase<S>}${RightWhitespace<S>}` : PascalCase<S>;
+//# sourceMappingURL=toPascalCase.d.ts.map

package/dist/runtime/src/runtime/literals/toPascalCase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toPascalCase.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/literals/toPascalCase.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAG,cAAc,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAGzE;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAC1B,CAAC,SAAS,MAAM,EAChB,CAAC,SAAS,OAAO,GAAG,SAAS,GAAG,SAAS,EACzC,KAAK,EAAE,CAAC,EAAE,kBAAkB,GAAE,CAAkB,gGAoBjD"}

package/dist/runtime/src/runtime/literals/toPascalCase.js

@@ -0,0 +1,20 @@
+import { capitalize } from "src/runtime";
+/**
+ * **toPascalCase**(str)
+ *
+ * Converts a string into `PascalCase` while preserving literal strings.
+ *
+ * **Note:** _by default it also removes surrounding white space (if it exists) but it
+ * can be preserved if you change the `preserveWhitespace` flag._
+ *
+ * **Related:** `toKebabCase`, `toCamelCase`, `toSnakeCase`
+ */
+export function toPascalCase(input, preserveWhitespace = undefined) {
+    const [_, preWhite, focus, postWhite] = /^(\s*)(.*?)(\s*)$/.exec(input);
+    const convertInteriorToCap = (i) => i.replace(/[ |_|-]+([0-9]*?[a-z|A-Z]{1})/gs, (_, p1) => p1.toUpperCase());
+    const startingToCap = (i) => i.replace(/^[_|-]*?([0-9]*?[a-z]{1})/gs, (_, p1) => p1.toUpperCase());
+    const replaceLeadingTrash = (i) => i.replace(/^[-_]/s, "");
+    const replaceTrailingTrash = (i) => i.replace(/[-_]$/s, "");
+    const pascal = `${preserveWhitespace ? preWhite : ""}${capitalize(replaceTrailingTrash(replaceLeadingTrash(convertInteriorToCap(startingToCap(focus)))))}${preserveWhitespace ? postWhite : ""}`;
+    return pascal;
+}

package/dist/runtime/src/runtime/literals/toSnakeCase.d.ts

@@ -0,0 +1,12 @@
+/**
+ * **toSnakeCase**(str)
+ *
+ * Converts a string into `snake_case` while preserving literal strings.
+ *
+ * **Note:** _by default it also removes surrounding white space (if it exists) but it
+ * can be preserved if you change the `preserveWhitespace` flag._
+ *
+ * **Related:** `toKebabCase`, `toCamelCase`, `toPascalCase`
+ */
+export declare function toSnakeCase<S extends string, P extends boolean = false>(input: S, preserveWhitespace?: P): string;
+//# sourceMappingURL=toSnakeCase.d.ts.map

package/dist/runtime/src/runtime/literals/toSnakeCase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toSnakeCase.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/literals/toSnakeCase.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CACzB,CAAC,SAAS,MAAM,EAChB,CAAC,SAAS,OAAO,GAAG,KAAK,EACzB,KAAK,EAAE,CAAC,EAAE,kBAAkB,GAAE,CAAc,GAAG,MAAM,CAgBtD"}

package/dist/runtime/src/runtime/literals/toSnakeCase.js

@@ -0,0 +1,20 @@
+/**
+ * **toSnakeCase**(str)
+ *
+ * Converts a string into `snake_case` while preserving literal strings.
+ *
+ * **Note:** _by default it also removes surrounding white space (if it exists) but it
+ * can be preserved if you change the `preserveWhitespace` flag._
+ *
+ * **Related:** `toKebabCase`, `toCamelCase`, `toPascalCase`
+ */
+export function toSnakeCase(input, preserveWhitespace = false) {
+    const [_, preWhite, focus, postWhite] = /^(\s*)(.*?)(\s*)$/.exec(input);
+    const convertInteriorSpace = (input) => input.replace(/\s+/gs, "_");
+    const convertDashes = (input) => input.replace(/-/gs, "_");
+    const injectUnderscoreBeforeCaps = (input) => input.replace(/([A-Z])/gs, "_$1");
+    const removeLeadingUnderscore = (input) => input.startsWith("_") ? input.slice(1) : input;
+    return ((preserveWhitespace ? preWhite : "") +
+        removeLeadingUnderscore(injectUnderscoreBeforeCaps(convertDashes(convertInteriorSpace(focus)))).toLowerCase() +
+        (preserveWhitespace ? postWhite : "")).replace(/__/g, "_");
+}

package/dist/runtime/src/runtime/literals/toString.d.ts

@@ -0,0 +1,9 @@
+import { ToString, Narrowable } from "src/types";
+/**
+ * **toString**()
+ *
+ * Runtime utility which converts any given type to a string while
+ * preserving literal types.
+ */
+export declare function toString<T extends Narrowable>(val: T): ToString<T>;
+//# sourceMappingURL=toString.d.ts.map

package/dist/runtime/src/runtime/literals/toString.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toString.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/literals/toString.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAEjD;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,UAAU,EAAE,GAAG,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAElE"}

package/dist/runtime/src/runtime/literals/toString.js

@@ -0,0 +1,9 @@
+/**
+ * **toString**()
+ *
+ * Runtime utility which converts any given type to a string while
+ * preserving literal types.
+ */
+export function toString(val) {
+    return String(val);
+}

package/dist/runtime/src/runtime/literals/toUppercase.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Converts a string to the "all caps" equivalent.
+ *
+ * Note: non-alpha characters are left "as is"
+ */
+export declare function toUppercase<T extends string>(str: T): Uppercase<T>;
+//# sourceMappingURL=toUppercase.d.ts.map

package/dist/runtime/src/runtime/literals/toUppercase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toUppercase.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/literals/toUppercase.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAKlE"}

package/dist/runtime/src/runtime/literals/toUppercase.js

@@ -0,0 +1,12 @@
+import { capitalize, ifLowercaseChar } from "src/runtime";
+/**
+ * Converts a string to the "all caps" equivalent.
+ *
+ * Note: non-alpha characters are left "as is"
+ */
+export function toUppercase(str) {
+    return str
+        .split("")
+        .map(i => ifLowercaseChar(i, v => capitalize(v), v => v))
+        .join("");
+}

package/dist/runtime/src/runtime/literals/trim.d.ts

@@ -0,0 +1,41 @@
+import { Trim, TrimLeft, TrimRight } from "src/types";
+/**
+ * **trim**(input)
+ *
+ * A runtime utility which trims whitespace on both sides of a string
+ * and returns a type-strong string literal where possible.
+ */
+export declare function trim<T extends string>(input: T): Trim<T>;
+/**
+ * **trimLeft**(input)
+ *
+ * A runtime utility which trims whitespace on the leading/left side of a string
+ * and returns a type-strong string literal where possible.
+ *
+ * @deprecated prefer use of `trimStart` instead
+ */
+export declare function trimLeft<T extends string>(input: T): TrimLeft<T>;
+/**
+ * **trimStart**(input)
+ *
+ * A runtime utility which trims whitespace on the leading/left side of a string
+ * and returns a type-strong string literal where possible.
+ */
+export declare function trimStart<T extends string>(input: T): TrimLeft<T>;
+/**
+ * **trimRight**(input)
+ *
+ * A runtime utility which trims whitespace on the tailing/right side of a string
+ * and returns a type-strong string literal where possible.
+ *
+ * @deprecated prefer use of `trimEnd` instead
+ */
+export declare function trimRight<T extends string>(input: T): TrimRight<T>;
+/**
+ * **trimEnd**(input)
+ *
+ * A runtime utility which trims whitespace on the tailing/right side of a string
+ * and returns a type-strong string literal where possible.
+ */
+export declare function trimEnd<T extends string>(input: T): TrimRight<T>;
+//# sourceMappingURL=trim.d.ts.map

package/dist/runtime/src/runtime/literals/trim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trim.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/literals/trim.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAEtD;;;;;GAKG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAExD;AAED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAEhE;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAEjE;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAElE;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAEhE"}

package/dist/runtime/src/runtime/literals/trim.js

@@ -0,0 +1,49 @@
+/**
+ * **trim**(input)
+ *
+ * A runtime utility which trims whitespace on both sides of a string
+ * and returns a type-strong string literal where possible.
+ */
+export function trim(input) {
+    return input.trim();
+}
+/**
+ * **trimLeft**(input)
+ *
+ * A runtime utility which trims whitespace on the leading/left side of a string
+ * and returns a type-strong string literal where possible.
+ *
+ * @deprecated prefer use of `trimStart` instead
+ */
+export function trimLeft(input) {
+    return input.trimStart();
+}
+/**
+ * **trimStart**(input)
+ *
+ * A runtime utility which trims whitespace on the leading/left side of a string
+ * and returns a type-strong string literal where possible.
+ */
+export function trimStart(input) {
+    return input.trimStart();
+}
+/**
+ * **trimRight**(input)
+ *
+ * A runtime utility which trims whitespace on the tailing/right side of a string
+ * and returns a type-strong string literal where possible.
+ *
+ * @deprecated prefer use of `trimEnd` instead
+ */
+export function trimRight(input) {
+    return input.trimEnd();
+}
+/**
+ * **trimEnd**(input)
+ *
+ * A runtime utility which trims whitespace on the tailing/right side of a string
+ * and returns a type-strong string literal where possible.
+ */
+export function trimEnd(input) {
+    return input.trimEnd();
+}

package/dist/runtime/src/runtime/literals/tuple.d.ts

@@ -0,0 +1,13 @@
+import { First, IfUnion, Length, Narrowable, UnionToTuple } from "src/types";
+/**
+ * **tuple**(value)
+ *
+ * Creates a discrete tuple.
+ * ```ts
+ * // [1,2,3]
+ * const t1 = tuple(1,2,3);
+ * const t2 = tuple([1,2,3]);
+ * ```
+ */
+export declare const tuple: <N extends Narrowable, K extends PropertyKey, T extends readonly (Narrowable | Record<K, N>)[]>(...values: T) => import("src/types").AsArray<Length<T> extends 1 ? T[0] extends readonly unknown[] ? T[0] extends infer Arr ? IfUnion<First<Arr & readonly unknown[]>, UnionToTuple<First<T[0]>>, T[0]> : T[0] : T[0] : T>;
+//# sourceMappingURL=tuple.d.ts.map

package/dist/runtime/src/runtime/literals/tuple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tuple.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/literals/tuple.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAI7E;;;;;;;;;GASG;AACH,eAAO,MAAM,KAAK,4TAuBjB,CAAC"}

package/dist/runtime/src/runtime/literals/tuple.js

@@ -0,0 +1,17 @@
+import { asArray } from "src/runtime";
+/**
+ * **tuple**(value)
+ *
+ * Creates a discrete tuple.
+ * ```ts
+ * // [1,2,3]
+ * const t1 = tuple(1,2,3);
+ * const t2 = tuple([1,2,3]);
+ * ```
+ */
+export const tuple = (...values) => {
+    const arr = (values.length === 1
+        ? values[0]
+        : values);
+    return asArray(arr);
+};

package/dist/runtime/src/runtime/literals/uncapitalize.d.ts

@@ -0,0 +1,8 @@
+/**
+ * **uncapitalize**()
+ *
+ * Run time utility which _un_-capitalizes a word/string and preserves
+ * string literal types.
+ */
+export declare function uncapitalize<T extends string>(str: T): Uncapitalize<T>;
+//# sourceMappingURL=uncapitalize.d.ts.map

package/dist/runtime/src/runtime/literals/uncapitalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uncapitalize.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/literals/uncapitalize.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAEtE"}

package/dist/runtime/src/runtime/literals/uncapitalize.js

@@ -0,0 +1,9 @@
+/**
+ * **uncapitalize**()
+ *
+ * Run time utility which _un_-capitalizes a word/string and preserves
+ * string literal types.
+ */
+export function uncapitalize(str) {
+    return `${str?.slice(0, 1).toLowerCase()}${str?.slice(1)}`;
+}

package/dist/runtime/src/runtime/literals/uppercase.d.ts

@@ -0,0 +1,8 @@
+/**
+ * **uppercase**()
+ *
+ * Run time utility which ensures all letters are uppercase while preserving
+ * string literal types.
+ */
+export declare function uppercase<T extends string>(str: T): Uppercase<T>;
+//# sourceMappingURL=uppercase.d.ts.map

package/dist/runtime/src/runtime/literals/uppercase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uppercase.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/literals/uppercase.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAEhE"}

package/dist/runtime/src/runtime/literals/uppercase.js

@@ -0,0 +1,9 @@
+/**
+ * **uppercase**()
+ *
+ * Run time utility which ensures all letters are uppercase while preserving
+ * string literal types.
+ */
+export function uppercase(str) {
+    return str.toUpperCase();
+}

package/dist/runtime/src/runtime/literals/widen.d.ts

@@ -0,0 +1,9 @@
+import { Narrowable, Widen } from "src/types";
+/**
+ * **widen**(value)
+ *
+ * Runtime utility which takes any _type_ and ensures it's widened to a wide
+ * type of passed in value is a literal.
+ */
+export declare function widen<T extends Narrowable>(value: T): Widen<T>;
+//# sourceMappingURL=widen.d.ts.map

package/dist/runtime/src/runtime/literals/widen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"widen.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/literals/widen.ts"],"names":[],"mappings":"AACA,OAAO,EAAG,UAAU,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AAG/C;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,UAAU,EAAE,KAAK,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAE9D"}

package/dist/runtime/src/runtime/literals/widen.js

@@ -0,0 +1,9 @@
+/**
+ * **widen**(value)
+ *
+ * Runtime utility which takes any _type_ and ensures it's widened to a wide
+ * type of passed in value is a literal.
+ */
+export function widen(value) {
+    return value;
+}

package/dist/runtime/src/runtime/runtime-types/createType.d.ts

@@ -0,0 +1,40 @@
+import type { FromTypeDefn, TypeDefaultValue, TypeDefn, TypeKind, TypeUnderlying } from "src/types";
+/**
+ * **TypeApi**
+ *
+ * The API surface used to define _types_ which have a runtime
+ * understanding of the type as well.
+ */
+/**
+ * **createTypeApi**
+ *
+ * Receives an array of properties on the full API
+ * which should be _omitted_ and then returns the
+ * remaining parts of the API surface.
+ */
+/**
+ * **createTypeDefn**(td: TypeDefn): Type
+ *
+ *
+* (defined by the `TypeDefn` type). This function then enriches
+ * this data to become a fully fledged "runtime type" as expressed
+ * by the `Type` type.
+ */
+export declare const createTypeDefn: <TD extends TypeDefn<TKind, TRequired, TDesc, TUnderlying, TDefValue, import("src/types").TypeDefnValidations>, TKind extends TypeKind, TRequired extends boolean, TDesc extends string, TUnderlying extends TypeUnderlying, TDefValue extends TypeDefaultValue<TKind, TRequired, TUnderlying>>(defn: TD) => FromTypeDefn<TD>;
+/**
+ * Creates a _run time_ type definition (`Type`).
+ *
+ * - you may pass in a `TypeDefn` or use the builder API to build the type.
+ * ```ts
+ * // pass in a `TypeDefn` dictionary
+ * const myString = type({ kind: "string" });
+ * // use the builder API
+ * const myObj = type(
+ *    defn => defn.objectLiteral()
+ *      .addProperty(p => p("string", { isRequired: false }))
+ *      .addProperty(p => p("number")
+ * )
+ * ```
+ */
+export declare const createType: <TD extends TypeDefn<TypeKind, boolean, string, TypeUnderlying, TypeDefaultValue<TypeKind, boolean, TypeUnderlying>, import("src/types").TypeDefnValidations>>(t: TD) => FromTypeDefn<TD>;
+//# sourceMappingURL=createType.d.ts.map

package/dist/runtime/src/runtime/runtime-types/createType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createType.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/runtime-types/createType.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,YAAY,EACZ,gBAAgB,EAChB,QAAQ,EACR,QAAQ,EACR,cAAc,EACf,MAAM,WAAW,CAAC;AAgBnB;;;;;GAKG;AAGH;;;;;;GAMG;AAaH;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,+TA8C1B,CAAC;AAgCF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,UAAU,2LAkBtB,CAAC"}

package/dist/runtime/src/runtime/runtime-types/createType.js

@@ -0,0 +1,116 @@
+import { LITERAL_TYPE_KINDS, NO_DEFAULT_VALUE, } from "src/constants";
+import { keysOf, box, isTypeDefn, createTypeGuard, createValidator, determineIdentity, determineType } from "src/runtime";
+/**
+ * **TypeApi**
+ *
+ * The API surface used to define _types_ which have a runtime
+ * understanding of the type as well.
+ */
+// type TypeApi<E extends (keyof TypeDefnApi)[] | []> = RemoveProps<TypeDefnApi, E>;
+/**
+ * **createTypeApi**
+ *
+ * Receives an array of properties on the full API
+ * which should be _omitted_ and then returns the
+ * remaining parts of the API surface.
+ */
+// const createTypeApi = <
+//   K extends TypeKind,
+//   T,
+//   R extends TypeIsRequired,
+//   // exclusions to API surface
+//   E extends (keyof TypeDefnApi)[]
+// >(
+//   state: Type<K,T,R>,
+//   exclude: E,
+// ): TypeApi<E> => removeProps(typeApiImplementation, exclude);
+/**
+ * **createTypeDefn**(td: TypeDefn): Type
+ *
+ *
+* (defined by the `TypeDefn` type). This function then enriches
+ * this data to become a fully fledged "runtime type" as expressed
+ * by the `Type` type.
+ */
+export const createTypeDefn = (defn) => {
+    const type = {
+        _type: "Type",
+        kind: defn.kind,
+        type: determineType(defn),
+        isRequired: defn.isRequired ? true : false,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        isLiteral: keysOf(LITERAL_TYPE_KINDS).includes(defn.kind) ? true : false,
+        description: (defn.description || ""),
+        validations: (defn.validations || []),
+        defaultValue: (defn.defaultValue
+            ? box(defn.defaultValue)
+            : NO_DEFAULT_VALUE),
+        identity: determineIdentity(defn),
+        underlying: (defn.underlying || "no-underlying"),
+        underlying_operand: (defn.kind === "intersection" ? "AND" : "OR"),
+        isUnion: (defn.isRequired === false || (Array.isArray(defn.underlying) && defn.underlying.length > 1)
+            ? true
+            : false),
+        // stubs
+        validate: (_val) => true,
+        is: ((_val) => true),
+    };
+    return createValidator(createTypeGuard(type));
+};
+// export const typeApiImplementation: TypeApi = {
+//   string(o) {
+//     return createTypeDefn({
+//       ...o,
+//       kind: "string",
+//     });
+//   },
+//   number(o) {
+//     return createTypeDefn({
+//       ...o,
+//       kind: "number",
+//     });
+//   },
+//   boolean(o) {
+//     return createTypeDefn({
+//       ...o,
+//       kind: "boolean",
+//     });
+//   },
+//   stringLiteral(literal, o) {
+//     return createTypeDefn({
+//       ...o,
+//       underlying: literal,
+//       kind: "stringLiteral",
+//     });
+//   },
+// };
+/**
+ * Creates a _run time_ type definition (`Type`).
+ *
+ * - you may pass in a `TypeDefn` or use the builder API to build the type.
+ * ```ts
+ * // pass in a `TypeDefn` dictionary
+ * const myString = type({ kind: "string" });
+ * // use the builder API
+ * const myObj = type(
+ *    defn => defn.objectLiteral()
+ *      .addProperty(p => p("string", { isRequired: false }))
+ *      .addProperty(p => p("number")
+ * )
+ * ```
+ */
+export const createType = (t) => {
+    if (isTypeDefn(t)) {
+        return createTypeDefn({ ...t, _type: "TypeDefn" });
+    }
+    else {
+        throw new Error(`type() received an invalid configuration. Valid types are either a "TypeDefn" dictionary or a API callback definition. Instead received: ${JSON.stringify(t)}`);
+        // create type from builder API
+        // const initialState = createTypeApi([], createEmptyState());
+        // const returnedState = type(initialState);
+        // if (returnedState.type.kind === "empty") {
+        //   throw new Error("Invalid type! When using the type() utility you must change the state from initial 'empty' state to something else. If you wanted to set to 'never' then choose that method on the API surface.");
+        // }
+        // return returnedState.type;
+    }
+};

package/dist/runtime/src/runtime/runtime-types/describeType.d.ts

@@ -0,0 +1,13 @@
+import { DescribeType } from "src/types";
+/**
+ * **describeType**(type)
+ *
+ * Provides a simple "wide type" description to the runtime while
+ * offering slightly more insight to the type system.
+ *
+ * **Note:** if the type passed in is actually a `TypeToken` then the
+ * runtime system will get the same resolution as the type system
+ * but in other cases this just isn't possible.
+ */
+export declare const describeType: <T>(type: T) => DescribeType<T>;
+//# sourceMappingURL=describeType.d.ts.map

package/dist/runtime/src/runtime/runtime-types/describeType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"describeType.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/runtime-types/describeType.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAa,MAAM,WAAW,CAAC;AAwBpD;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,iCAQxB,CAAC"}