@shwfed/config 2.3.10 → 2.3.12

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

@@ -9,9 +9,9 @@ type __VLS_ModelProps = {
     modelValue: AnyRecord;
 };
 type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
-declare var __VLS_232: {};
+declare var __VLS_219: {};
 type __VLS_Slots = {} & {
-    'general-extra'?: (props: typeof __VLS_232) => any;
+    'general-extra'?: (props: typeof __VLS_219) => 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

@@ -95,10 +95,17 @@ export declare const ColumnGroup: Schema.Struct<{
         message: Schema.SchemaClass<string, string, never>;
     }>]>>;
 }>;
-export declare function DataSource(configure: (env: Environment) => void): Schema.Struct<{
+export declare function DataSource(configure: (env: Environment) => void, extras?: {
+    request?: (env: Environment) => void;
+    data?: (env: Environment) => void;
+}): Schema.Struct<{
     request: Schema.optional<Schema.Schema<string, string, never>>;
     data: Schema.Schema<string, string, never>;
+}>;
+export declare function tableDataSource(configure: (env: Environment) => void): Schema.Struct<{
     total: Schema.optional<Schema.Schema<string, string, never>>;
+    request: Schema.optional<Schema.Schema<string, string, never>>;
+    data: Schema.Schema<string, string, never>;
 }>;
 export declare function TableConfig(configure: (env: Environment) => void): Schema.refine<{
     readonly style?: string | undefined;
@@ -295,9 +302,9 @@ export declare function TableConfig(configure: (env: Environment) => void): Sche
         default: () => never[];
     }>;
     dataSource: Schema.optional<Schema.Struct<{
+        total: Schema.optional<Schema.Schema<string, string, never>>;
         request: Schema.optional<Schema.Schema<string, string, never>>;
         data: Schema.Schema<string, string, never>;
-        total: Schema.optional<Schema.Schema<string, string, never>>;
     }>>;
     actions: Schema.optional<Schema.Struct<{
         size: Schema.optionalWith<Schema.Literal<["default", "sm", "xs"]>, {

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

@@ -127,13 +127,11 @@ export const ColumnGroup = Schema.Struct({
   description: "\u5217\u5206\u7EC4\u5B9A\u4E49"
 });
 const QUERY_VAR_DESCRIPTION = "\u641C\u7D22\u6761\u4EF6\u5F53\u524D\u72B6\u6001\uFF1B\u672A\u914D\u7F6E\u641C\u7D22\u6761\u4EF6\u65F6\u4E3A\u7A7A\u5BF9\u8C61";
-export function DataSource(configure) {
+export function DataSource(configure, extras) {
   const CelRequest = Expression({
     configure: (env) => {
       configure(env);
-      env.registerVariable("pageIndex", "number", { description: "\u5F53\u524D\u9875\u7801\uFF08\u4ECE 0 \u5F00\u59CB\uFF09\uFF1B\u672A\u542F\u7528\u5206\u9875\u65F6\u4E3A 0" });
-      env.registerVariable("pageSize", "number", { description: "\u6BCF\u9875\u884C\u6570\uFF1B\u672A\u542F\u7528\u5206\u9875\u65F6\u4E3A 0" });
-      env.registerVariable("query", "dyn", { description: QUERY_VAR_DESCRIPTION });
+      extras?.request?.(env);
     },
     resultType: "HttpRequest"
   });
@@ -143,10 +141,35 @@ export function DataSource(configure) {
       env.registerVariable("json", "optional<dyn>", {
         description: "HTTP \u54CD\u5E94\u4F53\uFF08\u5DF2\u89E3\u6790 JSON\uFF09\uFF1B\u672A\u914D\u7F6E request \u65F6\u4E3A none"
       });
-      env.registerVariable("query", "dyn", { description: QUERY_VAR_DESCRIPTION });
+      extras?.data?.(env);
     },
     resultType: (type) => type.startsWith("list") || type === "dyn" || type.startsWith("optional")
   });
+  return Schema.Struct({
+    request: Schema.optional(CelRequest).annotations({
+      title: "\u8BF7\u6C42",
+      description: "\u53EF\u9009\u7684 HTTP \u8BF7\u6C42\u8868\u8FBE\u5F0F\uFF1B\u672A\u914D\u7F6E\u65F6\u6570\u636E\u4ECE `data` \u8868\u8FBE\u5F0F\u4E2D\u8BFB\u53D6\uFF08\u901A\u5E38\u5F15\u7528\u4E0A\u4E0B\u6587\u53D8\u91CF\uFF09"
+    }),
+    data: CelRows.annotations({
+      title: "\u6570\u636E",
+      description: "\u8FD4\u56DE\u884C\u6570\u636E\u5217\u8868\uFF08`list<dyn>`\uFF09\u7684 CEL \u8868\u8FBE\u5F0F\uFF1B\u5728\u914D\u7F6E\u4E86 `request` \u65F6\u53EF\u901A\u8FC7 `json` \u5F15\u7528\u54CD\u5E94\u4F53"
+    })
+  }).annotations({
+    title: "DataSource",
+    description: "\u6570\u636E\u6E90\u914D\u7F6E"
+  });
+}
+export function tableDataSource(configure) {
+  const base = DataSource(configure, {
+    request: (env) => {
+      env.registerVariable("pageIndex", "number", { description: "\u5F53\u524D\u9875\u7801\uFF08\u4ECE 0 \u5F00\u59CB\uFF09\uFF1B\u672A\u542F\u7528\u5206\u9875\u65F6\u4E3A 0" });
+      env.registerVariable("pageSize", "number", { description: "\u6BCF\u9875\u884C\u6570\uFF1B\u672A\u542F\u7528\u5206\u9875\u65F6\u4E3A 0" });
+      env.registerVariable("query", "dyn", { description: QUERY_VAR_DESCRIPTION });
+    },
+    data: (env) => {
+      env.registerVariable("query", "dyn", { description: QUERY_VAR_DESCRIPTION });
+    }
+  });
   const CelTotal = Expression({
     configure: (env) => {
       configure(env);
@@ -158,14 +181,7 @@ export function DataSource(configure) {
     resultType: (type) => type === "number" || type === "dyn" || type.startsWith("optional")
   });
   return Schema.Struct({
-    request: Schema.optional(CelRequest).annotations({
-      title: "\u8BF7\u6C42",
-      description: "\u53EF\u9009\u7684 HTTP \u8BF7\u6C42\u8868\u8FBE\u5F0F\uFF1B\u672A\u914D\u7F6E\u65F6\u6570\u636E\u4ECE `data` \u8868\u8FBE\u5F0F\u4E2D\u8BFB\u53D6\uFF08\u901A\u5E38\u5F15\u7528\u4E0A\u4E0B\u6587\u53D8\u91CF\uFF09"
-    }),
-    data: CelRows.annotations({
-      title: "\u6570\u636E",
-      description: "\u8FD4\u56DE\u884C\u6570\u636E\u5217\u8868\uFF08`list<dyn>`\uFF09\u7684 CEL \u8868\u8FBE\u5F0F\uFF1B\u5728\u914D\u7F6E\u4E86 `request` \u65F6\u53EF\u901A\u8FC7 `json` \u5F15\u7528\u54CD\u5E94\u4F53"
-    }),
+    ...base.fields,
     total: Schema.optional(CelTotal).annotations({
       title: "\u603B\u6570",
       description: "\u8FD4\u56DE\u603B\u884C\u6570\uFF08`number`\uFF09\u7684 CEL \u8868\u8FBE\u5F0F\uFF1B\u914D\u7F6E\u540E\u542F\u7528\u670D\u52A1\u7AEF\u5206\u9875\uFF0C\u7559\u7A7A\u5219\u8D70\u524D\u7AEF\u5206\u9875"
@@ -198,7 +214,7 @@ export function TableConfig(configure) {
   const CelRowKey = CelRowAccess(configure, {
     resultType: (type) => type === "string" || type === "number" || type === "dyn"
   });
-  const dataSourceSchema = DataSource(configure);
+  const dataSourceSchema = tableDataSource(configure);
   const { fields: actionFields } = ActionSchemaFields((env) => {
     configure(env);
     env.registerVariable("selected", "list<dyn>", {

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/dist/runtime/components/ui/date-range-picker/DateRangePickerDateTimePanel.d.vue.ts

@@ -14,10 +14,10 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     "onUpdate:modelValue"?: ((args_0: DateRange | undefined) => any) | undefined;
 }>, {
-    rangeSeparatorIcon: string;
     numberOfMonths: number;
     granularity: "hour" | "minute" | "second";
     hourCycle: 12 | 24;
+    rangeSeparatorIcon: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/ui/date-range-picker/DateRangePickerDateTimePanel.vue.d.ts

@@ -14,10 +14,10 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     "onUpdate:modelValue"?: ((args_0: DateRange | undefined) => any) | undefined;
 }>, {
-    rangeSeparatorIcon: string;
     numberOfMonths: number;
     granularity: "hour" | "minute" | "second";
     hourCycle: 12 | 24;
+    rangeSeparatorIcon: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/ui/date-range-picker/DateRangePickerTimeInput.d.vue.ts

@@ -24,11 +24,11 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     "onUpdate:endValue"?: ((args_0: Time | undefined) => any) | undefined;
 }>, {
     size: "sm" | "md" | "lg";
-    rangeSeparatorIcon: string;
     granularity: "hour" | "minute" | "second";
     hourCycle: 12 | 24;
     clearable: boolean;
     clearIcon: string;
+    rangeSeparatorIcon: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/ui/date-range-picker/DateRangePickerTimeInput.vue.d.ts

@@ -24,11 +24,11 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     "onUpdate:endValue"?: ((args_0: Time | undefined) => any) | undefined;
 }>, {
     size: "sm" | "md" | "lg";
-    rangeSeparatorIcon: string;
     granularity: "hour" | "minute" | "second";
     hourCycle: 12 | 24;
     clearable: boolean;
     clearIcon: string;
+    rangeSeparatorIcon: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/ui/tree/Tree.d.vue.ts

@@ -0,0 +1,57 @@
+import type { CascadeMode, DropContext, GetChildren, LoadChildren, MoveEventPayload, NodeKey, SelectedPaneSlotProps, SelectionMode, TreeHandle } from './types.js';
+declare const __VLS_export: <Node>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<{
+        /** Root-level nodes. Use `v-model:roots` for controlled mode. */
+        roots: Node[];
+        getKey: (node: Node) => NodeKey;
+        getChildren?: GetChildren<Node>;
+        loadChildren?: LoadChildren<Node>;
+        /** `'none' | 'single' | 'multi'`. Default `'none'`. */
+        selectionMode?: SelectionMode;
+        /** Multi cascade mode. Ignored for `single` / `none`. */
+        cascade?: CascadeMode;
+        /** v-model for selection. Shape depends on `selectionMode`. */
+        modelValue?: NodeKey | NodeKey[] | undefined;
+        /** Per-node gate. */
+        selectable?: (node: Node, depth: number) => boolean;
+        /** Per-node draggable gate. Defaults to global `draggable` prop. */
+        draggable?: ((node: Node, depth: number) => boolean) | boolean;
+        /** Drop gate; required to enable drag-and-drop. */
+        canDrop?: (ctx: DropContext<Node>) => boolean;
+        /** Render-time filter. Does NOT mutate selection. */
+        filterPredicate?: (node: Node, query: string) => boolean;
+        filterQuery?: string;
+        /** Initial expanded set (uncontrolled). */
+        initialExpanded?: NodeKey[];
+    } & {
+        onMove?: ((payload: MoveEventPayload) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string | string[] | undefined) => any) | undefined;
+        "onUpdate:roots"?: ((value: Node[]) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<TreeHandle<Node>>) => void;
+    attrs: any;
+    slots: {
+        node?: (p: import("./types.js").NodeSlotProps<Node>) => unknown;
+        actions?: (p: import("./types.js").ActionsSlotProps<Node>) => unknown;
+        empty?: () => unknown;
+        error?: (p: import("./types.js").ErrorSlotProps<Node>) => unknown;
+        'loading-children'?: (p: import("./types.js").LoadingChildrenSlotProps<Node>) => unknown;
+        'selected-pane'?: (p: SelectedPaneSlotProps<Node>) => unknown;
+    };
+    emit: {
+        (e: "update:modelValue", value: NodeKey | NodeKey[] | undefined): void;
+        (e: "update:roots", value: Node[]): void;
+        (e: "move", payload: MoveEventPayload): void;
+    };
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};