inferred-types 0.37.6 → 0.40.2

package/dist/src/runtime/dictionary/omit.js

@@ -0,0 +1,27 @@
+import { keysOf } from "src/runtime";
+/**
+ * **omit**(obj, excluding)
+ *
+ * Runtime utility which _excludes_ certain **keys** from an object.
+ *
+ * - this utility is meant to mimic the type utility `Omit<T,U>` provided
+ * by Typescript in runtime
+ * - attempts will be made to extract the narrowest possible type from
+ * the passed in object.
+ *
+ * ```ts
+ * // { baz: 3 }
+ * const obj = omit({ foo: 1, bar: 2: baz: 3 }, "foo", "bar");
+ * ```
+ *
+ * **Related:** `createOmission`, `withoutKeys`
+ */
+export function omit(obj, ...removeKeys) {
+    const keys = keysOf(obj);
+    return keys.reduce((acc, key) => removeKeys.includes(key)
+        ? acc
+        : {
+            ...acc,
+            [key]: obj[key]
+        }, {});
+}

package/dist/src/runtime/dictionary/retain.d.ts

@@ -0,0 +1,16 @@
+import { ErrorCondition, HasUnionType, NarrowObject, Narrowable, ObjectKey, WithKeys } from "src/types";
+/**
+ * **retain**(obj,...keys)
+ *
+ * Reduces the key/value pairs in an object to those keys
+ * explicitly stated.
+ *
+ * **Related:** `createRetainer`, `omit`
+ */
+export declare const retain: <N extends Narrowable, TObj extends NarrowObject<N>, TKeys extends readonly (ObjectKey & keyof TObj)[]>(dict: TObj, ...keys: TKeys) => HasUnionType<TKeys> extends true ? ErrorCondition<"invalid-union", "the retain(obj, keys) function was called with keys which included a value which was a union type; this would make the typing inconsistent with the runtime type and should be avoided. Note that at runtime this will not produce an error but rather produce the valid runtime value.", {
+    context: {
+        keys: TKeys;
+    };
+    library: "retain";
+}> : WithKeys<TObj, TKeys>;
+//# sourceMappingURL=retain.d.ts.map

package/dist/src/runtime/dictionary/retain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retain.d.ts","sourceRoot":"","sources":["../../../../src/runtime/dictionary/retain.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,YAAY,EAAE,UAAU,EAAG,SAAS,EAAG,QAAQ,EAAE,MAAM,WAAW,CAAC;AAE1G;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM;;;;aAoB2B,QAAQ;0BAGrD,CAAC"}

package/dist/src/runtime/dictionary/retain.js

@@ -0,0 +1,18 @@
+/**
+ * **retain**(obj,...keys)
+ *
+ * Reduces the key/value pairs in an object to those keys
+ * explicitly stated.
+ *
+ * **Related:** `createRetainer`, `omit`
+ */
+export const retain = (dict, ...keys) => {
+    let output = {};
+    for (const k of keys) {
+        output = {
+            ...output,
+            [k]: dict[k]
+        };
+    }
+    return output;
+};

package/dist/src/runtime/dictionary/sharedKeys.d.ts

@@ -0,0 +1,8 @@
+import { AnyObject, SharedKeys } from "src/types";
+/**
+ * **sharedKeys**
+ *
+ * Runtime utility which provides the _shared_ keys between two objects.
+ */
+export declare const sharedKeys: <A extends AnyObject, B extends AnyObject>(a: A, b: B) => SharedKeys<A, B>;
+//# sourceMappingURL=sharedKeys.d.ts.map

package/dist/src/runtime/dictionary/sharedKeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sharedKeys.d.ts","sourceRoot":"","sources":["../../../../src/runtime/dictionary/sharedKeys.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAa,UAAU,EAAE,MAAM,WAAW,CAAC;AAE7D;;;;GAIG;AACH,eAAO,MAAM,UAAU,4EAQtB,CAAC"}

