inferred-types 0.37.5 → 0.40.1

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

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

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

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

package/dist/runtime/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/runtime/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/runtime/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/runtime/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/runtime/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/runtime/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/runtime/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/runtime/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/runtime/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) =>  ;

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

@@ -0,0 +1,25 @@
+import { AsFnMeta, Narrowable, AnyFunction, AnyObject, ObjectKey, FnProps, RemoveFnProps, EmptyObject, RemoveIndexKeys, ToFn } from "src/types";
+type Returns<TFn extends AnyFunction, TProps extends AnyObject> = TProps extends EmptyObject ? TFn : ToFn<AsFnMeta<RemoveFnProps<TFn> & RemoveIndexKeys<FnProps<TFn> & TProps>>>;
+/**
+ * **FnReadyForProps**(props)
+ *
+ * This type is the result of a partial application of the `createFnWithProps()`
+ * utility and is expecting a dictionary of key/value pairs that will be combined
+ * with the function which was already provided.
+ */
+export type FnReadyForProps<TFn extends AnyFunction> = <TProps extends Record<ObjectKey, N>, N extends Narrowable>(props: TProps) => Returns<TFn, TProps>;
+/**
+ * **createFnWithProps**(fn)(params)
+ *
+ * A higher order function which builds a type strong combination of
+ * a function and a dictionary.
+ *
+ * - The preliminary passed into the partial application of this utility
+ * _can_ contain key/value pairs and they will be preserved
+ * - Any keys which overlap between those on the
+ * function and the dictionary passed into fully apply this utility will be
+ * merged with the dictionary props will have precedence.
+ */
+export declare const createFnWithProps: <TFn extends <TArgs extends readonly Narrowable[]>(...args: TArgs) => unknown>(fn: TFn) => FnReadyForProps<TFn>;
+export {};
+//# sourceMappingURL=createFnWithProps.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createFnWithProps.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/initializers/createFnWithProps.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,QAAQ,EACR,UAAU,EACV,WAAW,EACX,SAAS,EACT,SAAS,EACT,OAAO,EACP,aAAa,EACb,WAAW,EACX,eAAe,EACf,IAAI,EACL,MAAM,WAAW,CAAC;AAGnB,KAAK,OAAO,CAAC,GAAG,SAAS,WAAW,EAAE,MAAM,SAAS,SAAS,IAC9D,MAAM,SAAS,WAAW,GACtB,GAAG,GACH,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,GAAG,CAAC,GAAG,eAAe,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;AAEhF;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,CACzB,GAAG,SAAS,WAAW,IACrB,CACF,MAAM,SAAS,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC,EACnC,CAAC,SAAS,UAAU,EACpB,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;AAyBzC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,iBAAiB,wEACyC,OAAO,kCACnD,CAAC"}

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

@@ -0,0 +1,23 @@
+const finalize = (fn) => (props) => {
+    const clone = (...args) => fn(...args);
+    for (const k of Object.keys(fn)) {
+        clone[k] = fn[k];
+    }
+    for (const k of Object.keys(props)) {
+        clone[k] = props[k];
+    }
+    return clone;
+};
+/**
+ * **createFnWithProps**(fn)(params)
+ *
+ * A higher order function which builds a type strong combination of
+ * a function and a dictionary.
+ *
+ * - The preliminary passed into the partial application of this utility
+ * _can_ contain key/value pairs and they will be preserved
+ * - Any keys which overlap between those on the
+ * function and the dictionary passed into fully apply this utility will be
+ * merged with the dictionary props will have precedence.
+ */
+export const createFnWithProps = (fn) => finalize(fn);

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

@@ -0,0 +1,3 @@
+import type { Type, TypeGuard } from "src/types";
+export declare function createTypeGuard<T extends Exclude<Type, "is" | "validate">>(defn: T): T & Record<"is", TypeGuard<T["type"]>>;
+//# sourceMappingURL=createTypeGuard.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createTypeGuard.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/initializers/createTypeGuard.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAEjD,wBAAgB,eAAe,CAC7B,CAAC,SAAS,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,UAAU,CAAC,EAC1C,IAAI,EAAE,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAcjD"}

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

