inferred-types 0.54.7 → 0.54.9

package/README.md

@@ -70,6 +70,20 @@ const people = pluralize("person");
 #### Data Patterns
 
 - types like `Url`, `IpAddress`, `CSV`, `DotPath`, `Hexadecimal`, `ZipCode`, and `DomainName` attempt to provide an out of the box type for common data structure patterns we find in the real world
+- ISO3166 support (aka, countries):
+  - `Iso3166_Alpha2`, `Iso3166_Alpha3`, ...
+  - `isIso3166Alpha2()`, `isIsoAlpha3()`, type guards ...
+- ISO8601 support (aka, datetime)
+  - `Iso8601DateTime`, `Iso8601Date`, `Iso8601Time`, ...
+  - `isIsoDateTime()`, `isIsoDate()`, `isIsoTime()`, ...
+
+#### String Literal Matching at design time and run time
+
+```ts
+const matcher = infer("{{ string }} is a {{ infer foo }} utility, that {{ infer bar }}");
+// { foo: "fancy"; bar: "thinks it's better than you!"}
+const fooBar = matcher("infer is a fancy utility, that thinks it's better than you!")
+```
 
 ### Numeric Literals
 
@@ -89,42 +103,73 @@ const people = pluralize("person");
 
 ### Object / Dictionaries
 
-1. Based on an object's entity values:
-
-    Assume a base type of `Obj`:
-
-    ```ts
-    type Obj = {
-        n1: number;
-        n2: 2;
-        n3: 3;
-        success: true;
-        s1: string;
-        s2: "hello";
-    }
-    ```
-
-    We can get a union of string literals representing the _keys_ on the object whose value _extends_ some value:
-
-    ```ts
-    import type { KeysWithValue, KeysWithoutValue } from "inferred-types";
-    // "s1" | "s2"
-    type S = KeysWithValue<Obj, string>;
-    // "success" | "n1" | "n2"
-    type N = KeysWithoutValue<Obj, string>;
-    ```
-
-    > though less used, you can also use `KeysEqualValue` and `KeysNotEqualValue` for equality matching
-
-    If you'd prefer to mutate the object's type rather than just identify the _keys_ which extend a value you can do this with: `WithValue` and `WithoutValue`:
-
-     ```ts
-     import type { WithValue, WithoutValue } from "inferred-types";
-     // { s1: string; s2: "hello" }
-     type S = WithValue<Obj, string>;
-     // { success: true; n1: number; n2: 2; n3: 3 }
-     type N = WithoutValue<Obj, string>;
-     ```
+#### Reduce Object to Keys with a knownValue
+
+  Assume a base type of `Obj`:
+
+  ```ts
+  type Obj = {
+      n1: number;
+      n2: 2;
+      n3: 3;
+      success: true;
+      s1: string;
+      s2: "hello";
+  }
+  ```
+
+  We can get a union of string literals representing the _keys_ on the object whose value _extends_ some value:
+
+  ```ts
+  import type { KeysWithValue, KeysWithoutValue } from "inferred-types";
+  // "s1" | "s2"
+  type S = KeysWithValue<Obj, string>;
+  // "success" | "n1" | "n2"
+  type N = KeysWithoutValue<Obj, string>;
+  ```
+
+  > though less used, you can also use `KeysEqualValue` and `KeysNotEqualValue` for equality matching
+
+  If you'd prefer to mutate the object's type rather than just identify the _keys_ which extend a value you can do this with: `WithValue` and `WithoutValue`:
+
+   ```ts
+   import type { WithValue, WithoutValue } from "inferred-types";
+   // { s1: string; s2: "hello" }
+   type S = WithValue<Obj, string>;
+   // { success: true; n1: number; n2: 2; n3: 3 }
+   type N = WithoutValue<Obj, string>;
+   ```
+
+  And at runtime:
+
+  ```ts
+  // { foo: "hi" }
+  const foo = withoutValue("number")({ foo: "hi", bar: 42, baz: 99 });
+  // { bar: 42 }
+  const bar = withoutValue("number(42,55,66)")({ foo: "hi", bar: 42, baz: 99 });
+
+  // { foo: "hi", bar: 42 }
+  const fooBar = withoutKeys("baz")({ foo: "hi", bar: 42, baz: 99 });
+  // { foo: "hi", bar: 42 }
+  const fooBar2 = withKeys("foo", "bar")({ foo: "hi", bar: 42, baz: 99 })
+  ```
+
+#### Reduce Object's to only `Required` or `Optional` keys
+
+```ts
+type Obj = { foo: string; bar?: string; baz?: number };
+// "foo"
+type ReqKeys = RequiredKeys<Obj>;
+// ["foo"]
+type ReqKeyTup = RequiredKeysTuple<Obj>;
+// "bar" | "baz"
+type OptKeys = OptionalKeys<Obj>;
+// ["bar", "baz"]
+type OptKeyTup = OptionalKeysTuple<Obj>;
+
+type Reduced =
+
+```
 
 ## Contributing
 

