@shwfed/config 3.0.3 → 3.0.6

package/dist/runtime/components/form/fields/2026-07-13/com.shwfed.form.field.dynamic/schema.d.ts

@@ -0,0 +1,59 @@
+import { Schema } from 'effect';
+import type { Environment } from '../../../../../vendor/cel-js/lib/index.js';
+export declare const type: "com.shwfed.form.field.dynamic";
+export declare const compatibilityDate: "2026-07-13";
+export declare const metadata: {
+    readonly name: "动态字段";
+    readonly icon: "fluent:form-multiple-20-regular";
+    readonly w: {
+        readonly initial: 12;
+        readonly min: 4;
+        readonly max: number;
+    };
+    readonly h: {
+        readonly initial: 4;
+        readonly min: 2;
+        readonly max: number;
+        readonly grow: true;
+    };
+};
+declare const DynFieldKind: Schema.Literal<["text", "number", "date", "daterange", "dropdown"]>;
+export type DynFieldKindValue = Schema.Schema.Type<typeof DynFieldKind>;
+export declare const KIND_TO_FIELD: Record<DynFieldKindValue, {
+    type: string;
+    compatibilityDate: string;
+}>;
+export declare const CHOICE_KINDS: ReadonlySet<DynFieldKindValue>;
+/**
+ * The narrow, module-owned DTO the `transform` must emit per field. Wider than
+ * the column DTO because these are *edit* definitions — they carry requiredness,
+ * options, and default values. Each list element is decoded against this at
+ * runtime (partial-drop, loud); the strongest static guarantee is only that
+ * `transform` returns `list<dyn>`.
+ */
+export declare const DynFieldDescriptor: Schema.Struct<{
+    binding: Schema.filter<typeof Schema.String>;
+    label: typeof Schema.String;
+    kind: Schema.Literal<["text", "number", "date", "daterange", "dropdown"]>;
+    required: Schema.optional<typeof Schema.Boolean>;
+    options: Schema.optional<Schema.Array$<Schema.Struct<{
+        value: Schema.Union<[typeof Schema.String, typeof Schema.Number]>;
+        label: typeof Schema.String;
+    }>>>;
+    default: Schema.optional<typeof Schema.Unknown>;
+}>;
+export type DynFieldDescriptorValue = Schema.Schema.Type<typeof DynFieldDescriptor>;
+export declare function schema(configure: (env: Environment) => void): Schema.Struct<{
+    type: Schema.Literal<["com.shwfed.form.field.dynamic"]>;
+    compatibilityDate: Schema.Literal<["2026-07-13"]>;
+    id: Schema.refine<string, typeof Schema.String>;
+    displayName: Schema.optional<Schema.SchemaClass<string, string, never>>;
+    hidden: Schema.optional<Schema.Schema<string, string, never>>;
+    request: Schema.Schema<string, string, never>;
+    transform: Schema.Schema<string, string, never>;
+    columns: Schema.optional<Schema.refine<number, Schema.filter<typeof Schema.Number>>>;
+    orientation: Schema.optional<Schema.Literal<["vertical", "floating"]>>;
+}>;
+export type Value = Schema.Schema.Type<ReturnType<typeof schema>>;
+export declare function defaults(): Partial<Value>;
+export {};

package/dist/runtime/components/form/fields/2026-07-13/com.shwfed.form.field.dynamic/schema.js