@@ -0,0 +1,14 @@
+export function createTypeGuard(defn) {
+    return {
+        ...defn,
+        /**
+         * **is**(value)
+         *
+         * Type guard which is able to able to identify and narrow the
+         * type definition of a runtime type defined by `Type`
+         */
+        is: (_value) => {
+            return true;
+        }
+    };
+}

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

@@ -0,0 +1,8 @@
+import { Narrowable, TypeTuple, TypeGuard } from "src/types";
+/**
+ * **createTypeTuple**(type, guard, desc)
+ *
+ * Defined a `TypeTuple` based on the inputs provided.
+ */
+export declare function createTypeTuple<T extends Narrowable, D extends string = "">(type: T, guard: TypeGuard<T>, desc?: D): TypeTuple<T, D>;
+//# sourceMappingURL=createTypeTuple.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createTypeTuple.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/initializers/createTypeTuple.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAG,SAAS,EAAG,SAAS,EAAE,MAAM,WAAW,CAAC;AAE/D;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,CAAC,SAAS,UAAU,EACpB,CAAC,SAAS,MAAM,GAAG,EAAE,EACrB,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC,mBAEvC"}

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

@@ -0,0 +1,8 @@
+/**
+ * **createTypeTuple**(type, guard, desc)
+ *
+ * Defined a `TypeTuple` based on the inputs provided.
+ */
+export function createTypeTuple(type, guard, desc) {
+    return [type, guard, desc ? desc : ""];
+}

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

@@ -0,0 +1,6 @@
+import { Type } from "src/types";
+/**
+ * Creates a `validate` function for a runtime type
+ */
+export declare function createValidator<T extends Type>(defn: T): T;
+//# sourceMappingURL=createValidator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createValidator.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/initializers/createValidator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,IAAI,EAAE,MAAM,WAAW,CAAC;AAE7C;;GAEG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,IAAI,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,CAgB1D"}

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

@@ -0,0 +1,20 @@
+/**
+ * Creates a `validate` function for a runtime type
+ */
+export function createValidator(defn) {
+    const fn = (val) => {
+        // the first _validation_ is that it passes the type guard test
+        if (defn.is(val)) {
+            return defn.validations && defn.validations.length > 0
+                ? defn.validations.every(v => v(val))
+                : true;
+        }
+        else {
+            return false;
+        }
+    };
+    return {
+        ...defn,
+        validate: fn
+    };
+}

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

@@ -0,0 +1,17 @@
+import { ExpandRecursively, SimplifyObject, Narrowable, RemoveIndex } from "src/types";
+/**
+ * **defineObj**(literal) -> (wide) -> object
+ *
+ * A runtime utility designed to create an object _type_ from runtime objects.
+ * The object's keys are all type literals, but the values can be either
+ * _wide_ variants of the value passed in or instead maintain as _narrow_
+ * a type definition as possible.
+ *
+ * ### Example
+ * ```ts
+ * // { foo: 1; bar: number; baz: number }
+ * const fooBarBaz = defineObj({foo: 1})({bar: 2, baz: 3});
+ * ```
+ */
+export declare function defineObj<N extends Narrowable, TLiteral extends Record<string, N>>(literal?: TLiteral): <TWide extends object>(wide?: TWide) => SimplifyObject<RemoveIndex<TLiteral> & ExpandRecursively<RemoveIndex<TWide>>>;
+//# sourceMappingURL=defineObj.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"defineObj.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/initializers/defineObj.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAEvF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,UAAU,EAAE,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,EAChF,OAAO,GAAE,QAAyB,yHAanC"}

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