package/dist/src/runtime/dictionary/sharedKeys.js

@@ -0,0 +1,10 @@
+/**
+ * **sharedKeys**
+ *
+ * Runtime utility which provides the _shared_ keys between two objects.
+ */
+export const sharedKeys = (a, b) => {
+    const ka = Object.keys(a);
+    const kb = Object.keys(b);
+    return ka.filter(k => kb.includes(k));
+};

package/dist/src/runtime/dictionary/strArrayToDict.d.ts

@@ -0,0 +1,7 @@
+import { ExpandRecursively } from "src/types";
+/**
+ * converts an array of strings `["a", "b", "c"]` into a more type friendly
+ * dictionary of the type `{ a: true, b: true, c: true }`
+ */
+export declare function strArrayToDict<T extends readonly string[]>(...strings: T): ExpandRecursively<Record<T[number], true>>;
+//# sourceMappingURL=strArrayToDict.d.ts.map

package/dist/src/runtime/dictionary/strArrayToDict.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strArrayToDict.d.ts","sourceRoot":"","sources":["../../../../src/runtime/dictionary/strArrayToDict.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAE9C;;;GAGG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,SAAS,MAAM,EAAE,EAAE,GAAG,OAAO,EAAE,CAAC,8CAKxE"}

package/dist/src/runtime/dictionary/strArrayToDict.js

@@ -0,0 +1,10 @@
+/**
+ * converts an array of strings `["a", "b", "c"]` into a more type friendly
+ * dictionary of the type `{ a: true, b: true, c: true }`
+ */
+export function strArrayToDict(...strings) {
+    return strings.reduce((acc, str) => {
+        acc = { ...acc, [str]: true };
+        return acc;
+    }, {});
+}

package/dist/src/runtime/dictionary/withKeys.d.ts

@@ -0,0 +1,16 @@
+import type { Narrowable, ObjectKey } from "src/types";
+/**
+ * **withKeys**(obj,keys)
+ *
+ * Reduces the key/value pairs in an object to those keys
+ * explicitly stated.
+ *
+ * - note: this function is an alias for `retain()`
+ */
+export declare const withKeys: <TObj extends Record<string | symbol, N>, N extends Narrowable, TKeys extends readonly (ObjectKey & keyof TObj)[]>(dict: TObj, ...keys: TKeys) => ([] extends [...TKeys] ? false : import("src/types").IfUnion<import("src/types").First<[...TKeys]>, true, [] extends import("src/types").AfterFirst<[...TKeys]> ? false : import("src/types").IfUnion<import("src/types").First<import("src/types").AfterFirst<[...TKeys]>>, true, [] extends import("src/types").AfterFirst<import("src/types").AfterFirst<[...TKeys]>> ? false : true>>) extends true ? import("src/types").ErrorCondition<"invalid-union", "the retain(obj, keys) function was called with keys which included a value which was a union type; this would make the typing inconsistent with the runtime type and should be avoided. Note that at runtime this will not produce an error but rather produce the valid runtime value.", {
+    context: {
+        keys: [...TKeys];
+    };
+    library: "retain";
+}> : import("src/types").ExpandRecursively<import("src/types").UnionToIntersection<([...TKeys] extends infer T ? T extends [...TKeys] ? T extends readonly PropertyKey[] ? import("src/types").TupleToUnion<T> : T : never : never) extends keyof TObj ? Pick<TObj, keyof TObj & ([...TKeys] extends infer T_1 ? T_1 extends [...TKeys] ? T_1 extends readonly PropertyKey[] ? import("src/types").TupleToUnion<T_1> : T_1 : never : never)> : never>>;
+//# sourceMappingURL=withKeys.d.ts.map

package/dist/src/runtime/dictionary/withKeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withKeys.d.ts","sourceRoot":"","sources":["../../../../src/runtime/dictionary/withKeys.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAGvD;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ;;;;;sbAOK,CAAC"}

package/dist/src/runtime/dictionary/withKeys.js

