@shwfed/config 2.9.13 → 2.10.1

package/dist/runtime/components/form/fields/2026-06-14/com.shwfed.form.field.combobox.single/schema.d.ts

@@ -0,0 +1,214 @@
+import { Schema } from 'effect';
+import type { Environment } from '../../../../../vendor/cel-js/lib/index.js';
+import type { MigrateFn, MigrateSource } from '../../../utils/resolve.js';
+export declare const type: "com.shwfed.form.field.combobox.single";
+export declare const compatibilityDate: "2026-06-14";
+export declare const metadata: {
+    readonly name: "下拉单选";
+    readonly icon: "fluent:chevron-down-20-regular";
+    readonly w: {
+        readonly initial: 8;
+        readonly min: 4;
+        readonly max: number;
+    };
+    readonly h: {
+        readonly initial: 2;
+        readonly min: 2;
+        readonly max: 2;
+    };
+    readonly selection: true;
+};
+export declare function itemSchema(configure: (env: Environment) => void): Schema.Struct<{
+    id: Schema.refine<string, typeof Schema.String>;
+    label: Schema.TupleType<readonly [Schema.Struct<{
+        locale: Schema.Literal<["zh"]>;
+        message: Schema.SchemaClass<string, string, never>;
+    }>], [Schema.Struct<{
+        locale: Schema.Literal<["ja", "en", "ko"]>;
+        message: Schema.SchemaClass<string, string, never>;
+    }>]>;
+    value: Schema.Union<[Schema.Struct<{
+        kind: Schema.Literal<["text"]>;
+        value: typeof Schema.String;
+    }>, Schema.Struct<{
+        kind: Schema.Literal<["number"]>;
+        value: typeof Schema.Number;
+    }>]>;
+    tooltip: Schema.optional<Schema.refine<readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], Schema.TupleType<readonly [Schema.Struct<{
+        locale: Schema.Literal<["zh"]>;
+        message: Schema.SchemaClass<string, string, never>;
+    }>], [Schema.Struct<{
+        locale: Schema.Literal<["ja", "en", "ko"]>;
+        message: Schema.SchemaClass<string, string, never>;
+    }>]>>>;
+    keywords: Schema.optional<Schema.Array$<typeof Schema.String>>;
+}>;
+export declare function remoteOptionsSchema(configure: (env: Environment) => void): Schema.Struct<{
+    kind: Schema.Literal<["remote"]>;
+    request: Schema.optional<Schema.Union<[Schema.Literal<[""]>, Schema.Schema<string, string, never>]>>;
+    options: Schema.Schema<string, string, never>;
+    optionValue: Schema.optionalWith<Schema.Schema<string, string, never>, {
+        default: () => string;
+    }>;
+    optionLabel: Schema.Schema<string, string, never>;
+    optionKeywords: Schema.optional<Schema.Schema<string, string, never>>;
+}>;
+export declare function optionsSchema(configure: (env: Environment) => void): Schema.Union<[Schema.Struct<{
+    kind: Schema.Literal<["static"]>;
+    items: Schema.optionalWith<Schema.Array$<Schema.Struct<{
+        id: Schema.refine<string, typeof Schema.String>;
+        label: Schema.TupleType<readonly [Schema.Struct<{
+            locale: Schema.Literal<["zh"]>;
+            message: Schema.SchemaClass<string, string, never>;
+        }>], [Schema.Struct<{
+            locale: Schema.Literal<["ja", "en", "ko"]>;
+            message: Schema.SchemaClass<string, string, never>;
+        }>]>;
+        value: Schema.Union<[Schema.Struct<{
+            kind: Schema.Literal<["text"]>;
+            value: typeof Schema.String;
+        }>, Schema.Struct<{
+            kind: Schema.Literal<["number"]>;
+            value: typeof Schema.Number;
+        }>]>;
+        tooltip: Schema.optional<Schema.refine<readonly [{
+            readonly locale: "zh";
+            readonly message: string;
+        }, ...{
+            readonly locale: "en" | "ja" | "ko";
+            readonly message: string;
+        }[]], Schema.TupleType<readonly [Schema.Struct<{
+            locale: Schema.Literal<["zh"]>;
+            message: Schema.SchemaClass<string, string, never>;
+        }>], [Schema.Struct<{
+            locale: Schema.Literal<["ja", "en", "ko"]>;
+            message: Schema.SchemaClass<string, string, never>;
+        }>]>>>;
+        keywords: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    }>>, {
+        default: () => readonly [];
+    }>;
+}>, Schema.Struct<{
+    kind: Schema.Literal<["remote"]>;
+    request: Schema.optional<Schema.Union<[Schema.Literal<[""]>, Schema.Schema<string, string, never>]>>;
+    options: Schema.Schema<string, string, never>;
+    optionValue: Schema.optionalWith<Schema.Schema<string, string, never>, {
+        default: () => string;
+    }>;
+    optionLabel: Schema.Schema<string, string, never>;
+    optionKeywords: Schema.optional<Schema.Schema<string, string, never>>;
+}>]>;
+export declare function schema(configure: (env: Environment) => void): Schema.Struct<{
+    label: Schema.optional<Schema.TupleType<readonly [Schema.Struct<{
+        locale: Schema.Literal<["zh"]>;
+        message: Schema.SchemaClass<string, string, never>;
+    }>], [Schema.Struct<{
+        locale: Schema.Literal<["ja", "en", "ko"]>;
+        message: Schema.SchemaClass<string, string, never>;
+    }>]>>;
+    placeholder: Schema.optional<Schema.TupleType<readonly [Schema.Struct<{
+        locale: Schema.Literal<["zh"]>;
+        message: Schema.SchemaClass<string, string, never>;
+    }>], [Schema.Struct<{
+        locale: Schema.Literal<["ja", "en", "ko"]>;
+        message: Schema.SchemaClass<string, string, never>;
+    }>]>>;
+    tooltip: Schema.optional<Schema.TupleType<readonly [Schema.Struct<{
+        locale: Schema.Literal<["zh"]>;
+        message: Schema.SchemaClass<string, string, never>;
+    }>], [Schema.Struct<{
+        locale: Schema.Literal<["ja", "en", "ko"]>;
+        message: Schema.SchemaClass<string, string, never>;
+    }>]>>;
+    orientation: Schema.optional<Schema.Literal<["vertical", "floating"]>>;
+    binding: Schema.optional<Schema.refine<string, typeof Schema.String>>;
+    disabled: Schema.optional<Schema.Schema<string, string, never>>;
+    readonly: Schema.optional<Schema.Schema<string, string, never>>;
+    derived: Schema.optional<Schema.Struct<{
+        mode: Schema.Literal<["formula", "prefill"]>;
+        expression: Schema.Schema<string, string, never>;
+    }>>;
+    options: Schema.optionalWith<Schema.Union<[Schema.Struct<{
+        kind: Schema.Literal<["static"]>;
+        items: Schema.optionalWith<Schema.Array$<Schema.Struct<{
+            id: Schema.refine<string, typeof Schema.String>;
+            label: Schema.TupleType<readonly [Schema.Struct<{
+                locale: Schema.Literal<["zh"]>;
+                message: Schema.SchemaClass<string, string, never>;
+            }>], [Schema.Struct<{
+                locale: Schema.Literal<["ja", "en", "ko"]>;
+                message: Schema.SchemaClass<string, string, never>;
+            }>]>;
+            value: Schema.Union<[Schema.Struct<{
+                kind: Schema.Literal<["text"]>;
+                value: typeof Schema.String;
+            }>, Schema.Struct<{
+                kind: Schema.Literal<["number"]>;
+                value: typeof Schema.Number;
+            }>]>;
+            tooltip: Schema.optional<Schema.refine<readonly [{
+                readonly locale: "zh";
+                readonly message: string;
+            }, ...{
+                readonly locale: "en" | "ja" | "ko";
+                readonly message: string;
+            }[]], Schema.TupleType<readonly [Schema.Struct<{
+                locale: Schema.Literal<["zh"]>;
+                message: Schema.SchemaClass<string, string, never>;
+            }>], [Schema.Struct<{
+                locale: Schema.Literal<["ja", "en", "ko"]>;
+                message: Schema.SchemaClass<string, string, never>;
+            }>]>>>;
+            keywords: Schema.optional<Schema.Array$<typeof Schema.String>>;
+        }>>, {
+            default: () => readonly [];
+        }>;
+    }>, Schema.Struct<{
+        kind: Schema.Literal<["remote"]>;
+        request: Schema.optional<Schema.Union<[Schema.Literal<[""]>, Schema.Schema<string, string, never>]>>;
+        options: Schema.Schema<string, string, never>;
+        optionValue: Schema.optionalWith<Schema.Schema<string, string, never>, {
+            default: () => string;
+        }>;
+        optionLabel: Schema.Schema<string, string, never>;
+        optionKeywords: Schema.optional<Schema.Schema<string, string, never>>;
+    }>]>, {
+        default: () => {
+            kind: "static";
+            items: readonly [];
+        };
+    }>;
+    id: Schema.refine<string, typeof Schema.String>;
+    displayName: Schema.optional<Schema.SchemaClass<string, string, never>>;
+    hidden: Schema.optional<Schema.Schema<string, string, never>>;
+    required: Schema.optional<Schema.Schema<string, string, never>>;
+    validations: Schema.optional<Schema.Array$<Schema.Struct<{
+        when: Schema.Schema<string, string, never>;
+        warning: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
+        message: Schema.refine<readonly [{
+            readonly locale: "zh";
+            readonly message: string;
+        }, ...{
+            readonly locale: "en" | "ja" | "ko";
+            readonly message: string;
+        }[]], Schema.TupleType<readonly [Schema.Struct<{
+            locale: Schema.Literal<["zh"]>;
+            message: Schema.SchemaClass<string, string, never>;
+        }>], [Schema.Struct<{
+            locale: Schema.Literal<["ja", "en", "ko"]>;
+            message: Schema.SchemaClass<string, string, never>;
+        }>]>>;
+    }>>>;
+    type: Schema.Literal<["com.shwfed.form.field.combobox.single"]>;
+    compatibilityDate: Schema.Literal<["2026-06-14"]>;
+}>;
+export type Value = Schema.Schema.Type<ReturnType<typeof schema>>;
+export declare function defaults(): Partial<Value>;
+export declare const migrateFrom: ReadonlyArray<MigrateSource>;
+export declare const migrate: MigrateFn;

