inferred-types 0.51.1 → 0.51.2

package/src/runtime/lists/asArray.ts

@@ -1,29 +0,0 @@
-import { AsArray, Narrowable } from "inferred-types/dist/types/index";
-
-/**
- * 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 const asArray = <T extends Narrowable>(thing: T) => {
-  return (
-    Array.isArray(thing) === true
-      ? // proxy thing back as it's already an array
-        thing
-      : typeof thing === "undefined"
-      ? ([] as T[])
-      : [thing]
-  ) as AsArray<T>;
-};

package/src/runtime/lists/createComparison.ts

@@ -1,15 +0,0 @@
-import {  ComparatorOperation, Comparison, ParamsForComparison, Narrowable } from "inferred-types/dist/types/index";
-
-/**
- * **createComparison**(op, ...args)
- *
- * Creates a _future_ comparison which can be used with the `filter`, `retain`, and
- * other runtime utilities.
- */
-export const createComparison = <
-  TOp extends ComparatorOperation,
-  TArgs extends readonly Narrowable[]
->(_op: TOp, ...args: TArgs & ParamsForComparison<TOp>) => {
-  return [args[0],...args.slice(1)] as unknown as Comparison<TOp, typeof args>
-}
-

package/src/runtime/lists/createConverter.ts

@@ -1,104 +0,0 @@
-
-import type {
-  Narrowable,
-  ConverterDefn,
-  Tuple,
-  Nothing,
-  AnyObject,
-  TypedFunction
-} from "inferred-types/dist/types/index";
-
-import { Never } from "inferred-types/dist/constants/index";
-import { isNothing, isObject } from "src/runtime/index";
-
-type CallIfDefined<
-  Handler
-> = Handler extends TypedFunction
-  ? 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 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>>) {
-  return <TInput extends Narrowable | Tuple>(input: TInput) => {
-    let result: unknown;
-    if (isNothing(input)) {
-      result = (mapper.nothing
-        ? mapper.nothing(input as TInput & Nothing)
-        : Never
-      )
-    } else if (isObject(input)) {
-      result = (mapper.object
-        ? mapper.object(input as TInput & AnyObject)
-        : Never
-      )
-    } else {
-      switch (typeof input) {
-        case "string":
-          result = (mapper.string
-            ? mapper.string(input)
-            : Never);
-          break;
-        case "number":
-        case "bigint":
-          result = (mapper.number
-            ? mapper.number(input as any)
-            : Never);
-          break;
-        case "boolean":
-          result = (mapper.boolean
-            ? mapper.boolean(input as any)
-            : Never);
-          break;
-        default:
-          throw new Error(`Unhandled type: ${typeof input}`);
-      }
-    }
-    return result as ConversionResult<typeof mapper, TInput>;
-  };
-
-}

package/src/runtime/lists/filter.ts

@@ -1,62 +0,0 @@
-// import { Filter,   Comparison } from "inferred-types/dist/types/index";
-// import { isSameTypeOf } from "../type-guards/higher-order/isSameTypeOf";
-// import {  endsWith,startsWith } from "../type-guards";
-// import { asArray } from "./asArray";
-// import { Never } from "inferred-types/dist/constants/index";
-
-
-// /**
-//  * **createFilter**(op,comparator) → (list) → _filtered results_
-//  *
-//  * A higher order runtime utility.
-//  *
-//  * - on it's first call it specifies the comparison that will be
-//  * made in the future
-//  * ```ts
-//  * const filterOutStrings = createFilter("extends", s => s.string())
-//  * ```
-//  *  - all subsequent calls will receive an array of items and _filter out_
-//  * the specified criteria
-//  * ```ts
-//  * // ["foo", "bar"]
-//  * filterOutStrings([1,2,"foo","bar"]);
-//  * ```
-//  */
-// export const createFilter = <
-//   TComparison extends Comparison
-// >(
-//   comparison: TComparison
-// ) => <
-//  TList extends readonly unknown[]
-// >(list: TList) => {
-//   let result: unknown;
-
-
-
-//   switch(op) {
-//     case "equals":
-//       result = list.filter(i => i === comparator);
-//       break;
-//     case "extends":
-//       result = list.filter(i => isSameTypeOf(i)(comparator));
-//       break;
-//     case "startsWith":
-//       result =  list.filter(i => startsWith(String(comparator))(String(i)));
-//       break;
-//     case "endsWith":
-//       result = list.filter(i => endsWith(String(comparator))(String(i)));
-//       break;
-//     case "contains":
-//       result = list.filter(i => contains(asArray(comparator))(i));
-//       break;
-//     case "containsAll":
-//       // result = list.filter(i => contains())
-//       break;
-//     default:
-//       result = Never
-//   }
-
-//   return result as Filter<TList, TComparator, TOp>;
-// };
-
-export const filter = "NOT READY";

