@shwfed/config 2.5.3 → 2.6.0

package/dist/runtime/components/ui/expression-editor/cel-language.d.ts

@@ -0,0 +1,16 @@
+import type { Extension } from '@codemirror/state';
+import { StreamLanguage } from '@codemirror/language';
+type State = {
+    afterDot: boolean;
+};
+/** The CEL stream language (tokeniser only — no indentation/folding services). */
+export declare const celLanguage: StreamLanguage<State>;
+/** One tokenised slice of a line: the source `text` and its stream-token name. */
+export type CELToken = {
+    text: string;
+    token: string | null;
+};
+export declare function tokenizeCEL(line: string): CELToken[];
+/** Full lexical-highlighting extension: the CEL language + its colour scheme. */
+export declare function celHighlighting(): Extension;
+export {};

package/dist/runtime/components/ui/expression-editor/cel-language.js

@@ -0,0 +1,114 @@
+import {
+  HighlightStyle,
+  StreamLanguage,
+  StringStream,
+  syntaxHighlighting
+} from "@codemirror/language";
+import { tags as t } from "@lezer/highlight";
+const ATOMS = /* @__PURE__ */ new Set(["true", "false", "null"]);
+const OPERATOR_RE = /^(?:==|!=|<=|>=|&&|\|\||[+\-*/%<>!?])/;
+const IDENT_RE = /^[A-Z_$][\w$]*/i;
+const NUMBER_RE = /^(?:0x[0-9a-f]+|\d+\.\d*(?:e[+-]?\d+)?|\d+(?:e[+-]?\d+)?)u?/i;
+function eatString(stream) {
+  const s = stream.string;
+  const start = stream.pos;
+  let i = start;
+  let prefixLen = 0;
+  while (prefixLen < 2 && /[br]/i.test(s[i + prefixLen] ?? "")) prefixLen++;
+  const quote = s[i + prefixLen];
+  if (quote !== '"' && quote !== "'") return false;
+  const raw = /r/i.test(s.slice(i, i + prefixLen));
+  i += prefixLen;
+  const triple = s.slice(i, i + 3) === quote + quote + quote;
+  const closer = triple ? quote + quote + quote : quote;
+  i += closer.length;
+  while (i < s.length) {
+    const c = s[i];
+    if (!raw && c === "\\") {
+      i += 2;
+      continue;
+    }
+    if (s.slice(i, i + closer.length) === closer) {
+      i += closer.length;
+      break;
+    }
+    if (!triple && (c === "\n" || c === "\r")) break;
+    i++;
+  }
+  stream.pos = Math.min(i, s.length);
+  return true;
+}
+const celStreamParser = {
+  startState: () => ({ afterDot: false }),
+  copyState: (state) => ({ afterDot: state.afterDot }),
+  token(stream, state) {
+    if (stream.eatSpace()) return null;
+    if (stream.match(/^\.\.\./)) {
+      state.afterDot = false;
+      return null;
+    }
+    if (eatString(stream)) {
+      state.afterDot = false;
+      return "string";
+    }
+    if (stream.match(NUMBER_RE)) {
+      state.afterDot = false;
+      return "number";
+    }
+    const ident = stream.match(IDENT_RE);
+    if (ident) {
+      const word = ident[0];
+      const afterDot = state.afterDot;
+      state.afterDot = false;
+      if (afterDot) return "propertyName";
+      if (word === "in") return "keyword";
+      if (ATOMS.has(word)) return "atom";
+      return stream.peek() === "(" ? "variableName.function" : "variableName";
+    }
+    if (stream.match(OPERATOR_RE)) {
+      state.afterDot = false;
+      return "operator";
+    }
+    if (stream.eat(".")) {
+      state.afterDot = true;
+      return null;
+    }
+    state.afterDot = false;
+    stream.next();
+    return null;
+  }
+};
+export const celLanguage = StreamLanguage.define(celStreamParser);
+export function tokenizeCEL(line) {
+  const stream = new StringStream(line, 4, 2);
+  const state = celStreamParser.startState();
+  const out = [];
+  while (!stream.eol()) {
+    stream.start = stream.pos;
+    const token = celStreamParser.token(stream, state);
+    if (stream.pos === stream.start) stream.next();
+    out.push({ text: line.slice(stream.start, stream.pos), token });
+  }
+  return out;
+}
+const celHighlightStyle = HighlightStyle.define([
+  { tag: t.keyword, color: "#5a3e8e" },
+  // magenta — control keyword `in`
+  { tag: t.operator, color: "#5a3e8e" },
+  // magenta — && || == + - …
+  { tag: t.string, color: "#385f0d" },
+  // green — strings / bytes
+  { tag: t.number, color: "#965027" },
+  // orange — numbers
+  { tag: t.atom, color: "#965027" },
+  // orange — true / false / null
+  { tag: t.variableName, color: "#343b58" },
+  // navy — variables
+  { tag: t.propertyName, color: "#0f4b6e" },
+  // cyan — object properties / member access
+  { tag: t.function(t.variableName), color: "#2959aa" }
+  // blue — function calls
+]);
+export function celHighlighting() {
+  return [celLanguage, syntaxHighlighting(celHighlightStyle)];
+}