package/dist/runtime/components/form/fields/2026-06-14/com.shwfed.form.field.combobox.single/schema.js

@@ -0,0 +1,191 @@
+import { Effect, Schema } from "effect";
+import { Expression, HttpRequestResult, LocaleMarkdown } from "../../../../../share/expression.js";
+import { Locale } from "../../../../../share/locale.js";
+import { commonFieldFields, derivedField, FieldOrientationSchema } from "../../../utils/common.js";
+import { localeLabelToExpression } from "../combobox-migrate.js";
+export const type = "com.shwfed.form.field.combobox.single";
+export const compatibilityDate = "2026-06-14";
+export const metadata = {
+  name: "\u4E0B\u62C9\u5355\u9009",
+  icon: "fluent:chevron-down-20-regular",
+  w: { initial: 8, min: 4, max: Infinity },
+  h: { initial: 2, min: 2, max: 2 },
+  // Publishes its resolved option to the `selections` registry (runtime.vue), so
+  // a sibling expression can read the full chosen record via `selections["<id>"]`.
+  selection: true
+};
+const isListType = (actual) => actual === "dyn" || actual.startsWith("list") || actual.startsWith("optional");
+function configureWithOption(configure) {
+  return (env) => {
+    configure(env);
+    env.registerVariable("option", "dyn", { description: "`\u9009\u9879` \u8868\u8FBE\u5F0F\u4EA7\u51FA\u7684\u6570\u7EC4\u4E2D\u8FED\u4EE3\u5230\u7684\u5355\u4E2A\u5143\u7D20" });
+  };
+}
+function configureWithJson(configure) {
+  return (env) => {
+    configure(env);
+    env.registerVariable("json", "dyn", { description: "HTTP \u54CD\u5E94\u4F53\uFF08\u5DF2\u89E3\u6790 JSON\uFF09\uFF1B\u672A\u914D\u7F6E\u8BF7\u6C42\u6216\u8BF7\u6C42\u5931\u8D25\u65F6\u4E3A `null`" });
+  };
+}
+export function itemSchema(configure) {
+  const LocaleMd = LocaleMarkdown({ configure });
+  const TextValue = Schema.Struct({
+    kind: Schema.Literal("text"),
+    value: Schema.String
+  });
+  const NumberValue = Schema.Struct({
+    kind: Schema.Literal("number"),
+    value: Schema.Number
+  });
+  const ItemValue = Schema.Union(TextValue, NumberValue).annotations({
+    title: "\u503C",
+    description: "\u9009\u9879\u7ED1\u5B9A\u7684\u503C\uFF0C\u53EF\u4EE5\u662F\u6587\u672C\u6216\u6570\u5B57"
+  });
+  return Schema.Struct({
+    id: Schema.UUID.annotations({ description: "\u9009\u9879\u552F\u4E00\u6807\u8BC6\uFF0C\u7528\u4E8E\u7A33\u5B9A\u7684 v-for key" }),
+    label: Locale.annotations({
+      title: "\u6807\u7B7E",
+      description: "\u9009\u9879\u5C55\u793A\u7684\u672C\u5730\u5316\u7EAF\u6587\u672C\uFF08\u4E0D\u652F\u6301 Markdown \u6216\u63D2\u503C\uFF09"
+    }),
+    value: ItemValue,
+    tooltip: Schema.optional(LocaleMd.annotations({
+      title: "\u63D0\u793A",
+      description: "\u9F20\u6807\u60AC\u505C\u5728\u9009\u9879\u4E0A\u65F6\u5C55\u793A\u7684\u672C\u5730\u5316\u63D0\u793A\uFF0C\u652F\u6301 Markdown"
+    })),
+    keywords: Schema.optional(Schema.Array(Schema.String).annotations({
+      title: "\u5173\u952E\u8BCD",
+      description: "\u9664\u6807\u7B7E\u4E4B\u5916\u53EF\u53C2\u4E0E\u641C\u7D22\u8FC7\u6EE4\u7684\u9644\u52A0\u8BCD\u6761\u5217\u8868\uFF08\u522B\u540D\u3001\u7F16\u7801\u3001\u62FC\u97F3\u7B49\uFF09\uFF1B\u4E0D\u5C55\u793A\uFF0C\u4EC5\u7528\u4E8E\u5339\u914D"
+    }))
+  }).annotations({
+    title: "ComboboxSingleItem"
+  });
+}
+export function remoteOptionsSchema(configure) {
+  const CelRequest = Schema.Union(
+    Schema.Literal(""),
+    Expression({ configure, resultType: HttpRequestResult })
+  );
+  const CelOptions = Expression({ configure: configureWithJson(configure), resultType: isListType });
+  const CelOptionValue = Expression({ configure: configureWithOption(configure), resultType: "dyn" });
+  const CelOptionLabel = Expression({ configure: configureWithOption(configure), resultType: "dyn" });
+  const CelKeywords = Expression({
+    configure: configureWithOption(configure),
+    resultType: (actual) => actual === "dyn" || actual.startsWith("list") || actual.startsWith("optional")
+  });
+  return Schema.Struct({
+    kind: Schema.Literal("remote"),
+    request: Schema.optional(CelRequest.annotations({
+      title: "\u8BF7\u6C42",
+      description: "\u8FD4\u56DE `HttpRequest` \u7684 CEL \u8868\u8FBE\u5F0F\uFF1B\u53EF\u8BBF\u95EE `form` \u5F53\u524D\u72B6\u6001\u3002\u7559\u7A7A\u5219\u4E0D\u53D1\u8D77\u8BF7\u6C42\uFF0C\u76F4\u63A5\u5BF9 `form` \u6C42\u503C `\u9009\u9879` \u8868\u8FBE\u5F0F\uFF08\u6B64\u65F6 `json` \u4E3A `null`\uFF09"
+    })),
+    options: CelOptions.annotations({
+      title: "\u9009\u9879",
+      description: "\u63D0\u53D6\u9009\u9879\u6570\u7EC4\u7684 CEL \u8868\u8FBE\u5F0F\uFF1B\u53EF\u8BBF\u95EE `form` \u4E0E `json`\u3002\u4F8B\uFF1A`json.data` \u6216 `[{value: 'a', label: 'A'}]`"
+    }),
+    optionValue: Schema.optionalWith(CelOptionValue.annotations({
+      title: "\u9009\u9879\u503C",
+      description: "\u4ECE\u5F53\u524D `option` \u63D0\u53D6\u5199\u5165\u7ED1\u5B9A\u7684\u503C\uFF1B\u4F8B\uFF1A`option.value`"
+    }), { default: () => "option" }),
+    optionLabel: CelOptionLabel.annotations({
+      title: "\u9009\u9879\u6807\u7B7E",
+      description: '\u8FD4\u56DE\u9009\u9879\u5C55\u793A\u6587\u672C\u7684 CEL \u8868\u8FBE\u5F0F\uFF0C\u53EF\u8BBF\u95EE `option`\uFF1B\u4F8B\uFF1A`option.name` \u6216 `string(option.code) + " - " + option.name`'
+    }),
+    optionKeywords: Schema.optional(CelKeywords.annotations({
+      title: "\u5173\u952E\u8BCD",
+      description: "\u8FD4\u56DE\u5B57\u7B26\u4E32\u5217\u8868\u7684 CEL \u8868\u8FBE\u5F0F\uFF0C\u53EF\u8BBF\u95EE `option`\uFF1B\u8FD9\u4E9B\u8BCD\u6761\u53C2\u4E0E\u641C\u7D22\u8FC7\u6EE4\u4F46\u4E0D\u5C55\u793A\u3002\u4F8B\uFF1A`[option.code, option.pinyin]`"
+    }))
+  }).annotations({ title: "ComboboxSingleOptionsRemote", description: "\u7531 CEL \u8868\u8FBE\u5F0F\uFF08\u53EF\u9009\u8FDC\u7A0B\u62C9\u53D6\uFF09\u4EA7\u51FA\u7684\u9009\u9879\u5217\u8868" });
+}
+export function optionsSchema(configure) {
+  const Item = itemSchema(configure);
+  const StaticSpec = Schema.Struct({
+    kind: Schema.Literal("static"),
+    items: Schema.optionalWith(Schema.Array(Item).annotations({
+      title: "\u9009\u9879",
+      description: "\u4E0B\u62C9\u6846\u53EF\u9009\u9879\u5217\u8868"
+    }), { default: () => [] })
+  }).annotations({ title: "ComboboxSingleOptionsStatic", description: "\u9759\u6001\u914D\u7F6E\u7684\u9009\u9879\u5217\u8868" });
+  const RemoteSpec = remoteOptionsSchema(configure);
+  return Schema.Union(StaticSpec, RemoteSpec).annotations({
+    title: "\u9009\u9879\u6765\u6E90",
+    description: '\u9009\u9879\u53EF\u4EE5\u662F\u9759\u6001\u914D\u7F6E\uFF08`kind: "static"`\uFF09\u6216\u7531 CEL \u8868\u8FBE\u5F0F / \u8FDC\u7A0B\u63A5\u53E3\u4EA7\u51FA\uFF08`kind: "remote"`\uFF09'
+  });
+}
+export function schema(configure) {
+  const CelBool = Expression({ configure, resultType: "bool" });
+  const Options = optionsSchema(configure);
+  return Schema.Struct({
+    type: Schema.Literal(type),
+    compatibilityDate: Schema.Literal(compatibilityDate),
+    ...commonFieldFields(configure),
+    label: Schema.optional(Locale.annotations({
+      title: "\u6807\u7B7E",
+      description: "\u5B57\u6BB5\u524D\u5C55\u793A\u7684\u6587\u672C\uFF1B\u7559\u7A7A\u5219\u4E0D\u6E32\u67D3\u6807\u7B7E"
+    })),
+    placeholder: Schema.optional(Locale.annotations({
+      title: "\u5360\u4F4D\u7B26",
+      description: "\u672A\u9009\u4E2D\u4EFB\u4F55\u9009\u9879\u65F6\u8F93\u5165\u6846\u4E2D\u7684\u5360\u4F4D\u6587\u672C"
+    })),
+    tooltip: Schema.optional(Locale.annotations({
+      title: "\u63D0\u793A",
+      description: "\u9F20\u6807\u60AC\u505C\u5728\u6807\u7B7E\u4E0A\u65F6\u5C55\u793A\u7684\u8BF4\u660E"
+    })),
+    orientation: Schema.optional(FieldOrientationSchema),
+    binding: Schema.optional(Schema.String.pipe(Schema.minLength(1)).annotations({
+      title: "\u7ED1\u5B9A\u8DEF\u5F84",
+      description: "\u5199\u5165\u8868\u5355\u72B6\u6001\u7684 `dot-prop` \u8DEF\u5F84\uFF0C\u4F8B\u5982 `user.role`\uFF1B\u7559\u7A7A\u5219\u4E3A\u975E\u53D7\u63A7\u5B57\u6BB5"
+    })),
+    disabled: Schema.optional(CelBool.annotations({
+      title: "\u7981\u7528\u6761\u4EF6",
+      description: "\u8FD4\u56DE `true` \u65F6\u4E0B\u62C9\u6846\u4ECD\u7136\u6E32\u67D3\u4F46\u4E0D\u53EF\u9009\u62E9"
+    })),
+    readonly: Schema.optional(CelBool.annotations({
+      title: "\u53EA\u8BFB\u6761\u4EF6",
+      description: "\u8FD4\u56DE `true` \u65F6\u4EC5\u4EE5\u7EAF\u6587\u672C\u5C55\u793A\u5F53\u524D\u9009\u9879\u7684\u6807\u7B7E"
+    })),
+    derived: derivedField(configure, "dyn"),
+    options: Schema.optionalWith(Options, {
+      default: () => ({ kind: "static", items: [] })
+    })
+  }).annotations({
+    title: "ComboboxSingleField",
+    description: "\u4E0B\u62C9\u5355\u9009\u8F93\u5165"
+  });
+}
+export function defaults() {
+  return {
+    options: { kind: "static", items: [] }
+  };
+}
+export const migrateFrom = [
+  { type: "com.shwfed.form.field.combobox.single", compatibilityDate: "2026-05-28" }
+];
+export const migrate = (prev) => Effect.try({
+  try: () => {
+    if (!prev || typeof prev !== "object") {
+      throw new Error("\u4E0B\u62C9\u5355\u9009\u8FC1\u79FB\u5931\u8D25\uFF1A\u539F\u503C\u4E0D\u662F\u5BF9\u8C61");
+    }
+    const src = prev;
+    const srcType = src.type;
+    const srcDate = src.compatibilityDate;
+    if (srcType === "com.shwfed.form.field.combobox.single" && srcDate === "2026-05-28") {
+      const { options, type: _t, compatibilityDate: _c, ...rest } = src;
+      let nextOptions = options;
+      if (options && typeof options === "object") {
+        const opts = options;
+        if (opts.kind === "remote") {
+          const { optionLabel, ...remoteRest } = opts;
+          nextOptions = { ...remoteRest, optionLabel: localeLabelToExpression(optionLabel) };
+        }
+      }
+      return {
+        ...rest,
+        type,
+        compatibilityDate,
+        options: nextOptions
+      };
+    }
+    throw new Error(`\u4E0B\u62C9\u5355\u9009\u8FC1\u79FB\u5931\u8D25\uFF1A\u672A\u8BC6\u522B\u7684\u6765\u6E90 ${String(srcType)}@${String(srcDate)}`);
+  },
+  catch: (e) => e instanceof Error ? e : new Error(String(e))
+});

