inferred-types 0.37.5 → 0.40.1

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

@@ -0,0 +1,34 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { ALPHA_CHARS } from "src/constants";
+import { createTypeTuple, kind } from "src/runtime";
+const digit = createTypeTuple(kind.explicitType("Digit"), (val) => {
+    return typeof val === "string" && ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"].includes(val);
+}, "A numeric digit (aka, 0-9)");
+const alpha = createTypeTuple(kind.explicitType("AlphaChar"), (val) => {
+    return typeof val === "string" && ALPHA_CHARS.includes(val);
+}, "A alpha (upper or lowercase)");
+// const alphaLowercase = createTypeTuple(
+//   runtimeType.explicitType<Join<LowerAlphaChar[]>>(),
+//   <T>(val: T): val is T & Lowercase<T> => {
+//     return typeof val === "string" && split(val).every(i => LOWER_ALPHA_CHARS.includes(i as LowerAlphaChar));
+//   },
+//   "A string with lowercase alphabetic characters"
+// );
+// const alphaUppercase = createTypeTuple(
+//   runtimeType.explicitType<Join<UpperAlphaChar[]>>(),
+//   <T>(val: T): val is T & Join<UpperAlphaChar[]> => {
+//     return typeof val === "string" && split(val).every(i => LOWER_ALPHA_CHARS.includes(i as any));
+//   },
+//   "A string with uppercase alphabetic characters"
+// );
+/**
+ * **typeTuples**
+ *
+ * A dictionary of `TypeTuple` definitions
+ */
+export const typeTuples = {
+    digit,
+    alpha,
+    // alphaLowercase,
+    // alphaUppercase
+};

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

@@ -0,0 +1,28 @@
+import { AnyFunction, Narrowable } from "src/types";
+export type ValueTuple = [type: unknown, narrowable: boolean];
+/**
+ * An API surface for choosing a **type** which is defined for run-time
+ * use but is translatable to the type system as well.
+ */
+export type ValueTypes = {
+    string: [string, false];
+    boolean: [];
+};
+export declare const valueTypes: {
+    string: [string, false];
+    boolean: [boolean, false];
+    number: [number, false];
+    function: [AnyFunction, false];
+    object: [Record<string, unknown>, false];
+    array: <T>(arr?: T[]) => [T[], false];
+    null: [null, false];
+    symbol: [symbol, false];
+    undefined: [undefined, false];
+    true: [true, true];
+    false: [false, true];
+    /** pass in a literal type */
+    literal: <N extends Narrowable, T_1 extends string | number | boolean | symbol | Record<PropertyKey, N> | null | undefined>(v: T_1) => [T_1, true];
+    literalArray: <N_1 extends Narrowable, T_2 extends string | number | boolean | symbol | Record<PropertyKey, N_1> | null | undefined>(arr: T_2[]) => (boolean | T_2[])[];
+};
+export type ValueTypeFunc<N extends Narrowable, T extends Record<PropertyKey, N> | number | string | boolean | symbol | null | AnyFunction> = (v: ValueTypes) => [T, boolean];
+//# sourceMappingURL=valueTypes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"valueTypes.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/runtime-types/valueTypes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAEpD,MAAM,MAAM,UAAU,GAAG,CAAC,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;AAE9D;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,MAAM,EAAE,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IACxB,OAAO,EAAE,EAAE,CAAC;CACb,CAAC;AAEF,eAAO,MAAM,UAAU;;;;;;;;;;;;IAcrB,6BAA6B;;;CAe9B,CAAC;AAEF,MAAM,MAAM,aAAa,CACvB,CAAC,SAAS,UAAU,EACpB,CAAC,SAAS,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,IAAI,GAAG,WAAW,IACxF,CAAC,CAAC,EAAE,UAAU,KAAK,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC"}

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

@@ -0,0 +1,20 @@
+export const valueTypes = {
+    // WIDE
+    string: ["", false],
+    boolean: [true, false],
+    number: [0, false],
+    function: [(() => ""), false],
+    object: [{}, false],
+    array: (arr = []) => [arr, false],
+    null: [null, false],
+    symbol: [Symbol("type"), false],
+    undefined: [undefined, false],
+    // NARROW
+    true: [true, true],
+    false: [false, true],
+    /** pass in a literal type */
+    literal: (v) => {
+        return [v, true];
+    },
+    literalArray: (arr) => [arr, true],
+};

package/dist/runtime/src/runtime/sets/index.d.ts

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

package/dist/runtime/src/runtime/sets/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/sets/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC"}

package/dist/runtime/src/runtime/sets/index.js

@@ -0,0 +1 @@
+export * from "./uniqueKeys";

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

