@shwfed/config 2.3.10 → 2.3.11

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

@@ -0,0 +1,66 @@
+import { Schema } from 'effect';
+import type { ColumnDef } from '@tanstack/vue-table';
+import type { Environment } from '../../../../../vendor/cel-js/lib/index.js';
+import type { ColumnDefDeps, MigrateFn, MigrateSource } from '../../../utils/resolve.js';
+export declare const type: "com.shwfed.table.column.switch.local";
+export declare const compatibilityDate: "2026-05-20";
+export declare const metadata: {
+    readonly name: "开关";
+    readonly icon: "fluent:toggle-left-20-regular";
+};
+export declare function schema(configure: (env: Environment) => void): Schema.Struct<{
+    hidden: Schema.optional<Schema.Schema<string, string, never>>;
+    disabled: Schema.optional<Schema.Schema<string, string, never>>;
+    readonly: Schema.optional<Schema.Schema<string, string, never>>;
+    trueLabel: 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>;
+    }>]>>;
+    falseLabel: 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>;
+    }>]>>;
+    derived: Schema.optional<Schema.Struct<{
+        mode: Schema.Literal<["formula", "prefill"]>;
+        expression: Schema.Schema<string, string, never>;
+    }>>;
+    title: 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>;
+    }>]>;
+    binding: Schema.refine<string, typeof Schema.String>;
+    enableSorting: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
+    size: Schema.optional<Schema.refine<number, Schema.filter<typeof Schema.Number>>>;
+    grow: Schema.optional<Schema.SchemaClass<boolean, boolean, 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>;
+    }>]>>;
+    id: Schema.refine<string, typeof Schema.String>;
+    groupId: Schema.optional<typeof Schema.UUID>;
+    type: Schema.Literal<["com.shwfed.table.column.switch.local"]>;
+    compatibilityDate: Schema.Literal<["2026-05-20"]>;
+}>;
+export type Value = Schema.Schema.Type<ReturnType<typeof schema>>;
+/**
+ * Adopts values that were stored under the pre-split `com.shwfed.table.column.switch`
+ * type at the same `compatibilityDate`. The field shape is byte-identical to
+ * this entry's schema — only the discriminator changes. Migration declarations
+ * live exclusively on this (new) entry; the old folder was removed and is
+ * never touched by this rewrite.
+ */
+export declare const migrateFrom: ReadonlyArray<MigrateSource>;
+export declare const migrate: MigrateFn;
+export declare function toColumnDef(value: Value, { getLocaleText }: ColumnDefDeps): Partial<ColumnDef<unknown, unknown>>;

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

@@ -0,0 +1,71 @@
+import { Effect, Schema } from "effect";
+import { getProperty } from "dot-prop";
+import { Locale } from "../../../../../share/locale.js";
+import { CelRowAccess, derivedRowField, editableColumnFields, editableHeader } from "../../../utils/shared.js";
+export const type = "com.shwfed.table.column.switch.local";
+export const compatibilityDate = "2026-05-20";
+export const metadata = {
+  name: "\u5F00\u5173",
+  icon: "fluent:toggle-left-20-regular"
+};
+export function schema(configure) {
+  const CelBool = CelRowAccess(configure, { resultType: "bool" });
+  return Schema.Struct({
+    type: Schema.Literal(type),
+    compatibilityDate: Schema.Literal(compatibilityDate),
+    ...editableColumnFields(),
+    hidden: Schema.optional(CelBool.annotations({
+      title: "\u9690\u85CF\u6761\u4EF6",
+      description: "\u8FD4\u56DE `true` \u65F6\u8BE5\u884C\u7684\u5F00\u5173\u4E0D\u6E32\u67D3\uFF08\u5176\u4F59\u884C\u4E0D\u53D7\u5F71\u54CD\uFF09"
+    })),
+    disabled: Schema.optional(CelBool.annotations({
+      title: "\u7981\u7528\u6761\u4EF6",
+      description: "\u8FD4\u56DE `true` \u65F6\u5F00\u5173\u4ECD\u7136\u6E32\u67D3\u4F46\u4E0D\u53EF\u5207\u6362"
+    })),
+    readonly: Schema.optional(CelBool.annotations({
+      title: "\u53EA\u8BFB\u6761\u4EF6",
+      description: "\u8FD4\u56DE `true` \u65F6\u4EC5\u4EE5\u7EAF\u6587\u672C\u5C55\u793A\u5F53\u524D\u503C"
+    })),
+    trueLabel: Schema.optional(Locale.annotations({
+      title: "\u5F00\u542F\u6587\u6848",
+      description: "\u53EA\u8BFB\u72B6\u6001\u4E0B\uFF0C\u503C\u4E3A `true` \u65F6\u5C55\u793A\u7684\u6587\u672C\uFF1B\u7559\u7A7A\u4F7F\u7528\u9ED8\u8BA4 `\u662F`"
+    })),
+    falseLabel: Schema.optional(Locale.annotations({
+      title: "\u5173\u95ED\u6587\u6848",
+      description: "\u53EA\u8BFB\u72B6\u6001\u4E0B\uFF0C\u503C\u4E3A `false` \u65F6\u5C55\u793A\u7684\u6587\u672C\uFF1B\u7559\u7A7A\u4F7F\u7528\u9ED8\u8BA4 `\u5426`"
+    })),
+    derived: derivedRowField(configure, "bool")
+  }).annotations({ title: "SwitchRenderer", description: "\u5F00\u5173\u6E32\u67D3\u5668\uFF08\u53EF\u7F16\u8F91\u3001\u672C\u5730\uFF09" });
+}
+export const migrateFrom = [
+  { type: "com.shwfed.table.column.switch", compatibilityDate }
+];
+export const migrate = (prev) => Effect.try({
+  try: () => {
+    if (!prev || typeof prev !== "object") {
+      throw new Error("\u5F00\u5173\uFF08\u672C\u5730\uFF09\u8FC1\u79FB\u5931\u8D25\uFF1A\u539F\u503C\u4E0D\u662F\u5BF9\u8C61");
+    }
+    return { ...prev, type, compatibilityDate };
+  },
+  catch: (e) => e instanceof Error ? e : new Error(String(e))
+});
+export function toColumnDef(value, { getLocaleText }) {
+  return {
+    header: editableHeader(getLocaleText(value.title)),
+    // `binding` is a dot-prop path (validated non-empty); the cell renderer
+    // reads through the same path it writes to. No CEL — accessor is literal.
+    accessorFn: (row) => {
+      if (!row || typeof row !== "object") return void 0;
+      return getProperty(row, value.binding);
+    },
+    enableSorting: value.enableSorting ?? false,
+    // `basic` orders by JS `<` — for booleans that yields `false < true`,
+    // which is the obvious grouping. Mirrors the remote switch column.
+    sortingFn: "basic",
+    size: value.size,
+    meta: {
+      grow: value.grow ?? false,
+      tooltip: getLocaleText(value.tooltip)
+    }
+  };
+}

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

