@contrail/util 1.1.17-alpha.0 → 1.1.17-alpha.2

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

@@ -0,0 +1,2 @@
+export declare function compressIntoString(obj: any): string;
+export declare function decompressFromString(str: string): any;

package/lib/compression-util/compression.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compressIntoString = compressIntoString;
+exports.decompressFromString = decompressFromString;
+const fflate_1 = require("fflate");
+function compressIntoString(obj) {
+    const jsonStr = JSON.stringify(obj === undefined ? null : obj);
+    if (typeof Buffer === 'undefined') {
+        console.warn('Buffer is not available. Compression will be skipped.');
+        return jsonStr;
+    }
+    const buffer = new TextEncoder().encode(jsonStr);
+    const compressed = (0, fflate_1.compressSync)(buffer);
+    return Buffer.from(compressed).toString('base64');
+}
+function decompressFromString(str) {
+    if (typeof Buffer === 'undefined') {
+        console.warn('Buffer is not available. Decompression will be skipped. Returning original string.');
+        return str;
+    }
+    const compressed = Buffer.from(str, 'base64');
+    const decompressed = (0, fflate_1.decompressSync)(compressed);
+    const originalText = new TextDecoder().decode(decompressed);
+    return JSON.parse(originalText);
+}

package/lib/compression-util/index.d.ts

@@ -0,0 +1 @@
+export * from './compression';

package/lib/compression-util/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./compression"), exports);

package/lib/date-util/getIsoDatePart/getIsoDatePart.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getIsoDatePart = void 0;
+exports.getIsoDatePart = getIsoDatePart;
 function getIsoDatePart(date) {
     console.log('date 1: ', date.toISOString(), '\n\n\n\n\n\n\n\n');
     let d = new Date(date);
@@ -14,4 +14,3 @@ function getIsoDatePart(date) {
     }
     return [year, month, day].join('-');
 }
-exports.getIsoDatePart = getIsoDatePart;

package/lib/index.d.ts

@@ -1,9 +1,11 @@
-export * from './object-util/object-util';
-export * from './string-util/string-util';
+export * from './app-util/app-util';
+export * from './compression-util';
 export * from './date-util/date-util';
 export * from './map-util/map-util';
-export * from './app-util/app-util';
-export * from './timer-util/timer-util';
-export * from './promise-util/promise-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';
+export * from './timer-util/timer-util';

package/lib/index.js

@@ -14,12 +14,14 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./object-util/object-util"), exports);
-__exportStar(require("./string-util/string-util"), exports);
+__exportStar(require("./app-util/app-util"), exports);
+__exportStar(require("./compression-util"), exports);
 __exportStar(require("./date-util/date-util"), exports);
 __exportStar(require("./map-util/map-util"), exports);