@@ -0,0 +1,139 @@
+import { Schema } from "effect";
+import { Expression, HttpRequestResult } from "../../../../../share/expression.js";
+import { md } from "../../../../../share/markdown.js";
+import { FieldOrientationSchema } from "../../../utils/common.js";
+import { FORM_VARIABLE_NAMES } from "../../../utils/form-vars.js";
+export const type = "com.shwfed.form.field.dynamic";
+export const compatibilityDate = "2026-07-13";
+export const metadata = {
+  name: "\u52A8\u6001\u5B57\u6BB5",
+  icon: "fluent:form-multiple-20-regular",
+  w: { initial: 12, min: 4, max: Infinity },
+  h: { initial: 4, min: 2, max: Infinity, grow: true }
+  // Hosts a runtime-generated sub-form; its config (two expressions + two
+  // inputs) is small enough for the docked inline pane, so leave `inlineConfig`
+  // at its default (supported).
+};
+const DynFieldKind = Schema.Literal(
+  "text",
+  "number",
+  "date",
+  "daterange",
+  "dropdown"
+);
+export const KIND_TO_FIELD = {
+  text: { type: "com.shwfed.form.field.text", compatibilityDate: "2026-04-22" },
+  number: { type: "com.shwfed.form.field.number", compatibilityDate: "2026-04-28" },
+  date: { type: "com.shwfed.form.field.date", compatibilityDate: "2026-04-27" },
+  daterange: { type: "com.shwfed.form.field.daterange", compatibilityDate: "2026-04-27" },
+  dropdown: { type: "com.shwfed.form.field.combobox.single", compatibilityDate: "2026-06-14" }
+};
+export const CHOICE_KINDS = /* @__PURE__ */ new Set(["dropdown"]);
+const DynFieldOption = Schema.Struct({
+  // The value bound when this option is chosen. A number maps to the leaves'
+  // `{ kind: 'number', value }` item shape, a string to `{ kind: 'text', value }`.
+  value: Schema.Union(Schema.String, Schema.Number),
+  // Plain string, no i18n (confirmed requirement); `expand` wraps it into a zh
+  // `Locale` via the dyn-cols `wrapLocale` idiom.
+  label: Schema.String
+});
+export const DynFieldDescriptor = Schema.Struct({
+  // dot-prop path like any field's binding; for the legacy app = `parameter_name`.
+  // Child `id` is namespaced `<blockId>::<binding>`, so it can never collide
+  // with a static field or another block in the form-wide validation /
+  // selections registries. First-wins on duplicate bindings within one block.
+  binding: Schema.String.pipe(Schema.minLength(1)),
+  // Plain string, no i18n (confirmed requirement); wrapped into a zh `Locale`.
+  label: Schema.String,
+  // Selects the pinned leaf (closed vocabulary).
+  kind: DynFieldKind,
+  // `true` → the child gets `required: 'true'` (the CEL literal), which is both
+  // the required star and the non-empty gate.
+  required: Schema.optional(Schema.Boolean),
+  // Choice kinds' static options. A choice-kind descriptor without `options` is
+  // dropped (loud). Legacy idiom:
+  // `f.optional_values.split('\n').map(v, {'value': v, 'label': v})`.
+  options: Schema.optional(Schema.Array(DynFieldOption)),
+  // Initial-value seed: written into form state at `binding` iff that path
+  // currently resolves to `undefined` (never clobbering the form-level `initial`
+  // seed or user input).
+  default: Schema.optional(Schema.Unknown)
+});
+function withoutFormVariables(configure) {
+  return (env) => {
+    const proxy = new Proxy(env, {
+      get(target, prop) {
+        if (prop === "registerVariable") {
+          return (name, ...rest) => {
+            if (FORM_VARIABLE_NAMES.has(name)) return;
+            return target.registerVariable(name, ...rest);
+          };
+        }
+        const v = Reflect.get(target, prop, target);
+        return typeof v === "function" ? v.bind(target) : v;
+      }
+    });
+    configure(proxy);
+  };
+}
+export function schema(configure) {
+  const frozenConfigure = withoutFormVariables(configure);
+  const CelRequest = Expression({ configure: frozenConfigure, resultType: HttpRequestResult });
+  const CelTransform = Expression({
+    configure: (env) => {
+      frozenConfigure(env);
+      const declared = new Set(env.getDefinitions().variables.map((v) => v.name));
+      if (!declared.has("json")) {
+        env.registerVariable("json", "optional<dyn>", {
+          label: "HTTP \u54CD\u5E94\u4F53",
+          description: "\u5B57\u6BB5\u5B9A\u4E49\u63A5\u53E3\u7684\u54CD\u5E94\u4F53\uFF08\u5DF2\u89E3\u6790 JSON\uFF09\uFF1B\u672A\u83B7\u53D6\u5230\u65F6\u4E3A none\uFF0C\u901A\u8FC7 `json.orValue(...)` \u89E3\u5305"
+        });
+      }
+    },
+    resultType: (t) => t.startsWith("list") || t === "dyn" || t.startsWith("optional")
+  });
+  const CelBool = Expression({ configure, resultType: "bool" });
+  return Schema.Struct({
+    type: Schema.Literal(type),
+    compatibilityDate: Schema.Literal(compatibilityDate),
+    // Design-time identity; placements reference it. The block carries NO
+    // `binding` / `required` / `validations` of its own — it has no value.
+    id: Schema.UUID.annotations({ description: "\u5B57\u6BB5\u552F\u4E00\u6807\u8BC6\uFF1B\u5E03\u5C40\u901A\u8FC7\u8BE5 id \u5F15\u7528\u8BE5\u52A8\u6001\u533A\u57DF" }),
+    displayName: Schema.optional(Schema.String.annotations({
+      title: "\u5185\u90E8\u540D\u79F0",
+      description: "\u4EC5\u5728\u7F16\u8F91\u5668\u5185\u53EF\u89C1\u7684\u540D\u79F0\uFF0C\u7528\u4E8E\u5728\u4FA7\u8FB9\u680F\u548C\u5E03\u5C40\u7F16\u8F91\u5668\u4E2D\u8BC6\u522B\u8BE5\u52A8\u6001\u533A\u57DF\uFF1B\u8FD0\u884C\u65F6\u4E0D\u5C55\u793A"
+    })),
+    hidden: Schema.optional(CelBool.annotations({
+      title: "\u9690\u85CF\u6761\u4EF6",
+      description: "\u8FD4\u56DE `true` \u65F6\u6574\u4E2A\u52A8\u6001\u533A\u57DF\u5728\u6240\u6709\u5E03\u5C40\u4E2D\u90FD\u4E0D\u6E32\u67D3\uFF08\u5E76\u89E6\u53D1\u8F68\u9053\u538B\u7F29\u6536\u8D77\u8BE5\u533A\u57DF\uFF09"
+    })),
+    request: CelRequest.annotations({
+      title: "\u5B57\u6BB5\u5B9A\u4E49\u8BF7\u6C42",
+      description: md`
+        获取字段定义列表的 HTTP 请求表达式（与数据源 \`request\` 同为 \`HttpRequest\` 形状）。
+        字段集合在挂载时**一次性**获取，**不随表单状态变化** —— 作用域内没有 \`form\` 等表单运行时变量。
+      `
+    }),
+    transform: CelTransform.annotations({
+      title: "\u5B57\u6BB5\u5B9A\u4E49\u6620\u5C04",
+      description: md`
+        将 \`json\`（字段定义响应体，用 \`json.orValue([])\` 解包）映射为一组字段描述（\`list\`）。
+        每个元素需符合固定字段（注意 CEL 映射字面量的键要加引号）：\`binding\`（写入路径 / 唯一标识）、
+        \`label\`（标签，纯文本无 i18n）、\`kind\`（\`text\`/\`number\`/\`date\`/\`daterange\`/\`dropdown\`）；
+        可选 \`required\`（布尔）、\`options\`（\`list<{value, label}>\`，\`dropdown\` 必填）、
+        \`default\`（初始值）。**所有与后端数据契约相关的知识都在这里**。
+      `
+    }),
+    columns: Schema.optional(Schema.Number.pipe(Schema.int(), Schema.positive()).annotations({
+      title: "\u5217\u6570",
+      description: "\u6BCF\u884C\u6392\u5E03\u7684\u5B50\u5B57\u6BB5\u6570\uFF1A\u6BCF\u4E2A\u5B50\u5B57\u6BB5\u6070\u597D\u5360\u4E00\u683C\uFF0C\u6309\u5B9A\u4E49\u987A\u5E8F\u884C\u4F18\u5148\u6392\u5E03\u3001\u6EE1\u884C\u6362\u884C\u3002\u9ED8\u8BA4 1\uFF08\u6BCF\u4E2A\u5B57\u6BB5\u5360\u6EE1\u6574\u884C\uFF09"
+    })),
+    orientation: Schema.optional(FieldOrientationSchema.annotations({
+      title: "\u65B9\u5411",
+      description: "\u7EDF\u4E00\u65BD\u52A0\u5230\u6BCF\u4E2A\u52A8\u6001\u5B50\u5B57\u6BB5\u7684\u6807\u7B7E\u6392\u5217\u65B9\u5411\uFF08`orientation` \u662F\u914D\u7F6E\u6570\u636E\uFF0C\u8FD0\u884C\u65F6\u6CA1\u6709\u65B9\u5411\u63D0\u4F9B\u8005\uFF09\uFF1B\u641C\u7D22\u8868\u5355\u573A\u666F\u901A\u5E38\u7528 `floating`"
+    }))
+  }).annotations({ title: "DynamicFields", description: "\u8FD0\u884C\u65F6\u52A8\u6001\u5B57\u6BB5\uFF08\u7531\u670D\u52A1\u7AEF\u5B57\u6BB5\u5B9A\u4E49\u751F\u6210\uFF09" });
+}
+export function defaults() {
+  return { request: "", transform: "" };
+}