package/dist/runtime/components/ui/expression-editor/chip-extension.d.ts

@@ -0,0 +1,5 @@
+import { type Extension, Facet } from '@codemirror/state';
+import { type ScopeInfo } from './scope-refs.js';
+export declare const scopeLookupFacet: Facet<Map<string, ScopeInfo>, Map<string, ScopeInfo>>;
+/** The full inline-chip extension: decoration plugin + theme. */
+export declare function scopeChips(): Extension;

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

@@ -0,0 +1,123 @@
+import { Facet, RangeSetBuilder } from "@codemirror/state";
+import {
+  Decoration,
+  EditorView,
+  ViewPlugin,
+  WidgetType
+} from "@codemirror/view";
+import { scanScopeRefs } from "./scope-refs.js";
+export const scopeLookupFacet = Facet.define({
+  combine: (values) => values.length > 0 ? values[values.length - 1] : /* @__PURE__ */ new Map()
+});
+class ScopeChipWidget extends WidgetType {
+  constructor(id, member, resolved) {
+    super();
+    this.id = id;
+    this.member = member;
+    this.resolved = resolved;
+  }
+  eq(other) {
+    return other.id === this.id && other.member === this.member && other.resolved?.origin === this.resolved?.origin && other.resolved?.label === this.resolved?.label && other.resolved?.type === this.resolved?.type;
+  }
+  toDOM() {
+    const chip = document.createElement("span");
+    chip.className = "cm-scope-chip";
+    chip.setAttribute("data-scope-id", this.id);
+    chip.setAttribute("data-scope-member", this.member);
+    const text = document.createElement("span");
+    text.className = "cm-scope-chip-label";
+    if (this.resolved) {
+      text.textContent = `${this.resolved.origin} \u203A ${this.resolved.label}`;
+      chip.title = this.resolved.origin;
+    } else {
+      chip.classList.add("cm-scope-chip-dangling");
+      const short = this.id.length > 8 ? `${this.id.slice(0, 8)}\u2026` : this.id;
+      text.textContent = `${short} \u203A ${this.member}`;
+      chip.title = `\u672A\u77E5\u4F5C\u7528\u57DF ${this.id}`;
+    }
+    chip.appendChild(text);
+    const type = this.resolved?.type;
+    if (type) {
+      const badge = document.createElement("span");
+      badge.className = "cm-scope-chip-type";
+      badge.textContent = type;
+      chip.appendChild(badge);
+    }
+    return chip;
+  }
+  ignoreEvent() {
+    return false;
+  }
+}
+function buildChips(view) {
+  const lookup = view.state.facet(scopeLookupFacet);
+  const builder = new RangeSetBuilder();
+  for (const ref of scanScopeRefs(view.state.doc.toString())) {
+    const info = lookup.get(ref.id);
+    const member = info?.members.get(ref.member);
+    const resolved = info && member ? { origin: info.origin, label: member.label, type: member.type } : null;
+    builder.add(
+      ref.from,
+      ref.to,
+      Decoration.replace({ widget: new ScopeChipWidget(ref.id, ref.member, resolved) })
+    );
+  }
+  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(scopeLookupFacet) !== update.state.facet(scopeLookupFacet)) {
+        this.decorations = buildChips(update.view);
+      }
+    }
+  },
+  {
+    decorations: (plugin) => plugin.decorations,
+    // Atomic ranges so the caret steps over a chip and Backspace removes the
+    // whole `__scopes__[...].member` at once — the user's delete-as-unit choice.
+    provide: (plugin) => EditorView.atomicRanges.of((view) => view.plugin(plugin)?.decorations ?? Decoration.none)
+  }
+);
+const chipTheme = EditorView.theme({
+  ".cm-scope-chip": {
+    display: "inline-flex",
+    alignItems: "center",
+    gap: "0.25rem",
+    margin: "0 1px",
+    padding: "0.125rem 0.25rem",
+    borderRadius: "0.25rem",
+    background: "#f4f4f5",
+    border: "1px solid #e4e4e7",
+    color: "#3f3f46",
+    fontFamily: "ui-sans-serif, system-ui, sans-serif",
+    verticalAlign: "baseline",
+    cursor: "default",
+    whiteSpace: "nowrap"
+  },
+  ".cm-scope-chip-dangling": {
+    background: "#fef2f2",
+    borderColor: "#fecaca",
+    color: "#b91c1c"
+  },
+  ".cm-scope-chip-label": {
+    fontSize: "0.75rem",
+    lineHeight: "1.1"
+  },
+  ".cm-scope-chip-type": {
+    borderRadius: "0.25rem",
+    background: "#f3e8ff",
+    padding: "0.05rem 0.25rem",
+    fontFamily: "var(--font-mono)",
+    fontSize: "10px",
+    lineHeight: "1",
+    color: "#7e22ce"
+  }
+});
+export function scopeChips() {
+  return [chipPlugin, chipTheme];
+}

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

