inferred-types 0.36.4 → 0.37.1

package/src/runtime/state/FluentConfigurator.ts

@@ -1,49 +0,0 @@
-import { ExpandRecursively } from "src/types/ExpandRecursively";
-
-export interface IFluentConfigurator<C> {
-  /**
-   * **set**
-   *
-   * Sets a new key/value pair to the configurator.
-   *
-   * @param key the key to put this new configuration item
-   * @param value the value of the configuration item
-   */
-  set<V, K extends string, KV = { [U in K]: V }>(key: K, value: V): IFluentConfigurator<C & KV>;
-  done(): ExpandRecursively<C>;
-}
-
-/**
- * This function will return a basic _configurator_ API surface which allows
- * you to add name/value pairs to a growing dictionary of strongly typed data.
- *
- * When configuration is complete, you call the `done()` endpoint and the typed
- * configuration will be returned with the API removed.
- *
- * > **Note:** the approach taken here requires that you configure using a **fluent style**
- * exclusively. If you don't the non-fluent properties set will not show up
- * in the typing or the run-time object.
- */
-export function FluentConfigurator<I>(initial: I = {} as I) {
-  const api = <C>(current: C): IFluentConfigurator<C> => {
-    return {
-      set<V, K extends string, KV = { [U in K]: V }>(key: K, value: V) {
-        const keyValue = { [key]: value as V } as unknown as KV;
-        const updated = { ...keyValue, ...current };
-
-        return api<C & KV>(updated);
-      },
-      done() {
-        return current as ExpandRecursively<C>;
-      },
-    };
-  };
-
-  if (initial && typeof initial !== "object") {
-    throw new Error(
-      "The FluentConfigurator was passed a non-object based value as the initial value. This is not allowed."
-    );
-  }
-
-  return initial ? api(initial) : api({});
-}

package/src/runtime/state/index.ts

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

package/src/runtime/type-checks/ifSameType.ts

@@ -1,20 +0,0 @@
-import { Narrowable, Not, Widen } from "src/types";
-
-export function ifSameType<
-  TValue extends Narrowable,
-  TType extends string | number | boolean | object,
-  IF extends Narrowable,
-  ELSE extends Narrowable
->(
-  value: TValue,
-  comparisonType: TType,
-  ifExtends: <T extends TType & TValue>(v: T) => IF,
-  doesNotExtend: (v: Not<TValue, TType>) => ELSE
-) {
-  return (
-    // runtime values match
-    (
-      typeof value === typeof comparisonType ? ifExtends(value as any) : doesNotExtend(value as any)
-    ) as Widen<TValue> extends Widen<TType> ? IF : ELSE
-  );
-}

package/src/runtime/type-checks/ifTypeOf.ts

