@contrail/util 1.1.14-alpha-2 → 1.1.14

package/lib/index.d.ts

@@ -4,6 +4,7 @@ export * from './date-util/date-util';
 export * from './map-util/map-util';
 export * from './object-util/object-util';
 export * from './order-util/order-util';
+export * from './performance-util/performance-util';
 export * from './promise-util/promise-util';
 export * from './retry-util/retry-util';
 export * from './string-util/string-util';

package/lib/index.js

@@ -20,6 +20,7 @@ __exportStar(require("./date-util/date-util"), exports);
 __exportStar(require("./map-util/map-util"), exports);
 __exportStar(require("./object-util/object-util"), exports);
 __exportStar(require("./order-util/order-util"), exports);
+__exportStar(require("./performance-util/performance-util"), exports);
 __exportStar(require("./promise-util/promise-util"), exports);
 __exportStar(require("./retry-util/retry-util"), exports);
 __exportStar(require("./string-util/string-util"), exports);

package/lib/object-util/cloneDeep/cloneDeep.d.ts

@@ -1,32 +1 @@
-type PerformanceComparisonEvent = {
-    durationMsJson: number;
-    durationMsRFDC: number;
-    input: any;
-};
-type PerformanceSummary = {
-    eventForWhichJsonWasMostFaster: PerformanceComparisonEvent | null;
-    eventForWhichRFDCWasMostFaster: PerformanceComparisonEvent | null;
-    totalDurationMsJson: number;
-    totalDurationMsRFDC: number;
-    invocationsInWhichJsonWasFaster: PerformanceComparisonEvent[];
-    invocationsInWhichRFDCWasFaster: PerformanceComparisonEvent[];
-};
-type CloneMethods = {
-    cloneRfdc: <T>(obj: T) => T;
-    cloneJson: <T>(obj: T) => T;
-    withTiming: (fn: () => any) => {
-        result: any;
-        durationMs: number;
-    };
-};
-declare global {
-    interface Window {
-        performanceSummary: PerformanceSummary;
-        performanceEvents: PerformanceComparisonEvent[];
-        cloneMethods: CloneMethods;
-    }
-}
-export declare function cloneDeep<T>(obj: T, options?: {
-    shouldPreserveCircularReferences?: boolean;
-}): T;
-export {};
+export declare function cloneDeep<T>(obj: T): T | null;

package/lib/object-util/cloneDeep/cloneDeep.js

