@shwfed/config 2.3.29 → 2.4.1

package/dist/runtime/components/form/schema.js

@@ -39,8 +39,8 @@ export function FormUnit(configure) {
 }
 export function registerFormVariablesIfAbsent(env) {
   const declared = new Set(env.getDefinitions().variables.map((v) => v.name));
-  if (!declared.has("now")) env.registerVariable("now", "Date", { description: "\u5F53\u524D\u65E5\u671F/\u65F6\u95F4" });
-  if (!declared.has("form")) env.registerVariable("form", "dyn", { description: "\u5F53\u524D\u8868\u5355\u72B6\u6001" });
+  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" });
 }
 export function FormConfig(configure) {
   const formConfigure = (env) => {
@@ -105,6 +105,10 @@ export function FormConfig(configure) {
         字段自身的「只读条件」会**覆盖**这里：未配置只读条件的字段跟随本表达式，配置了的以字段自己的结果为准（可在只读表单中单独放开某个字段）。
       `
     })),
+    style: Schema.optional(Schema.String).annotations({
+      title: "\u5BB9\u5668\u6837\u5F0F",
+      description: "\u5E94\u7528\u5728\u8868\u5355\u6700\u5916\u5C42\u5BB9\u5668\u4E0A\u7684 CSS \u6837\u5F0F\u5B57\u7B26\u4E32"
+    }),
     ...unitFields(formConfigure)
   }).pipe(Schema.filter(unitPlacementsFilter)).annotations({
     title: "FormConfig",

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

@@ -1,9 +1,51 @@
 import { Schema } from 'effect';
 import type { Environment } from '../../../vendor/cel-js/lib/index.js';
+/**
+ * One field-owned validation rule. Extracted so the config editor
+ * (`ValidationRulesField`) can read the `when` / `message` `@title` +
+ * `@description` straight off this struct — single source of truth, no
+ * duplicated label/tooltip copy. `configure` only shapes the CEL environment;
+ * the annotations are static, so a no-op `configure` is fine for metadata.
+ */
+export declare function validationRuleStruct(configure: (env: Environment) => void): 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>;
+    }>]>>;
+}>;
 export declare function commonFieldFields(configure: (env: Environment) => void): {
     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>;
+        }>]>>;
+    }>>>;
 };
 export declare const FIELD_ORIENTATIONS: readonly ["vertical", "floating"];
 export type FieldOrientation = typeof FIELD_ORIENTATIONS[number];

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

@@ -1,6 +1,27 @@
 import { Schema } from "effect";
-import { Expression } from "../../../share/expression.js";
+import { Expression, LocaleMarkdown } from "../../../share/expression.js";
 import { md } from "../../../share/markdown.js";
+export function validationRuleStruct(configure) {
+  const CelBool = Expression({ configure, resultType: "bool" });
+  return Schema.Struct({
+    when: CelBool.annotations({
+      title: "\u89C4\u5219",
+      description: md`
+        返回 \`true\` 时视为校验**未**通过，返回 \`false\` 视为通过
+      `
+    }),
+    // Severity toggle. Off (default / absent) ⇒ error: standard blocks submit
+    // and reds the field. On ⇒ warning: yellow hint only, never blocks submit.
+    warning: Schema.optional(Schema.Boolean.annotations({
+      title: "\u4EC5\u8B66\u544A",
+      description: "\u5F00\u542F\u540E\u8BE5\u89C4\u5219\u4EC5\u9EC4\u8272\u63D0\u793A\u3001\u4E0D\u963B\u6B62\u63D0\u4EA4"
+    })),
+    message: LocaleMarkdown({ configure }).annotations({
+      title: "\u6D88\u606F",
+      description: "\u6821\u9A8C\u672A\u901A\u8FC7\u65F6\u5C55\u793A\u7684\u672C\u5730\u5316\u6D88\u606F\uFF0C\u652F\u6301 inline Markdown \u4E0E `{{ \u8868\u8FBE\u5F0F }}` \u63D2\u503C"
+    })
+  });
+}
 export function commonFieldFields(configure) {
   const CelBool = Expression({ configure, resultType: "bool" });
   return {
@@ -12,7 +33,24 @@ export function commonFieldFields(configure) {
     hidden: Schema.optional(CelBool.annotations({
       title: "\u9690\u85CF\u6761\u4EF6",
       description: "\u8FD4\u56DE `true` \u65F6\u5B57\u6BB5\u5728\u6240\u6709\u5E03\u5C40\u4E2D\u90FD\u4E0D\u6E32\u67D3"
-    }))
+    })),
+    // Required marker + non-empty check share one expression — no drift
+    // between the star the user sees and the rule that gates submit.
+    required: Schema.optional(CelBool.annotations({
+      title: "\u5FC5\u586B\u6761\u4EF6",
+      description: "\u8FD4\u56DE `true` \u65F6\u663E\u793A\u5FC5\u586B\u661F\u53F7\u5E76\u8981\u6C42\u975E\u7A7A\uFF0C\u7559\u7A7A\u8868\u793A\u4E0D\u5FC5\u586B"
+    })),
+    // Field-owned rules. `when` returns a bool — `true` triggers the rule; the
+    // per-rule `warning` switch picks the severity (error by default, warning
+    // when on). The message is a localized Markdown template with `{{ 表达式 }}`
+    // interpolation. Cross-field rules read `form.*` and live on the field where
+    // the error should appear.
+    validations: Schema.optional(
+      Schema.Array(validationRuleStruct(configure)).annotations({
+        title: "\u6821\u9A8C\u89C4\u5219",
+        description: "\u53CD\u9988\u6D88\u606F\u5C06\u6309\u7167\u6821\u9A8C\u89C4\u5219\u5217\u8868\u987A\u5E8F\u5C55\u793A"
+      })
+    )
   };
 }
 export const FIELD_ORIENTATIONS = ["vertical", "floating"];

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