@@ -0,0 +1,17 @@
+import { type ScopeAncestor } from '../../../utils/cel-context.js';
+export type PickEntry = {
+    id: string;
+    group: 'var' | 'scope';
+    insert: string;
+    display: string;
+    label: string;
+    type: string;
+    description?: string;
+};
+export type PickVarMeta = {
+    type: string;
+    label: string;
+    description?: string;
+};
+export declare function buildVarEntries(celContext: Record<string, PickVarMeta>, extraVars?: Record<string, PickVarMeta>): PickEntry[];
+export declare function buildScopeEntries(ancestry: ReadonlyArray<ScopeAncestor>): PickEntry[];

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

@@ -0,0 +1,34 @@
+import { SCOPE_ADDRESS_VAR } from "../../../utils/cel-context.js";
+import { scopeOrigin } from "./scope-refs.js";
+export function buildVarEntries(celContext, extraVars) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [name, meta] of Object.entries(celContext)) {
+    if (name === SCOPE_ADDRESS_VAR) continue;
+    seen.add(name);
+    out.push({ id: name, group: "var", insert: name, display: name, label: meta.label, type: meta.type, description: meta.description });
+  }
+  for (const [name, meta] of Object.entries(extraVars ?? {})) {
+    if (seen.has(name) || name === SCOPE_ADDRESS_VAR) continue;
+    out.push({ id: name, group: "var", insert: name, display: name, label: meta.label, type: meta.type, description: meta.description });
+  }
+  return out;
+}
+export function buildScopeEntries(ancestry) {
+  const out = [];
+  for (const ancestor of ancestry) {
+    const origin = scopeOrigin(ancestor);
+    for (const member of ancestor.members) {
+      out.push({
+        id: `scope:${ancestor.id}:${member.key}`,
+        group: "scope",
+        insert: `${SCOPE_ADDRESS_VAR}[${JSON.stringify(ancestor.id)}].${member.key}`,
+        display: `${origin} \u203A ${member.label}`,
+        label: origin,
+        type: member.type,
+        description: member.description
+      });
+    }
+  }
+  return out;
+}

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

@@ -0,0 +1,20 @@
+import { type ScopeAncestor } from '../../../utils/cel-context.js';
+export declare function scopeOrigin(ancestor: Pick<ScopeAncestor, 'name' | 'typeName'>): string;
+export type ScopeRef = {
+    from: number;
+    to: number;
+    id: string;
+    member: string;
+};
+export declare function scanScopeRefs(text: string): ScopeRef[];
+/** A member of an addressable scope, resolved for chip display. */
+export type ScopeMemberInfo = {
+    label: string;
+    type: string;
+};
+/** Display data for one addressable ancestor, keyed by member name. */
+export type ScopeInfo = {
+    origin: string;
+    members: Map<string, ScopeMemberInfo>;
+};
+export declare function buildScopeLookup(ancestry: ReadonlyArray<ScopeAncestor>): Map<string, ScopeInfo>;

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