@@ -1,68 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cloneDeep = cloneDeep;
-const cloneDefault = require('rfdc')();
-const cloneWithCircles = require('rfdc')({ circles: true });
-function cloneRfdc(obj, options) {
-    var _a;
-    const shouldPreserveCircles = (_a = options === null || options === void 0 ? void 0 : options.shouldPreserveCircularReferences) !== null && _a !== void 0 ? _a : false;
-    const clone = shouldPreserveCircles ? cloneWithCircles : cloneDefault;
-    return clone(obj);
-}
-function withTiming(fn) {
-    const start = performance.now();
-    const result = fn();
-    const durationMs = performance.now() - start;
-    return { result, durationMs };
-}
-if (typeof window === 'undefined') {
-    var window = {};
-}
-window.cloneMethods = {
-    cloneRfdc,
-    cloneJson: (obj) => JSON.parse(JSON.stringify(obj)),
-    withTiming,
-};
-function cloneDeep(obj, options) {
-    var _a;
-    const shouldPreserveCircles = (_a = options === null || options === void 0 ? void 0 : options.shouldPreserveCircularReferences) !== null && _a !== void 0 ? _a : false;
-    const clone = shouldPreserveCircles ? cloneWithCircles : cloneDefault;
-    const { durationMs: durationMsJson } = withTiming(() => JSON.parse(JSON.stringify(obj)));
-    const { durationMs: durationMsRFDC } = withTiming(() => clone(obj));
-    const rfdcClone = clone(obj);
-    if (!window.performanceEvents) {
-        window.performanceEvents = [];
-    }
-    const performanceEvent = {
-        durationMsJson,
-        durationMsRFDC,
-        input: obj,
-    };
-    window.performanceEvents.push(performanceEvent);
-    window.performanceSummary = window.performanceSummary || {
-        eventForWhichJsonWasMostFaster: null,
-        eventForWhichRFDCWasMostFaster: null,
-        totalDurationMsJson: 0,
-        totalDurationMsRFDC: 0,
-        invocationsInWhichJsonWasFaster: [],
-        invocationsInWhichRFDCWasFaster: [],
-    };
-    window.performanceSummary.totalDurationMsJson += durationMsJson;
-    window.performanceSummary.totalDurationMsRFDC += durationMsRFDC;
-    const isJsonFaster = durationMsJson < durationMsRFDC;
-    if (isJsonFaster) {
-        window.performanceSummary.invocationsInWhichJsonWasFaster.push(performanceEvent);
-        if (!window.performanceSummary.eventForWhichJsonWasMostFaster ||
-            durationMsJson < window.performanceSummary.eventForWhichJsonWasMostFaster.durationMsJson) {
-            window.performanceSummary.eventForWhichJsonWasMostFaster = performanceEvent;
-        }
-    }
-    else {
-        window.performanceSummary.invocationsInWhichRFDCWasFaster.push(performanceEvent);
-        if (!window.performanceSummary.eventForWhichRFDCWasMostFaster ||
-            durationMsRFDC < window.performanceSummary.eventForWhichRFDCWasMostFaster.durationMsRFDC) {
-            window.performanceSummary.eventForWhichRFDCWasMostFaster = performanceEvent;
+function cloneDeep(obj) {
+    if (obj === null || obj === undefined)
+        return null;
+    return JSON.parse(JSON.stringify(obj), (_key, value) => {
+        if (typeof value === 'string' && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z$/.test(value)) {
+            const date = new Date(value);
+            if (!isNaN(date.getTime()))
+                return date;
         }
-    }
-    return rfdcClone;
+        return value;
+    });
 }

package/lib/performance-util/example-usage.js

@@ -0,0 +1,298 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const performance_util_1 = require("./performance-util");
+function demonstrateStartEndSpan() {
+    console.log('--- Demonstrating startSpan/endSpan functionality ---\n');
+    (0, performance_util_1.clearDefaultTimingProfile)();
+    console.log('Example 1: Simple span');
+    (0, performance_util_1.startSpan)('Data Processing');
+    const start1 = performance.now();
+    while (performance.now() < start1 + 100) {
+    }
+    (0, performance_util_1.endSpan)('Data Processing');
+    (0, performance_util_1.displayTimingTree)();
+    console.log('\nExample 2: Nested spans');
+    (0, performance_util_1.clearDefaultTimingProfile)();
+    (0, performance_util_1.startSpan)('Complete Task');
+    (0, performance_util_1.startSpan)('Initialization');
+    const start2 = performance.now();
+    while (performance.now() < start2 + 50) {
+    }
+    (0, performance_util_1.endSpan)('Initialization');
+    (0, performance_util_1.startSpan)('Main Processing');
+    (0, performance_util_1.startSpan)('Sub-task 1');
+    const start3 = performance.now();
+    while (performance.now() < start3 + 30) {
+    }
+    (0, performance_util_1.endSpan)('Sub-task 1');
+    (0, performance_util_1.startSpan)('Sub-task 2');
+    const start4 = performance.now();
+    while (performance.now() < start4 + 40) {
+    }
+    (0, performance_util_1.endSpan)('Sub-task 2');
+    (0, performance_util_1.endSpan)('Main Processing');
+    (0, performance_util_1.startSpan)('Cleanup');
+    const start5 = performance.now();
+    while (performance.now() < start5 + 20) {
+    }
+    (0, performance_util_1.endSpan)('Cleanup');
+    (0, performance_util_1.endSpan)('Complete Task');
+    (0, performance_util_1.displayTimingTree)();
+    console.log('\nExample 3: Multiple sequential spans');
+    (0, performance_util_1.clearDefaultTimingProfile)();
+    (0, performance_util_1.startSpan)('Phase 1');
+    const start6 = performance.now();
+    while (performance.now() < start6 + 60) {
+    }
+    (0, performance_util_1.endSpan)('Phase 1');
+    (0, performance_util_1.startSpan)('Phase 2');
+    const start7 = performance.now();
+    while (performance.now() < start7 + 80) {
+    }
+    (0, performance_util_1.endSpan)('Phase 2');
+    (0, performance_util_1.startSpan)('Phase 3');
+    const start8 = performance.now();
+    while (performance.now() < start8 + 40) {
+    }
+    (0, performance_util_1.endSpan)('Phase 3');
+    (0, performance_util_1.displayTimingTree)();
+}
+function demonstrateWarningBehavior() {
+    console.log('\n--- Demonstrating Warning Behavior ---\n');
+    (0, performance_util_1.clearDefaultTimingProfile)();
+    console.log('Example 4: Warning behavior');
+    (0, performance_util_1.startSpan)('Test Span');
+    console.log('Started "Test Span"');
+    (0, performance_util_1.startSpan)('Test Span');
+    console.log('Attempted to start "Test Span" again (should see warning above)');
+    (0, performance_util_1.endSpan)('Test Span');
+    console.log('Ended "Test Span"');
+    (0, performance_util_1.endSpan)('Non-existent Span');
+    console.log('Attempted to end "Non-existent Span" (should see warning above)');
+    (0, performance_util_1.displayTimingTree)();
+}
+function demonstrateParentNodeId() {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log('\n--- Demonstrating parentNodeId Functionality ---\n');
+        (0, performance_util_1.clearDefaultTimingProfile)();
+        console.log('Example 5: Concurrent async operations with explicit parent');
+        yield (0, performance_util_1.withTimingAsync)('Main Operation', () => __awaiter(this, void 0, void 0, function* () {
+            const mainOpId = (0, performance_util_1.getCurrentParentNodeId)();
+            console.log(`Main Operation ID: ${String(mainOpId)}`);
+            console.log('Starting concurrent operations...');
+            const results = yield Promise.all([
+                (0, performance_util_1.withTimingAsync)('Fetch User Data', () => __awaiter(this, void 0, void 0, function* () {
+                    yield new Promise((resolve) => setTimeout(resolve, 80));
+                    console.log('  ✓ User data fetched');
+                    return 'user-data';
+                }), { parentNodeId: mainOpId }),
+                (0, performance_util_1.withTimingAsync)('Fetch Permissions', () => __awaiter(this, void 0, void 0, function* () {
+                    yield new Promise((resolve) => setTimeout(resolve, 60));
+                    console.log('  ✓ Permissions fetched');
+                    return 'permissions-data';
+                }), { parentNodeId: mainOpId }),
+                (0, performance_util_1.withTimingAsync)('Fetch Preferences', () => __awaiter(this, void 0, void 0, function* () {
+                    yield new Promise((resolve) => setTimeout(resolve, 100));
+                    console.log('  ✓ Preferences fetched');
+                    return 'preferences-data';
+                }), { parentNodeId: mainOpId }),
+            ]);
+            console.log('All concurrent operations completed:', results);
+            yield (0, performance_util_1.withTimingAsync)('Process Results', () => __awaiter(this, void 0, void 0, function* () {
+                yield new Promise((resolve) => setTimeout(resolve, 30));
+                console.log('  ✓ Results processed');
+            }));
+        }));
+        (0, performance_util_1.displayTimingTree)();
+    });
+}
+function demonstrateMixedNesting() {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log('\n--- Demonstrating Mixed Natural and Explicit Nesting ---\n');
+        (0, performance_util_1.clearDefaultTimingProfile)();
+        console.log('Example 6: Mixed natural and explicit nesting');
+        yield (0, performance_util_1.withTimingAsync)('Application Startup', () => __awaiter(this, void 0, void 0, function* () {
+            yield (0, performance_util_1.withTimingAsync)('Load Configuration', () => __awaiter(this, void 0, void 0, function* () {
+                yield new Promise((resolve) => setTimeout(resolve, 50));
+                console.log('  ✓ Configuration loaded');
+                yield (0, performance_util_1.withTimingAsync)('Validate Config', () => __awaiter(this, void 0, void 0, function* () {
+                    yield new Promise((resolve) => setTimeout(resolve, 20));
+                    console.log('    ✓ Configuration validated');
+                }));
+            }));
+            console.log('Starting parallel initialization...');
+            (0, performance_util_1.startSpan)('Initialization');
+            const ininitializeId = (0, performance_util_1.getCurrentParentNodeId)();
+            (0, performance_util_1.withTimingSync)('Do something before initialization', () => {
+                const start = performance.now();
+                while (performance.now() < start + 20) {
+                }
+                console.log('  ✓ Pre-initialization task completed');
+            });
+            yield Promise.all([
+                (0, performance_util_1.withTimingAsync)('Initialize Database', () => __awaiter(this, void 0, void 0, function* () {
+                    yield new Promise((resolve) => setTimeout(resolve, 120));
+                    console.log('  ✓ Database initialized');
+                }), { parentNodeId: ininitializeId }),
+                (0, performance_util_1.withTimingAsync)('Initialize Cache', () => __awaiter(this, void 0, void 0, function* () {
+                    yield new Promise((resolve) => setTimeout(resolve, 90));
+                    console.log('  ✓ Cache initialized');
+                }), { parentNodeId: ininitializeId }),
+                (0, performance_util_1.withTimingAsync)('Initialize Logging', () => __awaiter(this, void 0, void 0, function* () {
+                    yield new Promise((resolve) => setTimeout(resolve, 40));
+                    console.log('  ✓ Logging initialized');
+                }), { parentNodeId: ininitializeId }),
+            ]);
+            (0, performance_util_1.withTimingSync)('Do something after initialization', () => {
+                const start = performance.now();
+                while (performance.now() < start + 20) {
+                }
+                console.log('  ✓ Post-initialization task completed');
+            });
+            (0, performance_util_1.endSpan)('Initialization');
+            yield (0, performance_util_1.withTimingAsync)('Final Setup', () => __awaiter(this, void 0, void 0, function* () {
+                yield new Promise((resolve) => setTimeout(resolve, 30));
+                console.log('  ✓ Final setup completed');
+            }));
+        }));
+        (0, performance_util_1.displayTimingTree)();
+    });
+}
+function demonstrateSyncWithParentId() {
+    console.log('\n--- Demonstrating Sync Functions with parentNodeId ---\n');
+    (0, performance_util_1.clearDefaultTimingProfile)();
+    console.log('Example 7: Sync functions with explicit parent');
+    (0, performance_util_1.withTimingSync)('Data Processing Pipeline', () => {
+        const pipelineId = (0, performance_util_1.getCurrentParentNodeId)();
+        console.log(`Pipeline ID: ${String(pipelineId)}`);
+        (0, performance_util_1.withTimingSync)('Load Input Data', () => {
+            const start = performance.now();
+            while (performance.now() < start + 50) {
+            }
+            console.log('  ✓ Input data loaded');
+        });
+        (0, performance_util_1.withTimingSync)('Process Batch 1', () => {
+            const start = performance.now();
+            while (performance.now() < start + 80) {
+            }
+            console.log('  ✓ Batch 1 processed');
+        }, { parentNodeId: pipelineId });
+        (0, performance_util_1.withTimingSync)('Process Batch 2', () => {
+            const start = performance.now();
+            while (performance.now() < start + 70) {
+            }
+            console.log('  ✓ Batch 2 processed');
+        }, { parentNodeId: pipelineId });
+        (0, performance_util_1.withTimingSync)('Process Batch 3', () => {
+            const start = performance.now();
+            while (performance.now() < start + 90) {
+            }
+            console.log('  ✓ Batch 3 processed');
+        }, { parentNodeId: pipelineId });
+        (0, performance_util_1.withTimingSync)('Save Results', () => {
+            const start = performance.now();
+            while (performance.now() < start + 40) {
+            }
+            console.log('  ✓ Results saved');
+        });
+    });
+    (0, performance_util_1.displayTimingTree)();
+}
+function demonstrateManualSpansWithParentId() {
+    console.log('\n--- Demonstrating Manual Spans with parentNodeId ---\n');
+    (0, performance_util_1.clearDefaultTimingProfile)();
+    console.log('Example 8: Manual spans with explicit parent');
+    (0, performance_util_1.startSpan)('Service Request');
+    const serviceId = (0, performance_util_1.getCurrentParentNodeId)();
+    console.log(`Service Request ID: ${String(serviceId)}`);
+    (0, performance_util_1.startSpan)('Authenticate User');
+    const start1 = performance.now();
+    while (performance.now() < start1 + 30) {
+    }
+    (0, performance_util_1.endSpan)('Authenticate User');
+    console.log('  ✓ User authenticated');
+    (0, performance_util_1.startSpan)('Validate Input', { parentNodeId: serviceId });
+    const start2 = performance.now();
+    while (performance.now() < start2 + 20) {
+    }
+    (0, performance_util_1.endSpan)('Validate Input');
+    console.log('  ✓ Input validated');
+    (0, performance_util_1.startSpan)('Check Rate Limits', { parentNodeId: serviceId });
+    const start3 = performance.now();
+    while (performance.now() < start3 + 15) {
+    }
+    (0, performance_util_1.endSpan)('Check Rate Limits');
+    console.log('  ✓ Rate limits checked');
+    (0, performance_util_1.startSpan)('Log Request', { parentNodeId: serviceId });
+    const start4 = performance.now();
+    while (performance.now() < start4 + 10) {
+    }
+    (0, performance_util_1.endSpan)('Log Request');
+    console.log('  ✓ Request logged');
+    (0, performance_util_1.startSpan)('Process Request');
+    const start5 = performance.now();
+    while (performance.now() < start5 + 60) {
+    }
+    (0, performance_util_1.endSpan)('Process Request');
+    console.log('  ✓ Request processed');
+    (0, performance_util_1.endSpan)('Service Request');
+    (0, performance_util_1.displayTimingTree)();
+}
+function demonstrateNestingComparison() {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log('\n--- Demonstrating Natural vs Explicit Nesting ---\n');
+        console.log('Natural Nesting (call stack based):');
+        (0, performance_util_1.clearDefaultTimingProfile)();
+        yield (0, performance_util_1.withTimingAsync)('Sequential Operations', () => __awaiter(this, void 0, void 0, function* () {
+            yield (0, performance_util_1.withTimingAsync)('Operation 1', () => __awaiter(this, void 0, void 0, function* () {
+                yield new Promise((resolve) => setTimeout(resolve, 30));
+            }));
+            yield (0, performance_util_1.withTimingAsync)('Operation 2', () => __awaiter(this, void 0, void 0, function* () {
+                yield new Promise((resolve) => setTimeout(resolve, 40));
+            }));
+            yield (0, performance_util_1.withTimingAsync)('Operation 3', () => __awaiter(this, void 0, void 0, function* () {
+                yield new Promise((resolve) => setTimeout(resolve, 35));
+            }));
+        }));
+        (0, performance_util_1.displayTimingTree)();
+        console.log('\nExplicit Parent Assignment (logical grouping):');
+        (0, performance_util_1.clearDefaultTimingProfile)();
+        yield (0, performance_util_1.withTimingAsync)('Parallel Operations', () => __awaiter(this, void 0, void 0, function* () {
+            const parentId = (0, performance_util_1.getCurrentParentNodeId)();
+            yield Promise.all([
+                (0, performance_util_1.withTimingAsync)('Operation 1', () => __awaiter(this, void 0, void 0, function* () {
+                    yield new Promise((resolve) => setTimeout(resolve, 30));
+                }), { parentNodeId: parentId }),
+                (0, performance_util_1.withTimingAsync)('Operation 2', () => __awaiter(this, void 0, void 0, function* () {
+                    yield new Promise((resolve) => setTimeout(resolve, 40));
+                }), { parentNodeId: parentId }),
+                (0, performance_util_1.withTimingAsync)('Operation 3', () => __awaiter(this, void 0, void 0, function* () {
+                    yield new Promise((resolve) => setTimeout(resolve, 35));
+                }), { parentNodeId: parentId }),
+            ]);
+        }));
+        (0, performance_util_1.displayTimingTree)();
+    });
+}
+function runAllExamples() {
+    return __awaiter(this, void 0, void 0, function* () {
+        demonstrateStartEndSpan();
+        demonstrateWarningBehavior();
+        yield demonstrateParentNodeId();
+        yield demonstrateMixedNesting();
+        demonstrateSyncWithParentId();
+        demonstrateManualSpansWithParentId();
+        yield demonstrateNestingComparison();
+        console.log('\nAll examples completed. ');
+    });
+}
+runAllExamples().catch(console.error);

