@svadmin/ui 0.88.1 → 0.92.0

package/dist/components/numeric-format.js

@@ -0,0 +1,198 @@
+/**
+ * Minimal, explicit locale contract for the numeric input family.
+ *
+ * Only the locales below are accepted by the public `locale` prop. The default
+ * (no `locale`) keeps the legacy `type="number"` behaviour untouched. Adding a
+ * locale is a product decision and must come with its own parsing/screen-reader
+ * matrix instead of silently widening the contract.
+ */
+export const NUMERIC_INPUT_LOCALES = ['en-US', 'de-DE', 'zh-CN'];
+const MAX_INPUT_LENGTH = 64;
+export function isNumericInputLocale(value) {
+    return typeof value === 'string' && NUMERIC_INPUT_LOCALES.includes(value);
+}
+const separatorCache = new Map();
+function separatorsFor(locale) {
+    const cached = separatorCache.get(locale);
+    if (cached)
+        return cached;
+    const parts = new Intl.NumberFormat(locale, { useGrouping: true }).formatToParts(1234567.89);
+    const group = parts.find(part => part.type === 'group')?.value ?? ',';
+    const decimal = parts.find(part => part.type === 'decimal')?.value ?? '.';
+    const separators = { group, decimal };
+    separatorCache.set(locale, separators);
+    return separators;
+}
+export function clampNumericPrecision(precision) {
+    if (precision == null || !Number.isFinite(precision))
+        return undefined;
+    return Math.min(20, Math.max(0, Math.trunc(precision)));
+}
+/**
+ * Formats a stored value for display. `precision` only rounds the display; the
+ * caller keeps the original stored number. Intl's default rounding is used.
+ */
+export function formatNumericValue(locale, value, precision) {
+    if (value == null || !Number.isFinite(value))
+        return '';
+    const digits = clampNumericPrecision(precision);
+    const options = {
+        useGrouping: true,
+        minimumFractionDigits: digits ?? 0,
+        maximumFractionDigits: digits ?? 20,
+    };
+    return new Intl.NumberFormat(locale, options).format(value);
+}
+/**
+ * Editable text mirrors formatting but omits grouping so that inserting a digit
+ * does not make an otherwise valid number look like a mixed-separator error.
+ */
+export function formatNumericEditingText(locale, value, precision) {
+    if (value == null || !Number.isFinite(value))
+        return '';
+    const digits = clampNumericPrecision(precision);
+    const options = {
+        useGrouping: false,
+        minimumFractionDigits: digits ?? 0,
+        maximumFractionDigits: digits ?? 20,
+    };
+    return new Intl.NumberFormat(locale, options).format(value);
+}
+/**
+ * Parses locale-formatted text into a stored value. Group separators are
+ * display-only and never become part of the number. Invalid or mixed input
+ * returns `{ ok: false }` without echoing the raw text or an error message.
+ */
+export function parseNumericInput(locale, text) {
+    const trimmed = text.trim();
+    if (trimmed === '')
+        return { ok: true, value: null };
+    if (trimmed.length > MAX_INPUT_LENGTH)
+        return { ok: false };
+    const { group, decimal } = separatorsFor(locale);
+    let index = 0;
+    let negative = false;
+    if (trimmed.startsWith('-') || trimmed.startsWith('\u2212')) {
+        negative = true;
+        index = 1;
+    }
+    if (index >= trimmed.length)
+        return { ok: false };
+    let integerDigits = '';
+    let fractionDigits = '';
+    let afterDecimal = false;
+    let sawDigit = false;
+    let groupCount = 0;
+    let firstGroupLength = 0;
+    let digitsSinceGroup = 0;
+    while (index < trimmed.length) {
+        if (decimal && trimmed.startsWith(decimal, index)) {
+            if (afterDecimal || groupCount > 0 && digitsSinceGroup !== 3)
+                return { ok: false };
+            afterDecimal = true;
+            index += decimal.length;
+            continue;
+        }
+        if (group && trimmed.startsWith(group, index)) {
+            if (afterDecimal || !sawDigit)
+                return { ok: false };
+            if (groupCount > 0 && digitsSinceGroup !== 3)
+                return { ok: false };
+            if (digitsSinceGroup < 1 || digitsSinceGroup > 3)
+                return { ok: false };
+            groupCount += 1;
+            if (groupCount === 1)
+                firstGroupLength = integerDigits.length;
+            digitsSinceGroup = 0;
+            index += group.length;
+            continue;
+        }
+        const char = trimmed[index] ?? '';
+        if (char < '0' || char > '9')
+            return { ok: false };
+        sawDigit = true;
+        if (afterDecimal) {
+            fractionDigits += char;
+        }
+        else {
+            integerDigits += char;
+            digitsSinceGroup += 1;
+        }
+        index += 1;
+    }
+    if (!sawDigit)
+        return { ok: false };
+    if (groupCount > 0) {
+        if (digitsSinceGroup !== 3 || firstGroupLength > 3)
+            return { ok: false };
+    }
+    if (afterDecimal && fractionDigits === '' && integerDigits === '')
+        return { ok: false };
+    const normalized = `${negative ? '-' : ''}${integerDigits || '0'}${afterDecimal ? `.${fractionDigits}` : ''}`;
+    const parsed = Number(normalized);
+    if (!Number.isFinite(parsed))
+        return { ok: false };
+    return { ok: true, value: Object.is(parsed, -0) ? 0 : parsed };
+}
+/** Rounds a stepped value to avoid floating-point drift when precision is set. */
+export function roundToNumericPrecision(value, precision) {
+    const digits = clampNumericPrecision(precision);
+    if (digits === undefined)
+        return value;
+    const factor = 10 ** digits;
+    const rounded = Math.round((value + Number.EPSILON) * factor) / factor;
+    return Object.is(rounded, -0) ? 0 : rounded;
+}
+/**
+ * Decimal scaling above 15 places would push 10^n past
+ * Number.MAX_SAFE_INTEGER, so the scaled path stops there. Larger decimal
+ * counts fall back to plain Number arithmetic, which keeps whatever the Number
+ * type can actually represent without promising sub-ulp precision.
+ */
+const MAX_STEP_DECIMALS = 15;
+function decimalPlaces(value) {
+    if (!Number.isFinite(value))
+        return 0;
+    const text = value.toString().toLowerCase();
+    const exponentIndex = text.indexOf('e');
+    if (exponentIndex >= 0) {
+        const mantissa = text.slice(0, exponentIndex);
+        const exponent = Number(text.slice(exponentIndex + 1));
+        const fractionLength = mantissa.split('.')[1]?.length ?? 0;
+        return Math.max(0, fractionLength - exponent);
+    }
+    return text.split('.')[1]?.length ?? 0;
+}
+/**
+ * Adds one step without rounding to the display precision. Display precision
+ * must not erase an explicit smaller step; decimal scaling only protects the
+ * arithmetic itself. Scaling is used while its integers stay inside
+ * Number.MAX_SAFE_INTEGER; beyond that, direct Number addition is the only
+ * truthful result. Non-finite results keep the original value.
+ */
+export function addNumericStep(base, step, direction = 1) {
+    if (!Number.isFinite(base) || !Number.isFinite(step) || step <= 0)
+        return base;
+    const delta = direction * step;
+    const direct = base + delta;
+    if (!Number.isFinite(direct))
+        return base;
+    const decimals = Math.max(decimalPlaces(base), decimalPlaces(step));
+    if (decimals <= MAX_STEP_DECIMALS) {
+        const factor = 10 ** decimals;
+        const scaledBase = base * factor;
+        const scaledDelta = delta * factor;
+        if (Number.isFinite(scaledBase)
+            && Number.isFinite(scaledDelta)
+            && Math.abs(scaledBase) <= Number.MAX_SAFE_INTEGER
+            && Math.abs(scaledDelta) <= Number.MAX_SAFE_INTEGER) {
+            const scaled = Math.round(scaledBase) + Math.round(scaledDelta);
+            if (Math.abs(scaled) <= Number.MAX_SAFE_INTEGER) {
+                const next = scaled / factor;
+                if (Number.isFinite(next))
+                    return Object.is(next, -0) ? 0 : next;
+            }
+        }
+    }
+    return Object.is(direct, -0) ? 0 : direct;
+}

