inferred-types 0.37.0 → 0.37.2

package/src/runtime/literals/box.ts

@@ -1,98 +0,0 @@
-import { AfterFirst, HasParameters, Narrowable } from "src/types";
-import { First } from "src/types/lists/First";
-import { keys } from "../keys";
-import { AnyFunction } from "../type-checks";
-
-export interface Box<T> {
-  __kind: "box";
-  value: T;
-  /**
-   * Unbox the boxed value in the narrowest possible type.
-   *
-   * **note:** if the boxed value is a function with parameters you
-   * can pass the parameters directly into the `b.unbox(params)` call.
-   */
-  unbox: HasParameters<Box<T>["value"]> extends true
-    ? Box<T>["value"] extends AnyFunction
-      ? Box<T>["value"] extends (...args: infer A) => infer R
-        ? <N extends A>(...args: N) => R
-        : () => ReturnType<T>
-      : () => T
-    : () => T;
-}
-
-export type BoxValue<T extends Box<any>> = T extends Box<infer V> ? V : never;
-
-export type BoxedFnParams<T extends Box<any>> = T extends Box<infer V>
-  ? V extends (...args: infer A) => any
-    ? A
-    : []
-  : [];
-
-export type BoxedReturn<T extends Box<any>> = T extends Box<infer V>
-  ? V extends Function
-    ? ReturnType<T["value"]>
-    : T["value"]
-  : never;
-
-export type NarrowBox<T> = <
-  N extends BoxedFnParams<Box<T>> | First<BoxedFnParams<Box<T>>>
->() => N extends BoxedFnParams<Box<T>>
-  ? T extends (...args: any[]) => any
-    ? (...args: N) => Box<T>["unbox"]
-    : never
-  : (first: N, ...rest: AfterFirst<BoxedFnParams<Box<T>>>) => BoxedReturn<Box<T>>;
-
-/**
- * Allows a value with an inner-type to be boxed into a dictionary
- * so that this type inference is preserved with the help of
- * [instantiation expressions](https://devblogs.microsoft.com/typescript/announcing-typescript-4-7-beta/#instantiation-expressions).
- *
- * NOTE: this feature is immature at best right now
- */
-export function box<T extends Narrowable>(value: T): Box<T> {
-  const rtn: Box<T> = {
-    __kind: "box",
-    value,
-    unbox: (<P extends any[], R extends Narrowable>(...p: P): R => {
-      return typeof value === "function" ? value(...p) : value;
-    }) as Box<T>["unbox"],
-  };
-
-  return rtn;
-}
-
-export function isBox(thing: Narrowable): thing is Box<any> {
-  return (
-    typeof thing === "object" && "__kind" in (thing as object) && (thing as any).__kind === "box"
-  );
-}
-
-/**
- * **boxDictionaryValues**(dict)
- *
- * Runtime utility which boxes each value in a dictionary
- */
-export function boxDictionaryValues<T extends {}>(dict: T) {
-  return keys(dict).reduce(
-    (acc, key) => ({ ...acc, [key]: box(dict[key]) }),
-    {} as {
-      [K in keyof T]: Box<T[K]>;
-    }
-  );
-}
-
-export type Unbox<T> = T extends Box<infer U> ? U : T;
-
-//TODO: it would make sense in the future to use `b.unbox` instead
-// of `b.value` to keep consistent but currently value behaves more
-// consistently and with somewhat stronger typing
-
-/**
- * **unbox**(maybeBox)
- *
- * Unboxes a value if it was a box; otherwise it leaves _as is_.
- */
-export function unbox<T>(val: T): Unbox<T> {
-  return isBox(val) ? val.value : val;
-}

package/src/runtime/literals/defineType.ts

@@ -1,20 +0,0 @@
-import { ExpandRecursively } from "src/types/ExpandRecursively";
-import { Narrowable } from "src/types/Narrowable";
-
-/**
- * Build a _type_ from two run-time dictionaries.
- *
- * 1. The _first_ -- which is optional -- is interpreted as a _literal_ type definition
- * 2. The _second_ dictionary is interpreted as a "wide" definition of prop types
- */
-export function defineType<N extends Narrowable, TLiteral extends Record<string, N>>(
-  literal: TLiteral = {} as TLiteral
-) {
-  /**
-   * Add any key/value pairs which you want to have _wide_ types associated;
-   * literal types are defined already and stated above.
-   */
-  return <TWide extends object>(wide: TWide = {} as TWide) => {
-    return (literal ? { ...wide, ...literal } : wide) as ExpandRecursively<TWide & TLiteral>;
-  };
-}

