@svadmin/core 0.67.0 → 0.69.3
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/package.json +6 -2
- package/src/adapters/ably.ts +58 -0
- package/src/adapters/cerbos.ts +92 -0
- package/src/adapters/firebase.ts +46 -0
- package/src/adapters/graphql-subscription.ts +45 -0
- package/src/adapters/live-event.ts +21 -0
- package/src/adapters/permit.ts +78 -0
- package/src/audit-hooks.svelte.ts +119 -0
- package/src/contract-form.svelte.ts +96 -6
- package/src/contracts.ts +11 -0
- package/src/crud-operator-schema.ts +20 -0
- package/src/editable-table.svelte.ts +90 -0
- package/src/editable-table.ts +314 -0
- package/src/hooks.svelte.ts +34 -0
- package/src/i18n.svelte.ts +7 -4
- package/src/index.ts +29 -8
- package/src/inferencer-contract.ts +114 -0
- package/src/inferencer.ts +219 -42
- package/src/query-hooks.svelte.ts +16 -6
- package/src/query-options.ts +50 -0
- package/src/query-snapshot.ts +3 -4
- package/src/resource-contract.ts +6 -3
- package/src/resource-schemas.ts +3 -6
- package/src/router-provider.ts +11 -0
- package/src/routing-hooks.svelte.ts +84 -3
- package/src/select-options.ts +35 -1
- package/src/select-query.svelte.ts +20 -5
- package/src/session-query.svelte.ts +6 -1
- package/src/strict-hooks.svelte.ts +9 -5
- package/src/table-hooks.svelte.ts +12 -0
- package/src/task-hooks.svelte.ts +1 -0
- package/src/theme.svelte.ts +8 -6
- package/src/types.ts +22 -7
- package/src/url-sync.ts +37 -17
- package/src/utility-hooks.svelte.ts +68 -5
package/src/contracts.ts
ADDED
|
@@ -0,0 +1,11 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Runtime contract decoders shared with adapters.
|
|
3
|
+
*
|
|
4
|
+
* This subpath intentionally avoids the runes-backed core entry so adapters and
|
|
5
|
+
* non-Svelte tooling can validate provider results without loading app state.
|
|
6
|
+
*/
|
|
7
|
+
export { decodeAuthAction, AuthMutationError } from './auth-mutation-contract';
|
|
8
|
+
export { decodeAuthCheck, decodeAuthErrorResult, decodeIdentity, AuthQueryError } from './auth-query-contract';
|
|
9
|
+
export { decodeCanResult, decodeCanResults } from './access-control-contract';
|
|
10
|
+
export { snapshotLiveEvent, decodeLiveMessage } from './live-transport';
|
|
11
|
+
export { decodeAuditEntry, decodeAuditEntries } from './audit-contract';
|
|
@@ -0,0 +1,20 @@
|
|
|
1
|
+
import { Type, type Static } from 'typebox';
|
|
2
|
+
import type { CrudOperator } from './types';
|
|
3
|
+
|
|
4
|
+
/** 与 CRUD_FIELD_OPERATORS 保持同一组字面量,供查询快照和资源 schema 共用。 */
|
|
5
|
+
export const crudFieldOperatorSchema = Type.Union([
|
|
6
|
+
Type.Literal('eq'), Type.Literal('ne'), Type.Literal('eqs'), Type.Literal('nes'),
|
|
7
|
+
Type.Literal('lt'), Type.Literal('gt'), Type.Literal('lte'), Type.Literal('gte'),
|
|
8
|
+
Type.Literal('in'), Type.Literal('nin'), Type.Literal('ina'), Type.Literal('nina'),
|
|
9
|
+
Type.Literal('contains'), Type.Literal('ncontains'), Type.Literal('containss'), Type.Literal('ncontainss'),
|
|
10
|
+
Type.Literal('startswith'), Type.Literal('nstartswith'), Type.Literal('startswiths'), Type.Literal('nstartswiths'),
|
|
11
|
+
Type.Literal('endswith'), Type.Literal('nendswith'), Type.Literal('endswiths'), Type.Literal('nendswiths'),
|
|
12
|
+
Type.Literal('null'), Type.Literal('nnull'),
|
|
13
|
+
Type.Literal('between'), Type.Literal('nbetween'),
|
|
14
|
+
]);
|
|
15
|
+
|
|
16
|
+
type OperatorParity = Static<typeof crudFieldOperatorSchema> extends CrudOperator
|
|
17
|
+
? CrudOperator extends Static<typeof crudFieldOperatorSchema> ? true : never
|
|
18
|
+
: never;
|
|
19
|
+
const operatorParity: OperatorParity = true;
|
|
20
|
+
void operatorParity;
|
|
@@ -0,0 +1,90 @@
|
|
|
1
|
+
import { captureAdminContext } from './context.svelte';
|
|
2
|
+
import { getAdminOptions } from './options.svelte';
|
|
3
|
+
import { createEditableTableController, resolveEditableTableQuery, type EditableTableQuery } from './editable-table';
|
|
4
|
+
import { readURLState } from './url-sync';
|
|
5
|
+
import type { DataProvider, Filter, Pagination, Sort } from './types';
|
|
6
|
+
import type { ResourceContract } from './resource-contract';
|
|
7
|
+
|
|
8
|
+
export interface UseEditableTableOptions {
|
|
9
|
+
resource: ResourceContract;
|
|
10
|
+
dataProviderName?: string;
|
|
11
|
+
provider?: DataProvider;
|
|
12
|
+
pagination?: Pagination;
|
|
13
|
+
sorters?: Sort[];
|
|
14
|
+
filters?: Filter[];
|
|
15
|
+
syncWithLocation?: boolean;
|
|
16
|
+
/**
|
|
17
|
+
* enabled 与 retry 会作用到这次加载。
|
|
18
|
+
* refetchInterval、select、placeholderData 仍由 useList / useTable 提供,这里的加载是命令式的。
|
|
19
|
+
*/
|
|
20
|
+
queryOptions?: { enabled?: boolean; retry?: EditableTableQuery['retry'] };
|
|
21
|
+
}
|
|
22
|
+
|
|
23
|
+
/**
|
|
24
|
+
* Refine-like editable table hook.
|
|
25
|
+
* The returned `editor` object is the prop EditableTable understands.
|
|
26
|
+
*/
|
|
27
|
+
export function useEditableTable(options: UseEditableTableOptions) {
|
|
28
|
+
const provider = options.provider ?? captureAdminContext().getDataProvider(options.dataProviderName);
|
|
29
|
+
const syncWithLocation = options.syncWithLocation ?? getAdminOptions().syncWithLocation ?? false;
|
|
30
|
+
const url = syncWithLocation && typeof window !== 'undefined' ? readURLState() : undefined;
|
|
31
|
+
const controller = createEditableTableController(options.resource, provider, {
|
|
32
|
+
...resolveEditableTableQuery({ ...options, syncWithLocation }, url),
|
|
33
|
+
...(options.queryOptions?.retry === undefined ? {} : { retry: options.queryOptions.retry }),
|
|
34
|
+
});
|
|
35
|
+
let version = $state(0);
|
|
36
|
+
|
|
37
|
+
$effect(() => {
|
|
38
|
+
if (options.queryOptions?.enabled === false) return;
|
|
39
|
+
void controller.load().then(() => {
|
|
40
|
+
version += 1;
|
|
41
|
+
}, () => {
|
|
42
|
+
version += 1;
|
|
43
|
+
});
|
|
44
|
+
});
|
|
45
|
+
|
|
46
|
+
function bump(): void {
|
|
47
|
+
version += 1;
|
|
48
|
+
}
|
|
49
|
+
|
|
50
|
+
return {
|
|
51
|
+
get snapshot() {
|
|
52
|
+
void version;
|
|
53
|
+
return controller.snapshot();
|
|
54
|
+
},
|
|
55
|
+
get editor() {
|
|
56
|
+
void version;
|
|
57
|
+
const current = controller.snapshot();
|
|
58
|
+
return {
|
|
59
|
+
rows: current.rows,
|
|
60
|
+
errors: current.errors,
|
|
61
|
+
saving: current.saving,
|
|
62
|
+
failure: current.failure,
|
|
63
|
+
onCell: (rowIndex: number, key: string, value: unknown) => {
|
|
64
|
+
controller.setCell(rowIndex, key, value);
|
|
65
|
+
bump();
|
|
66
|
+
},
|
|
67
|
+
onSubmit: async () => {
|
|
68
|
+
await controller.submit();
|
|
69
|
+
bump();
|
|
70
|
+
},
|
|
71
|
+
onRetry: async () => {
|
|
72
|
+
await controller.retry();
|
|
73
|
+
bump();
|
|
74
|
+
},
|
|
75
|
+
onAdd: () => {
|
|
76
|
+
controller.addRow();
|
|
77
|
+
bump();
|
|
78
|
+
},
|
|
79
|
+
onDelete: (rowIndex: number) => {
|
|
80
|
+
controller.deleteRow(rowIndex);
|
|
81
|
+
bump();
|
|
82
|
+
},
|
|
83
|
+
};
|
|
84
|
+
},
|
|
85
|
+
submitBatch: async (patch: Record<string, unknown>) => {
|
|
86
|
+
await controller.submitBatch(patch);
|
|
87
|
+
bump();
|
|
88
|
+
},
|
|
89
|
+
};
|
|
90
|
+
}
|
|
@@ -0,0 +1,314 @@
|
|
|
1
|
+
import type { DataProvider, Filter, Pagination, Sort } from './types';
|
|
2
|
+
import { HttpError } from './types';
|
|
3
|
+
import { definedOptions } from './defined-options';
|
|
4
|
+
import {
|
|
5
|
+
getContractFormFields,
|
|
6
|
+
parseContractCreateInput,
|
|
7
|
+
parseContractRecord,
|
|
8
|
+
parseContractUpdateInput,
|
|
9
|
+
type ResourceContract,
|
|
10
|
+
} from './resource-contract';
|
|
11
|
+
|
|
12
|
+
export interface EditableTableQuery {
|
|
13
|
+
pagination?: Pagination;
|
|
14
|
+
sorters?: Sort[];
|
|
15
|
+
filters?: Filter[];
|
|
16
|
+
meta?: Record<string, unknown>;
|
|
17
|
+
/** false 只请求一次;数字表示失败后的额外重试次数,与 TanStack Query 的 retry 一致。 */
|
|
18
|
+
retry?: boolean | number;
|
|
19
|
+
}
|
|
20
|
+
|
|
21
|
+
export function resolveEditableTableQuery(
|
|
22
|
+
options: {
|
|
23
|
+
pagination?: Pagination;
|
|
24
|
+
sorters?: Sort[];
|
|
25
|
+
filters?: Filter[];
|
|
26
|
+
syncWithLocation?: boolean;
|
|
27
|
+
},
|
|
28
|
+
url?: {
|
|
29
|
+
page?: number;
|
|
30
|
+
pageSize?: number;
|
|
31
|
+
sortField?: string;
|
|
32
|
+
sortOrder?: 'asc' | 'desc';
|
|
33
|
+
filters?: Filter[];
|
|
34
|
+
},
|
|
35
|
+
): Pick<EditableTableQuery, 'pagination' | 'sorters' | 'filters'> {
|
|
36
|
+
const synced = options.syncWithLocation === true;
|
|
37
|
+
return {
|
|
38
|
+
pagination: {
|
|
39
|
+
...options.pagination,
|
|
40
|
+
current: synced ? url?.page ?? options.pagination?.current ?? 1 : options.pagination?.current ?? 1,
|
|
41
|
+
pageSize: synced ? url?.pageSize ?? options.pagination?.pageSize ?? 50 : options.pagination?.pageSize ?? 50,
|
|
42
|
+
},
|
|
43
|
+
...(synced && url?.sortField
|
|
44
|
+
? { sorters: [{ field: url.sortField, order: url.sortOrder ?? 'asc' }] }
|
|
45
|
+
: options.sorters ? { sorters: options.sorters } : {}),
|
|
46
|
+
...((synced ? url?.filters ?? options.filters : options.filters) ? {
|
|
47
|
+
filters: synced ? url?.filters ?? options.filters : options.filters,
|
|
48
|
+
} : {}),
|
|
49
|
+
};
|
|
50
|
+
}
|
|
51
|
+
|
|
52
|
+
function retryAttempts(retry: boolean | number | undefined): number {
|
|
53
|
+
if (retry === true) return 4;
|
|
54
|
+
if (typeof retry === 'number' && Number.isInteger(retry) && retry > 0 && retry <= 10) return retry + 1;
|
|
55
|
+
return 1;
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
export interface EditableTableSnapshot {
|
|
59
|
+
rows: Record<string, unknown>[];
|
|
60
|
+
errors: Record<string, string>;
|
|
61
|
+
saving: boolean;
|
|
62
|
+
failure: string | null;
|
|
63
|
+
}
|
|
64
|
+
|
|
65
|
+
interface EditableRow {
|
|
66
|
+
key: string;
|
|
67
|
+
id?: string | number;
|
|
68
|
+
draft: boolean;
|
|
69
|
+
values: Record<string, unknown>;
|
|
70
|
+
original: Record<string, unknown>;
|
|
71
|
+
error: string | null;
|
|
72
|
+
failed: boolean;
|
|
73
|
+
dirty: boolean;
|
|
74
|
+
}
|
|
75
|
+
|
|
76
|
+
let nextKey = 0;
|
|
77
|
+
|
|
78
|
+
function pick(fields: readonly string[], values: Record<string, unknown>): Record<string, unknown> {
|
|
79
|
+
const result: Record<string, unknown> = {};
|
|
80
|
+
for (const field of fields) {
|
|
81
|
+
if (Object.hasOwn(values, field)) result[field] = values[field];
|
|
82
|
+
}
|
|
83
|
+
return result;
|
|
84
|
+
}
|
|
85
|
+
|
|
86
|
+
/**
|
|
87
|
+
* Headless editable-table contract: form values, schema validation,
|
|
88
|
+
* per-row submit, failure recovery, and batch update.
|
|
89
|
+
*/
|
|
90
|
+
export function createEditableTableController(
|
|
91
|
+
contract: ResourceContract,
|
|
92
|
+
provider: DataProvider,
|
|
93
|
+
query: EditableTableQuery = {},
|
|
94
|
+
) {
|
|
95
|
+
let rows: EditableRow[] = [];
|
|
96
|
+
let saving = false;
|
|
97
|
+
let failure: string | null = null;
|
|
98
|
+
|
|
99
|
+
function snapshot(): EditableTableSnapshot {
|
|
100
|
+
const errors: Record<string, string> = {};
|
|
101
|
+
for (const row of rows) {
|
|
102
|
+
if (row.error) errors[row.key] = row.error;
|
|
103
|
+
}
|
|
104
|
+
return {
|
|
105
|
+
rows: rows.map((row) => ({ ...row.values, id: row.id ?? row.key })),
|
|
106
|
+
errors,
|
|
107
|
+
saving,
|
|
108
|
+
failure,
|
|
109
|
+
};
|
|
110
|
+
}
|
|
111
|
+
|
|
112
|
+
async function readRows(): Promise<void> {
|
|
113
|
+
const result = await provider.getList({
|
|
114
|
+
resource: contract.name,
|
|
115
|
+
...definedOptions({
|
|
116
|
+
pagination: query.pagination ?? { current: 1, pageSize: 50 },
|
|
117
|
+
sorters: query.sorters,
|
|
118
|
+
filters: query.filters,
|
|
119
|
+
meta: query.meta,
|
|
120
|
+
}),
|
|
121
|
+
});
|
|
122
|
+
const records = result.data.map((record) => parseContractRecord(contract, record));
|
|
123
|
+
rows = records.map((record) => {
|
|
124
|
+
const rawId = record['id'];
|
|
125
|
+
const id = typeof rawId === 'string' || typeof rawId === 'number' ? rawId : undefined;
|
|
126
|
+
const values = { ...record };
|
|
127
|
+
return {
|
|
128
|
+
key: id === undefined ? `row_${++nextKey}` : String(id),
|
|
129
|
+
...(id === undefined ? {} : { id }),
|
|
130
|
+
draft: false,
|
|
131
|
+
values,
|
|
132
|
+
original: { ...values },
|
|
133
|
+
error: null,
|
|
134
|
+
failed: false,
|
|
135
|
+
dirty: false,
|
|
136
|
+
};
|
|
137
|
+
});
|
|
138
|
+
failure = null;
|
|
139
|
+
}
|
|
140
|
+
|
|
141
|
+
async function load(): Promise<void> {
|
|
142
|
+
const attempts = retryAttempts(query.retry);
|
|
143
|
+
let last: unknown;
|
|
144
|
+
for (let attempt = 0; attempt < attempts; attempt += 1) {
|
|
145
|
+
try {
|
|
146
|
+
await readRows();
|
|
147
|
+
return;
|
|
148
|
+
} catch (error) {
|
|
149
|
+
last = error;
|
|
150
|
+
if (error instanceof HttpError && error.code === 'INVALID_PROVIDER_RESPONSE') break;
|
|
151
|
+
}
|
|
152
|
+
}
|
|
153
|
+
failure = 'Could not load rows';
|
|
154
|
+
throw last;
|
|
155
|
+
}
|
|
156
|
+
|
|
157
|
+
function setCell(rowIndex: number, key: string, value: unknown): void {
|
|
158
|
+
const row = rows[rowIndex];
|
|
159
|
+
if (!row || key === 'id') return;
|
|
160
|
+
row.values = { ...row.values, [key]: value };
|
|
161
|
+
row.dirty = true;
|
|
162
|
+
row.error = null;
|
|
163
|
+
row.failed = false;
|
|
164
|
+
failure = null;
|
|
165
|
+
}
|
|
166
|
+
|
|
167
|
+
function addRow(): void {
|
|
168
|
+
const key = `row_${++nextKey}`;
|
|
169
|
+
const values: Record<string, unknown> = {};
|
|
170
|
+
for (const field of getContractFormFields(contract, 'create')) values[field] = '';
|
|
171
|
+
rows = [...rows, {
|
|
172
|
+
key,
|
|
173
|
+
draft: true,
|
|
174
|
+
values,
|
|
175
|
+
original: { ...values },
|
|
176
|
+
error: null,
|
|
177
|
+
failed: false,
|
|
178
|
+
dirty: true,
|
|
179
|
+
}];
|
|
180
|
+
}
|
|
181
|
+
|
|
182
|
+
function deleteRow(rowIndex: number): void {
|
|
183
|
+
const row = rows[rowIndex];
|
|
184
|
+
if (!row) return;
|
|
185
|
+
rows = rows.filter((candidate) => candidate !== row);
|
|
186
|
+
}
|
|
187
|
+
|
|
188
|
+
function validateRow(row: EditableRow): boolean {
|
|
189
|
+
try {
|
|
190
|
+
if (row.draft) {
|
|
191
|
+
parseContractCreateInput(contract, pick(getContractFormFields(contract, 'create'), row.values));
|
|
192
|
+
} else {
|
|
193
|
+
parseContractUpdateInput(contract, pick(getContractFormFields(contract, 'edit'), row.values));
|
|
194
|
+
}
|
|
195
|
+
row.error = null;
|
|
196
|
+
return true;
|
|
197
|
+
} catch {
|
|
198
|
+
row.error = row.draft ? 'Invalid create input' : 'Invalid update input';
|
|
199
|
+
return false;
|
|
200
|
+
}
|
|
201
|
+
}
|
|
202
|
+
|
|
203
|
+
async function persist(row: EditableRow): Promise<void> {
|
|
204
|
+
if (row.draft) {
|
|
205
|
+
const variables = parseContractCreateInput(contract, pick(getContractFormFields(contract, 'create'), row.values));
|
|
206
|
+
const result = await provider.create({ resource: contract.name, variables });
|
|
207
|
+
const created = parseContractRecord(contract, result.data);
|
|
208
|
+
const id = typeof created['id'] === 'string' || typeof created['id'] === 'number' ? created['id'] : undefined;
|
|
209
|
+
row.draft = false;
|
|
210
|
+
row.dirty = false;
|
|
211
|
+
row.failed = false;
|
|
212
|
+
row.error = null;
|
|
213
|
+
if (id !== undefined) {
|
|
214
|
+
row.id = id;
|
|
215
|
+
row.key = String(id);
|
|
216
|
+
}
|
|
217
|
+
row.values = { ...row.values, ...created };
|
|
218
|
+
row.original = { ...row.values };
|
|
219
|
+
return;
|
|
220
|
+
}
|
|
221
|
+
if (row.id === undefined) return;
|
|
222
|
+
const variables = parseContractUpdateInput(contract, pick(getContractFormFields(contract, 'edit'), row.values));
|
|
223
|
+
const result = await provider.update({ resource: contract.name, id: row.id, variables });
|
|
224
|
+
const saved = parseContractRecord(contract, result.data);
|
|
225
|
+
row.dirty = false;
|
|
226
|
+
row.failed = false;
|
|
227
|
+
row.error = null;
|
|
228
|
+
row.values = { ...row.values, ...saved };
|
|
229
|
+
row.original = { ...row.values };
|
|
230
|
+
}
|
|
231
|
+
|
|
232
|
+
async function exclusive(work: () => Promise<void>): Promise<void> {
|
|
233
|
+
if (saving) return;
|
|
234
|
+
saving = true;
|
|
235
|
+
try {
|
|
236
|
+
await work();
|
|
237
|
+
} finally {
|
|
238
|
+
saving = false;
|
|
239
|
+
}
|
|
240
|
+
}
|
|
241
|
+
|
|
242
|
+
async function submitTargets(targets: readonly EditableRow[]): Promise<void> {
|
|
243
|
+
failure = null;
|
|
244
|
+
let failed = 0;
|
|
245
|
+
for (const row of targets) {
|
|
246
|
+
if (!validateRow(row)) {
|
|
247
|
+
row.failed = true;
|
|
248
|
+
failed += 1;
|
|
249
|
+
continue;
|
|
250
|
+
}
|
|
251
|
+
try {
|
|
252
|
+
await persist(row);
|
|
253
|
+
} catch {
|
|
254
|
+
row.failed = true;
|
|
255
|
+
row.error = 'Save failed';
|
|
256
|
+
failed += 1;
|
|
257
|
+
}
|
|
258
|
+
}
|
|
259
|
+
failure = failed > 0 ? `${failed} row(s) were not saved` : null;
|
|
260
|
+
}
|
|
261
|
+
|
|
262
|
+
async function submit(): Promise<void> {
|
|
263
|
+
await exclusive(() => submitTargets(rows.filter((row) => row.draft || row.dirty || row.failed)));
|
|
264
|
+
}
|
|
265
|
+
|
|
266
|
+
async function retry(): Promise<void> {
|
|
267
|
+
await exclusive(() => submitTargets(rows.filter((row) => row.failed)));
|
|
268
|
+
}
|
|
269
|
+
|
|
270
|
+
async function submitBatch(patch: Record<string, unknown>): Promise<void> {
|
|
271
|
+
let variables: unknown;
|
|
272
|
+
try {
|
|
273
|
+
variables = parseContractUpdateInput(contract, patch);
|
|
274
|
+
} catch {
|
|
275
|
+
failure = 'Invalid update input';
|
|
276
|
+
return;
|
|
277
|
+
}
|
|
278
|
+
const targets = rows.filter((row) => !row.draft && row.id !== undefined);
|
|
279
|
+
const ids = targets.flatMap((row) => row.id === undefined ? [] : [row.id]);
|
|
280
|
+
await exclusive(async () => {
|
|
281
|
+
failure = null;
|
|
282
|
+
try {
|
|
283
|
+
if (provider.updateMany) {
|
|
284
|
+
const result = await provider.updateMany({ resource: contract.name, ids, variables });
|
|
285
|
+
for (const record of result.data) parseContractRecord(contract, record);
|
|
286
|
+
} else {
|
|
287
|
+
for (const id of ids) {
|
|
288
|
+
const result = await provider.update({ resource: contract.name, id, variables });
|
|
289
|
+
parseContractRecord(contract, result.data);
|
|
290
|
+
}
|
|
291
|
+
}
|
|
292
|
+
for (const row of targets) {
|
|
293
|
+
row.values = { ...row.values, ...patch };
|
|
294
|
+
row.original = { ...row.values };
|
|
295
|
+
row.dirty = false;
|
|
296
|
+
row.failed = false;
|
|
297
|
+
row.error = null;
|
|
298
|
+
}
|
|
299
|
+
} catch {
|
|
300
|
+
for (const row of targets) {
|
|
301
|
+
row.failed = true;
|
|
302
|
+
row.error = 'Save failed';
|
|
303
|
+
row.values = { ...row.values, ...patch };
|
|
304
|
+
row.dirty = true;
|
|
305
|
+
}
|
|
306
|
+
failure = `${targets.length} row(s) were not saved`;
|
|
307
|
+
}
|
|
308
|
+
});
|
|
309
|
+
}
|
|
310
|
+
|
|
311
|
+
return { snapshot, load, setCell, addRow, deleteRow, submit, retry, submitBatch };
|
|
312
|
+
}
|
|
313
|
+
|
|
314
|
+
export type EditableTableController = ReturnType<typeof createEditableTableController>;
|
package/src/hooks.svelte.ts
CHANGED
|
@@ -44,6 +44,40 @@ export function useOvertime(options?: OvertimeOptions) {
|
|
|
44
44
|
};
|
|
45
45
|
}
|
|
46
46
|
|
|
47
|
+
/**
|
|
48
|
+
* Refine-compatible alias for query-heavy callers.
|
|
49
|
+
*
|
|
50
|
+
* Accepts a query-like object or a loading getter and reports elapsed time while
|
|
51
|
+
* loading. `useOvertime` keeps the manual start/stop form for custom work.
|
|
52
|
+
*/
|
|
53
|
+
export function useLoadingOvertime(
|
|
54
|
+
source?: (() => boolean) | { isLoading?: boolean; isPending?: boolean; isFetching?: boolean },
|
|
55
|
+
options?: OvertimeOptions,
|
|
56
|
+
) {
|
|
57
|
+
const tracker=createOvertimeTracker(() => typeof source === 'function'
|
|
58
|
+
? source()
|
|
59
|
+
: source?.isLoading === true || source?.isPending === true || source?.isFetching === true, options);
|
|
60
|
+
return {
|
|
61
|
+
get elapsedTime() { return tracker.elapsedTime; },
|
|
62
|
+
get overtime() { return tracker.elapsedTime; },
|
|
63
|
+
};
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
/** Set `document.title` for the lifetime of the calling component. */
|
|
67
|
+
export function useTitle(value: string | (() => string) | undefined, options?: { append?: string }) {
|
|
68
|
+
let previous: string | undefined;
|
|
69
|
+
$effect(() => {
|
|
70
|
+
if (typeof document === 'undefined') return;
|
|
71
|
+
const title = typeof value === 'function' ? value() : value;
|
|
72
|
+
if (title === undefined) return;
|
|
73
|
+
if (previous === undefined) previous = document.title;
|
|
74
|
+
document.title = options?.append === undefined ? title : `${title}${options.append}`;
|
|
75
|
+
return () => {
|
|
76
|
+
if (previous !== undefined) document.title = previous;
|
|
77
|
+
};
|
|
78
|
+
});
|
|
79
|
+
}
|
|
80
|
+
|
|
47
81
|
// ─── useDataProvider ────────────────────────────────────────────────
|
|
48
82
|
|
|
49
83
|
export function useDataProvider(): (dataProviderName?: string) => DataProvider {
|
package/src/i18n.svelte.ts
CHANGED
|
@@ -513,7 +513,7 @@ const baseLocales: Record<string, Record<string, string>> = {
|
|
|
513
513
|
'settings.accent.rose': '玫瑰色',
|
|
514
514
|
'settings.accent.orange': '橙色',
|
|
515
515
|
'settings.accent.violet': '紫罗兰色',
|
|
516
|
-
'settings.accent.
|
|
516
|
+
'settings.accent.default': '默认',
|
|
517
517
|
'settings.accent.stripe': '条纹',
|
|
518
518
|
'settings.language': '语言',
|
|
519
519
|
'settings.interface': '界面',
|
|
@@ -758,6 +758,7 @@ const baseLocales: Record<string, Record<string, string>> = {
|
|
|
758
758
|
'task.invalidJson': '任务负载必须是合法 JSON',
|
|
759
759
|
'task.submitSuccess': '任务提交成功',
|
|
760
760
|
'task.submitFailed': '任务提交失败',
|
|
761
|
+
'task.submitUnconfirmed': '提交结果未知,请刷新任务列表确认后再试。',
|
|
761
762
|
'task.fetchFailed': '加载任务失败',
|
|
762
763
|
'task.fetchListFailed': '加载任务列表失败',
|
|
763
764
|
'task.actionFailed': '无法确认任务操作结果,请核对任务状态后再试。',
|
|
@@ -1434,7 +1435,7 @@ const baseLocales: Record<string, Record<string, string>> = {
|
|
|
1434
1435
|
'settings.accent.rose': 'Rose',
|
|
1435
1436
|
'settings.accent.orange': 'Orange',
|
|
1436
1437
|
'settings.accent.violet': 'Violet',
|
|
1437
|
-
'settings.accent.
|
|
1438
|
+
'settings.accent.default': 'Default',
|
|
1438
1439
|
'settings.accent.stripe': 'Stripe',
|
|
1439
1440
|
'settings.language': 'Language',
|
|
1440
1441
|
'settings.interface': 'Interface',
|
|
@@ -1679,6 +1680,7 @@ const baseLocales: Record<string, Record<string, string>> = {
|
|
|
1679
1680
|
'task.invalidJson': 'Task payload must be valid JSON',
|
|
1680
1681
|
'task.submitSuccess': 'Task submitted successfully',
|
|
1681
1682
|
'task.submitFailed': 'Task submission failed',
|
|
1683
|
+
'task.submitUnconfirmed': 'Submission result is unconfirmed. Refresh the task list before trying again.',
|
|
1682
1684
|
'task.fetchFailed': 'Fetch task failed',
|
|
1683
1685
|
'task.fetchListFailed': 'Fetch tasks failed',
|
|
1684
1686
|
'task.actionFailed': 'Unable to confirm the task action. Check the task status before trying again.',
|
|
@@ -1850,9 +1852,10 @@ const baseLocales: Record<string, Record<string, string>> = {
|
|
|
1850
1852
|
let locales = $state(structuredClone(baseLocales));
|
|
1851
1853
|
const initialLocales = structuredClone(baseLocales);
|
|
1852
1854
|
|
|
1853
|
-
/** Detect best locale from browser language */
|
|
1855
|
+
/** Detect best locale from browser language; server rendering always starts in English. */
|
|
1854
1856
|
function detectLocale(): string {
|
|
1855
|
-
|
|
1857
|
+
// Node 22+ exposes a global navigator, so gate SSR on the browser window instead.
|
|
1858
|
+
if (typeof window === 'undefined' || typeof navigator === 'undefined') return 'en';
|
|
1856
1859
|
const browserLang = navigator.language || navigator.languages?.[0] || 'zh-CN';
|
|
1857
1860
|
if (locales[browserLang]) return browserLang;
|
|
1858
1861
|
const [prefix = browserLang] = browserLang.split('-');
|
package/src/index.ts
CHANGED
|
@@ -55,18 +55,23 @@ export {
|
|
|
55
55
|
useApiUrl,
|
|
56
56
|
useNavigation, useGo, useBack,
|
|
57
57
|
useGetToPath, useLink,
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
|
|
58
|
+
useMutationMode, useWarnAboutChange, useSyncWithLocation, useMeta,
|
|
59
|
+
useResource, useResourceParams, useKeys,
|
|
60
|
+
useModal, useDrawer,
|
|
61
|
+
useOvertime, useLoadingOvertime,
|
|
62
|
+
useTitle,
|
|
61
63
|
useNotification,
|
|
62
64
|
useMenu, useBreadcrumb, useThemedLayoutContext,
|
|
63
65
|
resetSidebarCollapsed,
|
|
64
66
|
} from './hooks.svelte';
|
|
65
67
|
export {
|
|
66
|
-
useList, useOne, useShow, useMany, useInfiniteList, useSelect, useTable,
|
|
68
|
+
useList, useSimpleList, useOne, useShow, useMany, useInfiniteList, useSelect, useTable,
|
|
67
69
|
useCreate, useUpdate, useDelete, useCreateMany, useUpdateMany, useDeleteMany, useForm,
|
|
68
70
|
useInvalidate,
|
|
69
71
|
} from './strict-hooks.svelte';
|
|
72
|
+
export { useEditableTable } from './editable-table.svelte';
|
|
73
|
+
export { createEditableTableController } from './editable-table';
|
|
74
|
+
export type { EditableTableSnapshot } from './editable-table';
|
|
70
75
|
export { defineResource, getContractFormFields, withContractProjection } from './resource-contract';
|
|
71
76
|
export {
|
|
72
77
|
defineAdminConfig,
|
|
@@ -110,6 +115,7 @@ export type { ContractUpdateParams as UseUpdateMutateParams } from './update-con
|
|
|
110
115
|
export type { ContractDeleteOptions as UseDeleteOptions } from './delete-hooks.svelte';
|
|
111
116
|
export type { ContractDeleteParams as UseDeleteMutateParams } from './delete-contract';
|
|
112
117
|
export type { ContractFormAction, ContractFormDraft, ContractFormValues } from './resource-contract';
|
|
118
|
+
export type { AutoSaveOptions, AutoSaveState, AutoSaveStatus } from './contract-form.svelte';
|
|
113
119
|
export type { ContractProjectionOptions } from './resource-contract';
|
|
114
120
|
export type { ResourceContract, ContractSchemas, ContractRecord, ContractId, ContractInput } from './resource-contract';
|
|
115
121
|
export type { ContractFilter, ContractSort } from './strict-hooks.svelte';
|
|
@@ -140,6 +146,12 @@ export type {
|
|
|
140
146
|
PermissionSnapshot,
|
|
141
147
|
} from './permission-catalog';
|
|
142
148
|
export { useLive, useSubscription, usePublish } from './live.svelte';
|
|
149
|
+
export { createAblyLiveProvider } from './adapters/ably';
|
|
150
|
+
export type { AblyAdapterOptions, AblyChannelLike, AblyClientLike, AblyMessage } from './adapters/ably';
|
|
151
|
+
export { createFirebaseLiveProvider } from './adapters/firebase';
|
|
152
|
+
export type { FirebaseAdapterOptions, FirebaseLiveTransport } from './adapters/firebase';
|
|
153
|
+
export { createGraphQLSubscriptionLiveProvider } from './adapters/graphql-subscription';
|
|
154
|
+
export type { GraphQLSubscriptionTransport } from './adapters/graphql-subscription';
|
|
143
155
|
export { toast, getToastQueue, consumeToastQueue, getPromiseQueue, consumePromiseQueue, getToasts, removeToast, resetToast } from './toast.svelte';
|
|
144
156
|
export {
|
|
145
157
|
notify,
|
|
@@ -158,6 +170,8 @@ export type { DateTimeValueMode, DateTimeDisambiguation } from './date-time';
|
|
|
158
170
|
export { validateGantt, GANTT_LIMITS } from './gantt';
|
|
159
171
|
export type { GanttTaskShape, GanttValidationError } from './gantt';
|
|
160
172
|
export { audit, auditWithProvider, writeAuditEntry, recordMutationRollback, setAuditHandler, setAuditLogProvider, getAuditLogProvider, withValidatedAuditProvider, AuditError } from './audit';
|
|
173
|
+
export { useLog, useLogList } from './audit-hooks.svelte';
|
|
174
|
+
export type { UseLogOptions, UseLogMutation, UseLogListOptions, UseLogListResult } from './audit-hooks.svelte';
|
|
161
175
|
export type { AuditLogProvider, AuditLogTransport, AuditCreateParams, AuditQueryParams, AuditDraft } from './audit';
|
|
162
176
|
export { TaskError } from './task-contract';
|
|
163
177
|
export { withValidatedTaskProvider } from './task-provider';
|
|
@@ -211,7 +225,7 @@ export type { AdminOptions, TextTransformers, OvertimeConfig } from './options.s
|
|
|
211
225
|
export { checkError } from './hook-utils.svelte';
|
|
212
226
|
export type { NotificationConfig, OvertimeOptions, OvertimeResult, LiveSubscriptionParams } from './hook-utils.svelte';
|
|
213
227
|
|
|
214
|
-
export { DeleteManyPartialError, HttpError, UndoError } from './types';
|
|
228
|
+
export { CRUD_FIELD_OPERATORS, DeleteManyPartialError, HttpError, UndoError, isCrudFieldOperator } from './types';
|
|
215
229
|
export { withResourceSchemas } from './resource-schemas';
|
|
216
230
|
export type { ResourceSchemas, ResourceSchemaMap, InferSchemaResourceMap, InferSchemaInputMap } from './resource-schemas';
|
|
217
231
|
export type {
|
|
@@ -242,6 +256,10 @@ export { useCan } from './useCan';
|
|
|
242
256
|
export type { UseCanOptions, UseCanResult } from './useCan';
|
|
243
257
|
export { createCaslAccessControl } from './adapters/casl';
|
|
244
258
|
export { createCasbinAccessControl } from './adapters/casbin';
|
|
259
|
+
export { createCerbosAccessControl } from './adapters/cerbos';
|
|
260
|
+
export type { CerbosAdapterOptions, CerbosOptions, CerbosPrincipal } from './adapters/cerbos';
|
|
261
|
+
export { createPermitAccessControl } from './adapters/permit';
|
|
262
|
+
export type { PermitAdapterOptions, PermitOptions } from './adapters/permit';
|
|
245
263
|
export type { CasbinAdapterOptions } from './adapters/casbin';
|
|
246
264
|
export { downloadData, toCsv, toJson, toXlsx, parseCSV } from './data-transfer.svelte';
|
|
247
265
|
export { parseSpreadsheetClipboard, serializeSpreadsheetClipboard } from './spreadsheet-clipboard';
|
|
@@ -276,9 +294,11 @@ export {
|
|
|
276
294
|
captureAuthLiveScope as captureAuthSession,
|
|
277
295
|
} from './auth-hooks.svelte';
|
|
278
296
|
export type { AuthNotificationOptions } from './auth-hooks.svelte';
|
|
279
|
-
export { AuthQueryError, AuthErrorHandlingError } from './auth-query-contract';
|
|
280
|
-
export type { AuthErrorHandlingResult } from './auth-query-contract';
|
|
281
|
-
export { AuthMutationError } from './auth-mutation-contract';
|
|
297
|
+
export { AuthQueryError, AuthErrorHandlingError, decodeAuthCheck, decodeAuthErrorResult, decodeIdentity } from './auth-query-contract';
|
|
298
|
+
export type { AuthErrorHandlingResult, AuthErrorResult } from './auth-query-contract';
|
|
299
|
+
export { AuthMutationError, decodeAuthAction } from './auth-mutation-contract';
|
|
300
|
+
export { decodeCanResult } from './access-control-contract';
|
|
301
|
+
export { snapshotLiveEvent } from './live-transport';
|
|
282
302
|
export { useResourceContract } from './resource-binding.svelte';
|
|
283
303
|
export { PermissionHintsError } from './permission-hints-contract';
|
|
284
304
|
export type { PermissionHints } from './permission-hints-contract';
|
|
@@ -303,6 +323,7 @@ export {
|
|
|
303
323
|
generateEditPageCode,
|
|
304
324
|
generateShowPageCode,
|
|
305
325
|
generateResourceCode,
|
|
326
|
+
generateResourceContractCode,
|
|
306
327
|
generateComponentCode,
|
|
307
328
|
generateResourceBundle,
|
|
308
329
|
} from './inferencer';
|