@@ -0,0 +1,9 @@
+import { Container, UniqueKeys } from "src/types";
+/**
+ * **uniqueKeys**(left, right)
+ *
+ * Returns a strongly typed `LeftRight` tuple which identifies the
+ * unique keys for each participant list passed in.
+ */
+export declare const uniqueKeys: <L extends Container, R extends Container>(left: L, right: R) => UniqueKeys<L, R>;
+//# sourceMappingURL=uniqueKeys.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"uniqueKeys.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/sets/uniqueKeys.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAGlD;;;;;GAKG;AACH,eAAO,MAAM,UAAU,mFA0BtB,CAAC"}

package/dist/runtime/src/runtime/sets/uniqueKeys.js

@@ -0,0 +1,27 @@
+import { isArray, toNumber } from "src/runtime";
+/**
+ * **uniqueKeys**(left, right)
+ *
+ * Returns a strongly typed `LeftRight` tuple which identifies the
+ * unique keys for each participant list passed in.
+ */
+export const uniqueKeys = (left, right) => {
+    const isNumeric = isArray(left) && isArray(right)
+        ? true
+        : false;
+    if ((isArray(left) && !isArray(right)) ||
+        (isArray(right) && !isArray(left))) {
+        throw new Error("uniqueKeys(l,r) given invalid comparison; both left and right values should be an object or an array but not one of each!");
+    }
+    const l = isNumeric
+        ? toNumber(Object.keys(left))
+        : Object.keys(left);
+    const r = isNumeric
+        ? toNumber(Object.keys(right))
+        : Object.keys(right);
+    return [
+        "LeftRight",
+        l.filter(i => !r.includes(i)),
+        r.filter(i => !l.includes(i))
+    ];
+};

package/dist/runtime/src/runtime/state/Configurator.d.ts

@@ -0,0 +1,39 @@
+import { ExpandRecursively } from "src/types";
+type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+export interface IConfigurator<C = {}> {
+    set<V, K extends string, KV = {
+        [U in K]: V;
+    }>(key: K, value: V): asserts this is IConfigurator<ExpandRecursively<C & KV>>;
+    remove<K extends string & keyof C>(key: K): asserts this is IConfigurator<ExpandRecursively<Omit<C, K>>>;
+    done(): C;
+}
+/**
+ * **Configurator**
+ *
+ * This function provides a configurator which uses TypeScript assertions
+ * to narrow the scope of variables. Using type assertions though means we
+ * can't also return values and therefore a _fluent_ API style is not possible.
+ *
+ * Note: this approach does require, that you explicitly use the `IConfigurator`
+ * interface exported by this library. Without it you'd getting annoying TS errors
+ * on every call to `set()` but adding it is simple enough:
+ *
+ * ```ts
+ * import { Configurator, IConfigurator } from "inferred-types";
+ * const config: IConfigurator = Configurator();
+ * ```
+ *
+ * If you want to specify some guideline params which you expect to be set, you
+ * can add them like so:
+ *
+ * ```ts
+ * export type IExpected = { foo: number, bar: string };
+ * const config: IConfigurator<IExpected> = Configurator<IExpected>();
+ * ```
+ *
+ * This configuration will ensure that `foo` and `bar` will be seen as optional
+ * parameters. If you set them they will stop being optional.
+ */
+export declare function Configurator(): IConfigurator<{}>;
+export {};
+//# sourceMappingURL=Configurator.d.ts.map

package/dist/runtime/src/runtime/state/Configurator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Configurator.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/state/Configurator.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAE9C,KAAK,IAAI,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAS/D,MAAM,WAAW,aAAa,CAAC,CAAC,GAAG,EAAE;IACnC,GAAG,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EAAE,EAAE,GAAG;SAAG,CAAC,IAAI,CAAC,GAAG,CAAC;KAAE,EAC3C,GAAG,EAAE,CAAC,EACN,KAAK,EAAE,CAAC,GACP,OAAO,CAAC,IAAI,IAAI,aAAa,CAAC,iBAAiB,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;IAC5D,MAAM,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,CAAC,EAC/B,GAAG,EAAE,CAAC,GACL,OAAO,CAAC,IAAI,IAAI,aAAa,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IAChE,IAAI,IAAI,CAAC,CAAC;CACX;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,YAAY,sBA0B3B"}

package/dist/runtime/src/runtime/state/Configurator.js

