@svadmin/core 0.69.2 → 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 CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@svadmin/core",
3
- "version": "0.69.2",
3
+ "version": "0.69.3",
4
4
  "author": "zuohuadong",
5
5
  "repository": {
6
6
  "type": "git",
@@ -14,7 +14,7 @@
14
14
  "@testing-library/dom": "^10.4.1",
15
15
  "@testing-library/svelte": "^5.4.2",
16
16
  "@testing-library/user-event": "^14.6.6",
17
- "@types/bun": "^1.4.2",
17
+ "@types/bun": "^1.4.4",
18
18
  "@types/jsdom": "^30.0.0",
19
19
  "exceljs": "4.4.0",
20
20
  "happy-dom": "^21.0.4",
@@ -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/index.ts CHANGED
@@ -55,7 +55,8 @@ export {
55
55
  useApiUrl,
56
56
  useNavigation, useGo, useBack,
57
57
  useGetToPath, useLink,
58
- useResource,
58
+ useMutationMode, useWarnAboutChange, useSyncWithLocation, useMeta,
59
+ useResource, useResourceParams, useKeys,
59
60
  useModal, useDrawer,
60
61
  useOvertime, useLoadingOvertime,
61
62
  useTitle,
@@ -64,10 +65,13 @@ export {
64
65
  resetSidebarCollapsed,
65
66
  } from './hooks.svelte';
66
67
  export {
67
- useList, useOne, useShow, useMany, useInfiniteList, useSelect, useTable,
68
+ useList, useSimpleList, useOne, useShow, useMany, useInfiniteList, useSelect, useTable,
68
69
  useCreate, useUpdate, useDelete, useCreateMany, useUpdateMany, useDeleteMany, useForm,
69
70
  useInvalidate,
70
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';
71
75
  export { defineResource, getContractFormFields, withContractProjection } from './resource-contract';
72
76
  export {
73
77
  defineAdminConfig,
@@ -221,7 +225,7 @@ export type { AdminOptions, TextTransformers, OvertimeConfig } from './options.s
221
225
  export { checkError } from './hook-utils.svelte';
222
226
  export type { NotificationConfig, OvertimeOptions, OvertimeResult, LiveSubscriptionParams } from './hook-utils.svelte';
223
227
 
224
- export { DeleteManyPartialError, HttpError, UndoError } from './types';
228
+ export { CRUD_FIELD_OPERATORS, DeleteManyPartialError, HttpError, UndoError, isCrudFieldOperator } from './types';
225
229
  export { withResourceSchemas } from './resource-schemas';
226
230
  export type { ResourceSchemas, ResourceSchemaMap, InferSchemaResourceMap, InferSchemaInputMap } from './resource-schemas';
227
231
  export type {
@@ -319,6 +323,7 @@ export {
319
323
  generateEditPageCode,
320
324
  generateShowPageCode,
321
325
  generateResourceCode,
326
+ generateResourceContractCode,
322
327
  generateComponentCode,
323
328
  generateResourceBundle,
324
329
  } from './inferencer';
@@ -0,0 +1,114 @@
1
+ import type { FieldDefinition } from './types';
2
+
3
+ const contractExpressions = new WeakMap<FieldDefinition, string>();
4
+ const JSON_SCHEMA_DEPTH = 6;
5
+
6
+ export function propertyKey(key: string): string {
7
+ // 对象字面量里的 __proto__ 会改原型,必须写成字符串键。
8
+ if (key === '__proto__' || key === 'constructor' || key === 'prototype') return JSON.stringify(key);
9
+ return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
10
+ }
11
+
12
+ function unionExpressions(expressions: string[]): string | null {
13
+ const unique = [...new Set(expressions)];
14
+ if (unique.length === 0) return null;
15
+ if (unique.length === 1) return unique[0] ?? null;
16
+ return `Type.Union([${unique.join(', ')}])`;
17
+ }
18
+
19
+ function valueKind(value: unknown): 'string' | 'boolean' | 'number' | 'array' | 'object' | 'other' {
20
+ if (typeof value === 'string') return 'string';
21
+ if (typeof value === 'boolean') return 'boolean';
22
+ if (typeof value === 'number') return 'number';
23
+ if (Array.isArray(value)) return 'array';
24
+ if (typeof value === 'object' && value !== null) return 'object';
25
+ return 'other';
26
+ }
27
+
28
+ /** 从样本值生成 closeContractSchema 接受的封闭 TypeBox 表达式。无法封闭时返回 null。 */
29
+ export function closedValueExpression(values: unknown[], depth: number, seen: WeakSet<object>): string | null {
30
+ if (depth > JSON_SCHEMA_DEPTH) return null;
31
+ const defined = values.filter((value) => value !== undefined);
32
+ if (defined.length === 0) return null;
33
+ const nonNull = defined.filter((value) => value !== null);
34
+ const expression = nonNull.length === 0
35
+ ? 'Type.Null()'
36
+ : closedNonNullExpression(nonNull, depth, seen);
37
+ if (!expression) return null;
38
+ if (nonNull.length !== defined.length && expression !== 'Type.Null()') {
39
+ return `Type.Union([${expression}, Type.Null()])`;
40
+ }
41
+ return expression;
42
+ }
43
+
44
+ function closedNonNullExpression(values: unknown[], depth: number, seen: WeakSet<object>): string | null {
45
+ const kinds = [...new Set(values.map(valueKind))];
46
+ if (kinds.length !== 1) {
47
+ const parts: string[] = [];
48
+ for (const kind of kinds) {
49
+ const expression = closedNonNullExpression(values.filter((value) => valueKind(value) === kind), depth, seen);
50
+ if (!expression) return null;
51
+ parts.push(expression);
52
+ }
53
+ return unionExpressions(parts);
54
+ }
55
+ switch (kinds[0]) {
56
+ case 'string':
57
+ return 'Type.String()';
58
+ case 'boolean':
59
+ return 'Type.Boolean()';
60
+ case 'number':
61
+ return values.every((value) => typeof value === 'number' && Number.isFinite(value)) ? 'Type.Number()' : null;
62
+ case 'array':
63
+ return closedArrayExpression(values.filter(Array.isArray), depth, seen);
64
+ case 'object':
65
+ return closedObjectExpression(values.filter((value): value is Record<string, unknown> => valueKind(value) === 'object'), depth, seen);
66
+ default:
67
+ return null;
68
+ }
69
+ }
70
+
71
+ function closedArrayExpression(values: unknown[][], depth: number, seen: WeakSet<object>): string | null {
72
+ for (const value of values) {
73
+ if (seen.has(value)) return null;
74
+ }
75
+ for (const value of values) seen.add(value);
76
+ try {
77
+ const items = values.flat();
78
+ if (items.length === 0) return null;
79
+ const item = closedValueExpression(items, depth + 1, seen);
80
+ return item ? `Type.Array(${item})` : null;
81
+ } finally {
82
+ for (const value of values) seen.delete(value);
83
+ }
84
+ }
85
+
86
+ function closedObjectExpression(objects: Record<string, unknown>[], depth: number, seen: WeakSet<object>): string | null {
87
+ for (const value of objects) {
88
+ if (seen.has(value)) return null;
89
+ }
90
+ for (const value of objects) seen.add(value);
91
+ try {
92
+ const keys = [...new Set(objects.flatMap((value) => Object.keys(value)))].sort();
93
+ const properties: string[] = [];
94
+ for (const key of keys) {
95
+ const present = objects.filter((value) => Object.prototype.hasOwnProperty.call(value, key));
96
+ const expression = closedValueExpression(present.map((value) => value[key]), depth + 1, seen);
97
+ if (!expression) return null;
98
+ const rendered = present.length === objects.length ? expression : `Type.Optional(${expression})`;
99
+ properties.push(`${propertyKey(key)}: ${rendered}`);
100
+ }
101
+ const body = properties.length > 0 ? ` ${properties.join(', ')} ` : ' ';
102
+ return `Type.Object({${body}}, { additionalProperties: false })`;
103
+ } finally {
104
+ for (const value of objects) seen.delete(value);
105
+ }
106
+ }
107
+
108
+ export function rememberContractExpression(field: FieldDefinition, expression: string | null): void {
109
+ if (expression) contractExpressions.set(field, expression);
110
+ }
111
+
112
+ export function getContractExpression(field: FieldDefinition): string | undefined {
113
+ return contractExpressions.get(field);
114
+ }