@azrico/webobject 1.0.32 → 1.0.35
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/index.js +1 -1
- package/dist/src/WebObjects/ParentWebObject.js +15 -1
- package/dist/src/WebObjects/WebObject.d.ts +4 -16
- package/dist/src/WebObjects/WebObject.js +88 -15
- package/dist/src/WebObjects/WebObjectManager.d.ts +16 -1
- package/dist/src/WebObjects/WebObjectManager.js +71 -3
- package/dist/src/index.js +8 -1
- package/dist/src/structs/DummyObject.js +8 -1
- package/dist/src/structs/MapableObject.js +72 -2
- package/dist/src/structs/MetaObject.js +35 -1
- package/dist/src/structs/ObjectArray.js +43 -1
- package/dist/src/structs/ObjectManager.d.ts +3 -0
- package/dist/src/structs/ObjectManager.js +197 -7
- package/dist/src/structs/SimpleObject.d.ts +2 -1
- package/dist/src/structs/SimpleObject.js +424 -13
- package/package.json +1 -1
|
@@ -1,28 +1,439 @@
|
|
|
1
|
-
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
|
|
1
|
+
import { gcache, gfunc } from "@azrico/global";
|
|
2
|
+
import { object_clone, object_equals, object_isEmpty, object_isTrue, object_removeKeys, prop_rn, } from "@azrico/object";
|
|
3
|
+
import { MapableObject } from "./MapableObject";
|
|
4
|
+
import ObjectManager from "./ObjectManager";
|
|
5
|
+
import { combine_if_not_blank } from "@azrico/string";
|
|
6
|
+
export class SimpleObject extends MapableObject {
|
|
7
|
+
static __cache_name;
|
|
8
|
+
static __unchangeables;
|
|
9
|
+
static __changeables;
|
|
10
|
+
__originalobject;
|
|
11
|
+
//changes
|
|
12
|
+
__delta;
|
|
13
|
+
__changed = false;
|
|
14
|
+
__lastChanged = "";
|
|
15
|
+
__is_readonly;
|
|
16
|
+
__is_edit_mode;
|
|
17
|
+
//errors
|
|
18
|
+
__errors;
|
|
19
|
+
__showErrors;
|
|
20
|
+
//save results
|
|
21
|
+
__saveResultObject;
|
|
22
|
+
__saveResultIsSuccess;
|
|
23
|
+
__saveResultType;
|
|
24
|
+
//sequence key
|
|
25
|
+
_index_key;
|
|
26
|
+
//sequence value , used to index the object with increasing numbers
|
|
27
|
+
_index_value;
|
|
28
|
+
constructor(isEditMode = true, is_readonly = false) {
|
|
29
|
+
super();
|
|
30
|
+
this.__delta = {};
|
|
31
|
+
this.__is_edit_mode = isEditMode;
|
|
32
|
+
this.__is_readonly = is_readonly || !this.__is_edit_mode;
|
|
33
|
+
this.clear_changes();
|
|
34
|
+
}
|
|
35
|
+
/* -------------------------------------------------------------------------- */
|
|
36
|
+
/* Load */
|
|
37
|
+
/* -------------------------------------------------------------------------- */
|
|
38
|
+
loadValues(initObject, fullUpdate = false) {
|
|
39
|
+
SimpleObject.loadValues(this, initObject, fullUpdate);
|
|
40
|
+
return true;
|
|
41
|
+
}
|
|
42
|
+
static loadValues(obj, initObject, fullUpdate = false) {
|
|
43
|
+
SimpleObject.factoryClear(obj);
|
|
44
|
+
if (initObject == null) {
|
|
45
|
+
for (const key in obj) {
|
|
46
|
+
if (key.startsWith("__"))
|
|
47
|
+
continue;
|
|
48
|
+
delete obj[key];
|
|
49
|
+
}
|
|
50
|
+
}
|
|
51
|
+
else if (typeof initObject == "object") {
|
|
52
|
+
for (const key in initObject) {
|
|
53
|
+
if (key.startsWith("__"))
|
|
54
|
+
continue;
|
|
55
|
+
if (fullUpdate ||
|
|
56
|
+
Object.prototype.hasOwnProperty.call(obj, key)) {
|
|
57
|
+
obj[key] = initObject[key];
|
|
58
|
+
}
|
|
59
|
+
}
|
|
60
|
+
}
|
|
61
|
+
return true;
|
|
62
|
+
}
|
|
63
|
+
/* -------------------------------------------------------------------------- */
|
|
64
|
+
static getValue(o, key, original = false) {
|
|
65
|
+
if (o instanceof SimpleObject && typeof o.getValue === "function")
|
|
66
|
+
return o.getValue(key, original);
|
|
67
|
+
if (!original && o.__delta[key])
|
|
68
|
+
return o.__delta[key];
|
|
69
|
+
return o[key];
|
|
70
|
+
}
|
|
71
|
+
getValue(key, original = false) {
|
|
72
|
+
if (!original && this.__delta[key])
|
|
73
|
+
return this.__delta[key];
|
|
74
|
+
return this[key];
|
|
75
|
+
}
|
|
76
|
+
get(key, original = false) {
|
|
77
|
+
return this.getValue(key, original);
|
|
78
|
+
}
|
|
79
|
+
/**
|
|
7
80
|
* set value
|
|
8
81
|
* @param key
|
|
9
82
|
* @param value
|
|
10
83
|
* @return true if changed , false otherwise
|
|
11
|
-
*/
|
|
84
|
+
*/
|
|
85
|
+
setValue(key, value) {
|
|
86
|
+
if (!this.canModify)
|
|
87
|
+
throw Error("Cant use setValue when on readonly mode");
|
|
88
|
+
let isValueChanged = false;
|
|
89
|
+
try {
|
|
90
|
+
const oldval = this.getValue(key);
|
|
91
|
+
if (!object_equals(oldval, value, { ignoredStartingWords: "_" })) {
|
|
92
|
+
this.__delta[key] = value;
|
|
93
|
+
isValueChanged = true;
|
|
94
|
+
}
|
|
95
|
+
else
|
|
96
|
+
isValueChanged = false;
|
|
97
|
+
}
|
|
98
|
+
finally {
|
|
99
|
+
if (isValueChanged) {
|
|
100
|
+
this.notifyChanged("", key, value);
|
|
101
|
+
}
|
|
102
|
+
}
|
|
103
|
+
return isValueChanged;
|
|
104
|
+
}
|
|
105
|
+
/**
|
|
12
106
|
* set key of subObject
|
|
13
107
|
* @param key
|
|
14
108
|
* @param value
|
|
15
109
|
* @param subvalue
|
|
16
110
|
* @return true if changed , false otherwise
|
|
17
|
-
*/
|
|
18
|
-
|
|
111
|
+
*/
|
|
112
|
+
setSubValue(key, objKey, subvalue) {
|
|
113
|
+
if (!this.canModify)
|
|
114
|
+
throw Error("Cant use setValue when on readonly mode");
|
|
115
|
+
let isValueChanged = false;
|
|
116
|
+
try {
|
|
117
|
+
//if accessing subval of an object, make sure the object is not null
|
|
118
|
+
if (this.__delta[key] == null ||
|
|
119
|
+
typeof this.__delta[key] != "object")
|
|
120
|
+
this.__delta[key] = {};
|
|
121
|
+
const subval = this.__delta[key][objKey];
|
|
122
|
+
if (!object_equals(subval, subvalue, {
|
|
123
|
+
ignoredStartingWords: "_",
|
|
124
|
+
})) {
|
|
125
|
+
this.__delta[key][objKey] = subvalue;
|
|
126
|
+
isValueChanged = true;
|
|
127
|
+
}
|
|
128
|
+
else
|
|
129
|
+
isValueChanged = false;
|
|
130
|
+
}
|
|
131
|
+
finally {
|
|
132
|
+
if (isValueChanged) {
|
|
133
|
+
this.notifyChanged("", key, objKey, subvalue);
|
|
134
|
+
}
|
|
135
|
+
}
|
|
136
|
+
return isValueChanged;
|
|
137
|
+
}
|
|
138
|
+
//Push value on array
|
|
139
|
+
pushValue(key, value) {
|
|
140
|
+
if (value == null)
|
|
141
|
+
return null;
|
|
142
|
+
if (!this.canModify)
|
|
143
|
+
throw Error("Cant use pushValue when on readonly mode");
|
|
144
|
+
if (this.__delta[key] == null) {
|
|
145
|
+
this.__delta[key] = this.getValue(key);
|
|
146
|
+
}
|
|
147
|
+
if (!Array.isArray(this.__delta[key]))
|
|
148
|
+
throw Error("Cant use pushValue on non Array keys");
|
|
149
|
+
let tempArray = this.__delta[key];
|
|
150
|
+
tempArray.push(value);
|
|
151
|
+
this.__delta[key] = tempArray;
|
|
152
|
+
this.__changed = true;
|
|
153
|
+
this.__lastChanged = `${key} : +${value}`;
|
|
154
|
+
return tempArray;
|
|
155
|
+
}
|
|
156
|
+
notifyChanged(type, key, value, subvalue) {
|
|
157
|
+
if (value === undefined)
|
|
158
|
+
value = this.getValue(key);
|
|
159
|
+
this.__changed = true;
|
|
160
|
+
let lc = "";
|
|
161
|
+
if (type)
|
|
162
|
+
lc += `[${type}] `;
|
|
163
|
+
if (subvalue) {
|
|
164
|
+
lc += `${key}->${value} = ${subvalue}`;
|
|
165
|
+
}
|
|
166
|
+
else {
|
|
167
|
+
lc += `${key} = ${value}`;
|
|
168
|
+
}
|
|
169
|
+
this.__lastChanged = lc;
|
|
170
|
+
/* --------------------------- notify the manager --------------------------- */
|
|
171
|
+
const manager_class = this.get_managerClass();
|
|
172
|
+
if (manager_class instanceof ObjectManager) {
|
|
173
|
+
manager_class.notifyChanged(type, key, value, subvalue);
|
|
174
|
+
}
|
|
175
|
+
}
|
|
176
|
+
/**
|
|
19
177
|
* Rename object property, mostly used to fix init_object to match legacy versions
|
|
20
178
|
* @param o
|
|
21
179
|
* @param f
|
|
22
180
|
* @param t
|
|
23
181
|
* @returns
|
|
24
|
-
*/
|
|
182
|
+
*/
|
|
183
|
+
rn(o, f, t) {
|
|
184
|
+
if (typeof o == "object") {
|
|
185
|
+
if (typeof f === "string" && typeof t === "string") {
|
|
186
|
+
return prop_rn(o, f, t);
|
|
187
|
+
}
|
|
188
|
+
}
|
|
189
|
+
if (typeof o === "string" && typeof f === "string") {
|
|
190
|
+
return prop_rn(this, o, f);
|
|
191
|
+
}
|
|
192
|
+
return false;
|
|
193
|
+
}
|
|
194
|
+
static canChangeKey(key) {
|
|
195
|
+
return ((this.__changeables == null || this.__changeables.includes(key)) &&
|
|
196
|
+
(this.__unchangeables == null ||
|
|
197
|
+
!this.__unchangeables.includes(key)));
|
|
198
|
+
}
|
|
199
|
+
/* -------------------------------------------------------------------------- */
|
|
200
|
+
/* Changes */
|
|
201
|
+
/* -------------------------------------------------------------------------- */
|
|
202
|
+
/**
|
|
25
203
|
* Apply the changes and empty the delta object
|
|
26
|
-
*/
|
|
27
|
-
|
|
28
|
-
|
|
204
|
+
*/
|
|
205
|
+
apply_changes() {
|
|
206
|
+
if (!this.isChanged) {
|
|
207
|
+
console.warn("No changes to apply");
|
|
208
|
+
}
|
|
209
|
+
for (const key in this.__delta) {
|
|
210
|
+
const nv = this.__delta[key];
|
|
211
|
+
this[key] = nv;
|
|
212
|
+
}
|
|
213
|
+
this.__delta = {};
|
|
214
|
+
this.__changed = false;
|
|
215
|
+
}
|
|
216
|
+
clear_changes() {
|
|
217
|
+
this.__delta = {};
|
|
218
|
+
this.__changed = false;
|
|
219
|
+
}
|
|
220
|
+
static setReadonly(objs, readonlyval = true) {
|
|
221
|
+
let checkObjs = [];
|
|
222
|
+
if (!objs)
|
|
223
|
+
objs = [];
|
|
224
|
+
if (!Array.isArray(objs))
|
|
225
|
+
checkObjs = [objs];
|
|
226
|
+
else
|
|
227
|
+
checkObjs = objs;
|
|
228
|
+
for (let index = 0; index < checkObjs.length; index++) {
|
|
229
|
+
const element = checkObjs[index];
|
|
230
|
+
element.__is_readonly = readonlyval;
|
|
231
|
+
}
|
|
232
|
+
}
|
|
233
|
+
/* -------------------------------------------------------------------------- */
|
|
234
|
+
/* Get/Check */
|
|
235
|
+
/* -------------------------------------------------------------------------- */
|
|
236
|
+
get isChanged() {
|
|
237
|
+
return !object_isEmpty(this.__delta);
|
|
238
|
+
}
|
|
239
|
+
get isDeleted() {
|
|
240
|
+
return false;
|
|
241
|
+
}
|
|
242
|
+
get d() {
|
|
243
|
+
return this.__delta;
|
|
244
|
+
}
|
|
245
|
+
get canModify() {
|
|
246
|
+
return !this.__is_readonly && this.isEditMode;
|
|
247
|
+
}
|
|
248
|
+
get isEditMode() {
|
|
249
|
+
return this.__is_edit_mode !== false;
|
|
250
|
+
}
|
|
251
|
+
get __cache_name() {
|
|
252
|
+
return this.constructor["__cache_name"];
|
|
253
|
+
}
|
|
254
|
+
get isSaved() {
|
|
255
|
+
return Boolean(this.__saveResultIsSuccess ?? false);
|
|
256
|
+
}
|
|
257
|
+
get isNew() {
|
|
258
|
+
const mid = this.getID();
|
|
259
|
+
if (!mid || mid === "-1")
|
|
260
|
+
return true;
|
|
261
|
+
return false;
|
|
262
|
+
}
|
|
263
|
+
get manager() {
|
|
264
|
+
return this.get_managerClass();
|
|
265
|
+
}
|
|
266
|
+
get_lastChanged() {
|
|
267
|
+
return !this.__lastChanged;
|
|
268
|
+
}
|
|
269
|
+
get_managerClass = () => null;
|
|
270
|
+
static isDeleted(obj) {
|
|
271
|
+
if (obj instanceof SimpleObject)
|
|
272
|
+
return obj.isDeleted === true;
|
|
273
|
+
return false;
|
|
274
|
+
}
|
|
275
|
+
getIndexOrID() {
|
|
276
|
+
let res = this.getIndex();
|
|
277
|
+
if (!res || res == -1)
|
|
278
|
+
res = this.getID();
|
|
279
|
+
return res || -1;
|
|
280
|
+
}
|
|
281
|
+
getIndex() {
|
|
282
|
+
return this._index_value || -1;
|
|
283
|
+
}
|
|
284
|
+
getID() {
|
|
285
|
+
//@ts-ignore
|
|
286
|
+
return this.__data_id || this._id || this.id || this.ID || "-1";
|
|
287
|
+
}
|
|
288
|
+
/* -------------------------------------------------------------------------- */
|
|
289
|
+
/* Original */
|
|
290
|
+
/* -------------------------------------------------------------------------- */
|
|
291
|
+
getOriginal() {
|
|
292
|
+
return this.__originalobject || undefined;
|
|
293
|
+
}
|
|
294
|
+
setOriginal(toObj = 0) {
|
|
295
|
+
if (toObj === null) {
|
|
296
|
+
delete this.__originalobject;
|
|
297
|
+
return;
|
|
298
|
+
}
|
|
299
|
+
if (!this.isEditMode) {
|
|
300
|
+
console.warn("Cant use setOriginal on non original objects ! this will create an infinite loop");
|
|
301
|
+
return;
|
|
302
|
+
}
|
|
303
|
+
if (this.__is_readonly) {
|
|
304
|
+
delete this.__originalobject;
|
|
305
|
+
return;
|
|
306
|
+
}
|
|
307
|
+
if (toObj === 0) {
|
|
308
|
+
toObj = this;
|
|
309
|
+
}
|
|
310
|
+
const cloneObject = object_clone(toObj);
|
|
311
|
+
//this.__originalobject = cloneObject, ["__"];
|
|
312
|
+
this.__originalobject = object_removeKeys(cloneObject, ["__"]);
|
|
313
|
+
return this;
|
|
314
|
+
}
|
|
315
|
+
static setOriginal(obj, toObj = 0) {
|
|
316
|
+
if (!(obj instanceof SimpleObject))
|
|
317
|
+
return undefined;
|
|
318
|
+
return obj.setOriginal(toObj);
|
|
319
|
+
}
|
|
320
|
+
static getOriginal(obj) {
|
|
321
|
+
if (obj instanceof SimpleObject)
|
|
322
|
+
return obj.getOriginal();
|
|
323
|
+
return obj?.__originalobject;
|
|
324
|
+
}
|
|
325
|
+
/* -------------------------------------------------------------------------- */
|
|
326
|
+
/* Errors */
|
|
327
|
+
/* -------------------------------------------------------------------------- */
|
|
328
|
+
static addError(o, title, message, sendToRegister = "auto") {
|
|
329
|
+
const errStr = combine_if_not_blank(title, " : ", message);
|
|
330
|
+
if (o) {
|
|
331
|
+
if (!Array.isArray(o.__errors))
|
|
332
|
+
o.__errors = [];
|
|
333
|
+
o.__errors.push(errStr);
|
|
334
|
+
if (o.__showErrors === false)
|
|
335
|
+
return;
|
|
336
|
+
}
|
|
337
|
+
else if (sendToRegister === "auto")
|
|
338
|
+
sendToRegister = true;
|
|
339
|
+
if (sendToRegister === true) {
|
|
340
|
+
console.error("[REGISTER-ERROR]", errStr);
|
|
341
|
+
gfunc.run_action("add_error", {
|
|
342
|
+
title: title,
|
|
343
|
+
message: message,
|
|
344
|
+
type: "error",
|
|
345
|
+
});
|
|
346
|
+
}
|
|
347
|
+
else {
|
|
348
|
+
console.error("[ERROR]", errStr);
|
|
349
|
+
}
|
|
350
|
+
return o?.__errors || [];
|
|
351
|
+
}
|
|
352
|
+
static getErrors(o) {
|
|
353
|
+
return o.__errors || [];
|
|
354
|
+
}
|
|
355
|
+
static clearErrors(o) {
|
|
356
|
+
o.__errors = [];
|
|
357
|
+
return true;
|
|
358
|
+
}
|
|
359
|
+
/* -------------------------------------------------------------------------- */
|
|
360
|
+
/* Save Results */
|
|
361
|
+
/* -------------------------------------------------------------------------- */
|
|
362
|
+
static isResultValid(result_object) {
|
|
363
|
+
if (object_isEmpty(result_object))
|
|
364
|
+
return false;
|
|
365
|
+
switch (typeof result_object) {
|
|
366
|
+
case "string":
|
|
367
|
+
try {
|
|
368
|
+
result_object = JSON.parse(result_object);
|
|
369
|
+
return this.isResultValid(result_object);
|
|
370
|
+
}
|
|
371
|
+
catch {
|
|
372
|
+
return false;
|
|
373
|
+
}
|
|
374
|
+
case "object":
|
|
375
|
+
if (object_isTrue(result_object.acknowledged)) {
|
|
376
|
+
return true;
|
|
377
|
+
}
|
|
378
|
+
if (result_object.expected && result_object.result) {
|
|
379
|
+
return object_equals(result_object.expected, result_object.result);
|
|
380
|
+
}
|
|
381
|
+
return Number(this.getID(result_object)) >= 0;
|
|
382
|
+
case "number":
|
|
383
|
+
return result_object > 0;
|
|
384
|
+
case "boolean":
|
|
385
|
+
return result_object === true;
|
|
386
|
+
}
|
|
387
|
+
return false;
|
|
388
|
+
}
|
|
389
|
+
setSaveResult(toObj, type) {
|
|
390
|
+
this.__saveResultType = type;
|
|
391
|
+
if (toObj === true) {
|
|
392
|
+
}
|
|
393
|
+
else if (toObj === false) {
|
|
394
|
+
}
|
|
395
|
+
else {
|
|
396
|
+
if (toObj) {
|
|
397
|
+
this.setSaveResultObject(toObj);
|
|
398
|
+
}
|
|
399
|
+
else {
|
|
400
|
+
this.setSaveResultObject(null);
|
|
401
|
+
}
|
|
402
|
+
}
|
|
403
|
+
this.__saveResultIsSuccess =
|
|
404
|
+
(type === "normal" || type === "nothing") && toObj != null;
|
|
405
|
+
}
|
|
406
|
+
setSaveResultObject(toObj) {
|
|
407
|
+
this.__saveResultObject = toObj;
|
|
408
|
+
}
|
|
409
|
+
getSaveResult() {
|
|
410
|
+
if (this.isSaved)
|
|
411
|
+
return this.__saveResultObject;
|
|
412
|
+
return false;
|
|
413
|
+
}
|
|
414
|
+
/* -------------------------------------------------------------------------- */
|
|
415
|
+
/* statics */
|
|
416
|
+
/* -------------------------------------------------------------------------- */
|
|
417
|
+
static factoryClear(obj) {
|
|
418
|
+
obj.clear_changes();
|
|
419
|
+
SimpleObject.clearErrors(obj);
|
|
420
|
+
}
|
|
421
|
+
static delete_cache() {
|
|
422
|
+
if (!this.__cache_name)
|
|
423
|
+
return;
|
|
424
|
+
gcache.delete_cache(this.__cache_name);
|
|
425
|
+
}
|
|
426
|
+
static get_canModify(o) {
|
|
427
|
+
if (o instanceof SimpleObject)
|
|
428
|
+
return o.canModify;
|
|
429
|
+
return false;
|
|
430
|
+
}
|
|
431
|
+
/* -------------------------------------------------------------------------- */
|
|
432
|
+
static equals(a, b) {
|
|
433
|
+
console.warn("Dont use the default equals method !");
|
|
434
|
+
if (a == undefined || b == undefined)
|
|
435
|
+
return false;
|
|
436
|
+
return a === b;
|
|
437
|
+
}
|
|
438
|
+
}
|
|
439
|
+
export default SimpleObject;
|