package/src/runtime/literals/ensureLeading.ts

@@ -1,17 +0,0 @@
-import { EnsureLeading } from "src/types/alphabetic";
-
-/**
- * **ensureLeading**(content, strip)
- *
- * Runtime utility which ensures that last part of a string -- `content` -- has the
- * substring `ensure` at the end and adds it if not present.
- */
-export function ensureLeading<T extends string, U extends string>(
-  content: T,
-  ensure: U
-): EnsureLeading<T, U> {
-  return (
-    //
-    (content.startsWith(ensure) ? content : `${ensure}${content}`) as EnsureLeading<T, U>
-  );
-}

package/src/runtime/literals/ensureTrailing.ts

@@ -1,17 +0,0 @@
-import { EnsureTrailing } from "../../types/alphabetic/EnsureTrailing";
-
-/**
- * **ensureTrailing**(content, strip)
- *
- * Runtime utility which ensures that last part of a string -- `content` -- has the
- * substring `ensure` at the end and adds it if not present.
- */
-export function ensureTrailing<T extends string, U extends string>(
-  content: T,
-  ensure: U
-): EnsureTrailing<T, U> {
-  return (
-    //
-    (content.endsWith(ensure) ? content : `${content}${ensure}`) as EnsureTrailing<T, U>
-  );
-}

package/src/runtime/literals/identity.ts

@@ -1,12 +0,0 @@
-import { Narrowable } from "src/types/Narrowable";
-
-/**
- * An identity function for any type, with the goal of preserving literal type information
- * whereever possible.
- */
-export const identity = <
-  N extends Narrowable,
-  T extends Record<any, N> | number | string | boolean | symbol | undefined | null
->(
-  v: T
-) => v;

package/src/runtime/literals/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: 7a22bbbc
-
-// file exports
-export * from "./ExplicitFunction";
-export * from "./arrayToObject";
-export * from "./box";
-export * from "./defineType";
-export * from "./identity";
-export * from "./literal";
-export * from "./stripTrailing";
-export * from "./ensureTrailing";
-export * from "./ensureLeading";
-export * from "./pathJoin";
-export * from "./Suggest";
-export * from "./wide";
-
-// #endregion auto-indexed files
-
-// see https://github.com/inocan-group/do-devops/docs/autoindex.md
-// for more info

package/src/runtime/literals/literal.ts

@@ -1,48 +0,0 @@
-/* eslint-disable no-use-before-define */
-
-import { Narrowable } from "src/types/Narrowable";
-
-/**
- * Takes an object as input --which has an `id` property and returns it as the same
- * run-time content but with the _type_ of the `id` property being forced to a literal type
- */
-export function idLiteral<T extends { id: I }, I extends PropertyKey>(o: T): T & { id: T["id"] } {
-  return { ...o, id: o.id };
-}
-
-/**
- * Takes an object as input --which has an `name` property and returns it as the same
- * run-time content but with the _type_ of the `name` property being forced to a literal type
- */
-export function nameLiteral<T extends { name: I }, I extends PropertyKey>(
-  o: T
-): T & { name: T["name"] } {
-  return o;
-}
-
-/**
- * Takes an object as input --which has an `kind` property and returns it as the same
- * run-time content but with the _type_ of the `kind` property being forced to a literal type
- */
-export function kindLiteral<T extends { kind: I }, I extends PropertyKey>(
-  o: T
-): T & { kind: T["kind"] } {
-  return o;
-}
-
-export function idTypeGuard<T extends { id: I }, I extends PropertyKey>(
-  _o: T
-): _o is T & { id: I } {
-  return true;
-}
-
-/**
- * Takes an object as input and infers the narrow literal types of the property
- * values on the object.
- *
- * > Note: this addresses this [a known TS gap](https://github.com/microsoft/TypeScript/issues/30680).
- * > Hopefully at some point this will be addressed in the language.
- */
-export function literal<N extends Narrowable, T extends Record<keyof T, N>>(obj: T) {
-  return obj;
-}

package/src/runtime/literals/pathJoin.ts

