@shwfed/config 2.12.4 → 2.12.5

package/dist/runtime/vendor/cel-js/lib/optional.js

@@ -9,6 +9,20 @@ export function optionalValue(opt) {
   }
   return opt.value;
 }
+export function ensureOptional(value, ast, description) {
+  if (Option.isOption(value)) return value;
+  throw evaluationError("optional_expected", `${description} must be optional`, ast);
+}
+export function ensureOptionalType(checker, node, ctx, description) {
+  const type = checker.check(node, ctx);
+  if (type.kind === "optional") return type;
+  if (type.kind === "dyn") return checker.getType("optional");
+  throw checker.createError("optional_expected", `${description} must be optional, got '${type}'`, node);
+}
+export function bindOptionalValueType(checker, type) {
+  const vt = type.valueType;
+  return vt && vt.kind !== "param" ? vt : checker.getType("dyn");
+}
 class OptionalNamespace {
   #kind = "optional";
   toString() {
@@ -24,10 +38,7 @@ export function register(registry) {
   functionOverload("optional<A>.value(): A", (v) => optionalValue(v));
   registry.registerFunctionOverload("OptionalNamespace.none(): optional<T>", () => Option.none());
   functionOverload("OptionalNamespace.of(A): optional<A>", (_, value) => optionalOf(value));
-  function ensureOptional(value, ast, description) {
-    if (Option.isOption(value)) return value;
-    throw evaluationError("optional_expected", `${description} must be optional`, ast);
-  }
+  functionOverload("OptionalNamespace.ofNullable(A): optional<A>", (_, value) => value === null || value === void 0 ? Option.none() : Option.some(value));
   function evaluateOptional(ev, macro, ctx) {
     return Effect.gen(function* () {
       const v = yield* ev.eval(macro.receiver, ctx);
@@ -36,12 +47,6 @@ export function register(registry) {
       return yield* macro.onEmpty(ev, macro, ctx);
     });
   }
-  function ensureOptionalType(checker, node, ctx, description) {
-    const type = checker.check(node, ctx);
-    if (type.kind === "optional") return type;
-    if (type.kind === "dyn") return checker.getType("optional");
-    throw checker.createError("optional_expected", `${description} must be optional, got '${type}'`, node);
-  }
   function createOptionalMacro({ functionDesc, evaluate, typeCheck, onHasValue, onEmpty }) {
     return (opts) => {
       const { ast, args, receiver } = opts;
@@ -112,25 +117,19 @@ export function register(registry) {
     "optional<A>.flatMap(ast, ast): optional<dyn>",
     createFlatMapExpander()
   );
+  registry.registerFunctionOverload(
+    "optional<A>.zip(ast, ast, ast, ast): optional<dyn>",
+    createZipExpander()
+  );
 }
 function createFlatMapExpander() {
   const functionDesc = "optional.flatMap(var, body)";
   const invalidVar = `${functionDesc} invalid iteration variable`;
   const invalidReceiver = `${functionDesc} receiver`;
   const invalidBody = `${functionDesc} body`;
-  function ensureOptional(value, ast, description) {
-    if (Option.isOption(value)) return value;
-    throw evaluationError("optional_expected", `${description} must be optional`, ast);
-  }
-  function ensureOptionalType(checker, node, ctx, description) {
-    const type = checker.check(node, ctx);
-    if (type.kind === "optional") return type;
-    if (type.kind === "dyn") return checker.getType("optional");
-    throw checker.createError("optional_expected", `${description} must be optional, got '${type}'`, node);
-  }
   function typeCheck(checker, macro, ctx) {
     const receiverType = ensureOptionalType(checker, macro.receiver, ctx, invalidReceiver);
-    const innerType = receiverType.valueType ?? checker.getType("dyn");
+    const innerType = bindOptionalValueType(checker, receiverType);
     macro.iterCtx = ctx.forkWithVariable(macro.iterVarName, innerType);
     return ensureOptionalType(checker, macro.body, macro.iterCtx, invalidBody);
   }
@@ -160,3 +159,56 @@ function createFlatMapExpander() {
     };
   };
 }
+function createZipExpander() {
+  const functionDesc = "optional.zip(other, x, y, body)";
+  const invalidVarX = `${functionDesc} invalid first binding variable`;
+  const invalidVarY = `${functionDesc} invalid second binding variable`;
+  const invalidReceiver = `${functionDesc} receiver`;
+  const invalidOther = `${functionDesc} argument`;
+  function typeCheck(checker, macro, ctx) {
+    const receiverType = ensureOptionalType(checker, macro.receiver, ctx, invalidReceiver);
+    const otherType = ensureOptionalType(checker, macro.other, ctx, invalidOther);
+    const xType = bindOptionalValueType(checker, receiverType);
+    const yType = bindOptionalValueType(checker, otherType);
+    const ctxX = ctx.forkWithVariable(macro.xVarName, xType);
+    const ctxY = ctxX.forkWithVariable(macro.yVarName, yType);
+    macro.iterCtxX = ctxX;
+    macro.iterCtxY = ctxY;
+    const bodyType = checker.check(macro.body, ctxY);
+    return checker.registry.getOptionalType(bodyType);
+  }
+  function evaluate(ev, macro, ctx) {
+    return Effect.gen(function* () {
+      const recv = yield* ev.eval(macro.receiver, ctx);
+      const optRecv = ensureOptional(recv, macro.receiver, invalidReceiver);
+      if (Option.isNone(optRecv)) return Option.none();
+      const other = yield* ev.eval(macro.other, ctx);
+      const optOther = ensureOptional(other, macro.other, invalidOther);
+      if (Option.isNone(optOther)) return Option.none();
+      const ctxX = macro.iterCtxX.reuse(ctx).setIterValue(optRecv.value, ev);
+      const ctxY = macro.iterCtxY.reuse(ctxX).setIterValue(optOther.value, ev);
+      const result = yield* ev.eval(macro.body, ctxY);
+      return Option.some(result);
+    });
+  }
+  return (opts) => {
+    const { args, receiver, ast } = opts;
+    const xVar = args[1];
+    const yVar = args[2];
+    if (xVar.op !== "id") throw parseError("invalid_macro_argument", invalidVarX, xVar);
+    if (yVar.op !== "id") throw parseError("invalid_macro_argument", invalidVarY, yVar);
+    return {
+      ast,
+      receiver,
+      functionDesc,
+      other: args[0],
+      xVarName: xVar.args,
+      yVarName: yVar.args,
+      body: args[3],
+      iterCtxX: void 0,
+      iterCtxY: void 0,
+      evaluate,
+      typeCheck
+    };
+  };
+}

package/dist/runtime/vendor/cel-js/lib/parser.js

@@ -304,9 +304,7 @@ class Lexer {
       pos += 2;
       while (pos < length && HEX_CODES[input[pos].charCodeAt(0)]) pos++;
       this.pos = pos;
-      const result2 = this._parseAsHexNumber(start, pos);
-      if (pos < length && (input[pos] === "u" || input[pos] === "U")) this.pos++;
-      return result2;
+      return this._parseAsHexNumber(start, pos);
     }
     pos = this._readDigits(input, length, pos);
     if (pos + 1 < length) {
@@ -316,9 +314,7 @@ class Lexer {
       if (afterpos !== pos) pos = afterpos;
     }
     this.pos = pos;
-    const result = this._parseAsNumber(start, pos);
-    if (pos < length && (input[pos] === "u" || input[pos] === "U")) this.pos++;
-    return result;
+    return this._parseAsNumber(start, pos);
   }
   readString(del, prefix) {
     const { input: i, pos: s } = this;

package/dist/runtime/vendor/cel-js/lib/registry.js

@@ -1318,13 +1318,13 @@ function protobufjsTypeToCelType(protoType, resolvedType) {
     case "uint64":
     case "fixed32":
     case "fixed64":
-      return "double";
+      return "number";
     default:
       switch (resolvedType?.constructor?.name) {
         case "Type":
           return resolvedType.fullName.slice(1);
         case "Enum":
-          return "int";
+          return "number";
       }
       if (protoType?.includes(".")) return protoType;
       return "dyn";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shwfed/config",
-  "version": "2.12.4",
+  "version": "2.12.5",
   "description": "Configurable UI for SHWFED",
   "type": "module",
   "publishConfig": {