inferred-types 0.37.0 → 0.37.2

package/src/runtime/dictionary/kv/kv.ts

@@ -1,18 +0,0 @@
-import { ExpandRecursively } from "src/types/ExpandRecursively";
-import { Narrowable } from "src/types/Narrowable";
-
-/**
- * Build a key-value pair where both _key_ and _value_ are inferred. This
- * includes ensuring that the _key_ is a type literal not just a "string".
- *
- * > note: the value will be inferred but if you need to constrain it
- * > to a narrower type then both inferences will break and you should
- * > instead use `KV2` to get this capability.
- */
-export function kv<
-  K extends string,
-  N extends Narrowable,
-  V extends Record<any, N> | boolean | number | string | null | undefined
->(key: K, value: V) {
-  return { [key]: value } as ExpandRecursively<Record<K, V>>;
-}

package/src/runtime/dictionary/kv/kvToDict.ts

@@ -1,24 +0,0 @@
-import { DictFromKv } from "src/types/kv";
-import { Narrowable } from "src/types/Narrowable";
-
-/**
- * Converts an array of dictionaries with `key` and `value` properties to a singular dictionary.
- * ```ts
- * // { id: 123, foo: "bar" }
- * const arr = kvToDict([{ key: "id", value: 123 }, { key: "foo", value: "bar" }]);
- * ```
- *
- * Note: this is the inverse of `dictToKv()` function
- */
-export function kvToDict<
-  K extends string,
-  V extends Narrowable,
-  T extends readonly Readonly<{ key: K; value: V }>[]
->(kvArr: T): DictFromKv<T> {
-  const out = {} as any;
-  for (const kv of kvArr) {
-    out[kv.key as keyof DictFromKv<T>] = kv.value;
-  }
-
-  return out as DictFromKv<T>;
-}

package/src/runtime/dictionary/mapTo.ts