package/src/runtime/lists/find.ts

@@ -1,51 +0,0 @@
-import {
-  Find ,
-  FromDefn,
-  Narrowable,
-  ShapeCallback,
-  Tuple
-} from "inferred-types/dist/types/index";
-import { isContainer } from "src/runtime/index";
-
-
-/**
- * **Finder**
- *
- * A configured utility designed to find elements in a list.
- */
-export type Finder<
-  TList extends Tuple,
-  TDeref extends string | number | null
-> = <TExtends extends Narrowable | ShapeCallback>(value: TExtends) => Find<
-  TList,
-  "equals",
-  FromDefn<TExtends>,
-  TDeref
->;
-
-/**
- * **find**(list, [deref]) => (value) => el | undefined
- *
- * A higher order function that allows _finding_ an element in a list
- * while preserving any available type information.
- */
-export const find = <
-  TList extends Tuple,
-  TDeref extends string | number | null = null
->(
-  list: TList,
-  deref: TDeref = null as TDeref
-): Finder<TList, TDeref> => <
-  TExtends extends Narrowable | ShapeCallback
->(comparator: TExtends): Find<TList, "equals", FromDefn<TExtends>, TDeref> => {
-
-  return list.find((i: any) => {
-    const val = deref
-      ? isContainer(i)
-        ? deref in i ? i[deref] : undefined
-        : i
-      : i;
-    return val === comparator;
-  }) as unknown as Find<TList, "equals", FromDefn<TExtends>, TDeref>;
-};
-

package/src/runtime/lists/getEach.ts

@@ -1,48 +0,0 @@
-
-import type { Container, GetEach } from "inferred-types/dist/types/index";
-
-import { Never } from "inferred-types/dist/constants/index";
-import { isContainer, isErrorCondition, isNull, get } from "src/runtime/index";
-
-export interface GetEachOptions<
-  THandleErrors
-> {
-  handleErrors?: THandleErrors;
-}
-
-/**
- * **getEach**(list, dotPath, [options])
- *
- * Returns a specific _property_ (from an object) or _index_ (from an array) from a list
- * of items.
- *
- * - the options allow for a "default value" to be substituted for any _undefined_ or _never_ values
- * - errors in looking up dotpath's will -- by default -- be removed as this is typically the desired behavior but you can also choose from:
- *    - `to-never`: converts _type_ to `never` but runtime maintains error message
- *    - `report`: both _type_ and runtime are in the `ErrorCondition` format
- * - the dotpath is VueJS aware of possible `Ref<T>` objects and will gracefully navigate
- * over them without the need to offset by `.value`
- */
-export function getEach<
-  TList extends readonly unknown[],
-  TDotPath extends string | null,
->(
-  list: TList,
-  dotPath: TDotPath,
-): GetEach<[...TList], TDotPath> {
-
-  const result: unknown =  list
-    .map(i => isNull(dotPath)
-        ? i
-        : isContainer(i)
-          ? get(i as Container, dotPath as TDotPath & string )
-          : Never
-      )
-    .filter(i => !isErrorCondition(i));
-
-    return result as GetEach<
-      [...TList],
-      TDotPath
-    >;
-}
-

package/src/runtime/lists/index.ts

@@ -1,26 +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 "./getEach";
-export * from "./indexOf";
-export * from "./intersection";
-export * from "./unique";
-export * from "./logicalReturns";
-export * from "./find";
-export * from "./filter";
-export * from "./createConverter";
-export * from "./slice";
-export * from "./last";
-export * from "./reverse";
-export * from "./join";
-export * from "./shift";
-
-// #endregion auto-indexed files
-
-// see https://github.com/inocan-group/do-devops/docs/autoindex.md
-// for more info

package/src/runtime/lists/indexOf.ts

