@shwfed/config 2.3.10 → 2.3.12

package/dist/runtime/components/form/fields/2026-05-23/com.shwfed.form.field.tree.multi/schema.js

@@ -0,0 +1,129 @@
+import { Schema } from "effect";
+import { Expression, LocaleMarkdown } from "../../../../../share/expression.js";
+import { Locale } from "../../../../../share/locale.js";
+import { DataSource } from "../../../../table/schema.js";
+import { commonFieldFields, derivedField } from "../../../utils/common.js";
+export const type = "com.shwfed.form.field.tree.multi";
+export const compatibilityDate = "2026-05-23";
+export const metadata = {
+  name: "\u6811\uFF08\u591A\u9009\uFF09",
+  icon: "fluent:tree-evergreen-20-regular",
+  w: { initial: 8, min: 4, max: Infinity },
+  h: { initial: 8, min: 4, max: Infinity, grow: true }
+};
+export function schema(configure) {
+  const CelBool = Expression({ configure, resultType: "bool" });
+  const nodeConfigure = (env) => {
+    configure(env);
+    env.registerVariable("node", "dyn", { description: "\u5F53\u524D\u8282\u70B9\uFF1B\u7531 `\u6570\u636E` \u8868\u8FBE\u5F0F\u8FD4\u56DE\u7684\u6BCF\u4E00\u9879" });
+  };
+  const CelNodeKey = Expression({
+    configure: nodeConfigure,
+    resultType: (t) => t === "string" || t === "number" || t === "dyn"
+  });
+  const CelNodeChildren = Expression({
+    configure: nodeConfigure,
+    // Accept lists, optional lists, and `dyn` — CEL infers an empty literal
+    // such as `[]` as `list<dyn>` which a strict `list<dyn>` predicate would
+    // accept, but a configured expression like `has(node.kids) ? node.kids :
+    // null` lands on `dyn` once one branch is `null`. The looser predicate
+    // mirrors the table's `data` expression.
+    resultType: (t) => t === "dyn" || t.startsWith("list") || t.startsWith("optional")
+  });
+  const CelNodeBool = Expression({ configure: nodeConfigure, resultType: "bool" });
+  const NodeLocaleMd = LocaleMarkdown({ configure: nodeConfigure });
+  const CelKeywords = Expression({
+    configure: nodeConfigure,
+    // Empty list literals (`[]`) check as `list<dyn>`, and a
+    // `node.?keywords` access lands on `optional<dyn>` — accept either by
+    // sharing the same loose predicate the data expression uses.
+    resultType: (t) => t === "dyn" || t.startsWith("list") || t.startsWith("optional")
+  });
+  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"
+    })),
+    tooltip: Schema.optional(Locale.annotations({
+      title: "\u63D0\u793A",
+      description: "\u9F20\u6807\u60AC\u505C\u5728\u6807\u7B7E\u4E0A\u65F6\u5C55\u793A\u7684\u8BF4\u660E"
+    })),
+    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\uFF1B\u5199\u5165\u503C\u4E3A\u5DF2\u52FE\u9009\u8282\u70B9 ID \u7684\u6570\u7EC4\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\u4ECD\u6E32\u67D3\u4F46\u4E0D\u53EF\u52FE\u9009"
+    })),
+    readonly: Schema.optional(CelBool.annotations({
+      title: "\u53EA\u8BFB\u6761\u4EF6",
+      description: "\u8FD4\u56DE `true` \u65F6\u4EC5\u4EE5\u7EAF\u6587\u672C\u5C55\u793A\u5F53\u524D\u5DF2\u52FE\u9009\u8282\u70B9\u7684\u6807\u7B7E"
+    })),
+    derived: derivedField(configure, "dyn"),
+    dataSource: DataSource(configure).annotations({
+      title: "\u6570\u636E\u6E90",
+      description: "\u8FD4\u56DE\u5B8C\u6574\u6811\uFF08\u6839\u8282\u70B9\u5217\u8868\uFF09\u7684\u6570\u636E\u6E90\uFF1B\u6811\u901A\u8FC7 `\u8282\u70B9\u5B50\u7EA7` \u8868\u8FBE\u5F0F\u9010\u5C42\u5411\u4E0B\u8BFB\u53D6\u5B50\u7EA7"
+    }),
+    nodeKey: CelNodeKey.annotations({
+      title: "\u8282\u70B9 ID",
+      description: "\u4E3A\u6BCF\u4E2A\u8282\u70B9\u8BA1\u7B97\u7A33\u5B9A\u552F\u4E00 ID \u7684 CEL \u8868\u8FBE\u5F0F\uFF0C\u53EF\u8BBF\u95EE `node`\uFF1B\u8FD0\u884C\u65F6\u4EE5\u5B57\u7B26\u4E32\u5F62\u5F0F\u5B58\u50A8"
+    }),
+    nodeChildren: CelNodeChildren.annotations({
+      title: "\u8282\u70B9\u5B50\u7EA7",
+      description: "\u8FD4\u56DE\u5F53\u524D\u8282\u70B9\u7684\u5B50\u7EA7\u5217\u8868\u7684 CEL \u8868\u8FBE\u5F0F\uFF1B\u8FD4\u56DE `none` / `null` \u89C6\u4E3A\u53F6\u5B50\u8282\u70B9"
+    }),
+    nodeLabel: NodeLocaleMd.annotations({
+      title: "\u8282\u70B9\u6807\u7B7E",
+      description: "\u8282\u70B9\u5C55\u793A\u7684\u672C\u5730\u5316\u6587\u672C\uFF0C\u652F\u6301 Markdown \u4E0E `{{ node.foo }}` / `{{ form.foo }}` \u63D2\u503C"
+    }),
+    nodeTooltip: Schema.optional(NodeLocaleMd.annotations({
+      title: "\u8282\u70B9\u63D0\u793A",
+      description: "\u9F20\u6807\u60AC\u505C\u5728\u8282\u70B9\u4E0A\u65F6\u5C55\u793A\u7684\u672C\u5730\u5316\u63D0\u793A\uFF0C\u652F\u6301 Markdown \u4E0E\u63D2\u503C"
+    })),
+    nodeSelectable: Schema.optional(CelNodeBool.annotations({
+      title: "\u8282\u70B9\u53EF\u9009\u6761\u4EF6",
+      description: "\u8FD4\u56DE `true` \u8868\u793A\u8BE5\u8282\u70B9\u53EF\u88AB\u52FE\u9009\uFF1B\u7EA7\u8054\u9009\u62E9\u4ECD\u5C0A\u91CD\u8BE5\u6761\u4EF6"
+    })),
+    cascade: Schema.optionalWith(Schema.Literal("independent", "cascade-down", "cascade-both"), {
+      default: () => "cascade-both"
+    }).annotations({
+      title: "\u7EA7\u8054\u6A21\u5F0F",
+      description: "`\u72EC\u7ACB`\uFF1A\u4EC5\u52FE\u9009\u5F53\u524D\u8282\u70B9\uFF1B`\u5411\u4E0B\u7EA7\u8054`\uFF1A\u52FE\u9009\u7236\u8282\u70B9\u540C\u65F6\u52FE\u9009\u6240\u6709\u53EF\u9009\u540E\u4EE3\uFF1B`\u53CC\u5411\u7EA7\u8054`\uFF1A\u5728\u5411\u4E0B\u7EA7\u8054\u57FA\u7840\u4E0A\uFF0C\u7236\u8282\u70B9\u53CD\u6620\u540E\u4EE3\u52FE\u9009\u72B6\u6001\uFF08\u90E8\u5206\u9009\u4E2D\u663E\u793A\u4E3A\u534A\u9009\uFF09"
+    }),
+    expandAll: Schema.optionalWith(Schema.Boolean, { default: () => false }).annotations({
+      title: "\u9ED8\u8BA4\u5168\u90E8\u5C55\u5F00",
+      description: "\u5F00\u542F\u540E\u6302\u8F7D\u65F6\u5C55\u5F00\u6240\u6709\u975E\u53F6\u5B50\u8282\u70B9"
+    }),
+    filter: Schema.optional(Schema.Struct({
+      enabled: Schema.Boolean.annotations({ title: "\u542F\u7528", description: "\u662F\u5426\u5728\u6811\u4E0A\u65B9\u663E\u793A\u641C\u7D22\u8F93\u5165\u6846" }),
+      label: Schema.optional(Locale.annotations({
+        title: "\u6807\u7B7E",
+        description: "\u641C\u7D22\u8F93\u5165\u6846\u7684\u6D6E\u52A8\u6807\u7B7E\uFF1B\u7559\u7A7A\u5219\u4F7F\u7528\u9ED8\u8BA4\u503C\u300C\u641C\u7D22\u300D"
+      })),
+      keywords: Schema.optional(CelKeywords.annotations({
+        title: "\u989D\u5916\u5173\u952E\u8BCD",
+        description: "\u8FD4\u56DE\u5B57\u7B26\u4E32\u5217\u8868\u7684 CEL \u8868\u8FBE\u5F0F\uFF0C\u53EF\u8BBF\u95EE `node`\uFF1B\u5339\u914D\u89C4\u5219\u4E3A\u300C\u8282\u70B9\u6807\u7B7E \u6216 \u4EFB\u4E00\u5173\u952E\u8BCD\u300D\u5305\u542B\u641C\u7D22\u8BCD\uFF08\u4E0D\u533A\u5206\u5927\u5C0F\u5199\uFF09"
+      }))
+    }).annotations({
+      title: "\u8FC7\u6EE4",
+      description: "\u5BA2\u6237\u7AEF\u8FC7\u6EE4\uFF1B\u8FC7\u6EE4\u4E0D\u4F1A\u5F71\u54CD\u5DF2\u9009\u4E2D\u7684\u8282\u70B9 ID"
+    }))
+  }).annotations({
+    title: "TreeMultiField",
+    description: "\u57FA\u4E8E\u6811\u5F62\u6570\u636E\u7684\u591A\u9009\u8F93\u5165"
+  });
+}
+export function defaults() {
+  return {
+    dataSource: { data: "[]" },
+    nodeKey: "string(node.id)",
+    nodeChildren: "has(node.children) ? node.children : null",
+    nodeLabel: [{ locale: "zh", message: "{{ node.label }}" }],
+    cascade: "cascade-both",
+    expandAll: false
+  };
+}

