inferred-types 0.37.6 → 0.40.2

package/dist/src/runtime/boolean-logic/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/runtime/boolean-logic/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AAExB,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC"}

package/dist/src/runtime/boolean-logic/index.js

@@ -0,0 +1,21 @@
+export * from "./ifArray";
+export * from "./ifBoolean";
+export * from "./ifNumber";
+export * from "./ifString";
+export * from "./ifNotNull";
+export * from "./ifSameType";
+export * from "./ifFunction";
+export * from "./ifContainer";
+export * from "./ifHasKey";
+export * from "./ifLength";
+export * from "./ifScalar";
+export * from "./ifNull";
+export * from "./ifObject";
+export * from "./ifTrue";
+export * from "./ifFalse";
+export * from "./ifChar";
+export * from "./ifRef";
+// export * from "./ifStartsWith";
+export * from "./ifUndefined";
+export * from "./ifArrayPartial";
+// export * from "./ifTypeOf";

package/dist/src/runtime/combinators/and.d.ts

@@ -0,0 +1,7 @@
+import type { And } from "src/types";
+/**
+ * Groups a number of "logic functions" together by combining their results using
+ * the logical **AND** operator
+ */
+export declare const and: <TList extends readonly boolean[]>(...values: TList) => And<TList, []>;
+//# sourceMappingURL=and.d.ts.map

package/dist/src/runtime/combinators/and.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"and.d.ts","sourceRoot":"","sources":["../../../../src/runtime/combinators/and.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAErC;;;GAGG;AACH,eAAO,MAAM,GAAG,wEAIf,CAAC"}

package/dist/src/runtime/combinators/and.js

@@ -0,0 +1,7 @@
+/**
+ * Groups a number of "logic functions" together by combining their results using
+ * the logical **AND** operator
+ */
+export const and = (...values) => {
+    return values.every(i => i === true);
+};

package/dist/src/runtime/combinators/filter.d.ts

@@ -0,0 +1,85 @@
+import { LogicalCombinator } from "src/types";
+export type FilterStarts = {
+    /** one or more string which the value is allowed to start with */
+    startsWith: string | string[];
+};
+export type FilterIs = {
+    /** whether a string _**is**_ of a particular value */
+    is: string | string[];
+};
+export type FilterEnds = {
+    endsWith: string | string[];
+};
+export type FilterContains = {
+    /** whether any of the strings specified are _contained_ in the value */
+    contains: string | string[];
+};
+export type FilterEquals = {
+    /** one or more values which _equal_ the value passed in */
+    equals: number | number[];
+};
+export type FilterNotEqual = {
+    /** one or more values which ALL _do not equal_ the value passed in */
+    notEqual: number | number[];
+};
+export type FilterGreaterThan = {
+    /** the incoming value is greater than this value */
+    greaterThan: number;
+};
+export type FilterLessThan = {
+    /** the incoming value is less than this value */
+    lessThan: number;
+};
+export type StringFilter = FilterIs | FilterStarts | FilterEnds | FilterContains | (FilterStarts & FilterEnds) | (FilterStarts & FilterContains) | (FilterEnds & FilterContains) | (FilterStarts & FilterEnds & FilterContains);
+export type NumericFilter = FilterEquals | FilterNotEqual | FilterGreaterThan | FilterLessThan | (FilterEquals & FilterNotEqual) | (FilterEquals & FilterGreaterThan) | (FilterEquals & FilterLessThan) | (FilterNotEqual & FilterGreaterThan) | (FilterNotEqual & FilterLessThan) | (FilterGreaterThan & FilterLessThan) | (FilterEquals & FilterGreaterThan & FilterLessThan) | (FilterNotEqual & FilterGreaterThan & FilterLessThan) | (FilterEquals & FilterNotEqual & FilterGreaterThan & FilterLessThan);
+export type FilterDefn = StringFilter | NumericFilter;
+export type NotFilter = {
+    /**
+     * **not**
+     *
+     * If you want to build a filter who's conditions being met results in _filtering_
+     * the value rather than accepting it then choose this.
+     */
+    not: FilterDefn;
+};
+export declare function isNotFilter(f: FilterDefn | NotFilter): f is NotFilter;
+export type UnwrapNot<T extends FilterDefn | NotFilter> = T extends NotFilter ? T["not"] extends StringFilter ? StringFilter : NumericFilter : T;
+export declare function isNumericFilter(filter: FilterDefn): filter is NumericFilter;
+export type UndefinedValue<U extends boolean> = true extends U ? "undefined treated as 'true'" : U extends "no-impact" ? "undefined treated in no-impact fashion" : "undefined treated as 'false'";
+export type UndefinedTreatment = "undefined treated as 'true'" | "undefined treated as 'false'";
+/**
+ * **FilterFn**
+ *
+ * A filter function derived from the `filter()` configurator. This function is intended to provide a type-strong _filter_ function which can be used like so:
+ * be used like:
+ * ```ts
+ * const onlyPrivate = filter({ startsWith: "_" });
+ * const privateFiles = files.filter(onlyPrivate);
+ * ```
+ */
+export type FilterFn<T extends StringFilter | NumericFilter> = T extends StringFilter ? <V extends string | undefined>(input: V) => boolean : <V extends number | undefined>(input: V) => boolean;
+/**
+ * Defines a logical function for each condition type
+ */
+export type ConditionFilter<T extends StringFilter | NumericFilter> = T extends StringFilter ? (input: string) => boolean : (input: number) => boolean;
+/**
+ * **filter**
+ *
+ * A higher order helper utility which builds a boolean _filter_ function based on a simple
+ * configuration object. Support either _string_ or _numeric_ filters.
+ *
+ * ```ts
+ * const str = filter({startsWith: ["_", "."], endsWith: ".md"});
+ * const num = filter({ greaterThan: 55, notEqual: [66, 77]});
+ * ```
+ *
+ * All conditions (e.g., `startsWith`, `contains`, `notEqual`, etc.) that a particular filter
+ * is defined as having -- if there is more than one -- will be logically combined using AND
+ * unless specified otherwise in the third parameter.
+ *
+ * How a value of _undefined_ will be treated is stated in the second parameter but defaults
+ * to "no-impact" which means it's `false` when the logicCombinator is OR but defaults
+ * to `true` when the logicCombinator is AND.
+ */
+export declare const createFilter: <F extends FilterDefn | NotFilter, C extends LogicalCombinator, U extends boolean | "no-impact">(config: F, logicCombinator?: C, ifUndefined?: U) => FilterFn<UnwrapNot<F>>;
+//# sourceMappingURL=filter.d.ts.map

