inferred-types 0.51.0 → 0.51.2

package/dist/runtime/boolean-logic/ifString.d.ts

@@ -0,0 +1,14 @@
+import { If, IsFalse, IsString, IsTrue, Narrowable } from "inferred-types/dist/types/index";
+/**
+ * **ifString**
+ *
+ * Strongly type-aware conditional statement which checks whether a value is
+ * a _string_ and returns one of two values (strongly typed) based on the evaluation
+ * of this criteria.
+ *
+ * @param val the value being tested for being a string
+ * @param ifVal the value (strongly typed) returned if val is _string_
+ * @param elseVal the value (strongly typed) returned if val is NOT a _string
+ */
+export declare function ifString<TContent, TIf extends Narrowable, TElse extends Narrowable>(val: TContent, ifVal: <V extends TContent & string>(t: V & TContent) => TIf, elseVal: <V extends Exclude<TContent, string>>(v: V & TContent) => TElse): If<IsTrue<IsString<TContent>>, TIf, If<IsFalse<IsString<TContent>>, TElse, TIf | TElse>>;
+//# sourceMappingURL=ifString.d.ts.map

package/dist/runtime/boolean-logic/ifString.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ifString.d.ts","sourceRoot":"","sources":["../../../src/runtime/boolean-logic/ifString.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAI5F;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CACtB,QAAQ,EACR,GAAG,SAAS,UAAU,EACtB,KAAK,SAAS,UAAU,EAExB,GAAG,EAAE,QAAQ,EACb,KAAK,EAAE,CAAC,CAAC,SAAS,QAAQ,GAAG,MAAM,EAAE,CAAC,EAAE,CAAC,GAAG,QAAQ,KAAK,GAAG,EAC5D,OAAO,EAAE,CAAC,CAAC,SAAS,OAAO,CAAC,QAAQ,EAAE,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,QAAQ,KAAK,KAAK,GAOtE,EAAE,CACA,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,EAC1B,GAAG,EACH,EAAE,CAAC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,GAAG,KAAK,CAAC,CACpD,CAGJ"}

package/dist/runtime/boolean-logic/ifString.js

@@ -0,0 +1,16 @@
+/**
+ * **ifString**
+ *
+ * Strongly type-aware conditional statement which checks whether a value is
+ * a _string_ and returns one of two values (strongly typed) based on the evaluation
+ * of this criteria.
+ *
+ * @param val the value being tested for being a string
+ * @param ifVal the value (strongly typed) returned if val is _string_
+ * @param elseVal the value (strongly typed) returned if val is NOT a _string
+ */
+export function ifString(val, ifVal, elseVal) {
+    return (typeof val === "string"
+        ? ifVal(val)
+        : elseVal(val));
+}

package/dist/runtime/boolean-logic/ifTrue.d.ts

@@ -0,0 +1,13 @@
+import { IsFalse, IsTrue, Narrowable } from "inferred-types/dist/types/index";
+/**
+ * **ifTrue**
+ *
+ * Strongly type-aware conditional statement which checks whether a value is
+ * _true_. Valid outcomes are:
+ *
+ * - **IF** - returned when T is narrowly typed as `true`
+ * - **ELSE** - returned when T is narrowly typed as `false`
+ * - **IF | ELSE** - returned when T is a `boolean` type
+ */
+export declare function ifTrue<TContent extends Narrowable, TIf extends Narrowable, TElse extends Narrowable>(val: TContent, ifVal: <V extends TContent & true>(val: V) => TIf, elseVal: <V extends Exclude<TContent, true>>(val: V) => TElse): [IsTrue<TContent>] extends [true] ? TIf : [IsFalse<TContent>] extends [true] ? TElse : TIf | TElse;
+//# sourceMappingURL=ifTrue.d.ts.map

package/dist/runtime/boolean-logic/ifTrue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ifTrue.d.ts","sourceRoot":"","sources":["../../../src/runtime/boolean-logic/ifTrue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAI9E;;;;;;;;;GASG;AACH,wBAAgB,MAAM,CACpB,QAAQ,SAAS,UAAU,EAC3B,GAAG,SAAS,UAAU,EACtB,KAAK,SAAS,UAAU,EAExB,GAAG,EAAE,QAAQ,EACb,KAAK,EAAE,CAAC,CAAC,SAAS,QAAQ,GAAG,IAAI,EAAE,GAAG,EAAE,CAAC,KAAK,GAAG,EACjD,OAAO,EAAE,CAAC,CAAC,SAAS,OAAO,CAAC,QAAQ,EAAE,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,KAAK,GAQ3D,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC/B,GAAG,GACH,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,KAAK,GAAG,GAAG,GAAG,KAAK,CAC7D"}