@@ -0,0 +1,85 @@
+import { Effect } from 'effect';
+import type { ComputedRef, Ref } from 'vue';
+import { type LocaleValue } from '../../../share/locale.js';
+export type Severity = 'error' | 'warning';
+export type FieldValidationResult = {
+    severity: Severity;
+    /** Already i18n-resolved and `{{ }}`-interpolated — ready to render. */
+    message: string;
+    /** Index in the field's `validations[]`; `-1` for the implicit required rule. */
+    ruleIndex: number;
+};
+/** The slice of a field's config the validation engine reads. */
+export type ValidatableConfig = {
+    required?: string;
+    validations?: ReadonlyArray<{
+        when: string;
+        warning?: boolean;
+        message: LocaleValue;
+    }>;
+    binding?: string | readonly [string, string];
+};
+type Registration = () => ReadonlyArray<FieldValidationResult>;
+export type ValidationProvider = {
+    /**
+     * Global reveal gate. Errors on a pristine field stay hidden until that
+     * field's binding is dirtied (first blur) or `reveal()` flips this true.
+     * Once true it never retracts during the form's life — only a full unmount
+     * resets it. `undo`/`redo` do not touch it (they roll back state, not the
+     * gate).
+     */
+    revealed: Ref<boolean>;
+    reveal: () => void;
+    /** Register a mounted field's id + live results thunk; returns an unregister fn. */
+    register: (fieldId: () => string, results: Registration) => () => void;
+    /**
+     * Drain pending drafts, await the seed and derived-value settlement, then
+     * read every registered field's results. `true` ⇒ no `error`-severity
+     * result anywhere. Always calls `reveal()` so the failing fields surface.
+     */
+    validate: () => Promise<boolean>;
+    /** Union of results across the given field ids — used by collapsible aggregation. */
+    resultsFor: (fieldIds: ReadonlyArray<string>) => ReadonlyArray<FieldValidationResult>;
+};
+export type ValidationHost = {
+    /** Drain pending field commits (the form's commit bus). */
+    flush: () => void;
+    /** Resolves once the initial seed has landed. */
+    seeded: Promise<void>;
+    /** Resolves once every derived value — cascades included — has settled. */
+    settled: () => Promise<void>;
+};
+/**
+ * Provide the form-wide validation registry. Called once at the top-level form
+ * host, after the commit bus / quiescence are available; nested list rows
+ * inherit it through `inject`, so every field in the form — at any nesting
+ * depth — registers into this single provider.
+ */
+export declare function provideValidation(host: ValidationHost): ValidationProvider;
+/**
+ * Inject the form's validation provider. Returns `undefined` when used outside
+ * a `<Form>` host (e.g. a submit button placed on a bare page) — callers treat
+ * that as "no validation".
+ */
+export declare function useValidationProvider(): ValidationProvider | undefined;
+/**
+ * Field-level validation. Called inside an input field's `runtime.vue`. Reads
+ * the field's `required` / `validations` config, evaluates them synchronously
+ * against the field's CEL context (`form`, plus a list row's `item`/`index`),
+ * registers the live results into the form-wide provider for as long as the
+ * field is mounted, and returns the bits the field renders: the required star,
+ * the error/warning message lists, and the dirty-gated `visible` flag.
+ */
+export declare function useFieldValidation(options: {
+    fieldId: () => string;
+    config: () => ValidatableConfig;
+    $cel: <T>(expression: string, context?: Record<string, unknown>) => Effect.Effect<T, any>;
+    /** Current i18n locale, for resolving the message `Locale`. */
+    locale: () => string;
+}): {
+    isRequired: ComputedRef<boolean>;
+    errors: ComputedRef<ReadonlyArray<string>>;
+    warnings: ComputedRef<ReadonlyArray<string>>;
+    visible: ComputedRef<boolean>;
+};
+export {};

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

