@contrail/util 1.1.3 → 1.1.5-alpha-compression-1

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

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+export declare function compressToBase64(obj: any): Promise<string>;
+export declare function decompressFromBase64<T>(base64: string): Promise<T>;
+export declare function compressObjectIntoBuffer(obj: any): Promise<Buffer>;
+export declare function convertBufferToBase64(buffer: Buffer): string;
+export declare function convertBase64ToBuffer(base64: string): Buffer;
+export declare function decompressBuffer(buffer: Buffer): Promise<any>;

package/lib/compression-util/compression.js

@@ -0,0 +1,57 @@
+"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.decompressBuffer = exports.convertBase64ToBuffer = exports.convertBufferToBase64 = exports.compressObjectIntoBuffer = exports.decompressFromBase64 = exports.compressToBase64 = void 0;
+const zlib_1 = require("zlib");
+function compressToBase64(obj) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return compressObjectIntoBuffer(obj).then((buffer) => convertBufferToBase64(buffer));
+    });
+}
+exports.compressToBase64 = compressToBase64;
+function decompressFromBase64(base64) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const buffer = convertBase64ToBuffer(base64);
+        return decompressBuffer(buffer);
+    });
+}
+exports.decompressFromBase64 = decompressFromBase64;
+function compressObjectIntoBuffer(obj) {
+    const json = obj === undefined ? JSON.stringify(null) : JSON.stringify(obj);
+    return new Promise((resolve, reject) => {
+        zlib_1.default.gzip(json, (err, buffer) => {
+            if (err)
+                reject(err);
+            else
+                resolve(buffer);
+        });
+    });
+}
+exports.compressObjectIntoBuffer = compressObjectIntoBuffer;
+function convertBufferToBase64(buffer) {
+    return buffer.toString('base64');
+}
+exports.convertBufferToBase64 = convertBufferToBase64;
+function convertBase64ToBuffer(base64) {
+    return Buffer.from(base64, 'base64');
+}
+exports.convertBase64ToBuffer = convertBase64ToBuffer;
+function decompressBuffer(buffer) {
+    return new Promise((resolve, reject) => {
+        zlib_1.default.gunzip(buffer, (err, result) => {
+            if (err)
+                reject(err);
+            else
+                resolve(JSON.parse(result.toString()));
+        });
+    });
+}
+exports.decompressBuffer = decompressBuffer;

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/index.d.ts

@@ -1,9 +1,10 @@
-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 './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,13 @@ 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("./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/timer-util/timer-util.d.ts

@@ -2,6 +2,10 @@ export declare enum TimeUnit {
     MILLISECOND = "ms",
     SECOND = "s"
 }
+interface DumpOptions {
+    unit?: TimeUnit;
+    format?: boolean;
+}
 export declare class Timer {
     private startTime?;
     private endTime?;
@@ -13,4 +17,16 @@ export declare class Timer {
     getElapsedTime(timeUnit?: TimeUnit): number;
     private getCurrentTime;
 }
+export declare class TimerManager {
+    private timers;
+    private formatDuration;
+    start(key: string): void;
+    stop(key: string): void;
+    reset(key: string): void;
+    getElapsedTime(key: string, unit?: TimeUnit): number;
+    has(key: string): boolean;
+    clearAll(): void;
+    dump(options?: DumpOptions): Record<string, number | string>;
+}
 export declare function delay(ms: number): Promise<unknown>;
+export {};

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

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.delay = exports.Timer = exports.TimeUnit = void 0;
+exports.delay = exports.TimerManager = exports.Timer = exports.TimeUnit = void 0;
 var TimeUnit;
 (function (TimeUnit) {
     TimeUnit["MILLISECOND"] = "ms";
@@ -55,6 +55,60 @@ class Timer {
     }
 }
 exports.Timer = Timer;
+class TimerManager {
+    constructor() {
+        this.timers = new Map();
+    }
+    formatDuration(duration) {
+        return duration > 1000 ? `${(duration / 1000).toFixed(2)}s` : `${duration}ms`;
+    }
+    start(key) {
+        if (this.timers.has(key)) {
+            throw new Error(`Timer with key "${key}" already started`);
+        }
+        const timer = new Timer();
+        timer.start();
+        this.timers.set(key, timer);
+    }
+    stop(key) {
+        const timer = this.timers.get(key);
+        if (!timer) {
+            throw new Error(`Timer with key "${key}" not found`);
+        }
+        timer.stop();
+    }
+    reset(key) {
+        this.timers.delete(key);
+    }
+    getElapsedTime(key, unit = TimeUnit.MILLISECOND) {
+        const timer = this.timers.get(key);
+        if (!timer) {
+            throw new Error(`Timer with key "${key}" not found`);
+        }
+        return timer.getElapsedTime(unit);
+    }
+    has(key) {
+        return this.timers.has(key);
+    }
+    clearAll() {
+        this.timers.clear();
+    }
+    dump(options = {}) {
+        const { unit = TimeUnit.MILLISECOND, format = false } = options;
+        const result = {};
+        for (const [key, timer] of this.timers.entries()) {
+            try {
+                const duration = timer.getElapsedTime(unit);
+                result[key] = format ? this.formatDuration(duration) : duration;
+            }
+            catch (_a) {
+                result[key] = NaN;
+            }
+        }
+        return result;
+    }
+}
+exports.TimerManager = TimerManager;
 function delay(ms) {
     return __awaiter(this, void 0, void 0, function* () {
         return new Promise((resolve) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/util",
-  "version": "1.1.3",
+  "version": "1.1.5-alpha-compression-1",
   "description": "General javascript utilities",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",