@@ -1,124 +0,0 @@
-import { Narrowable } from "src/types/Narrowable";
-import { keys } from "../keys";
-
-function runtimeExtendsCheck<TValue extends any, TBase extends any>(
-  val: TValue,
-  base: TBase,
-  narrow: boolean = false
-): TValue extends TBase ? true : false {
-  if (typeof val !== typeof base) {
-    return false as TValue extends TBase ? true : false;
-  }
-
-  switch (typeof val) {
-    case "boolean":
-    case "string":
-    case "number":
-    case "symbol":
-    case "bigint":
-      return narrow
-        ? ((val === base) as TValue extends TBase ? true : false)
-        : (true as TValue extends TBase ? true : false);
-    case "undefined":
-      return true as TValue extends TBase ? true : false;
-    case "function":
-      if (narrow) {
-        throw new Error(`Use of narrowlyExtends with a function is not possible!`);
-      }
-      return true as TValue extends TBase ? true : false;
-    case "object":
-      if (val === null && base === null) {
-        return true as TValue extends TBase ? true : false;
-      } else {
-        return keys(base as object).every((i) =>
-          runtimeExtendsCheck((val as TValue)[i], base[i], narrow)
-        ) as TValue extends TBase ? true : false;
-      }
-  }
-}
-
-/**
- * A conditional clause used in the application of the `ifTypeOf` utility
- */
-export type ExtendsClause<
-  N extends Narrowable,
-  TValue extends Record<keyof TValue, N> | number | string | boolean | symbol
-> = <TBase extends any>(base: TBase) => TValue extends TBase ? true : false;
-
-/**
- * A conditional clause used in the application of the `ifTypeOf` utility
- */
-export type ExtendsNarrowlyClause<
-  N extends Narrowable,
-  TValue extends Record<keyof TValue, N> | number | string | boolean | symbol
-> = <
-  NB extends Narrowable,
-  TBase extends Record<keyof TBase, NB> | number | string | boolean | symbol
->(
-  base: TBase
-) => TValue extends TBase ? true : false;
-
-/**
- * **TypeCondition**
- *
- * A partially applied type from the `ifTypeOf` utility where the base type has been
- * defined and we now need to express the type which is intended to extend it.
- *
- * - `extends` - compares with _wide_ types
- * - `narrowlyExtends` - compares with _narrow_ / _literal_ types
- */
-export type TypeCondition<
-  N extends Narrowable,
-  TValue extends Record<keyof TValue, N> | number | string | boolean | symbol
-> = {
-  extends: ExtendsClause<N, TValue>;
-  narrowlyExtends: ExtendsNarrowlyClause<N, TValue>;
-};
-
-export const ifTypeOf = <
-  N extends Narrowable,
-  TValue extends Record<keyof TValue, N> | number | string | boolean | symbol
->(
-  val: TValue
-): TypeCondition<N, TValue> => ({
-  extends: <TBase extends any>(base: TBase) => {
-    const valid = runtimeExtendsCheck(val, base, false);
-    const trueFalse = (valid ? true : false) as TValue extends TBase ? true : false;
-    return (
-      {
-        then: <TResult extends any>(then?: TResult) => ({
-          else: <TElse extends any>(elseVal: TElse) => {
-            return (
-              valid ? (typeof then === "undefined" ? val : then) : elseVal
-            ) as TValue extends TBase ? (TResult extends undefined ? TValue : TResult) : TElse;
-          },
-        }),
-        else: <TElse extends any>(elseVal: TElse) =>
-          valid ? val : (elseVal as TValue extends TBase ? TValue : TElse),
-      } && trueFalse
-    );
-  },
-
-  narrowlyExtends: <
-    NB extends Narrowable,
-    TBase extends Record<keyof TBase, NB> | number | string | boolean | symbol
-  >(
-    base: TBase
-  ) => {
-    const valid = runtimeExtendsCheck(val, base, true);
-    const trueFalse = (valid ? true : false) as TValue extends TBase ? true : false;
-    return (
-      {
-        then: <TResult extends any>(then?: TResult) => ({
-          else: <TElse extends any>(elseVal: TElse) => {
-            return (
-              valid ? (typeof then === "undefined" ? val : then) : elseVal
-            ) as TValue extends TBase ? (TResult extends undefined ? TValue : TResult) : TElse;
-          },
-        }),
-        else: <TElse extends any>(elseVal: TElse) =>
-          valid ? val : (elseVal as TValue extends TBase ? TValue : TElse),
-      } && trueFalse
-    );
-  },
-});

package/src/runtime/type-checks/index.ts

@@ -1,24 +0,0 @@
-// #autoindex
-
-// #region auto-indexed files
-// index last changed at: 8th Aug, 2022, 09:51 AM ( GMT-7 )
-// hash-code: 4324574d
-
-// file exports
-export * from "./ifSameType";
-export * from "./isArray";
-export * from "./isBoolean";
-export * from "./isFalse";
-export * from "./isFunction";
-export * from "./isNull";
-export * from "./isNumber";
-export * from "./isObject";
-export * from "./isString";
-export * from "./isSymbol";
-export * from "./isTrue";
-export * from "./isUndefined";
-
-// #endregion auto-indexed files
-
-// see https://github.com/inocan-group/do-devops/docs/autoindex.md
-// for more info

package/src/runtime/type-checks/isArray.ts

@@ -1,34 +0,0 @@
-import { IsArray, IfArray } from "src/types/boolean-logic/array";
-import { Narrowable } from "src/types/Narrowable";
-
-export function isArray<T>(i: T) {
-  return (Array.isArray(i) === true) as IsArray<T>;
-}
-
-/**
- * **ifArray**(T, IF, ELSE)
- *
- * A utility which evaluates a type `T` for whether it is an array and then
- */
-export function ifArray<
-  // value which is possibly an array
-  T extends Narrowable,
-  // functions which return a known type
-  IF extends Narrowable,
-  ELSE extends Narrowable
->(
-  val: T,
-  isAnArray: <N extends T & readonly any[]>(arr: N) => IF,
-  isNotAnArray: <N extends Exclude<T, any[]>>(nonArr: N) => ELSE
-) {
-  return (isArray(val) ? isAnArray(val as any) : isNotAnArray(val as any)) as IfArray<T, IF, ELSE>;
-}
-
-export function ifArrayPartial<T extends Narrowable>() {
-  return <IF extends Narrowable, ELSE extends Narrowable>(
-    isAnArray: <N extends T & readonly any[]>(arr: N) => IF,
-    isNotAnArray: <N extends Exclude<T, any[]>>(nonArr: N) => ELSE
-  ) => {
-    return <V extends T>(val: V) => ifArray(val, isAnArray, isNotAnArray);
-  };
-}