package/lib/performance-util/performance-util.d.ts

@@ -0,0 +1,35 @@
+type TimingSpans = TimingNode[];
+type TimingStack = TimingNode[];
+export type TimingNode = {
+    label: string;
+    id: string;
+    durationMs: number;
+    children: TimingNode[];
+    startTime: number;
+};
+type ActiveSpan = {
+    node: TimingNode;
+    startTime: number;
+    wasAddedToStack: boolean;
+};
+type TimingProfile = {
+    activeSpans: Map<string, ActiveSpan>;
+    spansById: Map<string, TimingNode>;
+    timingSpans: TimingSpans;
+    timingStack: TimingStack;
+};
+export declare function getDefaultTimingProfile(): TimingProfile;
+export declare function clearDefaultTimingProfile(): void;
+export declare function getCurrentParentNodeId(): string | null;
+export declare function withTimingAsync<T>(label: string, fn: () => Promise<T>, options?: {
+    parentNodeId?: string | null;
+}): Promise<T>;
+export declare function withTimingSync<T>(label: string, fn: () => T, options?: {
+    parentNodeId?: string | null;
+}): T;
+export declare function displayTimingTree(nodes?: TimingSpans, depth?: number, prefix?: string): string;
+export declare function startSpan(spanName: string, options?: {
+    parentNodeId?: string | null;
+}): void;
+export declare function endSpan(spanName: string): void;
+export {};