package/dist/runtime/components/form/fields/2026-06-14/combobox-migrate.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Rewrite a `{{ }}`-interpolated template into a single CEL expression.
+ *
+ *  - `''` / no content                  → `''`           (valid empty-string literal)
+ *  - whole template is one `{{ expr }}` → `expr`         (kept bare; runtime coerces to string)
+ *  - mixed literal + interpolation      → `"lit" + string(expr) + …`
+ *
+ * Interpolated segments are wrapped in `string(...)` in the mixed case because
+ * CEL `+` requires matching operand types and the literal segments are strings;
+ * the old runtime stringified every interpolation, so this preserves behavior.
+ */
+export declare function templateToExpression(template: string): string;
+/**
+ * Collapse a legacy `optionLabel` (a Locale list of `{{ }}` templates) into the
+ * single CEL expression the 2026-06-14 schema expects. Picks the zh entry (or
+ * the first), then rewrites its template. Anything unrecognized → `''`.
+ */
+export declare function localeLabelToExpression(optionLabel: unknown): string;

package/dist/runtime/components/form/fields/2026-06-14/combobox-migrate.js

@@ -0,0 +1,36 @@
+const INTERPOLATION_RE = /\{\{(.*?)\}\}/gs;
+function celString(text) {
+  const body = text.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+  return `"${body}"`;
+}
+export function templateToExpression(template) {
+  const trimmed = template.trim();
+  if (trimmed.length === 0) return `''`;
+  const sole = /^\{\{([\s\S]*)\}\}$/.exec(trimmed);
+  if (sole && !sole[1].includes("{{")) {
+    const expr = sole[1].trim();
+    return expr.length > 0 ? expr : `''`;
+  }
+  const parts = [];
+  let last = 0;
+  let match;
+  INTERPOLATION_RE.lastIndex = 0;
+  while ((match = INTERPOLATION_RE.exec(template)) !== null) {
+    if (match.index > last) parts.push(celString(template.slice(last, match.index)));
+    const expr = match[1].trim();
+    if (expr.length > 0) parts.push(`string(${expr})`);
+    last = match.index + match[0].length;
+  }
+  if (last < template.length) parts.push(celString(template.slice(last)));
+  if (parts.length === 0) return `''`;
+  return parts.join(" + ");
+}
+export function localeLabelToExpression(optionLabel) {
+  if (!Array.isArray(optionLabel)) return `''`;
+  const zh = optionLabel.find(
+    (item) => !!item && typeof item === "object" && item.locale === "zh"
+  );
+  const chosen = zh ?? optionLabel[0];
+  const message = chosen && typeof chosen.message === "string" ? chosen.message : "";
+  return templateToExpression(message);
+}

