@punica/form 1.2.0 → 2.1.0-next.0
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/dist/controller/index.d.ts +46 -51
- package/dist/decorator/Readers.d.ts +2 -2
- package/dist/decorator/Services.d.ts +2 -2
- package/dist/decorator/Starters.d.ts +2 -2
- package/dist/define/FormItem.d.ts +12 -6
- package/dist/define/FormItemProperty.d.ts +5 -5
- package/dist/define/FormProperty.d.ts +5 -4
- package/dist/define/decorator.d.ts +16 -0
- package/dist/define/index.d.ts +1 -0
- package/dist/index.d.ts +1 -0
- package/dist/index.js +620 -22
- package/dist/index.mjs +572 -0
- package/dist/metadata/index.d.ts +16 -0
- package/dist/model/command/item.d.ts +11 -5
- package/dist/model/command/service.d.ts +25 -10
- package/dist/model/constants/index.d.ts +13 -2
- package/dist/model/form/index.d.ts +9 -4
- package/dist/model/index.d.ts +0 -1
- package/dist/model/item/index.d.ts +41 -12
- package/dist/model/reader/index.d.ts +5 -1
- package/dist/model/service/index.d.ts +28 -10
- package/dist/reader/index.d.ts +10 -17
- package/dist/register/index.d.ts +26 -39
- package/dist/shared.d.ts +20 -0
- package/dist/utils/deepCopy.d.ts +1 -1
- package/dist/utils/devtools.d.ts +11 -70
- package/dist/utils/index.d.ts +2 -1
- package/dist/utils/path.d.ts +10 -0
- package/package.json +21 -11
- package/dist/controller/index.js +0 -238
- package/dist/decorator/Readers.js +0 -15
- package/dist/decorator/Services.js +0 -15
- package/dist/decorator/Starters.js +0 -15
- package/dist/decorator/index.js +0 -19
- package/dist/define/FormItem.js +0 -26
- package/dist/define/FormItemProperty.js +0 -21
- package/dist/define/FormProperty.js +0 -15
- package/dist/define/index.js +0 -12
- package/dist/model/command/index.js +0 -18
- package/dist/model/command/item.js +0 -2
- package/dist/model/command/service.js +0 -2
- package/dist/model/constants/index.js +0 -2
- package/dist/model/form/index.js +0 -2
- package/dist/model/index.js +0 -24
- package/dist/model/item/index.js +0 -2
- package/dist/model/reader/index.js +0 -2
- package/dist/model/service/index.js +0 -2
- package/dist/model/starter/index.js +0 -2
- package/dist/model/util/GetItem.d.ts +0 -9
- package/dist/model/util/GetItem.js +0 -2
- package/dist/model/util/WriteItems.d.ts +0 -8
- package/dist/model/util/WriteItems.js +0 -2
- package/dist/model/util/index.d.ts +0 -2
- package/dist/model/util/index.js +0 -18
- package/dist/reader/decorators/base/index.d.ts +0 -35
- package/dist/reader/decorators/base/index.js +0 -82
- package/dist/reader/decorators/readers/FormItemsReader.d.ts +0 -17
- package/dist/reader/decorators/readers/FormItemsReader.js +0 -42
- package/dist/reader/decorators/readers/ItemDataReader.d.ts +0 -24
- package/dist/reader/decorators/readers/ItemDataReader.js +0 -42
- package/dist/reader/decorators/readers/ItemInitializerReader.d.ts +0 -16
- package/dist/reader/decorators/readers/ItemInitializerReader.js +0 -34
- package/dist/reader/decorators/readers/index.d.ts +0 -3
- package/dist/reader/decorators/readers/index.js +0 -12
- package/dist/reader/index.js +0 -30
- package/dist/reader/reader/Reader.d.ts +0 -13
- package/dist/reader/reader/Reader.js +0 -19
- package/dist/reader/reader/index.d.ts +0 -1
- package/dist/reader/reader/index.js +0 -8
- package/dist/register/index.js +0 -72
- package/dist/utils/deepCopy.js +0 -45
- package/dist/utils/devtools.js +0 -136
- package/dist/utils/index.js +0 -18
package/dist/index.mjs
ADDED
|
@@ -0,0 +1,572 @@
|
|
|
1
|
+
var __typeError = (msg) => {
|
|
2
|
+
throw TypeError(msg);
|
|
3
|
+
};
|
|
4
|
+
var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
|
|
5
|
+
var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
|
|
6
|
+
var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
|
|
7
|
+
var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
|
|
8
|
+
var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
|
|
9
|
+
var __privateWrapper = (obj, member, setter, getter) => ({
|
|
10
|
+
set _(value) {
|
|
11
|
+
__privateSet(obj, member, value, setter);
|
|
12
|
+
},
|
|
13
|
+
get _() {
|
|
14
|
+
return __privateGet(obj, member, getter);
|
|
15
|
+
}
|
|
16
|
+
});
|
|
17
|
+
|
|
18
|
+
// lib/shared.ts
|
|
19
|
+
var KEY = /* @__PURE__ */ Symbol.for("@punica/form");
|
|
20
|
+
var scope = globalThis;
|
|
21
|
+
var shared = scope[KEY] ?? (scope[KEY] = {
|
|
22
|
+
formProperties: /* @__PURE__ */ new WeakMap(),
|
|
23
|
+
formItemProperties: /* @__PURE__ */ new WeakMap(),
|
|
24
|
+
devTools: false,
|
|
25
|
+
usedServices: /* @__PURE__ */ new WeakSet()
|
|
26
|
+
});
|
|
27
|
+
|
|
28
|
+
// lib/metadata/index.ts
|
|
29
|
+
var { formProperties, formItemProperties } = shared;
|
|
30
|
+
var classesOf = (entity) => {
|
|
31
|
+
const classes = [];
|
|
32
|
+
let current = Object.getPrototypeOf(entity);
|
|
33
|
+
while (current && current !== Object.prototype) {
|
|
34
|
+
classes.unshift(current.constructor);
|
|
35
|
+
current = Object.getPrototypeOf(current);
|
|
36
|
+
}
|
|
37
|
+
return classes;
|
|
38
|
+
};
|
|
39
|
+
var setFormProperty = (target, key, data) => {
|
|
40
|
+
if (!formProperties.has(target)) {
|
|
41
|
+
formProperties.set(target, /* @__PURE__ */ new Map());
|
|
42
|
+
}
|
|
43
|
+
formProperties.get(target)?.set(key, data);
|
|
44
|
+
};
|
|
45
|
+
var setFormItemProperty = (target, key, property, data) => {
|
|
46
|
+
if (!formItemProperties.has(target)) {
|
|
47
|
+
formItemProperties.set(target, /* @__PURE__ */ new Map());
|
|
48
|
+
}
|
|
49
|
+
const properties = formItemProperties.get(target);
|
|
50
|
+
properties?.set(key, { ...properties.get(key), [property]: data });
|
|
51
|
+
};
|
|
52
|
+
var getFormProperty = (entity, key) => {
|
|
53
|
+
return classesOf(entity).reduce((found, target) => {
|
|
54
|
+
const properties = formProperties.get(target);
|
|
55
|
+
return properties?.has(key) ? properties.get(key) : found;
|
|
56
|
+
}, void 0);
|
|
57
|
+
};
|
|
58
|
+
var getFormItemProperties = (entity, key) => {
|
|
59
|
+
return classesOf(entity).reduce((found, target) => {
|
|
60
|
+
return {
|
|
61
|
+
...found,
|
|
62
|
+
...formItemProperties.get(target)?.get(key)
|
|
63
|
+
};
|
|
64
|
+
}, {});
|
|
65
|
+
};
|
|
66
|
+
|
|
67
|
+
// lib/register/index.ts
|
|
68
|
+
var _items;
|
|
69
|
+
var FormItemRegister = class {
|
|
70
|
+
constructor() {
|
|
71
|
+
__privateAdd(this, _items, /* @__PURE__ */ new Map());
|
|
72
|
+
}
|
|
73
|
+
/**
|
|
74
|
+
* Registers the renderer of a type. The first registration of a type wins.
|
|
75
|
+
*/
|
|
76
|
+
register(type, renderer) {
|
|
77
|
+
if (!__privateGet(this, _items).has(type)) {
|
|
78
|
+
__privateGet(this, _items).set(type, renderer);
|
|
79
|
+
}
|
|
80
|
+
}
|
|
81
|
+
unregister(type) {
|
|
82
|
+
__privateGet(this, _items).delete(type);
|
|
83
|
+
}
|
|
84
|
+
/** The renderer of a type. */
|
|
85
|
+
getItem(type) {
|
|
86
|
+
return __privateGet(this, _items).get(type);
|
|
87
|
+
}
|
|
88
|
+
/** The registered types. */
|
|
89
|
+
getItemKeys() {
|
|
90
|
+
return [...__privateGet(this, _items).keys()];
|
|
91
|
+
}
|
|
92
|
+
};
|
|
93
|
+
_items = new WeakMap();
|
|
94
|
+
var createFormItemRegister = () => {
|
|
95
|
+
return new FormItemRegister();
|
|
96
|
+
};
|
|
97
|
+
var _a;
|
|
98
|
+
var defaultFormItemRegister = (_a = shared).register ?? (_a.register = createFormItemRegister());
|
|
99
|
+
|
|
100
|
+
// lib/define/decorator.ts
|
|
101
|
+
var propertyDecorator = (register) => {
|
|
102
|
+
return (target, context) => {
|
|
103
|
+
if (typeof context === "object") {
|
|
104
|
+
context.addInitializer(function() {
|
|
105
|
+
register(this.constructor, String(context.name));
|
|
106
|
+
});
|
|
107
|
+
} else {
|
|
108
|
+
register(target.constructor, String(context));
|
|
109
|
+
}
|
|
110
|
+
};
|
|
111
|
+
};
|
|
112
|
+
|
|
113
|
+
// lib/define/FormItem.ts
|
|
114
|
+
var FORM_ITEMS = "form-items";
|
|
115
|
+
var defineFormItem = (type, renderer, options = {}) => {
|
|
116
|
+
(options.register ?? defaultFormItemRegister).register(type, renderer);
|
|
117
|
+
return (data) => propertyDecorator(
|
|
118
|
+
(target, property) => setFormItemProperty(target, FORM_ITEMS, property, { ...data, type })
|
|
119
|
+
);
|
|
120
|
+
};
|
|
121
|
+
var FormItem_default = defineFormItem;
|
|
122
|
+
|
|
123
|
+
// lib/define/FormItemProperty.ts
|
|
124
|
+
var defineFormItemProperty = (key) => {
|
|
125
|
+
return (data) => propertyDecorator(
|
|
126
|
+
(target, property) => setFormItemProperty(target, key, property, data)
|
|
127
|
+
);
|
|
128
|
+
};
|
|
129
|
+
var FormItemProperty_default = defineFormItemProperty;
|
|
130
|
+
|
|
131
|
+
// lib/define/FormProperty.ts
|
|
132
|
+
var defineFormProperty = (key) => {
|
|
133
|
+
return (data) => (target) => setFormProperty(target, key, data);
|
|
134
|
+
};
|
|
135
|
+
var FormProperty_default = defineFormProperty;
|
|
136
|
+
|
|
137
|
+
// lib/decorator/Readers.ts
|
|
138
|
+
var DECORATOR_READERS = "form-readers";
|
|
139
|
+
var Readers = (data) => {
|
|
140
|
+
return FormProperty_default(DECORATOR_READERS)(data);
|
|
141
|
+
};
|
|
142
|
+
|
|
143
|
+
// lib/decorator/Starters.ts
|
|
144
|
+
var DECORATOR_STARTERS = "form-starters";
|
|
145
|
+
var Starters = (data) => {
|
|
146
|
+
return FormProperty_default(DECORATOR_STARTERS)(data);
|
|
147
|
+
};
|
|
148
|
+
|
|
149
|
+
// lib/decorator/Services.ts
|
|
150
|
+
var DECORATOR_SERVICES = "form-services";
|
|
151
|
+
var Services = (data) => {
|
|
152
|
+
return FormProperty_default(DECORATOR_SERVICES)(data);
|
|
153
|
+
};
|
|
154
|
+
|
|
155
|
+
// lib/reader/index.ts
|
|
156
|
+
var createInitialReader = () => ({
|
|
157
|
+
async read(entity, form) {
|
|
158
|
+
form.services = getFormProperty(entity, DECORATOR_SERVICES);
|
|
159
|
+
form.readers = getFormProperty(entity, DECORATOR_READERS);
|
|
160
|
+
form.starters = getFormProperty(entity, DECORATOR_STARTERS);
|
|
161
|
+
const definitions = getFormItemProperties(entity, FORM_ITEMS);
|
|
162
|
+
const properties = /* @__PURE__ */ new Set([
|
|
163
|
+
...Object.keys(entity).filter((property) => definitions[property]),
|
|
164
|
+
...Object.keys(definitions)
|
|
165
|
+
]);
|
|
166
|
+
form.items = [...properties].map((property) => {
|
|
167
|
+
const item = { ...definitions[property], property };
|
|
168
|
+
return {
|
|
169
|
+
...item,
|
|
170
|
+
value: item.path ? readPropertyPath(entity, item.path) : entity[property]
|
|
171
|
+
};
|
|
172
|
+
});
|
|
173
|
+
const getItem = (property) => {
|
|
174
|
+
return form.items.find((item) => item.property === property);
|
|
175
|
+
};
|
|
176
|
+
for (const { property, initialize } of form.items) {
|
|
177
|
+
if (!initialize) continue;
|
|
178
|
+
const initialized = await initialize({
|
|
179
|
+
formItem: getItem(property),
|
|
180
|
+
initialEntity: entity,
|
|
181
|
+
getItem
|
|
182
|
+
});
|
|
183
|
+
for (const item of initialized) {
|
|
184
|
+
const index = form.items.findIndex((i) => i.property === item.property);
|
|
185
|
+
if (index >= 0) form.items[index] = item;
|
|
186
|
+
}
|
|
187
|
+
}
|
|
188
|
+
}
|
|
189
|
+
});
|
|
190
|
+
|
|
191
|
+
// lib/utils/devtools.ts
|
|
192
|
+
var DEVTOOLS_MESSAGE_SOURCE = "punica-form-devtools";
|
|
193
|
+
var DEVTOOLS_PROTOCOL_VERSION = 2;
|
|
194
|
+
var enableDevTools = () => {
|
|
195
|
+
shared.devTools = true;
|
|
196
|
+
};
|
|
197
|
+
var disableDevTools = () => {
|
|
198
|
+
shared.devTools = false;
|
|
199
|
+
};
|
|
200
|
+
var isDevToolsEnabled = () => {
|
|
201
|
+
return shared.devTools && typeof window !== "undefined";
|
|
202
|
+
};
|
|
203
|
+
var sendToDevTools = (formId, type, data, formItemKey) => {
|
|
204
|
+
if (!isDevToolsEnabled()) {
|
|
205
|
+
return;
|
|
206
|
+
}
|
|
207
|
+
try {
|
|
208
|
+
window.postMessage(
|
|
209
|
+
{
|
|
210
|
+
source: DEVTOOLS_MESSAGE_SOURCE,
|
|
211
|
+
version: DEVTOOLS_PROTOCOL_VERSION,
|
|
212
|
+
formId,
|
|
213
|
+
type,
|
|
214
|
+
data: JSON.stringify(data),
|
|
215
|
+
formItemKey
|
|
216
|
+
},
|
|
217
|
+
window.location.origin
|
|
218
|
+
);
|
|
219
|
+
} catch {
|
|
220
|
+
}
|
|
221
|
+
};
|
|
222
|
+
|
|
223
|
+
// lib/controller/index.ts
|
|
224
|
+
var formCount = 0;
|
|
225
|
+
var _form, _initialItems, _itemsMap, _services, _started, _batching, _dirty, _epoch, _writes, _subscribers, _listeners, _initialEntity, _register, _name, _FormController_instances, mapItems_fn, _getItem, _setItems, notify_fn, _supersede, _emit, _createCommandItem, _createCommandService, sendEntityToDevTools_fn;
|
|
226
|
+
var _FormController = class _FormController {
|
|
227
|
+
constructor(form, entity, options) {
|
|
228
|
+
__privateAdd(this, _FormController_instances);
|
|
229
|
+
__privateAdd(this, _form);
|
|
230
|
+
__privateAdd(this, _initialItems, []);
|
|
231
|
+
__privateAdd(this, _itemsMap, /* @__PURE__ */ new Map());
|
|
232
|
+
/** The services of the form, by their class. */
|
|
233
|
+
__privateAdd(this, _services, /* @__PURE__ */ new Map());
|
|
234
|
+
__privateAdd(this, _started, false);
|
|
235
|
+
__privateAdd(this, _batching, 0);
|
|
236
|
+
__privateAdd(this, _dirty, false);
|
|
237
|
+
__privateAdd(this, _epoch, 0);
|
|
238
|
+
__privateAdd(this, _writes, /* @__PURE__ */ new Map());
|
|
239
|
+
__privateAdd(this, _subscribers, /* @__PURE__ */ new Set());
|
|
240
|
+
__privateAdd(this, _listeners, /* @__PURE__ */ new Map());
|
|
241
|
+
__privateAdd(this, _initialEntity);
|
|
242
|
+
__privateAdd(this, _register);
|
|
243
|
+
__privateAdd(this, _name);
|
|
244
|
+
/**
|
|
245
|
+
* The current form. A form object is never changed once it is returned:
|
|
246
|
+
* after `start()` and after every change this returns a new object.
|
|
247
|
+
*/
|
|
248
|
+
this.getForm = () => {
|
|
249
|
+
return __privateGet(this, _form);
|
|
250
|
+
};
|
|
251
|
+
/**
|
|
252
|
+
* Calls the listener after every change of the form.
|
|
253
|
+
* @returns A function that removes the listener
|
|
254
|
+
*/
|
|
255
|
+
this.subscribe = (listener) => {
|
|
256
|
+
__privateGet(this, _subscribers).add(listener);
|
|
257
|
+
return () => __privateGet(this, _subscribers).delete(listener);
|
|
258
|
+
};
|
|
259
|
+
/**
|
|
260
|
+
* Runs changes as one: subscribers and UPDATE_FORM listeners are notified
|
|
261
|
+
* once, after the function returned or the promise it returned settled.
|
|
262
|
+
*/
|
|
263
|
+
this.batch = (change) => {
|
|
264
|
+
const done = () => {
|
|
265
|
+
if (--__privateWrapper(this, _batching)._ === 0 && __privateGet(this, _dirty)) {
|
|
266
|
+
__privateSet(this, _dirty, false);
|
|
267
|
+
__privateMethod(this, _FormController_instances, notify_fn).call(this);
|
|
268
|
+
}
|
|
269
|
+
};
|
|
270
|
+
__privateWrapper(this, _batching)._++;
|
|
271
|
+
try {
|
|
272
|
+
const result = change();
|
|
273
|
+
if (result instanceof Promise) {
|
|
274
|
+
return result.finally(done);
|
|
275
|
+
}
|
|
276
|
+
done();
|
|
277
|
+
return result;
|
|
278
|
+
} catch (error) {
|
|
279
|
+
done();
|
|
280
|
+
throw error;
|
|
281
|
+
}
|
|
282
|
+
};
|
|
283
|
+
__privateAdd(this, _getItem, (property) => {
|
|
284
|
+
const index = __privateGet(this, _itemsMap).get(property);
|
|
285
|
+
return index === void 0 ? void 0 : __privateGet(this, _form).items[index];
|
|
286
|
+
});
|
|
287
|
+
/** The only place the form changes after it was started. */
|
|
288
|
+
__privateAdd(this, _setItems, (items) => {
|
|
289
|
+
const next = [...__privateGet(this, _form).items];
|
|
290
|
+
let changed = false;
|
|
291
|
+
for (const item of items) {
|
|
292
|
+
const index = __privateGet(this, _itemsMap).get(item.property);
|
|
293
|
+
if (index !== void 0) {
|
|
294
|
+
next[index] = item;
|
|
295
|
+
changed = true;
|
|
296
|
+
}
|
|
297
|
+
}
|
|
298
|
+
if (!changed) {
|
|
299
|
+
return;
|
|
300
|
+
}
|
|
301
|
+
__privateSet(this, _form, { ...__privateGet(this, _form), items: next });
|
|
302
|
+
if (__privateGet(this, _batching)) {
|
|
303
|
+
__privateSet(this, _dirty, true);
|
|
304
|
+
} else {
|
|
305
|
+
__privateMethod(this, _FormController_instances, notify_fn).call(this);
|
|
306
|
+
}
|
|
307
|
+
});
|
|
308
|
+
__privateAdd(this, _supersede, (property) => {
|
|
309
|
+
if (property === void 0) {
|
|
310
|
+
__privateWrapper(this, _epoch)._++;
|
|
311
|
+
} else {
|
|
312
|
+
__privateGet(this, _writes).set(property, (__privateGet(this, _writes).get(property) ?? 0) + 1);
|
|
313
|
+
}
|
|
314
|
+
const epoch = __privateGet(this, _epoch);
|
|
315
|
+
const write = property === void 0 ? 0 : __privateGet(this, _writes).get(property);
|
|
316
|
+
return () => epoch === __privateGet(this, _epoch) && (property === void 0 || write === __privateGet(this, _writes).get(property));
|
|
317
|
+
});
|
|
318
|
+
__privateAdd(this, _emit, (event, payload) => {
|
|
319
|
+
__privateGet(this, _listeners).get(event)?.forEach((handler) => handler(payload));
|
|
320
|
+
if (event === "UPDATE_ITEM") {
|
|
321
|
+
for (const item of payload) {
|
|
322
|
+
sendToDevTools(__privateGet(this, _name), event, item, String(item.property));
|
|
323
|
+
}
|
|
324
|
+
} else {
|
|
325
|
+
sendToDevTools(__privateGet(this, _name), event, payload);
|
|
326
|
+
}
|
|
327
|
+
});
|
|
328
|
+
__privateAdd(this, _createCommandItem, (item) => {
|
|
329
|
+
const features = [...__privateGet(this, _services).values()].reduce(
|
|
330
|
+
(all, service) => ({
|
|
331
|
+
...all,
|
|
332
|
+
...service.addCustomFeaturesForCommandItem?.()
|
|
333
|
+
}),
|
|
334
|
+
{}
|
|
335
|
+
);
|
|
336
|
+
return {
|
|
337
|
+
...features,
|
|
338
|
+
formItem: { ...item },
|
|
339
|
+
initialEntity: __privateGet(this, _initialEntity),
|
|
340
|
+
getItem: (property) => {
|
|
341
|
+
const found = __privateGet(this, _getItem).call(this, property);
|
|
342
|
+
return found && { ...found };
|
|
343
|
+
}
|
|
344
|
+
};
|
|
345
|
+
});
|
|
346
|
+
__privateAdd(this, _createCommandService, () => ({
|
|
347
|
+
initialEntity: __privateGet(this, _initialEntity),
|
|
348
|
+
getForm: this.getForm,
|
|
349
|
+
getInitialItems: () => __privateGet(this, _initialItems),
|
|
350
|
+
getItem: __privateGet(this, _getItem),
|
|
351
|
+
setItems: __privateGet(this, _setItems),
|
|
352
|
+
supersede: __privateGet(this, _supersede),
|
|
353
|
+
emit: __privateGet(this, _emit),
|
|
354
|
+
createCommandItem: __privateGet(this, _createCommandItem)
|
|
355
|
+
}));
|
|
356
|
+
__privateSet(this, _form, form);
|
|
357
|
+
__privateSet(this, _initialEntity, entity);
|
|
358
|
+
__privateSet(this, _register, options.register ?? defaultFormItemRegister);
|
|
359
|
+
__privateSet(this, _name, `${options.name ?? entity.constructor.name}#${++formCount}`);
|
|
360
|
+
}
|
|
361
|
+
/**
|
|
362
|
+
* Creates a controller for a form that is described as data.
|
|
363
|
+
*/
|
|
364
|
+
static async fromForm(form, options = {}) {
|
|
365
|
+
return new _FormController(form, {}, {
|
|
366
|
+
name: "Form",
|
|
367
|
+
...options
|
|
368
|
+
});
|
|
369
|
+
}
|
|
370
|
+
/**
|
|
371
|
+
* Creates a controller for an instance of a decorated form class.
|
|
372
|
+
*/
|
|
373
|
+
static async fromEntity(entity, options = {}) {
|
|
374
|
+
const form = { items: [] };
|
|
375
|
+
await createInitialReader().read(entity, form);
|
|
376
|
+
return new _FormController(form, entity, options);
|
|
377
|
+
}
|
|
378
|
+
/**
|
|
379
|
+
* Listens to an event of the form.
|
|
380
|
+
* @returns A function that removes the handler
|
|
381
|
+
*/
|
|
382
|
+
on(event, handler) {
|
|
383
|
+
const handlers = __privateGet(this, _listeners).get(event) ?? /* @__PURE__ */ new Set();
|
|
384
|
+
__privateGet(this, _listeners).set(event, handlers.add(handler));
|
|
385
|
+
return () => handlers.delete(handler);
|
|
386
|
+
}
|
|
387
|
+
/**
|
|
388
|
+
* The service of a class listed in `@Services`, or of a subclass of it.
|
|
389
|
+
* @throws When the form is not started yet or has no service of the class
|
|
390
|
+
*/
|
|
391
|
+
getService(service) {
|
|
392
|
+
if (!__privateGet(this, _started)) {
|
|
393
|
+
throw new Error(
|
|
394
|
+
`Services are available after start(): ${service.name} was read too early.`
|
|
395
|
+
);
|
|
396
|
+
}
|
|
397
|
+
const instance = __privateGet(this, _services).get(service) ?? [...__privateGet(this, _services).values()].find((other) => other instanceof service);
|
|
398
|
+
if (!instance) {
|
|
399
|
+
throw new Error(
|
|
400
|
+
`Service not found: ${service.name}. Add it to @Services.`
|
|
401
|
+
);
|
|
402
|
+
}
|
|
403
|
+
return instance;
|
|
404
|
+
}
|
|
405
|
+
/**
|
|
406
|
+
* Starts the form: runs its readers and starters and initializes its
|
|
407
|
+
* services.
|
|
408
|
+
* @returns The form
|
|
409
|
+
*/
|
|
410
|
+
async start() {
|
|
411
|
+
__privateGet(this, _emit).call(this, "REGISTER_ITEMS", __privateGet(this, _register).getItemKeys());
|
|
412
|
+
let form = { ...__privateGet(this, _form), items: [...__privateGet(this, _form).items] };
|
|
413
|
+
for (const reader of form.readers ?? []) {
|
|
414
|
+
await reader.read(__privateGet(this, _initialEntity), form);
|
|
415
|
+
}
|
|
416
|
+
for (const starter of form.starters ?? []) {
|
|
417
|
+
form = await starter.run(form, __privateGet(this, _initialEntity));
|
|
418
|
+
}
|
|
419
|
+
__privateSet(this, _form, form);
|
|
420
|
+
__privateMethod(this, _FormController_instances, mapItems_fn).call(this);
|
|
421
|
+
const command = __privateGet(this, _createCommandService).call(this);
|
|
422
|
+
for (const entry of form.services ?? []) {
|
|
423
|
+
const service = typeof entry === "function" ? new entry() : entry;
|
|
424
|
+
if (typeof entry !== "function") {
|
|
425
|
+
if (shared.usedServices.has(service)) {
|
|
426
|
+
console.warn(
|
|
427
|
+
`[punica-form] The same ${service.constructor.name} instance is used by more than one form. Pass the class to @Services instead.`
|
|
428
|
+
);
|
|
429
|
+
}
|
|
430
|
+
shared.usedServices.add(service);
|
|
431
|
+
}
|
|
432
|
+
__privateGet(this, _services).set(service.constructor, service);
|
|
433
|
+
await service.initialize?.(
|
|
434
|
+
command
|
|
435
|
+
);
|
|
436
|
+
}
|
|
437
|
+
__privateSet(this, _initialItems, deepCopy(__privateGet(this, _form).items));
|
|
438
|
+
__privateSet(this, _started, true);
|
|
439
|
+
sendToDevTools(__privateGet(this, _name), "@@INIT", __privateGet(this, _form));
|
|
440
|
+
__privateMethod(this, _FormController_instances, notify_fn).call(this);
|
|
441
|
+
return __privateGet(this, _form);
|
|
442
|
+
}
|
|
443
|
+
};
|
|
444
|
+
_form = new WeakMap();
|
|
445
|
+
_initialItems = new WeakMap();
|
|
446
|
+
_itemsMap = new WeakMap();
|
|
447
|
+
_services = new WeakMap();
|
|
448
|
+
_started = new WeakMap();
|
|
449
|
+
_batching = new WeakMap();
|
|
450
|
+
_dirty = new WeakMap();
|
|
451
|
+
_epoch = new WeakMap();
|
|
452
|
+
_writes = new WeakMap();
|
|
453
|
+
_subscribers = new WeakMap();
|
|
454
|
+
_listeners = new WeakMap();
|
|
455
|
+
_initialEntity = new WeakMap();
|
|
456
|
+
_register = new WeakMap();
|
|
457
|
+
_name = new WeakMap();
|
|
458
|
+
_FormController_instances = new WeakSet();
|
|
459
|
+
mapItems_fn = function() {
|
|
460
|
+
__privateSet(this, _itemsMap, new Map(
|
|
461
|
+
__privateGet(this, _form).items.map((item, index) => [item.property, index])
|
|
462
|
+
));
|
|
463
|
+
};
|
|
464
|
+
_getItem = new WeakMap();
|
|
465
|
+
_setItems = new WeakMap();
|
|
466
|
+
/** Tells everyone who follows the form that it changed. */
|
|
467
|
+
notify_fn = function() {
|
|
468
|
+
__privateGet(this, _subscribers).forEach((listener) => listener());
|
|
469
|
+
__privateGet(this, _emit).call(this, "UPDATE_FORM", __privateGet(this, _form));
|
|
470
|
+
__privateMethod(this, _FormController_instances, sendEntityToDevTools_fn).call(this);
|
|
471
|
+
};
|
|
472
|
+
_supersede = new WeakMap();
|
|
473
|
+
_emit = new WeakMap();
|
|
474
|
+
_createCommandItem = new WeakMap();
|
|
475
|
+
_createCommandService = new WeakMap();
|
|
476
|
+
/** Developer tools show the entity as the `getValues` service returns it. */
|
|
477
|
+
sendEntityToDevTools_fn = function() {
|
|
478
|
+
if (!isDevToolsEnabled()) {
|
|
479
|
+
return;
|
|
480
|
+
}
|
|
481
|
+
const getValues = [...__privateGet(this, _services).values()].find(
|
|
482
|
+
(service) => service.name === "getValues"
|
|
483
|
+
);
|
|
484
|
+
getValues?.run().then((entity) => sendToDevTools(__privateGet(this, _name), "ENTITY", entity)).catch(() => void 0);
|
|
485
|
+
};
|
|
486
|
+
var FormController = _FormController;
|
|
487
|
+
|
|
488
|
+
// lib/utils/deepCopy.ts
|
|
489
|
+
var deepCopy = (value, seen = /* @__PURE__ */ new WeakMap()) => {
|
|
490
|
+
if (typeof value !== "object" || value === null) {
|
|
491
|
+
return value;
|
|
492
|
+
}
|
|
493
|
+
if (seen.has(value)) {
|
|
494
|
+
return seen.get(value);
|
|
495
|
+
}
|
|
496
|
+
if (value instanceof Date) {
|
|
497
|
+
return new Date(value.getTime());
|
|
498
|
+
}
|
|
499
|
+
if (value instanceof RegExp) {
|
|
500
|
+
return new RegExp(value.source, value.flags);
|
|
501
|
+
}
|
|
502
|
+
if (value instanceof Map) {
|
|
503
|
+
const copy2 = /* @__PURE__ */ new Map();
|
|
504
|
+
seen.set(value, copy2);
|
|
505
|
+
value.forEach((v, k) => copy2.set(deepCopy(k, seen), deepCopy(v, seen)));
|
|
506
|
+
return copy2;
|
|
507
|
+
}
|
|
508
|
+
if (value instanceof Set) {
|
|
509
|
+
const copy2 = /* @__PURE__ */ new Set();
|
|
510
|
+
seen.set(value, copy2);
|
|
511
|
+
value.forEach((v) => copy2.add(deepCopy(v, seen)));
|
|
512
|
+
return copy2;
|
|
513
|
+
}
|
|
514
|
+
const copy = Array.isArray(value) ? [] : Object.create(Object.getPrototypeOf(value));
|
|
515
|
+
seen.set(value, copy);
|
|
516
|
+
for (const key of Object.keys(value)) {
|
|
517
|
+
copy[key] = deepCopy(value[key], seen);
|
|
518
|
+
}
|
|
519
|
+
return copy;
|
|
520
|
+
};
|
|
521
|
+
|
|
522
|
+
// lib/utils/path.ts
|
|
523
|
+
var keysOf = (path) => path.split("/").filter(Boolean);
|
|
524
|
+
var isIndex = (key) => /^\d+$/.test(key);
|
|
525
|
+
var readPropertyPath = (entity, path) => {
|
|
526
|
+
let value = entity;
|
|
527
|
+
for (const key of keysOf(path)) {
|
|
528
|
+
if (!value || typeof value !== "object" || !(key in value)) {
|
|
529
|
+
return void 0;
|
|
530
|
+
}
|
|
531
|
+
value = value[key];
|
|
532
|
+
}
|
|
533
|
+
return value;
|
|
534
|
+
};
|
|
535
|
+
var writeToPropertyPath = (entity, path, value) => {
|
|
536
|
+
const keys = keysOf(path);
|
|
537
|
+
let current = entity;
|
|
538
|
+
keys.forEach((key, index) => {
|
|
539
|
+
if (index === keys.length - 1) {
|
|
540
|
+
current[key] = value;
|
|
541
|
+
} else {
|
|
542
|
+
current[key] ?? (current[key] = isIndex(keys[index + 1]) ? [] : {});
|
|
543
|
+
current = current[key];
|
|
544
|
+
}
|
|
545
|
+
});
|
|
546
|
+
};
|
|
547
|
+
export {
|
|
548
|
+
DECORATOR_READERS,
|
|
549
|
+
DECORATOR_SERVICES,
|
|
550
|
+
DECORATOR_STARTERS,
|
|
551
|
+
DEVTOOLS_MESSAGE_SOURCE,
|
|
552
|
+
DEVTOOLS_PROTOCOL_VERSION,
|
|
553
|
+
FormController,
|
|
554
|
+
FormItemRegister,
|
|
555
|
+
Readers,
|
|
556
|
+
Services,
|
|
557
|
+
Starters,
|
|
558
|
+
createFormItemRegister,
|
|
559
|
+
createInitialReader,
|
|
560
|
+
deepCopy,
|
|
561
|
+
defaultFormItemRegister,
|
|
562
|
+
FormItem_default as defineFormItem,
|
|
563
|
+
FormItemProperty_default as defineFormItemProperty,
|
|
564
|
+
FormProperty_default as defineFormProperty,
|
|
565
|
+
disableDevTools,
|
|
566
|
+
enableDevTools,
|
|
567
|
+
getFormItemProperties,
|
|
568
|
+
getFormProperty,
|
|
569
|
+
isDevToolsEnabled,
|
|
570
|
+
readPropertyPath,
|
|
571
|
+
writeToPropertyPath
|
|
572
|
+
};
|
|
@@ -0,0 +1,16 @@
|
|
|
1
|
+
export declare const setFormProperty: (target: object, key: string, data: unknown) => void;
|
|
2
|
+
export declare const setFormItemProperty: (target: object, key: string, property: string, data: unknown) => void;
|
|
3
|
+
/**
|
|
4
|
+
* Reads what a decorator created with `defineFormProperty` stored on the
|
|
5
|
+
* class of the entity. A class overrides its base classes.
|
|
6
|
+
* @param entity - An instance of the form class
|
|
7
|
+
* @param key - The key the decorator was defined with
|
|
8
|
+
*/
|
|
9
|
+
export declare const getFormProperty: <T>(entity: object, key: string) => T | undefined;
|
|
10
|
+
/**
|
|
11
|
+
* Reads what a decorator created with `defineFormItemProperty` stored for
|
|
12
|
+
* the properties of the entity, keyed by property name.
|
|
13
|
+
* @param entity - An instance of the form class
|
|
14
|
+
* @param key - The key the decorator was defined with
|
|
15
|
+
*/
|
|
16
|
+
export declare const getFormItemProperties: <T>(entity: object, key: string) => Record<string, T>;
|
|
@@ -1,7 +1,13 @@
|
|
|
1
1
|
import { FormItem } from '..';
|
|
2
|
-
|
|
2
|
+
/**
|
|
3
|
+
* What the functions of a form item (initialize, control, validation) receive.
|
|
4
|
+
* `C` holds the features services add, such as the functions of `Store`.
|
|
5
|
+
*/
|
|
6
|
+
export type CommandItem<E, F extends FormItem<E>, C = Record<string, unknown>> = {
|
|
7
|
+
/** A copy of the item the function belongs to. */
|
|
3
8
|
formItem: F;
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
9
|
+
/** The entity the form was created from. */
|
|
10
|
+
initialEntity: E;
|
|
11
|
+
/** A copy of another item of the form. */
|
|
12
|
+
getItem: (property: keyof E) => F | undefined;
|
|
13
|
+
} & C;
|
|
@@ -1,15 +1,30 @@
|
|
|
1
|
-
import { Form,
|
|
2
|
-
import { CommandItem } from '.';
|
|
1
|
+
import { CommandItem, Form, FormEventMap, FormItem } from '..';
|
|
3
2
|
/**
|
|
4
|
-
*
|
|
3
|
+
* What a service receives when it is initialized: the only way to read and
|
|
4
|
+
* change the state of the form.
|
|
5
5
|
*/
|
|
6
6
|
export type CommandService<E, F extends FormItem<E>> = {
|
|
7
|
-
|
|
7
|
+
/** The entity the form was created from. */
|
|
8
8
|
initialEntity: E;
|
|
9
|
-
form
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
|
|
14
|
-
|
|
9
|
+
/** The current form. */
|
|
10
|
+
getForm: () => Form<E, F>;
|
|
11
|
+
/** The items as they were when the form was started. */
|
|
12
|
+
getInitialItems: () => F[];
|
|
13
|
+
/** The current item of a property. */
|
|
14
|
+
getItem: (property: keyof E) => F | undefined;
|
|
15
|
+
/**
|
|
16
|
+
* Replaces the items with the same properties. The form gets a new
|
|
17
|
+
* reference and UPDATE_FORM is fired. Unknown properties are ignored.
|
|
18
|
+
*/
|
|
19
|
+
setItems: (items: Array<FormItem<E>>) => void;
|
|
20
|
+
/**
|
|
21
|
+
* Marks the pending asynchronous writes of a property, or of the whole
|
|
22
|
+
* form when no property is given, as superseded by a newer one.
|
|
23
|
+
* @returns A function that tells whether this write is still the newest
|
|
24
|
+
*/
|
|
25
|
+
supersede: (property?: keyof E) => () => boolean;
|
|
26
|
+
/** Fires an event of the controller. */
|
|
27
|
+
emit: <K extends keyof FormEventMap<E, F>>(event: K, payload: FormEventMap<E, F>[K]) => void;
|
|
28
|
+
/** Creates what the functions of a form item receive. */
|
|
29
|
+
createCommandItem: (item: F) => CommandItem<E, F>;
|
|
15
30
|
};
|
|
@@ -1,4 +1,15 @@
|
|
|
1
|
+
import { Form, FormItem } from '..';
|
|
1
2
|
/**
|
|
2
|
-
*
|
|
3
|
+
* The events of a form controller, mapped to the payload of each event.
|
|
3
4
|
*/
|
|
4
|
-
export type
|
|
5
|
+
export type FormEventMap<E, F extends FormItem<E>> = {
|
|
6
|
+
/** The form changed. Fired after every change of the state. */
|
|
7
|
+
UPDATE_FORM: Form<E, F>;
|
|
8
|
+
/** The form was reset to its initial state. Fired after UPDATE_FORM. */
|
|
9
|
+
RESET: Form<E, F>;
|
|
10
|
+
/** A value was set: the changed item, then the items its control returned. */
|
|
11
|
+
UPDATE_ITEM: F[];
|
|
12
|
+
/** The registered form item types. Fired at the beginning of start(). */
|
|
13
|
+
REGISTER_ITEMS: string[];
|
|
14
|
+
};
|
|
15
|
+
export type FormEvents = keyof FormEventMap<unknown, FormItem<unknown>>;
|
|
@@ -1,8 +1,13 @@
|
|
|
1
1
|
import { FormItem, IReader, IService, IStarter } from '../..';
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
|
|
2
|
+
/**
|
|
3
|
+
* The state of a form. Readers and starters may attach their own properties
|
|
4
|
+
* (a title, a layout, …), which are read back as `unknown`.
|
|
5
|
+
*/
|
|
6
|
+
export type Form<E, F extends FormItem<E> = FormItem<E>> = {
|
|
7
|
+
items: F[];
|
|
8
|
+
/** Service classes (one instance per form) or instances. */
|
|
9
|
+
services?: Array<IService | (new () => IService)>;
|
|
5
10
|
readers?: Array<IReader<E, F>>;
|
|
6
11
|
starters?: Array<IStarter<E, F>>;
|
|
7
|
-
[key: string]:
|
|
12
|
+
[key: string]: unknown;
|
|
8
13
|
};
|
package/dist/model/index.d.ts
CHANGED