package/lib/performance-util/performance-util.js

@@ -0,0 +1,257 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultTimingProfile = getDefaultTimingProfile;
+exports.clearDefaultTimingProfile = clearDefaultTimingProfile;
+exports.getCurrentParentNodeId = getCurrentParentNodeId;
+exports.withTimingAsync = withTimingAsync;
+exports.withTimingSync = withTimingSync;
+exports.displayTimingTree = displayTimingTree;
+exports.startSpan = startSpan;
+exports.endSpan = endSpan;
+const DEFAULT_TIMING_PROFILE = {
+    activeSpans: new Map(),
+    spansById: new Map(),
+    timingSpans: [],
+    timingStack: [],
+};
+function getDefaultTimingProfile() {
+    return DEFAULT_TIMING_PROFILE;
+}
+function getTimingStack() {
+    return DEFAULT_TIMING_PROFILE.timingStack;
+}
+function getTimingSpans() {
+    return DEFAULT_TIMING_PROFILE.timingSpans;
+}
+function getNodeById(id) {
+    return DEFAULT_TIMING_PROFILE.spansById.get(id);
+}
+function setSpanId(id, node) {
+    DEFAULT_TIMING_PROFILE.spansById.set(id, node);
+}
+function clearDefaultTimingProfile() {
+    DEFAULT_TIMING_PROFILE.timingSpans = [];
+    DEFAULT_TIMING_PROFILE.timingStack = [];
+    DEFAULT_TIMING_PROFILE.activeSpans.clear();
+    DEFAULT_TIMING_PROFILE.spansById.clear();
+}
+function getParentNode() {
+    const stack = getTimingStack();
+    return stack.length > 0 ? stack[stack.length - 1] : null;
+}
+function getCurrentParentNodeId() {
+    const parentNode = getParentNode();
+    return parentNode ? parentNode.id : null;
+}
+function withTimingAsync(label, fn, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const start = performance.now();
+        const chosenId = options === null || options === void 0 ? void 0 : options.parentNodeId;
+        const uniqueId = generateUUID();
+        const timingNode = {
+            label,
+            durationMs: 0,
+            children: [],
+            id: uniqueId,
+            startTime: start,
+        };
+        setSpanId(uniqueId, timingNode);
+        const parent = chosenId ? getNodeById(chosenId) : getParentNode();
+        if (parent) {
+            parent.children.push(timingNode);
+        }
+        else {
+            getTimingSpans().push(timingNode);
+        }
+        const isRunningConcurrently = !!chosenId;
+        if (!isRunningConcurrently) {
+            getTimingStack().push(timingNode);
+        }
+        return fn().finally(() => {
+            const end = performance.now();
+            timingNode.durationMs = end - start;
+            if (!isRunningConcurrently) {
+                getTimingStack().pop();
+            }
+        });
+    });
+}
+function withTimingSync(label, fn, options) {
+    const start = performance.now();
+    const chosenId = options === null || options === void 0 ? void 0 : options.parentNodeId;
+    const uniqueId = generateUUID();
+    const timingNode = {
+        label,
+        durationMs: 0,
+        children: [],
+        id: uniqueId,
+        startTime: start,
+    };
+    setSpanId(uniqueId, timingNode);
+    const parent = chosenId ? getNodeById(chosenId) : getParentNode();
+    if (parent) {
+        parent.children.push(timingNode);
+    }
+    else {
+        getTimingSpans().push(timingNode);
+    }
+    const isRunningConcurrently = !!chosenId;
+    if (!isRunningConcurrently) {
+        getTimingStack().push(timingNode);
+    }
+    try {
+        return fn();
+    }
+    finally {
+        const end = performance.now();
+        timingNode.durationMs = end - start;
+        if (!isRunningConcurrently) {
+            getTimingStack().pop();
+        }
+    }
+}
+function displayTimingTree(nodes = DEFAULT_TIMING_PROFILE.timingSpans, depth = 0, prefix = '') {
+    const lines = [];
+    const totalWidth = 120;
+    const timeWidth = 10;
+    const sortedNodes = [...nodes].sort((a, b) => a.startTime - b.startTime);
+    const groups = [];
+    let currentGroup = [];
+    for (let i = 0; i < sortedNodes.length; i++) {
+        const node = sortedNodes[i];
+        if (currentGroup.length === 0) {
+            currentGroup = [node];
+        }
+        else {
+            const hasOverlap = currentGroup.some((groupNode) => {
+                const nodeEnd = node.startTime + node.durationMs;
+                const groupNodeEnd = groupNode.startTime + groupNode.durationMs;
+                return node.startTime < groupNodeEnd && nodeEnd > groupNode.startTime;
+            });
+            if (hasOverlap) {
+                currentGroup.push(node);
+            }
+            else {
+                groups.push(currentGroup);
+                currentGroup = [node];
+            }
+        }
+    }
+    if (currentGroup.length > 0) {
+        groups.push(currentGroup);
+    }
+    groups.forEach((group, groupIndex) => {
+        const isLastGroup = groupIndex === groups.length - 1;
+        if (group.length === 1) {
+            const node = group[0];
+            const timeStr = `${node.durationMs.toFixed(2)}ms`;
+            const connector = depth === 0 ? '' : isLastGroup ? '└── ' : '├── ';
+            const labelWithPrefix = `${prefix}${connector}${node.label}`;
+            const availableWidth = totalWidth - timeWidth - labelWithPrefix.length;
+            const dots = '.'.repeat(Math.max(2, availableWidth));
+            lines.push(`${labelWithPrefix}${dots}${timeStr.padStart(timeWidth)}`);
+            if (node.children && node.children.length > 0) {
+                const childPrefix = prefix + (depth === 0 ? '' : isLastGroup ? '    ' : '│   ');
+                lines.push(displayTimingTree(node.children, depth + 1, childPrefix));
+            }
+        }
+        else {
+            const connector = depth === 0 ? '' : isLastGroup ? '└── ' : '├── ';
+            const parallelHeader = `${prefix}${connector}∥ Parallel Operations (${group.length})`;
+            lines.push(parallelHeader);
+            group.forEach((node, nodeIndex) => {
+                const isLastNode = nodeIndex === group.length - 1;
+                const timeStr = `${node.durationMs.toFixed(2)}ms`;
+                const parallelIndicator = '∥ ';
+                const nodeConnector = isLastNode ? '└── ' : '├── ';
+                const nodePrefix = prefix + (depth === 0 ? '' : isLastGroup ? '    ' : '│   ');
+                const labelWithPrefix = `${nodePrefix}${nodeConnector}${parallelIndicator}${node.label}`;
+                const availableWidth = totalWidth - timeWidth - labelWithPrefix.length;
+                const dots = '.'.repeat(Math.max(2, availableWidth));
+                lines.push(`${labelWithPrefix}${dots}${timeStr.padStart(timeWidth)}`);
+                if (node.children && node.children.length > 0) {
+                    const childPrefix = nodePrefix + (isLastNode ? '    ' : '│   ');
+                    lines.push(displayTimingTree(node.children, depth + 1, childPrefix));
+                }
+            });
+        }
+    });
+    const result = lines.join('\n');
+    if (depth === 0) {
+        console.log('\n--- Performance Timing Tree ---');
+        console.log(result);
+        console.log('\n--- End Timing ---\n');
+    }
+    return result;
+}
+function startSpan(spanName, options) {
+    if (DEFAULT_TIMING_PROFILE.activeSpans.has(spanName)) {
+        console.warn(`Span "${spanName}" is already active. Please end it before starting a new one with the same name.`);
+        return;
+    }
+    const startTime = performance.now();
+    const chosenId = options === null || options === void 0 ? void 0 : options.parentNodeId;
+    const uniqueId = generateUUID();
+    const timingNode = {
+        label: spanName,
+        durationMs: 0,
+        children: [],
+        id: uniqueId,
+        startTime: startTime,
+    };
+    setSpanId(uniqueId, timingNode);
+    const parent = chosenId ? getNodeById(chosenId) : getParentNode();
+    if (parent) {
+        parent.children.push(timingNode);
+    }
+    else {
+        getTimingSpans().push(timingNode);
+    }
+    const isRunningConcurrently = !!chosenId;
+    if (!isRunningConcurrently) {
+        getTimingStack().push(timingNode);
+    }
+    DEFAULT_TIMING_PROFILE.activeSpans.set(spanName, {
+        node: timingNode,
+        startTime: startTime,
+        wasAddedToStack: !isRunningConcurrently,
+    });
+}
+function endSpan(spanName) {
+    const activeSpan = DEFAULT_TIMING_PROFILE.activeSpans.get(spanName);
+    if (!activeSpan) {
+        console.warn(`No active span found with name "${spanName}". Make sure to call startSpan() first.`);
+        return;
+    }
+    const endTime = performance.now();
+    activeSpan.node.durationMs = endTime - activeSpan.startTime;
+    if (activeSpan.wasAddedToStack) {
+        const currentTop = getTimingStack()[getTimingStack().length - 1];
+        if (currentTop === activeSpan.node) {
+            getTimingStack().pop();
+        }
+        else {
+            const stackIndex = getTimingStack().findIndex((node) => node === activeSpan.node);
+            if (stackIndex !== -1) {
+                getTimingStack().splice(stackIndex, 1);
+            }
+        }
+    }
+    DEFAULT_TIMING_PROFILE.activeSpans.delete(spanName);
+}
+function generateUUID() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+        const r = (Math.random() * 16) | 0;
+        const v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@contrail/util",
-  "version": "1.1.14-alpha-2",
-  "description": "General javascript utilities",
+  "version": "1.1.14",
+  "description": "General JavaScript utilities",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "scripts": {
@@ -41,7 +41,6 @@
   "dependencies": {
     "@contrail/types": "^3.0.95",
     "fflate": "^0.8.2",
-    "lodash": "^4.17.21",
-    "rfdc": "^1.4.1"
+    "lodash": "^4.17.21"
   }
 }