@@ -0,0 +1,39 @@
+import { SCOPE_ADDRESS_VAR } from "../../../utils/cel-context.js";
+export function scopeOrigin(ancestor) {
+  return ancestor.name ? `${ancestor.typeName}\u300C${ancestor.name}\u300D` : ancestor.typeName;
+}
+const SCOPE_REF_RE = new RegExp(
+  `${SCOPE_ADDRESS_VAR}\\[("(?:[^"\\\\]|\\\\.)*")\\]\\.([A-Za-z_$][\\w$]*)`,
+  "g"
+);
+export function scanScopeRefs(text) {
+  const out = [];
+  SCOPE_REF_RE.lastIndex = 0;
+  let match;
+  while ((match = SCOPE_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,
+      member: match[2]
+    });
+  }
+  return out;
+}
+export function buildScopeLookup(ancestry) {
+  const lookup = /* @__PURE__ */ new Map();
+  for (const ancestor of ancestry) {
+    const members = /* @__PURE__ */ new Map();
+    for (const member of ancestor.members) {
+      members.set(member.key, { label: member.label, type: member.type });
+    }
+    lookup.set(ancestor.id, { origin: scopeOrigin(ancestor), members });
+  }
+  return lookup;
+}

package/dist/runtime/share/expression.js

@@ -12,6 +12,12 @@ function formatExpectedType(expected) {
   if (Array.isArray(expected)) return expected.join(" | ");
   return "(\u81EA\u5B9A\u4E49)";
 }