@@ -0,0 +1,10 @@
+import { retain } from "src/runtime";
+/**
+ * **withKeys**(obj,keys)
+ *
+ * Reduces the key/value pairs in an object to those keys
+ * explicitly stated.
+ *
+ * - note: this function is an alias for `retain()`
+ */
+export const withKeys = (dict, ...keys) => retain(dict, ...keys);

package/dist/src/runtime/dictionary/withValue.d.ts

@@ -0,0 +1,26 @@
+import { AnyObject, Narrowable, WithValue } from "src/types";
+import { KindApi } from "src/runtime";
+/**
+ * **WithValuePartial**`<TReturn>`
+ *
+ * A runtime utility function which receives an object of some structure
+ * and then reduces this to only key/value pairs where the _values_ extend
+ * the `TReturn` type.
+ */
+export type WithValuePartial<TReturn> = <TObj extends AnyObject>(obj: TObj) => WithValue<TObj, TReturn>;
+/**
+ * **withValue**
+ *
+ * Reduces a dictionary object -- in both _type_ and _run-time_ structure -- to only those
+ * key/value pairs which _do not have_ a specified value. For instance:
+ *
+ * ```ts
+ * const obj = { foo: 1, bar: 2, message: "hi there" };
+ * // { message: "hi there" }
+ * const onlyStrings = withoutValue(t => t.string())(obj);
+ * // { foo: 1 }
+ * const justOne = withoutValue(t => t.literal(1))(obj);
+ * ```
+ */
+export declare const withValue: <N extends Narrowable, TApi extends (t: KindApi) => N>(cb: TApi) => <TObj extends AnyObject>(obj: TObj) => WithValue<TObj, ReturnType<TApi>>;
+//# sourceMappingURL=withValue.d.ts.map

package/dist/src/runtime/dictionary/withValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withValue.d.ts","sourceRoot":"","sources":["../../../../src/runtime/dictionary/withValue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAG,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAC9D,OAAO,EAAE,OAAO,EAAoB,MAAM,aAAa,CAAC;AAExD;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,CAAC,OAAO,IAAI,CACtC,IAAI,SAAS,SAAS,EACtB,GAAG,EAAE,IAAI,KAAK,SAAS,CAAC,IAAI,EAAC,OAAO,CAAC,CAAC;AAExC;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,SAAS,0CAEH,OAAO,6FAYvB,CAAC"}

package/dist/src/runtime/dictionary/withValue.js

@@ -0,0 +1,21 @@
+import { kind, isSameType } from "src/runtime";
+/**
+ * **withValue**
+ *
+ * Reduces a dictionary object -- in both _type_ and _run-time_ structure -- to only those
+ * key/value pairs which _do not have_ a specified value. For instance:
+ *
+ * ```ts
+ * const obj = { foo: 1, bar: 2, message: "hi there" };
+ * // { message: "hi there" }
+ * const onlyStrings = withoutValue(t => t.string())(obj);
+ * // { foo: 1 }
+ * const justOne = withoutValue(t => t.literal(1))(obj);
+ * ```
+ */
+export const withValue = (cb) => (obj) => {
+    const newObj = Object.keys(obj).reduce((acc, key) => key in obj && isSameType(obj[key], cb(kind))
+        ? ({ ...acc, [key]: obj[key] })
+        : acc, {});
+    return newObj;
+};

package/dist/src/runtime/dictionary/withoutKeys.d.ts