package/dist/runtime/components/form/utils/form-vars.d.ts

@@ -1,19 +1,9 @@
 import type { Environment } from '../../../vendor/cel-js/lib/index.js';
 /**
- * Register the form-wide `now` / `form` live variables on `env`, skipping any
- * already declared. Idempotent so it composes safely from either side: a
- * `FormConfig` nested inside another (the `table` form field embeds a table
- * whose `query` is its own sub-form, and the embedding `configure` advertises
- * the same pair) would otherwise register `form` twice on one env and the CEL
- * registry throws `'form' is already registered`. Mirrors
- * `registerRowVariablesIfAbsent`.
- *
- * This is the single source of truth for the `form` / `now` metadata: the
- * schema's expression validators register it here, the designer-time picker
- * probes it (`buildFormCelScope`), and the runtime scope derives its
- * type/label/description from it too (`buildFormRuntimeScope`). Lives in this
- * dependency-light module — not `schema.ts` — so the scope helpers can import it
- * without pulling `utils/resolve` (and its `import.meta.glob`) into per-folder
- * unit tests. `schema.ts` re-exports it for existing call sites.
+ * The names the form registrar owns — the form-runtime state a schema can
+ * subtract from an expression scope when its semantics forbid depending on the
+ * live form (the dynamic-fields block's `request` / `transform`: the field set
+ * is frozen at mount and must not read `form`).
  */