@@ -0,0 +1,113 @@
+import { Effect } from "effect";
+import { computed, inject, nextTick, onScopeDispose, provide, ref } from "vue";
+import { getLocalizedText } from "../../../share/locale.js";
+import { interpolate } from "../../../utils/interpolate.js";
+import { useFormState } from "./state.js";
+const VALIDATION_KEY = Symbol("shwfed-form-validation");
+export function provideValidation(host) {
+  const revealed = ref(false);
+  const entries = /* @__PURE__ */ new Map();
+  function union() {
+    const out = [];
+    for (const entry of entries.values()) out.push(...entry.results());
+    return out;
+  }
+  const provider = {
+    revealed,
+    reveal: () => {
+      revealed.value = true;
+    },
+    register: (fieldId, results) => {
+      const token = Symbol("field");
+      entries.set(token, { fieldId, results });
+      return () => {
+        entries.delete(token);
+      };
+    },
+    async validate() {
+      host.flush();
+      await host.seeded;
+      await host.settled();
+      await nextTick();
+      const results = union();
+      provider.reveal();
+      return results.every((r) => r.severity !== "error");
+    },
+    resultsFor(fieldIds) {
+      const wanted = new Set(fieldIds);
+      const out = [];
+      for (const entry of entries.values()) {
+        if (wanted.has(entry.fieldId())) out.push(...entry.results());
+      }
+      return out;
+    }
+  };
+  provide(VALIDATION_KEY, provider);
+  return provider;
+}
+export function useValidationProvider() {
+  return inject(VALIDATION_KEY, void 0);
+}
+const DEFAULT_REQUIRED_MESSAGE = {
+  zh: "\u8BF7\u586B\u5199\u6B64\u5B57\u6BB5",
+  ja: "\u3053\u306E\u9805\u76EE\u3092\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044",
+  en: "Please fill in this field",
+  ko: "\uC774 \uD56D\uBAA9\uC744 \uC785\uB825\uD574 \uC8FC\uC138\uC694"
+};
+function defaultRequiredMessage(locale) {
+  return DEFAULT_REQUIRED_MESSAGE[locale] ?? DEFAULT_REQUIRED_MESSAGE.zh;
+}
+function isEmptyValue(value) {
+  return value == null || value === "" || Array.isArray(value) && value.length === 0;
+}
+export function useFieldValidation(options) {
+  const { getAt, dirty } = useFormState();
+  const provider = useValidationProvider();
+  function evalBool(expression) {
+    if (!expression) return false;
+    try {
+      return Effect.runSync(options.$cel(expression));
+    } catch {
+      return false;
+    }
+  }
+  const isRequired = computed(() => evalBool(options.config().required));
+  function resolveMessage(message) {
+    const template = getLocalizedText(message, options.locale()) ?? "";
+    if (!template) return "";
+    return interpolate(template, (expression) => {
+      try {
+        const out = Effect.runSync(options.$cel(expression));
+        return out == null ? "" : String(out);
+      } catch {
+        return "";
+      }
+    });
+  }
+  const results = computed(() => {
+    const config = options.config();
+    const out = [];
+    if (typeof config.binding === "string" && isRequired.value && isEmptyValue(getAt(config.binding))) {
+      out.push({ severity: "error", message: defaultRequiredMessage(options.locale()), ruleIndex: -1 });
+    }
+    const rules = config.validations ?? [];
+    rules.forEach((rule, ruleIndex) => {
+      if (!evalBool(rule.when)) return;
+      const severity = rule.warning ? "warning" : "error";
+      out.push({ severity, message: resolveMessage(rule.message), ruleIndex });
+    });
+    return out;
+  });
+  if (provider) {
+    const unregister = provider.register(options.fieldId, () => results.value);
+    onScopeDispose(unregister);
+  }
+  const errors = computed(() => results.value.filter((r) => r.severity === "error").map((r) => r.message));
+  const warnings = computed(() => results.value.filter((r) => r.severity === "warning").map((r) => r.message));
+  const visible = computed(() => {
+    if (provider?.revealed.value) return true;
+    const binding = options.config().binding;
+    return typeof binding === "string" && dirty.value.has(binding);
+  });
+  return { isRequired, errors, warnings, visible };
+}

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

