inferred-types 0.54.6 → 0.54.8

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

@@ -248,12 +248,15 @@ __export(src_exports, {
   createFnWithProps: () => createFnWithProps,
   createFnWithPropsExplicit: () => createFnWithPropsExplicit,
   createLifoQueue: () => createLifoQueue,
+  createMapper: () => createMapper,
+  createObjectMap: () => createObjectMap,
   createTypeToken: () => createTypeToken,
   cssColor: () => cssColor,
   csv: () => csv,
   defineCss: () => defineCss,
   defineObj: () => defineObj,
   defineObject: () => defineObject,
+  defineObjectApi: () => defineObjectApi,
   defineTuple: () => defineTuple,
   endsWith: () => endsWith,
   ensureLeading: () => ensureLeading,
@@ -572,7 +575,10 @@ __export(src_exports, {
   mergeTuples: () => mergeTuples,
   nameLiteral: () => nameLiteral,
   narrow: () => narrow,
+  narrowObjectTo: () => narrowObjectTo,
+  narrowObjectToType: () => narrowObjectToType,
   never: () => never,
+  objectToApi: () => objectToApi,
   omit: () => omit,
   optional: () => optional,
   optionalOrNull: () => optionalOrNull,
@@ -3165,6 +3171,101 @@ function asApi(api2) {
 function handleDoneFn(val, call_bare_fn = false) {
   return isObject(val) || isFunction(val) ? isDoneFn(val) ? val.done() : isFunction(val) ? call_bare_fn ? val() : val : val : isFunction(val) ? call_bare_fn ? val() : val : val;
 }
+function addPropsToFn(fn2, clone_fn) {
+  const localFn = clone_fn ? (...args) => fn2(args) : fn2;
+  return (obj) => {
+    for (const k in obj) {
+      localFn[k] = obj[k];
+    }
+    return localFn;
+  };
+}
+function addFnToProps(props, _clone_fn) {
+  return (fn2) => {
+    const localFn = (...args) => fn2(args);
+    for (const k in props) {
+      localFn[k] = props[k];
+    }
+    return localFn;
+  };
+}
+function createCssSelector(_opt) {
+  return (...selectors) => {
+    return selectors.join(" ");
+  };
+}
+function createFnWithProps(fn2, props, narrowing = false) {
+  const fnWithProps = fn2;
+  for (const prop of Object.keys(props)) {
+    fnWithProps[prop] = props[prop];
+  }
+  return isTrue(narrowing) ? fnWithProps : fnWithProps;
+}
+function createFnWithPropsExplicit(fn2, props) {
+  const fnWithProps = fn2;
+  for (const prop of Object.keys(props)) {
+    fnWithProps[prop] = props[prop];
+  }
+  return fnWithProps;
+}
+function defineObj(literal2 = {}) {
+  return (wide22 = {}) => {
+    const obj = literal2 ? { ...literal2, ...wide22 } : wide22;
+    return obj;
+  };
+}
+function defineTuple(...values) {
+  return values.map(
+    (i) => isFunction(i) ? handleDoneFn(i(ShapeApiImplementation)) : i
+  );
+}
+function objectToApi(obj, def = null) {
+  const transformed = Object.keys(obj).reduce(
+    (acc, key) => {
+      const val = obj[key];
+      return {
+        ...acc,
+        [key]: () => val
+      };
+    },
+    {}
+  );
+  const api2 = {
+    __kind: "ObjectApi",
+    done: () => def,
+    ...transformed
+  };
+  return api2;
+}
+function mapper() {
+  return (map2) => {
+    return (input) => {
+      const api2 = objectToApi(input);
+      const rtn = map2(api2);
+      return handleDoneFn(rtn);
+    };
+  };
+}
+function objectApi() {
+  return {
+    mapTo: (_defn) => ({
+      mapper: mapper()
+    }),
+    mapToWithType: () => mapper()
+  };
+}
+function defineObjectApi__Fn(_inputDefn) {
+  return objectApi();
+}
+var defineObjectApi__Prop = {
+  withType: () => {
+    return objectApi();
+  }
+};
+var defineObjectApi = createFnWithProps(
+  defineObjectApi__Fn,
+  defineObjectApi__Prop
+);
 function ifArray(val, isAnArray, isNotAnArray) {
   return Array.isArray(val) ? isAnArray(val) : isNotAnArray(val);
 }
@@ -5132,6 +5233,31 @@ function keysOf(container) {
   const keys = Array.isArray(container) ? Object.keys(container).map((i) => Number(i)) : isObject(container) ? isRef(container) ? ["value"] : Object.keys(container) : [];
   return keys;
 }
+function callback() {
+  return (cb) => {
+    return (input) => cb(input);
+  };
+}
+function narrowFn() {
+  const fn2 = (obj) => obj;
+  return fn2;
+}
+function narrowObjectTo(_defn) {
+  return createFnWithPropsExplicit(
+    narrowFn(),
+    {
+      asCallback: callback()
+    }
+  );
+}
+function narrowObjectToType() {
+  return createFnWithPropsExplicit(
+    narrowFn(),
+    {
+      asCallback: callback()
+    }
+  );
+}
 function omit(obj, ...removeKeys) {
   const keys = Object.keys(obj);
   return keys.reduce(
@@ -5218,75 +5344,27 @@ function fnMeta(func) {
   };
 }
 var wrapFn = "NOT IMPLEMENTED";
-function addPropsToFn(fn2, clone_fn) {
-  const localFn = clone_fn ? (...args) => fn2(args) : fn2;
-  return (obj) => {
-    for (const k in obj) {
-      localFn[k] = obj[k];
-    }
-    return localFn;
-  };
-}
-function addFnToProps(props, _clone_fn) {
-  return (fn2) => {
-    const localFn = (...args) => fn2(args);
-    for (const k in props) {
-      localFn[k] = props[k];
-    }
-    return localFn;
-  };
-}
-function createCssSelector(_opt) {
-  return (...selectors) => {
-    return selectors.join(" ");
-  };
-}
-function createFnWithProps(fn2, props, narrowing = false) {
-  const fnWithProps = fn2;
-  for (const prop of Object.keys(props)) {
-    fnWithProps[prop] = props[prop];
-  }
-  return isTrue(narrowing) ? fnWithProps : fnWithProps;
-}
-function createFnWithPropsExplicit(fn2, props) {
-  const fnWithProps = fn2;
-  for (const prop of Object.keys(props)) {
-    fnWithProps[prop] = props[prop];
-  }
-  return fnWithProps;
-}
-function defineObj(literal2 = {}) {
-  return (wide22 = {}) => {
-    const obj = literal2 ? { ...literal2, ...wide22 } : wide22;
-    return obj;
-  };
-}
-function defineTuple(...values) {
-  return values.map(
-    (i) => isFunction(i) ? handleDoneFn(i(ShapeApiImplementation)) : i
-  );
-}
 function asArray(thing) {
   return Array.isArray(thing) === true ? thing : typeof thing === "undefined" ? [] : [thing];
 }
-function createConverter(mapper) {
+function createConverter(mapper2) {
   return (input) => {
     let result2;
     if (isNothing(input)) {
-      result2 = mapper.nothing ? mapper.nothing(input) : Never2;
+      result2 = mapper2.nothing ? mapper2.nothing(input) : Never2;
     } else if (isObject(input)) {
-      result2 = mapper.object ? mapper.object(input) : Never2;
+      result2 = mapper2.object ? mapper2.object(input) : Never2;
     } else {
       switch (typeof input) {
         case "string":
-          result2 = mapper.string ? mapper.string(input) : Never2;
+          result2 = mapper2.string ? mapper2.string(input) : Never2;
           break;
         case "number":
         case "bigint":
-          result2 = mapper.number ? mapper.number(input) : Never2;
+          result2 = mapper2.number ? mapper2.number(input) : Never2;
           break;
         case "boolean":
-          result2 = mapper.boolean ? mapper.boolean(input) : Never2;
+          result2 = mapper2.boolean ? mapper2.boolean(input) : Never2;
           break;
         default:
           throw new Error(`Unhandled type: ${typeof input}`);
@@ -5806,6 +5884,37 @@ function lookupCountryCode(token) {
   const uc = uppercase(token);
   return isNumberLike(token) ? lookupNumericCode(token, "countryCode") : isIso3166Alpha2(uc) ? lookupAlpha2Code(uc, "countryCode") : isIso3166Alpha3(uc) ? lookupAlpha3Code(uc, "countryCode") : isIso3166CountryName(token) ? lookupName(token, "countryCode") : void 0;
 }
+function asMapper(fn2) {
+  const props = {
+    kind: "Mapper",
+    map: (from) => {
+      return from.map(fn2);
+    }
+  };
+  return createFnWithPropsExplicit(fn2, props);
+}
+function createObjectMap() {
+  return (map2) => {
+    const fn2 = (input) => {
+      return Object.keys(map2).reduce(
+        (acc, key) => {
+          const val = map2[key];
+          return {
+            ...acc,
+            [key]: isFunction(val) ? val(input) : val
+          };
+        },
+        {}
+      );
+    };
+    return fn2;
+  };
+}
+function createMapper() {
+  return (fn2) => {
+    return asMapper(fn2);
+  };
+}
 function mergeObjects(defVal, override) {
   const intersectingKeys = sharedKeys(defVal, override);
   const defUnique = withoutKeys(defVal, ...intersectingKeys);
@@ -6633,26 +6742,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 });
@@ -6670,19 +6776,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) {
@@ -6694,19 +6800,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;
@@ -7854,12 +7961,15 @@ var ExifSaturation = /* @__PURE__ */ ((ExifSaturation2) => {
   createFnWithProps,
   createFnWithPropsExplicit,
   createLifoQueue,
+  createMapper,
+  createObjectMap,
   createTypeToken,
   cssColor,
   csv,
   defineCss,
   defineObj,
   defineObject,
+  defineObjectApi,
   defineTuple,
   endsWith,
   ensureLeading,
@@ -8178,7 +8288,10 @@ var ExifSaturation = /* @__PURE__ */ ((ExifSaturation2) => {
   mergeTuples,
   nameLiteral,
   narrow,
+  narrowObjectTo,
+  narrowObjectToType,
   never,
+  objectToApi,
   omit,
   optional,
   optionalOrNull,