@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.
@@ -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>;
@@ -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 {
@@ -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.arco': '默认',
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.arco': 'Default',
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
- if (typeof navigator === 'undefined') return 'en';
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
- useResource,
59
- useModal,
60
- useOvertime,
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';