@@ -0,0 +1,18 @@
+import type { NarrowObject, Narrowable } from "src/types";
+/**
+ * **withoutKeys**(obj,...keys)
+ *
+ * Reduces the key/value pairs in an object with the expressed
+ * keys excluded.
+ *
+ * - this is an alias to the `omit()` utility
+ *
+ * **Related**: `omit`, `createOmission`
+ */
+export declare const withoutKeys: <TObj extends NarrowObject<N>, N extends Narrowable, TKeys extends readonly (string & keyof TObj)[]>(dict: TObj, ...exclude: TKeys) => ([] extends [...TKeys] ? false : import("src/types").IfUnion<import("src/types").First<[...TKeys]>, true, [] extends import("src/types").AfterFirst<[...TKeys]> ? false : import("src/types").IfUnion<import("src/types").First<import("src/types").AfterFirst<[...TKeys]>>, true, [] extends import("src/types").AfterFirst<import("src/types").AfterFirst<[...TKeys]>> ? false : true>>) extends true ? import("src/types").ErrorCondition<"invalid-union", "the omit(obj, keys) function was called with keys which included a value which was a union type; this would make the typing inconsistent with the runtime type and should be avoided. Note that at runtime this will not produce an error but rather produce the valid runtime value.", {
+    context: {
+        keys: [...TKeys];
+    };
+    library: "omit";
+}> : import("src/types").IfLength<import("src/types").AsArray<[...TKeys]>, 0, TObj, import("src/types").ExpandRecursively<Omit<TObj, import("src/types").TupleToUnion<import("src/types").AsArray<[...TKeys]>>>> extends import("src/types").EmptyObject ? import("src/types").EmptyObject : import("src/types").ExpandRecursively<Omit<TObj, import("src/types").TupleToUnion<import("src/types").AsArray<[...TKeys]>>>>, TObj | (import("src/types").ExpandRecursively<Omit<TObj, import("src/types").TupleToUnion<import("src/types").AsArray<[...TKeys]>>>> extends import("src/types").EmptyObject ? import("src/types").EmptyObject : import("src/types").ExpandRecursively<Omit<TObj, import("src/types").TupleToUnion<import("src/types").AsArray<[...TKeys]>>>>)>;
+//# sourceMappingURL=withoutKeys.d.ts.map

package/dist/src/runtime/dictionary/withoutKeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withoutKeys.d.ts","sourceRoot":"","sources":["../../../../src/runtime/dictionary/withoutKeys.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAG1D;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW;;;;;0uBAOG,CAAC"}

package/dist/src/runtime/dictionary/withoutKeys.js

@@ -0,0 +1,12 @@
+import { omit } from "src/runtime";
+/**
+ * **withoutKeys**(obj,...keys)
+ *
+ * Reduces the key/value pairs in an object with the expressed
+ * keys excluded.
+ *
+ * - this is an alias to the `omit()` utility
+ *
+ * **Related**: `omit`, `createOmission`
+ */
+export const withoutKeys = (dict, ...exclude) => omit(dict, ...exclude);

package/dist/src/runtime/dictionary/withoutValue.d.ts

@@ -0,0 +1,17 @@
+import { AnyObject, Narrowable, WithoutValue } from "src/types";
+/**
+ * **withoutValue**
+ *
+ * Reduces a dictionary object -- in both _type_ and _run-time_ structure -- to only those
+ * key/value pairs which _do not have_ a specified value. For instance:
+ *
+ * ```ts
+ * const obj = { foo: 1, bar: 2, message: "hi there" };
+ * // { message: "hi there" }
+ * const onlyStrings = withoutValue(t => kind.string())(obj);
+ * // { foo: 1 }
+ * const justOne = withoutValue(t => kind.literal(1))(obj);
+ * ```
+ */
+export declare function withoutValue<TVal extends Narrowable>(val: TVal): <TObj extends AnyObject>(obj: TObj) => WithoutValue<TObj, TVal>;
+//# sourceMappingURL=withoutValue.d.ts.map

package/dist/src/runtime/dictionary/withoutValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withoutValue.d.ts","sourceRoot":"","sources":["../../../../src/runtime/dictionary/withoutValue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAEhE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAAC,IAAI,SAAS,UAAU,EAAE,GAAG,EAAE,IAAI,mEAS9D"}

package/dist/src/runtime/dictionary/withoutValue.js