@@ -1,58 +0,0 @@
-import {
-  IndexOf,
-  Narrowable,
-  Tuple
-} from "inferred-types/dist/types/index";
-import {
-  errCondition,
-  isArray,
-  isNull,
-  isNumber,
-  isObject
-} from "src/runtime/index";
-
-/**
- * **indexOf**(val, index)
- *
- * A dereferencing utility which receives a **value** and an **index** and then
- * returns `value[idx]`.
- *
- * - If the _index_ is passed in as a `null` value then no dereferencing will be done
- * and it will simply pass back the _value_.
- * - If an array is passed in, you are allowed to use negative values to dereference
- * off the back of the array.
- */
-export function indexOf<
-  TContainer extends Narrowable | Tuple,
-  TIdx extends PropertyKey | null
->(val: TContainer, index: TIdx) {
-
-  const isNegative = isNumber(index) && index < 0;
-  if (isNegative && !Array.isArray(val)) {
-    throw new Error(`The indexOf(val,idx) utility received a negative index value [${index}] but the value being de-references is not an array [${typeof val}]!`);
-  }
-  if (isNegative && Array.isArray(val) && val.length < Math.abs(index)) {
-    throw new Error(`The indexOf(val,idx) utility received a negative index of ${index} but the length of the array passed in is only ${val.length}! This is not allowed.`);
-  }
-
-  /** real index after considering negative indexing */
-  const idx = isNegative && Array.isArray(val)
-    ? val.length + 1 - Math.abs(index)
-    : index;
-
-  return (
-    index === null
-      ? val
-      : isNull(idx)
-        ? val
-        : isArray(val)
-          ? Number(idx as PropertyKey) in val
-            ? val[Number(idx)]
-            : errCondition("invalid-index", `attempt to index a numeric array with an invalid index: ${Number(idx)}`)
-          : isObject(val)
-            ? String(idx as PropertyKey) in val
-              ? val[String(idx) as keyof TContainer]
-              : errCondition("invalid-index", `attempt to index a dictionary object with an invalid index: ${String(idx)}`)
-            : errCondition("invalid-container-type", `Attempt to use indexOf() on an invalid container type: ${typeof val}`)
-  ) as unknown as IndexOf<TContainer, TIdx>;
-}

package/src/runtime/lists/intersection.ts

@@ -1,69 +0,0 @@
-import type { Container, Intersection, } from "inferred-types/dist/types/index";
-import { isIndexable, getEach,  get } from "src/runtime/index";
-import { ifNotNull } from "../boolean-logic/ifNotNull";
-
-function intersectWithOffset<
-  A extends readonly unknown[],
-  B extends readonly unknown[],
-  TDeref extends string | number
->(a: A, b: B, deref: TDeref) {
-  const aIndexable = a.every(i => isIndexable(i));
-  const bIndexable = b.every(i => isIndexable(i));
-
-  if (!aIndexable || !bIndexable) {
-    if (!aIndexable) {
-      throw new Error(`The "a" array passed into intersect(a,b) was not fully composed of indexable properties: ${a.map(i => typeof i).join(", ")}`);
-    } else {
-      throw new Error(`The "b" array passed into intersect(a,b) was not fully composed of indexable properties: ${b.map(i => typeof i).join(", ")}`);
-    }
-  }
-
-  const aMatches = getEach(a, deref as any) as readonly unknown[];
-  const bMatches = getEach(b, deref as any) as readonly unknown[];
-
-  const sharedKeys = ifNotNull(
-    deref,
-    v => [
-      a.filter(i => Array.from(bMatches).includes(get(i as Container, v as string | null))),
-      b.filter(i => Array.from(aMatches).includes(get(i as Container, v as string | null)))
-    ],
-    () => a.filter(k => b.includes(k))
-  );
-
-  return sharedKeys;
-}
-
-function intersectNoOffset<
-  A extends readonly unknown[],
-  B extends readonly unknown[],
->(a: A, b: B) {
-  return a.length < b.length
-    ? a.filter((val) => b.includes(val))
-    : b.filter((val) => a.includes(val));
-}
-
-/**
- * **intersection**(a,b,[deref])
- *
- * A set operation which provides the _intersection_ between
- * between two array's `a` and `b`.
- *
- * - when passing in arrays, you may also pass in a _dereferencing_ property
- * which will be used for arrays of objects (or sub-arrays) so that the comparison
- * is done on the dereferenced value versus the value as a whole.
- */
-export const intersection = <
-  A extends readonly unknown[],
-  B extends readonly unknown[],
-  TDeref extends string | null = null
->(
-  a: A,
-  b: B,
-  deref: TDeref = null as TDeref
-): Intersection<A, B, TDeref> => {
-  return (
-    deref === null
-      ? intersectNoOffset(a, b) as unknown
-      : intersectWithOffset(a, b, deref) as unknown
-  ) as unknown as Intersection<A, B, TDeref>;
-};

package/src/runtime/lists/join.ts

@@ -1,34 +0,0 @@
-import { Tuple, Join } from "inferred-types/dist/types/index";
-
-export type Joiner<
-  TJoin extends string> = <TContent extends Tuple<string>
->(...tuple: TContent) => Join<TContent,TJoin>;
-
-
-/**
- * **join**(joinWith)(tuple) -> joined
- *
- * A higher order runtime utility which provides the ability to create
- * type-strong join's with an array of string and a joining string.
- *
- * ```ts
- * // "hello world"
- * const helloWorld = join("")("hello", " ", "world");
- * // "foo, bar, baz"
- * const list = join(", ")("foo", "bar", "baz");
- * ```
- */
-export function joinWith<TJoin extends string>(
-  joinWith: TJoin
-) {
-
-  /**
-   * add elements of the tuple you want to join
-   */
-  return <TContent extends readonly string[]>(
-    ...tuple: TContent
-  ): Join<TContent,TJoin> => {
-    const tup: readonly string[] = tuple;
-    return tup.join(joinWith) as unknown as Join<TContent,TJoin>
-  };
-}