@@ -1,206 +0,0 @@
-import {
-  FinalizedMapConfig,
-  MapCardinalityIllustrated,
-  MapperApi,
-  MapTo,
-  AsFinalizedConfig,
-  MapConfig,
-  ConfiguredMap,
-  Mapper,
-  MapFn,
-} from "src/types/dictionary";
-import { OptRequired } from "src/types/literal-unions";
-import { createFnWithProps } from "../createFnWithProps";
-
-/**
- * utility function to take a fully-qualified _user_ config
- * and make it into a FinalizedMapConfig
- */
-const toFinalizedConfig = <
-  IR extends OptRequired,
-  D extends MapCardinalityIllustrated,
-  OR extends OptRequired
->(
-  config: MapConfig<IR, D, OR>
-) => {
-  return { ...config, finalized: true } as FinalizedMapConfig<IR, D, OR>;
-};
-
-export const DEFAULT_ONE_TO_MANY_MAPPING = toFinalizedConfig({
-  input: "req",
-  output: "opt",
-  cardinality: "I -> O[]",
-});
-export const DEFAULT_ONE_TO_ONE_MAPPING = toFinalizedConfig({
-  input: "req",
-  output: "req",
-  cardinality: "I -> O",
-});
-export const DEFAULT_MANY_TO_ONE_MAPPING = toFinalizedConfig({
-  input: "req",
-  output: "req",
-  cardinality: "I[] -> O",
-});
-
-export type DefaultOneToManyMapping = typeof DEFAULT_ONE_TO_MANY_MAPPING;
-export type DefaultOneToOneMapping = typeof DEFAULT_ONE_TO_ONE_MAPPING;
-export type DefaultManyToOneMapping = typeof DEFAULT_MANY_TO_ONE_MAPPING;
-
-const debugMsg = <C extends FinalizedMapConfig<any, any, any>>(
-  config: C,
-  source: any,
-  output: any
-) => {
-  if (config.debug) {
-    console.error(
-      `MapFn[${typeof config.output === "string" ? `${config.output}, ` : ""}${config.input}, ${
-        config.cardinality
-      }, ${config.output}] received:\n\n${JSON.stringify(source)}\n\nAnd produced: ${JSON.stringify(
-        output
-      )}\n\n`
-    );
-  }
-};
-
-/**
- * The single implementation for all mapping
- */
-const mapper =
-  <
-    //
-    C extends FinalizedMapConfig<
-      OptRequired, //
-      MapCardinalityIllustrated,
-      OptRequired
-    >
-  >(
-    config: C
-  ) =>
-  <I, O>(map: MapTo<I, O, C>): Mapper<I, O, C> => {
-    const fn: MapFn<I, O, C> = <S>(source: S) => {
-      /**
-       * Determine whether input is an array; this will be true
-       */
-      const isArray =
-        config.cardinality === "I -> O[]" && Array.isArray(source)
-          ? true
-          : config.cardinality === "I[] -> O" && Array.isArray(source) && Array.isArray(source[0])
-          ? true
-          : false;
-
-      if (isArray) {
-        // iterate over inputs with flatMap to return mapped values as
-        // well as supporting filtering functionality. We could achieve
-        // the same results by simply passing in all inputs to our mapper
-        // in most cardinalities but when cardinality is M:1 we need to
-        // make sure that the first array of elements is passed as a single
-        // item and this approach achieves this.
-        // TODO: we should check that the approach below doesn't work for M:1 here
-        // as well
-        const output = (source as any).flatMap(map);
-        debugMsg(config, source, output);
-
-        return output;
-      } else {
-        // receive _all_ inputs provided as pass into ; this is just a single input unless the
-        // cardinality is
-        const output = map(source as any);
-        debugMsg(config, source, output);
-
-        return output;
-      }
-    };
-
-    return createFnWithProps(fn, {
-      input: config.input,
-      output: config.output,
-      cardinality: config.cardinality,
-      debug: config.debug,
-      inputType: {} as I,
-      outputType: {} as O,
-      fnSignature: null as unknown as MapFn<I, O, C>,
-    });
-  };
-
-/**
- * Takes a userland configuration and a default configuration and then produces
- * the appropriately typed `ConfiguredMap` API surface.
- */
-const setMapper = <
-  U extends MapConfig<
-    OptRequired | undefined,
-    MapCardinalityIllustrated | undefined,
-    OptRequired | undefined
-  >,
-  D extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>
->(
-  config: U = { input: undefined, output: undefined, cardinality: undefined } as U,
-  defaultValue: D
-): ConfiguredMap<AsFinalizedConfig<U, D>> => ({
-  map: (source) => {
-    // merge userland config with defaults for a cardinality
-    const c = {
-      ...defaultValue,
-      ...config,
-    } as unknown as AsFinalizedConfig<U, D>;
-    return mapper(c)(source);
-  },
-  input: config?.input || defaultValue.input,
-  output: config?.output || defaultValue.output,
-  cardinality: config?.cardinality || defaultValue.cardinality,
-  debug: config?.debug || false,
-});
-
-/**
- * **mapTo** _utility_
- *
- * This utility -- by default -- creates a strongly typed 1:M data mapper which maps from one
- * known source `I` to any array of another `O[]`:
- * ```ts
- * const mapper = mapTo<I, O>(i => [{
- *    foo: i.bar
- * }]);
- * ```
- */
-export const mapToFn: ConfiguredMap<DefaultOneToManyMapping>["map"] = (map) => {
-  return mapper(DEFAULT_ONE_TO_MANY_MAPPING)(map);
-};
-
-/**
- * Provides a `config` method which allows the relationships between _inputs_
- * and _outputs_ to be configured.
- */
-export const mapToDict: MapperApi = {
-  config(config) {
-    const c = { ...DEFAULT_ONE_TO_MANY_MAPPING, ...config };
-    return setMapper(c, DEFAULT_ONE_TO_MANY_MAPPING);
-  },
-  oneToOne(config) {
-    const c = { ...DEFAULT_ONE_TO_ONE_MAPPING, ...config };
-    return setMapper(c, DEFAULT_ONE_TO_ONE_MAPPING);
-  },
-  manyToOne(config) {
-    const c = { ...DEFAULT_MANY_TO_ONE_MAPPING, ...config };
-    return setMapper(c, DEFAULT_MANY_TO_ONE_MAPPING);
-  },
-  oneToMany(config) {
-    const c = { ...DEFAULT_ONE_TO_MANY_MAPPING, ...config };
-    return setMapper(c, DEFAULT_ONE_TO_MANY_MAPPING);
-  },
-};
-
-/**
- * **mapTo** _utility_
- *
- * This utility creates a strongly typed data mapper which maps from one
- * known source `I` to another `O`.
- *
- * Signatures:
- * ```ts
- * const defMap = mapTo<I,O>( ... );
- * const configured = mapTo.config({ output: "req" }).map<I,O>( ... );
- * const one2one = mapTo.oneToOne().map<I,O>( ... );
- * const many2one = mapTo.manyToOne().map<I,O>( ... );
- * ```
- */
-export const mapTo = createFnWithProps(mapToFn, mapToDict);