package/modules/inferred-types/dist/index.cjs

@@ -430,12 +430,14 @@ __export(src_exports, {
   isLuminosityUom: () => isLuminosityUom,
   isLuxonDateTime: () => isLuxonDateTime,
   isMacysUrl: () => isMacysUrl,
+  isMap: () => isMap,
   isMapToken: () => isMapToken,
   isMassMetric: () => isMassMetric,
   isMassUom: () => isMassUom,
   isMetric: () => isMetric,
   isMexicanNewsUrl: () => isMexicanNewsUrl,
   isMoment: () => isMoment,
+  isNarrowableObject: () => isNarrowableObject,
   isNever: () => isNever,
   isNewsUrl: () => isNewsUrl,
   isNikeUrl: () => isNikeUrl,
@@ -470,6 +472,7 @@ __export(src_exports, {
   isSet: () => isSet,
   isSetBasedKind: () => isSetBasedKind,
   isSetBasedToken: () => isSetBasedToken,
+  isSetContainer: () => isSetContainer,
   isSetToken: () => isSetToken,
   isShape: () => isShape,
   isShapeCallback: () => isShapeCallback,
@@ -579,6 +582,7 @@ __export(src_exports, {
   narrowObjectToType: () => narrowObjectToType,
   never: () => never,
   objectToApi: () => objectToApi,
+  objectValues: () => objectValues,
   omit: () => omit,
   optional: () => optional,
   optionalOrNull: () => optionalOrNull,
@@ -655,6 +659,7 @@ __export(src_exports, {
   widen: () => widen,
   withDefaults: () => withDefaults,
   withKeys: () => withKeys,
+  withValue: () => withValue,
   withoutKeys: () => withoutKeys,
   withoutValue: () => withoutValue,
   wrapFn: () => wrapFn,
@@ -5258,6 +5263,16 @@ function narrowObjectToType() {
     }
   );
 }
+function objectValues(obj) {
+  const tuple3 = Object.keys(obj).reduce(
+    (acc, key) => [
+      ...acc,
+      obj[key]
+    ],
+    []
+  );
+  return tuple3;
+}
 function omit(obj, ...removeKeys) {
   const keys = Object.keys(obj);
   return keys.reduce(
@@ -5308,12 +5323,110 @@ function withKeys(dict, ...keys) {
 function withoutKeys(dict, ...exclude) {
   return omit(dict, ...exclude);
 }
-function withoutValue(val) {
+function doesExtend(type) {
+  return (val) => {
+    let response = false;
+    if (isString(val)) {
+      if (type === "string") {
+        response = true;
+      }
+      if (type.startsWith("string(")) {
+        const literals = stripAfter(
+          stripBefore(type, "string("),
+          ")"
+        ).split(/,\s*/);
+        if (literals.includes(val)) {
+          response = true;
+        }
+      }
+    }
+    if (isNumber(val)) {
+      if (type === "number") {
+        response = true;
+      }
+      if (type.startsWith("number(")) {
+        const literals = stripAfter(
+          stripBefore(type, "number("),
+          ")"
+        ).split(/,\s*/).map(Number);
+        if (literals.includes(val)) {
+          response = true;
+        }
+      }
+    }
+    if (isNull(val) && (type === "null" || type === "Opt<null>")) {
+      response = true;
+    }
+    if (isUndefined(val) && (type === "undefined" || type.startsWith("Opt<"))) {
+      response = true;
+    }
+    if (isBoolean(val)) {
+      if (type === "boolean") {
+        response = true;
+      }
+      if (type === "true" && val === true || type === "false" && val === false) {
+        response = true;
+      }
+    }
+    if (isNarrowableObject(val)) {
+      if (type === "Dict" || type === "Dict<string, unknown>") {
+        response = true;
+      }
+      if (startsWith("Dict<")(type)) {
+        const match = infer("Dict<{{infer key}}, {{infer value}}>")(type);
+        if (match) {
+          const { value } = match;
+          const isOpt = value.includes(`Opt<`);
+          const values = objectValues(val);
+          if (values.every((i) => isOpt ? isString(i) || isUndefined(i) : isString(i)) && type === "Dict<string, string>" || values.every((i) => isOpt ? isUndefined(i) || isNumber(i) : isNumber(i)) && type === "Dict<string, number>" || values.every((i) => isOpt ? isUndefined(i) || isBoolean(i) : isBoolean(i)) && type === "Dict<string, boolean>") {
+            response = true;
+          }
+        }
+      }
+    }
+    if (isArray(val)) {
+      if (type === "Array" || type === "Array<unknown>") {
+        return true;
+      }
+      if (type === "Array<Dict>" && val.every(isObject) || type === "Array<boolean>" && val.every(isBoolean) || type === "Array<string>" && val.every(isString) || type === "Array<number>" && val.every(isNumber) || type === "Array<Map>" && val.every(isMap) || type === "Array<Set>" && val.every(isSetContainer)) {
+        response = true;
+      }
+    }
+    if (isMap(val)) {
+      if (type === "Map" || type === "Map<Dict, Array>" && Array.from(val.keys()).every(isObject) && Array.from(val.values()).every(isArray) || type === "Map<Dict, Dict>" && Array.from(val.keys()).every(isObject) && Array.from(val.values()).every(isObject) || type === "Map<Dict, boolean>" && Array.from(val.keys()).every(isObject) && Array.from(val.values()).every(isBoolean) || type === "Map<Dict, number>" && Array.from(val.keys()).every(isObject) && Array.from(val.values()).every(isNumber) || type === "Map<Dict, string>" && Array.from(val.keys()).every(isObject) && Array.from(val.values()).every(isString) || type === "Map<Dict, unknown>" && Array.from(val.keys()).every(isObject) || type === "Map<string, string>" && Array.from(val.keys()).every(isString) && Array.from(val.values()).every(isString) || type === "Map<string, number>" && Array.from(val.keys()).every(isString) && Array.from(val.values()).every(isNumber) || type === "Map<string, boolean>" && Array.from(val.keys()).every(isString) && Array.from(val.values()).every(isBoolean) || type === "Map<string, unknown>" && Array.from(val.keys()).every(isString) || type === "Map<number, string>" && Array.from(val.keys()).every(isNumber) && Array.from(val.values()).every(isString) || type === "Map<number, number>" && Array.from(val.keys()).every(isNumber) && Array.from(val.values()).every(isNumber) || type === "Map<number, boolean>" && Array.from(val.keys()).every(isNumber) && Array.from(val.values()).every(isBoolean) || type === "Map<number, unknown>" && Array.from(val.keys()).every(isNumber)) {
+        response = true;
+      }
+    }
+    if (isSetContainer(val)) {
+      if (type === "Set" || type === "Set<unknown>" || type === "Set<boolean>" && Array.from(val).every(isBoolean) || type === "Set<string>" && Array.from(val).every(isString) || type === "Set<number>" && Array.from(val).every(isNumber) || type === "Set<Opt<boolean>>" && Array.from(val).every((i) => isBoolean(i) || isUndefined(i)) || type === "Set<Opt<string>>" && Array.from(val).every((i) => isString(i) || isUndefined(i)) || type === "Set<Opt<number>>" && Array.from(val).every((i) => isNumber(i) || isUndefined(i))) {
+        response = true;
+      }
+    }
+    return response;
+  };
+}
+function withoutValue(wo) {
   return (obj) => {
-    return Object.keys(obj).reduce(
-      (acc, key) => val === obj[key] ? acc : { ...acc, [key]: obj[key] },
-      {}
-    );
+    const output = {};
+    for (const key of keysOf(obj)) {
+      const val = obj[key];
+      if (!doesExtend(wo)(val)) {
+        output[key] = val;
+      }
+    }
+    return output;
+  };
+}
+function withValue(wo) {
+  return (obj) => {
+    const output = {};
+    for (const key of keysOf(obj)) {
+      const val = obj[key];
+      if (doesExtend(wo)(val)) {
+        output[key] = val;
+      }
+    }
+    return output;
   };
 }
 function createErrorCondition(kind, msg = "", utility = "") {
@@ -5532,6 +5645,9 @@ function isFunction(value) {
 function isObject(value) {
   return typeof value === "object" && value !== null && Array.isArray(value) === false;
 }
+function isNarrowableObject(value) {
+  return isObject(value) && Object.keys(value).every((key) => ["string", "number", "boolean", "symbol", "object", "undefined", "void", "null"].includes(typeof value[key]));
+}
 function isEscapeFunction(val) {
   return isFunction(val) && "escape" in val && val.escape === true;
 }
@@ -6088,6 +6204,9 @@ function isIndexable(value) {
 function isInlineSvg(v) {
   return isString(v) && v.trim().startsWith(`<svg`) && v.trim().endsWith(`</svg>`);
 }
+function isMap(val) {
+  return val instanceof Map;
+}
 function isNever(val) {
   return isConstant(val) && val.kind === "never";
 }
@@ -6136,6 +6255,12 @@ function isLikeRegExp(val) {
   }
   return false;
 }
+function isSet(val) {
+  return isObject(val) ? val.kind !== "Unset" : true;
+}
+function isSetContainer(val) {
+  return val instanceof Set;
+}
 function isStringArray(val) {
   return Array.isArray(val) && val.every((i) => isString(i));
 }
@@ -6160,9 +6285,6 @@ function isTypeTuple(value) {
 function isUnset(val) {
   return isObject(val) && val.kind === "Unset";
 }
-function isSet(val) {
-  return isObject(val) ? val.kind !== "Unset" : true;
-}
 function isUri(val, ...protocols) {
   const p = protocols.length === 0 ? valuesOf(NETWORK_PROTOCOL_LOOKUP2).flat().filter((i) => i) : protocols;
   return isString(val) && p.some((i) => val.startsWith(`${i}://`));
@@ -6742,26 +6864,23 @@ function ifUppercaseChar(ch, callbackForMatch, callbackForNoMatch) {
   return LOWER_ALPHA_CHARS2.includes(ch) ? callbackForMatch(ch) : callbackForNoMatch(ch);
 }
 function parseTemplate(template) {
-  const pattern = /\{\{\s*infer\s+([A-Za-z_]\w*)\s*(?:as\s+(string|number|boolean)\s*)?\}\}/g;
+  const pattern = /\{\{\s*infer\s+([A-Za-z_]\w*)\s*(?:(?:extends|as)\s+(string|number|boolean)\s*)?\}\}/g;
   let lastIndex = 0;
   let match;
   const segments = [];
-  do {
-    match = pattern.exec(template);
-    if (match) {
-      const [fullMatch, varName, asType2] = match;
-      const staticPart = template.slice(lastIndex, match.index);
-      if (staticPart) {
-        segments.push({ dynamic: false, text: staticPart });
-      }
-      segments.push({
-        dynamic: true,
-        varName,
-        type: asType2 ? asType2 : "string"
-      });
-      lastIndex = match.index + fullMatch.length;
+  while (match = pattern.exec(template)) {
+    const [fullMatch, varName, asType2] = match;
+    const staticPart = template.slice(lastIndex, match.index);
+    if (staticPart) {
+      segments.push({ dynamic: false, text: staticPart });
     }
-  } while (match);
+    segments.push({
+      dynamic: true,
+      varName,
+      type: asType2 ? asType2 : "string"
+    });
+    lastIndex = match.index + fullMatch.length;
+  }
   const remainder = template.slice(lastIndex);
   if (remainder) {
     segments.push({ dynamic: false, text: remainder });
@@ -6779,19 +6898,19 @@ function buildRegexPattern(segments) {
     } else {
       switch (seg.type) {
         case "string":
-          regexStr += `(?<${seg.varName}>.*?)`;
+          regexStr += "(.*?)";
           break;
         case "number":
-          regexStr += `(?<${seg.varName}>\\d+)`;
+          regexStr += "(\\d+)";
           break;
         case "boolean":
-          regexStr += `(?<${seg.varName}>(?:true|false))`;
+          regexStr += "(true|false)";
           break;
       }
     }
   }
   regexStr += "$";
-  return new RegExp(regexStr, "s");
+  return new RegExp(regexStr);
 }
 function convertValue(type, value) {
   switch (type) {
@@ -6803,19 +6922,20 @@ function convertValue(type, value) {
       return value === "true";
   }
 }
-function matchTemplate(inference, test) {
-  const segments = parseTemplate(inference);
+function matchTemplate(template, test) {
+  const segments = parseTemplate(template);
   const regex = buildRegexPattern(segments);
-  const match = test.match(regex);
+  const match = regex.exec(test);
   if (!match)
     return false;
+  let captureIndex = 1;
   const result2 = {};
   for (const seg of segments) {
     if (seg.dynamic) {
-      const rawVal = match.groups?.[seg.varName];
+      const rawVal = match[captureIndex++];
       if (rawVal === void 0)
         return false;
-      result2[seg.varName.toLowerCase()] = convertValue(seg.type, rawVal);
+      result2[seg.varName] = convertValue(seg.type, rawVal);
     }
   }
   return result2;
@@ -8145,12 +8265,14 @@ var ExifSaturation = /* @__PURE__ */ ((ExifSaturation2) => {
   isLuminosityUom,
   isLuxonDateTime,
   isMacysUrl,
+  isMap,
   isMapToken,
   isMassMetric,
   isMassUom,
   isMetric,
   isMexicanNewsUrl,
   isMoment,
+  isNarrowableObject,
   isNever,
   isNewsUrl,
   isNikeUrl,
@@ -8185,6 +8307,7 @@ var ExifSaturation = /* @__PURE__ */ ((ExifSaturation2) => {
   isSet,
   isSetBasedKind,
   isSetBasedToken,
+  isSetContainer,
   isSetToken,
   isShape,
   isShapeCallback,
@@ -8294,6 +8417,7 @@ var ExifSaturation = /* @__PURE__ */ ((ExifSaturation2) => {
   narrowObjectToType,
   never,
   objectToApi,
+  objectValues,
   omit,
   optional,
   optionalOrNull,
@@ -8370,6 +8494,7 @@ var ExifSaturation = /* @__PURE__ */ ((ExifSaturation2) => {
   widen,
   withDefaults,
   withKeys,
+  withValue,
   withoutKeys,
   withoutValue,
   wrapFn,