package/src/runtime/type-checks/isBoolean.ts

@@ -1,24 +0,0 @@
-import { Narrowable } from "src/types";
-import { IsBoolean } from "src/types/boolean-logic";
-
-/**
- * Runtime and type checks whether a variable is a boolean value.
- */
-export function isBoolean<T extends Narrowable>(i: T): IsBoolean<T> {
-  return (typeof i === "boolean") as IsBoolean<T>;
-}
-
-/**
- * **ifBoolean**
- *
- * Strongly type-aware conditional statement which checks whether a value is
- * a _boolean_ 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 _boolean_
- * @param elseVal the value (strongly typed) returned if val is NOT a _boolean
- */
-export function ifBoolean<T, IF, ELSE>(val: T, ifVal: IF, elseVal: ELSE) {
-  return (isBoolean(val) ? ifVal : elseVal) as IsBoolean<T> extends true ? IF : ELSE;
-}

package/src/runtime/type-checks/isFalse.ts

@@ -1,29 +0,0 @@
-import { IfFalse, IsFalse } from "src/types/boolean-logic/boolean";
-import { Narrowable } from "src/types/Narrowable";
-
-export function isFalse<T>(i: T) {
-  return (typeof i === "boolean" && !i) as IsFalse<T>;
-}
-
-/**
- * **ifTrue**
- *
- * Strongly type-aware conditional statement which checks whether a value is
- * a _true_ 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 _true_ value
- * @param elseVal the value (strongly typed) returned if val is NOT a _true_ value
- *
- * Note: at runtime there's no way to distinguish if the value was widely or loosely
- * typed so unlike the type utility there is no "MAYBE" state but if a wide type if
- * encountered the _type_ will the union of `IF` and `ELSE`.
- */
-export function ifFalse<T extends boolean, IF extends Narrowable, ELSE extends Narrowable>(
-  val: T,
-  ifVal: IF,
-  elseVal: ELSE
-) {
-  return (isFalse(val) ? ifVal : elseVal) as IfFalse<T, IF, ELSE, IF | ELSE>;
-}

package/src/runtime/type-checks/isFunction.ts

@@ -1,26 +0,0 @@
-import { FunctionType } from "src/types/FunctionType";
-
-export type IsFunction<T> = T extends FunctionType ? true : false;
-
-export type HybridFunction<TProps extends {}> = (<TArgs extends any[]>(...args: TArgs) => any) &
-  TProps;
-
-export type SimpleFunction = (...args: any[]) => any;
-
-export type AnyFunction<TProps extends {} = {}> = SimpleFunction | HybridFunction<TProps>;
-
-/**
- * Checks whether a passed in value is a function and ensures run-time and types
- * are consistent.
- * ```ts
- * // true
- * const yup = isFunction(() => "hello world");
- * ```
- *
- * Note: the runtime `typeof [variable]` will correctly say "function" when a function is
- * encountered but if that function also has object types defined then the type will be a big
- * and ugly union type. This function will give you a proper boolean value in both cases.
- */
-export function isFunction<T>(input: T): IsFunction<T> {
-  return (typeof input === "function" ? true : false) as IsFunction<T>;
-}

package/src/runtime/type-checks/isNull.ts

@@ -1,26 +0,0 @@
-import { Narrowable } from "src/types";
-
-export type IsNull<T> = T extends null ? true : false;
-
-export function isNull<T extends Narrowable>(i: T) {
-  return (i === null) as T extends null ? true : false;
-}
-
-/**
- * **ifNull**
- *
- * Strongly type-aware conditional statement which checks whether a value is
- * Null 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 `null`
- * @param elseVal the value (strongly typed) returned if val is NOT `null`
- */
-export function ifNull<T extends Narrowable, IF extends Narrowable, ELSE extends Narrowable>(
-  val: T,
-  ifVal: IF,
-  elseVal: ELSE
-) {
-  return (isNull(val) ? ifVal : elseVal) as IsNull<T> extends true ? IF : ELSE;
-}