@@ -0,0 +1,25 @@
+/**
+ * **defineObj**(literal) -> (wide) -> object
+ *
+ * A runtime utility designed to create an object _type_ from runtime objects.
+ * The object's keys are all type literals, but the values can be either
+ * _wide_ variants of the value passed in or instead maintain as _narrow_
+ * a type definition as possible.
+ *
+ * ### Example
+ * ```ts
+ * // { foo: 1; bar: number; baz: number }
+ * const fooBarBaz = defineObj({foo: 1})({bar: 2, baz: 3});
+ * ```
+ */
+export function defineObj(literal = {}) {
+    /**
+     * Add any key/value pairs which you want to have _wide_ types associated;
+     * literal types are defined already and stated above.
+     */
+    return (wide = {}) => {
+        return (literal
+            ? { ...wide, ...literal }
+            : wide);
+    };
+}

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

@@ -0,0 +1,19 @@
+import { Flatten, Narrowable } from "src/types";
+/**
+ * **createTuple**(...values) -> (...values) -> Tuple
+ *
+ * Runtime utility to define a strongly typed tuple.
+ *
+ * - if you want to _widen_ certain elements in the Tuple you can use
+ * the `widen()` type utility for those elements.
+ *
+ * ### Example
+ * ```ts
+ * // [ "foo", "bar", 42 ]
+ * const foobar = defineTuple("foo", "bar", 42)
+ * // [ string, "bar", 42]
+ * const foey = defineTuple(wide("foo"), "bar", 42)
+ * ```
+ */
+export declare const defineTuple: <T extends readonly Narrowable[] | readonly Narrowable[][]>(...values: T) => Flatten<T>;
+//# sourceMappingURL=defineTuple.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"defineTuple.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/initializers/defineTuple.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAEhD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,WAAW,yFAEsB,CAAC"}

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

@@ -0,0 +1,17 @@
+/**
+ * **createTuple**(...values) -> (...values) -> Tuple
+ *
+ * Runtime utility to define a strongly typed tuple.
+ *
+ * - if you want to _widen_ certain elements in the Tuple you can use
+ * the `widen()` type utility for those elements.
+ *
+ * ### Example
+ * ```ts
+ * // [ "foo", "bar", 42 ]
+ * const foobar = defineTuple("foo", "bar", 42)
+ * // [ string, "bar", 42]
+ * const foey = defineTuple(wide("foo"), "bar", 42)
+ * ```
+ */
+export const defineTuple = (...values) => values.flat();

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

@@ -0,0 +1,9 @@
+export * from "./addFnToProps";
+export * from "./addPropsToFn";
+export * from "./createTypeGuard";
+export * from "./createTypeTuple";
+export * from "./createValidator";
+export * from "./createFnWithProps";
+export * from "./defineObj";
+export * from "./defineTuple";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/initializers/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC"}

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

@@ -0,0 +1,8 @@
+export * from "./addFnToProps";
+export * from "./addPropsToFn";
+export * from "./createTypeGuard";
+export * from "./createTypeTuple";
+export * from "./createValidator";
+export * from "./createFnWithProps";
+export * from "./defineObj";
+export * from "./defineTuple";

package/dist/runtime/src/runtime/lists/asArray.d.ts

@@ -0,0 +1,18 @@
+import { AsArray, Narrowable } from "src/types";
+/**
+ * Type utility which converts `undefined[]` to `unknown[]`
+ */
+export type UndefinedArrayIsUnknown<T extends unknown[]> = undefined[] extends T ? unknown[] : T;
+/**
+ * Ensures that any input passed in is passed back as an array:
+ *
+ * - if it was already an array than this just serves as an _identity_ function
+ * - if it was not then it wraps the element into a one element array of the
+ * given type
+ *
+ * Note: by default the _type_ of values will be intentionally widened so that the value "abc"
+ * is of type `string` not the literal `abc`. If you want to keep literal types then
+ * change the optional _widen_ parameter to _false_.
+ */
+export declare const asArray: <T extends Narrowable>(thing: T) => AsArray<T>;
+//# sourceMappingURL=asArray.d.ts.map

package/dist/runtime/src/runtime/lists/asArray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asArray.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/lists/asArray.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAEhD;;GAEG;AACH,MAAM,MAAM,uBAAuB,CAAC,CAAC,SAAS,OAAO,EAAE,IAAI,SAAS,EAAE,SAAS,CAAC,GAAG,OAAO,EAAE,GAAG,CAAC,CAAC;AAEjG;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,OAAO,gDASnB,CAAC"}