package/dist/runtime/boolean-logic/ifTrue.js

@@ -0,0 +1,18 @@
+import { isTrue } from "src/runtime/index";
+/**
+ * **ifTrue**
+ *
+ * Strongly type-aware conditional statement which checks whether a value is
+ * _true_. Valid outcomes are:
+ *
+ * - **IF** - returned when T is narrowly typed as `true`
+ * - **ELSE** - returned when T is narrowly typed as `false`
+ * - **IF | ELSE** - returned when T is a `boolean` type
+ */
+export function ifTrue(val, ifVal, elseVal) {
+    return (
+    //
+    isTrue(val)
+        ? ifVal(val)
+        : elseVal(val));
+}

package/dist/runtime/boolean-logic/ifUndefined.d.ts

@@ -0,0 +1,15 @@
+import { IsUndefined, Narrowable } from "inferred-types/dist/types/index";
+/**
+ * **ifUndefined**
+ *
+ * Strongly type-aware conditional statement which checks whether a value is
+ * _undefined_ and returns one of two values (strongly typed) based on the evaluation
+ * of this criteria.
+ *
+ * @param val the value being tested
+ * @param ifVal the value (strongly typed) returned if val is `undefined`
+ * @param elseVal the value (strongly typed) returned if val is NOT `undefined`
+ */
+export declare function ifUndefined<T extends Narrowable, IF extends Narrowable = undefined, ELSE extends Narrowable = Exclude<T, undefined>>(val: T, ifUndefined: () => IF, ifDefined: <V extends Exclude<T, undefined>>(v: V) => ELSE): IsUndefined<T> extends true ? IF : ELSE;
+export declare function ifDefined<T extends Narrowable, IF extends Narrowable = Exclude<T, undefined>, ELSE extends Narrowable = undefined>(val: T, ifVal: <V extends Exclude<T, undefined>>(v: V) => IF, elseVal: () => ELSE): (<V extends Exclude<T, undefined>>(v: V) => IF) | (() => ELSE);
+//# sourceMappingURL=ifUndefined.d.ts.map

package/dist/runtime/boolean-logic/ifUndefined.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ifUndefined.d.ts","sourceRoot":"","sources":["../../../src/runtime/boolean-logic/ifUndefined.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAG1E;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CACzB,CAAC,SAAS,UAAU,EACpB,EAAE,SAAS,UAAU,GAAG,SAAS,EACjC,IAAI,SAAS,UAAU,GAAG,OAAO,CAAC,CAAC,EAAE,SAAS,CAAC,EAE/C,GAAG,EAAE,CAAC,EACN,WAAW,EAAE,MAAM,EAAE,EACrB,SAAS,EAAE,CAAC,CAAC,SAAS,OAAO,CAAC,CAAC,EAAC,SAAS,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,IAAI,GAIpD,WAAW,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,EAAE,GAAG,IAAI,CAC7C;AAED,wBAAgB,SAAS,CACvB,CAAC,SAAS,UAAU,EACpB,EAAE,SAAS,UAAU,GAAG,OAAO,CAAC,CAAC,EAAE,SAAS,CAAC,EAC7C,IAAI,SAAS,UAAU,GAAG,SAAS,EAEnC,GAAG,EAAE,CAAC,EACN,KAAK,EAAE,CAAC,CAAC,SAAS,OAAO,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,EAAE,EACpD,OAAO,EAAE,MAAM,IAAI,KADX,CAAC,SAAS,OAAO,CAAC,CAAC,EAAE,SAAS,CAAC,KAAK,CAAC,KAAK,EAAE,WACrC,IAAI,EAGpB"}

package/dist/runtime/boolean-logic/ifUndefined.js

