@design-edito/tools 0.1.22 → 0.1.24

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,647 @@
1
+ import {
2
+ ref
3
+ } from "./chunk-3X6RXJBR.js";
4
+ import {
5
+ toRecord
6
+ } from "./chunk-F5YMP5WU.js";
7
+ import {
8
+ toString
9
+ } from "./chunk-DMDOCC72.js";
10
+ import {
11
+ toRef
12
+ } from "./chunk-4RDW62CU.js";
13
+ import {
14
+ toText
15
+ } from "./chunk-3PHPA25U.js";
16
+ import {
17
+ trim
18
+ } from "./chunk-7IGZP4TV.js";
19
+ import {
20
+ toTransformer
21
+ } from "./chunk-SMLKMOAX.js";
22
+ import {
23
+ replace
24
+ } from "./chunk-MDEDNPU5.js";
25
+ import {
26
+ split
27
+ } from "./chunk-6CM2SWSX.js";
28
+ import {
29
+ toArray
30
+ } from "./chunk-Q52UJOBC.js";
31
+ import {
32
+ toBoolean
33
+ } from "./chunk-SH3Y2I5P.js";
34
+ import {
35
+ toNodeList
36
+ } from "./chunk-DBAJ66BR.js";
37
+ import {
38
+ toElement
39
+ } from "./chunk-S5XDYLJH.js";
40
+ import {
41
+ toNull
42
+ } from "./chunk-RJ5E22H5.js";
43
+ import {
44
+ toNumber
45
+ } from "./chunk-F7XWUG2V.js";
46
+ import {
47
+ append
48
+ } from "./chunk-K3OQEJI3.js";
49
+ import {
50
+ join
51
+ } from "./chunk-RWUPHV54.js";
52
+ import {
53
+ length
54
+ } from "./chunk-S42P73SC.js";
55
+ import {
56
+ print
57
+ } from "./chunk-2DMWYLFG.js";
58
+ import {
59
+ push
60
+ } from "./chunk-FWHUASVA.js";
61
+ import {
62
+ classList
63
+ } from "./chunk-VRUJR6WR.js";
64
+ import {
65
+ querySelector
66
+ } from "./chunk-BNB7LEMQ.js";
67
+ import {
68
+ Cast
69
+ } from "./chunk-QO64L4KB.js";
70
+ import {
71
+ Serialize
72
+ } from "./chunk-DRNK3RLE.js";
73
+ import {
74
+ Crossenv
75
+ } from "./chunk-3LVR6KZH.js";
76
+ import {
77
+ Types
78
+ } from "./chunk-7QMAYGNV.js";
79
+ import {
80
+ Utils
81
+ } from "./chunk-YEBOL67V.js";
82
+ import {
83
+ replaceInElement
84
+ } from "./chunk-GBMHGF7P.js";
85
+ import {
86
+ isRecord
87
+ } from "./chunk-YDIBNEGA.js";
88
+ import {
89
+ isInEnum
90
+ } from "./chunk-E6MSDKON.js";
91
+
92
+ // src/agnostic/html/hyper-json/transformers/transformSelected/index.ts
93
+ var transformSelected = (callerTagName, ...args) => {
94
+ return Utils.toNamedTransformer(callerTagName, (currentValue, callerTree) => {
95
+ const { NodeList, Element, Text } = Crossenv.getWindow();
96
+ if (!(currentValue instanceof Element) && !(currentValue instanceof NodeList)) return Utils.makeTransformerError({
97
+ message: "Current value must be Element or NodeList",
98
+ input: currentValue
99
+ });
100
+ const [selector, ...transformerDescriptors] = args;
101
+ if (typeof selector !== "string" && !(selector instanceof Text)) return Utils.makeTransformerError({
102
+ message: "Selector argument must be string or text",
103
+ input: selector !== void 0 ? selector : "<undefined>"
104
+ });
105
+ if (transformerDescriptors.length === 0) return Utils.makeTransformerError("No transformer descriptor provided");
106
+ let transformers = [];
107
+ for (const descriptor of transformerDescriptors) {
108
+ const errorResponse = Utils.makeTransformerError({
109
+ message: "Transformer descriptors must be of shape { name: string, arguments: Value[] }",
110
+ input: descriptor
111
+ });
112
+ if (!isRecord(descriptor)) return errorResponse;
113
+ if (!("name" in descriptor) || typeof descriptor.name !== "string") return errorResponse;
114
+ if (!("arguments" in descriptor) || !Array.isArray(descriptor.arguments)) return errorResponse;
115
+ const { name, arguments: args2 } = descriptor;
116
+ const generator = callerTree.getGenerator(name);
117
+ if (generator === void 0) return Utils.makeTransformerError(`No transformer found under the name ${name}`);
118
+ transformers.push(generator(name, ...args2));
119
+ }
120
+ const elementInput = Cast.toElement(currentValue);
121
+ const strSelector = Cast.toString(selector);
122
+ const selected = Array.from(elementInput.querySelectorAll(strSelector));
123
+ const transformationErrors = [];
124
+ const transformed = selected.map((input) => {
125
+ const output = transformers.reduce((reduced, transformer, transformerPos) => {
126
+ const result = transformer(reduced, callerTree);
127
+ if (result.action === "REPLACE") return result.value;
128
+ else if (result.action === "MERGE") {
129
+ const merged = Tree.mergeValues(
130
+ reduced,
131
+ result.value,
132
+ transformerPos,
133
+ callerTree
134
+ );
135
+ return merged;
136
+ }
137
+ if (result.action === "ERROR") transformationErrors.push({
138
+ message: result.value,
139
+ transformerName: transformer.transformerName,
140
+ transformerPos,
141
+ transforming: reduced
142
+ });
143
+ return reduced;
144
+ }, input);
145
+ return { input, output };
146
+ });
147
+ if (transformationErrors.length !== 0) return Utils.makeTransformerError({
148
+ message: "Some nested transformers returned an error",
149
+ errors: transformationErrors
150
+ });
151
+ const nonElementTransformResult = transformed.find((item) => !(item.output instanceof Element));
152
+ if (nonElementTransformResult !== void 0) return Utils.makeTransformerError({
153
+ message: "Some transformations resulted in a non Element output",
154
+ inputElement: nonElementTransformResult.input,
155
+ outputValue: nonElementTransformResult.output
156
+ });
157
+ const transformMap = new Map(transformed.map((e) => [e.input, e.output]));
158
+ const elementOutput = replaceInElement(elementInput, transformMap);
159
+ return {
160
+ action: "REPLACE",
161
+ value: elementOutput
162
+ };
163
+ });
164
+ };
165
+
166
+ // src/agnostic/html/hyper-json/transformers/index.ts
167
+ var Transformers;
168
+ ((Transformers2) => {
169
+ Transformers2.defaultGeneratorsMap = /* @__PURE__ */ new Map([
170
+ ["append", append],
171
+ ["classList", classList],
172
+ ["join", join],
173
+ ["length", length],
174
+ ["print", print],
175
+ ["push", push],
176
+ ["querySelector", querySelector],
177
+ ["ref", ref],
178
+ ["replace", replace],
179
+ ["split", split],
180
+ ["toArray", toArray],
181
+ ["toBoolean", toBoolean],
182
+ ["toElement", toElement],
183
+ ["toNodeList", toNodeList],
184
+ ["toNull", toNull],
185
+ ["toNumber", toNumber],
186
+ ["toRecord", toRecord],
187
+ ["toRef", toRef],
188
+ ["toString", toString],
189
+ ["toText", toText],
190
+ ["toTransformer", toTransformer],
191
+ ["transformSelected", transformSelected],
192
+ ["trim", trim]
193
+ ]);
194
+ })(Transformers || (Transformers = {}));
195
+
196
+ // src/agnostic/html/hyper-json/tree/index.ts
197
+ var getWindow = Crossenv.getWindow;
198
+ var isElement = (node) => node.nodeType === getWindow().Node.ELEMENT_NODE;
199
+ var isText = (node) => node.nodeType === getWindow().Node.TEXT_NODE;
200
+ var Tree;
201
+ ((_Tree) => {
202
+ _Tree.defaultKeyAttribute = "_key";
203
+ _Tree.defaultActionAttribute = "_action";
204
+ _Tree.defaultRootKey = "_ROOT_";
205
+ function mergeValues(currentValue, incomingValue, mergeKey, initiatorTree) {
206
+ const { Element, Text, NodeList, document } = getWindow();
207
+ if (typeof incomingValue === "function") {
208
+ const evaluated = incomingValue(currentValue, initiatorTree);
209
+ if (evaluated.action === null) return currentValue;
210
+ if (evaluated.action === "REPLACE") return evaluated.value;
211
+ if (evaluated.action === "ERROR") {
212
+ const errorMessage = `Tranformer error:
213
+ from: ${incomingValue.transformerName}
214
+ at: ${initiatorTree.pathString.slice(1)}/${mergeKey}
215
+ message:`;
216
+ console.warn(errorMessage, evaluated.value);
217
+ return currentValue;
218
+ }
219
+ return mergeValues(
220
+ currentValue,
221
+ evaluated.value,
222
+ mergeKey,
223
+ initiatorTree
224
+ );
225
+ }
226
+ if (Array.isArray(currentValue)) {
227
+ if (typeof mergeKey === "string") return currentValue;
228
+ return [...currentValue, incomingValue];
229
+ }
230
+ if (currentValue === null || typeof currentValue === "boolean" || typeof currentValue === "number" || typeof currentValue === "string" || typeof currentValue === "function" || currentValue instanceof Text || currentValue instanceof Element) {
231
+ if (incomingValue === null || typeof incomingValue === "boolean" || typeof incomingValue === "number" || typeof incomingValue === "string" || Array.isArray(incomingValue) || isRecord(incomingValue)) {
232
+ return incomingValue;
233
+ }
234
+ const frag = document.createDocumentFragment();
235
+ if (currentValue instanceof Element || currentValue instanceof Text) frag.append(currentValue.cloneNode(true));
236
+ else frag.append(`${currentValue}`);
237
+ if (incomingValue instanceof Element || incomingValue instanceof Text) {
238
+ frag.append(incomingValue.cloneNode(true));
239
+ return frag.childNodes;
240
+ }
241
+ frag.append(...Array.from(incomingValue).map((e) => e.cloneNode(true)));
242
+ return frag.childNodes;
243
+ }
244
+ if (currentValue instanceof NodeList) {
245
+ if (incomingValue instanceof Element || incomingValue instanceof Text) {
246
+ const frag = document.createDocumentFragment();
247
+ frag.append(...Array.from(currentValue).map((e) => e.cloneNode(true)), incomingValue);
248
+ return frag.childNodes;
249
+ }
250
+ if (incomingValue instanceof NodeList) {
251
+ const frag = document.createDocumentFragment();
252
+ frag.append(
253
+ ...Array.from(currentValue).map((e) => e.cloneNode(true)),
254
+ ...Array.from(incomingValue).map((e) => e.cloneNode(true))
255
+ );
256
+ return frag.childNodes;
257
+ }
258
+ if (incomingValue === null || typeof incomingValue === "string" || typeof incomingValue === "number" || typeof incomingValue === "boolean") {
259
+ const frag = document.createDocumentFragment();
260
+ frag.append(...Array.from(currentValue).map((e) => e.cloneNode(true)), `${incomingValue}`);
261
+ return frag.childNodes;
262
+ }
263
+ if (Array.isArray(incomingValue)) return [
264
+ ...Array.from(currentValue),
265
+ ...incomingValue
266
+ ];
267
+ return { ...incomingValue };
268
+ }
269
+ if (typeof mergeKey === "number") return currentValue;
270
+ return {
271
+ ...currentValue,
272
+ [mergeKey]: incomingValue
273
+ };
274
+ }
275
+ _Tree.mergeValues = mergeValues;
276
+ function mergeNodes(nodes, options = {}) {
277
+ const [first, ...rest] = nodes;
278
+ const actionAttribute = options?.actionAttribute ?? _Tree.defaultActionAttribute;
279
+ const keyAttribute = options?.keyAttribute ?? _Tree.defaultKeyAttribute;
280
+ if (first === void 0) throw new Error("Expecting at least one node");
281
+ const { Text, Element, document } = getWindow();
282
+ function isTextOrElement(node) {
283
+ return node instanceof Text || node instanceof Element;
284
+ }
285
+ let CURRENT = first;
286
+ rest.forEach((node) => {
287
+ if (node instanceof Text) {
288
+ CURRENT.remove();
289
+ CURRENT = node;
290
+ return;
291
+ }
292
+ const actionRaw = node.getAttribute(actionAttribute);
293
+ const action = isInEnum(Types.ReductionAction, actionRaw) ? actionRaw : Types.ReductionAction.REPLACE;
294
+ if (action === Types.ReductionAction.REPLACE) {
295
+ CURRENT.remove();
296
+ CURRENT = node;
297
+ return;
298
+ }
299
+ if (CURRENT instanceof Text) {
300
+ if (node instanceof Text) {
301
+ const appended = action === Types.ReductionAction.APPEND ? document.createTextNode(`${CURRENT.textContent}${node.textContent}`) : document.createTextNode(`${node.textContent}${CURRENT.textContent}`);
302
+ CURRENT.remove();
303
+ node.remove();
304
+ CURRENT = appended;
305
+ return;
306
+ }
307
+ CURRENT.remove();
308
+ CURRENT = node;
309
+ return;
310
+ }
311
+ if (node instanceof Text) {
312
+ CURRENT.remove();
313
+ CURRENT = node;
314
+ return;
315
+ }
316
+ const currentAttributes = Array.from(CURRENT.attributes);
317
+ const nodeAttributes = Array.from(node.attributes);
318
+ const nodeChildren = Array.from(node.childNodes).filter(isTextOrElement);
319
+ const outputAttributes = action === Types.ReductionAction.APPEND ? [...currentAttributes, ...nodeAttributes] : [...nodeAttributes, ...currentAttributes];
320
+ if (action === Types.ReductionAction.APPEND) CURRENT.append(...nodeChildren);
321
+ else CURRENT.prepend(...nodeChildren);
322
+ outputAttributes.forEach((attr) => CURRENT.setAttribute(attr.name, attr.value));
323
+ node.remove();
324
+ return;
325
+ });
326
+ const wrapperChildren = Array.from(CURRENT.childNodes);
327
+ const subpaths = /* @__PURE__ */ new Map();
328
+ let positionnedChildrenCount = 0;
329
+ wrapperChildren.forEach((child) => {
330
+ if (child instanceof Text) {
331
+ const childKey = positionnedChildrenCount;
332
+ const found = subpaths.get(childKey) ?? [];
333
+ found.push(child);
334
+ subpaths.set(childKey, found);
335
+ positionnedChildrenCount += 1;
336
+ } else {
337
+ const rawChildKey = child.getAttribute(keyAttribute);
338
+ const childKey = rawChildKey ?? positionnedChildrenCount;
339
+ const found = subpaths.get(childKey) ?? [];
340
+ found.push(child);
341
+ subpaths.set(childKey, found);
342
+ if (rawChildKey === null) {
343
+ positionnedChildrenCount += 1;
344
+ }
345
+ }
346
+ });
347
+ subpaths.forEach((nodes2, subpath) => {
348
+ if (nodes2.length < 2) return;
349
+ return mergeNodes(nodes2, {
350
+ actionAttribute,
351
+ keyAttribute
352
+ });
353
+ });
354
+ return CURRENT;
355
+ }
356
+ _Tree.mergeNodes = mergeNodes;
357
+ function mergeRootNodes(...args) {
358
+ const [nodes, options] = args;
359
+ const actionAttribute = options?.actionAttribute ?? _Tree.defaultActionAttribute;
360
+ const keyAttribute = options?.keyAttribute ?? _Tree.defaultKeyAttribute;
361
+ const rootKey = options?.rootKey ?? _Tree.defaultRootKey;
362
+ const { Element } = getWindow();
363
+ const elements = nodes.filter((e) => e instanceof Element);
364
+ elements.forEach((element) => {
365
+ element.setAttribute(keyAttribute, rootKey);
366
+ const elementAction = element.getAttribute(actionAttribute) ?? Types.ReductionAction.APPEND;
367
+ element.setAttribute(actionAttribute, elementAction);
368
+ });
369
+ const merged = mergeNodes(elements, options);
370
+ return merged;
371
+ }
372
+ _Tree.mergeRootNodes = mergeRootNodes;
373
+ function from(nodes, options) {
374
+ const merged = mergeRootNodes(nodes, options);
375
+ return new Tree2(merged, options);
376
+ }
377
+ _Tree.from = from;
378
+ class Tree2 {
379
+ node;
380
+ name;
381
+ parent;
382
+ root;
383
+ isRoot;
384
+ path;
385
+ pathString;
386
+ tagName;
387
+ attributes;
388
+ subtrees = /* @__PURE__ */ new Map();
389
+ children;
390
+ type;
391
+ generators;
392
+ keyAttribute;
393
+ actionAttribute;
394
+ static fillOptions(options) {
395
+ const defaultOptions = {
396
+ generatorsMap: Transformers.defaultGeneratorsMap,
397
+ keyAttribute: _Tree.defaultKeyAttribute,
398
+ actionAttribute: _Tree.defaultActionAttribute
399
+ };
400
+ return {
401
+ ...defaultOptions,
402
+ ...options
403
+ };
404
+ }
405
+ constructor(node, parentOrOptions, pathFromParent, options) {
406
+ this.resolve = this.resolve.bind(this);
407
+ this.getGenerator = this.getGenerator.bind(this);
408
+ this.initValue = this.initValue.bind(this);
409
+ this.getInnerValue = this.getInnerValue.bind(this);
410
+ this.wrapInnerValue = this.wrapInnerValue.bind(this);
411
+ this.setCache = this.setCache.bind(this);
412
+ this.getPerfCounters = this.getPerfCounters.bind(this);
413
+ this.printPerfCounters = this.printPerfCounters.bind(this);
414
+ this.pushToEvalCallStack = this.pushToEvalCallStack.bind(this);
415
+ this.flushEvalCallStack = this.flushEvalCallStack.bind(this);
416
+ this.evaluate = this.evaluate.bind(this);
417
+ const { Element, Text } = getWindow();
418
+ const _node = node;
419
+ const _parent = parentOrOptions instanceof Tree2 ? parentOrOptions : void 0;
420
+ this.node = _node;
421
+ this.parent = _parent ?? null;
422
+ this.root = this.parent === null ? this : this.parent.root;
423
+ this.isRoot = this.root === this;
424
+ const _options = options ?? parentOrOptions instanceof Tree2 ? Tree2.fillOptions({}) : Tree2.fillOptions(parentOrOptions ?? {});
425
+ this.keyAttribute = _options.keyAttribute;
426
+ this.actionAttribute = _options.actionAttribute;
427
+ this.generators = this.isRoot ? _options.generatorsMap : this.root.generators;
428
+ this.name = this.node instanceof Element ? this.node.getAttribute(this.keyAttribute) : null;
429
+ const _pathFromParent = pathFromParent !== void 0 ? pathFromParent : void 0;
430
+ if (this.parent === null) this.path = [];
431
+ else if (_pathFromParent === void 0) {
432
+ this.path = [...this.parent.path, 0];
433
+ } else {
434
+ this.path = [...this.parent.path, _pathFromParent];
435
+ }
436
+ this.pathString = `/${this.path.join("/")}`;
437
+ this.tagName = node instanceof Element ? node.tagName.toLowerCase() : null;
438
+ this.attributes = isElement(node) ? Array.from(node.attributes) : null;
439
+ const { childNodes } = node;
440
+ let positionnedChildrenCount = 0;
441
+ const mutableSubtrees = /* @__PURE__ */ new Map();
442
+ Array.from(childNodes).filter((node2, _, nodes) => {
443
+ if (isElement(node2)) return true;
444
+ if (isText(node2)) {
445
+ const hasContent = (node2.textContent ?? "").trim() !== "";
446
+ if (hasContent) return true;
447
+ if (nodes.some((n) => n instanceof Element)) return false;
448
+ return true;
449
+ }
450
+ return false;
451
+ }).forEach((childNode) => {
452
+ if (childNode instanceof Text) {
453
+ mutableSubtrees.set(
454
+ positionnedChildrenCount,
455
+ new Tree2(childNode, this, positionnedChildrenCount)
456
+ );
457
+ positionnedChildrenCount += 1;
458
+ } else {
459
+ const propertyName = childNode.getAttribute(this.keyAttribute);
460
+ if (propertyName === null) {
461
+ mutableSubtrees.set(
462
+ positionnedChildrenCount,
463
+ new Tree2(childNode, this, positionnedChildrenCount)
464
+ );
465
+ positionnedChildrenCount += 1;
466
+ } else {
467
+ mutableSubtrees.set(
468
+ propertyName,
469
+ new Tree2(childNode, this, propertyName)
470
+ );
471
+ }
472
+ }
473
+ });
474
+ this.subtrees = mutableSubtrees;
475
+ this.children = Array.from(this.subtrees.values());
476
+ if (this.tagName === null) {
477
+ this.type = "text";
478
+ } else if (this.tagName === Types.TyperTagName.NULL) {
479
+ this.type = "null";
480
+ } else if (this.tagName === Types.TyperTagName.BOOLEAN) {
481
+ this.type = "boolean";
482
+ } else if (this.tagName === Types.TyperTagName.NUMBER) {
483
+ this.type = "number";
484
+ } else if (this.tagName === Types.TyperTagName.STRING) {
485
+ this.type = "string";
486
+ } else if (this.tagName === Types.TyperTagName.TEXT) {
487
+ this.type = "text";
488
+ } else if (this.tagName === Types.TyperTagName.NODELIST) {
489
+ this.type = "nodelist";
490
+ } else if (this.tagName === Types.TyperTagName.ARRAY) {
491
+ this.type = "array";
492
+ } else if (this.tagName === Types.TyperTagName.RECORD) {
493
+ this.type = "record";
494
+ } else if (this.generators.get(this.tagName) !== void 0) {
495
+ this.type = "transformer";
496
+ } else {
497
+ this.type = "element";
498
+ }
499
+ }
500
+ resolve = function(path) {
501
+ let currentTree = this.root;
502
+ for (const chunk of path) {
503
+ const { subtrees } = currentTree;
504
+ const foundSubtree = subtrees.get(chunk);
505
+ if (foundSubtree === void 0) return void 0;
506
+ currentTree = foundSubtree;
507
+ }
508
+ return currentTree;
509
+ };
510
+ getGenerator(name) {
511
+ return this.generators.get(name);
512
+ }
513
+ initValue() {
514
+ const { type } = this;
515
+ let currentValue;
516
+ if (type === "null") {
517
+ currentValue = null;
518
+ } else if (type === "boolean") {
519
+ currentValue = false;
520
+ } else if (type === "number") {
521
+ currentValue = 0;
522
+ } else if (type === "string") {
523
+ currentValue = "";
524
+ } else if (type === "text") {
525
+ currentValue = this.node.textContent;
526
+ } else if (type === "element") {
527
+ currentValue = getWindow().document.createDocumentFragment().childNodes;
528
+ } else if (type === "nodelist") {
529
+ currentValue = getWindow().document.createDocumentFragment().childNodes;
530
+ } else if (type === "array") {
531
+ currentValue = [];
532
+ } else if (type === "record") {
533
+ currentValue = {};
534
+ } else if (type === "transformer") {
535
+ currentValue = [];
536
+ } else {
537
+ currentValue = null;
538
+ }
539
+ return currentValue;
540
+ }
541
+ getInnerValue(initialValue) {
542
+ const { subtrees } = this;
543
+ const innerValue = Array.from(subtrees.entries()).reduce((currentValue, [subpath, subtree]) => mergeValues(
544
+ currentValue,
545
+ subtree.evaluate(),
546
+ subpath,
547
+ this
548
+ ), initialValue);
549
+ return innerValue;
550
+ }
551
+ wrapInnerValue(innerValue) {
552
+ const { type } = this;
553
+ if (type === "transformer") {
554
+ const transformerName = this.tagName;
555
+ if (transformerName === null) return innerValue;
556
+ const generator = this.getGenerator(transformerName);
557
+ if (generator === void 0) return innerValue;
558
+ const transformer = Array.isArray(innerValue) ? generator(transformerName, ...innerValue) : generator(transformerName, innerValue);
559
+ return transformer;
560
+ }
561
+ if (type === "null") return Cast.toNull();
562
+ if (type === "boolean") return Cast.toBoolean(innerValue);
563
+ if (type === "number") return Cast.toNumber(innerValue);
564
+ if (type === "string") return Cast.toString(innerValue);
565
+ if (type === "array") return Cast.toArray(innerValue);
566
+ if (type === "record") return Cast.toRecord(innerValue);
567
+ if (type === "text") return Cast.toText(innerValue);
568
+ if (type === "element") return Cast.toElement(innerValue);
569
+ if (type === "nodelist") return Cast.toNodeList(innerValue);
570
+ return Cast.toNull();
571
+ }
572
+ cache = void 0;
573
+ setCache(value) {
574
+ this.cache = Serialize.serialize(value);
575
+ }
576
+ perfCounters = {
577
+ computed: 0,
578
+ computeTime: 0,
579
+ computeTimeAvg: 0,
580
+ cached: 0,
581
+ cacheTime: 0,
582
+ cacheTimeAvg: 0,
583
+ totalTime: 0
584
+ };
585
+ getPerfCounters() {
586
+ const { subtrees } = this;
587
+ const subCounters = [];
588
+ subCounters.push([this.pathString, this.perfCounters]);
589
+ subtrees.forEach((subtree) => subCounters.push(...subtree.getPerfCounters()));
590
+ return subCounters;
591
+ }
592
+ printPerfCounters() {
593
+ const perfCounters = this.getPerfCounters().sort((a, b) => b[1].totalTime - a[1].totalTime).map((e) => ({
594
+ path: e[0],
595
+ totalMs: e[1].totalTime,
596
+ computeMs: e[1].computeTime,
597
+ cacheMs: e[1].cacheTime,
598
+ ops: `${e[1].computed}/${e[1].cached}`
599
+ }));
600
+ console.table(perfCounters);
601
+ }
602
+ callstack = [];
603
+ pushToEvalCallStack(path) {
604
+ this.callstack.push(path);
605
+ this.parent?.pushToEvalCallStack(path);
606
+ }
607
+ flushEvalCallStack() {
608
+ this.callstack.length = 0;
609
+ }
610
+ evaluate() {
611
+ const start = Date.now();
612
+ const circularPatternDetected = this.callstack.some((p) => p.startsWith(this.pathString));
613
+ if (circularPatternDetected) throw new Error(`Circular reference pattern detected @ ${this.pathString}`);
614
+ this.pushToEvalCallStack(this.pathString);
615
+ const { perfCounters, cache } = this;
616
+ if (cache !== void 0) {
617
+ const deserialized = Serialize.deserialize(cache);
618
+ const end2 = Date.now();
619
+ const time2 = end2 - start;
620
+ perfCounters.cached++;
621
+ perfCounters.cacheTime += time2;
622
+ perfCounters.cacheTimeAvg = perfCounters.cacheTime / perfCounters.cached;
623
+ perfCounters.totalTime = perfCounters.computeTime + perfCounters.cacheTime;
624
+ return deserialized;
625
+ }
626
+ const init = this.initValue();
627
+ const inner = this.getInnerValue(init);
628
+ const wrapped = this.wrapInnerValue(inner);
629
+ this.setCache(wrapped);
630
+ const end = Date.now();
631
+ const time = end - start;
632
+ perfCounters.computed++;
633
+ perfCounters.computeTime += time;
634
+ perfCounters.computeTimeAvg = perfCounters.computeTime / perfCounters.computed;
635
+ perfCounters.totalTime = perfCounters.computeTime + perfCounters.cacheTime;
636
+ this.flushEvalCallStack();
637
+ return wrapped;
638
+ }
639
+ }
640
+ _Tree.Tree = Tree2;
641
+ })(Tree || (Tree = {}));
642
+
643
+ export {
644
+ Tree,
645
+ transformSelected,
646
+ Transformers
647
+ };