inferred-types 0.46.1 → 0.47.1

package/dist/runtime/runtime-types/tokens/createTypeToken.d.ts

@@ -0,0 +1,30 @@
+import { If, IsLength, Join, SimpleType, TypeTokenAtomics, TypeTokenKind, TypeTokenSingletons } from "../../../types/index";
+type BaseReturn<TBase extends TypeTokenKind> = TBase extends TypeTokenAtomics ? `<<${TBase}>>` : TBase extends TypeTokenSingletons ? SingletonClosure<TBase> : unknown;
+export type UnionClosure = <T extends readonly unknown[]>(...elements: T) => `union::[${Join<T, ", ">}]`;
+/**
+ * **SingletonClosure**
+ *
+ * Closes out the `string` or `number` base types to conclude as
+ * either a wide type or a string literal. It does allow for multiple
+ * literal values and in this case will need to add a union token as
+ * a parameter
+ *
+ * ```ts
+ * // <<string>>
+ * const a = closure<"string">();
+ * // <<string::foo>>
+ * const b = closure<"string">("foo");
+ * // <<string::${UnionClosure("foo", "bar")}>>
+ * const c = closure<"string">("foo","bar");
+ * ```
+ */
+export type SingletonClosure<T extends "string" | "number"> = <TLit extends readonly SimpleType<T>[]>(...literals: TLit) => If<IsLength<TLit, 0>, `<<${T}>>`, If<IsLength<TLit, 1>, `<<${T}::${TLit[0]}>>`, `<<${T}::>>`>>;
+/**
+ * **createTypeToken**`(base) => (secondary) => ...`
+ *
+ * A higher order function designed to creating a valid
+ * `TypeToken` simple through a compound process.
+ */
+export declare const createTypeToken: <TBase extends TypeTokenAtomics>(base: TBase) => BaseReturn<TBase>;
+export {};
+//# sourceMappingURL=createTypeToken.d.ts.map

package/dist/runtime/runtime-types/tokens/createTypeToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTypeToken.d.ts","sourceRoot":"","sources":["../../../../src/runtime/runtime-types/tokens/createTypeToken.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,EAAE,EACF,QAAQ,EACR,IAAI,EACJ,UAAU,EACV,gBAAgB,EAChB,aAAa,EACb,mBAAmB,EAEpB,6BAAwB;AAOzB,KAAK,UAAU,CAAC,KAAK,SAAS,aAAa,IAAI,KAAK,SAAS,gBAAgB,GACzE,KAAK,KAAK,IAAI,GACd,KAAK,SAAS,mBAAmB,GACjC,gBAAgB,CAAC,KAAK,CAAC,GACvB,OAAO,CAAC;AAGZ,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,EAAE,GAAG,QAAQ,EAAE,CAAC,KACtE,WAAW,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC;AAE9B;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ,IACxD,CAAC,IAAI,SAAS,SAAS,UAAU,CAAC,CAAC,CAAC,EAAE,EACpC,GAAG,QAAQ,EAAE,IAAI,KAChB,EAAE,CACL,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,EACjB,KAAK,CAAC,IAAI,EACV,EAAE,CACA,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,EACjB,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,EACtB,KAAK,CAAC,MAAM,CACb,CACF,CAAC;AAuCF;;;;;GAKG;AACH,eAAO,MAAM,eAAe,GAC1B,KAAK,SAAS,gBAAgB,QACxB,KAAK,KAAG,UAAU,CAAC,KAAK,CAQ/B,CAAA"}

package/dist/runtime/runtime-types/tokens/createTypeToken.js

@@ -0,0 +1,29 @@
+import { isAtomicToken, isSingletonToken, jsonValues } from "../../index.js";
+const unionToken = (...els) => {
+    return `<<union::[${jsonValues(els)}]>>`;
+};
+const singleton = (base) => {
+    const handler = (...lits) => {
+        return (lits.length === 0
+            ? base === "string" ? `<<string>>` : `<<number>>`
+            : lits.length === 1
+                ? base === "string" ? `<<string::${lits[0]}>>` : `<<number::${lits[0]}>>`
+                : base === "string"
+                    ? `<<string::${unionToken(...lits)}>>`
+                    : `<<number::${unionToken(...lits)}>>`);
+    };
+    return handler;
+};
+/**
+ * **createTypeToken**`(base) => (secondary) => ...`
+ *
+ * A higher order function designed to creating a valid
+ * `TypeToken` simple through a compound process.
+ */
+export const createTypeToken = (base) => {
+    return (isAtomicToken(base)
+        ? `<<${base}>>`
+        : isSingletonToken(base)
+            ? singleton(base)
+            : "");
+};

package/dist/runtime/runtime-types/tokens/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./simpleToken";
+export * from "./createTypeToken";
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/runtime-types/tokens/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/runtime/runtime-types/tokens/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA;AAC7B,cAAc,mBAAmB,CAAA"}

package/dist/runtime/runtime-types/tokens/index.js

@@ -0,0 +1,2 @@
+export * from "./simpleToken.js";
+export * from "./createTypeToken.js";

package/dist/runtime/runtime-types/tokens/simpleToken.d.ts

