inferred-types 0.37.5 → 0.40.1

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

@@ -0,0 +1,65 @@
+import { NO_DEFAULT_VALUE, NOT_DEFINED } from "src/constants";
+import { hasDefaultValue, isTruthy, isRef, hasIndexOf, isSpecificConstant, createErrorCondition, split, isContainer, } from "src/runtime";
+/** updates based on whether segment is a Ref or not */
+function updatedDotPath(value, dotpath, segment) {
+    return isRef(value)
+        ? dotpath.replace(segment, `Ref(${segment})`)
+        : dotpath;
+}
+/**
+ * **getValue**(value, dotpath, defaultValue, handler, fullDotPath)
+ */
+function getValue(value, dotPath, defaultValue, handleInvalid, fullDotPath) {
+    /** the remaining segments that need processing */
+    const pathSegments = isTruthy(dotPath)
+        ? split(dotPath, ".") || []
+        : [];
+    /** current index property */
+    const idx = pathSegments[0];
+    /**
+     * dotpath _will_ need to recurse further to
+     * reach destination
+     **/
+    const hasMoreSegments = pathSegments.length > 1;
+    /** whether or not the value is indexable or not */
+    const valueIsIndexable = isContainer(value) && hasIndexOf(value, idx);
+    /** has handler for invalid dotpath */
+    const hasHandler = !isSpecificConstant("not-defined")(handleInvalid);
+    const errors = createErrorCondition(`get(value, "${updatedDotPath(value, fullDotPath, idx)}", ${hasDefaultValue(defaultValue) ? `${String(defaultValue)}` : "[defValue]"})`);
+    const invalidDotPath = errors("invalid-dot-path")(`The segment "${idx}" in the dotpath "${fullDotPath}" was not indexable and no default value existed on: ${JSON.stringify(value)}`);
+    const current = (hasMoreSegments
+        ? isContainer(value) && hasIndexOf(value, idx)
+            ? getValue(value[idx], pathSegments.join(".").replace(`${idx}.`, ""), defaultValue, handleInvalid, updatedDotPath(value, fullDotPath, idx))
+            : hasHandler
+                ? handleInvalid
+                : invalidDotPath
+        : valueIsIndexable
+            ? hasDefaultValue(hasDefaultValue)
+                ? value[idx] || defaultValue
+                : value[idx]
+            : hasHandler ? handleInvalid : invalidDotPath);
+    return current;
+}
+/**
+ * **get**(obj, dotPath, [defVal])
+ *
+ * Gets a value in a deeply nested object while attempting to preserve type information
+ * (a default value is allowed as optional param).
+ *
+ * - if the dot-path is invalid then an `ErrorCondition` will be returned, unless
+ * a defaultValue is provided in which case this will be returned instead
+ * - this function is also VueJS _aware_ in the sense that it can also traverse
+ * VueJS `ref` properties when encountered
+ *
+ * ```ts
+ * const prop = get(obj, "foo.bar.baz", "nothing there chief!");
+ * ```
+ */
+export function get(value, dotPath, options = {
+    defaultValue: NO_DEFAULT_VALUE,
+    handleInvalidDotpath: NOT_DEFINED
+}) {
+    return (dotPath === null || dotPath === ""
+        ? value
+        : getValue(value, dotPath, options?.defaultValue || NO_DEFAULT_VALUE, options?.handleInvalidDotpath || NOT_DEFINED, String(dotPath)));
+}

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

@@ -0,0 +1,14 @@
+export * from "./arrayToKeyLookup";
+export * from "./entries";
+export * from "./get";
+export * from "./keysOf";
+export * from "./mapValues";
+export * from "./omit";
+export * from "./retain";
+export * from "./sharedKeys";
+export * from "./strArrayToDict";
+export * from "./withKeys";
+export * from "./withoutKeys";
+export * from "./withValue";
+export * from "./withoutValue";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/dictionary/index.ts"],"names":[],"mappings":"AAMA,cAAc,oBAAoB,CAAC;AACnC,cAAc,WAAW,CAAC;AAC1B,cAAc,OAAO,CAAC;AACtB,cAAc,UAAU,CAAC;AAEzB,cAAc,aAAa,CAAC;AAC5B,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC"}

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

@@ -0,0 +1,22 @@
+// #autoindex
+// #region auto-indexed files
+// index last changed at: 8th Aug, 2022, 09:51 AM ( GMT-7 )
+// hash-code: b0051c37
+// file exports
+export * from "./arrayToKeyLookup";
+export * from "./entries";
+export * from "./get";
+export * from "./keysOf";
+// export * from "./mapTo";
+export * from "./mapValues";
+export * from "./omit";
+export * from "./retain";
+export * from "./sharedKeys";
+export * from "./strArrayToDict";
+export * from "./withKeys";
+export * from "./withoutKeys";
+export * from "./withValue";
+export * from "./withoutValue";
+// #endregion auto-indexed files
+// see https://github.com/inocan-group/do-devops/docs/autoindex.md
+// for more info

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