@@ -0,0 +1,55 @@
+function omit(obj, ...removals) {
+    const untyped = removals;
+    return Object.fromEntries(Object.entries(obj).filter(([key]) => !untyped.includes(key)));
+}
+/**
+ * **Configurator**
+ *
+ * This function provides a configurator which uses TypeScript assertions
+ * to narrow the scope of variables. Using type assertions though means we
+ * can't also return values and therefore a _fluent_ API style is not possible.
+ *
+ * Note: this approach does require, that you explicitly use the `IConfigurator`
+ * interface exported by this library. Without it you'd getting annoying TS errors
+ * on every call to `set()` but adding it is simple enough:
+ *
+ * ```ts
+ * import { Configurator, IConfigurator } from "inferred-types";
+ * const config: IConfigurator = Configurator();
+ * ```
+ *
+ * If you want to specify some guideline params which you expect to be set, you
+ * can add them like so:
+ *
+ * ```ts
+ * export type IExpected = { foo: number, bar: string };
+ * const config: IConfigurator<IExpected> = Configurator<IExpected>();
+ * ```
+ *
+ * This configuration will ensure that `foo` and `bar` will be seen as optional
+ * parameters. If you set them they will stop being optional.
+ */
+export function Configurator() {
+    let configuration = () => ({});
+    const api = () => {
+        return {
+            set(key, value) {
+                const keyValue = { [key]: value };
+                const config = configuration();
+                const updated = { ...config, ...keyValue };
+                configuration = () => updated;
+                return updated;
+            },
+            remove(key) {
+                const config = configuration();
+                const updated = omit(config, key);
+                configuration = () => updated;
+                return updated;
+            },
+            done() {
+                return configuration();
+            },
+        };
+    };
+    return api();
+}

package/dist/runtime/src/runtime/state/FluentConfigurator.d.ts

@@ -0,0 +1,28 @@
+import { ExpandRecursively } from "src/types";
+export interface IFluentConfigurator<C> {
+    /**
+     * **set**
+     *
+     * Sets a new key/value pair to the configurator.
+     *
+     * @param key the key to put this new configuration item
+     * @param value the value of the configuration item
+     */
+    set<V, K extends string, KV = {
+        [U in K]: V;
+    }>(key: K, value: V): IFluentConfigurator<C & KV>;
+    done(): ExpandRecursively<C>;
+}
+/**
+ * This function will return a basic _configurator_ API surface which allows
+ * you to add name/value pairs to a growing dictionary of strongly typed data.
+ *
+ * When configuration is complete, you call the `done()` endpoint and the typed
+ * configuration will be returned with the API removed.
+ *
+ * > **Note:** the approach taken here requires that you configure using a **fluent style**
+ * exclusively. If you don't the non-fluent properties set will not show up
+ * in the typing or the run-time object.
+ */
+export declare function FluentConfigurator<I>(initial?: I): IFluentConfigurator<{}>;
+//# sourceMappingURL=FluentConfigurator.d.ts.map

package/dist/runtime/src/runtime/state/FluentConfigurator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FluentConfigurator.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/state/FluentConfigurator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAE9C,MAAM,WAAW,mBAAmB,CAAC,CAAC;IACpC;;;;;;;OAOG;IACH,GAAG,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EAAE,EAAE,GAAG;SAAG,CAAC,IAAI,CAAC,GAAG,CAAC;KAAE,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,mBAAmB,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC;IAC9F,IAAI,IAAI,iBAAiB,CAAC,CAAC,CAAC,CAAC;CAC9B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,OAAO,GAAE,CAAW,2BAsBzD"}

package/dist/runtime/src/runtime/state/FluentConfigurator.js

@@ -0,0 +1,29 @@
+/**
+ * This function will return a basic _configurator_ API surface which allows
+ * you to add name/value pairs to a growing dictionary of strongly typed data.
+ *
+ * When configuration is complete, you call the `done()` endpoint and the typed
+ * configuration will be returned with the API removed.
+ *
+ * > **Note:** the approach taken here requires that you configure using a **fluent style**
+ * exclusively. If you don't the non-fluent properties set will not show up
+ * in the typing or the run-time object.
+ */
+export function FluentConfigurator(initial = {}) {
+    const api = (current) => {
+        return {
+            set(key, value) {
+                const keyValue = { [key]: value };
+                const updated = { ...keyValue, ...current };
+                return api(updated);
+            },
+            done() {
+                return current;
+            },
+        };
+    };
+    if (initial && typeof initial !== "object") {
+        throw new Error("The FluentConfigurator was passed a non-object based value as the initial value. This is not allowed.");
+    }
+    return initial ? api(initial) : api({});
+}

package/dist/runtime/src/runtime/state/index.d.ts

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

package/dist/runtime/src/runtime/state/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/state/index.ts"],"names":[],"mappings":"AAMA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC"}

package/dist/runtime/src/runtime/state/index.js

@@ -0,0 +1,10 @@
+// #autoindex
+// #region auto-indexed files
+// index last changed at: 8th Aug, 2022, 09:51 AM ( GMT-7 )
+// hash-code: 397c607b
+// file exports
+export * from "./Configurator";
+export * from "./FluentConfigurator";
+// #endregion auto-indexed files
+// see https://github.com/inocan-group/do-devops/docs/autoindex.md
+// for more info