inferred-types 0.24.3 → 0.26.0

package/dist/index.mjs

@@ -84,6 +84,333 @@ var api = (priv) => (pub) => {
   return surface;
 };
 
+// src/utility/boolean-logic/and.ts
+var and = (...ops) => {
+  const fn = (...args) => {
+    return [...ops].every((i) => i(...args));
+  };
+  return fn;
+};
+
+// src/utility/boolean-logic/or.ts
+var or = (...ops) => {
+  const fn = (...args) => {
+    return [...ops].some((i) => i(...args));
+  };
+  return fn;
+};
+
+// src/utility/boolean-logic/not.ts
+var not = (op) => {
+  const fn = (...args) => {
+    return !op(...args);
+  };
+  return fn;
+};
+
+// src/utility/runtime/condition.ts
+var condition = (c, input) => {
+  return c(input);
+};
+
+// src/utility/runtime/ifTypeOf.ts
+function runtimeExtendsCheck(val, base, narrow = false) {
+  if (typeof val !== typeof base) {
+    return false;
+  }
+  switch (typeof val) {
+    case "boolean":
+    case "string":
+    case "number":
+    case "symbol":
+    case "bigint":
+      return narrow ? val === base : true;
+    case "undefined":
+      return true;
+    case "function":
+      if (narrow) {
+        throw new Error(`Use of narrowlyExtends with a function is not possible!`);
+      }
+      return true;
+    case "object":
+      if (val === null && base === null) {
+        return true;
+      } else {
+        return keys(base).every(
+          (i) => runtimeExtendsCheck(val[i], base[i], narrow)
+        );
+      }
+  }
+}
+var ifTypeOf = (val) => ({
+  extends: (base) => {
+    const valid = runtimeExtendsCheck(val, base, false);
+    const trueFalse = valid ? true : false;
+    return {
+      then: (then) => ({
+        else: (elseVal) => {
+          return valid ? typeof then === "undefined" ? val : then : elseVal;
+        }
+      }),
+      else: (elseVal) => valid ? val : elseVal
+    } && trueFalse;
+  },
+  narrowlyExtends: (base) => {
+    const valid = runtimeExtendsCheck(val, base, true);
+    const trueFalse = valid ? true : false;
+    return {
+      then: (then) => ({
+        else: (elseVal) => {
+          return valid ? typeof then === "undefined" ? val : then : elseVal;
+        }
+      }),
+      else: (elseVal) => valid ? val : elseVal
+    } && trueFalse;
+  }
+});
+
+// src/utility/runtime/conditions/isArray.ts
+function isArray(i) {
+  return Array.isArray(i) === true;
+}
+
+// src/utility/runtime/conditions/isBoolean.ts
+function isBoolean(i) {
+  return typeof i === "boolean";
+}
+
+// src/utility/runtime/conditions/isFalse.ts
+function isFalse(i) {
+  return typeof i === "boolean" && !i;
+}
+
+// src/utility/runtime/conditions/isFunction.ts
+function isFunction(input) {
+  return typeof input === "function";
+}
+
+// src/utility/runtime/conditions/isNull.ts
+function isNull(i) {
+  return i === null;
+}
+
+// src/utility/runtime/conditions/isNumber.ts
+function isNumber(i) {
+  return typeof i === "number";
+}
+
+// src/utility/runtime/conditions/isObject.ts
+function isObject(i) {
+  return typeof i === "object" && i !== null && Array.isArray(i) === false;
+}
+
+// src/utility/runtime/conditions/isString.ts
+function isString(i) {
+  return typeof i === "string";
+}
+
+// src/utility/runtime/conditions/isSymbol.ts
+function isSymbol(i) {
+  return typeof i === "symbol";
+}
+
+// src/utility/runtime/conditions/isTrue.ts
+function isTrue(i) {
+  return typeof i === "boolean" && i;
+}
+
+// src/utility/runtime/conditions/isUndefined.ts
+function isUndefined(i) {
+  return typeof i === "undefined";
+}
+
+// src/utility/runtime/type.ts
+var typeApi = () => ({
+  string: {
+    name: "string",
+    type: "",
+    typeGuard: (v) => isString(v),
+    is: isString
+  },
+  boolean: {
+    name: "boolean",
+    type: true,
+    typeGuard: (v) => isBoolean(v),
+    is: isBoolean
+  },
+  number: {
+    name: "number",
+    type: 1,
+    typeGuard: (v) => isNumber(v),
+    is: isNumber
+  },
+  function: {
+    name: "function",
+    type: Function,
+    typeGuard: (v) => isFunction(v),
+    is: isFunction
+  },
+  null: {
+    name: "null",
+    type: null,
+    typeGuard: (v) => isNull(v),
+    is: isNull
+  },
+  symbol: {
+    name: "symbol",
+    type: Symbol(),
+    typeGuard: (v) => isSymbol(v),
+    is: isSymbol
+  },
+  undefined: {
+    name: "undefined",
+    type: void 0,
+    typeGuard: (v) => isUndefined(v),
+    is: isUndefined
+  },
+  true: {
+    name: "true",
+    type: true,
+    typeGuard: (v) => isTrue(v),
+    is: isTrue
+  },
+  false: {
+    name: "false",
+    type: false,
+    typeGuard: (v) => isFalse(v),
+    is: isFalse
+  },
+  object: {
+    name: "object",
+    type: {},
+    typeGuard: (v) => isObject(v),
+    is: isObject
+  },
+  array: {
+    name: "array",
+    type: {},
+    typeGuard: (v) => isArray(v),
+    is: isObject
+  }
+});
+function isType(t) {
+  return typeof t === "object" && ["name", "type", "is"].every((i) => Object.keys(t).includes(i));
+}
+function type(fn) {
+  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;
+}
+
+// src/utility/dictionary/entries.ts
+function entries(obj) {
+  const iterable = {
+    *[Symbol.iterator]() {
+      for (const k of keys(obj)) {
+        yield [k, obj[k]];
+      }
+    }
+  };
+  return iterable;
+}
+
+// src/utility/runtime/withValue.ts
+function withValue(td) {
+  return (obj) => {
+    const t = type(td);
+    return Object.fromEntries(
+      [...entries(obj)].filter(([_key, value]) => {
+        return t.typeGuard(value);
+      })
+    );
+  };
+}
+
+// src/utility/lists/asArray.ts
+var asArray = (thing, _widen) => {
+  return isArray(thing) ? thing : typeof thing === "undefined" ? [] : [thing];
+};
+
+// src/utility/boolean-logic/filter.ts
+function isNotFilter(f) {
+  return typeof f === "object" && "not" in f;
+}
+function isNumericFilter(filter2) {
+  return "equals" in filter2 || "notEqual" in filter2 || "greaterThan" in filter2 || "lessThan" in filter2 ? true : false;
+}
+var numericOps = (config, boolLogic) => {
+  const equals = (n) => {
+    const f = asArray(n);
+    return f.length === 0 ? [] : [(input) => f.some((i) => i === input)];
+  };
+  const notEqual = (n) => {
+    const f = asArray(n);
+    return f.length === 0 ? [] : [(input) => f.every((i) => i !== input)];
+  };
+  const greaterThan = (n) => {
+    const val = [(input) => input !== void 0 && input > n];
+    return val;
+  };
+  const lessThan = (n) => {
+    const val = [(input) => input !== void 0 && input < n];
+    return val;
+  };
+  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" ? (input) => conditions.every((c) => c(input)) : (input) => conditions.some((c) => c(input));
+  return combined;
+};
+var stringOps = (config, boolLogic) => {
+  const startsWith = (n) => {
+    const f = asArray(n);
+    return f.length === 0 ? [] : [(input) => f.some((i) => input == null ? void 0 : input.startsWith(i))];
+  };
+  const endsWith = (n) => {
+    const f = asArray(n);
+    return f.length === 0 ? [] : [(input) => f.some((i) => input == null ? void 0 : input.endsWith(i))];
+  };
+  const contains = (n) => {
+    const f = asArray(n);
+    return f.length === 0 ? [] : [(input) => f.some((i) => input == null ? void 0 : 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) => conditions.every((c) => c(input)) : (input) => conditions.some((c) => c(input));
+  return combined;
+};
+var filterFn = (defn, logicCombinator, ifUndefined = "no-impact") => {
+  const config = isNotFilter(defn) ? defn["not"] : defn;
+  const filter2 = (input) => {
+    const undefValue = ifUndefined === "no-impact" ? logicCombinator === "AND" ? true : false : ifUndefined;
+    let flag;
+    if (typeof input === "undefined") {
+      flag = undefValue;
+    } else if (isNumericFilter(config)) {
+      const fn = numericOps(config, logicCombinator);
+      flag = isNotFilter(defn) ? !fn(input) : fn(input);
+    } else {
+      const fn = stringOps(config, logicCombinator);
+      flag = isNotFilter(defn) ? !fn(input) : fn(input);
+    }
+    return flag;
+  };
+  return filter2;
+};
+var filter = (config, logicCombinator = "AND", ifUndefined = "no-impact") => {
+  return filterFn(config, logicCombinator, ifUndefined);
+};
+
 // src/utility/dictionary/arrayToKeyLookup.ts
 function arrayToKeyLookup(...keys2) {
   const obj = {};
@@ -159,18 +486,6 @@ var dictArr = (...dicts) => {
   return api2;
 };
 
-// src/utility/dictionary/entries.ts
-function entries(obj) {
-  const iterable = {
-    *[Symbol.iterator]() {
-      for (const k of keys(obj)) {
-        yield [k, obj[k]];
-      }
-    }
-  };
-  return iterable;
-}
-
 // src/utility/dictionary/mapValues.ts
 function mapValues(obj, valueMapper) {
   return Object.fromEntries(
@@ -332,33 +647,6 @@ function literal(obj) {
   return obj;
 }
 
-// src/utility/map-reduce/filter.ts
-var equals = (field, val) => ({
-  kind: "Equals",
-  field,
-  val
-});
-var greater = (field, val) => ({
-  kind: "Greater",
-  field,
-  val
-});
-var less = (field, val) => ({
-  kind: "Less",
-  field,
-  val
-});
-var and = (a, b) => ({
-  kind: "And",
-  a,
-  b
-});
-var or = (a, b) => ({
-  kind: "Or",
-  a,
-  b
-});
-
 // src/utility/modelling/Model.ts
 function Model(name) {
   return {
@@ -376,216 +664,6 @@ function Model(name) {
     }
   };
 }
-
-// src/utility/runtime/condition.ts
-var condition = (c, input) => {
-  return c(input);
-};
-
-// src/utility/runtime/ifTypeOf.ts
-function runtimeExtendsCheck(val, base, narrow = false) {
-  if (typeof val !== typeof base) {
-    return false;
-  }
-  switch (typeof val) {
-    case "boolean":
-    case "string":
-    case "number":
-    case "symbol":
-    case "bigint":
-      return narrow ? val === base : true;
-    case "undefined":
-      return true;
-    case "function":
-      if (narrow) {
-        throw new Error(`Use of narrowlyExtends with a function is not possible!`);
-      }
-      return true;
-    case "object":
-      if (val === null && base === null) {
-        return true;
-      } else {
-        return keys(base).every(
-          (i) => runtimeExtendsCheck(val[i], base[i], narrow)
-        );
-      }
-  }
-}
-var ifTypeOf = (val) => ({
-  extends: (base) => {
-    const valid = runtimeExtendsCheck(val, base, false);
-    const trueFalse = valid ? true : false;
-    return {
-      then: (then) => ({
-        else: (elseVal) => {
-          return valid ? typeof then === "undefined" ? val : then : elseVal;
-        }
-      }),
-      else: (elseVal) => valid ? val : elseVal
-    } && trueFalse;
-  },
-  narrowlyExtends: (base) => {
-    const valid = runtimeExtendsCheck(val, base, true);
-    const trueFalse = valid ? true : false;
-    return {
-      then: (then) => ({
-        else: (elseVal) => {
-          return valid ? typeof then === "undefined" ? val : then : elseVal;
-        }
-      }),
-      else: (elseVal) => valid ? val : elseVal
-    } && trueFalse;
-  }
-});
-
-// src/utility/runtime/conditions/isArray.ts
-function isArray(i) {
-  return Array.isArray(i) === true;
-}
-
-// src/utility/runtime/conditions/isBoolean.ts
-function isBoolean(i) {
-  return typeof i === "boolean";
-}
-
-// src/utility/runtime/conditions/isFalse.ts
-function isFalse(i) {
-  return typeof i === "boolean" && !i;
-}
-
-// src/utility/runtime/conditions/isFunction.ts
-function isFunction(input) {
-  return typeof input === "function";
-}
-
-// src/utility/runtime/conditions/isNull.ts
-function isNull(i) {
-  return i === null;
-}
-
-// src/utility/runtime/conditions/isNumber.ts
-function isNumber(i) {
-  return typeof i === "number";
-}
-
-// src/utility/runtime/conditions/isObject.ts
-function isObject(i) {
-  return typeof i === "object" && i !== null && Array.isArray(i) === false;
-}
-
-// src/utility/runtime/conditions/isString.ts
-function isString(i) {
-  return typeof i === "string";
-}
-
-// src/utility/runtime/conditions/isSymbol.ts
-function isSymbol(i) {
-  return typeof i === "symbol";
-}
-
-// src/utility/runtime/conditions/isTrue.ts
-function isTrue(i) {
-  return typeof i === "boolean" && i;
-}
-
-// src/utility/runtime/conditions/isUndefined.ts
-function isUndefined(i) {
-  return typeof i === "undefined";
-}
-
-// src/utility/runtime/type.ts
-var typeApi = () => ({
-  string: {
-    name: "string",
-    type: "",
-    typeGuard: (v) => isString(v),
-    is: isString
-  },
-  boolean: {
-    name: "boolean",
-    type: true,
-    typeGuard: (v) => isBoolean(v),
-    is: isBoolean
-  },
-  number: {
-    name: "number",
-    type: 1,
-    typeGuard: (v) => isNumber(v),
-    is: isNumber
-  },
-  function: {
-    name: "function",
-    type: Function,
-    typeGuard: (v) => isFunction(v),
-    is: isFunction
-  },
-  null: {
-    name: "null",
-    type: null,
-    typeGuard: (v) => isNull(v),
-    is: isNull
-  },
-  symbol: {
-    name: "symbol",
-    type: Symbol(),
-    typeGuard: (v) => isSymbol(v),
-    is: isSymbol
-  },
-  undefined: {
-    name: "undefined",
-    type: void 0,
-    typeGuard: (v) => isUndefined(v),
-    is: isUndefined
-  },
-  true: {
-    name: "true",
-    type: true,
-    typeGuard: (v) => isTrue(v),
-    is: isTrue
-  },
-  false: {
-    name: "false",
-    type: false,
-    typeGuard: (v) => isFalse(v),
-    is: isFalse
-  },
-  object: {
-    name: "object",
-    type: {},
-    typeGuard: (v) => isObject(v),
-    is: isObject
-  },
-  array: {
-    name: "array",
-    type: {},
-    typeGuard: (v) => isArray(v),
-    is: isObject
-  }
-});
-function isType(t) {
-  return typeof t === "object" && ["name", "type", "is"].every((i) => Object.keys(t).includes(i));
-}
-function type(fn) {
-  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;
-}
-
-// src/utility/runtime/withValue.ts
-function withValue(td) {
-  return (obj) => {
-    const t = type(td);
-    return Object.fromEntries(
-      [...entries(obj)].filter(([_key, value]) => {
-        return t.typeGuard(value);
-      })
-    );
-  };
-}
 export {
   Configurator,
   ExplicitFunction,
@@ -596,6 +674,7 @@ export {
   api,
   arrayToKeyLookup,
   arrayToObject,
+  asArray,
   condition,
   createFnWithProps,
   createMutationFunction,
@@ -605,10 +684,9 @@ export {
   dictToKv,
   dictionaryTransform,
   entries,
-  equals,
+  filter,
   filterDictArray,
   fnWithProps,
-  greater,
   groupBy,
   idLiteral,
   idTypeGuard,
@@ -618,8 +696,10 @@ export {
   isBoolean,
   isFalse,
   isFunction,
+  isNotFilter,
   isNull,
   isNumber,
+  isNumericFilter,
   isObject,
   isString,
   isSymbol,
@@ -630,11 +710,11 @@ export {
   kindLiteral,
   kv,
   kvToDict,
-  less,
   literal,
   mapTo,
   mapValues,
   nameLiteral,
+  not,
   or,
   randomString,
   readonlyFnWithProps,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inferred-types",
-  "version": "0.24.3",
+  "version": "0.26.0",
   "description": "Functions which provide useful type inference on TS projects",
   "license": "MIT",
   "author": "Ken Snyder<ken@ken.net>",
@@ -46,6 +46,7 @@
     "eslint-plugin-prettier": "^4.2.1",
     "eslint-plugin-promise": "^6.1.1",
     "npm-run-all": "~4.1.5",
+    "pathe": "^0.3.9",
     "prettier": "~2.7.1",
     "rimraf": "^3.0.2",
     "sharp": "^0.31.1",

package/src/types/TypeInfo/Includes.ts

@@ -0,0 +1,34 @@
+import { TupleToUnion } from "../type-conversion";
+import { IsLiteral } from "./IsLiteral";
+import { IsStringLiteral } from "./IsStringLiteral";
+
+/**
+ * **Includes<TSource, TValue>**
+ *
+ * Type utility which returns `true` or `false` based on whether `TValue` is found
+ * in `TSource`. Where `TSource` can be a string literal or an array of string literals.
+ *
+ * **Note:** if the source is a _wide_ type (aka, `string` or `string[]`) then there is
+ * no way to know at design-time whether the value includes `TValue` and so it will return
+ * a type of `boolean`.
+ */
+export type Includes<
+  TSource extends string | string[],
+  TValue extends string
+> = TSource extends string[]
+  ? IsStringLiteral<TupleToUnion<TSource>> extends true
+    ? IsLiteral<TValue> extends true
+      ? TValue extends TupleToUnion<TSource>
+        ? true
+        : false
+      : boolean
+    : boolean
+  : TSource extends string
+  ? IsLiteral<TSource> extends true
+    ? IsLiteral<TValue> extends true
+      ? TSource extends `${string}${TValue}${string}`
+        ? true
+        : false
+      : boolean
+    : boolean
+  : boolean;

package/src/types/TypeInfo/IsBooleanLiteral.ts

@@ -0,0 +1,7 @@
+/**
+ * **IsBooleanLiteral**
+ *
+ * Type utility which returns true/false if the boolean value is a _boolean literal_ versus
+ * just the wider _boolean_ type.
+ */
+export type IsBooleanLiteral<T extends boolean> = boolean extends T ? false : true;

package/src/types/TypeInfo/IsLiteral.ts

@@ -0,0 +1,20 @@
+import { IsBooleanLiteral } from "./IsBooleanLiteral";
+import { IsStringLiteral } from "./IsStringLiteral";
+import { IsNumericLiteral } from "./IsNumericLiteral";
+
+// [note on handling of boolean](https://stackoverflow.com/questions/74213646/detecting-type-literals-works-in-isolation-but-not-when-combined-with-other-lite/74213713#74213713)
+
+/**
+ * **IsLiteral**
+ *
+ * Type utility which returns true/false if the value passed -- a form of a
+ * string, number, or boolean -- is a _literal_ value of that type (true) or
+ * the more generic wide type (false).
+ */
+export type IsLiteral<T extends string | number | boolean> = [T] extends [string]
+  ? IsStringLiteral<T>
+  : [T] extends [boolean]
+  ? IsBooleanLiteral<T>
+  : [T] extends [number]
+  ? IsNumericLiteral<T>
+  : never;