@@ -0,0 +1,12 @@
+import type { Container, IsRef, Keys } from "src/types";
+/**
+ * **keysOf**(container)
+ *
+ * Provides a read-only array of the _keys_ an object (or array) contains.
+ *
+ * **Note:** this function is aware of Ref<T> types from VueJS and will return
+ * `readonly ["value"]` as the keys array when detected rather than reporting
+ * on props like `__v_isRef`, etc.
+ */
+export declare function keysOf<TContainer extends Container>(container: TContainer): IsRef<TContainer> extends true ? readonly ["value"] : Keys<TContainer>;
+//# sourceMappingURL=keysOf.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"keysOf.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/dictionary/keysOf.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAG,SAAS,EAAG,KAAK,EAAG,IAAI,EAAE,MAAM,WAAW,CAAC;AAG3D;;;;;;;;GAQG;AACH,wBAAgB,MAAM,CACpB,UAAU,SAAS,SAAS,EAE5B,SAAS,EAAE,UAAU,GACpB,KAAK,CAAC,UAAU,CAAC,SAAS,IAAI,GAAG,SAAS,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,CAaxE"}

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

@@ -0,0 +1,19 @@
+import { isObject, isReadonlyArray, isRef } from "src/runtime";
+/**
+ * **keysOf**(container)
+ *
+ * Provides a read-only array of the _keys_ an object (or array) contains.
+ *
+ * **Note:** this function is aware of Ref<T> types from VueJS and will return
+ * `readonly ["value"]` as the keys array when detected rather than reporting
+ * on props like `__v_isRef`, etc.
+ */
+export function keysOf(container) {
+    return (isReadonlyArray(container)
+        ? Object.keys(container).map(i => Number(i))
+        : isObject(container)
+            ? isRef(container)
+                ? ["value"]
+                : Object.keys(container)
+            : []);
+}

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

@@ -0,0 +1,14 @@
+import { Narrowable } from "src/types";
+/**
+ * **mapValues**
+ *
+ * Maps over a dictionary, preserving the keys but allowing the values to be mutated.
+ *
+ * ```ts
+ * const colors = { red: 4, blue: 2, green: 3 };
+ * // { red: 8, blue: 4, green: 6 }
+ * const twoX = mapValues(colors, v => v * 2);
+ * ```
+ */
+export declare function mapValues<N extends Narrowable, T extends Record<string, N>, V>(obj: T, valueMapper: (k: T[keyof T]) => V): { [K in keyof T]: V; };
+//# sourceMappingURL=mapValues.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mapValues.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/dictionary/mapValues.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAGvC;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,EAC5E,GAAG,EAAE,CAAC,EACN,WAAW,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,0BAMlC"}

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

@@ -0,0 +1,17 @@
+import { entries } from "src/runtime";
+/**
+ * **mapValues**
+ *
+ * Maps over a dictionary, preserving the keys but allowing the values to be mutated.
+ *
+ * ```ts
+ * const colors = { red: 4, blue: 2, green: 3 };
+ * // { red: 8, blue: 4, green: 6 }
+ * const twoX = mapValues(colors, v => v * 2);
+ * ```
+ */
+export function mapValues(obj, valueMapper) {
+    return Object.fromEntries(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    [...entries(obj)].map(([k, v]) => [k, valueMapper(v)]));
+}

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

@@ -0,0 +1,25 @@
+import type { Narrowable, WithoutKeys, ErrorCondition, HasUnionType, ObjectKey } from "src/types";
+/**
+ * **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 declare function omit<TObj extends Record<ObjectKey, N>, N extends Narrowable, TKeys extends readonly ObjectKey[] = readonly []>(obj: TObj, ...removeKeys: TKeys): HasUnionType<TKeys> extends true ? 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: typeof removeKeys;
+    };
+    library: "omit";
+}> : WithoutKeys<TObj, TKeys>;
+//# sourceMappingURL=omit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"omit.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/dictionary/omit.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAG,cAAc,EAAE,YAAY,EAAG,SAAS,EAAE,MAAM,WAAW,CAAC;AAGpG;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,IAAI,CAClB,IAAI,SAAS,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC,EACjC,CAAC,SAAS,UAAU,EACpB,KAAK,SAAS,SAAS,SAAS,EAAE,GAAG,SAAS,EAAE,EAChD,GAAG,EAAE,IAAI,EAAE,GAAG,UAAU,EAAE,KAAK;;cAeP,iBAAiB;;aAAY,MAAM;8BAG5D"}

package/dist/runtime/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/runtime/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/runtime/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/runtime/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/runtime/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/runtime/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/runtime/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/runtime/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/runtime/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/runtime/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/runtime/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/runtime/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/runtime/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/runtime/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/runtime/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/runtime/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/runtime/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/runtime/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/runtime/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/runtime/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/runtime/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/runtime/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/runtime/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/runtime/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/runtime/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/runtime/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/runtime/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/runtime/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/runtime/src/runtime/errors/index.d.ts

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

package/dist/runtime/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/runtime/src/runtime/errors/index.js

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

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

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

package/dist/runtime/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/runtime/src/runtime/functional/index.js

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

package/dist/runtime/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/runtime/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"}