@@ -0,0 +1,18 @@
+import { isDefined, isUndefined } from "src/runtime/index";
+/**
+ * **ifUndefined**
+ *
+ * Strongly type-aware conditional statement which checks whether a value is
+ * _undefined_ and returns one of two values (strongly typed) based on the evaluation
+ * of this criteria.
+ *
+ * @param val the value being tested
+ * @param ifVal the value (strongly typed) returned if val is `undefined`
+ * @param elseVal the value (strongly typed) returned if val is NOT `undefined`
+ */
+export function ifUndefined(val, ifUndefined, ifDefined) {
+    return (isUndefined(val) ? ifUndefined() : ifDefined(val));
+}
+export function ifDefined(val, ifVal, elseVal) {
+    return isDefined(val) ? ifVal : elseVal;
+}

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

@@ -0,0 +1,19 @@
+export * from "./ifArray";
+export * from "./ifBoolean";
+export * from "./ifNumber";
+export * from "./ifNotNull";
+export * from "./ifSameType";
+export * from "./ifContainer";
+export * from "./ifHasKey";
+export * from "./ifLength";
+export * from "./ifScalar";
+export * from "./ifNull";
+export * from "./ifObject";
+export * from "./ifTrue";
+export * from "./ifFunction";
+export * from "./ifFalse";
+export * from "./ifChar";
+export * from "./ifString";
+export * from "./ifUndefined";
+export * from "./ifArrayPartial";
+//# sourceMappingURL=index.d.ts.map

package/dist/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,aAAa,CAAC;AAC5B,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,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC"}

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

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

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

@@ -0,0 +1,7 @@
+import type { And } from "inferred-types/dist/types/index";
+/**
+ * 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/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,iCAAiC,CAAC;AAE3D;;;GAGG;AACH,eAAO,MAAM,GAAG,GACd,KAAK,SAAS,SAAS,OAAO,EAAE,aACrB,KAAK,KAAG,GAAG,CAAC,KAAK,CAE7B,CAAC"}

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

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

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

package/dist/runtime/combinators/index.js

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

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

@@ -0,0 +1,9 @@
+import type { Or } from "inferred-types/dist/types/index";
+/**
+ * **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/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,iCAAiC,CAAC;AAE1D;;;;;GAKG;AACH,wBAAgB,EAAE,CAAC,KAAK,SAAS,SAAS,OAAO,EAAE,EAAE,GAAG,UAAU,EAAE,KAAK,GAGtD,EAAE,CAAC,KAAK,CAAC,CAC3B"}

package/dist/runtime/combinators/or.js

@@ -0,0 +1,10 @@
+/**
+ * **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) {
+    const values = conditions.some((v) => v === true ? true : false);
+    return values;
+}

package/dist/runtime/dictionary/defineOptions.d.ts

@@ -0,0 +1,26 @@
+import { Dictionary, MakeKeysRequired, RequiredKeys } from "inferred-types/dist/types/index";
+export type UserOptions<TDefn extends Dictionary, TReq extends ((string | symbol) & keyof TDefn)> = TReq extends "" ? <T extends Partial<TDefn>, R extends TDefn>(opt?: T) => R & {
+    param: MakeKeysRequired<Partial<TDefn>, TReq>;
+} : TReq extends readonly (keyof TDefn)[] ? <T extends MakeKeysRequired<Partial<TDefn>, TReq>, R extends TDefn>(opt: T) => R & {
+    param: MakeKeysRequired<Partial<TDefn>, TReq>;
+} : never;
+export type AsUserOptions<TDefn extends Dictionary, _TDefaults extends Partial<TDefn>> = UserOptions<TDefn, RequiredKeys<TDefn>>;
+/**
+ * **defineOptions**`<T>(def_values?: () => { .. }) → UserOptions<T, TReq>`
+ *
+ * Defines:
+ *   1. a set of options,
+ *   2. allows default values to be assigned,
+ *   3. then provides
+ * a type for user input which makes all properties that were optional or have
+ * a default value be optional while also providing a type-strong merge function
+ * to merge in their results.
+ * ```ts
+ * // {
+ * //    userOptions: {width?: number; height: number}},
+ * //    merge<U>(user: U) => T
+ * // }
+ * const opts = defineOptions<{width: number; height: number}() => ({width: 640});
+ * ```
+ */
+//# sourceMappingURL=defineOptions.d.ts.map