+export declare const FORM_VARIABLE_NAMES: ReadonlySet<string>;
 export declare function registerFormVariablesIfAbsent(env: Environment): void;

package/dist/runtime/components/form/utils/form-vars.js

@@ -1,10 +1,16 @@
 import { OPTIONS_VAR, SELECTIONS_VAR } from "../../../utils/cel-context.js";
+const FORM_VARIABLE_DEFS = [
+  { name: "now", type: "Date", meta: { label: "\u5F53\u524D\u65F6\u95F4", description: "\u5F53\u524D\u65E5\u671F/\u65F6\u95F4" } },
+  { name: "form", type: "dyn", meta: { label: "\u8868\u5355\u503C", description: "\u5F53\u524D\u8868\u5355\u72B6\u6001" } },
+  { name: "undoable", type: "bool", meta: { label: "\u53EF\u64A4\u9500", description: "\u5F53\u524D\u662F\u5426\u6709\u53EF\u64A4\u9500\u7684\u4FEE\u6539" } },
+  { name: "redoable", type: "bool", meta: { label: "\u53EF\u91CD\u505A", description: "\u5F53\u524D\u662F\u5426\u6709\u53EF\u91CD\u505A\u7684\u4FEE\u6539" } },
+  { name: SELECTIONS_VAR, type: "dyn", meta: { label: "\u9009\u4E2D\u9879", description: "\u5404\u9009\u62E9\u5B57\u6BB5\u5F53\u524D\u9009\u4E2D\u9879\u7684\u5B8C\u6574\u5BF9\u8C61\uFF08\u6309\u5B57\u6BB5\u6807\u8BC6\uFF09" } },
+  { name: OPTIONS_VAR, type: "dyn", meta: { label: "\u5168\u90E8\u9009\u9879", description: "\u5404\u9009\u62E9\u5B57\u6BB5\u5F53\u524D\u5DF2\u52A0\u8F7D\u7684\u5168\u90E8\u9009\u9879\uFF08\u6309\u5B57\u6BB5\u6807\u8BC6\uFF0C\u5143\u7D20\u4E3A\u9009\u9879\u5B8C\u6574\u5BF9\u8C61\uFF09" } }
+];
+export const FORM_VARIABLE_NAMES = new Set(FORM_VARIABLE_DEFS.map((d) => d.name));
 export function registerFormVariablesIfAbsent(env) {
   const declared = new Set(env.getDefinitions().variables.map((v) => v.name));
-  if (!declared.has("now")) env.registerVariable("now", "Date", { label: "\u5F53\u524D\u65F6\u95F4", description: "\u5F53\u524D\u65E5\u671F/\u65F6\u95F4" });
-  if (!declared.has("form")) env.registerVariable("form", "dyn", { label: "\u8868\u5355\u503C", description: "\u5F53\u524D\u8868\u5355\u72B6\u6001" });
-  if (!declared.has("undoable")) env.registerVariable("undoable", "bool", { label: "\u53EF\u64A4\u9500", description: "\u5F53\u524D\u662F\u5426\u6709\u53EF\u64A4\u9500\u7684\u4FEE\u6539" });
-  if (!declared.has("redoable")) env.registerVariable("redoable", "bool", { label: "\u53EF\u91CD\u505A", description: "\u5F53\u524D\u662F\u5426\u6709\u53EF\u91CD\u505A\u7684\u4FEE\u6539" });
-  if (!declared.has(SELECTIONS_VAR)) env.registerVariable(SELECTIONS_VAR, "dyn", { label: "\u9009\u4E2D\u9879", description: "\u5404\u9009\u62E9\u5B57\u6BB5\u5F53\u524D\u9009\u4E2D\u9879\u7684\u5B8C\u6574\u5BF9\u8C61\uFF08\u6309\u5B57\u6BB5\u6807\u8BC6\uFF09" });
-  if (!declared.has(OPTIONS_VAR)) env.registerVariable(OPTIONS_VAR, "dyn", { label: "\u5168\u90E8\u9009\u9879", description: "\u5404\u9009\u62E9\u5B57\u6BB5\u5F53\u524D\u5DF2\u52A0\u8F7D\u7684\u5168\u90E8\u9009\u9879\uFF08\u6309\u5B57\u6BB5\u6807\u8BC6\uFF0C\u5143\u7D20\u4E3A\u9009\u9879\u5B8C\u6574\u5BF9\u8C61\uFF09" });
+  for (const d of FORM_VARIABLE_DEFS) {
+    if (!declared.has(d.name)) env.registerVariable(d.name, d.type, d.meta);
+  }
 }

package/dist/runtime/components/operations/2026-06-11/com.shwfed.operation.http.request.json/schema.js

