@shwfed/config 2.12.1 → 2.12.3

package/dist/runtime/components/ui/expression-editor/option-chip-extension.js

@@ -0,0 +1,119 @@
+import { Facet, RangeSetBuilder } from "@codemirror/state";
+import {
+  Decoration,
+  EditorView,
+  ViewPlugin,
+  WidgetType
+} from "@codemirror/view";
+import { scanOptionRefs } from "./option-refs.js";
+export const optionLookupFacet = Facet.define({
+  combine: (values) => values.length > 0 ? values[values.length - 1] : /* @__PURE__ */ new Map()
+});
+class OptionChipWidget extends WidgetType {
+  constructor(id, name) {
+    super();
+    this.id = id;
+    this.name = name;
+  }
+  eq(other) {
+    return other.id === this.id && other.name === this.name;
+  }
+  toDOM() {
+    const chip = document.createElement("span");
+    chip.className = "cm-option-chip";
+    chip.setAttribute("data-option-id", this.id);
+    const tag = document.createElement("span");
+    tag.className = "cm-option-chip-tag";
+    tag.textContent = "\u5168\u90E8\u9009\u9879";
+    chip.appendChild(tag);
+    const text = document.createElement("span");
+    text.className = "cm-option-chip-label";
+    if (this.name !== null) {
+      text.textContent = this.name;
+      chip.title = `\u5168\u90E8\u9009\u9879 \xB7 ${this.name}`;
+    } else {
+      chip.classList.add("cm-option-chip-dangling");
+      const short = this.id.length > 8 ? `${this.id.slice(0, 8)}\u2026` : this.id;
+      text.textContent = short;
+      chip.title = `\u672A\u77E5\u5B57\u6BB5 ${this.id}`;
+    }
+    chip.appendChild(text);
+    return chip;
+  }
+  ignoreEvent() {
+    return false;
+  }
+}
+function buildChips(view) {
+  const lookup = view.state.facet(optionLookupFacet);
+  const builder = new RangeSetBuilder();
+  for (const ref of scanOptionRefs(view.state.doc.toString())) {
+    const name = lookup.get(ref.id) ?? null;
+    builder.add(
+      ref.from,
+      ref.to,
+      Decoration.replace({ widget: new OptionChipWidget(ref.id, name) })
+    );
+  }
+  return builder.finish();
+}
+const chipPlugin = ViewPlugin.fromClass(
+  class {
+    decorations;
+    constructor(view) {
+      this.decorations = buildChips(view);
+    }
+    update(update) {
+      if (update.docChanged || update.viewportChanged || update.startState.facet(optionLookupFacet) !== update.state.facet(optionLookupFacet)) {
+        this.decorations = buildChips(update.view);
+      }
+    }
+  },
+  {
+    decorations: (plugin) => plugin.decorations,
+    // Atomic so the caret steps over a chip and Backspace removes the whole
+    // `options["id"]` at once — matching the selection chip's delete-as-unit feel.
+    provide: (plugin) => EditorView.atomicRanges.of((view) => view.plugin(plugin)?.decorations ?? Decoration.none)
+  }
+);
+const chipTheme = EditorView.theme({
+  ".cm-option-chip": {
+    display: "inline-flex",
+    alignItems: "center",
+    gap: "0.25rem",
+    margin: "0 1px",
+    padding: "0.125rem 0.25rem",
+    borderRadius: "0.25rem",
+    background: "#fffbeb",
+    border: "1px solid #fde68a",
+    color: "#b45309",
+    fontFamily: "ui-sans-serif, system-ui, sans-serif",
+    verticalAlign: "baseline",
+    cursor: "default",
+    whiteSpace: "nowrap"
+  },
+  ".cm-option-chip-dangling": {
+    background: "#fef2f2",
+    borderColor: "#fecaca",
+    color: "#b91c1c"
+  },
+  ".cm-option-chip-tag": {
+    borderRadius: "0.125rem",
+    background: "#fef3c7",
+    padding: "0.05rem 0.2rem",
+    fontSize: "9px",
+    lineHeight: "1",
+    color: "#d97706"
+  },
+  ".cm-option-chip-dangling .cm-option-chip-tag": {
+    background: "#fee2e2",
+    color: "#b91c1c"
+  },
+  ".cm-option-chip-label": {
+    fontSize: "0.75rem",
+    lineHeight: "1.1"
+  }
+});
+export function optionChips() {
+  return [chipPlugin, chipTheme];
+}

package/dist/runtime/components/ui/expression-editor/option-refs.d.ts

@@ -0,0 +1,6 @@
+export type OptionRef = {
+    from: number;
+    to: number;
+    id: string;
+};
+export declare function scanOptionRefs(text: string): OptionRef[];

package/dist/runtime/components/ui/expression-editor/option-refs.js