package/src/runtime/dictionary/mapValues.ts

@@ -1,23 +0,0 @@
-import { Narrowable } from "src/types/Narrowable";
-import { entries } from "./entries";
-
-/**
- * **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<N extends Narrowable, T extends Record<string, N>, V>(
-  obj: T,
-  valueMapper: (k: T[keyof T]) => V
-) {
-  return Object.fromEntries(
-    // TODO: fix the type error with v and valueMapper
-    [...entries(obj)].map(([k, v]) => [k, valueMapper(v as any)])
-  ) as { [K in keyof T]: V };
-}

package/src/runtime/dictionary/merge.ts

@@ -1,36 +0,0 @@
-import { Mutable, Narrowable, SimplifyObject, TypeDefault } from "src/types";
-import { keys } from "../keys";
-import { isObject } from "../runtime";
-
-/**
- * **merge**(val, defaultVal)
- *
- * Merges two values together where the second property is considered the
- * the "default value". This means that in any cases where the primary value
- * os _undefined_ it will be replaced by the default value. The merging will
- * also recurse into object types to do matching at a property-by-property
- * level.
- *
- * As much as is possible, this utility will maintain strong and narrow types
- * across the merge process.
- */
-export const merge = <T extends Narrowable, D extends Narrowable>(
-  val: T,
-  defVal: D
-): SimplifyObject<Mutable<TypeDefault<T, D>>> => {
-  const result =
-    val === undefined
-      ? // value is undefined; use default value
-        defVal
-      : isObject(defVal) && isObject(val)
-      ? // value and and default value are objects; recurse via default values
-        keys(defVal as Record<string, any>).reduce((acc, key) => {
-          const v = (val as Record<string, any>)[key];
-          const dv = (defVal as Record<string, any>)[key];
-
-          return { ...acc, [key]: merge(v, dv) };
-        }, {} as Record<string, any>)
-      : val;
-
-  return result as SimplifyObject<Mutable<TypeDefault<T, D>>>;
-};

package/src/runtime/dictionary/strArrayToDict.ts

@@ -1,12 +0,0 @@
-import { ExpandRecursively } from "src/types/ExpandRecursively";
-
-/**
- * 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<T extends readonly string[]>(...strings: T) {
-  return strings.reduce((acc, str) => {
-    acc = { ...acc, [str]: true };
-    return acc;
-  }, {} as ExpandRecursively<Record<typeof strings[number], true>>);
-}

package/src/runtime/index.ts

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

package/src/runtime/keys.ts

@@ -1,16 +0,0 @@
-import { Keys } from "src/types/Keys";
-import { Length } from "src/types/Length";
-
-/**
- * Provides the _keys_ of an object with the `keyof T` made explicit.
- */
-export function keys<T extends {}, W extends readonly string[]>(obj: T, ...without: W) {
-  const v =
-    without.length > 0
-      ? (Object.keys(obj).filter((k) => !without.includes(k)) as unknown as Array<
-          Exclude<keyof T, Keys<W>>
-        >)
-      : (Object.keys(obj) as unknown as Array<keyof T>);
-
-  return v as unknown as Length<W> extends 0 ? Array<keyof T> : Array<Exclude<keyof T, Keys<W>>>;
-}

