inferred-types 0.35.0 → 0.36.1

package/dist/index.mjs

@@ -75,6 +75,11 @@ var condition = (c, input) => {
   return c(input);
 };
 
+// src/runtime/type-checks/ifSameType.ts
+function ifSameType(value, comparisonType, ifExtends, doesNotExtend) {
+  return typeof value === typeof comparisonType ? ifExtends(value) : doesNotExtend(value);
+}
+
 // src/runtime/type-checks/isArray.ts
 function isArray(i) {
   return Array.isArray(i) === true;
@@ -129,6 +134,9 @@ function ifNumber(val, ifVal, elseVal) {
 function isObject(i) {
   return typeof i === "object" && i !== null && Array.isArray(i) === false;
 }
+function ifObject(val, ifObj, notObj) {
+  return isObject(val) ? ifObj : notObj;
+}
 
 // src/runtime/type-checks/isString.ts
 function isString(i) {
@@ -158,6 +166,9 @@ function isUndefined(i) {
 function ifUndefined(val, ifVal, elseVal) {
   return isUndefined(val) ? ifVal : elseVal;
 }
+function ifDefined(val, ifVal, elseVal) {
+  return isUndefined(val) ? ifVal : elseVal;
+}
 
 // src/runtime/runtime/type.ts
 var typeApi = () => ({
@@ -621,6 +632,69 @@ function groupBy(_data) {
   throw new Error("not implemented");
 }
 
+// src/runtime/literals/box.ts
+function box(value) {
+  const rtn = {
+    __kind: "box",
+    value,
+    unbox: (...p) => {
+      return typeof value === "function" ? value(...p) : value;
+    }
+  };
+  return rtn;
+}
+function isBox(thing) {
+  return typeof thing === "object" && "__kind" in thing && thing.__kind === "box";
+}
+function boxDictionaryValues(dict) {
+  return keys(dict).reduce(
+    (acc, key) => ({ ...acc, [key]: box(dict[key]) }),
+    {}
+  );
+}
+function unbox(val) {
+  return isBox(val) ? val.value : val;
+}
+
+// src/runtime/literals/wide.ts
+var wide = {
+  boolean: false,
+  string: "",
+  number: 0,
+  symbol: Symbol(),
+  null: null,
+  undefined: void 0
+};
+
+// src/runtime/lists/createConverter.ts
+function createConverter(mapper2) {
+  const converter = boxDictionaryValues(mapper2);
+  return (input) => {
+    const v = ifSameType(
+      input,
+      wide.string,
+      (i) => converter.string.unbox(i),
+      (i) => ifSameType(
+        i,
+        wide.number,
+        (i2) => converter.number.unbox(i2),
+        (i2) => ifSameType(
+          i2,
+          wide.boolean,
+          (i3) => converter.boolean.unbox(i3),
+          (i3) => ifSameType(
+            i3,
+            {},
+            (i4) => converter.object.unbox(i4),
+            (i4) => i4
+          )
+        )
+      )
+    );
+    return v;
+  };
+}
+
 // src/runtime/literals/ExplicitFunction.ts
 function ExplicitFunction(fn) {
   return fn;
@@ -638,26 +712,10 @@ function arrayToObject(prop, unique) {
   return transform;
 }
 
-// src/runtime/literals/box.ts
-function box(value) {
-  const rtn = {
-    __kind: "box",
-    value,
-    unbox: () => value
-  };
-  return rtn;
-}
-function isBox(thing) {
-  return typeof thing === "object" && "__kind" in thing && thing.__kind === "box";
-}
-function unbox(thing) {
-  return isBox(thing) ? thing.unbox() : thing;
-}
-
 // src/runtime/literals/defineType.ts
 function defineType(literal2 = {}) {
-  return (wide = {}) => {
-    return literal2 ? { ...wide, ...literal2 } : wide;
+  return (wide2 = {}) => {
+    return literal2 ? { ...wide2, ...literal2 } : wide2;
   };
 }
 
@@ -681,16 +739,20 @@ function literal(obj) {
   return obj;
 }
 
-// src/runtime/literals/stripEnding.ts
-function stripEnding(content, strip) {
+// src/runtime/literals/stripTrailing.ts
+function stripTrailing(content, strip) {
   const re = new RegExp(`(.*)${strip}$`);
   return content.endsWith(strip) ? content.replace(re, "$1") : content;
 }
 
-// src/runtime/literals/stripStarting.ts
-function stripStarting(content, strip) {
-  const re = new RegExp(`^${strip}(.*)`);
-  return content.startsWith(strip) ? content.replace(re, "$1") : content;
+// src/runtime/literals/ensureTrailing.ts
+function ensureTrailing(content, ensure) {
+  return content.endsWith(ensure) ? content : `${content}${ensure}`;
+}
+
+// src/runtime/literals/ensureLeading.ts
+function ensureLeading(content, ensure) {
+  return content.startsWith(ensure) ? content : `${ensure}${content}`;
 }
 export {
   Configurator,
@@ -706,13 +768,17 @@ export {
   arrayToObject,
   asArray,
   box,
+  boxDictionaryValues,
   condition,
+  createConverter,
   createFnWithProps,
   defineProperties,
   defineType,
   dictArr,
   dictToKv,
   dictionaryTransform,
+  ensureLeading,
+  ensureTrailing,
   entries,
   filter,
   filterDictArray,
@@ -724,9 +790,12 @@ export {
   ifArray,
   ifArrayPartial,
   ifBoolean,
+  ifDefined,
   ifFalse,
   ifNull,
   ifNumber,
+  ifObject,
+  ifSameType,
   ifString,
   ifTrue,
   ifUndefined,
@@ -760,10 +829,10 @@ export {
   readonlyFnWithProps,
   ruleSet,
   strArrayToDict,
-  stripEnding,
-  stripStarting,
+  stripTrailing,
   type,
   typeApi,
   unbox,
+  wide,
   withValue
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inferred-types",
-  "version": "0.35.0",
+  "version": "0.36.1",
   "description": "Functions which provide useful type inference on TS projects",
   "license": "MIT",
   "author": "Ken Snyder<ken@ken.net>",
@@ -16,14 +16,15 @@
     "autoindex": "npx dd autoindex",
     "build": "run-s clean autoindex lint build:bundle",
     "build:force": "run-s clean autoindex build:bundle",
-    "build:bundle": "npx tsup src/index.ts --dts --format=esm,cjs --clean",
+    "build:bundle": "npx tsup src/index.ts --dts --format=esm --clean",
     "watch": "run-p watch:*",
     "watch:autoindex": "npx dd autoindex --watch",
-    "watch:bundle": "npx tsup src/index.ts --dts --format=esm,cjs --watch",
+    "watch:bundle": "npx tsup src/index.ts --dts --format=esm --watch",
     "clean": "rimraf dist/**/*",
     "lint": "eslint src/**/*.ts --fix && tsc --noEmit ",
     "lint:full": "eslint src/**/*.ts && eslint tests/**/*.ts && tsc --noEmit",
     "test": "vitest",
+    "test:ui": "vitest --ui",
     "test:ci": "vitest run",
     "audit:fix": "pnpm audit --fix",
     "release": "run-s lint:full release:latest test:ci audit:fix release:bump",
@@ -32,10 +33,10 @@
   },
   "devDependencies": {
     "@type-challenges/utils": "~0.1.1",
-    "@types/node": "^16.18.4",
-    "@typescript-eslint/eslint-plugin": "^5.45.1",
-    "@typescript-eslint/parser": "^5.45.1",
-    "@vitest/ui": "^0.25.4",
+    "@types/node": "^16.18.7",
+    "@typescript-eslint/eslint-plugin": "^5.46.0",
+    "@typescript-eslint/parser": "^5.46.0",
+    "@vitest/ui": "^0.25.6",
     "bumpp": "^8.2.1",
     "common-types": "^1.33.2",
     "cross-env": "^7.0.3",
@@ -48,16 +49,16 @@
     "eslint-plugin-promise": "^6.1.1",
     "npm-run-all": "~4.1.5",
     "pathe": "^1.0.0",
-    "prettier": "~2.8.0",
+    "prettier": "~2.8.1",
     "rimraf": "^3.0.2",
     "sharp": "^0.31.2",
     "tsup": "^6.5.0",
-    "typescript": "^4.9.3",
+    "typescript": "^4.9.4",
     "vite": "^3.2.5",
-    "vitest": "^0.25.4"
+    "vitest": "^0.25.6"
   },
   "dependencies": {
-    "brilliant-errors": "^0.6.1"
+    "brilliant-errors": "^0.7.1"
   },
   "pnpm": {
     "overrides": {

package/src/runtime/combinators/filter.ts

@@ -109,7 +109,6 @@ export type LogicalCombinator = "AND" | "OR";
  * 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

package/src/runtime/lists/asArray.ts

@@ -27,8 +27,12 @@ export type AsArray<T, W extends boolean = false> = T extends any[]
  */
 // 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) ? thing : typeof thing === "undefined" ? ([] as T[]) : [thing]) as AsArray<
-    T,
-    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

@@ -0,0 +1,62 @@
+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/index.ts

@@ -7,6 +7,7 @@
 // file exports
 export * from "./asArray";
 export * from "./groupBy";
+export * from "./createConverter";
 
 // #endregion auto-indexed files
 

package/src/runtime/literals/box.ts

@@ -1,5 +1,7 @@
-import { AfterFirst, Narrowable } from "src/types";
+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";
@@ -7,22 +9,16 @@ export interface Box<T> {
   /**
    * Unbox the boxed value in the narrowest possible type.
    *
-   * **Note:** _if you want a wider type definition use `wide()`
-   * instead._
+   * **note:** if the boxed value is a function with parameters you
+   * can pass the parameters directly into the `b.unbox(params)` call.
    */
-  unbox(): T;
-  // /**
-  //  * If the boxed value is a function with generics then you have opportunity to
-  //  * _narrow_ the type definition over time. This is achieved in a type strong manner,
-  //  * so you can't change the fundamental type but this example will work as expected:
-  //  * ```ts
-  //  * const fn = <T extends string>(name: T) => `Hello ${name}` as const;
-  //  * const b = box(fn);
-  //  * // later
-  //  * const b2 = b.narrow<"foo" | "bar">();
-  //  * ```
-  //  */
-  // narrow: NarrowBox<T>;
+  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;
@@ -58,20 +54,45 @@ export function box<T extends Narrowable>(value: T): Box<T> {
   const rtn: Box<T> = {
     __kind: "box",
     value,
-    unbox: () => 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: unknown): thing is Box<any> {
+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;
 
-export function unbox<T>(thing: T): Unbox<T> {
-  return isBox(thing) ? thing.unbox() : thing;
+//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/ensureLeading.ts

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,17 @@
+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/index.ts

@@ -10,9 +10,11 @@ export * from "./box";
 export * from "./defineType";
 export * from "./identity";
 export * from "./literal";
-export * from "./stripEnding";
-export * from "./stripStarting";
+export * from "./stripTrailing";
+export * from "./ensureTrailing";
+export * from "./ensureLeading";
 export * from "./Suggest";
+export * from "./wide";
 
 // #endregion auto-indexed files
 

package/src/runtime/literals/pathJoin.ts

@@ -1,17 +1,32 @@
 import { PathJoin } from "src/types/alphabetic/PathJoin";
-import { stripStarting } from "./stripStarting";
-import { stripEnding } from "./stripEnding";
+import { ensureLeading } from "./ensureLeading";
+import { ensureTrailing } from "./ensureTrailing";
+import { stripLeading } from "./stripLeading";
+import { stripTrailing } from "./stripTrailing";
 
 /**
- * **pathJoin**`<T,U>()`
+ * **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 string>(begin: T, finish: U): PathJoin<T, U> {
-  const start = stripEnding(begin, "/");
-  const end = stripStarting(finish, "/");
+export function pathJoin<T extends string, U extends readonly string[]>(
+  begin: T,
+  ...rest: U
+): PathJoin<T, U> {
+  const start = ensureTrailing(begin, "/");
+  const end = ensureLeading(rest.slice(-1)[0], "/");
+  const middle = rest
+    .slice(0, rest.length - 1)
+    .map((i) => stripLeading(stripTrailing(i, "/"), '"'));
+  const midString = stripTrailing(stripLeading(middle.join("/"), "/"), "/");
 
-  return `${start}/${end}` as PathJoin<T, U>;
+  return (
+    rest.length > 1 ? `${start}${midString}${end}` : `${start}${stripLeading(end, "/")}`
+  ) as PathJoin<T, U>;
 }

package/src/runtime/literals/{stripStarting.ts → stripLeading.ts}

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

package/src/runtime/literals/stripTrailing.ts

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,13 @@
+/**
+ * **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/type-checks/ifSameType.ts

@@ -0,0 +1,20 @@
+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/index.ts

@@ -5,6 +5,7 @@
 // hash-code: 4324574d
 
 // file exports
+export * from "./ifSameType";
 export * from "./isArray";
 export * from "./isBoolean";
 export * from "./isFalse";

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

@@ -1,9 +1,10 @@
+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 any>(i: T) {
+export function isBoolean<T extends Narrowable>(i: T): IsBoolean<T> {
   return (typeof i === "boolean") as IsBoolean<T>;
 }
 

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

@@ -5,11 +5,9 @@ export type IsFunction<T> = T extends FunctionType ? true : false;
 export type HybridFunction<TProps extends {}> = (<TArgs extends any[]>(...args: TArgs) => any) &
   TProps;
 
-export type SimpleFunction = <TArgs extends any[]>(...args: TArgs) => any;
+export type SimpleFunction = (...args: any[]) => any;
 
-export type AnyFunction<TProps extends {} | never = never> = TProps extends {}
-  ? HybridFunction<TProps>
-  : SimpleFunction;
+export type AnyFunction<TProps extends {} = {}> = SimpleFunction | HybridFunction<TProps>;
 
 /**
  * Checks whether a passed in value is a function and ensures run-time and types

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

@@ -1,5 +1,5 @@
 import { FunctionType, Narrowable, Not } from "src/types";
-import { IsObject } from "src/types/boolean-logic";
+import { IfObject, IsObject } from "src/types/boolean-logic";
 
 export type ObjectType = Not<Record<string, Narrowable>, FunctionType>;
 
@@ -9,6 +9,14 @@ export type ObjectType = Not<Record<string, Narrowable>, FunctionType>;
  * arrays are excluded, as well as functions which also have properties hanging
  * off of them.
  */
-export function isObject<T extends unknown>(i: T) {
+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>;
+}