package/dist/src/runtime/combinators/filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../../../src/runtime/combinators/filter.ts"],"names":[],"mappings":"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"}

package/dist/src/runtime/combinators/filter.js

@@ -0,0 +1,118 @@
+import { asArray } from "src/runtime";
+export function isNotFilter(f) {
+    return typeof f === "object" && "not" in f;
+}
+export function isNumericFilter(filter) {
+    return "equals" in filter ||
+        "notEqual" in filter ||
+        "greaterThan" in filter ||
+        "lessThan" in filter
+        ? true
+        : false;
+}
+/**
+ * Wraps numeric filter's configuration into a logic filter
+ */
+const numericOps = (config, boolLogic) => {
+    const equals = (n) => {
+        const f = asArray(n);
+        return f.length === 0 ? [] : [(input) => f.some((i) => i === input)];
+    };
+    const notEqual = (n) => {
+        const f = asArray(n);
+        return f.length === 0 ? [] : [(input) => f.every((i) => i !== input)];
+    };
+    /** returns 1 FilterFn's */
+    const greaterThan = (n) => {
+        const val = [(input) => input !== undefined && input > n];
+        return val;
+    };
+    /** returns 0 or 1 FilterFn's */
+    const lessThan = (n) => {
+        const val = [(input) => input !== undefined && input < n];
+        return val;
+    };
+    const conditions = [
+        //
+        ...("equals" in config ? equals(config.equals) : []),
+        ...("notEqual" in config ? notEqual(config.notEqual) : []),
+        ...("greaterThan" in config ? greaterThan(config.greaterThan) : []),
+        ...("lessThan" in config ? lessThan(config.lessThan) : []),
+    ];
+    const combined = boolLogic === "AND"
+        ? (input) => conditions.every((c) => c(input))
+        : (input) => conditions.some((c) => c(input));
+    return combined;
+};
+/** wraps configuration along with boolean logic  */
+const stringOps = (config, boolLogic) => {
+    const startsWith = (n) => {
+        const f = asArray(n);
+        return f.length === 0 ? [] : [(input) => f.some((i) => input?.startsWith(i))];
+    };
+    const endsWith = (n) => {
+        const f = asArray(n);
+        return f.length === 0 ? [] : [(input) => f.some((i) => input?.endsWith(i))];
+    };
+    const contains = (n) => {
+        const f = asArray(n);
+        return f.length === 0 ? [] : [(input) => f.some((i) => input?.includes(i))];
+    };
+    const conditions = [
+        ...("startsWith" in config ? startsWith(config.startsWith) : []),
+        ...("endsWith" in config ? endsWith(config.endsWith) : []),
+        ...("contains" in config ? contains(config.contains) : []),
+    ];
+    const combined = boolLogic === "AND"
+        ? (input) => conditions.every((c) => c(input))
+        : (input) => conditions.some((c) => c(input));
+    return combined;
+};
+const filterFn = (defn, logicCombinator, ifUndefined = "no-impact") => {
+    const config = isNotFilter(defn) ? defn["not"] : defn;
+    const filter = (
+    //
+    input) => {
+        const undefValue = ifUndefined === "no-impact"
+            ? logicCombinator === "AND"
+                ? true
+                : false
+            : ifUndefined;
+        let flag;
+        if (typeof input === "undefined") {
+            flag = undefValue;
+        }
+        else if (isNumericFilter(config)) {
+            const fn = numericOps(config, logicCombinator);
+            flag = isNotFilter(defn) ? !fn(input) : fn(input);
+        }
+        else {
+            const fn = stringOps(config, logicCombinator);
+            flag = isNotFilter(defn) ? !fn(input) : fn(input);
+        }
+        return flag;
+    };
+    return filter;
+};
+/**
+ * **filter**
+ *
+ * A higher order helper utility which builds a boolean _filter_ function based on a simple
+ * configuration object. Support either _string_ or _numeric_ filters.
+ *
+ * ```ts
+ * const str = filter({startsWith: ["_", "."], endsWith: ".md"});
+ * const num = filter({ greaterThan: 55, notEqual: [66, 77]});
+ * ```
+ *
+ * All conditions (e.g., `startsWith`, `contains`, `notEqual`, etc.) that a particular filter
+ * is defined as having -- if there is more than one -- will be logically combined using AND
+ * unless specified otherwise in the third parameter.
+ *
+ * How a value of _undefined_ will be treated is stated in the second parameter but defaults
+ * to "no-impact" which means it's `false` when the logicCombinator is OR but defaults
+ * to `true` when the logicCombinator is AND.
+ */
+export const createFilter = (config, logicCombinator = "AND", ifUndefined = "no-impact") => {
+    return filterFn(config, logicCombinator, ifUndefined);
+};

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

