@shwfed/config 2.2.0 → 2.2.1

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "shwfed",
   "configKey": "shwfed",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "unknown"

package/dist/runtime/components/form/fields/2026-04-28/com.shwfed.form.field.number/config.d.vue.ts

@@ -43,6 +43,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
         } | undefined;
         readonly precision?: number | undefined;
         readonly roundingMode?: "round" | "floor" | "ceil" | undefined;
+        readonly valueAsString?: boolean | undefined;
     }) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_ModelProps> & Readonly<{
     "onUpdate:modelValue"?: ((value: {
@@ -85,6 +86,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
         } | undefined;
         readonly precision?: number | undefined;
         readonly roundingMode?: "round" | "floor" | "ceil" | undefined;
+        readonly valueAsString?: boolean | undefined;
     }) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;

package/dist/runtime/components/form/fields/2026-04-28/com.shwfed.form.field.number/config.vue

@@ -26,6 +26,7 @@ import {
   SelectTrigger,
   SelectValue
 } from "../../../../ui/select";
+import { Switch } from "../../../../ui/switch";
 import { getStructFieldDescription, getStructFieldTitle } from "../../../schema";
 import { DEFAULT_FIELD_ORIENTATION, FIELD_ORIENTATION_OPTIONS } from "../../../utils/common";
 import { schema } from "./schema";
@@ -76,6 +77,14 @@ function onStepChange(v) {
     value.value = { ...value.value, step: v };
   }
 }
+function onValueAsStringChange(next) {
+  if (next) {
+    value.value = { ...value.value, valueAsString: true };
+  } else {
+    const { valueAsString: _omit, ...rest } = value.value;
+    value.value = rest;
+  }
+}
 </script>
 
 <template>
@@ -300,6 +309,28 @@ function onStepChange(v) {
       </Field>
     </div>
 
+    <Field orientation="vertical">
+      <FieldLabel class="text-xs text-zinc-500">
+        <template
+          v-if="fieldDescription('valueAsString')"
+          #tooltip
+        >
+          <Markdown
+            :source="fieldDescription('valueAsString')"
+            block
+            class="prose prose-sm prose-zinc"
+          />
+        </template>
+        {{ fieldTitle("valueAsString") }}
+      </FieldLabel>
+      <div>
+        <Switch
+          :model-value="value.valueAsString ?? false"
+          @update:model-value="onValueAsStringChange"
+        />
+      </div>
+    </Field>
+
     <div class="grid grid-cols-2 gap-3">
       <Field orientation="vertical">
         <FieldLabel class="text-xs text-zinc-500">

package/dist/runtime/components/form/fields/2026-04-28/com.shwfed.form.field.number/config.vue.d.ts

@@ -43,6 +43,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
         } | undefined;
         readonly precision?: number | undefined;
         readonly roundingMode?: "round" | "floor" | "ceil" | undefined;
+        readonly valueAsString?: boolean | undefined;
     }) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_ModelProps> & Readonly<{
     "onUpdate:modelValue"?: ((value: {
@@ -85,6 +86,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
         } | undefined;
         readonly precision?: number | undefined;
         readonly roundingMode?: "round" | "floor" | "ceil" | undefined;
+        readonly valueAsString?: boolean | undefined;
     }) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;

package/dist/runtime/components/form/fields/2026-04-28/com.shwfed.form.field.number/runtime.vue

@@ -62,8 +62,18 @@ const formatOptions = computed(() => ({
 }));
 const { draft, commit } = useFieldValue({
   binding: () => props.config.binding,
-  fromState: (raw) => typeof raw === "number" && Number.isFinite(raw) ? raw : void 0,
-  toState: (next) => typeof next === "number" && Number.isFinite(next) ? next : null
+  fromState: (raw) => {
+    if (typeof raw === "number" && Number.isFinite(raw)) return raw;
+    if (typeof raw === "string" && raw.length > 0) {
+      const n = Number(raw);
+      return Number.isFinite(n) ? n : void 0;
+    }
+    return void 0;
+  },
+  toState: (next) => {
+    if (typeof next !== "number" || !Number.isFinite(next)) return null;
+    return props.config.valueAsString ? String(next) : next;
+  }
 });
 function applyRounding(n, precision, mode) {
   const factor = 10 ** precision;

package/dist/runtime/components/form/fields/2026-04-28/com.shwfed.form.field.number/schema.d.ts

@@ -49,6 +49,7 @@ export declare function schema(configure: (env: Environment) => void): Schema.St
     precision: Schema.optional<Schema.refine<number, Schema.filter<typeof Schema.Number>>>;
     roundingMode: Schema.optional<Schema.Literal<["round", "floor", "ceil"]>>;
     step: Schema.optional<Schema.refine<number, typeof Schema.Number>>;
+    valueAsString: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
     min: Schema.optional<Schema.Schema<string, string, never>>;
     max: Schema.optional<Schema.Schema<string, string, never>>;
     id: Schema.refine<string, typeof Schema.String>;

package/dist/runtime/components/form/fields/2026-04-28/com.shwfed.form.field.number/schema.js

@@ -55,6 +55,10 @@ export function schema(configure) {
       title: "\u6B65\u957F",
       description: "\u53D6\u503C\u7684\u6700\u5C0F\u6B65\u957F\uFF1B\u7559\u7A7A\u65F6\u4E0D\u9650\u5236\uFF08\u4EFB\u610F\u7CBE\u5EA6\uFF09"
     })),