@@ -0,0 +1,21 @@
+/**
+ * **withoutValue**
+ *
+ * Reduces a dictionary object -- in both _type_ and _run-time_ structure -- to only those
+ * key/value pairs which _do not have_ a specified value. For instance:
+ *
+ * ```ts
+ * const obj = { foo: 1, bar: 2, message: "hi there" };
+ * // { message: "hi there" }
+ * const onlyStrings = withoutValue(t => kind.string())(obj);
+ * // { foo: 1 }
+ * const justOne = withoutValue(t => kind.literal(1))(obj);
+ * ```
+ */
+export function withoutValue(val) {
+    return (obj) => {
+        return Object.keys(obj).reduce((acc, key) => val === obj[key]
+            ? acc
+            : ({ ...acc, [key]: obj[key] }), {});
+    };
+}

package/dist/src/runtime/errors/TypedError.d.ts

@@ -0,0 +1,31 @@
+import { AnyObject, Narrowable } from "src/types";
+export interface TypedError<TKind extends string = string, TMsg extends string = string, TContext extends AnyObject = AnyObject> extends Error {
+    kind: TKind;
+    msg: TMsg;
+    context: TContext;
+    stack?: string;
+}
+/**
+ * **KindedApi**
+ *
+ * An error builder where the `kind` property has already been set.
+ */
+export type KindedApi<TKind extends string> = <TMsg extends string, K extends PropertyKey, V extends Narrowable, TContext extends Record<K, V>>(msg: TMsg, context?: TContext) => TypedError<TKind, TMsg, TContext>;
+export type ErrorApi = {
+    /**
+     * A simple API surface to create an error with a `kind` and `msg` type.
+     */
+    kinded<TKind extends string, TMsg extends string>(kind: TKind, msg: TMsg): TypedError<TMsg, TKind>;
+    /**
+     * Allows expressing the `kind` of error initially
+     * and then provides a function to supply specific
+     * errors.
+     */
+    asKind<TKind extends string>(kind: TKind): KindedApi<TKind>;
+};
+export declare const TypedError: (<TMsg extends string>(msg: TMsg) => {
+    kind: "unknown";
+    msg: TMsg;
+    context: {};
+}) & ErrorApi;
+//# sourceMappingURL=TypedError.d.ts.map

package/dist/src/runtime/errors/TypedError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypedError.d.ts","sourceRoot":"","sources":["../../../../src/runtime/errors/TypedError.ts"],"names":[],"mappings":"AAEA,OAAO,EAAI,SAAS,EAAkB,UAAU,EAAI,MAAM,WAAW,CAAC;AAEtE,MAAM,WAAW,UAAU,CACzB,KAAK,SAAS,MAAM,GAAG,MAAM,EAC7B,IAAI,SAAS,MAAM,GAAG,MAAM,EAC5B,QAAQ,SAAS,SAAS,GAAG,SAAS,CACtC,SAAQ,KAAK;IACb,IAAI,EAAE,KAAK,CAAC;IACZ,GAAG,EAAE,IAAI,CAAC;IACV,OAAO,EAAE,QAAQ,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,MAAM,MAAM,SAAS,CAAC,KAAK,SAAS,MAAM,IAAI,CAC5C,IAAI,SAAS,MAAM,EACnB,CAAC,SAAS,WAAW,EACrB,CAAC,SAAS,UAAU,EACpB,QAAQ,SAAS,MAAM,CAAC,CAAC,EAAC,CAAC,CAAC,EAC5B,GAAG,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,QAAQ,KAAK,UAAU,CAAC,KAAK,EAAC,IAAI,EAAC,QAAQ,CAAC,CAAC;AAEpE,MAAM,MAAM,QAAQ,GAAG;IACrB;;OAEG;IACH,MAAM,CAAC,KAAK,SAAS,MAAM,EAAE,IAAI,SAAS,MAAM,EAC9C,IAAI,EAAE,KAAK,EACX,GAAG,EAAE,IAAI,GAAG,UAAU,CAAC,IAAI,EAAC,KAAK,CAAC,CAAC;IAErC;;;;OAIG;IACH,MAAM,CAAC,KAAK,SAAS,MAAM,EAAE,IAAI,EAAE,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;CAC7D,CAAC;AAyBF,eAAO,MAAM,UAAU;;;;aAA2B,CAAC"}