package/dist/runtime/dictionary/defineOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineOptions.d.ts","sourceRoot":"","sources":["../../../src/runtime/dictionary/defineOptions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EAGV,gBAAgB,EAChB,YAAY,EACb,MAAM,iCAAiC,CAAA;AAMxC,MAAM,MAAM,WAAW,CACrB,KAAK,SAAS,UAAU,EACxB,IAAI,SAAS,CAAC,CAAC,MAAM,GAAC,MAAM,CAAC,GAAG,MAAM,KAAK,CAAC,IAC1C,IAAI,SAAS,EAAE,GACjB,CACE,CAAC,SAAS,OAAO,CAAC,KAAK,CAAC,EACxB,CAAC,SAAS,KAAK,EACf,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG;IAAE,KAAK,EAAE,gBAAgB,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,CAAA;CAAE,GACnE,IAAI,SAAS,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,GACrC,CACE,CAAC,SAAS,gBAAgB,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,EAChD,CAAC,SAAS,KAAK,EACf,GAAG,EAAE,CAAC,KAAK,CAAC,GAAG;IAAE,KAAK,EAAE,gBAAgB,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,CAAA;CAAE,GAClE,KAAK,CAAC;AAGR,MAAM,MAAM,aAAa,CACvB,KAAK,SAAS,UAAU,EACxB,UAAU,SAAS,OAAO,CAAC,KAAK,CAAC,IAC/B,WAAW,CACf,KAAK,EACL,YAAY,CAAC,KAAK,CAAC,CAClB,CAAC;AAiBF;;;;;;;;;;;;;;;;;GAiBG"}

package/dist/runtime/dictionary/defineOptions.js

@@ -0,0 +1,30 @@
+import { createFnWithProps, } from "src/runtime/index";
+const _userOptions = (def_values) => createFnWithProps((opt) => {
+    return {
+        ...def_values,
+        opt
+    };
+}, { param: null });
+/**
+ * **defineOptions**`<T>(def_values?: () => { .. }) → UserOptions<T, TReq>`
+ *
+ * Defines:
+ *   1. a set of options,
+ *   2. allows default values to be assigned,
+ *   3. then provides
+ * a type for user input which makes all properties that were optional or have
+ * a default value be optional while also providing a type-strong merge function
+ * to merge in their results.
+ * ```ts
+ * // {
+ * //    userOptions: {width?: number; height: number}},
+ * //    merge<U>(user: U) => T
+ * // }
+ * const opts = defineOptions<{width: number; height: number}() => ({width: 640});
+ * ```
+ */
+// export const defineOptions = <
+//   T extends Dictionary
+// >(a: ({defaults: (<D extends Partial<T>>() => D)): void) => {
+//   return userOptions(cb());
+// };

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