@@ -0,0 +1,24 @@
+import { OPTIONS_VAR } from "../../../utils/cel-context.js";
+const OPTION_REF_RE = new RegExp(
+  `(?<![\\w$.])${OPTIONS_VAR}\\[\\??("(?:[^"\\\\]|\\\\.)*")\\]`,
+  "g"
+);
+export function scanOptionRefs(text) {
+  const out = [];
+  OPTION_REF_RE.lastIndex = 0;
+  let match;
+  while ((match = OPTION_REF_RE.exec(text)) !== null) {
+    let id;
+    try {
+      id = JSON.parse(match[1]);
+    } catch {
+      continue;
+    }
+    out.push({
+      from: match.index,
+      to: match.index + match[0].length,
+      id
+    });
+  }
+  return out;
+}

package/dist/runtime/components/ui/expression-editor/picker-entries.d.ts

@@ -1,7 +1,7 @@
 import { type ScopeAncestor, type SelectionFieldRef, type StepRef } from '../../../utils/cel-context.js';
 export type PickEntry = {
     id: string;
-    group: 'var' | 'scope' | 'selection' | 'step';
+    group: 'var' | 'scope' | 'selection' | 'option' | 'step';
     insert: string;
     display: string;
     label: string;
@@ -15,6 +15,7 @@ export type PickVarMeta = {
 };
 export declare function buildVarEntries(celContext: Record<string, PickVarMeta>, extraVars?: Record<string, PickVarMeta>): PickEntry[];
 export declare function buildSelectionEntries(roster: ReadonlyArray<SelectionFieldRef>): PickEntry[];
+export declare function buildOptionEntries(roster: ReadonlyArray<SelectionFieldRef>): PickEntry[];
 export declare function buildStepEntries(roster: ReadonlyArray<StepRef>): PickEntry[];
 export declare function selectShadowedScopes(ancestry: ReadonlyArray<ScopeAncestor>): ScopeAncestor[];
 export declare function buildScopeEntries(ancestry: ReadonlyArray<ScopeAncestor>): PickEntry[];

package/dist/runtime/components/ui/expression-editor/picker-entries.js

@@ -1,6 +1,6 @@
-import { SCOPE_ADDRESS_VAR, SELECTIONS_VAR, STEPS_VAR } from "../../../utils/cel-context.js";
+import { OPTIONS_VAR, SCOPE_ADDRESS_VAR, SELECTIONS_VAR, STEPS_VAR } from "../../../utils/cel-context.js";
 import { scopeOrigin } from "./scope-refs.js";
-const SUPPRESSED_VARS = /* @__PURE__ */ new Set([SCOPE_ADDRESS_VAR, SELECTIONS_VAR, STEPS_VAR]);
+const SUPPRESSED_VARS = /* @__PURE__ */ new Set([SCOPE_ADDRESS_VAR, SELECTIONS_VAR, OPTIONS_VAR, STEPS_VAR]);
 export function buildVarEntries(celContext, extraVars) {
   const out = [];
   const seen = /* @__PURE__ */ new Set();
@@ -25,6 +25,16 @@ export function buildSelectionEntries(roster) {
     type: "dyn"
   }));
 }