@@ -8,7 +8,7 @@ export const metadata = {
   name: "\u53D1\u9001\u8BF7\u6C42",
   icon: "fluent:cloud-arrow-up-20-regular",
   // This op publishes its parsed response as a chain-step output, so later
-  // trigger rows can reference it via `steps["<row-id>"]`.
+  // trigger rows can reference it via `steps[?"<row-id>"]`.
   output: "HTTP \u54CD\u5E94\uFF08\u89E3\u6790\u540E\u7684 JSON\uFF09"
 };
 export function schema(configure) {
@@ -69,7 +69,7 @@ export function schema(configure) {
     description: md`
       发起一次 HTTP 请求（响应解析为 JSON）。请求失败（网络错误 / 非 2xx / 响应不可解析）
       或「执行结果」为 \`error\` 时中止本次触发链。在触发列表中串联多个本操作即可按顺序
-      调用多个接口——前一个失败后，后续操作不再执行。后面的步骤可经 \`steps["<步骤标识>"]\`
+      调用多个接口——前一个失败后，后续操作不再执行。后面的步骤可经 \`steps[?"<步骤标识>"]\`
       引用前面步骤的响应。
 
       toast 完全由「提示标题」「提示内容」决定（含失败场景）；不配置标题、或标题求值为空字符串则静默。

package/dist/runtime/components/operations/2026-06-15/com.shwfed.operation.http.download/schema.js

@@ -39,7 +39,7 @@ export function schema(configure) {
       title: "\u8BF7\u6C42",
       description: md`
         构造一个请求，其响应将被取回并保存为文件。
-        可经 \`steps["<步骤标识>"]\` 引用前序步骤的输出——把先前
+        可经 \`steps[?"<步骤标识>"]\` 引用前序步骤的输出——把先前
         \`发送请求\` 行取得的凭据用于构造真正的下载请求。
       `
     }),