package/dist/src/runtime/errors/TypedError.js

@@ -0,0 +1,16 @@
+import { addFnToProps } from "src/runtime";
+const fn = (kind) => (msg) => ({
+    kind,
+    msg,
+    context: {}
+});
+const api = {
+    kinded: (kind, msg) => fn(kind)(msg),
+    asKind: (kind) => (msg, context) => ({ kind, msg, context: context || {} })
+};
+const basic = (msg) => ({
+    kind: "unknown",
+    msg,
+    context: {}
+});
+export const TypedError = addFnToProps(api)(basic);

package/dist/src/runtime/errors/createErrorCondition.d.ts

@@ -0,0 +1,11 @@
+import { ErrorCondition } from "src/types";
+/**
+ * **createErrorConditionTemplate**(domain) => (kind) => (msg) => ErrorCondition
+ *
+ * A higher order runtime utility for generating reusable `ErrorCondition`'s at
+ * runtime.
+ */
+export declare const createErrorCondition: <TLibrary extends string = "undefined">(library?: TLibrary | undefined) => <TKind extends string>(kind: TKind) => <TMsg extends string = "">(message: TMsg) => ErrorCondition<TKind, TMsg, {
+    library: TLibrary;
+}>;
+//# sourceMappingURL=createErrorCondition.d.ts.map

package/dist/src/runtime/errors/createErrorCondition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createErrorCondition.d.ts","sourceRoot":"","sources":["../../../../src/runtime/errors/createErrorCondition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAE3C;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;;EAahC,CAAC"}

package/dist/src/runtime/errors/createErrorCondition.js

@@ -0,0 +1,14 @@
+/**
+ * **createErrorConditionTemplate**(domain) => (kind) => (msg) => ErrorCondition
+ *
+ * A higher order runtime utility for generating reusable `ErrorCondition`'s at
+ * runtime.
+ */
+export const createErrorCondition = (library) => (kind) => (message) => {
+    return {
+        _type: "ErrorCondition",
+        library,
+        kind,
+        message: message || ""
+    };
+};

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,2 @@
+export * from "./left";
+export * from "./right";

package/dist/src/runtime/functional/left.d.ts

@@ -0,0 +1,8 @@
+import { LeftRight } from "src/types";
+/**
+ * **left**(value)
+ *
+ * Extracts the _left_ value from a `LeftRight` struct.
+ */
+export declare const left: <T extends LeftRight>(value: T) => T[2];
+//# sourceMappingURL=left.d.ts.map

package/dist/src/runtime/functional/left.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"left.d.ts","sourceRoot":"","sources":["../../../../src/runtime/functional/left.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAEtC;;;;GAIG;AACH,eAAO,MAAM,IAAI,yCAAsD,CAAC"}

package/dist/src/runtime/functional/left.js

@@ -0,0 +1,6 @@
+/**
+ * **left**(value)
+ *
+ * Extracts the _left_ value from a `LeftRight` struct.
+ */
+export const left = (value) => value[2];

package/dist/src/runtime/functional/right.d.ts

@@ -0,0 +1,8 @@
+import { LeftRight } from "src/types";
+/**
+ * **left**(value)
+ *
+ * Extracts the _right_ value from a `LeftRight` struct.
+ */
+export declare const right: <T extends LeftRight>(value: T) => T[1];
+//# sourceMappingURL=right.d.ts.map

package/dist/src/runtime/functional/right.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"right.d.ts","sourceRoot":"","sources":["../../../../src/runtime/functional/right.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAEtC;;;;GAIG;AACH,eAAO,MAAM,KAAK,yCAAsD,CAAC"}

