@shwfed/config 2.12.1 → 2.12.2

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