package/dist/runtime/components/form/utils/state.d.ts

@@ -67,3 +67,14 @@ export type FormStateBag = {
 export declare const FORM_STATE_KEY: InjectionKey<FormStateBag>;
 export declare function provideFormState(state: Ref<unknown>, kind?: FormStateBagKind): FormStateBag;
 export declare function useFormState(): FormStateBag;
+/**
+ * The nearest `'form'`-kind bag enclosing the current field — what the CEL
+ * variable `form` means. Field runtimes bind `form:` from THIS bag's state,
+ * not from `useFormState()`'s: inside a `list` row the nearest bag is the
+ * row slice, but the design-time scope, `useDerived`, and the validation
+ * rules all resolve `form` to the outer form (the row is reachable as
+ * `item`). Walks the same `parent` chain `state.write` does; falls back to
+ * the nearest bag itself when no `'form'`-kind ancestor exists (a bare row
+ * bag — e.g. a table cell, where the row IS the record).
+ */
+export declare function useFormScope(): FormStateBag;

package/dist/runtime/components/form/utils/state.js

@@ -42,3 +42,8 @@ export function useFormState() {
   }
   return bag;
 }
+export function useFormScope() {
+  let bag = useFormState();
+  while (bag.kind !== "form" && bag.parent) bag = bag.parent;
+  return bag;
+}