package/dist/src/runtime/functional/right.js

@@ -0,0 +1,6 @@
+/**
+ * **left**(value)
+ *
+ * Extracts the _right_ value from a `LeftRight` struct.
+ */
+export const right = (value) => value[1];

package/dist/src/runtime/functions/fnMeta.d.ts

@@ -0,0 +1,20 @@
+import { AnyFunction } from "src/types";
+/**
+ * **fnMeta**(func)
+ *
+ * Runtime utility which provides a `fn` and `props` property which are
+ * decomposed from the input function.
+ *
+ * - the `fn` is a clone of the underlying function
+ */
+export declare const fnMeta: <TFn extends AnyFunction>(func: TFn) => {
+    fn: <A extends Parameters<TFn>>(...args: A) => any;
+    props: import("src/types").IfNever<import("src/types").ExpandRecursively<keyof TFn>, {}, import("src/types").ExpandRecursively<Pick<TFn, import("src/types").ExpandRecursively<keyof TFn>>>> extends {
+        [x: string]: unknown;
+        [x: symbol]: unknown;
+    } ? {
+        [x: string]: unknown;
+        [x: symbol]: unknown;
+    } & import("src/types").IfNever<import("src/types").ExpandRecursively<keyof TFn>, {}, import("src/types").ExpandRecursively<Pick<TFn, import("src/types").ExpandRecursively<keyof TFn>>>> : never;
+};
+//# sourceMappingURL=fnMeta.d.ts.map

package/dist/src/runtime/functions/fnMeta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fnMeta.d.ts","sourceRoot":"","sources":["../../../../src/runtime/functions/fnMeta.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAa,MAAM,WAAW,CAAC;AAInD;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM;;;;;;;;;CAclB,CAAC"}

package/dist/src/runtime/functions/fnMeta.js

@@ -0,0 +1,16 @@
+/**
+ * **fnMeta**(func)
+ *
+ * Runtime utility which provides a `fn` and `props` property which are
+ * decomposed from the input function.
+ *
+ * - the `fn` is a clone of the underlying function
+ */
+export const fnMeta = (func) => {
+    const fn = (...args) => func(...args);
+    const props = Object.keys(fn).reduce((acc, key) => ({ ...acc, [key]: fn[key] }), {});
+    return {
+        fn,
+        props
+    };
+};

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

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

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

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

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

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

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

@@ -0,0 +1,15 @@
+export * from "./boolean-logic/index";
+export * from "./combinators/index";
+export * from "./dictionary/index";
+export * from "./errors/index";
+export * from "./functional/index";
+export * from "./functions/index";
+export * from "./initializers/index";
+export * from "./lists/index";
+export * from "./literals/index";
+export * from "./runtime-types/index";
+export * from "./sets/index";
+export * from "./state/index";
+export * from "./type-conversion/index";
+export * from "./type-guards/index";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime/index.ts"],"names":[],"mappings":"AASA,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,yBAAyB,CAAC;AACxC,cAAc,qBAAqB,CAAC"}

package/dist/src/runtime/index.js

@@ -0,0 +1,23 @@
+// #autoindex
+// #region auto-indexed files
+// index last changed at: 8th Aug, 2022, 09:51 AM ( GMT-7 )
+// hash-code: 9dd9ac96
+// file exports
+// directory exports
+export * from "./boolean-logic/index";
+export * from "./combinators/index";
+export * from "./dictionary/index";
+export * from "./errors/index";
+export * from "./functional/index";
+export * from "./functions/index";
+export * from "./initializers/index";
+export * from "./lists/index";
+export * from "./literals/index";
+export * from "./runtime-types/index";
+export * from "./sets/index";
+export * from "./state/index";
+export * from "./type-conversion/index";
+export * from "./type-guards/index";
+// #endregion auto-indexed files
+// see https://github.com/inocan-group/do-devops/docs/autoindex.md
+// for more info

package/dist/src/runtime/initializers/addFnToProps.d.ts