@@ -0,0 +1,18 @@
+import { KeyValue, Narrowable } from "inferred-types/dist/types/index";
+/**
+ * **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/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,iCAAiC,CAAC;AAIvE;;;;;;;;;;;;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/runtime/dictionary/entries.js

@@ -0,0 +1,25 @@
+import { keysOf } from "src/runtime/index";
+/**
+ * **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/runtime/dictionary/get.d.ts

@@ -0,0 +1,37 @@
+import type { Narrowable, DotPathFor, Get, Suggest } from "inferred-types/dist/types/index";
+import { NoDefaultValue, NotDefined } from "inferred-types/dist/constants/index";
+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/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,EAGR,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAEL,cAAc,EACd,UAAU,EAEX,MAAM,qCAAqC,CAAC;AA0F7C,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,GAcP,GAAG,CAAC,MAAM,EAAC,QAAQ,CAAC,CAClD"}

package/dist/runtime/dictionary/get.js

@@ -0,0 +1,65 @@
+import { NO_DEFAULT_VALUE, NOT_DEFINED } from "inferred-types/dist/constants/index";
+import { createErrorCondition, isTruthy, hasIndexOf, isSpecificConstant, hasDefaultValue, isContainer, isRef, indexOf } from "inferred-types/dist/runtime/index";
+/** 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)
+        ? dotPath.split(".")
+        : [];
+    /** 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 invalidDotPath = createErrorCondition("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) && idx in value
+            ? getValue(indexOf(value, idx), pathSegments.join(".").replace(`${idx}.`, ""), defaultValue, handleInvalid, updatedDotPath(value, fullDotPath, idx))
+            : hasHandler
+                ? handleInvalid
+                : invalidDotPath
+        : valueIsIndexable
+            ? hasDefaultValue(hasDefaultValue)
+                ? (indexOf(value, idx) || defaultValue)
+                : indexOf(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
+}) {
+    const outcome = (dotPath === null || dotPath === ""
+        ? value
+        : getValue(value, dotPath, options?.defaultValue || NO_DEFAULT_VALUE, options?.handleInvalidDotpath || NOT_DEFINED, String(dotPath)));
+    return outcome;
+}

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

@@ -0,0 +1,13 @@
+export * from "./entries";
+export * from "./get";
+export * from "./keysOf";
+export * from "./omit";
+export * from "./retain";
+export * from "./sharedKeys";
+export * from "./takeProp";
+export * from "./withKeys";
+export * from "./withoutKeys";
+export * from "./withoutValue";
+export * from "./withDefaults";
+export * from "./valuesOf";
+//# sourceMappingURL=index.d.ts.map

package/dist/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,WAAW,CAAC;AAC1B,cAAc,OAAO,CAAC;AACtB,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC"}

package/dist/runtime/dictionary/index.js

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

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

@@ -0,0 +1,12 @@
+import type { Container, Keys } from "inferred-types/dist/types/index";
+/**
+ * **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): Keys<TContainer> & (keyof TContainer)[];
+//# sourceMappingURL=keysOf.d.ts.map

package/dist/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,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,iCAAiC,CAAC;AAIvE;;;;;;;;GAQG;AACH,wBAAgB,MAAM,CAAC,UAAU,SAAS,SAAS,EACjD,SAAS,EAAE,UAAU,GAYN,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,UAAU,CAAC,EAAE,CACvD"}

package/dist/runtime/dictionary/keysOf.js

@@ -0,0 +1,20 @@
+import { isObject, isRef } from "src/runtime/index";
+/**
+ * **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) {
+    const keys = (Array.isArray(container)
+        ? Object.keys(container).map(i => Number(i))
+        : isObject(container)
+            ? isRef(container)
+                ? ["value"]
+                : Object.keys(container)
+            : []);
+    return keys;
+}

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

@@ -0,0 +1,20 @@
+import type { Narrowable, WithoutKeys, ObjectKey } from "inferred-types/dist/types/index";
+/**
+ * **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): WithoutKeys<TObj, TKeys>;
+//# sourceMappingURL=omit.d.ts.map

package/dist/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,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAG3F;;;;;;;;;;;;;;;;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,GAWf,WAAW,CAAC,IAAI,EAAE,KAAK,CAAC,CAEzC"}

package/dist/runtime/dictionary/omit.js

@@ -0,0 +1,27 @@
+/* eslint-disable no-use-before-define */
+/**
+ * **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 = Object.keys(obj);
+    return keys.reduce((acc, key) => removeKeys.includes(key)
+        ? acc
+        : {
+            ...acc,
+            [key]: obj[key]
+        }, {});
+}

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

@@ -0,0 +1,13 @@
+import { Throw, HasUnionType, NarrowObject, Narrowable, ObjectKey, WithKeys } from "inferred-types/dist/types/index";
+/**
+ * **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 ? Throw<"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.", "retain()", {
+    keys: TKeys;
+}> : WithKeys<TObj, TKeys>;
+//# sourceMappingURL=retain.d.ts.map

package/dist/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,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,UAAU,EAAG,SAAS,EAAG,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAEvH;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,GACjB,CAAC,SAAS,UAAU,EACpB,IAAI,SAAS,YAAY,CAAC,CAAC,CAAC,EAC5B,KAAK,SAAS,SAAS,CAAC,SAAS,GAAG,MAAM,IAAI,CAAC,EAAE,QAE3C,IAAI,WACD,KAAK,KAUc,YAAY,CAAC,KAAK,CAAC,SAAS,IAAI,GAC1D,KAAK,CACH,eAAe,EACf,yRAAyR,EACzR,UAAU,EACV;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,CAChB,GACD,QAAQ,CAAC,IAAI,EAAE,KAAK,CACvB,CAAC"}

package/dist/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/dictionary/sharedKeys.d.ts

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

package/dist/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,EAAE,QAAQ,EAAa,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAE7F;;;;GAIG;AACH,eAAO,MAAM,UAAU,GACrB,CAAC,SAAS,SAAS,GAAG,MAAM,EAC5B,CAAC,SAAS,SAAS,GAAG,MAAM,KACzB,CAAC,KAAK,CAAC,KAAG,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAKjD,CAAC"}