+function registerScopeAddressVar(env) {
+  env.registerVariable("__scopes__", "map<string, dyn>", {
+    label: "\u8DE8\u5C42\u4F5C\u7528\u57DF",
+    description: "\u6309 UUID \u5BFB\u5740\u88AB\u906E\u853D\u7684\u7956\u5148\u4F5C\u7528\u57DF"
+  });
+}
 function buildDescription(baseline, env, resultType) {
   const defs = env.getDefinitions();
   const baselineVarNames = new Set(baseline.variables.map((v) => v.name));
@@ -39,6 +45,7 @@ export function Expression(options) {
   const env = new Environment({
     unlistedVariablesAreDyn: options.unlistedVariablesAreDyn ?? false
   });
+  registerScopeAddressVar(env);
   const baseline = env.getDefinitions();
   options.configure(env);
   const description = buildDescription(baseline, env, options.resultType);
@@ -69,6 +76,7 @@ export function Expression(options) {
 const INTERPOLATION_RE = /\{\{(.*?)\}\}/gs;
 export function Markdown(options) {
   const env = new Environment({ unlistedVariablesAreDyn: false });
+  registerScopeAddressVar(env);
   const baseline = env.getDefinitions();
   options.configure(env);
   const description = `Markdown with CEL interpolation via {{ expression }}. ${buildDescription(baseline, env).slice("CEL expression. ".length)}`;
@@ -100,6 +108,7 @@ export function Markdown(options) {
 }
 export function LocaleMarkdown(options) {
   const env = new Environment({ unlistedVariablesAreDyn: false });
+  registerScopeAddressVar(env);
   const baseline = env.getDefinitions();
   options.configure(env);
   const description = `Locale with Markdown CEL interpolation via {{ expression }}. ${buildDescription(baseline, env).slice("CEL expression. ".length)}`;

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

@@ -1,3 +1,4 @@
+import type { Ref } from 'vue';
 export type CELVar = {
     type: string;
     label: string;
@@ -5,6 +6,41 @@ export type CELVar = {
     value: unknown;
 };
 export type CELContext = Record<string, CELVar>;
+export declare const SCOPE_ADDRESS_VAR = "__scopes__";
+export type ScopeAccessor = Record<string, () => unknown>;
 export declare function provideCELContext(context: CELContext): void;
 export declare function injectCELContext(): CELContext;
+export declare function provideScopeAddress(uuid: string, accessor: ScopeAccessor): void;
+/** One addressable member of an ancestor scope, e.g. `row` / `index`. */
+export type ScopeAncestorMember = Readonly<{
+    /** Member name appended after the address — `__scopes__["id"].<key>`. */
+    key: string;
+    label: string;
+    /** CEL type shown as the picker badge. */
+    type: string;
+    description?: string;
+}>;
+/** A scope-exposing ancestor instance, as seen by an expression-editor picker. */
+export type ScopeAncestor = Readonly<{
+    /** Instance id keyed into `__scopes__["<id>"]`. */
+    id: string;
+    /** Instance display name (a table's 内部名称); blank → show the type name alone. */
+    name?: string;
+    /** Component type display name (from type metadata). */
+    typeName: string;
+    /** Component type icon (from type metadata). */
+    typeIcon?: string;
+    members: ReadonlyArray<ScopeAncestorMember>;
+}>;
+/**
+ * Contribute one scope-exposing ancestor frame. Descendant editors see it
+ * prepended (nearest first) to the inherited chain. A `null` value contributes
+ * nothing — for an editor whose current target may or may not own an `id`.
+ */
+export declare function provideScopeAncestor(ancestor: Ref<ScopeAncestor | null>): void;
+/**
+ * The scope-exposing ancestors enclosing the current editing position, nearest
+ * first. Empty when nothing up the config tree exposes an addressable scope.
+ */
+export declare function useScopeAncestry(): Ref<ReadonlyArray<ScopeAncestor>>;
 export declare function celBindings(context: CELContext): Record<string, unknown>;

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

@@ -1,4 +1,6 @@
+import { computed, inject, provide, shallowRef } from "vue";
 import { injectLocal, provideLocal } from "@vueuse/core";
+export const SCOPE_ADDRESS_VAR = "__scopes__";
 const CEL_CONTEXT_KEY = Symbol("cel-context");
 export function provideCELContext(context) {
   const parent = injectLocal(CEL_CONTEXT_KEY, {});
@@ -7,6 +9,43 @@ export function provideCELContext(context) {
 export function injectCELContext() {
   return injectLocal(CEL_CONTEXT_KEY, {});
 }
+function resolveScopeAccessor(accessor) {
+  const resolved = {};
+  for (const [member, thunk] of Object.entries(accessor)) resolved[member] = thunk();
+  return resolved;
+}
+export function provideScopeAddress(uuid, accessor) {
+  const parentScopes = injectCELContext()[SCOPE_ADDRESS_VAR];
+  provideCELContext({
+    [SCOPE_ADDRESS_VAR]: {
+      type: "map<string, dyn>",
+      label: "\u8DE8\u5C42\u4F5C\u7528\u57DF",
+      description: '\u6309 UUID \u5BFB\u5740\u88AB\u906E\u853D\u7684\u7956\u5148\u4F5C\u7528\u57DF\uFF08\u5982 `__scopes__["<uuid>"].row`\uFF09\uFF1B\u4EC5\u80FD\u547D\u4E2D\u8BCD\u6CD5\u4E0A\u5305\u4F4F\u5F53\u524D\u4F4D\u7F6E\u7684\u4F5C\u7528\u57DF\u3002',
+      // Resolved fresh each binding pass: invoke the parent thunk for live
+      // ancestor rows, then overlay this uuid. Picker-stored expressions index
+      // this by uuid; a uuid not on the ancestor chain is simply absent, so
+      // bracket access throws a located `No such key` at the offending uuid.
+      value: () => {
+        const base = parentScopes ? typeof parentScopes.value === "function" ? parentScopes.value() : parentScopes.value : {};
+        return { ...base, [uuid]: resolveScopeAccessor(accessor) };
+      }
+    }
+  });
+}
+const SCOPE_ANCESTRY_KEY = Symbol("cel-scope-ancestry");
+export function provideScopeAncestor(ancestor) {
+  const parent = inject(SCOPE_ANCESTRY_KEY, void 0);
+  provide(
+    SCOPE_ANCESTRY_KEY,
+    computed(() => {
+      const chain = parent?.value ?? [];
+      return ancestor.value ? [ancestor.value, ...chain] : chain;
+    })
+  );
+}
+export function useScopeAncestry() {
+  return inject(SCOPE_ANCESTRY_KEY, void 0) ?? shallowRef([]);
+}
 export function celBindings(context) {
   const out = {};
   for (const [name, entry] of Object.entries(context)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shwfed/config",
-  "version": "2.5.3",
+  "version": "2.6.0",
   "description": "Configurable UI for SHWFED",
   "type": "module",
   "publishConfig": {
@@ -44,10 +44,15 @@
   "dependencies": {
     "@atlaskit/pragmatic-drag-and-drop": "^1.8.1",
     "@atlaskit/pragmatic-drag-and-drop-hitbox": "^1.1.0",
+    "@codemirror/commands": "^6.10.3",
+    "@codemirror/language": "^6.12.3",
+    "@codemirror/state": "^6.6.0",
+    "@codemirror/view": "^6.43.0",
     "@date-fns/tz": "^1.4.1",
     "@iconify/vue": "^5.0.1",
     "@internationalized/date": "^3.12.1",
     "@intlify/unplugin-vue-i18n": "^11.2.3",
+    "@lezer/highlight": "^1.2.3",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@nuxt/kit": "^4.4.5",
     "@tailwindcss/typography": "^0.5.19",