@shwfed/config 2.1.2 → 2.2.1

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

@@ -1,9 +1,10 @@
 /**
  * `HttpRequestBuilder` — the value an `http.*` CEL expression evaluates to.
  *
- * A local (non-upstream) extension. A CEL expression builds and *describes* a
- * request; `.file()` is exposed as a CEL method and evaluates to the downloaded
- * `File`, while `.json()` is dispatched by the host on the returned builder.
+ * A local (non-upstream) extension. A CEL expression only *describes* a
+ * request — it never issues one. Both terminal methods, `.json()` and
+ * `.file()`, are dispatched by the host on the returned builder, keeping
+ * expression evaluation free of IO.
  *
  * Endpoints are used verbatim — there is no base-URL resolution, so callers
  * must pass absolute URLs.
@@ -12,6 +13,8 @@ import { Effect } from 'effect';
 import { Fetch } from 'fx-fetch';
 export declare class HttpRequestBuilder {
     #private;
+    static setDefaultHeader(name: string, value: string | (() => string | null | undefined)): void;
+    static clearDefaultHeader(name: string): void;
     constructor(url: string, method: string);
     header(name: string, value: string): this;
     query(key: string, value: string | number): this;

package/dist/runtime/vendor/cel-js/lib/http-builder.js

@@ -38,6 +38,20 @@ export class HttpRequestBuilder {
   #headers = [];
   #queries = [];
   #body;
+  // Process-wide defaults applied at `#buildRequest()` time. Each entry is
+  // keyed by lowercased header name so an explicit `.header('X', …)` on the
+  // builder wins regardless of casing. A getter returning `null` / `undefined`
+  // / `''` skips the header for that request — lets the host source values
+  // from a live ref (e.g. the current i18n locale) without baking in stale
+  // snapshots.
+  static #defaultHeaders = /* @__PURE__ */ new Map();
+  static setDefaultHeader(name, value) {
+    const get = typeof value === "function" ? value : () => value;
+    HttpRequestBuilder.#defaultHeaders.set(name.toLowerCase(), { name, get });
+  }
+  static clearDefaultHeader(name) {
+    HttpRequestBuilder.#defaultHeaders.delete(name.toLowerCase());
+  }
   constructor(url, method) {
     this.#url = url;
     this.#method = method;
@@ -117,9 +131,16 @@ export class HttpRequestBuilder {
       url: this.#url,
       method: this.#method
     };
-    if (this.#headers.length > 0) {
-      const headers = {};
-      for (const [k, v] of this.#headers) headers[k] = v;
+    const explicit = new Set(this.#headers.map(([k]) => k.toLowerCase()));
+    const headers = {};
+    for (const [k, v] of this.#headers) headers[k] = v;
+    for (const [key, { name, get }] of HttpRequestBuilder.#defaultHeaders) {
+      if (explicit.has(key)) continue;
+      const v = get();
+      if (v == null || v === "") continue;
+      headers[name] = v;
+    }
+    if (Object.keys(headers).length > 0) {
       parts.headers = headers;
     }
     if (this.#body !== void 0) {

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

@@ -3,9 +3,9 @@
  *
  * Registers the `http` / `HttpRequest` types, the `http` constant, and the
  * request-builder functions on the registry. `http.get(url).header(...).body(...)`
- * builds an `HttpRequestBuilder`; the terminal `.file()` method issues the
- * request and evaluates to the downloaded `File`. `.json()` is *not* a CEL
- * method — the host dispatches that on the returned builder value.
+ * builds an `HttpRequestBuilder` — a pure *description* of a request. CEL never
+ * issues it: both `.json()` and `.file()` are dispatched by the host on the
+ * returned builder, so expression evaluation stays free of IO.
  *
  * Wired into `globalRegistry` at module load (see `evaluator.ts`), so every
  * `Environment` gets HTTP for free — both type-checking and evaluation.

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

@@ -52,8 +52,4 @@ export function registerHttpBuiltins(registry) {
     "HttpRequest.body(dyn): HttpRequest",
     (b, data) => b.body(data)
   );
-  registry.registerFunctionOverload(
-    "HttpRequest.file(): File",
-    (b) => b.file()
-  );
 }

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

@@ -74,8 +74,106 @@ function checkOptionalAccessNode(chk, ast, ctx) {
   const actualType = leftType.kind === "optional" ? leftType.valueType : leftType;
   return chk.registry.getOptionalType(chk.checkAccessOnType(ast, ctx, actualType, true));
 }
-function checkElement(chk, ctx, expected, el) {
-  return expected.unify(chk.registry, chk.check(el, ctx)) ?? dynType;
+function spreadInner(node) {
+  return node.args;
+}
+function spreadListElementType(chk, ctx, node) {
+  const t = chk.check(spreadInner(node), ctx);
+  if (t.kind === "dyn") return chk.dynType;
+  if (t.kind === "list") return t.valueType;
+  throw chk.createError(
+    "invalid_spread",
+    `Cannot spread '${chk.formatType(t)}' into a list (expected a list)`,
+    node
+  );
+}
+function spreadMapEntryTypes(chk, ctx, node) {
+  const t = chk.check(spreadInner(node), ctx);
+  if (t.kind === "dyn") return [chk.dynType, chk.dynType];
+  if (t.kind === "map") return [t.keyType, t.valueType];
+  if (t.kind === "message") {
+    const Base2 = chk;
+    return [Base2.stringType, chk.dynType];
+  }
+  throw chk.createError(
+    "invalid_spread",
+    `Cannot spread '${chk.formatType(t)}' into a map (expected a map)`,
+    node
+  );
+}
+const SPREAD_SKIP_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function assignFragmentEntry(obj, k, v) {
+  const key = k;
+  if (SPREAD_SKIP_KEYS.has(key)) return;
+  obj[key] = v;
+}
+function mergeMapFragments(ev, frags) {
+  const obj = {};
+  for (const f of frags) {
+    if ("kv" in f) {
+      assignFragmentEntry(obj, f.kv[0], f.kv[1]);
+      continue;
+    }
+    const src = f.spread;
+    if (src instanceof Map) {
+      for (const [k, v] of src) assignFragmentEntry(obj, k, v);
+      continue;
+    }
+    if (src !== null && typeof src === "object" && !isArray(src)) {
+      for (const k in src) {
+        if (hasOwn(src, k)) assignFragmentEntry(obj, k, src[k]);
+      }
+      continue;
+    }
+    throw ev.createError(
+      "invalid_spread",
+      `Cannot spread a non-map value into a map`,
+      f.node
+    );
+  }
+  return obj;
+}
+function evaluateSpreadList(ev, ast, ctx) {
+  const arr = ast.args;
+  return Effect.all(
+    arr.map(
+      (el) => el.op === "spread" ? ev.eval(spreadInner(el), ctx).pipe(
+        Effect.flatMap(
+          (v) => isArray(v) ? Effect.succeed(v) : Effect.fail(
+            ev.createError(
+              "invalid_spread",
+              `Cannot spread a non-list value into a list`,
+              el
+            )
+          )
+        )
+      ) : ev.eval(el, ctx).pipe(Effect.map((v) => [v]))
+    )
+  ).pipe(Effect.map((parts) => parts.flat()));
+}
+function evaluateSpreadMap(ev, ast, ctx) {
+  const arr = ast.args;
+  return Effect.all(
+    arr.map((e) => {
+      if (e.length === 1 || e[0].op === "spread") {
+        const node = e[0];
+        return ev.eval(spreadInner(node), ctx).pipe(
+          Effect.map((src) => ({ spread: src, node }))
+        );
+      }
+      const pair = e;
+      return Effect.all([ev.eval(pair[0], ctx), ev.eval(pair[1], ctx)]).pipe(
+        Effect.map(([k, v]) => ({ kv: [k, v] }))
+      );
+    })
+  ).pipe(
+    Effect.flatMap(
+      (frags) => Effect.try({
+        try: () => mergeMapFragments(ev, frags),
+        catch: (e) => e
+      })
+    )
+  );
 }
 function ternaryConditionError(ev, value, node) {
   const type = ev.debugRuntimeType(value);
@@ -481,9 +579,19 @@ const OPERATORS_MAP = {
       const arr = ast.args;
       const arrLen = arr.length;
       if (arrLen === 0) return ast.setMeta("evaluate", emptyList) && chk.getType("list<T>");
-      let valueType = chk.check(arr[0], ctx);
-      for (let i = 1; i < arrLen; i++)
-        valueType = checkElement(chk, ctx, valueType, arr[i]);
+      let hasSpread = false;
+      let valueType;
+      for (const el of arr) {
+        let t;
+        if (el.op === "spread") {
+          hasSpread = true;
+          t = spreadListElementType(chk, ctx, el);
+        } else {
+          t = chk.check(el, ctx);
+        }
+        valueType = valueType === void 0 ? t : valueType.unify(chk.registry, t) ?? dynType;
+      }
+      if (hasSpread) ast.setMeta("evaluate", evaluateSpreadList);
       return chk.registry.getListType(valueType);
     },
     evaluate(ev, ast, ctx) {
@@ -495,13 +603,23 @@ const OPERATORS_MAP = {
       const arr = ast.args;
       const arrLen = arr.length;
       if (arrLen === 0) return ast.setMeta("evaluate", emptyMap) && chk.getType("map<K, V>");
-      let keyType = chk.check(arr[0][0], ctx);
-      let valueType = chk.check(arr[0][1], ctx);
-      for (let i = 1; i < arrLen; i++) {
-        const e = arr[i];
-        keyType = checkElement(chk, ctx, keyType, e[0]);
-        valueType = checkElement(chk, ctx, valueType, e[1]);
+      let hasSpread = false;
+      let keyType;
+      let valueType;
+      for (const e of arr) {
+        let k;
+        let v;
+        if (e.length === 1 || e[0].op === "spread") {
+          hasSpread = true;
+          [k, v] = spreadMapEntryTypes(chk, ctx, e[0]);
+        } else {
+          k = chk.check(e[0], ctx);
+          v = chk.check(e[1], ctx);
+        }
+        keyType = keyType === void 0 ? k : keyType.unify(chk.registry, k) ?? dynType;
+        valueType = valueType === void 0 ? v : valueType.unify(chk.registry, v) ?? dynType;
       }
+      if (hasSpread) ast.setMeta("evaluate", evaluateSpreadMap);
       return chk.registry.getMapType(keyType, valueType);
     },
     evaluate(ev, ast, ctx) {
@@ -513,6 +631,16 @@ const OPERATORS_MAP = {
       ).pipe(Effect.map(safeFromEntries));
     }
   },
+  "spread": {
+    // Reached only via direct `ast.check`/`ast.evaluate` — parents consume the
+    // node inline, so these are defensive guards.
+    check(chk, ast) {
+      throw chk.createError("misplaced_spread", `'...' is only valid inside a list or map literal`, ast);
+    },
+    evaluate(ev, ast) {
+      return Effect.fail(ev.createError("misplaced_spread", `'...' is only valid inside a list or map literal`, ast));
+    }
+  },
   "comprehension": {
     check(chk, ast, ctx) {
       const args = ast.args;

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

@@ -76,8 +76,9 @@ export declare class Parser {
     parsePostfix(): ASTNode;
     parsePrimary(): ASTNode;
     parseList(): ASTNode;
+    parseListElement(): ASTNode;
     parseMap(): ASTNode;
-    parseProperty(): [ASTNode, ASTNode];
+    parseProperty(): [ASTNode, ASTNode] | [ASTNode];
     parseArgumentList(): ASTNode[];
 }
 export {};

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

@@ -34,7 +34,8 @@ const TOKEN = {
   COMMA: 28,
   COLON: 29,
   QUESTION: 30,
-  BYTES: 31
+  BYTES: 31,
+  ELLIPSIS: 32
 };
 const OP_FOR_TOKEN = {
   [TOKEN.EQ]: OPS["=="],
@@ -208,6 +209,8 @@ class Lexer {
         case "}":
           return this.token(this.pos++, TOKEN.RBRACE);
         case ".":
+          if (input[pos + 1] === "." && input[pos + 2] === ".")
+            return this.token((this.pos += 3) - 3, TOKEN.ELLIPSIS);
           return this.token(this.pos++, TOKEN.DOT);
         case ",":
           return this.token(this.pos++, TOKEN.COMMA);
@@ -735,12 +738,12 @@ export class Parser {
     const elements = [];
     let remainingElements = this.limits.maxListElements;
     if (!this.match(TOKEN.RBRACKET)) {
-      elements.push(this.parseExpression());
+      elements.push(this.parseListElement());
       if (!remainingElements--) this.#limitExceeded("maxListElements", elements.at(-1).pos);
       while (this.match(TOKEN.COMMA)) {
         this.#advanceToken();
         if (this.match(TOKEN.RBRACKET)) break;
-        elements.push(this.parseExpression());
+        elements.push(this.parseListElement());
         if (!remainingElements--) this.#limitExceeded("maxListElements", elements.at(-1).pos);
       }
     }
@@ -748,6 +751,10 @@ export class Parser {
     this.consume(TOKEN.RBRACKET);
     return this.#node(start, closeEnd, OPS.list, elements);
   }
+  parseListElement() {
+    if (this.match(TOKEN.ELLIPSIS)) return this.#parseSpread();
+    return this.parseExpression();
+  }
   parseMap() {
     const start = this.consume(TOKEN.LBRACE);
     const props = [];
@@ -767,8 +774,18 @@ export class Parser {
     return this.#node(start, closeEnd, OPS.map, props);
   }
   parseProperty() {
+    if (this.match(TOKEN.ELLIPSIS)) return [this.#parseSpread()];
     return [this.parseExpression(), (this.consume(TOKEN.COLON), this.parseExpression())];
   }
+  // `...expr` — only valid as a list element or map entry; the parent literal
+  // consumes the node and `parsePrimary` never sees ELLIPSIS, so a stray `...`
+  // surfaces as a normal "unexpected token" parse error.
+  #parseSpread() {
+    const start = this.pos;
+    this.#advanceToken();
+    const inner = this.parseExpression();
+    return this.#node(start, inner.end, OPS.spread, inner);
+  }
   parseArgumentList() {
     const args = [];
     let remainingArgs = this.limits.maxCallArguments;

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

@@ -79,7 +79,11 @@ export function serialize(ast) {
     case "list":
       return `[${args.map(serialize).join(", ")}]`;
     case "map":
-      return `{${args.map(([k, v]) => `${serialize(k)}: ${serialize(v)}`).join(", ")}}`;
+      return `{${args.map(
+        (e) => e.length === 1 || e[0].op === "spread" ? serialize(e[0]) : `${serialize(e[0])}: ${serialize(e[1])}`
+      ).join(", ")}}`;
+    case "spread":
+      return `...${serialize(args)}`;
     case "?:": {
       const ternArgs = args;
       return `${wrap(ternArgs[0], op)} ? ${wrap(ternArgs[1], op)} : ${serialize(ternArgs[2])}`;

package/package.json

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