@@ -1,33 +0,0 @@
-import { PathJoin } from "src/types/alphabetic/PathJoin";
-import { ensureLeading } from "./ensureLeading";
-import { ensureTrailing } from "./ensureTrailing";
-import { stripLeading } from "./stripLeading";
-import { stripTrailing } from "./stripTrailing";
-
-/**
- * **pathJoin**`<T,U>(begin, ...rest)`
- *
- * Run time utility which joins two strings together with
- * the intent to have them be divided by a Posix `/` character
- * appropriate for Unix file paths and URLs.
- *
- * **note:** to support more than two paths being joined there
- * is now the ability to add a tuple of paths into the _rest_
- * parameter
- */
-export function pathJoin<T extends string, U extends readonly string[]>(
-  begin: T,
-  ...rest: U
-): PathJoin<T, U> {
-  const start = rest.length > 0 ? ensureTrailing(begin, "/") : begin;
-  const end = rest.length > 0 ? ensureLeading(rest.slice(-1)[0], "/") : "";
-  const middle =
-    rest.length > 1
-      ? rest.slice(0, rest.length - 1).map((i) => stripLeading(stripTrailing(i, "/"), '"'))
-      : [];
-  const midString = stripTrailing(stripLeading(middle.join("/"), "/"), "/");
-
-  return (
-    rest.length > 1 ? `${start}${midString}${end}` : `${start}${stripLeading(end, "/")}`
-  ) as PathJoin<T, U>;
-}

package/src/runtime/literals/stripLeading.ts

@@ -1,15 +0,0 @@
-import { StripLeading } from "src/types/alphabetic/StripLeading";
-
-export function stripLeading<T extends string, U extends string>(
-  content: T,
-  strip: U
-): StripLeading<T, U> {
-  const re = new RegExp(`^${strip}(.*)`);
-  return (
-    content.startsWith(strip)
-      ? // starts with
-        content.replace(re, "$1")
-      : // does not
-        content
-  ) as StripLeading<T, U>;
-}

package/src/runtime/literals/stripTrailing.ts

@@ -1,15 +0,0 @@
-import { StripTrailing } from "src/types/alphabetic/StripTrailing";
-
-/**
- * **stripTrailing**(content, strip)
- *
- * Runtime utility which ensures that last part of a string has substring
- * removed if it exists and that strong typing is preserved.
- */
-export function stripTrailing<T extends string, U extends string>(
-  content: T,
-  strip: U
-): StripTrailing<T, U> {
-  const re = new RegExp(`(.*)${strip}$`);
-  return (content.endsWith(strip) ? content.replace(re, "$1") : content) as StripTrailing<T, U>;
-}

package/src/runtime/literals/wide.ts

@@ -1,13 +0,0 @@
-/**
- * **wide**
- *
- * Provides a dictionary of _wide_ types
- */
-export const wide = {
-  boolean: false as boolean,
-  string: "" as string,
-  number: 0 as number,
-  symbol: Symbol() as Symbol,
-  null: null,
-  undefined: undefined,
-} as const;

package/src/runtime/ruleset.ts

@@ -1,42 +0,0 @@
-/* eslint-disable no-use-before-define */
-
-import { Narrowable } from "src/types/Narrowable";
-
-// TODO: get ruleset functionality working!
-
-// const dynamicRuleState = {
-// state: <TState extends any>() => {
-//   return {
-//     rules: <TRules extends DynamicRuleSet<TState, any>>(rules: TRules) => {
-//       const dynRules = rules();
-//     }
-//   };
-// }
-// };
-
-/**
- * **ruleSet**
- *
- * Defines a ruleset composed of _dynamic_ and _static_ boolean operators.
- *
- * - the first function call defines _dynamic_ props (_optional_)
- * - the second function call defines static values
- *
- * ```ts
- * const rs = ruleSet(
- *    r => r.state()( { maybe: r => r.extends({ foo: 1 }) })
- * )(
- *    { color: true, age: false }
- * );
- * ```
- */
-export function ruleSet<N extends Narrowable, TState extends Record<keyof TState, N>>(
-  defn?: TState
-) {
-  // return <
-  //   TStatic extends { [K in keyof TStatic]: Readonly<true | false> },
-  //   >(rules: TStatic) => {
-  //   return rules;
-  // };
-  return defn;
-}

package/src/runtime/runtime/README.md

@@ -1,3 +0,0 @@
-# Runtime Utilities
-
-A set of utilities which help to keep the runtime types and the _typings_ in step with one another.

package/src/runtime/runtime/condition.ts