@@ -1,5 +1,4 @@
 <script setup>
-import { Switch } from "../../../../ui/switch";
 import { Separator } from "../../../../ui/separator";
 import { Field, FieldLabel } from "../../../../ui/field";
 import { ExpressionEditor } from "../../../../ui/expression-editor";
@@ -68,27 +67,6 @@ function updateOptionalString(key, next) {
           </SelectContent>
         </Select>
       </Field>
-      <Field orientation="vertical">
-        <FieldLabel class="text-xs text-zinc-500">
-          <template
-            v-if="fieldDescription('crossPage')"
-            #tooltip
-          >
-            <Markdown
-              :source="fieldDescription('crossPage')"
-              block
-              class="prose prose-sm prose-zinc"
-            />
-          </template>
-          {{ fieldTitle("crossPage") }}
-        </FieldLabel>
-        <div class="flex h-9 items-center">
-          <Switch
-            :model-value="value.crossPage ?? false"
-            @update:model-value="(v) => value.crossPage = v"
-          />
-        </div>
-      </Field>
     </div>
     <Separator />
     <div class="grid grid-cols-2 gap-x-6 gap-y-4">

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

@@ -11,36 +11,24 @@ const { t } = useI18n({
   inheritLocale: true,
   messages: {
     zh: {
-      "select-all-rows-on-page": "\u9009\u62E9\u5F53\u524D\u9875\u5168\u90E8\u884C",
       "select-all-rows": "\u9009\u62E9\u5168\u90E8\u884C"
     },
     en: {
-      "select-all-rows-on-page": "Select all rows on page",
       "select-all-rows": "Select all rows"
     },
     ja: {
-      "select-all-rows-on-page": "\u73FE\u5728\u306E\u30DA\u30FC\u30B8\u306E\u3059\u3079\u3066\u306E\u884C\u3092\u9078\u629E",
       "select-all-rows": "\u3059\u3079\u3066\u306E\u884C\u3092\u9078\u629E"
     }
   }
 });
 const table = computed(() => props.ctx.table);
-const crossPage = computed(() => props.column.crossPage ?? false);
 const hidden = computed(() => props.column.mode === "radio");
-const indeterminate = computed(
-  () => crossPage.value ? table.value.getIsSomePageRowsSelected() : table.value.getIsSomeRowsSelected()
-);
-const checked = computed(
-  () => crossPage.value ? table.value.getIsAllPageRowsSelected() : table.value.getIsAllRowsSelected()
-);
+const indeterminate = computed(() => table.value.getIsSomeRowsSelected());
+const checked = computed(() => table.value.getIsAllRowsSelected());
 const modelValue = computed(
   () => checked.value ? true : indeterminate.value ? "indeterminate" : false
 );
 function onUpdate(value) {
-  if (crossPage.value) {
-    table.value.toggleAllPageRowsSelected(value === true);
-    return;
-  }
   table.value.toggleAllRowsSelected(value === true);
 }
 </script>
@@ -52,7 +40,7 @@ function onUpdate(value) {
   >
     <Checkbox
       :model-value="modelValue"
-      :aria-label="crossPage ? t('select-all-rows-on-page') : t('select-all-rows')"
+      :aria-label="t('select-all-rows')"
       class="w-4 h-4 bg-white"
       @update:model-value="onUpdate"
     />

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

@@ -11,7 +11,6 @@ export declare function schema(configure: (env: Environment) => void): Schema.St
     mode: Schema.optionalWith<Schema.Literal<["radio", "checkbox"]>, {
         default: () => "checkbox";
     }>;
-    crossPage: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
     enableRowSelection: Schema.optional<Schema.Schema<string, string, never>>;
     enableMultiRowSelection: Schema.optional<Schema.Schema<string, string, never>>;
     id: Schema.refine<string, typeof Schema.String>;

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

@@ -25,10 +25,6 @@ export function schema(configure) {
       title: "\u6A21\u5F0F",
       description: "\u9009\u62E9\u6A21\u5F0F\uFF0Cradio \u4E3A\u5355\u9009\uFF0Ccheckbox \u4E3A\u591A\u9009"
     }), { default: () => "checkbox" }),
