@shwfed/config 2.12.4 → 2.12.6

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

@@ -1,7 +1,7 @@
 import { Effect, Option } from "effect";
 import { evaluationError, parseError } from "./errors.js";
 import { OPERATORS as OPS } from "./operators.js";
-import { optionalOf } from "./optional.js";
+import { optionalOf, ensureOptional, bindOptionalValueType } from "./optional.js";
 const identity = (x) => x;
 function assertIdentifier(node, message) {
   if (node.op === "id") return node.args;
@@ -34,9 +34,10 @@ function createMapExpander(hasFilter) {
   }
   function functorMap(ev, macro, ctx, recv) {
     return Effect.gen(function* () {
-      if (Option.isNone(recv)) return Option.none();
+      const optional = ensureOptional(recv, macro.receiver, `${functionDesc} receiver`);
+      if (Option.isNone(optional)) return Option.none();
       const iterCtx = macro.iterCtx.reuse(ctx);
-      const result = yield* ev.eval(macro.body, iterCtx.setIterValue(recv.value, ev));
+      const result = yield* ev.eval(macro.body, iterCtx.setIterValue(optional.value, ev));
       return Option.some(result);
     });
   }
@@ -44,7 +45,7 @@ function createMapExpander(hasFilter) {
     const recvType = chk.check(macro.receiver, ctx);
     if (recvType.kind === "optional") {
       macro.mode = "optional";
-      const innerType = recvType.valueType ?? chk.getType("dyn");
+      const innerType = bindOptionalValueType(chk, recvType);
       macro.iterCtx = ctx.forkWithVariable(macro.iterVarName, innerType);
       const bodyType = chk.check(macro.body, macro.iterCtx);
       return chk.registry.getOptionalType(bodyType);
@@ -83,10 +84,62 @@ function createMapExpander(hasFilter) {
     };
   };
 }
+function evaluateOptionalPredicate(ev, macro, ctx, optional, label) {
+  return Effect.gen(function* () {
+    const iterCtx = macro.iterCtx.reuse(ctx);
+    const result = yield* ev.eval(macro.body, iterCtx.setIterValue(optional.value, ev));
+    if (typeof result !== "boolean") {
+      throw evaluationError("invalid_condition_type", `${label}, got '${ev.debugRuntimeType(result)}'`, macro.body);
+    }
+    return result;
+  });
+}
+function checkOptionalPredicate(chk, macro, ctx, recvType, label) {
+  macro.iterCtx = ctx.forkWithVariable(macro.iterVarName, bindOptionalValueType(chk, recvType));
+  const bodyType = chk.check(macro.body, macro.iterCtx);
+  if (!bodyType.isDynOrBool() && bodyType.kind !== "param") {
+    throw chk.createError("invalid_condition_type", `${label}, got '${bodyType}'`, macro.body);
+  }
+}
 function createFilterExpander() {
   const functionDesc = "filter(var, predicate)";
   const invalidMsg = `${functionDesc} invalid predicate iteration variable`;
   const label = `${functionDesc} predicate must return bool`;
+  const invalidReceiver = `${functionDesc} receiver`;
+  function typeCheck(chk, macro, ctx) {
+    const recvType = chk.check(macro.receiver, ctx);
+    if (recvType.kind === "optional") {
+      macro.mode = "optional";
+      checkOptionalPredicate(chk, macro, ctx, recvType, label);
+      return recvType;
+    }
+    if (recvType.kind === "dyn") {
+      macro.mode = "dyn";
+      macro.iterCtx = ctx.forkWithVariable(macro.iterVarName, chk.getType("dyn"));
+      chk.check(macro.comprehension, ctx);
+      return chk.getType("dyn");
+    }
+    macro.mode = "list";
+    return chk.check(macro.comprehension, ctx);
+  }
+  function filterOptional(ev, macro, ctx, recv) {
+    return Effect.gen(function* () {
+      const optional = ensureOptional(recv, macro.receiver, invalidReceiver);
+      if (Option.isNone(optional)) return optional;
+      const keep = yield* evaluateOptionalPredicate(ev, macro, ctx, optional, label);
+      return keep ? optional : Option.none();
+    });
+  }
+  function evaluate(ev, macro, ctx) {
+    if (macro.mode === "list") return ev.eval(macro.comprehension, ctx);
+    if (macro.mode === "optional") {
+      return Effect.flatMap(ev.eval(macro.receiver, ctx), (recv) => filterOptional(ev, macro, ctx, recv));
+    }
+    return Effect.flatMap(
+      ev.eval(macro.receiver, ctx),
+      (recv) => Option.isOption(recv) ? filterOptional(ev, macro, ctx, recv) : ev.eval(macro.comprehension, ctx)
+    );
+  }
   return (opts) => {
     const { args, receiver, ast: callAst } = opts;
     const iterVarName = assertIdentifier(args[0], invalidMsg);
@@ -95,35 +148,89 @@ function createFilterExpander() {
     const appendItem = callAst.clone(OPS.accuPush, callAst.clone(OPS.id, iterVarName));
     const step = predicate.clone(OPS.ternary, [predicate, appendItem, accuValue]);
     return {
-      callAst: callAst.clone(OPS.comprehension, {
+      ast: callAst,
+      receiver,
+      iterVarName,
+      body: predicate,
+      comprehension: callAst.clone(OPS.comprehension, {
         errorsAreFatal: true,
         iterable: receiver,
         iterVarName,
         init: callAst.clone(OPS.list, []),
         step,
         result: identity
-      })
+      }),
+      iterCtx: void 0,
+      mode: "list",
+      typeCheck,
+      evaluate
     };
   };
 }
 function createQuantifierExpander(opts) {
   const invalidMsg = `${opts.name}(var, predicate) invalid predicate iteration variable`;
   const label = `${opts.name}(var, predicate) predicate must return bool`;
+  const invalidReceiver = `${opts.name}(var, predicate) receiver`;
+  const optionalBranch = opts.optional;
+  function typeCheck(chk, macro, ctx) {
+    const recvType = chk.check(macro.receiver, ctx);
+    if (recvType.kind === "optional") {
+      macro.mode = "optional";
+      checkOptionalPredicate(chk, macro, ctx, recvType, label);
+      return chk.getType("bool");
+    }
+    if (recvType.kind === "dyn") {
+      macro.mode = "dyn";
+      macro.iterCtx = ctx.forkWithVariable(macro.iterVarName, chk.getType("dyn"));
+      chk.check(macro.comprehension, ctx);
+      return chk.getType("bool");
+    }
+    macro.mode = "list";
+    return chk.check(macro.comprehension, ctx);
+  }
+  function foldOptional(ev, macro, ctx, recv) {
+    return Effect.gen(function* () {
+      const optional = ensureOptional(recv, macro.receiver, invalidReceiver);
+      if (Option.isNone(optional)) return optionalBranch.onNone;
+      return yield* evaluateOptionalPredicate(ev, macro, ctx, optional, label);
+    });
+  }
+  function evaluate(ev, macro, ctx) {
+    if (macro.mode === "list") return ev.eval(macro.comprehension, ctx);
+    if (macro.mode === "optional") {
+      return Effect.flatMap(ev.eval(macro.receiver, ctx), (recv) => foldOptional(ev, macro, ctx, recv));
+    }
+    return Effect.flatMap(
+      ev.eval(macro.receiver, ctx),
+      (recv) => Option.isOption(recv) ? foldOptional(ev, macro, ctx, recv) : ev.eval(macro.comprehension, ctx)
+    );
+  }
   return (callOpts) => {
     const { args, receiver, ast: callAst } = callOpts;
+    const iterVarName = assertIdentifier(args[0], invalidMsg);
     const predicate = args[1].setMeta("label", label);
     const transform = opts.transform({ args, ast: callAst, predicate, opts });
+    const comprehension = callAst.clone(OPS.comprehension, {
+      kind: "quantifier",
+      errorsAreFatal: opts.errorsAreFatal || false,
+      iterable: receiver,
+      iterVarName,
+      init: transform.init,
+      condition: transform.condition,
+      step: transform.step,
+      result: transform.result || identity
+    });
+    if (!optionalBranch) return { callAst: comprehension };
     return {
-      callAst: callAst.clone(OPS.comprehension, {
-        kind: "quantifier",
-        errorsAreFatal: opts.errorsAreFatal || false,
-        iterable: receiver,
-        iterVarName: assertIdentifier(args[0], invalidMsg),
-        init: transform.init,
-        condition: transform.condition,
-        step: transform.step,
-        result: transform.result || identity
-      })
+      ast: callAst,
+      receiver,
+      iterVarName,
+      body: predicate,
+      comprehension,
+      iterCtx: void 0,
+      mode: "list",
+      typeCheck,
+      evaluate
     };
   };
 }
@@ -231,6 +338,7 @@ export function registerMacros(registry) {
     "list.all(ast, ast): bool",
     createQuantifierExpander({
       name: "all",
+      optional: { onNone: true },
       transform({ ast: callAst, predicate }) {
         return {
           init: callAst.clone(OPS.value, true),
@@ -248,6 +356,7 @@ export function registerMacros(registry) {
     "list.exists(ast, ast): bool",
     createQuantifierExpander({
       name: "exists",
+      optional: { onNone: false },
       condition(accu) {
         return !accu;
       },

package/dist/runtime/vendor/cel-js/lib/math-builtins.d.ts

@@ -0,0 +1,2 @@
+import type { Registry } from './registry.js.js';
+export declare function registerMathBuiltins(registry: Registry): void;

package/dist/runtime/vendor/cel-js/lib/math-builtins.js

@@ -0,0 +1,39 @@
+import { evaluationError } from "./errors.js";
+import { Decimal } from "./decimal.js";
+class MathNamespace {
+  brand = "math";
+}
+const MATH_INSTANCE = new MathNamespace();
+function toDecimal(v) {
+  return Decimal.from(v);
+}
+function extremum(name, values) {
+  if (values.length === 0) {
+    throw evaluationError("empty_list", `math.${name}(): an empty list has no ${name === "min" ? "minimum" : "maximum"}`);
+  }
+  let best = toDecimal(values[0]);
+  for (let i = 1; i < values.length; i++) {
+    const v = toDecimal(values[i]);
+    if (name === "min" ? v.lt(best) : v.gt(best)) best = v;
+  }
+  return best;
+}
+export function registerMathBuiltins(registry) {
+  registry.registerType("math", MathNamespace);
+  registry.registerVariable({
+    name: "math",
+    type: "math",
+    value: MATH_INSTANCE,
+    description: "\u6570\u5B66\u51FD\u6570"
+  });
+  const overload = (sig, handler) => registry.registerFunctionOverload(sig, handler);
+  overload("math.trunc(number): number", (_r, v) => toDecimal(v).trunc());
+  overload("math.floor(number): number", (_r, v) => toDecimal(v).floor());
+  overload("math.ceil(number): number", (_r, v) => toDecimal(v).ceil());
+  overload("math.round(number): number", (_r, v) => toDecimal(v).round());
+  overload("math.abs(number): number", (_r, v) => toDecimal(v).abs());
+  overload("math.min(number, number): number", (_r, a, b) => extremum("min", [a, b]));
+  overload("math.max(number, number): number", (_r, a, b) => extremum("max", [a, b]));
+  overload("math.min(list<number>): number", (_r, values) => extremum("min", values));
+  overload("math.max(list<number>): number", (_r, values) => extremum("max", values));
+}

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

@@ -1,5 +1,9 @@
 import { Option } from 'effect';
+import type { IContextBase, ITypeCheckerBase, IASTNode, ITypeDeclaration } from './types.js.js';
 import type { Registry } from './registry.js.js';
 export declare function optionalOf(value: unknown): Option.None<{} | null> | Option.Some<{} | null>;
 export declare function optionalValue(opt: Option.Option<unknown>): unknown;
+export declare function ensureOptional(value: unknown, ast: IASTNode, description: string): Option.Option<unknown>;
+export declare function ensureOptionalType(checker: ITypeCheckerBase, node: IASTNode, ctx: IContextBase, description: string): ITypeDeclaration;
+export declare function bindOptionalValueType(checker: ITypeCheckerBase, type: ITypeDeclaration): ITypeDeclaration;
 export declare function register(registry: Registry): void;

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.6",
   "description": "Configurable UI for SHWFED",
   "type": "module",
   "publishConfig": {