@shwfed/config 2.12.0 → 2.12.2

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/share/disabled-date.d.ts

@@ -0,0 +1,34 @@
+import type { Environment } from '../vendor/cel-js/lib/index.js';
+import type { ResultType } from './expression.js';
+/**
+ * Result-type matcher for a per-date "should this date be disabled" expression.
+ * The expression returns `true` to disable the candidate date; `false`/none/
+ * absent leave it enabled (matching reka-ui's native `isDateDisabled`). Accepts
+ * a bare `bool` (`input >= now`) as well as `optional<bool>`
+ * (`cond ? optional.of(true) : optional.none()`) — same leniency as
+ * `HttpRequestResult` in `share/expression.ts`. At runtime `cel()` unwraps
+ * `optional.none()` to `undefined`, which the predicate treats as "no opinion,
+ * keep the date enabled". `dyn`/`optional<dyn>` ride along for gradual typing.
+ */
+export declare const DISABLE_DATE_RESULT: ResultType;
+/**
+ * Register the `input` (Date) CEL variable — the candidate date the calendar is
+ * rendering — only when an enclosing `configure` hasn't already declared it. The
+ * CEL registry throws `'input' is already registered` on a duplicate, so the
+ * guard mirrors `registerRowVariablesIfAbsent` / `registerLoopVariablesIfAbsent`.
+ */
+export declare function registerInputDateIfAbsent(env: Environment): void;
+/**
+ * The `input` variable advertised to `ExpressionEditor` via its `extra-vars`
+ * prop, so completion offers it at design time. Pair with
+ * `DISABLE_DATE_EDITOR_RESULT` for the editor's `result-type` — the editor prop
+ * can't take a function matcher, so the array form mirrors `DISABLE_DATE_RESULT`.
+ */
+export declare const INPUT_DATE_VARS: {
+    readonly input: {
+        readonly type: "Date";
+        readonly label: "候选日期";
+        readonly description: "日历中待判定是否可选的日期";
+    };
+};
+export declare const DISABLE_DATE_EDITOR_RESULT: readonly ["bool", "optional<bool>"];

package/dist/runtime/share/disabled-date.js

@@ -0,0 +1,13 @@
+export const DISABLE_DATE_RESULT = (t) => t === "bool" || t === "optional<bool>" || t === "optional<dyn>" || t === "dyn";
+const INPUT_VAR_LABEL = "\u5019\u9009\u65E5\u671F";
+const INPUT_VAR_DESCRIPTION = "\u65E5\u5386\u4E2D\u5F85\u5224\u5B9A\u662F\u5426\u53EF\u9009\u7684\u65E5\u671F";
+export function registerInputDateIfAbsent(env) {
+  const declared = new Set(env.getDefinitions().variables.map((v) => v.name));
+  if (!declared.has("input")) {
+    env.registerVariable("input", "Date", { label: INPUT_VAR_LABEL, description: INPUT_VAR_DESCRIPTION });
+  }
+}
+export const INPUT_DATE_VARS = {
+  input: { type: "Date", label: INPUT_VAR_LABEL, description: INPUT_VAR_DESCRIPTION }
+};
+export const DISABLE_DATE_EDITOR_RESULT = ["bool", "optional<bool>"];

package/dist/runtime/utils/ai/index.js

@@ -5,7 +5,7 @@ import { coerceFromString } from "../../share/coerce-from-string.js";
 const ENDPOINT = "http://192.168.168.10/anthropic/v1/messages";
 const MODEL = "MiniMax-M2.7";
 const ANTHROPIC_VERSION = "2023-06-01";