package/dist/components/record-detail.svelte.js

@@ -15,6 +15,8 @@ export function useRecordDetail(options) {
         void rendering;
         return {
             resource: binding.resource, id: options().id, dataProviderName: binding.dataProviderName,
+            // 详情页和抽屉已提供错误态与重试入口，避免重复通知。
+            errorNotification: false,
             queryOptions: { enabled: canRead },
         };
     });

package/dist/components/saved-list-views.d.ts

@@ -25,6 +25,13 @@ export interface SavedListViewAccess {
     mode: SavedListViewAccessMode;
     subjectIds: string[];
 }
+/** 解码时被裁剪的失效字段；只用于提示，不改变持久化数据。 */
+export interface SavedListViewDecodeReport {
+    /** 所有视图裁剪列的并集，供聚合提示使用。 */
+    prunedColumnIds: string[];
+    /** 按视图 id 记录各自被裁剪的列，删除或覆盖单个视图时可精确清除。 */
+    prunedColumnsByView: Record<string, string[]>;
+}
 export interface SavedListViewSubject {
     id: string;
     label: string;
@@ -87,13 +94,13 @@ export interface ListPreferenceScope {
 }
 export declare function decodeSavedListViewAccess(value: unknown): SavedListViewAccess | undefined;
 export declare function decodeSavedListViewSubjects(value: unknown): SavedListViewSubject[] | undefined;
-export declare function readSavedListViews(raw: string | null, allowedColumnIds: Set<string>, source?: SavedListView['source']): SavedListView[];
+export declare function readSavedListViews(raw: string | null, allowedColumnIds: Set<string>, source?: SavedListView['source'], report?: SavedListViewDecodeReport): SavedListView[];
 export declare function decodeSavedListViewMutationResult(value: unknown, allowedColumnIds: Set<string>, expected?: Pick<SavedListViewMutation, 'id' | 'source' | 'expectedVersion'>): SavedListViewMutationSuccess | SavedListViewMutationConflict | undefined;
 export declare function decodeSavedListViewRemoveResult(value: unknown, expected: {
     id: string;
     expectedVersion: number;
 }): SavedListViewRemoveSuccess | undefined;
-export declare function decodeRemoteSavedListViews(value: unknown, allowedColumnIds: Set<string>, writable?: boolean): SavedListView[];
+export declare function decodeRemoteSavedListViews(value: unknown, allowedColumnIds: Set<string>, writable?: boolean, report?: SavedListViewDecodeReport): SavedListView[];
 export declare function serializeSavedListViews(views: SavedListView[]): string;
 export declare function cloneSavedListViewState(state: SavedListViewState): SavedListViewState;
 export declare function listPreferenceScopeId(scope: ListPreferenceScope): string;

package/dist/components/saved-list-views.js

@@ -44,23 +44,41 @@ function parseSorters(value, allowedFieldIds) {
     }
     return sorters;
 }