package/src/runtime/type-checks/isNumber.ts

@@ -1,20 +0,0 @@
-export type IsNumber<T> = T extends number ? true : false;
-
-export function isNumber<T>(i: T) {
-  return (typeof i === "number") as T extends number ? true : false;
-}
-
-/**
- * **ifNumber**
- *
- * Strongly type-aware conditional statement which checks whether a value is
- * a _number_ 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 number
- * @param elseVal the value (strongly typed) returned if val is NOT a number
- */
-export function ifNumber<T, IF, ELSE>(val: T, ifVal: IF, elseVal: ELSE) {
-  return (isNumber(val) ? ifVal : elseVal) as IsNumber<T> extends true ? IF : ELSE;
-}

package/src/runtime/type-checks/isObject.ts

@@ -1,22 +0,0 @@
-import { FunctionType, Narrowable, Not } from "src/types";
-import { IfObject, IsObject } from "src/types/boolean-logic";
-
-export type ObjectType = Not<Record<string, Narrowable>, FunctionType>;
-
-/**
- * Detects whether the passed in `v` is of type "object" where an object
- * is defined to be a string keyed dictionary style object. This means that
- * arrays are excluded, as well as functions which also have properties hanging
- * off of them.
- */
-export function isObject<T extends Narrowable>(i: T) {
-  return (typeof i === "object" && i !== null && Array.isArray(i) === false) as IsObject<T>;
-}
-
-export function ifObject<T extends Narrowable, IF extends Narrowable, ELSE extends Narrowable>(
-  val: T,
-  ifObj: IF,
-  notObj: ELSE
-): IfObject<T, IF, ELSE> {
-  return (isObject(val) ? ifObj : notObj) as IfObject<T, IF, ELSE>;
-}

package/src/runtime/type-checks/isString.ts

@@ -1,34 +0,0 @@
-import { Narrowable } from "src/types/Narrowable";
-import { IfString, IsString } from "src/types/boolean-logic/string";
-
-/**
- * **isString**
- *
- * Returns true or false on whether the passed in parameter is a
- * string (either a wide string or a string literal).
- *
- * The boolean return is traceable by the type system as well as the
- * runtime system.
- */
-export function isString<T>(i: T) {
-  return (typeof i === "string") as IsString<T>;
-}
-
-/**
- * **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<T extends Narrowable, IF extends Narrowable, ELSE extends Narrowable>(
-  val: T,
-  ifVal: <E extends string>(t: E & T) => IF,
-  elseVal: ELSE
-) {
-  return (isString(val) ? ifVal : elseVal) as IfString<T, IF, ELSE>;
-}

package/src/runtime/type-checks/isSymbol.ts

@@ -1,3 +0,0 @@
-export function isSymbol<T>(i: T) {
-  return (typeof i === "symbol") as T extends symbol ? true : false;
-}

package/src/runtime/type-checks/isTrue.ts

@@ -1,31 +0,0 @@
-import { IfTrue, IsTrue } from "src/types/boolean-logic";
-import { Narrowable } from "src/types/Narrowable";
-
-/**
- * Run-time and type checking of whether a variable is `true`.
- */
-export function isTrue<T extends Narrowable>(i: T) {
-  return (typeof i === "boolean" && i === true) as IsTrue<T>;
-}
-
-/**
- * **ifTrue**
- *
- * Strongly type-aware conditional statement which checks whether a value is
- * _true_.
- *
- * @param val the value being tested
- * @param ifVal the value (strongly typed) returned if val is _true_ value
- * @param elseVal the value (strongly typed) returned if val is NOT a _true_ value
- *
- * Note: at runtime there's no way to distinguish if the value was widely or loosely
- * typed so unlike the type utility there is no "MAYBE" state but if a wide type if
- * encountered the _type_ will the union of `IF` and `ELSE`.
- */
-export function ifTrue<T extends boolean, IF extends Narrowable, ELSE extends Narrowable>(
-  val: T,
-  ifVal: IF,
-  elseVal: ELSE
-) {
-  return (isTrue(val) ? ifVal : elseVal) as IfTrue<T, IF, ELSE, IF | ELSE>;
-}

package/src/runtime/type-checks/isUndefined.ts