-const DEFAULT_MAX_TOKENS = 8192;
+const DEFAULT_MAX_TOKENS = 32768;
 export class StructuredOutputDecodeError extends Error {
   rawOutput;
   constructor(rawOutput, cause) {
@@ -273,6 +273,8 @@ async function streamChat(input) {
   };
   const assistant = { id: createMessageId(), role: "assistant", parts: [] };
   const publish = () => input.onMessageUpdate?.(assistant);
+  const MAX_TRUNCATION_STREAK = 3;
+  let truncationStreak = 0;
   for (; ; ) {
     const partByIndex = /* @__PURE__ */ new Map();
     const response = await callStream(messages, input.system, opts, input.signal, () => {
@@ -313,8 +315,29 @@ async function streamChat(input) {
       (b) => b.type === "tool_use"
     );
     if (toolUses.length === 0) {
+      if (response.stop_reason === "max_tokens") {
+        if (truncationStreak >= MAX_TRUNCATION_STREAK) {
+          throw new Error("\u6A21\u578B\u8FDE\u7EED\u591A\u8F6E\u5728\u4EA7\u51FA\u524D\u7528\u5C3D token \u9884\u7B97\uFF08max_tokens\uFF09\uFF0C\u5DF2\u505C\u6B62\u3002\u8BF7\u7F29\u5C0F\u672C\u6B21\u914D\u7F6E\u8303\u56F4\u6216\u62C6\u5206\u6307\u4EE4\u540E\u91CD\u8BD5\u3002");
+        }
+        truncationStreak++;
+        const echoable = response.content.filter(
+          (b) => !(b.type === "text" && b.text.length === 0)
+        );
+        const assistantEcho = echoable.length > 0 ? echoable : [{ type: "text", text: "\u2026" }];
+        messages.push({ role: "assistant", content: assistantEcho });
+        messages.push({
+          role: "user",
+          content: "\u4E0A\u4E00\u8F6E\u5728 max_tokens \u5904\u88AB\u622A\u65AD\u3002\u8BF7\u7528\u66F4\u5C0F\u7684\u6B65\u5B50\u7EE7\u7EED\uFF1A\u672C\u8F6E\u53EA\u505A\u4E00\u6B65\uFF08\u4E00\u4E2A\u5DE5\u5177\u8C03\u7528\uFF0C\u6216\u4E00\u6BB5\u7B80\u77ED\u56DE\u590D\uFF09\u3002"
+        });
+        if (assistant.parts.length > 0) {
+          assistant.parts.push({ type: "step-start" });
+          publish();
+        }
+        continue;
+      }
       return assistant;
     }
+    truncationStreak = 0;
     await runToolResults(
       messages,
       response.content,

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/disabled-date.d.ts

@@ -0,0 +1,26 @@
+import type { DateValue } from 'reka-ui';
+/**
+ * Convert an `@internationalized/date` `DateValue` (what the picker's
+ * `disabledDate` callback receives) to a native JS `Date`, so user expressions
+ * see a plain `input: Date`. Mirrors `pickerValueToNative` in
+ * `ui/date-picker/DatePicker.vue` (minus the `Time` branch — the per-date
+ * predicate never receives a `Time`). For a `CalendarDate` (date/month/year
+ * panels) the time fields are absent and default to `0`; for `month` panels the
+ * candidate is the first of the month (`day` is `1`).
+ */
+export declare function dateValueToNative(d: DateValue): Date;
+/**
+ * Build the `(d: DateValue) => boolean` predicate the date pickers expect from a
+ * user-authored CEL expression. Centralizes three concerns shared by every date
+ * block: the `DateValue` → native `Date` conversion, the "expression returns
+ * `true` ⇒ date disabled" mapping (`false`/`undefined`/none ⇒ enabled — matching
+ * reka-ui's native `isDateDisabled`), and error containment (a throwing
+ * expression leaves the date enabled).
+ *
+ * Each runtime passes its own `evalWithInput` closure so its existing CEL scope
+ * is preserved verbatim — form fields evaluate against `{ form, input }`, table
+ * columns against `celScope(celContext, { input })`. Returns `undefined` when
+ * there's no expression, so the picker omits the prop and all dates stay
+ * selectable.
+ */
+export declare function makeDisabledDatePredicate(expr: string | undefined, evalWithInput: (input: Date) => boolean | undefined): ((d: DateValue) => boolean) | undefined;

package/dist/runtime/utils/disabled-date.js

@@ -0,0 +1,21 @@
+export function dateValueToNative(d) {
+  return new Date(
+    d.year,
+    d.month - 1,
+    "day" in d ? d.day : 1,
+    "hour" in d ? d.hour : 0,
+    "hour" in d ? d.minute : 0,
+    "hour" in d ? d.second : 0
+  );
+}
+export function makeDisabledDatePredicate(expr, evalWithInput) {
+  if (!expr) return void 0;
+  return (d) => {
+    try {
+      return evalWithInput(dateValueToNative(d)) === true;
+    } catch (e) {
+      console.error("[shwfed] disabledDate expression failed", e);
+      return false;
+    }
+  };
+}

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