package/dist/runtime/src/runtime/lists/asArray.js

@@ -0,0 +1,20 @@
+/**
+ * Ensures that any input passed in is passed back as an array:
+ *
+ * - if it was already an array than this just serves as an _identity_ function
+ * - if it was not then it wraps the element into a one element array of the
+ * given type
+ *
+ * Note: by default the _type_ of values will be intentionally widened so that the value "abc"
+ * is of type `string` not the literal `abc`. If you want to keep literal types then
+ * change the optional _widen_ parameter to _false_.
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export const asArray = (thing) => {
+    return (Array.isArray(thing) === true
+        ? // proxy thing back as it's already an array
+            thing
+        : typeof thing === "undefined"
+            ? []
+            : [thing]);
+};

package/dist/runtime/src/runtime/lists/createConverter.d.ts

@@ -0,0 +1,25 @@
+import type { Narrowable, ConverterDefn, Tuple, Nothing, AnyObject, AnyFunction } from "src/types";
+type CallIfDefined<Handler> = Handler extends AnyFunction ? ReturnType<Handler> : never;
+type ConversionResult<TConvert extends Partial<ConverterDefn<any, any, any, any, any, any>>, TInput extends Narrowable | Tuple> = TInput extends string ? CallIfDefined<TConvert["string"]> : TInput extends number ? CallIfDefined<TConvert["number"]> : TInput extends boolean ? CallIfDefined<TConvert["boolean"]> : TInput extends AnyObject ? CallIfDefined<TConvert["object"]> : TInput extends Tuple ? CallIfDefined<TConvert["tuple"]> : TInput extends Nothing ? CallIfDefined<TConvert["nothing"]> : never;
+/**
+ * **createConverter**(mapper)
+ *
+ * A runtime utility which allows for the creation of a function which
+ * receives multiple wide types (string, number, boolean, object) and then transform it
+ * based on the "wide type" but while retaining the potentially narrow values passed in.
+ *
+ * The number of wide types which the converter will accept is based on how it configured
+ * as there are discrete functions which must be passed in for handling: strings, numbers,
+ * booleans, and "objects" (aka, Record<string,any>).
+ *
+ * ```ts
+ * // handles strings and numbers
+ * const convert = createConverter({
+ *    string: s => `the string was ${s}`,
+ *    number: n => `the number was ${n}`,
+ * });
+ * ```
+ */
+export declare function createConverter<TStr extends Narrowable = never, TNum extends Narrowable = never, TBool extends Narrowable = never, TObj extends Narrowable = never, TTuple extends Narrowable = never, TNothing extends Narrowable = never>(mapper: Partial<ConverterDefn<TStr, TNum, TBool, TObj, TTuple, TNothing>>): <TInput extends Narrowable | readonly unknown[]>(input: TInput) => ConversionResult<Partial<ConverterDefn<TStr, TNum, TBool, TObj, TTuple, TNothing>>, TInput>;
+export {};
+//# sourceMappingURL=createConverter.d.ts.map