@@ -1,33 +0,0 @@
-import { Narrowable } from "src/types";
-import { IsUndefined } from "src/types/boolean-logic/IsUndefined";
-
-export function isUndefined<T extends Narrowable>(i: T) {
-  return (typeof i === "undefined") as undefined extends T ? true : false;
-}
-
-/**
- * **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<T extends Narrowable, IF extends Narrowable, ELSE extends Narrowable>(
-  val: T,
-  ifVal: IF,
-  elseVal: ELSE
-) {
-  return (isUndefined(val) ? ifVal : elseVal) as IsUndefined<T> extends true ? IF : ELSE;
-}
-
-export function ifDefined<T extends Narrowable, IF extends Narrowable, ELSE extends Narrowable>(
-  val: T,
-  ifVal: <V extends Exclude<T, undefined>>(v: V) => IF,
-  elseVal: ELSE
-) {
-  return (isUndefined(val) ? ifVal : elseVal) as IsUndefined<T> extends true ? IF : ELSE;
-}

package/src/runtime/type-checks/startsWith.ts

@@ -1,107 +0,0 @@
-import { Narrowable } from "src/types";
-import { IfStartsWith, StartsWith } from "src/types/boolean-logic";
-import { IfUndefined } from "src/types/boolean-logic/IsUndefined";
-import { createFnWithProps } from "../createFnWithProps";
-import { box, Box } from "../literals";
-import { ifTrue } from "./isTrue";
-
-/**
- * **startsWith**
- *
- * A higher-order and type strong way to checking whether a string literal `<T>` starts with
- * another known string literal `<S>`:
- * ```ts
- * const answer = startsWith("foo")("foobar");
- * ```
- */
-export const startsWith =
-  <S extends string>(
-    /** The starting string you will test for */
-    start: S
-  ) =>
-  <T extends string>(
-    /** The text being tested */
-    input: T
-  ): StartsWith<T, S> => {
-    return input.startsWith(start) as StartsWith<T, S>;
-  };
-
-/**
- * **IfStartsWithFn**
- *
- * A function which comes from a partial application of the `ifStartsWith()`
- * utility. This type will receive a value `<T>` and _if_ this values starts
- * with `<S>` then the callback function will executed in a type strong manner.
- */
-export type IfStartsWith__Fn<
-  /** The "start with" constraint */
-  TStartsWith extends string,
-  TIf extends Box<<T extends string>(i: `${TStartsWith}${T}`) => any>,
-  TElse extends Box<(<T extends string>(i: T) => any) | undefined>
-> = <T extends string>(
-  val: T
-) => IfStartsWith<
-  T, //
-  TStartsWith,
-  // Condition Passes
-  ReturnType<TIf["value"]>,
-  // Condition Fails
-  IfUndefined<
-    TElse, //
-    undefined,
-    Exclude<TElse, undefined>
-  >
->;
-
-export type NarrowFn<N extends string> = <F extends <T extends string>(input: T) => any>(
-  fn: F
-) => (input: N) => Box<F>["unbox"];
-
-export const stringLiteralFn = <F extends <T extends string>(input: T) => any>(fn: F) => {
-  const b = box(fn);
-  const api = {
-    narrow<N extends string>() {
-      return (input: N) => b.unbox()(input);
-    },
-  };
-
-  return createFnWithProps(fn, api);
-};
-
-export type StringLiteralFn<S extends string = string> = <T extends S>(input: T) => any;
-
-/**
- * **ifStartsWith**
- *
- * Type strong way to move into a conditional execution block:
- * ```ts
- * // partial application
- * const mutate = ifStartsWith(
- *    "foo",
- *    i => `${i} is a foo`,
- *    i => `${i} ain't welcome in this town`
- * );
- * // type: `foobar is a foo`
- * const outcome = mutate("foobar");
- * ```
- *
- * Where the variable `i` will _extend_ a string and function which this utility
- * returns is able to
- */
-export const ifStartsWith =
-  <TStartsWith extends string, TIf extends Narrowable, TElse extends Narrowable>(
-    /** the string literal _start value_ which a string must begin with */
-    start: TStartsWith,
-    /** a mutation function when a value _does_ start with `TStartsWith` */
-    isTrue: <T extends string>(input: T) => TIf,
-    /** an optional mutation function */
-    isFalse: <T extends string>(input: T) => TElse
-  ) =>
-  <TTextValue extends string>(input: TTextValue) =>
-    ifTrue(
-      // condition
-      startsWith(start)(input),
-      // handlers
-      isTrue(input),
-      isFalse(input)
-    );