@@ -169,6 +169,7 @@ function configureTableQuery(env) {
 }
 const tableConfigSchema = TableConfig(configure);
 const dataSourceSchema = DataSource(configure);
+const pickerEntries = computed(() => COLUMNS.filter((e) => !e.deprecated));
 const advertisedHostContext = (() => {
   const probe = new Environment({ unlistedVariablesAreDyn: false });
   const baseline = new Set(probe.getDefinitions().variables.map((v) => v.name));
@@ -1227,7 +1228,7 @@ const tableQueryValue = computed({
             <InputGroupCombobox>
               <CommandGroup>
                 <CommandItem
-                  v-for="entry in COLUMNS"
+                  v-for="entry in pickerEntries"
                   :key="`${entry.type}@${entry.compatibilityDate}`"
                   :value="`${entry.type}@${entry.compatibilityDate}`"
                   @select="addColumn(entry.type, entry.compatibilityDate)"

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

@@ -16,6 +16,33 @@ export type ColumnDefDeps = Readonly<{
     inheritedContext: Record<string, unknown>;
 }>;
 type ToColumnDef = (value: any, deps: ColumnDefDeps) => Partial<ColumnDef<unknown, unknown>>;
+/**
+ * Capabilities a column-migration function may need from the host. Mirrors
+ * the form host's `MigrationContext` so cross-host helpers can share a
+ * signature; extend additively rather than introducing a parallel context.
+ */
+export type MigrationContext = Readonly<{
+    $cel: <T>(expression: string, context?: Record<string, unknown>) => Effect.Effect<T, unknown>;
+}>;
+/**
+ * Migrates a value of a *source* column schema to this entry's schema. Lives
+ * on the *target* (newer) entry. The target is picked by one of two rules:
+ * (a) same `type` with a strictly newer `compatibilityDate`; (b) an explicit
+ * `migrateFrom` declaration on the target naming this source. Failures
+ * surface to the host as a toast — see `table/config.vue`'s migrate handler.
+ */
+export type MigrateFn = (prev: unknown, ctx: MigrationContext) => Effect.Effect<unknown, Error>;
+/**
+ * Identifies a column entry by `(type, compatibilityDate)`. Used for both
+ * `migrateFrom` declarations and the cross-type form of `supersededBy`.
+ *
+ * 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 ColumnEntry = Readonly<{
     type: string;
     compatibilityDate: string;
@@ -24,9 +51,35 @@ export type ColumnEntry = Readonly<{
     config: Component;
     runtime: Component;
     toColumnDef: ToColumnDef;
+    /**
+     * 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;
+    /**
+     * Identifies the entry that supersedes this one. Same `type` for the
+     * date-versioned rule; a different `type` for declared cross-type
+     * migrations.
+     */
+    supersededBy?: MigrateSource;
+    migrate?: MigrateFn;
+    migrateFrom?: ReadonlyArray<MigrateSource>;
 }>;
 export declare const COLUMNS: ReadonlyArray<ColumnEntry>;
 export declare function allColumnSchemas(configure: (env: Environment) => void): ReadonlyArray<AnySchema>;
 export declare function findColumn(type: string, compatibilityDate: string): ColumnEntry | undefined;
+/**
+ * Finds the registry entry that has declared `(type, compatibilityDate)` as a
+ * migration source on its `migrateFrom`. Use when a stored column'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 `findColumn(supersededBy.type, …)`
+ * rather than this function.
+ */
+export declare function findMigrationTarget(type: string, compatibilityDate: string): ColumnEntry | undefined;
 export declare function latestColumnByType(): ReadonlyArray<ColumnEntry>;
 export {};

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

@@ -11,6 +11,7 @@ const runtimeModules = import.meta.glob(
   "../columns/*/*/runtime.vue",
   { eager: true, import: "default", exhaustive: true }
 );
+const sourceKey = (type, compatibilityDate) => `${type}@${compatibilityDate}`;
 const registry = defineRegistry({
   hostName: "shwfed-table",
   dirSegment: "columns",
@@ -21,6 +22,47 @@ const registry = defineRegistry({
     if (typeof mod.toColumnDef !== "function") {
       throw new TypeError(`[shwfed-table] column "${type}@${date}" is missing toColumnDef export`);
     }
+  },
+  // Deprecation rules mirror the form host:
+  //   (a) date-versioned: another entry shares this entry's `type` with a
+  //       strictly greater `compatibilityDate`;
+  //   (b) explicit cross-type: another entry declares this one in its
+  //       `migrateFrom`. Same source claimed twice → throw.
+  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 migrationTargets2 = /* @__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 = migrationTargets2.get(key);
+        if (existing) {
+          throw new Error(
+            `[shwfed-table] migrateFrom collision: source "${key}" is claimed by both "${sourceKey(existing.type, existing.compatibilityDate)}" and "${sourceKey(d.type, d.compatibilityDate)}"`
+          );
+        }
+        migrationTargets2.set(key, { type: d.type, compatibilityDate: d.compatibilityDate });
+      }
+    }
+    return (draft) => {
+      const declared = migrationTargets2.get(sourceKey(draft.type, draft.compatibilityDate));
+      if (declared) {
+        return { deprecated: true, supersededBy: declared };
+      }
+      const latest = latestByType.get(draft.type);
+      if (draft.compatibilityDate < latest) {
+        return {
+          deprecated: true,
+          supersededBy: { type: draft.type, compatibilityDate: latest }
+        };
+      }
+      return { deprecated: false };
+    };
   }
 });
 export const COLUMNS = registry.ENTRIES.map((e) => ({
@@ -30,14 +72,37 @@ export const COLUMNS = registry.ENTRIES.map((e) => ({
   schema: e.module.schema,
   config: e.config,
   runtime: e.runtime,
-  toColumnDef: e.module.toColumnDef
+  toColumnDef: e.module.toColumnDef,
+  deprecated: e.deprecated,
+  ...e.supersededBy !== void 0 ? { supersededBy: e.supersededBy } : {},
+  ...e.module.migrate !== void 0 ? { migrate: e.module.migrate } : {},
+  ...e.module.migrateFrom !== void 0 ? { migrateFrom: e.module.migrateFrom } : {}
 }));
+const migrationTargets = (() => {
+  const map = /* @__PURE__ */ new Map();
+  for (const entry of COLUMNS) {
+    const sources = entry.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
+      });
+    }
+  }
+  return map;
+})();
 export function allColumnSchemas(configure) {
   return COLUMNS.map((entry) => entry.schema(configure));
 }
 export function findColumn(type, compatibilityDate) {
   return COLUMNS.find((r) => r.type === type && r.compatibilityDate === compatibilityDate);
 }
+export function findMigrationTarget(type, compatibilityDate) {
+  const target = migrationTargets.get(sourceKey(type, compatibilityDate));
+  if (!target) return void 0;
+  return findColumn(target.type, target.compatibilityDate);
+}
 export function latestColumnByType() {
   const byType = /* @__PURE__ */ new Map();
   for (const r of COLUMNS) {

package/package.json

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

package/dist/preview/assets/index-D3pf2RjG.js

@@ -1 +0,0 @@
-import{aH as e}from"./index-OUd02U3g.js";import{aI as r,aJ as s,aK as t}from"./index-OUd02U3g.js";export{r as TableConfig,s as createTableConfig,e as default,t as getColumnTechnicalKey};