+    valueAsString: Schema.optional(Schema.Boolean.annotations({
+      title: "\u4EE5\u5B57\u7B26\u4E32\u8BFB\u5199",
+      description: "\u5F00\u542F\u540E\u8868\u5355\u72B6\u6001\u4EE5\u5B57\u7B26\u4E32\u5F62\u5F0F\u5B58\u50A8\u8BE5\u503C\uFF08\u9002\u7528\u4E8E\u540E\u7AEF\u4F7F\u7528 `DECIMAL` / `BIGINT` \u7B49\u9700\u8981\u539F\u6837\u56DE\u4F20\u7684\u5B57\u6BB5\uFF09\uFF1B\u5173\u95ED\u65F6\u82E5\u8BFB\u5230\u7684\u662F\u6570\u503C\u5B57\u7B26\u4E32\u4E5F\u4F1A\u88AB\u89E3\u6790\uFF0C\u4F46\u5199\u56DE\u4ECD\u4E3A\u6570\u503C\u3002\u6CE8\u610F\uFF1A\u8F93\u5165\u65F6\u4ECD\u7ECF\u8FC7 JavaScript \u6D6E\u70B9\u6570\uFF0C\u4EC5\u80FD\u5728\u300C\u88C5\u8F7D-\u56DE\u4F20\u300D\u672A\u7F16\u8F91\u573A\u666F\u4E0B\u4FDD\u7559\u7CBE\u5EA6"
+    })),
     min: Schema.optional(CelNumber.annotations({
       title: "\u6700\u5C0F\u503C",
       description: "\u5141\u8BB8\u8F93\u5165\u7684\u6700\u5C0F\u503C\u8868\u8FBE\u5F0F\uFF1B\u7559\u7A7A\u65F6\u4E0D\u9650\u5236\u4E0B\u9650"

package/dist/runtime/components/form/fields/2026-04-28/com.shwfed.form.field.numberrange/config.d.vue.ts

@@ -51,6 +51,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
         readonly precision?: number | undefined;
         readonly roundingMode?: "round" | "floor" | "ceil" | undefined;
         readonly rangeSeparatorIcon?: string | undefined;
+        readonly valueAsString?: boolean | undefined;
     }) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_ModelProps> & Readonly<{
     "onUpdate:modelValue"?: ((value: {
@@ -101,6 +102,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
         readonly precision?: number | undefined;
         readonly roundingMode?: "round" | "floor" | "ceil" | undefined;
         readonly rangeSeparatorIcon?: string | undefined;
+        readonly valueAsString?: boolean | undefined;
     }) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;

package/dist/runtime/components/form/fields/2026-04-28/com.shwfed.form.field.numberrange/config.vue

@@ -28,6 +28,7 @@ import {
   SelectTrigger,
   SelectValue
 } from "../../../../ui/select";
+import { Switch } from "../../../../ui/switch";
 import { getStructFieldDescription, getStructFieldTitle } from "../../../schema";
 import { DEFAULT_FIELD_ORIENTATION, FIELD_ORIENTATION_OPTIONS } from "../../../utils/common";
 import { schema } from "./schema";
@@ -112,6 +113,14 @@ function setSeparatorIcon(next) {
     value.value = { ...value.value, rangeSeparatorIcon: trimmed };
   }
 }
+function onValueAsStringChange(next) {
+  if (next) {
+    value.value = { ...value.value, valueAsString: true };
+  } else {
+    const { valueAsString: _omit, ...rest } = value.value;
+    value.value = rest;
+  }
+}
 </script>
 
 <template>
@@ -468,6 +477,28 @@ function setSeparatorIcon(next) {
           @update:model-value="setSeparatorIcon"
         />
       </Field>
+
+      <Field orientation="vertical">
+        <FieldLabel class="text-xs text-zinc-500">
+          <template
+            v-if="fieldDescription('valueAsString')"
+            #tooltip
+          >
+            <Markdown
+              :source="fieldDescription('valueAsString')"
+              block
+              class="prose prose-sm prose-zinc"
+            />
+          </template>
+          {{ fieldTitle("valueAsString") }}
+        </FieldLabel>
+        <div>
+          <Switch
+            :model-value="value.valueAsString ?? false"
+            @update:model-value="onValueAsStringChange"
+          />
+        </div>
+      </Field>
     </div>
 
     <div class="grid grid-cols-3 gap-3">

package/dist/runtime/components/form/fields/2026-04-28/com.shwfed.form.field.numberrange/config.vue.d.ts

@@ -51,6 +51,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
         readonly precision?: number | undefined;
         readonly roundingMode?: "round" | "floor" | "ceil" | undefined;
         readonly rangeSeparatorIcon?: string | undefined;
+        readonly valueAsString?: boolean | undefined;
     }) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_ModelProps> & Readonly<{
     "onUpdate:modelValue"?: ((value: {
@@ -101,6 +102,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
         readonly precision?: number | undefined;
         readonly roundingMode?: "round" | "floor" | "ceil" | undefined;
         readonly rangeSeparatorIcon?: string | undefined;
+        readonly valueAsString?: boolean | undefined;
     }) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;

package/dist/runtime/components/form/fields/2026-04-28/com.shwfed.form.field.numberrange/runtime.vue

@@ -63,15 +63,23 @@ const formatOptions = computed(() => ({
   useGrouping: false,
   maximumFractionDigits: 20
 }));
+function asNumber(raw) {
+  if (typeof raw === "number" && Number.isFinite(raw)) return raw;
+  if (typeof raw === "string" && raw.length > 0) {
+    const n = Number(raw);
+    return Number.isFinite(n) ? n : void 0;
+  }
+  return void 0;
+}
 function asRange(raw) {
   if (!Array.isArray(raw) || raw.length !== 2) return void 0;
-  const [a, b] = raw;
-  if (typeof a !== "number" || typeof b !== "number") return void 0;
-  if (!Number.isFinite(a) || !Number.isFinite(b)) return void 0;
+  const a = asNumber(raw[0]);
+  const b = asNumber(raw[1]);
+  if (a == null || b == null) return void 0;
   return [a, b];
 }
-function asNumber(raw) {
-  return typeof raw === "number" && Number.isFinite(raw) ? raw : void 0;
+function shape(n) {
+  return props.config.valueAsString ? String(n) : n;
 }
 const uncontrolled = ref(void 0);
 const model = computed({
@@ -91,11 +99,11 @@ const model = computed({
       return;
     }
     if (typeof binding === "string") {
-      setAt(binding, next ?? null);
+      setAt(binding, next ? [shape(next[0]), shape(next[1])] : null);
       return;
     }
-    setAt(binding[0], next?.[0] ?? null);
-    setAt(binding[1], next?.[1] ?? null);
+    setAt(binding[0], next ? shape(next[0]) : null);
+    setAt(binding[1], next ? shape(next[1]) : null);
   }
 });
 const localStart = ref(model.value?.[0]);

package/dist/runtime/components/form/fields/2026-04-28/com.shwfed.form.field.numberrange/schema.d.ts

@@ -56,6 +56,7 @@ export declare function schema(configure: (env: Environment) => void): Schema.St
     precision: Schema.optional<Schema.refine<number, Schema.filter<typeof Schema.Number>>>;
     roundingMode: Schema.optional<Schema.Literal<["round", "floor", "ceil"]>>;
     step: Schema.optional<Schema.refine<number, typeof Schema.Number>>;
+    valueAsString: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
     min: Schema.optional<Schema.Schema<string, string, never>>;
     max: Schema.optional<Schema.Schema<string, string, never>>;
     rangeSeparatorIcon: Schema.optional<Schema.refine<string, typeof Schema.String>>;

package/dist/runtime/components/form/fields/2026-04-28/com.shwfed.form.field.numberrange/schema.js

@@ -66,6 +66,10 @@ export function schema(configure) {
       title: "\u6B65\u957F",
       description: "\u53D6\u503C\u7684\u6700\u5C0F\u6B65\u957F\uFF1B\u7559\u7A7A\u65F6\u4E0D\u9650\u5236\uFF08\u4EFB\u610F\u7CBE\u5EA6\uFF09"
     })),
+    valueAsString: Schema.optional(Schema.Boolean.annotations({
+      title: "\u4EE5\u5B57\u7B26\u4E32\u8BFB\u5199",
+      description: "\u5F00\u542F\u540E\u8868\u5355\u72B6\u6001\u4EE5\u5B57\u7B26\u4E32\u5F62\u5F0F\u5B58\u50A8\u4E24\u7AEF\u7684\u503C\uFF08\u9002\u7528\u4E8E\u540E\u7AEF\u4F7F\u7528 `DECIMAL` / `BIGINT` \u7B49\u9700\u8981\u539F\u6837\u56DE\u4F20\u7684\u5B57\u6BB5\uFF09\uFF1B\u5173\u95ED\u65F6\u82E5\u8BFB\u5230\u7684\u662F\u6570\u503C\u5B57\u7B26\u4E32\u4E5F\u4F1A\u88AB\u89E3\u6790\uFF0C\u4F46\u5199\u56DE\u4ECD\u4E3A\u6570\u503C\u3002\u6CE8\u610F\uFF1A\u8F93\u5165\u65F6\u4ECD\u7ECF\u8FC7 JavaScript \u6D6E\u70B9\u6570\uFF0C\u4EC5\u80FD\u5728\u300C\u88C5\u8F7D-\u56DE\u4F20\u300D\u672A\u7F16\u8F91\u573A\u666F\u4E0B\u4FDD\u7559\u7CBE\u5EA6"
+    })),
     min: Schema.optional(CelNumber.annotations({
       title: "\u6700\u5C0F\u503C",
       description: "\u5141\u8BB8\u8F93\u5165\u7684\u6700\u5C0F\u503C\u8868\u8FBE\u5F0F\uFF1B\u540C\u65F6\u4F5C\u7528\u4E8E\u8D77\u59CB\u4E0E\u7ED3\u675F\u8F93\u5165"

package/dist/runtime/plugins/i18n/index.js

@@ -1,14 +1,20 @@
 import { defineNuxtPlugin } from "#app";
 import { createI18n } from "vue-i18n";
+import { HttpRequestBuilder } from "../../vendor/cel-js/lib/http-builder.js";
 export default defineNuxtPlugin({
   name: "shwfed:i18n",
   setup: (nuxt) => {
-    nuxt.vueApp.use(createI18n({
+    const i18n = createI18n({
       locale: navigator?.language,
       legacy: false,
       fallbackWarn: false,
       fallbackLocale: "zh",
       globalInjection: false
-    }));
+    });
+    nuxt.vueApp.use(i18n);
+    HttpRequestBuilder.setDefaultHeader(
+      "Accept-Language",
+      () => i18n.global.locale.value
+    );
   }
 });

package/dist/runtime/vendor/cel-js/CLAUDE.md

@@ -20,7 +20,9 @@ The `homogeneousAggregateLiterals` and `enableOptionalTypes` environment options
 
 The custom `Optional` class has been replaced with Effect's `Option` type (`import { Option } from 'effect'`). Internal helpers `optionalOf(value)` and `optionalValue(opt)` in `optional.js` handle the CEL-specific semantics (treating `undefined` as `None`, throwing `EvaluationError` on missing value access).
 
-An `http` built-in has been added (`http-builtins.ts`, `http-builder.ts`) — not from upstream. It registers the `http` constant and the `http` / `HttpRequest` types on `globalRegistry`, so `http.get(url).header(...).body(...)` expressions type-check and evaluate in every `Environment`. A CEL expression only builds an `HttpRequestBuilder` — a pure description of a request; it never issues one. Both terminal methods, `.json()` and `.file()`, are dispatched by the host on the returned builder (neither is a CEL method), so expression evaluation stays free of IO. Endpoints must be absolute URLs — there is no base-URL resolution. Depends on `fx-fetch`.
+An `http` built-in has been added (`http-builtins.ts`, `http-builder.ts`) — not from upstream. It registers the `http` constant and the `http` / `HttpRequest` types on `globalRegistry`, so `http.get(url).header(...).body(...)` expressions type-check and evaluate in every `Environment`. A CEL expression only builds an `HttpRequestBuilder` — a pure description of a request; it never issues one. Both terminal methods, `.json()` and `.file()`, are dispatched by the host on the returned builder (neither is a CEL method), so expression evaluation stays free of IO. Endpoints must be absolute URLs — there is no base-URL resolution. Depends on `fx-fetch`. The host can register process-wide default headers via `HttpRequestBuilder.setDefaultHeader(name, valueOrGetter)` / `clearDefaultHeader(name)`; they are merged in at `#buildRequest()` time, with case-insensitive precedence to an explicit `.header(...)` on the builder. A getter that returns `null` / `undefined` / `''` skips the header for that request, so the host can source values from live refs (e.g. the active i18n locale for `Accept-Language`) without baking in stale snapshots.
+
+Spread syntax (`...expr`) inside list and map literals — not from upstream. A new `ELLIPSIS` token (3-char lookahead in the lexer) and a `spread` AST op let `[1, ...a, 4]` and `{...a, "x": 1, ...b}` desugar inside the parent literal. The spread node's own `check`/`evaluate` are defensive stubs — `parsePrimary` never produces one, so `...` outside a list/map is an "unexpected token" parse error. List `args` shape is unchanged (`IASTNode[]`, with spread elements detected via `op === 'spread'`); map `args` becomes `([IASTNode, IASTNode] | [IASTNode])[]` — a length-1 tuple represents a spread entry, preserving positional ordering for override semantics (later writes win). The fast path is preserved: the `list`/`map` `check` swaps `evaluate` meta to `evaluateSpreadList`/`evaluateSpreadMap` only when a spread child is present; literals without spreads run the original `resolveAstArray`/`safeFromEntries` paths byte-for-byte. Spread map sources may be plain objects, `Map` instances, or registered message types (typed as `map<string, dyn>`); the `__proto__`/`constructor`/`prototype` skip from `safeFromEntries` is applied to spread sources too. Runtime errors fire on non-list/non-map sources (including `null`). `maxListElements` / `maxMapEntries` count a spread as one entry — runtime expansion bypasses those caps (deliberate trade-off). Call-argument spread (`f(...args)`) is **not** supported.
 
 ## Architecture
 

package/dist/runtime/vendor/cel-js/PROMPT.md

@@ -67,6 +67,26 @@ condition ? value_if_true : value_if_false
 [1, 2] + [3, 4]            // [1, 2, 3, 4]
 ```
 
+### Spread (`...expr`)
+A spread inlines another list inside a list literal or another map inside a
+map literal. Order is preserved — a later entry (including a later spread)
+overrides an earlier one when keys collide.
+```cel
+[1, ...a, 4]                 // a flattens in position
+[...a, ...b]                 // equivalent to a + b
+
+{...a, "x": 1}               // copy a, then set x to 1
+{"x": 1, ...a}               // set x, then let a override
+{...a, ...b}                 // b overrides a on overlapping keys
+{...a, "x": 1, ...b}         // a, then x, then b — last write wins
+
+[...[1, 2], 3, ...[4]]       // [1, 2, 3, 4]
+```
+Spread is only valid as a list element or map entry — `f(...args)` is not
+supported (CEL resolves overloads by fixed arity). Spreading a non-list into
+a list, or a non-map into a map (including `null`), is an error — at compile
+time when statically known, at runtime when the source is `dyn`.
+
 ### Field access
 ```cel
 obj.field                   // access field on map/object

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

@@ -13,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/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.2.0",
+  "version": "2.2.1",
   "description": "Configurable UI for SHWFED",
   "type": "module",
   "publishConfig": {