-    crossPage: Schema.optional(Schema.Boolean.annotations({
-      title: "\u8BB0\u5FC6\u9009\u4E2D\u9879",
-      description: "\u662F\u5426\u652F\u6301\u8DE8\u9875\u9009\u62E9"
-    })),
     enableRowSelection: Schema.optional(CelRowSelectionPredicate).annotations({
       title: "\u884C\u53EF\u9009\u4E2D",
       description: "\u884C\u662F\u5426\u53EF\u9009\u4E2D\u7684 CEL \u8868\u8FBE\u5F0F"

package/dist/runtime/components/table/config.d.vue.ts

@@ -9,9 +9,11 @@ type __VLS_ModelProps = {
     modelValue: AnyRecord;
 };
 type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
-declare var __VLS_219: {};
+declare var __VLS_219: {}, __VLS_221: {};
 type __VLS_Slots = {} & {
-    'general-extra'?: (props: typeof __VLS_219) => any;
+    'general-grid-extra'?: (props: typeof __VLS_219) => any;
+} & {
+    'general-extra'?: (props: typeof __VLS_221) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:modelValue": (value: AnyRecord) => any;

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

@@ -1263,61 +1263,68 @@ const tableQueryValue = computed({
             v-if="selectedGeneral"
             class="space-y-5"
           >
-            <Field
-              v-if="!hideDisplayName"
-              orientation="vertical"
-            >
-              <FieldLabel class="text-xs text-zinc-500">
-                <template
-                  v-if="generalFieldDescription('displayName')"
-                  #tooltip
-                >
-                  <Markdown
-                    :source="generalFieldDescription('displayName')"
-                    block
-                    class="prose prose-sm prose-zinc"
+            <div class="grid grid-cols-2 gap-x-6 gap-y-4">
+              <Field
+                v-if="!hideDisplayName"
+                orientation="vertical"
+              >
+                <FieldLabel class="text-xs text-zinc-500">
+                  <template
+                    v-if="generalFieldDescription('displayName')"
+                    #tooltip
+                  >
+                    <Markdown
+                      :source="generalFieldDescription('displayName')"
+                      block
+                      class="prose prose-sm prose-zinc"
+                    />
+                  </template>
+                  {{ generalFieldTitle("displayName") }}
+                </FieldLabel>
+                <InputGroup>
+                  <InputGroupInput
+                    :model-value="editingGeneralConfig.displayName ?? ''"
+                    placeholder="例：订单列表"
+                    @update:model-value="setGeneralDisplayName"
                   />
-                </template>
-                {{ generalFieldTitle("displayName") }}
-              </FieldLabel>
-              <InputGroup>
-                <InputGroupInput
-                  :model-value="editingGeneralConfig.displayName ?? ''"
-                  placeholder="例：订单列表"
-                  @update:model-value="setGeneralDisplayName"
-                />
-              </InputGroup>
-            </Field>
+                </InputGroup>
+              </Field>
 
-            <Field orientation="vertical">
-              <FieldLabel class="text-xs text-zinc-500">
-                <template
-                  v-if="generalFieldDescription('rowKey')"
-                  #tooltip
-                >
-                  <Markdown
-                    :source="generalFieldDescription('rowKey')"
-                    block
-                    class="prose prose-sm prose-zinc"
+              <Field orientation="vertical">
+                <FieldLabel class="text-xs text-zinc-500">
+                  <template
+                    v-if="generalFieldDescription('rowKey')"
+                    #tooltip
+                  >
+                    <Markdown
+                      :source="generalFieldDescription('rowKey')"
+                      block
+                      class="prose prose-sm prose-zinc"
+                    />
+                  </template>
+                  {{ generalFieldTitle("rowKey") }}
+                </FieldLabel>
+                <RowKeyCELContext>
+                  <ExpressionEditor
+                    :model-value="editingGeneralConfig.rowKey ?? ''"
+                    placeholder="如 row.id"
+                    result-type="string"
+                    @update:model-value="(v) => updateGeneralOptionalString('rowKey', v)"
                   />
-                </template>
-                {{ generalFieldTitle("rowKey") }}
-              </FieldLabel>
-              <RowKeyCELContext>
-                <ExpressionEditor
-                  :model-value="editingGeneralConfig.rowKey ?? ''"
-                  placeholder="如 row.id"
-                  result-type="string"
-                  @update:model-value="(v) => updateGeneralOptionalString('rowKey', v)"
-                />
-              </RowKeyCELContext>
-              <p
-                v-if="getError('rowKey')"
-                class="text-xs text-red-500"
-              >
-                {{ getError("rowKey") }}
-              </p>
-            </Field>
+                </RowKeyCELContext>
+                <p
+                  v-if="getError('rowKey')"
+                  class="text-xs text-red-500"
+                >
+                  {{ getError("rowKey") }}
+                </p>
+              </Field>
+
+              <!-- Host slot inside the general grid: a wrapping editor (e.g. the
+                   `table` form field, which hides 内部名称) drops a field into
+                   the cell next to 行唯一标识 so the two sit on one row. -->
+              <slot name="general-grid-extra" />
+            </div>
 
             <!-- Host extension slot: a wrapping editor (e.g. the `table` form
                  field config) injects its own fields into the general pane. -->

package/dist/runtime/components/table/config.vue.d.ts

@@ -9,9 +9,11 @@ type __VLS_ModelProps = {
     modelValue: AnyRecord;
 };
 type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
-declare var __VLS_219: {};
+declare var __VLS_219: {}, __VLS_221: {};
 type __VLS_Slots = {} & {
-    'general-extra'?: (props: typeof __VLS_219) => any;
+    'general-grid-extra'?: (props: typeof __VLS_219) => any;
+} & {
+    'general-extra'?: (props: typeof __VLS_221) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:modelValue": (value: AnyRecord) => any;

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

@@ -132,6 +132,7 @@ export declare function TableConfig(configure: (env: Environment) => void): Sche
         }[]] | undefined;
     }[];
     readonly query?: {
+        readonly style?: string | undefined;
         readonly initial?: {
             readonly data: string;
             readonly request?: string | undefined;
@@ -436,6 +437,7 @@ export declare function TableConfig(configure: (env: Environment) => void): Sche
         }, never>>;
     }>>;
     query: Schema.optional<Schema.refine<{
+        readonly style?: string | undefined;
         readonly initial?: {
             readonly data: string;
             readonly request?: string | undefined;
@@ -502,6 +504,7 @@ export declare function TableConfig(configure: (env: Environment) => void): Sche
             data: Schema.Schema<string, string, never>;
         }>>>;
         readonly: Schema.optional<Schema.Schema<string, string, never>>;
+        style: Schema.optional<typeof Schema.String>;
     }>>>;
     rowKey: Schema.optional<Schema.Schema<string, string, never>>;
     cellStyle: Schema.optional<Schema.Schema<string, string, never>>;
@@ -571,6 +574,7 @@ export declare function createTableConfig(body: Omit<Schema.Schema.Type<ReturnTy
         }[]] | undefined;
     }[];
     query?: {
+        readonly style?: string | undefined;
         readonly initial?: {
             readonly data: string;
             readonly request?: string | undefined;

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

@@ -84,10 +84,10 @@ export function editableHeader(titleText) {
 export function registerRowVariablesIfAbsent(env) {
   const declared = new Set(env.getDefinitions().variables.map((v) => v.name));
   if (!declared.has("row")) {
-    env.registerVariable("row", "dyn", { description: "\u5F53\u524D\u884C\u6570\u636E" });
+    env.registerVariable("row", "dyn", { label: "\u5F53\u524D\u884C", description: "\u5F53\u524D\u884C\u6570\u636E" });
   }
   if (!declared.has("index")) {
-    env.registerVariable("index", "number", { description: "\u884C\u7D22\u5F15" });
+    env.registerVariable("index", "number", { label: "\u884C\u5E8F\u53F7", description: "\u884C\u7D22\u5F15" });
   }
 }
 function configureWithRow(configure) {

package/dist/runtime/components/ui/field/FieldError.vue

@@ -28,7 +28,7 @@ const content = computed(() => {
     v-if="$slots.default || content"
     role="alert"
     data-slot="field-error"
-    :class="cn('absolute left-0 top-full z-10 max-w-full pt-0.25 text-red-600 text-xs leading-tight font-normal', props.class)"
+    :class="cn('max-w-full pt-0.25 text-red-600 text-xs leading-tight font-normal', props.class)"
   >
     <slot v-if="$slots.default" />
 

package/dist/runtime/components/ui/field/FieldMessages.d.vue.ts

@@ -0,0 +1,9 @@
+import type { HTMLAttributes } from 'vue';
+type __VLS_Props = {
+    class?: HTMLAttributes['class'];
+    errors?: ReadonlyArray<string>;
+    warnings?: ReadonlyArray<string>;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;