package/lib/object-util/cloneDeep/performanceTest.js

@@ -1,106 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const lodash_1 = require("lodash");
-const cloneDeep_1 = require("./cloneDeep");
-function jsonClone(obj) {
-    return JSON.parse(JSON.stringify(obj));
-}
-console.log('Performance test for small objects:');
-let smallObject = {
-    sub1: {
-        val: 1,
-    },
-    sub3: {
-        val: 2,
-        valX: '3',
-    },
-};
-console.time('cloneDeepSmallRFDC');
-Array.from({ length: 10000 }).forEach(() => {
-    (0, cloneDeep_1.cloneDeep)(smallObject);
-});
-console.timeEnd('cloneDeepSmallRFDC');
-console.time('cloneDeepSmallLodash');
-Array.from({ length: 10000 }).forEach(() => {
-    (0, lodash_1.cloneDeep)(smallObject);
-});
-console.timeEnd('cloneDeepSmallLodash');
-console.time('cloneDeepSmallJson');
-Array.from({ length: 10000 }).forEach(() => {
-    jsonClone(smallObject);
-});
-console.timeEnd('cloneDeepSmallJson');
-console.time('structuredCloneSmall');
-Array.from({ length: 10000 }).forEach(() => {
-    structuredClone(smallObject);
-});
-console.timeEnd('structuredCloneSmall');
-console.log('\n\nPerformance test for very large objects:');
-let veryLargeObject = {};
-for (let i = 0; i < 100000; i++) {
-    veryLargeObject[`key${i}`] = {
-        sub1: {
-            val: i,
-        },
-        sub2: new Date('2023-10-01T12:00:00.000Z'),
-        sub3: {
-            val: i + 1,
-            valX: i + 2,
-        },
-    };
-}
-console.time('cloneDeepRFDC');
-(0, cloneDeep_1.cloneDeep)(veryLargeObject);
-console.timeEnd('cloneDeepRFDC');
-console.time('cloneDeepLodash');
-(0, lodash_1.cloneDeep)(veryLargeObject);
-console.timeEnd('cloneDeepLodash');
-console.time('cloneDeepJson');
-jsonClone(veryLargeObject);
-console.timeEnd('cloneDeepJson');
-console.time('structuredClone');
-structuredClone(veryLargeObject);
-console.timeEnd('structuredClone');
-console.log('\n\nPerformance test for very large arrays:');
-let veryLargeArray = [];
-for (let i = 0; i < 100000; i++) {
-    veryLargeArray.push({
-        sub1: {
-            val: i,
-        },
-        sub2: new Date('2023-10-01T12:00:00.000Z'),
-        sub3: {
-            val: i + 1,
-            valX: i + 2,
-        },
-    });
-}
-console.time('cloneDeepArrayRFDC');
-(0, cloneDeep_1.cloneDeep)(veryLargeArray);
-console.timeEnd('cloneDeepArrayRFDC');
-console.time('cloneDeepArrayLodash');
-(0, lodash_1.cloneDeep)(veryLargeArray);
-console.timeEnd('cloneDeepArrayLodash');
-console.time('cloneDeepArrayJson');
-jsonClone(veryLargeArray);
-console.timeEnd('cloneDeepArrayJson');
-console.time('structuredCloneArray');
-structuredClone(veryLargeArray);
-console.timeEnd('structuredCloneArray');
-console.log('\n\nPerformance test for assortment.json:');
-const fs = require("fs");
-const path = require("path");
-const assortmentFilePath = path.join(__dirname, 'assortment.json');
-const assortmentData = JSON.parse(fs.readFileSync(assortmentFilePath, 'utf8'));
-console.time('cloneDeepAssortment25kRFDC');
-(0, cloneDeep_1.cloneDeep)(assortmentData);
-console.timeEnd('cloneDeepAssortment25kRFDC');
-console.time('cloneDeepAssortment25kLodash');
-(0, lodash_1.cloneDeep)(assortmentData);
-console.timeEnd('cloneDeepAssortment25kLodash');
-console.time('cloneDeepAssortment25kJson');
-jsonClone(assortmentData);
-console.timeEnd('cloneDeepAssortment25kJson');
-console.time('structuredCloneAssortment25k');
-structuredClone(assortmentData);
-console.timeEnd('structuredCloneAssortment25k');