package/src/runtime/lists/asArray.ts

@@ -1,38 +0,0 @@
-import { Narrowable, Widen } from "src/types";
-import { isArray } from "../runtime";
-
-/**
- * Type utility which converts `undefined[]` to `unknown[]`
- */
-export type UndefinedArrayIsUnknown<T extends any[]> = undefined[] extends T ? unknown[] : T;
-
-export type AsArray<T, W extends boolean = false> = T extends any[]
-  ? W extends true
-    ? Widen<T>
-    : T
-  : W extends true
-  ? UndefinedArrayIsUnknown<Widen<T>[]>
-  : UndefinedArrayIsUnknown<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_.
- */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export const asArray = <T extends Narrowable, W extends boolean = true>(thing: T, _widen?: W) => {
-  return (
-    isArray(thing)
-      ? // proxy thing back as it's already an array
-        thing
-      : typeof thing === "undefined"
-      ? ([] as T[])
-      : [thing]
-  ) as AsArray<T, W>;
-};

package/src/runtime/lists/createConverter.ts

@@ -1,62 +0,0 @@
-import { Narrowable } from "src/types";
-import { ConverterShape, AvailableConverters } from "src/types/lists/ConvertAndMap";
-import { boxDictionaryValues } from "../literals/box";
-import { wide } from "../literals/wide";
-import { ifSameType } from "../type-checks";
-
-/**
- * **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<
-  S extends Narrowable = undefined,
-  N extends Narrowable = undefined,
-  B extends Narrowable = undefined,
-  O extends Narrowable = undefined
->(mapper: Partial<ConverterShape<S, N, B, O>>) {
-  type Mapper = Required<typeof mapper>;
-  const converter = boxDictionaryValues(mapper as Mapper);
-
-  return <T extends AvailableConverters<S, N, B, O>>(input: T) => {
-    const v = ifSameType(
-      input,
-      wide.string,
-      <T extends string>(i: T) => converter.string.unbox(i),
-      (i) =>
-        ifSameType(
-          i,
-          wide.number,
-          (i) => converter.number.unbox(i),
-          (i) =>
-            ifSameType(
-              i,
-              wide.boolean,
-              (i) => converter.boolean.unbox(i),
-              (i) =>
-                ifSameType(
-                  i,
-                  {} as Record<string, any>,
-                  (i) => converter.object.unbox(i),
-                  (i) => i as unknown
-                )
-            )
-        )
-    );
-    return v;
-  };
-}

package/src/runtime/lists/groupBy.ts

@@ -1,15 +0,0 @@
-import { Narrowable } from "src/types/Narrowable";
-
-/**
- * Groups an array of data based on the value of a property
- * in the objects within the array.
- * ```ts
- * const data = [ {}, {}, {} ];
- *
- * ```
- *
- * @ignore not implemented
- */
-export function groupBy<T extends Record<string, Narrowable>>(_data: Readonly<T[]>) {
-  throw new Error("not implemented");
-}

package/src/runtime/lists/index.ts

@@ -1,15 +0,0 @@
-// #autoindex
-
-// #region auto-indexed files
-// index last changed at: 8th Aug, 2022, 09:51 AM ( GMT-7 )
-// hash-code: bf4a6791
-
-// file exports
-export * from "./asArray";
-export * from "./groupBy";
-export * from "./createConverter";
-
-// #endregion auto-indexed files
-
-// see https://github.com/inocan-group/do-devops/docs/autoindex.md
-// for more info

package/src/runtime/literals/ExplicitFunction.ts