@@ -1,13 +0,0 @@
-import { Narrowable } from "src/types/Narrowable";
-
-export type Condition<TInput extends Narrowable, TResult extends boolean> = (
-  input: TInput
-) => TResult;
-
-export const condition = <TInput extends Narrowable, C extends Condition<Narrowable, boolean>>(
-  c: C,
-  input: TInput
-) => {
-  // const v
-  return c(input);
-};

package/src/runtime/runtime/index.ts

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

package/src/runtime/runtime/type.ts

@@ -1,127 +0,0 @@
-import { FunctionType } from "src/types/FunctionType";
-import { Narrowable } from "src/types/Narrowable";
-import { TypeGuard } from "src/types/TypeGuard";
-import {
-  isString,
-  isBoolean,
-  isNumber,
-  isFunction,
-  isSymbol,
-  isNull,
-  isTrue,
-  isFalse,
-  isUndefined,
-  isObject,
-  isArray,
-  ObjectType,
-} from "../type-checks";
-// import { isLiteral } from "./conditions/isLiteral";
-
-export type Type<T extends any, V extends Function> = {
-  name: string;
-  type: T;
-  typeGuard: TypeGuard<T>;
-  is: V;
-};
-
-export const typeApi = () =>
-  ({
-    string: {
-      name: "string",
-      type: "" as string,
-      typeGuard: (v: unknown): v is string => isString(v),
-      is: isString,
-    } as Type<string, typeof isString>,
-    boolean: {
-      name: "boolean",
-      type: true as boolean,
-      typeGuard: (v: unknown): v is boolean => isBoolean(v),
-      is: isBoolean,
-    } as Type<boolean, typeof isBoolean>,
-    number: {
-      name: "number",
-      type: 1 as number,
-      typeGuard: (v: unknown): v is number => isNumber(v),
-      is: isNumber,
-    } as Type<number, typeof isNumber>,
-    function: {
-      name: "function",
-      type: Function as FunctionType,
-      typeGuard: (v: unknown): v is FunctionType => isFunction(v),
-      is: isFunction,
-    } as Type<FunctionType, typeof isFunction>,
-    null: {
-      name: "null",
-      type: null as null,
-      typeGuard: (v: unknown): v is null => isNull(v),
-      is: isNull,
-    } as Type<null, typeof isNull>,
-    symbol: {
-      name: "symbol",
-      type: Symbol() as Symbol,
-      typeGuard: (v: unknown): v is Symbol => isSymbol(v),
-      is: isSymbol,
-    } as Type<symbol, typeof isSymbol>,
-    undefined: {
-      name: "undefined",
-      type: undefined as undefined,
-      typeGuard: (v: unknown): v is undefined => isUndefined(v),
-      is: isUndefined,
-    } as Type<undefined, typeof isUndefined>,
-
-    true: {
-      name: "true",
-      type: true as true,
-      typeGuard: (v: Narrowable): v is true => isTrue(v),
-      is: isTrue,
-    } as Type<true, typeof isTrue>,
-    false: {
-      name: "false",
-      type: false as false,
-      typeGuard: (v: unknown): v is false => isFalse(v),
-      is: isFalse,
-    } as Type<false, typeof isFalse>,
-
-    object: {
-      name: "object",
-      type: {},
-      typeGuard: (v: unknown): v is ObjectType => isObject(v),
-      is: isObject,
-    } as Type<ObjectType, typeof isObject>,
-
-    array: {
-      name: "array",
-      type: {} as any[],
-      typeGuard: (v: unknown): v is Object => isArray(v),
-      is: isObject,
-    } as Type<any[], typeof isArray>,
-
-    // literal: <T extends Readonly<string>>(...literalValues: T[]) =>
-    //   ({
-    //     name: "literal",
-    //     type: v as T,
-    //     typeGuard: (v: unknown): v is T => isLiteral(...literalValues)(v),
-    //     is: isLiteral(...literalValues)(v),
-    //   } as Type<T, typeof isLiteral>),
-  } as const);
-
-export type TypeApi = ReturnType<typeof typeApi>;
-
-export function isType<T extends any, V extends Function>(t: unknown): t is Type<T, V> {
-  return (
-    typeof t === "object" && ["name", "type", "is"].every((i) => Object.keys(t as {}).includes(i))
-  );
-}
-
-export type TypeDefinition<T extends any, V extends Function> = (defn: TypeApi) => Type<T, V>;
-
-export function type<T extends any, V extends Function>(fn: TypeDefinition<T, V>) {
-  const result = fn(typeApi());
-  if (!isType(result)) {
-    throw new Error(
-      `When using type(), the callback passed in returned an invalid type! Value returned was: ${result}`
-    );
-  }
-
-  return result;
-}