@@ -0,0 +1,51 @@
+import { SimpleContainerToken, SimpleScalarToken, SimpleToken, SimpleType } from "../../../types/index";
+/**
+ * **simpleToken**`(token)`
+ *
+ * Creates a `SimpleToken` which assured to be a valid token type.
+ *
+ * **Related:** `simpleType()`, `simpleScalarToken()`, `simpleContainerToken()`
+ */
+export declare const simpleToken: <T extends SimpleToken>(token: T) => T;
+/**
+ * **simpleScalarToken**`(token)`
+ *
+ * Creates a `SimpleScalarToken` which is assured to be a valid token type.
+ *
+ * **Related:** `simpleType()`, `simpleToken()`, `simpleContainerToken()`
+ */
+export declare const simpleScalarToken: <T extends SimpleScalarToken>(token: T) => T;
+/**
+ * **simpleContainerToken**`(token)`
+ *
+ * Creates a `SimpleContainerToken` which assured to be a valid token type.
+ *
+ * **Related:** `simpleType()`, `simpleToken()`, `simpleScalarToken()`
+ */
+export declare const simpleContainerToken: <T extends SimpleContainerToken>(token: T) => T;
+/**
+ * **simpleScalarType**`(token)`
+ *
+ * Creates a valid runtime token _and_ converts it's type to the type that
+ * the token represents.
+ *
+ * **Related:** `simpleScalarToken`
+ */
+export declare const simpleScalarType: <T extends SimpleScalarToken>(token: T) => SimpleType<T>;
+/**
+ * **simpleContainerType**`(token)`
+ *
+ * Creates a valid runtime token _and_ converts it's type to the type that
+ * the token represents.
+ *
+ * **Related:** `simpleContainerToken`
+ */
+export declare const simpleContainerType: <T extends SimpleContainerToken>(token: T) => SimpleType<T>;
+/**
+ * **simpleType**`(token)`
+ *
+ * Creates a valid runtime token of the `SimpleToken` convention and converts
+ * the _type_ to the type that the token represents.
+ */
+export declare const simpleType: <T extends SimpleToken>(token: T) => SimpleType<T>;
+//# sourceMappingURL=simpleToken.d.ts.map

package/dist/runtime/runtime-types/tokens/simpleToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simpleToken.d.ts","sourceRoot":"","sources":["../../../../src/runtime/runtime-types/tokens/simpleToken.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,oBAAoB,EACpB,iBAAiB,EACjB,WAAW,EACX,UAAU,EACX,6BAAwB;AAEzB;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,WAAW,SAAS,CAAC,MAAU,CAAC;AAEtE;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,iBAAiB,SAAS,CAAC,MAAU,CAAC;AAGlF;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,GAAI,CAAC,SAAS,oBAAoB,SAAS,CAAC,MAAU,CAAC;AAGxF;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,iBAAiB,SAAS,CAAC,KAGpD,UAAU,CAAC,CAAC,CAC7B,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,GAAI,CAAC,SAAS,oBAAoB,SAAS,CAAC,KAG1D,UAAU,CAAC,CAAC,CAC7B,CAAA;AAGD;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,SAAS,WAAW,SAAS,CAAC,KASxC,UAAU,CAAC,CAAC,CAC7B,CAAA"}

package/dist/runtime/runtime-types/tokens/simpleToken.js

@@ -0,0 +1,64 @@
+import { Never } from "../../../constants/index.js";
+import { isSimpleContainerToken, isSimpleScalarToken } from "../../index.js";
+/**
+ * **simpleToken**`(token)`
+ *
+ * Creates a `SimpleToken` which assured to be a valid token type.
+ *
+ * **Related:** `simpleType()`, `simpleScalarToken()`, `simpleContainerToken()`
+ */
+export const simpleToken = (token) => token;
+/**
+ * **simpleScalarToken**`(token)`
+ *
+ * Creates a `SimpleScalarToken` which is assured to be a valid token type.
+ *
+ * **Related:** `simpleType()`, `simpleToken()`, `simpleContainerToken()`
+ */
+export const simpleScalarToken = (token) => token;
+/**
+ * **simpleContainerToken**`(token)`
+ *
+ * Creates a `SimpleContainerToken` which assured to be a valid token type.
+ *
+ * **Related:** `simpleType()`, `simpleToken()`, `simpleScalarToken()`
+ */
+export const simpleContainerToken = (token) => token;
+/**
+ * **simpleScalarType**`(token)`
+ *
+ * Creates a valid runtime token _and_ converts it's type to the type that
+ * the token represents.
+ *
+ * **Related:** `simpleScalarToken`
+ */
+export const simpleScalarType = (token) => {
+    const value = simpleScalarToken(token);
+    return value;
+};
+/**
+ * **simpleContainerType**`(token)`
+ *
+ * Creates a valid runtime token _and_ converts it's type to the type that
+ * the token represents.
+ *
+ * **Related:** `simpleContainerToken`
+ */
+export const simpleContainerType = (token) => {
+    const value = simpleContainerToken(token);
+    return value;
+};
+/**
+ * **simpleType**`(token)`
+ *
+ * Creates a valid runtime token of the `SimpleToken` convention and converts
+ * the _type_ to the type that the token represents.
+ */
+export const simpleType = (token) => {
+    const value = (isSimpleScalarToken(token)
+        ? simpleScalarType(token)
+        : isSimpleContainerToken(token)
+            ? simpleContainerToken(token)
+            : Never);
+    return value;
+};

package/dist/runtime/sets/uniqueKeys.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"uniqueKeys.d.ts","sourceRoot":"","sources":["../../../src/runtime/sets/uniqueKeys.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAiB,UAAU,EAAE,0BAAwB;AAGvE;;;;;GAKG;AACH,eAAO,MAAM,UAAU,mDAGf,CAAC,SAAS,CAAC,qBAmClB,CAAC"}
+{"version":3,"file":"uniqueKeys.d.ts","sourceRoot":"","sources":["../../../src/runtime/sets/uniqueKeys.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAiB,UAAU,EAAE,0BAAwB;AAGvE;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GACrB,CAAC,SAAS,SAAS,EACnB,CAAC,SAAS,SAAS,QACb,CAAC,SAAS,CAAC,KAAG,UAAU,CAAC,CAAC,EAAC,CAAC,CAmCnC,CAAC"}