@@ -75,7 +75,7 @@ export function schema(configure) {
       发起一次 HTTP 请求：若响应是二进制（非 JSON）则保存为本地文件；若响应是 JSON，
       则视为后端返回的状态信封，经「执行结果」裁定成败而**不**保存。下载失败（网络错误 / 非 2xx）
       或「执行结果」为 \`error\` 会中止本次触发链——其后排队的操作不再执行。把本操作接在一个
-      \`发送请求\` 行之后、并经 \`steps["<步骤标识>"]\` 引用其响应，即可实现
+      \`发送请求\` 行之后、并经 \`steps[?"<步骤标识>"]\` 引用其响应，即可实现
       “先取凭据再下载”的两步式。toast 完全由「提示标题」「提示内容」决定（含失败场景）；
       不配置标题、或标题求值为空字符串则静默。
     `

package/dist/runtime/components/operations/2026-06-15/com.shwfed.operation.navigation/runtime.js

@@ -1,12 +1,6 @@
 import { Effect } from "effect";
 import { navigateTo, useRouter } from "#app";
-function isExternal(url) {
-  try {
-    return new URL(url, window.location.href).origin !== window.location.origin;
-  } catch {
-    return false;
-  }
-}
+import { isAbsoluteUrl } from "../../../../share/navigation.js";
 export const handler = (params, ctx) => {
   const { url, mode } = params ?? {};
   if (!url || url.trim().length === 0) return Effect.void;
@@ -14,13 +8,13 @@ export const handler = (params, ctx) => {
     const steps = ctx.step?.outputs() ?? {};
     const resolved = yield* ctx.cel(url, { steps });
     const router = useRouter();
-    const external = isExternal(resolved);
-    yield* Effect.promise(async () => {
+    const absolute = isAbsoluteUrl(resolved);
+    yield* Effect.tryPromise(async () => {
       if (mode === "_blank") {
-        window.open(external ? resolved : router.resolve(resolved).href, "_blank");
+        window.open(absolute ? resolved : router.resolve(resolved).href, "_blank");
         return;
       }
-      await navigateTo(resolved, { external });
+      await navigateTo(resolved, { external: absolute });
     });
   });
   return program.pipe(

package/dist/runtime/components/operations/2026-06-15/com.shwfed.operation.navigation/schema.js

@@ -28,7 +28,7 @@ export function schema(configure) {
   }).annotations({
     title: "NavigationOperation",
     description: md`
-      按所选方式打开一个链接。链接表达式可经 \`steps["<步骤标识>"]\` 引用前序步骤的输出，
+      按所选方式打开一个链接。链接表达式可经 \`steps[?"<步骤标识>"]\` 引用前序步骤的输出，
       因此可由先前请求的响应拼接目标地址。导航失败不中止本次触发链。
     `
   });

package/dist/runtime/components/operations/utils/resolve.d.ts

@@ -30,7 +30,7 @@ export type OperationMetadata = Readonly<{
     icon: string;
     /**
      * Present iff this operation publishes a chain-step output (`ctx.step.publish`)
-     * for later trigger rows to read via `steps["<row-id>"]` — the value is the
+     * for later trigger rows to read via `steps[?"<row-id>"]` — the value is the
      * designer-facing label of what gets published (e.g. 'HTTP 响应'). The trigger
      * editor reads it to decide which rows to offer as step references, so a
      * non-publishing op never advertises a reference that resolves to nothing.

package/dist/runtime/components/operations/utils/step-vars.d.ts

@@ -6,10 +6,12 @@ import { type CELVar } from '../../../utils/cel-context.js';
  * an op schema may be embedded under a host whose `configure` already
  * advertises it, and double registration throws.
  *
- * `dyn` (not `map<string, dyn>`) so `steps["<id>"].data.code` type-checks the
+ * `dyn` (not `map<string, dyn>`) so `steps[?"<id>"].data.code` type-checks the
  * same way `form.foo.bar` does — what a step publishes is backend-defined and
  * unknowable at design time. Keyed by trigger-row uuid; the picker renders
- * each key as its「第 N 步」position.
+ * each key as its「第 N 步」position, and writes the OPTIONAL lookup (`[?]`), so
+ * a step that published nothing evaluates to `undefined` instead of throwing
+ * `No such key`.
  */
 export declare function registerStepsVariableIfAbsent(env: Environment): void;
 /**

package/dist/runtime/components/table/columns/2026-04-14/com.shwfed.table.column.select/runtime.vue

@@ -1,33 +1,13 @@
 <script setup>
 import { computed } from "vue";
-import { Effect } from "effect";
 import { Icon } from "@iconify/vue";
-import { cel as $cel } from "../../../../../utils/cel";
-import { celScope, injectCELContext } from "../../../../../utils/cel-context";
 import { cn } from "../../../../../utils/cn";
 defineOptions({ name: "ShwfedTableSelectRendererRuntime" });
 const props = defineProps({
   column: { type: null, required: true },
   ctx: { type: Object, required: true }
 });
-const celContext = injectCELContext();
-function evalPredicate(expression, fallback) {
-  try {
-    return Boolean(Effect.runSync($cel(expression, celScope(celContext))));
-  } catch (e) {
-    console.error("[shwfed-table] row-selection predicate failed", e);
-    return fallback;
-  }
-}
-const canSelect = computed(() => {
-  if (props.column.enableRowSelection && !evalPredicate(props.column.enableRowSelection, true)) {
-    return false;
-  }
-  if (props.column.mode === "checkbox" && props.column.enableMultiRowSelection && !evalPredicate(props.column.enableMultiRowSelection, true)) {
-    return false;
-  }
-  return true;
-});
+const canSelect = computed(() => props.ctx.row.getCanSelect());
 function onCheckboxClick(e) {
   if (!canSelect.value) return;
   const { row, table } = props.ctx;

package/dist/runtime/components/table/columns/2026-04-14/com.shwfed.table.column.select/schema.d.ts

@@ -1,6 +1,7 @@
 import { Schema } from 'effect';
 import type { ColumnDef } from '@tanstack/vue-table';
 import type { Environment } from '../../../../../vendor/cel-js/lib/index.js';
+import type { ColumnRowSelection } from '../../../utils/resolve.js';
 export declare const type: "com.shwfed.table.column.select";
 export declare const compatibilityDate: "2026-04-14";
 export declare const metadata: {
@@ -20,4 +21,5 @@ export declare function schema(configure: (env: Environment) => void): Schema.St
 }>;
 export type Value = Schema.Schema.Type<ReturnType<typeof schema>>;
 export declare function defaults(): Partial<Value>;
+export declare const rowSelection: ColumnRowSelection;
 export declare function toColumnDef(value: Value): Partial<ColumnDef<unknown, unknown>>;

package/dist/runtime/components/table/columns/2026-04-14/com.shwfed.table.column.select/schema.js

@@ -1,4 +1,4 @@
-import { Schema } from "effect";
+import { Effect, Schema } from "effect";
 import { h } from "vue";
 import { Expression } from "../../../../../share/expression.js";
 import { columnIdentityFields, registerRowVariablesIfAbsent } from "../../../utils/shared.js";
@@ -40,6 +40,21 @@ export function defaults() {
     mode: "checkbox"
   };
 }
+export const rowSelection = (value, deps) => {
+  const predicates = [
+    value.enableRowSelection,
+    value.mode === "checkbox" ? value.enableMultiRowSelection : void 0
+  ].filter((e) => typeof e === "string" && e.trim() !== "");
+  if (predicates.length === 0) return () => true;
+  return (row, index) => predicates.every((expression) => {
+    try {
+      return Boolean(Effect.runSync(deps.$cel(expression, deps.rowScope(row, index))));
+    } catch (e) {
+      console.error("[shwfed-table] row-selection predicate failed", e);
+      return true;
+    }
+  });
+};
 export function toColumnDef(value) {
   return {
     header: (ctx) => h(Header, { column: value, ctx }),

package/dist/runtime/components/table/index.vue

@@ -324,6 +324,20 @@ const getRowId = createRowKeyResolver({
     }
   }
 });
+const rowSelectionPredicates = computed(() => effectiveColumns.value.flatMap((col) => {
+  const contribute = findColumn(col.type, col.compatibilityDate)?.rowSelection;
+  if (!contribute) return [];
+  return [contribute(col, {
+    $cel,
+    rowScope: (row, index) => celScope(inheritedContext, { row, index })
+  })];
+}));
+function canSelectRow(row) {
+  const predicates = rowSelectionPredicates.value;
+  if (predicates.length === 0) return true;
+  const index = getDisplayIndex(row);
+  return predicates.every((p) => p(row.original, index));
+}
 const tableApi = useVueTable({
   get columns() {
     return columns.value;
@@ -331,6 +345,7 @@ const tableApi = useVueTable({
   get data() {
     return rowData.value;
   },
+  enableRowSelection: canSelectRow,
   get manualPagination() {
     return isManualPagination.value;
   },

package/dist/runtime/components/table/schema.d.ts

@@ -352,6 +352,9 @@ export declare function TableConfig(configure: (env: Environment) => void): Sche
         readonly expanded?: boolean | {
             readonly [x: string]: boolean;
         } | undefined;
+        readonly rowSelection?: {
+            readonly [x: string]: boolean;
+        } | undefined;
         readonly columnVisibility?: {
             readonly [x: string]: boolean;
         } | undefined;
@@ -372,9 +375,6 @@ export declare function TableConfig(configure: (env: Environment) => void): Sche
         readonly columnSizing?: {
             readonly [x: string]: number;
         } | undefined;
-        readonly rowSelection?: {
-            readonly [x: string]: boolean;
-        } | undefined;
     } | undefined;
 }, Schema.Struct<{
     kind: Schema.tag<"shwfed.component.table">;
@@ -1021,6 +1021,9 @@ export declare function createTableConfig(body: Omit<Schema.Schema.Type<ReturnTy
         readonly expanded?: boolean | {
             readonly [x: string]: boolean;
         } | undefined;
+        readonly rowSelection?: {
+            readonly [x: string]: boolean;
+        } | undefined;
         readonly columnVisibility?: {
             readonly [x: string]: boolean;
         } | undefined;
@@ -1041,9 +1044,6 @@ export declare function createTableConfig(body: Omit<Schema.Schema.Type<ReturnTy
         readonly columnSizing?: {
             readonly [x: string]: number;
         } | undefined;
-        readonly rowSelection?: {
-            readonly [x: string]: boolean;
-        } | undefined;
     } | undefined;
     kind: typeof KIND;
 };

package/dist/runtime/components/table/utils/resolve.d.ts

@@ -64,6 +64,26 @@ export type ColumnExpandDeps = Readonly<{
     seen: ReadonlySet<string>;
 }>;
 export type ColumnExpand = (value: any, deps: ColumnExpandDeps) => ColumnValue[];
+/**
+ * Capabilities a column's row-selection predicate needs from the host.
+ */
+export type RowSelectionDeps = Readonly<{
+    $cel: CelEvaluator;
+    /**
+     * CEL scope for one row — inherited host vars plus `row` / `index`, matching
+     * what a cell sees. Lazy, so a predicate only subscribes to the vars it reads.
+     */
+    rowScope: (row: unknown, index: number) => Record<string, unknown>;
+}>;
+/**
+ * Whether a row may be selected, per this column's config. A column exporting
+ * this contributes to the table-level `enableRowSelection` option, so TanStack
+ * itself knows which rows are selectable: select-all, shift-range and
+ * `row.getCanSelect()` then all agree with what the cell renders. Without it,
+ * a cell that merely *renders* itself disabled still gets checked by select-all
+ * — and the user cannot uncheck it. Columns with no selection semantics omit it.
+ */
+export type ColumnRowSelection = (value: any, deps: RowSelectionDeps) => (row: unknown, index: number) => boolean;
 /**
  * Capabilities a column-migration function may need from the host. Mirrors
  * the form host's `MigrationContext` so cross-host helpers can share a
@@ -133,6 +153,12 @@ export type ColumnEntry = Readonly<{
      * `translateColumn` only ever sees the leaf columns it emits.
      */
     expand?: ColumnExpand;
+    /**
+     * Present iff this entry has a say in which rows are selectable (today: the
+     * select column). The host folds every present one into TanStack's
+     * `enableRowSelection`. See `ColumnRowSelection`.
+     */
+    rowSelection?: ColumnRowSelection;
 }>;
 export declare const COLUMNS: ReadonlyArray<ColumnEntry>;
 export declare function allColumnSchemas(configure: (env: Environment) => void): ReadonlyArray<AnySchema>;

package/dist/runtime/components/table/utils/resolve.js

@@ -85,7 +85,8 @@ export const COLUMNS = registry.ENTRIES.map((e) => ({
   ...e.module.migrate !== void 0 ? { migrate: e.module.migrate } : {},
   ...e.module.migrateFrom !== void 0 ? { migrateFrom: e.module.migrateFrom } : {},
   ...e.module.defaults !== void 0 ? { defaults: e.module.defaults } : {},
-  ...e.module.expand !== void 0 ? { expand: e.module.expand } : {}
+  ...e.module.expand !== void 0 ? { expand: e.module.expand } : {},
+  ...e.module.rowSelection !== void 0 ? { rowSelection: e.module.rowSelection } : {}
 }));
 const migrationTargets = (() => {
   const map = /* @__PURE__ */ new Map();

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

@@ -39,7 +39,7 @@ export function buildStepEntries(roster) {
   return roster.filter((step) => step.valid).map((step) => ({
     id: `step:${step.id}`,
     group: "step",
-    insert: `${STEPS_VAR}[${JSON.stringify(step.id)}]`,
+    insert: `${STEPS_VAR}[?${JSON.stringify(step.id)}]`,
     display: step.label,
     label: "\u524D\u5E8F\u6B65\u9AA4",
     type: "dyn",

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

@@ -76,7 +76,7 @@ const chipPlugin = ViewPlugin.fromClass(
   {
     decorations: (plugin) => plugin.decorations,
     // Atomic so the caret steps over a chip and Backspace removes the whole
-    // `steps["id"]` at once — matching the scope/selection chips' feel.
+    // `steps[?"id"]` at once — matching the scope/selection chips' feel.
     provide: (plugin) => EditorView.atomicRanges.of((view) => view.plugin(plugin)?.decorations ?? Decoration.none)
   }
 );

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

@@ -1,6 +1,6 @@
 import { STEPS_VAR } from "../../../utils/cel-context.js";
 const STEP_REF_RE = new RegExp(
-  `(?<![\\w$.])${STEPS_VAR}\\[("(?:[^"\\\\]|\\\\.)*")\\]`,
+  `(?<![\\w$.])${STEPS_VAR}\\[\\??("(?:[^"\\\\]|\\\\.)*")\\]`,
   "g"
 );
 export function scanStepRefs(text) {

package/dist/runtime/share/event-bus.js

@@ -4,10 +4,10 @@ export const Trigger = Schema.Struct({
   // Additive + optional like `compatibilityDate`/`params` below, so every
   // pre-existing `{ target, operation }` trigger keeps loading. Minted by the
   // trigger editor on add; it is the address under which this step's output is
-  // published for later steps (`steps["<id>"]`), so it must survive reorders —
+  // published for later steps (`steps[?"<id>"]`), so it must survive reorders —
   // which the list index, the only other row identity, does not.
   id: Schema.optional(Schema.UUID.annotations({
-    description: '\u89E6\u53D1\u884C\u7684\u7A33\u5B9A\u6807\u8BC6\uFF0C\u540E\u7EED\u6B65\u9AA4\u7ECF steps["<id>"] \u5F15\u7528\u672C\u6B65\u8F93\u51FA'
+    description: '\u89E6\u53D1\u884C\u7684\u7A33\u5B9A\u6807\u8BC6\uFF0C\u540E\u7EED\u6B65\u9AA4\u7ECF steps[?"<id>"] \u5F15\u7528\u672C\u6B65\u8F93\u51FA'
   })),
   target: Schema.UUID.annotations({
     description: "\u76EE\u6807\u7956\u5148\u5B9E\u4F8B\u7684 ID"

package/dist/runtime/share/navigation.d.ts

@@ -0,0 +1 @@
+export declare function isAbsoluteUrl(url: string): boolean;

package/dist/runtime/share/navigation.js

@@ -0,0 +1,4 @@
+const ABSOLUTE = /^(?:[a-z][a-z0-9+\-.]*:|\/\/)/i;
+export function isAbsoluteUrl(url) {
+  return ABSOLUTE.test(url.trim());
+}

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

@@ -108,10 +108,10 @@ export declare function useSelectionRoster(): Ref<ReadonlyArray<SelectionFieldRe
  * surfaces it. Unlike a selection field a trigger row has no designer-given
  * name, so `label` is its position —「第 N 步」— computed live from the row's
  * current index and thus following drag-and-drop reorders for free (the
- * persisted reference is `steps["<id>"]`; the label is never stored).
+ * persisted reference is `steps[?"<id>"]`; the label is never stored).
  */
 export type StepRef = Readonly<{
-    /** Trigger-row uuid keyed into `steps["<id>"]` — the publish address. */
+    /** Trigger-row uuid keyed into `steps[?"<id>"]` — the publish address. */
     id: string;
     /** Position label,「第 N 步」, derived from the row's current index. */
     label: string;

package/package.json

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