package/src/runtime/lists/last.ts

@@ -1,5 +0,0 @@
-import { Last, Tuple } from "inferred-types/dist/types/index";
-
-export const last = <T extends Tuple>(list: T): Last<T> => {
-  return [...list].pop() as Last<T>;
-};

package/src/runtime/lists/logicalReturns.ts

@@ -1,18 +0,0 @@
-import { LogicFunction, LogicalReturns } from "inferred-types/dist/types/index";
-import { isBoolean, isFunction } from "src/runtime/index";
-import { Never } from "inferred-types/dist/constants/index";
-
-
-export function logicalReturns<
-  TConditions extends readonly (boolean | LogicFunction)[],
->(conditions: TConditions) {
-
-  return conditions.map(c => isBoolean(c)
-    ? c
-    : isFunction(c)
-      ? c()
-      : Never
-  ) as unknown as LogicalReturns<TConditions>;
-
-}
-

package/src/runtime/lists/reverse.ts

@@ -1,10 +0,0 @@
-import { Reverse } from "inferred-types/dist/types/index";
-
-/**
- * **reverse**(list)
- *
- * Allows reversing the order of a readonly array and preserving the types.
- */
-export const reverse = <T extends readonly unknown[]>(list: T): Reverse<T> => {
-  return [...list].reverse() as unknown as Reverse<T>;
-};

package/src/runtime/lists/shift.ts

@@ -1,66 +0,0 @@
-import {
-  First,
-  IsEqual,
-  IsUndefined,
-  Narrowable,
-} from "inferred-types/dist/types/index";
-import { isDefined } from "src/runtime/index";
-
-type Rtn<
-  T extends readonly K[] | K[] | undefined,
-  K extends Narrowable
-> = IsUndefined<T> extends true
-  ? undefined
-  : T extends readonly K[] | K[]
-  ? IsEqual<T["length"], number> extends true
-    ? undefined | string
-    : T["length"] extends 0
-      ? undefined
-      : First<T>
-  : never;
-
-/**
- * **shift**(list)
- *
- * Takes a list of elements and:
- *
- * - if the list is empty returns _undefined_
- * - otherwise returns the first element in the list
- *
- * **Note:** unlike using the builtin `ARR.shift()` method:
- *
- * - the source array is _never_ mutated
- * - you can shift off the first element of the readonly array as well a mutable one
- * (because the underlying array is _not_ mutated)
- * - in **many** cases, you should be using a queue of some sort with utils like
- * `createLifoQueue()` or `createFifoQueue()`
- *
- */
-export const shift = <
-  T extends  readonly K[] | K[] | undefined,
-  K extends Narrowable
->(list: T): Rtn<T,K> => {
-  let rtn;
-  if (isDefined(list)) {
-    rtn = (
-      list.length === 0
-        ? undefined
-        : list[0]
-    ) as First<T>;
-
-    try {
-      // remove item from source array where possible
-      // note: not possible when array is frozen by being
-      // made readonly
-      list = list.slice(1) as any;
-    } catch {
-      // ignore
-    }
-
-  } else {
-    rtn = undefined;
-  }
-
-  return rtn as Rtn<T,K>;
-};
-

package/src/runtime/lists/slice.ts

@@ -1,16 +0,0 @@
-import { Slice, Tuple } from "inferred-types/dist/types/index";
-
-/**
- * **slice**(list, start, end)
- *
- * Runtime utility to slice an array while maintaining strong
- * types.
- */
-export const slice = <
-  TList extends Tuple,
-  TStart extends number,
-  TEnd extends number
->(list: TList, start: TStart, end: TEnd) => {
-  return list.slice(start,end) as Slice<TList,TStart,TEnd>;
-};
-

package/src/runtime/lists/unique.ts

@@ -1,26 +0,0 @@
-import {  First,  Narrowable,  UnionToTuple, Unique } from "inferred-types/dist/types/index";
-
-
-/**
- * **unique**
- *
- * Runtime utility which removes intersecting values from two sets and
- * provides a unique values contained in each set.
- */
-export const unique = <
-N extends Narrowable,
-K extends number,
-T extends readonly (Record<K,N> | Narrowable)[]
->(...values: T) => {
-
-  const u: any[] = [];
-  for (const i of values.flat()) {
-    if(!u.includes(i)) {
-      u.push(i);
-    }
-  }
-
-  return u as First<T> extends readonly (Record<K,N> | Narrowable)[]
-      ? Unique<UnionToTuple<First<T>>>
-    : Unique<T>;
-}