-function parseColumnVisibility(value, allowedColumnIds) {
+function parseColumnVisibility(value, allowedColumnIds, pruned) {
     if (!isRecord(value))
         return undefined;
     const visibility = {};
     for (const [columnId, visible] of Object.entries(value)) {
-        if (!allowedColumnIds.has(columnId) || typeof visible !== 'boolean')
+        if (!allowedColumnIds.has(columnId)) {
+            pruned.add(columnId);
+            continue;
+        }
+        if (typeof visible !== 'boolean')
             continue;
         visibility[columnId] = visible;
     }
     return visibility;
 }
-function parseColumnOrder(value, allowedColumnIds) {
+function parseColumnOrder(value, allowedColumnIds, pruned) {
     if (!Array.isArray(value))
         return undefined;
-    return [...new Set(value.filter((columnId) => (typeof columnId === 'string' && allowedColumnIds.has(columnId))))];
+    const order = [];
+    const seen = new Set();
+    for (const columnId of value) {
+        if (typeof columnId !== 'string')
+            continue;
+        if (!allowedColumnIds.has(columnId)) {
+            pruned.add(columnId);
+            continue;
+        }
+        if (seen.has(columnId))
+            continue;
+        seen.add(columnId);
+        order.push(columnId);
+    }
+    return order;
 }
-function parseState(value, allowedColumnIds) {
+function parseState(value, allowedColumnIds, pruned) {
     if (!isRecord(value))
         return undefined;
     if (typeof value['search'] !== 'string' || value['search'].length > 1_000)
@@ -76,8 +94,8 @@ function parseState(value, allowedColumnIds) {
     if (filters.some((entry) => entry === undefined))
         return undefined;
     const sorters = parseSorters(value['sorters'], allowedFieldIds);
-    const columnVisibility = parseColumnVisibility(value['columnVisibility'], allowedColumnIds);
-    const columnOrder = parseColumnOrder(value['columnOrder'], allowedColumnIds);
+    const columnVisibility = parseColumnVisibility(value['columnVisibility'], allowedColumnIds, pruned);
+    const columnOrder = parseColumnOrder(value['columnOrder'], allowedColumnIds, pruned);
     if (!sorters || !columnVisibility || !columnOrder)
         return undefined;
     return {
@@ -148,7 +166,7 @@ export function decodeSavedListViewSubjects(value) {
         return;
     }
 }
-export function readSavedListViews(raw, allowedColumnIds, source = 'local') {
+export function readSavedListViews(raw, allowedColumnIds, source = 'local', report) {
     if (!raw)
         return [];
     try {
@@ -164,12 +182,25 @@ export function readSavedListViews(raw, allowedColumnIds, source = 'local') {
                 continue;
             if (typeof entry['name'] !== 'string' || !entry['name'].trim() || entry['name'].length > 60)
                 continue;
-            const state = parseState(entry['state'], allowedColumnIds);
+            const pruned = new Set();
+            const state = parseState(entry['state'], allowedColumnIds, pruned);
             if (!state)
                 continue;
             const access = entry['access'] === undefined ? undefined : parseAccess(entry['access']);
             if (entry['access'] !== undefined && !access)
                 continue;
+            if (report) {
+                if (pruned.size > 0) {
+                    // 视图 id 允许 "__proto__" 等特殊字符串，必须写为自身数据属性，避免触发原型 setter。
+                    Object.defineProperty(report.prunedColumnsByView, entry['id'], {
+                        value: [...pruned], enumerable: true, configurable: true, writable: true,
+                    });
+                }
+                for (const columnId of pruned) {
+                    if (!report.prunedColumnIds.includes(columnId))
+                        report.prunedColumnIds.push(columnId);
+                }
+            }
             seenIds.add(entry['id']);
             views.push({
                 id: entry['id'], name: entry['name'].trim(), state,
@@ -289,12 +320,12 @@ export function decodeSavedListViewRemoveResult(value, expected) {
         return;
     }
 }
-export function decodeRemoteSavedListViews(value, allowedColumnIds, writable = false) {
+export function decodeRemoteSavedListViews(value, allowedColumnIds, writable = false, report) {
     try {
         const snapshot = snapshotPlainData(value);
         if (!Array.isArray(snapshot))
             return [];
-        return readSavedListViews(JSON.stringify({ version: STORAGE_VERSION, views: snapshot }), allowedColumnIds, 'team')
+        return readSavedListViews(JSON.stringify({ version: STORAGE_VERSION, views: snapshot }), allowedColumnIds, 'team', report)
             .map(view => {
             const entry = snapshot.find(entry => isRecord(entry) && entry['id'] === view.id);
             return {

package/dist/components/saved-list-views.svelte.d.ts

@@ -7,6 +7,8 @@ interface SavedListViewsOptions {
     isScopeLoaded: () => boolean;
     readPreference: (scope: ListPreferenceScope, key: string, legacyKey: string) => string | null;
     hasExplicitURLState: boolean;
+    /** 初始查询快照已优先于持久化视图时，不把旧活动视图标记为当前视图；默认 false。 */
+    initialStateOverridesSavedView?: boolean;
     canApplyRemoteDefault: () => boolean;
     captureState: () => SavedListViewState;
     applyState: (state: SavedListViewState) => void;
@@ -21,6 +23,7 @@ export declare function createSavedListViews(options: SavedListViewsOptions): {
     savedViewSource: "local" | "team" | "system";
     readonly remoteViewsLoading: boolean;
     readonly remoteViewsFailed: boolean;
+    readonly staleSavedViewColumns: string[];
     readonly savedViewMutationPending: boolean;
     readonly savedViewMutationError: "failure" | "conflict" | undefined;
     accessDrafts: SvelteMap<string, SavedListViewAccess>;

package/dist/components/saved-list-views.svelte.js

@@ -7,19 +7,25 @@ export function createSavedListViews(options) {
     const savedViewProvider = $derived(options.provider());
     const preferenceScopeIsLoaded = options.isScopeLoaded;
     const hasExplicitURLState = options.hasExplicitURLState;
-    function readPreferences(scope) {
-        const savedViews = readSavedListViews(options.readPreference(scope, savedListViewsStorageKey(scope), legacySavedListViewsStorageKey(scope.resourceName)), savedViewColumnIds);
+    function readPreferences(scope, report) {
+        report ??= { prunedColumnIds: [], prunedColumnsByView: {} };
+        const savedViews = readSavedListViews(options.readPreference(scope, savedListViewsStorageKey(scope), legacySavedListViewsStorageKey(scope.resourceName)), savedViewColumnIds, 'local', report);
         const candidate = options.readPreference(scope, activeSavedListViewStorageKey(scope), legacyActiveSavedListViewStorageKey(scope.resourceName));
         const activeSavedView = savedViews.find(view => view.id === candidate);
-        return { savedViews, activeSavedView };
+        return { savedViews, activeSavedView, prunedColumnIds: report.prunedColumnIds };
     }
-    const initial = untrack(() => readPreferences(listPreferenceScope));
-    const initialSavedView = hasExplicitURLState ? undefined : initial.activeSavedView;
+    const initialReport = { prunedColumnIds: [], prunedColumnsByView: {} };
+    const initial = untrack(() => readPreferences(listPreferenceScope, initialReport));
+    const initialSavedView = hasExplicitURLState || (options.initialStateOverridesSavedView ?? false)
+        ? undefined
+        : initial.activeSavedView;
     let savedViews = $state(initial.savedViews);
     let activeSavedViewId = $state(initialSavedView?.id);
     let savedViewName = $state('');
     let savedViewsOpen = $state(false);
     let savedViewSource = $state('local');
+    let localStaleColumns = $state({ ...initialReport.prunedColumnsByView });
+    let remoteStaleColumns = $state({});
     let remoteSavedViews = $state([]);
     let remoteViewsLoading = $state(false);
     let remoteViewsFailed = $state(false);
@@ -45,6 +51,16 @@ export function createSavedListViews(options) {
         });
     });
     const activeSavedViewName = $derived(availableSavedViews.find(view => view.id === activeSavedViewId)?.name);
+    function clearStaleColumns(key, viewId) {
+        const current = key === 'local' ? localStaleColumns : remoteStaleColumns;
+        if (!(viewId in current))
+            return;
+        const next = Object.fromEntries(Object.entries(current).filter(([id]) => id !== viewId));
+        if (key === 'local')
+            localStaleColumns = next;
+        else
+            remoteStaleColumns = next;
+    }
     function persistSavedViews() {
         if (typeof window === 'undefined' || !preferenceScopeIsLoaded())
             return;
@@ -86,11 +102,14 @@ export function createSavedListViews(options) {
     // 表格完成列偏好和查询恢复后才打开持久化门，避免把旧租户状态写入新作用域。
     function restoreScope(scope) {
         remoteDefaultEligible = true;
-        const preferences = readPreferences(scope);
+        const report = { prunedColumnIds: [], prunedColumnsByView: {} };
+        const preferences = readPreferences(scope, report);
         savedViewName = '';
         savedViewsOpen = false;
         savedViews = preferences.savedViews;
         remoteSavedViews = [];
+        localStaleColumns = { ...report.prunedColumnsByView };
+        remoteStaleColumns = {};
         activeSavedViewId = preferences.activeSavedView?.id;
         return preferences.activeSavedView;
     }
@@ -100,6 +119,7 @@ export function createSavedListViews(options) {
         const columns = savedViewColumnIds;
         void remoteViewsReload;
         remoteSavedViews = [];
+        remoteStaleColumns = {};
         remoteViewsLoading = false;
         remoteViewsFailed = false;
         accessDrafts.clear();
@@ -119,7 +139,9 @@ export function createSavedListViews(options) {
         void Promise.resolve().then(() => provider.list({ ...scope })).then(value => {
             if (epoch !== remoteViewEpoch || !preferenceScopeIsLoaded())
                 return;
-            remoteSavedViews = decodeRemoteSavedListViews(value, columns, !!(provider.save || provider.remove || provider.setDefault || provider.updateAccess));
+            const report = { prunedColumnIds: [], prunedColumnsByView: {} };
+            remoteSavedViews = decodeRemoteSavedListViews(value, columns, !!(provider.save || provider.remove || provider.setDefault || provider.updateAccess), report);
+            remoteStaleColumns = { ...report.prunedColumnsByView };
             if (options.canApplyRemoteDefault() && remoteDefaultEligible) {
                 const defaults = remoteSavedViews.filter(view => view.default === true);
                 if (!hasExplicitURLState && !activeSavedViewId && defaults.length === 1 && defaults[0]) {
@@ -169,6 +191,8 @@ export function createSavedListViews(options) {
         savedViews = existing
             ? savedViews.map(candidate => candidate.id === existing.id ? view : candidate)
             : [view, ...savedViews].slice(0, 25);
+        if (existing)
+            clearStaleColumns('local', existing.id);
         activeSavedViewId = view.id;
         savedViewName = '';
         persistSavedViews();
@@ -188,6 +212,7 @@ export function createSavedListViews(options) {
             return;
         }
         savedViews = savedViews.filter(view => view.id !== id);
+        clearStaleColumns('local', id);
         if (activeSavedViewId === id)
             activeSavedViewId = undefined;
         persistSavedViews();
@@ -217,6 +242,7 @@ export function createSavedListViews(options) {
                 id: mutation.id, expectedVersion: mutation.expectedVersion,
             })) {
                 remoteSavedViews = remoteSavedViews.filter(view => view.id !== mutation.id);
+                clearStaleColumns('remote', mutation.id);
                 if (activeSavedViewId === mutation.id)
                     activeSavedViewId = undefined;
                 persistActiveSavedView();
@@ -234,6 +260,7 @@ export function createSavedListViews(options) {
             }
             const view = { ...decoded.view, readOnly: decoded.view.readOnly !== false };
             remoteSavedViews = [view, ...remoteSavedViews.filter(candidate => candidate.id !== view.id)];
+            clearStaleColumns('remote', view.id);
             savedViewName = '';
         }
         catch {
@@ -395,6 +422,28 @@ export function createSavedListViews(options) {
         set savedViewSource(value) { savedViewSource = value; },
         get remoteViewsLoading() { return remoteViewsLoading; },
         get remoteViewsFailed() { return remoteViewsFailed; },
+        get staleSavedViewColumns() {
+            const visibleLocal = new Set();
+            const visibleRemote = new Set();
+            for (const view of availableSavedViews) {
+                if (view.source === 'team' || view.source === 'system')
+                    visibleRemote.add(view.id);
+                else
+                    visibleLocal.add(view.id);
+            }
+            const columns = new Set();
+            for (const [viewId, pruned] of Object.entries(localStaleColumns)) {
+                if (visibleLocal.has(viewId))
+                    for (const columnId of pruned)
+                        columns.add(columnId);
+            }
+            for (const [viewId, pruned] of Object.entries(remoteStaleColumns)) {
+                if (visibleRemote.has(viewId))
+                    for (const columnId of pruned)
+                        columns.add(columnId);
+            }
+            return [...columns];
+        },
         get savedViewMutationPending() { return savedViewMutationPending; },
         get savedViewMutationError() { return savedViewMutationError; },
         accessDrafts, accessSubjects, accessSubjectsLoading, accessSubjectsFailed, accessSubjectQueries,

package/dist/components/task-action.svelte.d.ts

@@ -10,4 +10,5 @@ export declare function createTaskAction(options: {
     run: () => Promise<void>;
     readonly pending: boolean;
     readonly available: boolean;
+    readonly failed: boolean;
 };

package/dist/components/task-action.svelte.js

@@ -1,6 +1,27 @@
 import { onDestroy } from 'svelte';
+import { SvelteMap } from 'svelte/reactivity';
 import { captureAdminContext, captureAuthSession, queryKeyMatches, TaskError, withValidatedTaskProvider } from '@svadmin/core';
 import { useQueryClient } from '@tanstack/svelte-query';
+// 同一任务的重试与取消共享一个在途声明，避免不同按钮或重复挂载同时写入。
+let nextProviderId = 1;
+const providerIds = new WeakMap();
+const actionClaims = new SvelteMap();
+function claimKey(scope) {
+    if (!scope.provider)
+        return undefined;
+    let providerId = providerIds.get(scope.provider);
+    if (providerId === undefined) {
+        providerId = nextProviderId++;
+        providerIds.set(scope.provider, providerId);
+    }
+    return JSON.stringify([providerId, scope.id, scope.tenant ?? null, scope.session.cacheKey]);
+}
+function sameActionScope(left, right) {
+    return left.provider === right.provider && left.id === right.id
+        && left.tenant === right.tenant && left.auth === right.auth
+        && left.router === right.router && left.access === right.access
+        && left.session.cacheKey === right.session.cacheKey && left.session.isCurrent();
+}
 export function createTaskAction(options) {
     const context = captureAdminContext();
     const client = useQueryClient();
@@ -12,28 +33,50 @@ export function createTaskAction(options) {
     });
     let mounted = true;
     let attempt = $state.raw();
+    let failureScope = $state.raw();
     function current(origin) {
         return mounted && origin.provider === scope.provider && origin.id === scope.id
             && origin.tenant === scope.tenant && origin.auth === scope.auth
             && origin.router === scope.router && origin.access === scope.access
             && origin.session.isCurrent();
     }
-    onDestroy(() => { mounted = false; attempt = undefined; });
+    onDestroy(() => {
+        mounted = false;
+        // 卸载只停止结果交付；在途声明由请求结算释放，避免按钮切换重开并发窗口。
+        attempt = undefined;
+    });
     $effect.pre(() => {
         if (attempt && !current(attempt.scope))
             attempt = undefined;
+        if (failureScope && !current(failureScope))
+            failureScope = undefined;
     });
-    const pending = $derived(!!attempt && current(attempt.scope));
+    const claim = $derived.by(() => {
+        const key = claimKey(scope);
+        if (!key)
+            return undefined;
+        const currentClaim = actionClaims.get(key);
+        return currentClaim && sameActionScope(currentClaim.scope, scope) ? currentClaim : undefined;
+    });
+    const pending = $derived(!!claim);
     const available = $derived(!options.disabled && scope.session.available && !!provider?.[options.action]);
     async function run() {
         if (!available || pending || !mounted || !provider)
             return;
         const origin = scope;
+        const key = claimKey(origin);
+        if (!key)
+            return;
+        const existing = actionClaims.get(key);
+        if (existing && sameActionScope(existing.scope, origin))
+            return;
         const token = { scope: origin };
         const matcher = context.queryKeyMatcher();
         const success = options.onSuccess;
         const failure = options.onError;
+        failureScope = undefined;
         attempt = token;
+        actionClaims.set(key, token);
         let error;
         let failed = false;
         let deliver;
@@ -57,9 +100,13 @@ export function createTaskAction(options) {
             deliver = current(origin) && attempt === token;
             if (attempt === token)
                 attempt = undefined;
+            if (actionClaims.get(key) === token)
+                actionClaims.delete(key);
         }
         if (!deliver || !current(origin))
             return;
+        if (failed)
+            failureScope = origin;
         // 观察者异常不能被误报为服务端操作失败，也不能形成未处理的 Promise。
         try {
             if (failed)
@@ -69,5 +116,10 @@ export function createTaskAction(options) {
         }
         catch { /* 回调由宿主管理，不重试已发出的写入。 */ }
     }
-    return { run, get pending() { return pending; }, get available() { return available; } };
+    return {
+        run,
+        get pending() { return pending; },
+        get available() { return available; },
+        get failed() { return !!failureScope && current(failureScope); },
+    };
 }

package/dist/components/task-utils.d.ts

@@ -1,4 +1,5 @@
 import type { TaskRecord } from '@svadmin/core';
+export declare function formatTaskDate(value: unknown, locale: string): string;
 export type TaskLifecycle = 'queued' | 'processing' | 'completed' | 'failed' | 'cancelled' | 'unknown';
 export declare function normalizeTaskStatus(status: unknown): TaskLifecycle;
 export declare function isTaskActive(task: TaskRecord): boolean;

package/dist/components/task-utils.js

@@ -1,3 +1,21 @@
+import { parseDisplayDate } from './fields/date-display';
+export function formatTaskDate(value, locale) {
+    if (typeof value !== 'string' || !value)
+        return '\u2014';
+    const parsed = parseDisplayDate(value);
+    if (!parsed)
+        return '\u2014';
+    try {
+        return new Intl.DateTimeFormat(locale, {
+            dateStyle: 'medium',
+            timeStyle: 'medium',
+            ...(parsed.civil ? { timeZone: 'UTC' } : {}),
+        }).format(parsed.date);
+    }
+    catch {
+        return parsed.title;
+    }
+}
 const STATUS_ALIASES = {
     pending: 'queued',
     queued: 'queued',

package/dist/components/ui/input/input.svelte

@@ -14,7 +14,7 @@
 	type Props = WithElementRef<Omit<HTMLInputAttributes, "type" | "value" | "size">> &
 			{ size?: "default" | "compact"; nativeSize?: number } &
 			(Type extends "file"
-				? { type: "file"; files?: FileList; value?: never }
+				? { type: "file"; files?: FileList | undefined; value?: never }
 				: { type?: Type; files?: undefined; value?: InputValue });
 
 	let {

package/dist/components/ui/input/input.svelte.d.ts

@@ -7,7 +7,7 @@ declare function $$render<Type extends HTMLInputTypeAttribute | undefined = unde
         nativeSize?: number;
     } & (Type extends "file" ? {
         type: "file";
-        files?: FileList;
+        files?: FileList | undefined;
         value?: never;
     } : {
         type?: Type;