package/src/runtime/runtime/withValue.ts

@@ -1,39 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-
-import { WithValue } from "src/types/dictionary";
-import { ExpandRecursively } from "src/types/ExpandRecursively";
-import { Narrowable } from "src/types/Narrowable";
-import { entries } from "../dictionary/entries";
-import { type, TypeDefinition } from "./type";
-
-/**
- * **withValue**
- *
- * Reduces a dictionary object -- in both _type_ and _run-time_ structure -- to only those
- * key/value pairs which have a specified value. For instance:
- *
- * ```ts
- * const obj = { foo: 1, bar: 2, message: "hi there" };
- * // { message: "hi there" }
- * const onlyStrings = withValue(t => t.string)(obj);
- * // { foo: 1 }
- * const justOne = withValue(t => t.literal(1))(obj);
- * ```
- *
- * Note: _often useful to provide run-time type profiles with the_ `inferredType` _utility_
- */
-export function withValue<T extends any, V extends Function>(td: TypeDefinition<T, V>) {
-  return <N extends Narrowable, R extends Record<string, N>>(obj: R) => {
-    const t = type(td);
-    // type Type = typeof t.type;
-
-    return Object.fromEntries(
-      [...entries(obj)].filter(([_key, value]) => {
-        // runtime check
-        // const tg = <X extends { [key]: any }>(value: X): value is Extract<X, { [key]: Type }> =>
-        //   t.is(value);
-        return t.typeGuard(value);
-      })
-    ) as unknown as ExpandRecursively<WithValue<T, R>>;
-  };
-}

package/src/runtime/state/Configurator.ts

@@ -1,76 +0,0 @@
-import { ExpandRecursively } from "src/types/ExpandRecursively";
-
-type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
-function omit<T extends {}, K extends Array<keyof T>>(obj: T, ...removals: K) {
-  const untyped = removals as Array<unknown>;
-  return Object.fromEntries(Object.entries(obj).filter(([key]) => !untyped.includes(key))) as Omit<
-    T,
-    K[number]
-  >;
-}
-
-export interface IConfigurator<C = {}> {
-  set<V, K extends string, KV = { [U in K]: V }>(
-    key: K,
-    value: V
-  ): asserts this is IConfigurator<ExpandRecursively<C & KV>>;
-  remove<K extends string & keyof C>(
-    key: K
-  ): asserts this is IConfigurator<ExpandRecursively<Omit<C, K>>>;
-  done(): C;
-}
-
-/**
- * **Configurator**
- *
- * This function provides a configurator which uses TypeScript assertions
- * to narrow the scope of variables. Using type assertions though means we
- * can't also return values and therefore a _fluent_ API style is not possible.
- *
- * Note: this approach does require, that you explicitly use the `IConfigurator`
- * interface exported by this library. Without it you'd getting annoying TS errors
- * on every call to `set()` but adding it is simple enough:
- *
- * ```ts
- * import { Configurator, IConfigurator } from "inferred-types";
- * const config: IConfigurator = Configurator();
- * ```
- *
- * If you want to specify some guideline params which you expect to be set, you
- * can add them like so:
- *
- * ```ts
- * export type IExpected = { foo: number, bar: string };
- * const config: IConfigurator<IExpected> = Configurator<IExpected>();
- * ```
- *
- * This configuration will ensure that `foo` and `bar` will be seen as optional
- * parameters. If you set them they will stop being optional.
- */
-export function Configurator() {
-  let configuration = () => ({});
-
-  const api = <C extends {}>(): IConfigurator<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 config = configuration() as C;
-        const updated = { ...config, ...keyValue };
-
-        configuration = (): C & KV => updated;
-        return updated;
-      },
-      remove<K extends string & keyof C>(key: K) {
-        const config = configuration() as C;
-        const updated = omit(config, key) as ExpandRecursively<Omit<C, K>>;
-        configuration = (): ExpandRecursively<Omit<C, K>> => updated;
-        return updated;
-      },
-      done() {
-        return configuration() as C;
-      },
-    };
-  };
-
-  return api();
-}