package/dist/runtime/components/table/columns/2026-05-20/com.shwfed.table.column.combobox-single/runtime.vue

@@ -5,6 +5,7 @@ import { computed, nextTick, ref, watch } from "vue";
 import { useI18n } from "vue-i18n";
 import { cel as _rawCel } from "../../../../../utils/cel";
 import { celBindings, injectCELContext } from "../../../../../utils/cel-context";
+import { useFormReadonly } from "../../../../form/utils/readonly";
 import { getLocalizedText } from "../../../../../share/locale";
 import {
   Command,
@@ -61,7 +62,10 @@ function evalBool(expression, label) {
 }
 const isHidden = computed(() => evalBool(props.column.hidden, "hidden"));
 const isDisabled = computed(() => evalBool(props.column.disabled, "disabled"));
-const isReadonly = computed(() => evalBool(props.column.readonly, "readonly"));
+const formReadonly = useFormReadonly();
+const isReadonly = computed(
+  () => props.column.readonly != null ? evalBool(props.column.readonly, "readonly") : formReadonly.value
+);
 const effectiveReadonly = computed(
   () => isReadonly.value || props.column.derived?.mode === "formula"
 );

package/dist/runtime/components/table/columns/2026-05-20/com.shwfed.table.column.number-input/runtime.vue

@@ -5,6 +5,7 @@ import { computed, nextTick } from "vue";
 import { useI18n } from "vue-i18n";
 import { cel as _rawCel } from "../../../../../utils/cel";
 import { celBindings, injectCELContext } from "../../../../../utils/cel-context";
+import { useFormReadonly } from "../../../../form/utils/readonly";
 import { getLocalizedText } from "../../../../../share/locale";
 import { InputGroup, InputGroupAddon, InputGroupButton, InputGroupNumberField } from "../../../../ui/input-group";
 import { useFieldValue } from "../../../../form/utils/field-value";
@@ -40,7 +41,10 @@ function evalNumber(expression, label) {
 }
 const isHidden = computed(() => evalBool(props.column.hidden, "hidden"));
 const isDisabled = computed(() => evalBool(props.column.disabled, "disabled"));
-const isReadonly = computed(() => evalBool(props.column.readonly, "readonly"));
+const formReadonly = useFormReadonly();
+const isReadonly = computed(
+  () => props.column.readonly != null ? evalBool(props.column.readonly, "readonly") : formReadonly.value
+);
 const effectiveReadonly = computed(
   () => isReadonly.value || props.column.derived?.mode === "formula"
 );
@@ -108,11 +112,20 @@ async function onBlur() {
       v-if="isHidden"
       class="block h-7 w-full"
     />
+    <!--
+      Readonly empty state mirrors the `text` column exactly: a centered,
+      faded, non-selectable `-` in `font-mono`, so a readonly grid reads
+      uniformly regardless of column type. A present value keeps the
+      left-aligned dark text.
+    -->
     <span
       v-else-if="effectiveReadonly"
-      class="flex items-center h-7 w-full px-2 text-[0.75rem] text-zinc-700 truncate"
+      :class="[
+  'flex items-center h-7 w-full px-2 text-[0.75rem] truncate',
+  draft !== void 0 ? 'text-zinc-700' : 'justify-center font-mono text-zinc-300 select-none'
+]"
     >
-      {{ draft ?? "\u2014" }}
+      {{ draft ?? "-" }}
     </span>
     <InputGroup
       v-else

package/dist/runtime/components/table/columns/2026-05-20/com.shwfed.table.column.switch/runtime.vue

@@ -4,6 +4,7 @@ import { computed } from "vue";
 import { useI18n } from "vue-i18n";
 import { cel as _rawCel } from "../../../../../utils/cel";
 import { celBindings, injectCELContext } from "../../../../../utils/cel-context";
+import { useFormReadonly } from "../../../../form/utils/readonly";
 import { getLocalizedText } from "../../../../../share/locale";
 import { Switch } from "../../../../ui/switch";
 import { useFieldValue } from "../../../../form/utils/field-value";
@@ -26,7 +27,10 @@ function evalBool(expression, label) {
 }
 const isHidden = computed(() => evalBool(props.column.hidden, "hidden"));
 const isDisabled = computed(() => evalBool(props.column.disabled, "disabled"));
-const isReadonly = computed(() => evalBool(props.column.readonly, "readonly"));
+const formReadonly = useFormReadonly();
+const isReadonly = computed(
+  () => props.column.readonly != null ? evalBool(props.column.readonly, "readonly") : formReadonly.value
+);
 const effectiveReadonly = computed(
   () => isReadonly.value || props.column.derived?.mode === "formula"
 );

package/dist/runtime/components/table/columns/2026-05-20/com.shwfed.table.column.switch.local/runtime.vue

@@ -4,6 +4,7 @@ import { computed } from "vue";
 import { useI18n } from "vue-i18n";
 import { cel as _rawCel } from "../../../../../utils/cel";
 import { celBindings, injectCELContext } from "../../../../../utils/cel-context";
+import { useFormReadonly } from "../../../../form/utils/readonly";
 import { getLocalizedText } from "../../../../../share/locale";
 import { Switch } from "../../../../ui/switch";
 import { useFieldValue } from "../../../../form/utils/field-value";
@@ -26,7 +27,10 @@ function evalBool(expression, label) {
 }
 const isHidden = computed(() => evalBool(props.column.hidden, "hidden"));
 const isDisabled = computed(() => evalBool(props.column.disabled, "disabled"));
-const isReadonly = computed(() => evalBool(props.column.readonly, "readonly"));
+const formReadonly = useFormReadonly();
+const isReadonly = computed(
+  () => props.column.readonly != null ? evalBool(props.column.readonly, "readonly") : formReadonly.value
+);
 const effectiveReadonly = computed(
   () => isReadonly.value || props.column.derived?.mode === "formula"
 );

package/dist/runtime/components/table/columns/2026-05-20/com.shwfed.table.column.text-input/runtime.vue

@@ -5,6 +5,7 @@ import { useI18n } from "vue-i18n";
 import { Icon } from "@iconify/vue";
 import { cel as $cel } from "../../../../../utils/cel";
 import { celBindings, injectCELContext } from "../../../../../utils/cel-context";
+import { useFormReadonly } from "../../../../form/utils/readonly";
 import { getLocalizedText } from "../../../../../share/locale";
 import {
   InputGroup,
@@ -35,7 +36,10 @@ function evalBool(expression, label) {
 }
 const isHidden = computed(() => evalBool(props.column.hidden, "hidden"));
 const isDisabled = computed(() => evalBool(props.column.disabled, "disabled"));
-const isReadonly = computed(() => evalBool(props.column.readonly, "readonly"));
+const formReadonly = useFormReadonly();
+const isReadonly = computed(
+  () => props.column.readonly != null ? evalBool(props.column.readonly, "readonly") : formReadonly.value
+);
 const effectiveReadonly = computed(
   () => isReadonly.value || props.column.derived?.mode === "formula"
 );
@@ -89,11 +93,21 @@ function handleClear() {
       v-if="isHidden"
       class="block h-7 w-full"
     />
+    <!--
+      Readonly empty state mirrors the `text` column exactly: a centered,
+      faded, non-selectable `-` rendered in `font-mono`, so a readonly grid
+      reads uniformly regardless of which column type backs each cell. A
+      non-empty readonly value keeps the editable cell's left-aligned dark
+      text.
+    -->
     <span
       v-else-if="effectiveReadonly"
-      class="flex items-center h-7 w-full px-2 text-[0.75rem] text-zinc-700 truncate"
+      :class="[
+  'flex items-center h-7 w-full px-2 text-[0.75rem] truncate',
+  draft ? 'text-zinc-700' : 'justify-center font-mono text-zinc-300 select-none'
+]"
     >
-      {{ draft || "\u2014" }}
+      {{ draft || "-" }}
     </span>
     <!--
       Idle border is faded to 30% so a whole grid of inputs reads as data, not

package/dist/runtime/components/table/columns/2026-05-24/com.shwfed.table.column.combobox-single.remote.options-remote/runtime.vue

@@ -9,6 +9,7 @@ import { useI18n } from "vue-i18n";
 import { asRequest, fetchJsonOption } from "../../../../../share/request";
 import { cel as _rawCel } from "../../../../../utils/cel";
 import { celBindings, injectCELContext } from "../../../../../utils/cel-context";
+import { useFormReadonly } from "../../../../form/utils/readonly";
 import { getLocalizedText } from "../../../../../share/locale";
 import { dispatchTriggers, useEventChannel } from "../../../../../share/event-bus";
 import {
@@ -72,7 +73,10 @@ function evalBool(expression, label) {
 }
 const isHidden = computed(() => evalBool(props.column.hidden, "hidden"));
 const isDisabledByConfig = computed(() => evalBool(props.column.disabled, "disabled"));
-const isReadonly = computed(() => evalBool(props.column.readonly, "readonly"));
+const formReadonly = useFormReadonly();
+const isReadonly = computed(
+  () => props.column.readonly != null ? evalBool(props.column.readonly, "readonly") : formReadonly.value
+);
 const isInteractive = computed(() => !!props.column.onChange);
 const pending = ref(false);
 const json = ref(null);