@@ -0,0 +1,9 @@
+import { AnyFunction, FnWithDict, Narrowable } from "src/types";
+/**
+ * **addPropsToFn**(fn, [clone]) => (props) => FnWithProps
+ *
+ * A higher order function which takes a dictionary object and
+ * then a function and combines them into a single type.
+ */
+export declare const addPropsToFn: <TFn extends AnyFunction, TClone extends boolean | undefined>(fn: TFn, clone_fn?: TClone | undefined) => <K extends PropertyKey, N extends Narrowable, TProps extends Record<K, N>>(obj: TProps) => FnWithDict<TFn, TProps, TClone>;
+//# sourceMappingURL=addFnToProps.d.ts.map

package/dist/src/runtime/initializers/addFnToProps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addFnToProps.d.ts","sourceRoot":"","sources":["../../../../src/runtime/initializers/addFnToProps.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAG,UAAU,EAAE,UAAU,EAAI,MAAM,WAAW,CAAC;AAEnE;;;;;GAKG;AACH,eAAO,MAAM,YAAY,qOAyBxB,CAAC"}

package/dist/src/runtime/initializers/addFnToProps.js

@@ -0,0 +1,17 @@
+/**
+ * **addPropsToFn**(fn, [clone]) => (props) => FnWithProps
+ *
+ * A higher order function which takes a dictionary object and
+ * then a function and combines them into a single type.
+ */
+export const addPropsToFn = (fn, clone_fn) => {
+    const localFn = clone_fn
+        ? (...args) => fn(args)
+        : fn;
+    return (obj) => {
+        for (const k in obj) {
+            localFn[k] = obj[k];
+        }
+        return localFn;
+    };
+};

package/dist/src/runtime/initializers/addPropsToFn.d.ts

@@ -0,0 +1,15 @@
+import { AnyFunction, FnWithDict, Narrowable } from "src/types";
+/**
+ * **addFnToProps**(props, [clone]) => (fn) => FnWithProps
+ *
+ * A higher order function which takes
+ *
+ * - `props` - key/value pairs to add to the a _future_ function
+ * - `clone` - optionally state whether you want to use the future function's
+ * type "as is" or you want to purify it's props with a clone (default is `true`)
+ *
+ * This is partially applied to reveal a function which takes a
+ * function as input.
+ */
+export declare const addFnToProps: <K extends string, N extends Narrowable, TProps extends Record<K, N>, TClone extends boolean | undefined>(props: TProps, clone_fn?: TClone | undefined) => <TFn extends AnyFunction>(fn: TFn) => FnWithDict<TFn, TProps, TClone>;
+//# sourceMappingURL=addPropsToFn.d.ts.map

package/dist/src/runtime/initializers/addPropsToFn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addPropsToFn.d.ts","sourceRoot":"","sources":["../../../../src/runtime/initializers/addPropsToFn.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAG,UAAU,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAEjE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY,kOAmBtB,CAAC"}

package/dist/src/runtime/initializers/addPropsToFn.js

@@ -0,0 +1,23 @@
+/**
+ * **addFnToProps**(props, [clone]) => (fn) => FnWithProps
+ *
+ * A higher order function which takes
+ *
+ * - `props` - key/value pairs to add to the a _future_ function
+ * - `clone` - optionally state whether you want to use the future function's
+ * type "as is" or you want to purify it's props with a clone (default is `true`)
+ *
+ * This is partially applied to reveal a function which takes a
+ * function as input.
+ */
+export const addFnToProps = (props, clone_fn) => (fn) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const localFn = (...args) => fn(args);
+    for (const k in props) {
+        localFn[k] = props[k];
+    }
+    return localFn;
+};
+// export const narrowFn = <
+//   TFn extends AnyFunction
+// >(fn: TFn) => <TArgs extends AsFnMeta<TFn>["args"]>(...args: TArgs) => <R extends AsFnMeta<TFn>["returns"]>(fn(args): R) =>  ;