@@ -1,10 +0,0 @@
-/* eslint-disable no-use-before-define */
-export type ExplicitFunction<P extends any[], R extends any> = (...args: P) => R;
-
-/**
- * Takes a given function and converts it to an explicit representation
- * where the generics represent the _parameter_ and _return_ typings.
- */
-export function ExplicitFunction<T extends (...args: any[]) => any>(fn: T) {
-  return fn as ExplicitFunction<Parameters<T>, ReturnType<T>>;
-}

package/src/runtime/literals/Suggest.ts

@@ -1,19 +0,0 @@
-/**
- * **Suggest**
- *
- * Type utility that helps to build a enumerated set
- * of string literals which _could_ be the value for
- * a string based property but _allows_ a string that
- * is not part of the suggestion to be typed in too.
- */
-export type Suggest<T extends string> = T | (string & {});
-
-/**
- * **SuggestNumeric**`<T>`
- *
- * Type utility that helps to build a enumerated set
- * of numeric literals which _could_ be the value for
- * a number based property but _allows_ a number that
- * is not part of the suggestion to be typed in too.
- */
-export type SuggestNumeric<T extends number> = T | (number & {});

package/src/runtime/literals/arrayToObject.ts

@@ -1,78 +0,0 @@
-import { Narrowable } from "src/types/Narrowable";
-
-/**
- * **UniqueDictionary**
- *
- * A dictionary converted by `arrayToObject()` which expects each key `S` to have a only a
- * single/unique value.
- */
-export type UniqueDictionary<
-  S extends PropertyKey,
-  N extends Narrowable,
-  T extends Record<keyof T, N> & Record<S, any>
-> = { [V in T as V[S]]: V };
-
-/**
- * **GeneralDictionary**
- *
- * A dictionary converted by `arrayToObject()` which expects each key `S` to have an
- * array of values.
- */
-export type GeneralDictionary<
-  S extends PropertyKey,
-  N extends Narrowable,
-  T extends Record<keyof T, N> & Record<S, any>
-> = { [V in T as V[S]]: V[] };
-
-export type ArrayConverter<S extends PropertyKey, U extends boolean> =
-  /**
-   * An `ArrayConverter` is the partial application of the `arrayToObject()`
-   * utility. At this point, the configuration is setup already and all that's
-   * left is to pass in an array of objects.
-   */
-  <N extends Narrowable, T extends Record<keyof T, N> & Record<S, any>>(
-    arr: readonly T[]
-  ) => true extends U ? UniqueDictionary<S, N, T> : GeneralDictionary<S, N, T>;
-
-/**
- * Converts an array of objects into a dictionary by picking a property name contained
- * by all objects and using that as the key to the dictionary.
- *
- * ```ts
- * const arr = [
- *   { kind: "color", favorite: "blue", likes: 100 },
- *   { kind: "song", favorite: "some song", likes: 25 }
- * ];
- * const dict = arrayToObject("kind")(arr);
- * ```
- *
- * This will produce a dictionary with keys of `color` and `song`.
- */
-export function arrayToObject<S extends PropertyKey, U extends boolean>(prop: S, unique?: U) {
-  type X = true extends U ? true : false;
-  /**
-   * **arrayToObject** - partially applied
-   *
-   * pass in an array of objects to complete application of arrayToObject()
-   */
-  const transform: ArrayConverter<S, X> = <
-    N extends Narrowable,
-    T extends Record<keyof T, N> & Record<S, any>
-  >(
-    arr: readonly T[]
-  ): true extends X ? UniqueDictionary<S, N, T> : GeneralDictionary<S, N, T> => {
-    const result =
-      unique !== false
-        ? arr.reduce((acc, v) => ({ ...acc, [v[prop]]: v }), {} as UniqueDictionary<S, N, T>)
-        : arr.reduce((acc, v) => {
-            const existing = acc[v[prop] as T[S]] || [];
-            return { ...acc, [v[prop]]: [...existing, v] };
-          }, {} as GeneralDictionary<S, N, T>);
-
-    // type cast based on `U`
-    return result as true extends X ? UniqueDictionary<S, N, T> : GeneralDictionary<S, N, T>;
-  };
-
-  return transform;
-  // return converter(prop, unique);
-}