@@ -0,0 +1,4 @@
+export * from "./and";
+export * from "./or";
+export * from "./filter";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/runtime/combinators/index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC;AACtB,cAAc,MAAM,CAAC;AACrB,cAAc,UAAU,CAAC"}

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

@@ -0,0 +1,3 @@
+export * from "./and";
+export * from "./or";
+export * from "./filter";

package/dist/src/runtime/combinators/or.d.ts

@@ -0,0 +1,9 @@
+import type { Or } from "src/types";
+/**
+ * **or**(conditions) -> boolean
+ *
+ * If you have a discrete list of boolean values then you can use this
+ * function to perform a logical OR operation on them.
+ */
+export declare function or<TList extends readonly boolean[]>(...conditions: TList): Or<TList>;
+//# sourceMappingURL=or.d.ts.map

package/dist/src/runtime/combinators/or.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"or.d.ts","sourceRoot":"","sources":["../../../../src/runtime/combinators/or.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,WAAW,CAAC;AAEpC;;;;;GAKG;AACH,wBAAgB,EAAE,CAAC,KAAK,SAAS,SAAS,OAAO,EAAE,EAAE,GAAG,UAAU,EAAE,KAAK,aAExE"}

package/dist/src/runtime/combinators/or.js

@@ -0,0 +1,9 @@
+/**
+ * **or**(conditions) -> boolean
+ *
+ * If you have a discrete list of boolean values then you can use this
+ * function to perform a logical OR operation on them.
+ */
+export function or(...conditions) {
+    return (conditions.some((v) => v === true) ? true : false);
+}

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

@@ -0,0 +1,12 @@
+/**
+ * Passing in an array of strings, you are passed back a dictionary with
+ * all the keys being the strings and values set to `true`.
+ * ```ts
+ * // { bar: true, bar: true } as const;
+ * const d - dictArr(arr);
+ *
+ * const fooBar = arrayToKeyLookup("foo", "bar");
+ * ```
+ */
+export declare function arrayToKeyLookup<T extends readonly string[]>(...keys: T): Record<T[number], true>;
+//# sourceMappingURL=arrayToKeyLookup.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"arrayToKeyLookup.d.ts","sourceRoot":"","sources":["../../../../src/runtime/dictionary/arrayToKeyLookup.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,SAAS,MAAM,EAAE,EAAE,GAAG,IAAI,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,CAQjG"}

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

@@ -0,0 +1,17 @@
+/**
+ * Passing in an array of strings, you are passed back a dictionary with
+ * all the keys being the strings and values set to `true`.
+ * ```ts
+ * // { bar: true, bar: true } as const;
+ * const d - dictArr(arr);
+ *
+ * const fooBar = arrayToKeyLookup("foo", "bar");
+ * ```
+ */
+export function arrayToKeyLookup(...keys) {
+    const obj = {};
+    for (const key of keys) {
+        obj[key] = true;
+    }
+    return obj;
+}

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