package/dist/runtime/src/runtime/lists/createConverter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createConverter.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/lists/createConverter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,aAAa,EACb,KAAK,EACL,OAAO,EACP,SAAS,EACT,WAAW,EACZ,MAAM,WAAW,CAAC;AAQnB,KAAK,aAAa,CAChB,OAAO,IACL,OAAO,SAAS,WAAW,GAC3B,UAAU,CAAC,OAAO,CAAC,GACnB,KAAK,CAAC;AAEV,KAAK,gBAAgB,CACnB,QAAQ,SAAS,OAAO,CACtB,aAAa,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAC5C,EACD,MAAM,SAAS,UAAU,GAAG,KAAK,IAC/B,MAAM,SAAS,MAAM,GACrB,aAAa,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,GACjC,MAAM,SAAS,MAAM,GACnB,aAAa,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,GACjC,MAAM,SAAS,OAAO,GACpB,aAAa,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,GAClC,MAAM,SAAS,SAAS,GACtB,aAAa,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,GACjC,MAAM,SAAS,KAAK,GAClB,aAAa,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,GAChC,MAAM,SAAS,OAAO,GACpB,aAAa,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,GAClC,KAAK,CAAC;AAEpB;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,eAAe,CAC7B,IAAI,SAAS,UAAU,GAAG,KAAK,EAC/B,IAAI,SAAS,UAAU,GAAG,KAAK,EAC/B,KAAK,SAAS,UAAU,GAAG,KAAK,EAChC,IAAI,SAAS,UAAU,GAAG,KAAK,EAC/B,MAAM,SAAS,UAAU,GAAG,KAAK,EACjC,QAAQ,SAAS,UAAU,GAAG,KAAK,EACnC,MAAM,EAAE,OAAO,CAAC,aAAa,CAAC,IAAI,EAAC,IAAI,EAAC,KAAK,EAAC,IAAI,EAAC,MAAM,EAAC,QAAQ,CAAC,CAAC,kKAwCrE"}

package/dist/runtime/src/runtime/lists/createConverter.js

@@ -0,0 +1,59 @@
+import { isTupleType, isObject, isNothing } from "src/runtime";
+import { Never } from "src/constants";
+/**
+ * **createConverter**(mapper)
+ *
+ * A runtime utility which allows for the creation of a function which
+ * receives multiple wide types (string, number, boolean, object) and then transform it
+ * based on the "wide type" but while retaining the potentially narrow values passed in.
+ *
+ * The number of wide types which the converter will accept is based on how it configured
+ * as there are discrete functions which must be passed in for handling: strings, numbers,
+ * booleans, and "objects" (aka, Record<string,any>).
+ *
+ * ```ts
+ * // handles strings and numbers
+ * const convert = createConverter({
+ *    string: s => `the string was ${s}`,
+ *    number: n => `the number was ${n}`,
+ * });
+ * ```
+ */
+export function createConverter(mapper) {
+    return (input) => {
+        if (isTupleType(input)) {
+            return (mapper.tuple
+                ? mapper.tuple(input)
+                : Never);
+        }
+        else if (isNothing(input)) {
+            return (mapper.nothing
+                ? mapper.nothing(input)
+                : Never);
+        }
+        else if (isObject(input)) {
+            return (mapper.object
+                ? mapper.object(input)
+                : Never);
+        }
+        else {
+            switch (typeof input) {
+                case "string":
+                    return (mapper.string
+                        ? mapper.string(input)
+                        : Never);
+                case "number":
+                case "bigint":
+                    return (mapper.number
+                        ? mapper.number(input)
+                        : Never);
+                case "boolean":
+                    return (mapper.boolean
+                        ? mapper.boolean(input)
+                        : Never);
+                default:
+                    throw new Error(`Unhandled type: ${typeof input}`);
+            }
+        }
+    };
+}

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

@@ -0,0 +1,3 @@
+import { Filter, FilterOps, Narrowable } from "src/types";
+export declare const filter: <TList extends readonly unknown[], TOp extends FilterOps, TFilter extends Narrowable>(list: TList, op: TOp, value: TFilter) => Filter<TList, TFilter, TOp>;
+//# sourceMappingURL=filter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/lists/filter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAG,SAAS,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAG3D,eAAO,MAAM,MAAM,4JA2BlB,CAAC"}

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

@@ -0,0 +1,19 @@
+import { isSameTypeOf } from "src/runtime";
+export const filter = (list, op, value) => {
+    let result;
+    switch (op) {
+        case "not-equal":
+            result = list.filter(i => i !== value);
+            break;
+        case "equals":
+            result = list.filter(i => i === value);
+            break;
+        case "extends":
+            result = list.filter(i => isSameTypeOf(i)(value));
+            break;
+        case "does-not-extend":
+            result = list.filter(i => !isSameTypeOf(i)(value));
+            break;
+    }
+    return result;
+};