+export function buildOptionEntries(roster) {
+  return roster.map((field) => ({
+    id: `option:${field.id}`,
+    group: "option",
+    insert: `${OPTIONS_VAR}[?${JSON.stringify(field.id)}]`,
+    display: field.name,
+    label: "\u5168\u90E8\u9009\u9879",
+    type: "dyn"
+  }));
+}
 export function buildStepEntries(roster) {
   return roster.filter((step) => step.valid).map((step) => ({
     id: `step:${step.id}`,

package/dist/runtime/utils/cel-context.d.ts

@@ -8,6 +8,7 @@ export type CELVar = {
 export type CELContext = Record<string, CELVar>;
 export declare const SCOPE_ADDRESS_VAR = "__scopes__";
 export declare const SELECTIONS_VAR = "selections";
+export declare const OPTIONS_VAR = "options";
 export declare const STEPS_VAR = "steps";
 export type ScopeAccessor = Record<string, () => unknown>;
 export declare function provideCELContext(context: CELContext): void;

package/dist/runtime/utils/cel-context.js

@@ -2,6 +2,7 @@ import { computed, inject, provide, shallowRef } from "vue";
 import { injectLocal, provideLocal } from "@vueuse/core";
 export const SCOPE_ADDRESS_VAR = "__scopes__";
 export const SELECTIONS_VAR = "selections";
+export const OPTIONS_VAR = "options";
 export const STEPS_VAR = "steps";
 const CEL_CONTEXT_KEY = Symbol("cel-context");
 export function provideCELContext(context) {

package/dist/runtime/utils/selections-registry.d.ts

@@ -38,17 +38,38 @@ export type SelectionsRegistry = {
     clear: (uuid: string) => void;
 };
 /**
- * Create a registry and provide it to descendants. Called once per host (the
- * form root; later, a table row). The returned `entries` ref is what the host
- * overlays as the `selections` CEL thunk.
+ * The `options` channel is the exact same registry shape — a `uuid → value` map
+ * with the identical shallowRef + map-replace + identity-dedup discipline — but
+ * carries a field's WHOLE loaded option list (`options["<uuid>"]` → `[opt, …]`)
+ * rather than its selected option. A field owns both channels: `selections`
+ * publishes the picked option(s), `options` publishes every option it loaded.
+ * Kept under a separate injection key so the two maps are independent providers
+ * on the one host (the form root provides both). `OptionsRegistry` is a plain
+ * alias of `SelectionsRegistry` — the recursion-safety invariant is identical,
+ * so they must share the one implementation, never a drifting copy.
+ */
+export type OptionsRegistry = SelectionsRegistry;
+/**
+ * Create the selections registry and provide it to descendants. The returned
+ * `entries` ref is what the host overlays as the `selections` CEL thunk.
  */
 export declare function provideSelectionsRegistry(): SelectionsRegistry;
 /**
- * Inject the nearest registry, or `undefined` when there's no providing host
- * (an uncontrolled field, a unit test). Callers must tolerate the absent case —
- * publishing is best-effort.
+ * Create the options registry and provide it to descendants. The returned
+ * `entries` ref is what the host overlays as the `options` CEL thunk.
+ */
+export declare function provideOptionsRegistry(): OptionsRegistry;
+/**
+ * Inject the nearest selections registry, or `undefined` when there's no
+ * providing host (an uncontrolled field, a unit test). Callers must tolerate the
+ * absent case — publishing is best-effort.
  */
 export declare function useSelectionsRegistry(): SelectionsRegistry | undefined;
+/**
+ * Inject the nearest options registry, or `undefined` when there's no providing
+ * host. Best-effort, same contract as `useSelectionsRegistry`.
+ */
+export declare function useOptionsRegistry(): OptionsRegistry | undefined;
 /**
  * Wire a selection field's publish lifecycle to the nearest registry. Call once
  * in setup; it injects the host registry (tolerating absence), watches the
@@ -75,3 +96,16 @@ export declare function publishSelection<T>(key: string, resolved: () => T | und
     identity: (value: T) => string;
     raw: (value: T) => unknown;
 }): void;
+/**
+ * Wire a selection field's OPTIONS-list publish lifecycle to the nearest options
+ * registry. Same contract and de-dup discipline as `publishSelection` — the
+ * recursion hazard is identical (`celBindings` reads the `options` map on every
+ * `$cel` pass, and remote records are re-copied each pass), so `resolved` must
+ * return the whole loaded list, `identity` must project it to the STABLE joined
+ * option keys (never the payload), and `raw` projects it to the array stored for
+ * siblings to read. An empty list resolves to `undefined` → the entry clears.
+ */
+export declare function publishOptions<T>(key: string, resolved: () => T | undefined, project: {
+    identity: (value: T) => string;
+    raw: (value: T) => unknown;
+}): void;

package/dist/runtime/utils/selections-registry.js

@@ -1,5 +1,6 @@
 import { inject, onUnmounted, provide, shallowRef, watch } from "vue";
 const SELECTIONS_KEY = Symbol("shwfed-selections");
+const OPTIONS_KEY = Symbol("shwfed-options");
 function sameSelection(a, b) {
   if (Object.is(a, b)) return true;
   if (Array.isArray(a) && Array.isArray(b)) {
@@ -8,7 +9,7 @@ function sameSelection(a, b) {
   }
   return false;
 }
-export function provideSelectionsRegistry() {
+function createRegistry(key) {
   const entries = shallowRef({});
   const registry = {
     entries,
@@ -19,18 +20,29 @@ export function provideSelectionsRegistry() {
     clear: (uuid) => {
       if (!(uuid in entries.value)) return;
       entries.value = Object.fromEntries(
-        Object.entries(entries.value).filter(([key]) => key !== uuid)
+        Object.entries(entries.value).filter(([key2]) => key2 !== uuid)
       );
     }
   };
-  provide(SELECTIONS_KEY, registry);
+  provide(key, registry);
   return registry;
 }
+export function provideSelectionsRegistry() {
+  return createRegistry(SELECTIONS_KEY);
+}
+export function provideOptionsRegistry() {
+  return createRegistry(OPTIONS_KEY);
+}
 export function useSelectionsRegistry() {
   return inject(SELECTIONS_KEY, void 0);
 }
+export function useOptionsRegistry() {
+  return inject(OPTIONS_KEY, void 0);
+}
 export function publishSelection(key, resolved, project) {
-  const registry = useSelectionsRegistry();
+  publishTo(useSelectionsRegistry(), key, resolved, project);
+}
+function publishTo(registry, key, resolved, project) {
   const NONE = "\0:none";
   let last = "\0:init";
   watch(
@@ -47,3 +59,6 @@ export function publishSelection(key, resolved, project) {
   );
   onUnmounted(() => registry?.clear(key));
 }
+export function publishOptions(key, resolved, project) {
+  publishTo(useOptionsRegistry(), key, resolved, project);
+}

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

@@ -18,6 +18,8 @@ A `list.enumerate(): list<map<string, dyn>>` receiver method has been added (not
 
 A `list.slice(number)` / `list.slice(number, number)` receiver pair has been added (not from upstream, in `functions.ts` beside `list.enumerate()`) — delegates straight to JS `Array.prototype.slice`, so negative indices count from the end (`list.slice(0, -1)` drops the last element) and out-of-range bounds clamp rather than throw. End is exclusive. Fills the gap left by CEL's `list[i]`, which has no negative indexing. Both overloads return `list<dyn>`.
 
+A `string.replace(string, string): string` / `string.replace(string, string, number): string` receiver pair has been added (in `functions.ts` beside `string.trim()`), matching the CEL strings-extension `replace`. The two-arg form delegates to JS `String.prototype.replaceAll` (so all non-overlapping occurrences are replaced; an empty `from` interleaves `to`). The three-arg form takes a limit and mirrors Go's `strings.Replace` via the `replaceLimited` helper: `limit < 0` replaces all, `0` replaces none, otherwise the first `limit` occurrences (`"foo".replace("", "_", 2) == "_f_oo"`).
+
 `evaluate` now returns `Effect<T, ParseError | EvaluationError | TypeError>` instead of a plain value. The entire evaluation pipeline is Effect-based — every AST node's `evaluate` function returns an Effect, and sub-expressions are composed via `Effect.gen` / `yield*`. Promise-based async handling has been removed. User-registered functions may return `Effect` values, which are automatically flatMapped into the evaluation pipeline. Import `Effect` from `effect` and use `Effect.runSync` or `Effect.runPromise` to execute the returned Effect.
 
 The `homogeneousAggregateLiterals` and `enableOptionalTypes` environment options have been removed. Aggregate data structures (lists, maps) are always heterogeneous — mixed-type literals are inferred as `list<dyn>` or `map<dyn, dyn>`. Optional types (`.?`, `[?]`, `optional.*` helpers) are always enabled.

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

@@ -161,6 +161,8 @@ Mirrors JS `Array.prototype.slice`. Negative indices count from the end (CEL's `
 "hello".indexOf("l")                 // 2
 "hello".lastIndexOf("l")             // 3
 "hello".matches("[a-z]+")            // true (regex)
+"hello".replace("l", "L")            // "heLLo" (all occurrences)
+"hello".replace("l", "L", 1)         // "heLlo" (first N; N<0 = all, 0 = none)
 "a,b,c".split(",")                   // ["a", "b", "c"]
 "a,b,c".split(",", 2)               // ["a", "b,c"]
 ["a", "b"].join()                    // "ab"

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

@@ -139,6 +139,14 @@ export function registerFunctions(registry) {
   functionOverload("string.lowerAscii(): string", (a) => a.toLowerCase());
   functionOverload("string.upperAscii(): string", (a) => a.toUpperCase());
   functionOverload("string.trim(): string", (a) => a.trim());
+  functionOverload(
+    "string.replace(string, string): string",
+    (string, from, to) => string.replaceAll(from, to)
+  );
+  functionOverload(
+    "string.replace(string, string, number): string",
+    (string, from, to, limit) => replaceLimited(string, from, to, toNum(limit))
+  );
   functionOverload(
     "string.indexOf(string): number",
     (string, search) => Decimal.from(string.indexOf(search))
@@ -436,3 +444,28 @@ function stringSize(str) {
   for (const _ of str) count++;
   return count;
 }
+function replaceLimited(str, from, to, limit) {
+  if (limit < 0) return str.replaceAll(from, to);
+  if (limit === 0 || from === to) return str;
+  let result = "";
+  let start = 0;
+  let count = 0;
+  while (count < limit) {
+    let j;
+    if (from === "") {
+      if (count > 0) {
+        if (start >= str.length) break;
+        j = start + 1;
+      } else {
+        j = start;
+      }
+    } else {
+      j = str.indexOf(from, start);
+      if (j < 0) break;
+    }
+    result += str.slice(start, j) + to;
+    start = j + from.length;
+    count++;
+  }
+  return result + str.slice(start);
+}

package/package.json

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