-__exportStar(require("./app-util/app-util"), exports);
-__exportStar(require("./timer-util/timer-util"), exports);
-__exportStar(require("./promise-util/promise-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);
+__exportStar(require("./timer-util/timer-util"), exports);

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

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.areItemPropertyValuesEqual = exports.determineChangesIfEqual = exports.applyChangesIfEqual = void 0;
+exports.applyChangesIfEqual = applyChangesIfEqual;
+exports.determineChangesIfEqual = determineChangesIfEqual;
+exports.areItemPropertyValuesEqual = areItemPropertyValuesEqual;
 const types_1 = require("@contrail/types");
 const compareDeep_1 = require("../compareDeep/compareDeep");
 function applyChangesIfEqual(target, priorSourceValues, newSourceValues, properties) {
@@ -9,7 +11,6 @@ function applyChangesIfEqual(target, priorSourceValues, newSourceValues, propert
         Object.assign(target, changes);
     }
 }
-exports.applyChangesIfEqual = applyChangesIfEqual;
 function determineChangesIfEqual(target, priorSourceValues, newSourceValues, properties) {
     const changes = {};
     for (const property of properties) {
@@ -26,26 +27,24 @@ function determineChangesIfEqual(target, priorSourceValues, newSourceValues, pro
     }
     return changes;
 }
-exports.determineChangesIfEqual = determineChangesIfEqual;
 function areItemPropertyValuesEqual(property, itemOne, itemTwo) {
-    var _a, _b;
+    var _a, _b, _c, _d;
     const propertyKey = getPropertyKey(property);
-    const propertyValueOne = itemOne[propertyKey];
-    const propertyValueTwo = itemTwo[propertyKey];
+    const propertyValueOne = (_a = itemOne[propertyKey]) !== null && _a !== void 0 ? _a : null;
+    const propertyValueTwo = (_b = itemTwo[propertyKey]) !== null && _b !== void 0 ? _b : null;
     if (property.propertyType === types_1.PropertyType.MultiSelect) {
         const propertyValueOneAsArray = getMultiSelectValueAsArray(propertyValueOne);
         const propertyValueTwoAsArray = getMultiSelectValueAsArray(propertyValueTwo);
         return areArraysEqualIgnoreOrder(propertyValueOneAsArray, propertyValueTwoAsArray);
     }
     if (property.propertyType === types_1.PropertyType.SizeRange) {
-        const isOfSameSizeRangeTemplate = ((_a = itemOne === null || itemOne === void 0 ? void 0 : itemOne.sizeRangeTemplate) === null || _a === void 0 ? void 0 : _a.id) === ((_b = itemTwo === null || itemTwo === void 0 ? void 0 : itemTwo.sizeRangeTemplate) === null || _b === void 0 ? void 0 : _b.id);
+        const isOfSameSizeRangeTemplate = ((_c = itemOne === null || itemOne === void 0 ? void 0 : itemOne.sizeRangeTemplate) === null || _c === void 0 ? void 0 : _c.id) === ((_d = itemTwo === null || itemTwo === void 0 ? void 0 : itemTwo.sizeRangeTemplate) === null || _d === void 0 ? void 0 : _d.id);
         if (!isOfSameSizeRangeTemplate)
             return false;
         return areSizeRangesEqual(propertyValueOne, propertyValueTwo);
     }
     return propertyValueOne === propertyValueTwo;
 }
-exports.areItemPropertyValuesEqual = areItemPropertyValuesEqual;
 function areSizeRangesEqual(sizeRangeOne, sizeRangeTwo) {
     var _a, _b;
     if (!sizeRangeOne && !sizeRangeTwo) {

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

@@ -1 +1,5 @@
-export declare function cloneDeep(obj: any): any;
+export declare function cloneDeep<T>(obj: T): DatesAsStrings<T> | null;
+type DatesAsStrings<T> = T extends Date ? string : T extends (infer U)[] ? DatesAsStrings<U>[] : T extends object ? {
+    [K in keyof T]: DatesAsStrings<T[K]>;
+} : T;
+export {};

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

@@ -1,10 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cloneDeep = void 0;
+exports.cloneDeep = cloneDeep;
 function cloneDeep(obj) {
-    if (!obj) {
+    if (obj == null)
         return null;
-    }
     return JSON.parse(JSON.stringify(obj));
 }
-exports.cloneDeep = cloneDeep;

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

@@ -0,0 +1,6 @@
+export declare function cloneDeepPreserveDates<T>(obj: T): T | null;
+declare const DATE_TAG = "__$date";
+export declare function tagDates(input: unknown): unknown;
+export declare function reviveTaggedDates(_key: string, value: unknown): unknown;
+export declare function isTaggedDate(v: unknown): v is Record<typeof DATE_TAG, string>;
+export {};

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cloneDeepPreserveDates = cloneDeepPreserveDates;
+exports.tagDates = tagDates;
+exports.reviveTaggedDates = reviveTaggedDates;
+exports.isTaggedDate = isTaggedDate;
+function cloneDeepPreserveDates(obj) {
+    if (obj == null)
+        return null;
+    const tagged = tagDates(obj);
+    const json = JSON.stringify(tagged);
+    return JSON.parse(json, reviveTaggedDates);
+}
+const DATE_TAG = '__$date';
+function tagDates(input) {
+    if (input instanceof Date)
+        return { [DATE_TAG]: input.toISOString() };
+    if (Array.isArray(input))
+        return input.map(tagDates);
+    if (input && typeof input === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(input))
+            out[k] = tagDates(v);
+        return out;
+    }
+    return input;
+}
+function reviveTaggedDates(_key, value) {
+    return isTaggedDate(value) ? new Date(value[DATE_TAG]) : value;
+}
+function isTaggedDate(v) {
+    return (!!v &&
+        typeof v === 'object' &&
+        v !== null &&
+        DATE_TAG in v &&
+        typeof v[DATE_TAG] === 'string');
+}

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getObjectDiff = exports.getObjectDiffs = void 0;
+exports.getObjectDiffs = getObjectDiffs;
+exports.getObjectDiff = getObjectDiff;
 function getObjectDiffs(before, after, prefix) {
     const diffs = [];
     if (!before || !after) {
@@ -67,7 +68,6 @@ function getObjectDiffs(before, after, prefix) {
     });
     return diffs;
 }
-exports.getObjectDiffs = getObjectDiffs;
 function getObjectDiff(before, after, name) {
     const diff = {
         propertyName: name,
@@ -76,7 +76,6 @@ function getObjectDiff(before, after, name) {
     };
     return diff;
 }
-exports.getObjectDiff = getObjectDiff;
 function sortFunc(x, y) {
     const pre = ['string', 'number', 'bool'];
     if (typeof x !== typeof y)

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

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isObject = void 0;
+exports.isObject = isObject;
 function isObject(item) {
     return item && typeof item === 'object' && !Array.isArray(item);
 }
-exports.isObject = isObject;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeDeep = void 0;
+exports.mergeDeep = mergeDeep;
 const isObject_1 = require("../isObject/isObject");
 function mergeDeep(target, ...sources) {
     if (!sources.length)
@@ -20,7 +20,6 @@ function mergeDeep(target, ...sources) {
     }
     return mergeDeep(target, ...sources);
 }
-exports.mergeDeep = mergeDeep;
 function isDate(object) {
     return object != null && object instanceof Date;
 }

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

@@ -1,8 +1,10 @@
 import { cloneDeep } from './cloneDeep/cloneDeep';
+import { cloneDeepPreserveDates } from './cloneDeepPreserveDates/cloneDeepPreserveDates';
 import { isObject } from './isObject/isObject';
 import { mergeDeep } from './mergeDeep/mergeDeep';
 import { getObjectDiffs } from './compareDeep/compareDeep';
 import { applyChangesIfEqual, determineChangesIfEqual, areItemPropertyValuesEqual } from './applyChangesIfEqual/applyChangesIfEqual';
+import { retainOnlyProperties } from './retainOnlyProperties/retainOnlyProperties';
 export { ObjectDiff } from './compareDeep/compareDeep';
 export declare class ObjectUtil {
     static getByPath(obj: any, path: string, def?: any): any;
@@ -13,8 +15,10 @@ export declare class ObjectUtil {
     static isObject: typeof isObject;
     static mergeDeep: typeof mergeDeep;
     static cloneDeep: typeof cloneDeep;
+    static cloneDeepPreserveDates: typeof cloneDeepPreserveDates;
     static compareDeep: typeof getObjectDiffs;
     static applyChangesIfEqual: typeof applyChangesIfEqual;
     static determineChangesIfEqual: typeof determineChangesIfEqual;
     static areItemPropertyValuesEqual: typeof areItemPropertyValuesEqual;
+    static retainOnlyProperties: typeof retainOnlyProperties;
 }

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

@@ -2,10 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObjectUtil = void 0;
 const cloneDeep_1 = require("./cloneDeep/cloneDeep");
+const cloneDeepPreserveDates_1 = require("./cloneDeepPreserveDates/cloneDeepPreserveDates");
 const isObject_1 = require("./isObject/isObject");
 const mergeDeep_1 = require("./mergeDeep/mergeDeep");
 const compareDeep_1 = require("./compareDeep/compareDeep");
 const applyChangesIfEqual_1 = require("./applyChangesIfEqual/applyChangesIfEqual");
+const retainOnlyProperties_1 = require("./retainOnlyProperties/retainOnlyProperties");
 class ObjectUtil {
     static getByPath(obj, path, def = null) {
         if (obj == undefined)
@@ -79,7 +81,9 @@ exports.ObjectUtil = ObjectUtil;
 ObjectUtil.isObject = isObject_1.isObject;
 ObjectUtil.mergeDeep = mergeDeep_1.mergeDeep;
 ObjectUtil.cloneDeep = cloneDeep_1.cloneDeep;
+ObjectUtil.cloneDeepPreserveDates = cloneDeepPreserveDates_1.cloneDeepPreserveDates;
 ObjectUtil.compareDeep = compareDeep_1.getObjectDiffs;
 ObjectUtil.applyChangesIfEqual = applyChangesIfEqual_1.applyChangesIfEqual;
 ObjectUtil.determineChangesIfEqual = applyChangesIfEqual_1.determineChangesIfEqual;
 ObjectUtil.areItemPropertyValuesEqual = applyChangesIfEqual_1.areItemPropertyValuesEqual;
+ObjectUtil.retainOnlyProperties = retainOnlyProperties_1.retainOnlyProperties;

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

@@ -0,0 +1,8 @@
+export declare function retainOnlyProperties<T extends Record<string, any>, K extends readonly string[]>(obj: T[], keysToKeep: K, options?: {
+    shouldDeleteInPlace?: boolean;
+    skipKeys?: readonly string[];
+}): Array<Pick<T, K[number]>>;
+export declare function retainOnlyProperties<T extends Record<string, any>, K extends readonly string[]>(obj: T, keysToKeep: K, options?: {
+    shouldDeleteInPlace?: boolean;
+    skipKeys?: readonly string[];
+}): Pick<T, K[number]>;

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retainOnlyProperties = retainOnlyProperties;
+const object_util_1 = require("../object-util");
+function retainOnlyProperties(obj, keysToKeep, options = {}) {
+    const keepSet = new Set(keysToKeep);
+    const skipSet = new Set(options.skipKeys || []);
+    const shouldReturnAsIs = (value) => value === null || value === undefined || typeof value !== 'object' || value instanceof Date;
+    const retain = (target) => {
+        if (shouldReturnAsIs(target))
+            return target;
+        if (Array.isArray(target)) {
+            return target.map(retain);
+        }
+        for (const key in target) {
+            if (skipSet.has(key)) {
+                continue;
+            }
+            if (!keepSet.has(key)) {
+                delete target[key];
+            }
+            else {
+                target[key] = retain(target[key]);
+            }
+        }
+        return target;
+    };
+    const objToModify = options.shouldDeleteInPlace ? obj : object_util_1.ObjectUtil.cloneDeepPreserveDates(obj);
+    return retain(objToModify);
+}

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

@@ -0,0 +1 @@
+export {};

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 ---\n');
+        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/lib/promise-util/promise-util.d.ts

@@ -1,4 +1,4 @@
 export declare class PromiseUtil {
-    static resolveInChunks(objects: Array<any>, chunksSize: number, asyncFunction: (chunk: any) => Promise<any>): Promise<any>;
-    static resolveInChunksAndLimit(objects: Array<any>, chunksSize: number, limitSize: number, asyncFunction: (chunk: any) => Promise<any>): Promise<any>;
+    static resolveInChunks<TInput, TOutput>(objects: Array<TInput>, chunksSize: number, asyncFunction: (chunk: TInput[]) => Promise<TOutput[]>): Promise<TOutput[]>;
+    static resolveInChunksAndLimit<TInput, TOutput>(objects: Array<TInput>, chunksSize: number, limitSize: number, asyncFunction: (chunk: TInput[]) => Promise<TOutput[]>): Promise<TOutput[]>;
 }

package/lib/promise-util/promise-util.js

@@ -14,24 +14,21 @@ const p_limit_1 = require("p-limit");
 const lodash_1 = require("lodash");
 class PromiseUtil {
     static resolveInChunks(objects, chunksSize, asyncFunction) {
-        const chunks = (0, lodash_1.chunk)(objects, chunksSize);
-        const promises = [];
-        for (const chunk of chunks) {
-            promises.push(asyncFunction(chunk));
-        }
-        return Promise.all(promises).then((chunkedResults) => chunkedResults.flat());
+        return __awaiter(this, void 0, void 0, function* () {
+            const chunks = (0, lodash_1.chunk)(objects, chunksSize);
+            const promises = chunks.map((chunk) => asyncFunction(chunk));
+            const chunkedResults = yield Promise.all(promises);
+            return chunkedResults.flat();
+        });
     }
     static resolveInChunksAndLimit(objects, chunksSize, limitSize, asyncFunction) {
-        const limit = (0, p_limit_1.default)(limitSize);
-        const chunks = (0, lodash_1.chunk)(objects, chunksSize);
-        const promises = [];
-        for (const chunk of chunks) {
-            const promise = limit(() => __awaiter(this, void 0, void 0, function* () {
-                return yield asyncFunction(chunk);
-            }));
-            promises.push(promise);
-        }
-        return Promise.all(promises).then((chunkedResults) => chunkedResults.flat());
+        return __awaiter(this, void 0, void 0, function* () {
+            const limit = (0, p_limit_1.default)(limitSize);
+            const chunks = (0, lodash_1.chunk)(objects, chunksSize);
+            const promises = chunks.map((chunk) => limit(() => __awaiter(this, void 0, void 0, function* () { return asyncFunction(chunk); })));
+            const chunkedResults = yield Promise.all(promises);
+            return chunkedResults.flat();
+        });
     }
 }
 exports.PromiseUtil = PromiseUtil;

package/lib/retry-util/retry-util.js

@@ -9,13 +9,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.retry = void 0;
+exports.retry = retry;
 const DEFAULT_CONFIG = {
     maxRetries: 3,
     initialDelay: 1000,
 };
-function retry(fn, config = DEFAULT_CONFIG) {
-    return __awaiter(this, void 0, void 0, function* () {
+function retry(fn_1) {
+    return __awaiter(this, arguments, void 0, function* (fn, config = DEFAULT_CONFIG) {
         const { maxRetries, initialDelay, onRetryCallback } = Object.assign(Object.assign({}, DEFAULT_CONFIG), config);
         if (maxRetries < 1) {
             throw new Error('maxRetries must be at least 1');
@@ -39,4 +39,3 @@ function retry(fn, config = DEFAULT_CONFIG) {
         throw new Error('Max retries reached');
     });
 }
-exports.retry = retry;

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

@@ -3,6 +3,8 @@ export declare class StringUtil {
     static parseVariables(variableString: string, data: any, quoteStrings?: boolean): string;
     static convertToCamelCase(str: any): any;
     static convertToTitleCase(str: any): any;
-    static isString(value: any): boolean;
-    static isArray(value: any): boolean;
+    static isString(value: any): value is string | String;
+    static isArray(value: any): value is any[];
+    static decodeEncodedString(encodedString: string): string;
+    static getStringSizeInMB(str: string): number;
 }

package/lib/string-util/string-util.js

@@ -67,5 +67,19 @@ class StringUtil {
     static isArray(value) {
         return Array.isArray(value);
     }
+    static decodeEncodedString(encodedString) {
+        return encodedString.replace(/_COMMA_/g, ',').replace(/%[0-9A-Fa-f]{2}/g, (match) => {
+            try {
+                return decodeURIComponent(match);
+            }
+            catch (_a) {
+                return match;
+            }
+        });
+    }
+    static getStringSizeInMB(str) {
+        const bytes = new TextEncoder().encode(str).length;
+        return bytes / (1024 * 1024);
+    }
 }
 exports.StringUtil = StringUtil;

package/lib/timer-util/timer-util.js

@@ -9,12 +9,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.delay = exports.TimerManager = exports.Timer = exports.TimeUnit = void 0;
+exports.TimerManager = exports.Timer = exports.TimeUnit = void 0;
+exports.delay = delay;
 var TimeUnit;
 (function (TimeUnit) {
     TimeUnit["MILLISECOND"] = "ms";
     TimeUnit["SECOND"] = "s";
-})(TimeUnit = exports.TimeUnit || (exports.TimeUnit = {}));
+})(TimeUnit || (exports.TimeUnit = TimeUnit = {}));
 const MILLISECONDS_PER_TIME_UNIT = {
     [TimeUnit.MILLISECOND]: 1,
     [TimeUnit.SECOND]: 1000,
@@ -116,4 +117,3 @@ function delay(ms) {
         });
     });
 }
-exports.delay = delay;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/util",
-  "version": "1.1.17-alpha.0",
+  "version": "1.1.17-alpha.2",
   "description": "General JavaScript utilities",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",