inferred-types 0.37.0 → 0.37.1

package/src/runtime/builders/Model.ts

@@ -1,25 +0,0 @@
-export function Model<N extends string, _R extends {} = {}, _O extends {} = {}>(name: N) {
-  // let tg: TypeGuard<any> = (_input: unknown) => {
-  //   throw new Error(`No typeguard was assigned to the model ${name}`);
-  // };
-
-  return {
-    required<P extends string>(_prop: P) {
-      return Model(name);
-    },
-    optional<P extends string>(_prop: P) {
-      return Model(name);
-    },
-    // typeGuard<TG extends TypeGuard<any>>(typeguard: TG) {
-    //   tg = typeguard;
-    //   return Model(name);
-    // },
-    done() {
-      return {
-        __model__: name,
-        __kind__: "model" as const,
-        // __tg__: tg,
-      };
-    },
-  };
-}

package/src/runtime/builders/url.ts

@@ -1,15 +0,0 @@
-import { DomainName, Ipv4, NetworkProtocol, RelativeUrl } from "src/types";
-
-export const url = <
-  Proto extends NetworkProtocol,
-  Site extends DomainName | Ipv4,
-  Path extends RelativeUrl
->(
-  ...args: [Proto, Site, Path]
-) => {
-  if (args.length === 3) {
-    return `${args[0]}://${args[1]}/${args[2]}`;
-  } else {
-    return args[0];
-  }
-};

package/src/runtime/combinators/and.ts

@@ -1,15 +0,0 @@
-import { LogicFunction } from "src/types/functions";
-
-/**
- * Groups a number of "logic functions" together by combining their results using
- * the logical **AND** operator.
- *
- * **Note:** a "logic function" is any function which returns a boolean
- */
-export const and = <T extends any[]>(...ops: readonly LogicFunction<T>[]): LogicFunction<T> => {
-  const fn: LogicFunction<T> = (...args: T) => {
-    return [...ops].every((i) => i(...args));
-  };
-
-  return fn;
-};

package/src/runtime/combinators/filter.ts