@@ -0,0 +1,18 @@
+import { KeyValue, Narrowable } from "src/types";
+/**
+ * **entries**
+ *
+ * Provides an _iterable_ over the passed in dictionary object where each iteration
+ * provides a tuple of `[ key, value ]` which preserve type literals.
+ *
+ * For example:
+ * ```ts
+ * const obj = { foo: 1, bar: "hi" };
+ * // k type is "foo" then "bar"; v type is 1 then "hi"
+ * for (const [k, v] of entries(obj)) { ... }
+ * ```
+ */
+export declare function entries<N extends Narrowable, T extends Record<PropertyKey, N>, I extends KeyValue<T, keyof T>>(obj: T): {
+    [Symbol.iterator](): Generator<I, void, unknown>;
+};
+//# sourceMappingURL=entries.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"entries.d.ts","sourceRoot":"","sources":["../../../../src/runtime/dictionary/entries.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAGjD;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CACrB,CAAC,SAAS,UAAU,EACpB,CAAC,SAAS,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC,EAChC,CAAC,SAAS,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,EAC9B,GAAG,EAAE,CAAC;;EAWP"}

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

@@ -0,0 +1,25 @@
+import { keysOf } from "src/runtime";
+/**
+ * **entries**
+ *
+ * Provides an _iterable_ over the passed in dictionary object where each iteration
+ * provides a tuple of `[ key, value ]` which preserve type literals.
+ *
+ * For example:
+ * ```ts
+ * const obj = { foo: 1, bar: "hi" };
+ * // k type is "foo" then "bar"; v type is 1 then "hi"
+ * for (const [k, v] of entries(obj)) { ... }
+ * ```
+ */
+export function entries(obj) {
+    const iterable = {
+        *[Symbol.iterator]() {
+            for (const k of keysOf(obj)) {
+                // const [k, v] = entry as KeyValue<T, First<typeof entry>>;
+                yield [k, obj[k]];
+            }
+        },
+    };
+    return iterable;
+}

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

@@ -0,0 +1,37 @@
+import type { Narrowable, DotPathFor, Get, Suggest } from "src/types";
+import { NoDefaultValue, NotDefined } from "src/constants";
+export interface GetOptions<TDefVal extends Narrowable, TInvalid extends Narrowable> {
+    /**
+     * Typically when getting a valid dotpath and the value evaluates to _undefined_
+     * then the value returned is _undefined_ but if you'd prefer to put something else
+     * in here you may.
+     */
+    defaultValue?: TDefVal;
+    /**
+     * Typically when a dotpath is invalid for a given item then this item
+     * is set as a `ErrorCondition<'invalid-dot-path'>` but if you'd like
+     * to set it to something else you may.
+     *
+     * Note: a common replacement would be the `Never` constant from this library
+     * as it "reports" as being `never` but allows for a more sophisticated
+     * handling process to follow.
+     */
+    handleInvalidDotpath?: TInvalid;
+}
+/**
+ * **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 declare function get<TValue extends Narrowable | readonly unknown[], TDotPath extends Suggest<DotPathFor<TValue>>, TDefVal extends Narrowable = NoDefaultValue, TInvalid extends Narrowable = NotDefined>(value: TValue, dotPath: TDotPath | null, options?: GetOptions<TDefVal, TInvalid>): Get<TValue, TDotPath>;
+//# sourceMappingURL=get.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get.d.ts","sourceRoot":"","sources":["../../../../src/runtime/dictionary/get.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,UAAU,EACV,GAAG,EACH,OAAO,EAIR,MAAM,WAAW,CAAC;AACnB,OAAO,EAEL,cAAc,EACd,UAAU,EAEX,MAAM,eAAe,CAAC;AAwFvB,MAAM,WAAW,UAAU,CACzB,OAAO,SAAS,UAAU,EAC1B,QAAQ,SAAS,UAAU;IAE3B;;;;OAIG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;;;;;;OAQG;IACH,oBAAoB,CAAC,EAAE,QAAQ,CAAC;CACjC;AAGD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,GAAG,CACjB,MAAM,SAAS,UAAU,GAAG,SAAS,OAAO,EAAE,EAC9C,QAAQ,SAAS,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,EAC5C,OAAO,SAAS,UAAU,GAAG,cAAc,EAC3C,QAAQ,SAAS,UAAU,GAAG,UAAU,EAEtC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,QAAQ,GAAG,IAAI,EACxB,OAAO,GAAE,UAAU,CAAC,OAAO,EAAE,QAAQ,CAGH,yBAcrC"}

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