package/dist/runtime/components/form/unit-config.vue

@@ -21,7 +21,6 @@ import { Button } from "../ui/button";
 import { ScrollArea } from "../ui/scroll-area";
 import { Separator } from "../ui/separator";
 import { FIELDS, findField } from "./utils/resolve";
-import ShwfedFormAiFieldsButton from "./ai/fields-button.vue";
 defineOptions({ name: "ShwfedFormUnitConfig" });
 const unit = defineModel({ type: Object, ...{ required: true } });
 const selection = defineModel("selection", { type: Object, ...{
@@ -90,6 +89,7 @@ function addLayout() {
 const FIELD_PICKER_ENTRIES = computed(() => {
   const byType = /* @__PURE__ */ new Map();
   for (const f of FIELDS) {
+    if (f.deprecated) continue;
     const prev = byType.get(f.type);
     if (!prev || f.compatibilityDate > prev.compatibilityDate) {
       byType.set(f.type, {
@@ -176,16 +176,6 @@ function removeFields(ids) {
     stack.value = stack.value.slice(0, -1);
   }
 }
-function applyAiFields(generated) {
-  const valid = generated.filter(
-    (f) => !!findField(f.type, f.compatibilityDate)
-  );
-  if (valid.length === 0) return;
-  unit.value = {
-    ...unit.value,
-    fields: [...unit.value.fields, ...valid]
-  };
-}
 function updateActiveField(next) {
   const id = activeFieldId.value;
   if (!id) return;
@@ -203,7 +193,7 @@ const migrationContext = { $cel: celForMigration };
 const latestEntry = computed(() => {
   const e = activeFieldEntry.value;
   if (!e?.deprecated || !e.supersededBy) return null;
-  return findField(e.type, e.supersededBy) ?? null;
+  return findField(e.supersededBy.type, e.supersededBy.compatibilityDate) ?? null;
 });
 const canMigrate = computed(() => !!latestEntry.value?.migrate);
 async function migrateActiveField() {
@@ -213,7 +203,10 @@ async function migrateActiveField() {
   try {
     const next = await Effect.runPromise(target.migrate(sel, migrationContext));
     updateActiveField(next);
-    toast.success(`\u5DF2\u8FC1\u79FB\u5230 ${target.compatibilityDate} \u7248\u672C`);
+    const isSameType = target.type === sel.type;
+    toast.success(
+      isSameType ? `\u5DF2\u8FC1\u79FB\u5230 ${target.compatibilityDate} \u7248\u672C` : `\u5DF2\u8FC1\u79FB\u5230 ${target.type}@${target.compatibilityDate}`
+    );
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     toast.error("\u8FC1\u79FB\u5931\u8D25", { description: message });
@@ -326,12 +319,6 @@ function isExtraActive(id) {
           </button>
         </div>
       </ScrollArea>
-
-      <ShwfedFormAiFieldsButton
-        :configure="configure"
-        :fields="unit.fields"
-        @apply="applyAiFields"
-      />
     </template>
   </Teleport>
 
@@ -409,12 +396,6 @@ function isExtraActive(id) {
             </button>
           </div>
         </ScrollArea>
-
-        <ShwfedFormAiFieldsButton
-          :configure="configure"
-          :fields="unit.fields"
-          @apply="applyAiFields"
-        />
       </template>
     </div>
 
@@ -466,7 +447,7 @@ function isExtraActive(id) {
           v-if="activeFieldEntry"
         >
           <div
-            v-if="activeFieldEntry.deprecated"
+            v-if="activeFieldEntry.deprecated && activeFieldEntry.supersededBy"
             class="mb-4 flex items-center gap-2 rounded border border-amber-200 bg-amber-50 px-3 py-2 text-xs text-amber-800"
             role="alert"
           >
@@ -475,7 +456,7 @@ function isExtraActive(id) {
               class="size-4 shrink-0"
             />
             <span class="flex-1">
-              此字段类型已弃用，建议迁移至 <span class="tabular-nums font-medium">{{ activeFieldEntry.supersededBy }}</span> 版本。
+              此字段类型已弃用，建议迁移至 <span class="tabular-nums font-medium">{{ activeFieldEntry.supersededBy.type === activeFieldEntry.type ? activeFieldEntry.supersededBy.compatibilityDate : `${activeFieldEntry.supersededBy.type}@${activeFieldEntry.supersededBy.compatibilityDate}` }}</span>。
             </span>
             <Button
               v-if="canMigrate"

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

@@ -13,12 +13,29 @@ export type MigrationContext = Readonly<{
     $cel: <T>(expression: string, context?: Record<string, unknown>) => Effect.Effect<T, unknown>;
 }>;
 /**
- * Migrates a value of the previous compatibilityDate's schema to this entry's
- * schema. Lives on the *target* (newer) entry. The Effect's success channel
- * is the migrated value; failures surface to the host as a toast — see
+ * Migrates a value of a source schema to this entry's schema. Lives on the
+ * target (newer) entry. The Effect's success channel is the migrated value;
+ * failures surface to the host as a toast — see
  * src/runtime/components/form/config.vue's migrate handler.
+ *
+ * The target is selected by one of two rules: (a) same `type` with a strictly
+ * newer `compatibilityDate`, or (b) an explicit `migrateFrom` declaration on
+ * the target naming this source `(type, compatibilityDate)`. Either way the
+ * migrate function only sees the previous value and the host capabilities.
  */
 export type MigrateFn = (prev: unknown, ctx: MigrationContext) => Effect.Effect<unknown, Error>;
+/**
+ * Identifies an entry by `(type, compatibilityDate)`. Used for `migrateFrom`
+ * declarations on a target, and for the cross-type form of `supersededBy`
+ * exposed on a deprecated entry.
+ *
+ * Migration declarations only ever live on the *new* (target) code — old
+ * folders are never modified to announce that they have been superseded.
+ */
+export type MigrateSource = Readonly<{
+    type: string;
+    compatibilityDate: string;
+}>;
 export type FieldSizeRange = Readonly<{
     /** Span (in step units) used when the field is first placed. */
     initial: number;
@@ -54,16 +71,25 @@ export type FieldEntry = Readonly<{
     schema: SchemaFactory;
     config: Component;
     runtime: Component;
-    /** True iff a newer entry with the same `type` exists in the registry. */
+    /**
+     * True iff this entry is shadowed by either (a) a newer-date entry sharing
+     * its `type`, or (b) another entry whose `migrateFrom` names this one.
+     */
     deprecated: boolean;
-    /** `compatibilityDate` of the newest entry sharing this `type`, when deprecated. */
-    supersededBy?: string;
     /**
-     * Optional migration from the previous compatibilityDate's schema to this
-     * entry's schema. When present, the host renders a "迁移" button on
-     * deprecated fields whose superseding entry exposes this function.
+     * Identifies the entry that supersedes this one. Same `type` for the
+     * date-versioned rule; a different `type` for declared cross-type
+     * migrations.
+     */
+    supersededBy?: MigrateSource;
+    /**
+     * Optional migration from a recognized source schema to this entry's
+     * schema. When present, the host renders a "迁移" button on deprecated
+     * entries whose target exposes this function.
      */
     migrate?: MigrateFn;
+    /** Source schemas this entry accepts migration from. See module field. */
+    migrateFrom?: ReadonlyArray<MigrateSource>;
     /**
      * Optional creation-time defaults. The host merges the returned partial
      * onto the seed when the user adds a new field via the picker. Absent →
@@ -74,4 +100,17 @@ export type FieldEntry = Readonly<{
 export declare const FIELDS: ReadonlyArray<FieldEntry>;
 export declare function allFieldSchemas(configure: (env: Environment) => void): ReadonlyArray<AnySchema>;
 export declare function findField(type: string, compatibilityDate: string): FieldEntry | undefined;
+/**
+ * Finds the registry entry that has declared `(type, compatibilityDate)` as a
+ * migration source on its `migrateFrom`. Use when a stored value's identity
+ * no longer matches any registry entry (the old folder was renamed away) —
+ * a present return means the value is still migratable via the target's
+ * `migrate`.
+ *
+ * Note: for the date-versioned rule (same `type`, newer `compatibilityDate`)
+ * the entry itself is in the registry and tagged `deprecated`/`supersededBy`;
+ * callers reach the target through `findField(supersededBy.type, …)` rather
+ * than this function.
+ */
+export declare function findMigrationTarget(type: string, compatibilityDate: string): FieldEntry | undefined;
 export {};

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

@@ -11,28 +11,76 @@ const runtimeModules = import.meta.glob(
   "../fields/*/*/runtime.vue",
   { eager: true, import: "default", exhaustive: true }
 );
+const sourceKey = (type, compatibilityDate) => `${type}@${compatibilityDate}`;
 const registry = defineRegistry({
   hostName: "shwfed-form",
   dirSegment: "fields",
   schemaModules,
   configModules,
   runtimeModules,
-  // An entry is deprecated iff another entry shares its `type` with a strictly
-  // greater `compatibilityDate`. The picker already shows only the latest per
-  // type; this flag drives the deprecation alert in the right-pane inspector.
+  // An entry is deprecated by one of two rules:
+  //   (a) another entry shares its `type` with a strictly greater
+  //       `compatibilityDate` — date-versioned supersession;
+  //   (b) another entry declares this one in its `migrateFrom` — explicit
+  //       cross-type supersession (rename, split, merge).
+  // Rule (a) wins on overlap, since the date-versioned rule is the implicit
+  // convention; an explicit `migrateFrom` against a still-current entry is
+  // almost always a mistake, but we let it slide as long as no two targets
+  // claim the same source (that collision throws below).
   deriveEntryExtras: (drafts) => {
     const latestByType = /* @__PURE__ */ new Map();
     for (const d of drafts) {
       const prev = latestByType.get(d.type);
       if (!prev || d.compatibilityDate > prev) latestByType.set(d.type, d.compatibilityDate);
     }
+    const migrationTargets = /* @__PURE__ */ new Map();
+    for (const d of drafts) {
+      const sources = d.module.migrateFrom;
+      if (!sources || sources.length === 0) continue;
+      for (const src of sources) {
+        const key = sourceKey(src.type, src.compatibilityDate);
+        const existing = migrationTargets.get(key);
+        if (existing) {
+          throw new Error(
+            `[shwfed-form] migrateFrom collision: source "${key}" is claimed by both "${sourceKey(existing.type, existing.compatibilityDate)}" and "${sourceKey(d.type, d.compatibilityDate)}"`
+          );
+        }
+        migrationTargets.set(key, { type: d.type, compatibilityDate: d.compatibilityDate });
+      }
+    }
     return (draft) => {
+      const declared = migrationTargets.get(sourceKey(draft.type, draft.compatibilityDate));
+      if (declared) {
+        return { deprecated: true, supersededBy: declared };
+      }
       const latest = latestByType.get(draft.type);
-      const deprecated = draft.compatibilityDate < latest;
-      return deprecated ? { deprecated: true, supersededBy: latest } : { deprecated: false };
+      if (draft.compatibilityDate < latest) {
+        return {
+          deprecated: true,
+          supersededBy: { type: draft.type, compatibilityDate: latest }
+        };
+      }
+      return { deprecated: false };
     };
   }
 });
+let _migrationTargets = null;
+function getMigrationTargets() {
+  if (_migrationTargets) return _migrationTargets;
+  const map = /* @__PURE__ */ new Map();
+  for (const entry of registry.ENTRIES) {
+    const sources = entry.module.migrateFrom;
+    if (!sources || sources.length === 0) continue;
+    for (const src of sources) {
+      map.set(sourceKey(src.type, src.compatibilityDate), {
+        type: entry.type,
+        compatibilityDate: entry.compatibilityDate
+      });
+    }
+  }
+  _migrationTargets = map;
+  return map;
+}
 let _fields = null;
 function getFields() {
   if (_fields) return _fields;
@@ -46,6 +94,7 @@ function getFields() {
     deprecated: e.deprecated,
     ...e.supersededBy !== void 0 ? { supersededBy: e.supersededBy } : {},
     migrate: e.module.migrate,
+    ...e.module.migrateFrom !== void 0 ? { migrateFrom: e.module.migrateFrom } : {},
     defaults: e.module.defaults
   }));
   return _fields;
@@ -72,3 +121,8 @@ export function allFieldSchemas(configure) {
 export function findField(type, compatibilityDate) {
   return getFields().find((f) => f.type === type && f.compatibilityDate === compatibilityDate);
 }
+export function findMigrationTarget(type, compatibilityDate) {
+  const target = getMigrationTargets().get(sourceKey(type, compatibilityDate));
+  if (!target) return void 0;
+  return findField(target.type, target.compatibilityDate);
+}

package/dist/runtime/components/table/columns/2026-05-13/com.shwfed.table.column.switch.remote/config.d.vue.ts

@@ -0,0 +1,10 @@
+type __VLS_ModelProps = {
+    modelValue: Record<string, any>;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: Record<string, any>) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_ModelProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: Record<string, any>) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;