@@ -1,267 +0,0 @@
-import { asArray } from "../lists/asArray";
-
-// string filters
-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[];
-};
-
-// numeric filters
-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;
-
-// NOT filter
-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 function isNotFilter(f: FilterDefn | NotFilter): f is NotFilter {
-  return typeof f === "object" && "not" in f;
-}
-
-export type UnwrapNot<T extends FilterDefn | NotFilter> = T extends NotFilter
-  ? T["not"] extends StringFilter
-    ? StringFilter
-    : NumericFilter
-  : T;
-
-export function isNumericFilter(filter: FilterDefn): filter is NumericFilter {
-  return "equals" in filter ||
-    "notEqual" in filter ||
-    "greaterThan" in filter ||
-    "lessThan" in filter
-    ? true
-    : false;
-}
-
-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'";
-
-export type LogicalCombinator = "AND" | "OR";
-
-/**
- * **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;
-
-/**
- * Wraps numeric filter's configuration into a logic filter
- */
-const numericOps = <L extends LogicalCombinator>(config: NumericFilter, boolLogic: L) => {
-  const equals = (n: number | number[]): [ConditionFilter<NumericFilter>] | [] => {
-    const f = asArray(n);
-    return f.length === 0 ? [] : [(input?: number) => f.some((i) => i === input)];
-  };
-  const notEqual = (n: number | number[]): [ConditionFilter<NumericFilter>] | [] => {
-    const f = asArray(n);
-    return f.length === 0 ? [] : [(input?: number) => f.every((i) => i !== input)];
-  };
-
-  /** returns 1 FilterFn's */
-  const greaterThan = <V extends number>(n: V) => {
-    const val = [(input?: V) => input !== undefined && input > n] as [(input: V) => boolean];
-    return val as [ConditionFilter<NumericFilter>];
-  };
-
-  /** returns 0 or 1 FilterFn's */
-  const lessThan = <V extends number>(n: V) => {
-    const val = [(input: V) => input !== undefined && input < n];
-    return val as [ConditionFilter<NumericFilter>] | [];
-  };
-
-  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"
-      ? <N extends number>(input: N) => conditions.every((c) => c(input))
-      : <N extends number>(input: N) => conditions.some((c) => c(input));
-
-  return combined;
-};
-
-/** wraps configuration along with boolean logic  */
-const stringOps = <L extends LogicalCombinator>(
-  config: StringFilter,
-  boolLogic: L
-): ConditionFilter<StringFilter> => {
-  const startsWith = (n: string | string[]): [ConditionFilter<StringFilter>] | [] => {
-    const f = asArray(n);
-    return f.length === 0 ? [] : [(input?: string) => f.some((i) => input?.startsWith(i))];
-  };
-  const endsWith = (n: string | string[]): [ConditionFilter<StringFilter>] | [] => {
-    const f = asArray(n);
-    return f.length === 0 ? [] : [(input?: string) => f.some((i) => input?.endsWith(i))];
-  };
-  const contains = (n: string | string[]): [ConditionFilter<StringFilter>] | [] => {
-    const f = asArray(n);
-    return f.length === 0 ? [] : [(input: string) => 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: string) => conditions.every((c) => c(input))
-      : (input: string) => conditions.some((c) => c(input));
-
-  return combined as ConditionFilter<StringFilter>;
-};
-
-const filterFn = <
-  F extends FilterDefn | NotFilter,
-  C extends LogicalCombinator,
-  U extends boolean | "no-impact"
->(
-  defn: F,
-  logicCombinator: C,
-  ifUndefined: U = "no-impact" as U
-): FilterFn<UnwrapNot<F>> => {
-  type D = UnwrapNot<F>;
-  const config: D = isNotFilter(defn) ? (defn["not"] as D) : (defn as D);
-
-  const filter: FilterFn<D> = (
-    //
-    input: Parameters<FilterFn<D>>[0]
-  ) => {
-    const undefValue =
-      ifUndefined === "no-impact"
-        ? logicCombinator === "AND"
-          ? true
-          : false
-        : (ifUndefined as true | false);
-
-    let flag: boolean;
-
-    if (typeof input === "undefined") {
-      flag = undefValue;
-    } else if (isNumericFilter(config)) {
-      const fn = numericOps(config, logicCombinator);
-      flag = isNotFilter(defn) ? !fn(input as number) : fn(input as number);
-    } else {
-      const fn = stringOps(config, logicCombinator);
-      flag = isNotFilter(defn) ? !fn(input as string) : fn(input as string);
-    }
-
-    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 filter = <
-  F extends FilterDefn | NotFilter,
-  U extends boolean | "no-impact",
-  C extends LogicalCombinator
->(
-  config: F,
-  logicCombinator: C = "AND" as C,
-  ifUndefined: U = "no-impact" as U
-) => {
-  return filterFn(config, logicCombinator, ifUndefined);
-};

package/src/runtime/combinators/index.ts

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

package/src/runtime/combinators/not.ts

@@ -1,15 +0,0 @@
-import { LogicFunction } from "src/types/functions";
-
-/**
- * Groups a number of "logic functions" together by combining their results using
- * the logical **NOT** operator.
- *
- * **Note:** a "logic function" is any function which returns a boolean
- */
-export const not = <T extends any[]>(op: LogicFunction<T>): LogicFunction<T> => {
-  const fn: LogicFunction<T> = (...args: T) => {
-    return !op(...args);
-  };
-
-  return fn;
-};

package/src/runtime/combinators/or.ts

@@ -1,5 +0,0 @@
-import { Or } from "src/types/boolean-logic/Or";
-
-export function or<O extends readonly boolean[]>(...conditions: O) {
-  return (conditions.some((v) => v === true) ? true : false) as Or<O>;
-}

package/src/runtime/createFnWithProps.ts

@@ -1,37 +0,0 @@
-import { Narrowable } from "../types/Narrowable";
-import { keys } from "./keys";
-
-export function createFnWithProps<F extends Function, P extends {}>(fn: F, props: P) {
-  return (() => {
-    // eslint-disable-next-line prefer-const
-    let combined: any = fn;
-    for (const prop of keys(props)) {
-      combined[prop] = props[prop];
-    }
-    return combined;
-  })() as unknown as F & P;
-}
-
-/**
- * Adds a dictionary of key/value pairs to a function.
- */
-export function fnWithProps<A extends any[], R extends any, P extends {}>(fn: ((...args: A) => R), props: P) {
-  // eslint-disable-next-line prefer-const
-  let combined: any = fn;
-  for (const prop of keys(props)) {
-    combined[prop] = props[prop];
-  }
-  return combined as ((...args: A) => R) & P;
-}
-
-/**
- * Adds read-only (and narrowly typed) key/value pairs to a function
- */
-export function readonlyFnWithProps<A extends any[], R extends any, N extends Narrowable, P extends Record<keyof P, N>>(fn: ((...args: A) => R), props: P) {
-  // eslint-disable-next-line prefer-const
-  let combined: any = fn;
-  for (const prop of keys(props)) {
-    combined[prop] = props[prop];
-  }
-  return combined as ((...args: A) => R) & Readonly<P>;
-}

package/src/runtime/dictionary/arrayToKeyLookup.ts

@@ -1,19 +0,0 @@
-/**
- * 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<T extends readonly string[]>(...keys: T): Record<T[number], true> {
-  const obj: Record<string, true> = {};
-
-  for (const key of keys) {
-    obj[key] = true;
-  }
-
-  return obj;
-}

package/src/runtime/dictionary/defineProperties.ts

@@ -1,35 +0,0 @@
-export interface DefinePropertiesApi<T extends {}> {
-  /**
-   * Makes a property on the object **readonly** on the Javascript runtime
-   */
-  ro<K extends keyof T>(
-    prop: K,
-    errorMsg?: (p: K, v: any) => string
-  ): Omit<T, K> & Record<K, Readonly<T[K]>>;
-  /**
-   * Makes a property on the object **read/writeable** on the Javascript runtime;
-   * this is the default so only use this where it is needed.
-   */
-  rw<K extends keyof T>(prop: K): Omit<T, K> & Record<K, Readonly<T[K]>>;
-}
-
-export function defineProperties<T extends {}>(obj: T) {
-  return {
-    ro(prop, errorMsg) {
-      Object.defineProperty(obj, prop, {
-        writable: false,
-        set(v: any) {
-          const message = errorMsg
-            ? errorMsg(prop, v)
-            : `The ${String(
-                prop
-              )} is readonly but an attempt was made to change it's value to "${JSON.stringify(
-                v
-              )}"!`;
-          throw new Error(message);
-        },
-      });
-      return obj;
-    },
-  } as DefinePropertiesApi<T>;
-}

package/src/runtime/dictionary/dictArr.ts

@@ -1,69 +0,0 @@
-import { Keys, Narrowable, OptionalKeys, RequiredKeys, UniqueForProp } from "src/types";
-
-export interface Uniqueness<T> {
-  /** boolean flag to indicate whether the property was unique across all records */
-  isUnique: boolean;
-  /** the overall number of records which contained the property */
-  size: number;
-  /** specifies if undefined values were encountered for this property */
-  includedUndefined: boolean;
-  /** the unique values for the property across all records */
-  values: readonly T[];
-}
-
-export type DictArrApi<T extends Record<string, Narrowable>, A extends readonly T[]> = {
-  length: number;
-  toLookup<PL extends RequiredKeys<T, string> & keyof T & string>(
-    prop: PL
-  ): UniqueForProp<A, PL> extends string ? Record<UniqueForProp<A, PL>, T> : Record<string, T>;
-  sum<PS extends RequiredKeys<T, number> | OptionalKeys<T, number>>(prop: PS): number;
-  count<PC extends OptionalKeys<T>>(prop: PC): number;
-  unique<PU extends Keys<T> & keyof T>(prop: PU): Uniqueness<T[PU]>;
-};
-
-/**
- * converts an array of objects to a dictionary with keys formed from a given property
- * of the object and the value being the object itself.
- */
-export const dictArr = <T extends Record<string, Narrowable>>(...dicts: readonly T[]) => {
-  // build API
-  const api: DictArrApi<T, typeof dicts> = {
-    length: dicts.length,
-    toLookup: (prop) => {
-      let dict: Record<string, T> = {};
-      for (const obj of dicts) {
-        const key = obj[prop] as string;
-        dict = { ...dict, [key]: obj };
-      }
-      return dict;
-    },
-    /**
-     * The unique values of a given property
-     */
-    unique: (prop) => {
-      type P = typeof prop;
-      const v = new Set<T[P]>();
-      dicts.forEach((i) => v.add(i[prop]));
-      const size = dictArr(...dicts).count(prop as any);
-      const values = Array.from(v);
-      const u: Uniqueness<T[P]> = {
-        isUnique: values.includes(undefined as any) ? size === v.size - 1 : size === v.size,
-        includedUndefined: values.includes(undefined as any) ? true : false,
-        size,
-        values,
-      };
-      return u;
-    },
-    sum: (prop) => {
-      return dicts.reduce((acc, obj) => (prop in obj ? acc + (obj[prop] as number) : acc), 0);
-    },
-    count: (prop) => {
-      return dicts.reduce(
-        (acc, obj) => (prop in obj && typeof obj[prop] !== "undefined" ? acc + 1 : acc),
-        0
-      );
-    },
-  };
-
-  return api;
-};

package/src/runtime/dictionary/dictionaryTransform.ts

@@ -1,22 +0,0 @@
-/* eslint-disable no-use-before-define */
-
-import { SameKeys } from "src/types/dictionary";
-import { Transformer } from "src/types/Transformer";
-import { keys } from "../keys";
-
-/**
- * Takes a dictionary of type `I` and converts it to a dictionary of type `O` where
- * they _keys_ used in both dictionaries are the same.
- *
- * The _transform_ function passed in must be able to recieve the full input object
- * and key, and then return expected value of `O` for the given key.
- */
-export function dictionaryTransform<I extends object, O extends SameKeys<I>>(
-  input: I,
-  transform: Transformer<I, O>
-) {
-  return keys(input).reduce((acc, i) => {
-    const key = i as string & keyof I;
-    return { ...acc, [key]: transform(input, key) };
-  }, {} as O);
-}

package/src/runtime/dictionary/entries.ts

@@ -1,33 +0,0 @@
-import { KeyValue } from "src/types/kv";
-import { Narrowable } from "src/types/Narrowable";
-import { keys } from "../keys";
-
-/**
- * **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<
-  N extends Narrowable,
-  T extends Record<string, N>,
-  I extends KeyValue<T, keyof T>
->(obj: T) {
-  const iterable = {
-    *[Symbol.iterator]() {
-      for (const k of keys(obj)) {
-        // const [k, v] = entry as KeyValue<T, First<typeof entry>>;
-        yield [k, obj[k]] as KeyValue<T, typeof k> as I;
-      }
-    },
-  };
-
-  return iterable;
-}

package/src/runtime/dictionary/index.ts

@@ -1,21 +0,0 @@
-// #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 "./defineProperties";
-export * from "./dictionaryTransform";
-export * from "./dictArr";
-export * from "./entries";
-export * from "./mapValues";
-export * from "./mapTo";
-export * from "./strArrayToDict";
-// directory exports
-export * from "./kv/index";
-
-// #endregion auto-indexed files
-
-// see https://github.com/inocan-group/do-devops/docs/autoindex.md
-// for more info

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

@@ -1,21 +0,0 @@
-import { KvFrom } from "src/types/kv";
-import { Mutable } from "src/types/Mutable";
-import { Narrowable } from "src/types/Narrowable";
-import { UnionToTuple } from "src/types/type-conversion";
-import { keys } from "src/runtime/keys";
-
-/**
- * Converts a dictionary object into an array of dictionaries with `key` and `value` properties
- * ```ts
- * // [ { key: "id", value: 123 }, { key: "foo", value: "bar" } ]
- * const arr = dictToKv({ id: 123, foo: "bar" });
- * ```
- */
-export function dictToKv<N extends Narrowable, T extends { [key: string]: N }, U extends boolean>(
-  obj: T,
-  _makeTuple: U = false as U
-) {
-  return keys(obj).map((k) => {
-    return { key: k, value: obj[k] };
-  }) as unknown as U extends true ? UnionToTuple<KvFrom<Mutable<T>>[0]> : KvFrom<Mutable<T>>;
-}

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

@@ -1,31 +0,0 @@
-import { DictArray, DictArrayFilterCallback } from "src/types/tuples";
-import { Configurator, IConfigurator } from "src/runtime/state";
-
-export interface Array<T> {
-  filter<U extends T>(pred: (a: T) => a is U): U[];
-}
-
-/**
- * Accepts a `DictArray` and a callback which receives each key
- * value pair.
- */
-export function filterDictArray<
-  T extends object,
-  C extends DictArrayFilterCallback<keyof T, T, true | false>
->(dictArr: DictArray<T>, cb: C) {
-  const state: IConfigurator = Configurator();
-
-  const updated = dictArr.filter((i) => {
-    const [k, v] = i;
-    const keep = cb(k, v);
-    if (!keep) {
-      state.set(k as string, true);
-    }
-
-    return keep;
-  });
-
-  // TODO: fix this so that typing is actualy working!
-  type ExcludedKeys = "";
-  return updated as unknown as DictArray<Omit<T, ExcludedKeys>>;
-}

package/src/runtime/dictionary/kv/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: dd4e4592
-
-// file exports
-export * from "./dictToKv";
-export * from "./filterDictArray";
-export * from "./kv";
-export * from "./kvToDict";
-
-// #endregion auto-indexed files
-
-// see https://github.com/inocan-group/do-devops/docs/autoindex.md
-// for more info