core-3nweb-client-lib 0.25.6 → 0.27.0

package/build/lib-common/objs-on-disk/v1-obj-file-format.js

@@ -23,16 +23,16 @@ var headerChunkInfo;
 (function (headerChunkInfo) {
     function toBytes(hInfo) {
         const buf = Buffer.allocUnsafe(12);
-        big_endian_1.packUintTo4Bytes(hInfo.len, buf, 0);
-        big_endian_1.packUintTo8Bytes(hInfo.fileOfs, buf, 4);
+        (0, big_endian_1.packUintTo4Bytes)(hInfo.len, buf, 0);
+        (0, big_endian_1.packUintTo8Bytes)(hInfo.fileOfs, buf, 4);
         return buf;
     }
     headerChunkInfo.toBytes = toBytes;
     function fromBytes(b, i) {
         let bytesRead = 0;
-        const len = big_endian_1.uintFrom4Bytes(b, i + bytesRead);
+        const len = (0, big_endian_1.uintFrom4Bytes)(b, i + bytesRead);
         bytesRead += 4;
-        const fileOfs = big_endian_1.uintFrom8Bytes(b, i + bytesRead);
+        const fileOfs = (0, big_endian_1.uintFrom8Bytes)(b, i + bytesRead);
         bytesRead += 8;
         const hInfo = { len, fileOfs };
         return { hInfo: Object.freeze(hInfo), bytesRead };
@@ -60,18 +60,18 @@ var segsChunkInfo;
         let i = 0;
         buf[i] = flag;
         i += 1;
-        big_endian_1.packUintTo8Bytes(sInfo.thisVerOfs, buf, i);
+        (0, big_endian_1.packUintTo8Bytes)(sInfo.thisVerOfs, buf, i);
         i += 8;
         if (sInfo.type !== 'new-endless') {
-            big_endian_1.packUintTo8Bytes(sInfo.len, buf, 9);
+            (0, big_endian_1.packUintTo8Bytes)(sInfo.len, buf, 9);
             i += 8;
         }
         if ((sInfo.type === 'new-on-disk') || (sInfo.type === 'base-on-disk')) {
-            big_endian_1.packUintTo8Bytes(sInfo.fileOfs, buf, i);
+            (0, big_endian_1.packUintTo8Bytes)(sInfo.fileOfs, buf, i);
             i += 8;
         }
         if ((sInfo.type === 'base') || (sInfo.type === 'base-on-disk')) {
-            big_endian_1.packUintTo8Bytes(sInfo.baseVerOfs, buf, i);
+            (0, big_endian_1.packUintTo8Bytes)(sInfo.baseVerOfs, buf, i);
         }
         return buf;
     }
@@ -80,21 +80,21 @@ var segsChunkInfo;
         let bytesRead = 0;
         const flag = b[i + bytesRead];
         bytesRead += 1;
-        const thisVerOfs = big_endian_1.uintFrom8Bytes(b, i + bytesRead);
+        const thisVerOfs = (0, big_endian_1.uintFrom8Bytes)(b, i + bytesRead);
         bytesRead += 8;
         let len = undefined;
         if ((flag & IS_ENDLESS_BITMASK) === 0) {
-            len = big_endian_1.uintFrom8Bytes(b, i + bytesRead);
+            len = (0, big_endian_1.uintFrom8Bytes)(b, i + bytesRead);
             bytesRead += 8;
         }
         let fileOfs = undefined;
         if (flag & FILE_OFS_PRESENT_BITMASK) {
-            fileOfs = big_endian_1.uintFrom8Bytes(b, i + bytesRead);
+            fileOfs = (0, big_endian_1.uintFrom8Bytes)(b, i + bytesRead);
             bytesRead += 8;
         }
         let baseVerOfs = undefined;
         if (flag & BASE_VER_OFS_PRESENT_BITMASK) {
-            baseVerOfs = big_endian_1.uintFrom8Bytes(b, i + bytesRead);
+            baseVerOfs = (0, big_endian_1.uintFrom8Bytes)(b, i + bytesRead);
             bytesRead += 8;
         }
         const isOnDisk = (fileOfs !== undefined);
@@ -168,7 +168,7 @@ var layoutV1;
         if (a.baseVersion !== undefined) {
             flag |= BASE_PRESENT_BITMASK;
             baseBytes = Buffer.allocUnsafe(8);
-            big_endian_1.packUintTo8Bytes(a.baseVersion, baseBytes, 0);
+            (0, big_endian_1.packUintTo8Bytes)(a.baseVersion, baseBytes, 0);
             if (a.allBaseBytesInFile) {
                 flag |= ALL_BASE_BYTES_IN_FILE_BITMASK;
             }
@@ -214,7 +214,7 @@ var layoutV1;
         i += 1;
         let baseVersion = undefined;
         if (flag & BASE_PRESENT_BITMASK) {
-            baseVersion = big_endian_1.uintFrom8Bytes(b, i);
+            baseVersion = (0, big_endian_1.uintFrom8Bytes)(b, i);
             i += 8;
         }
         let headerChunk = undefined;

package/build/lib-common/processes/deferred.d.ts

@@ -0,0 +1,6 @@
+export interface Deferred<T> {
+    promise: Promise<T>;
+    resolve: (result?: T | PromiseLike<T>) => void;
+    reject: (err: any) => void;
+}
+export declare function defer<T>(): Deferred<T>;

package/build/lib-common/processes/deferred.js

@@ -0,0 +1,30 @@
+"use strict";
+/*
+ Copyright (C) 2015, 2017, 2019 - 2022 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defer = void 0;
+function defer() {
+    const d = {};
+    d.promise = new Promise((resolve, reject) => {
+        d.resolve = resolve;
+        d.reject = reject;
+    });
+    Object.freeze(d);
+    return d;
+}
+exports.defer = defer;
+Object.freeze(exports);

package/build/lib-common/processes/labelled-exec-pools.d.ts

@@ -0,0 +1,33 @@
+export interface Task<PoolLabel extends string> {
+    neededExecutor(): PoolLabel | undefined;
+    process(): Promise<void>;
+    cancel(): Promise<void>;
+}
+declare class ProcessingPool<PoolLabel extends string> {
+    readonly label: PoolLabel;
+    private readonly maxProcs;
+    private readonly logError?;
+    private readonly inProcess;
+    private readonly queue;
+    isRunning: boolean;
+    constructor(label: PoolLabel, maxProcs: number, logError?: ((err: any, msg?: string) => Promise<void>) | undefined);
+    add(task: Task<any>): void;
+    private processNextQueued;
+    pause(): void;
+    start(): void;
+    private readonly doOnError;
+    stop(): Promise<void>;
+}
+export declare class LabelledExecPools<PoolLabel extends string> {
+    private readonly pools;
+    private isRunning;
+    constructor(setup: {
+        label: PoolLabel;
+        maxProcs: number;
+    }[], logError?: ProcessingPool<PoolLabel>['logError']);
+    add(task: Task<PoolLabel>, queueIfNotRunning?: boolean): void;
+    start(): void;
+    pause(): void;
+    stop(): Promise<void>;
+}
+export {};

package/build/lib-common/processes/labelled-exec-pools.js

@@ -0,0 +1,141 @@
+"use strict";
+/*
+ Copyright (C) 2022 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LabelledExecPools = void 0;
+const assert_1 = require("../assert");
+class ProcessingPool {
+    constructor(label, maxProcs, logError) {
+        this.label = label;
+        this.maxProcs = maxProcs;
+        this.logError = logError;
+        this.inProcess = new Set();
+        this.queue = [];
+        this.isRunning = false;
+        this.doOnError = async (err) => {
+            if (this.logError) {
+                await this.logError(err, `Error in pool ${this.label}`);
+            }
+        };
+        Object.seal(this);
+    }
+    add(task) {
+        this.queue.push(task);
+        if (this.isRunning) {
+            this.processNextQueued();
+        }
+    }
+    async processNextQueued() {
+        if (!this.isRunning || (this.inProcess.size >= this.maxProcs)) {
+            return;
+        }
+        const task = this.queue.shift();
+        if (!task) {
+            return;
+        }
+        if (task.neededExecutor() !== this.label) {
+            return this.processNextQueued();
+        }
+        let proc = undefined;
+        try {
+            proc = task.process().catch(this.doOnError);
+            this.inProcess.add(proc);
+            await proc;
+        }
+        catch (err) {
+            await this.doOnError(err);
+        }
+        finally {
+            if (proc) {
+                this.inProcess.delete(proc);
+            }
+        }
+        return this.processNextQueued();
+    }
+    pause() {
+        this.isRunning = false;
+    }
+    start() {
+        this.isRunning = true;
+        const triggerCount = Math.min(this.maxProcs, this.queue.length);
+        for (let i = 0; i < triggerCount; i += 1) {
+            this.processNextQueued();
+        }
+    }
+    async stop() {
+        if (!this.isRunning) {
+            return;
+        }
+        this.isRunning = false;
+        const cancellations = this.queue.splice(0, this.queue.length)
+            .map(t => t.cancel().catch(this.doOnError));
+        await Promise.all(cancellations.concat(Array.from(this.inProcess)));
+    }
+}
+Object.freeze(ProcessingPool.prototype);
+Object.freeze(ProcessingPool);
+class LabelledExecPools {
+    constructor(setup, logError) {
+        this.pools = new Map();
+        this.isRunning = false;
+        (0, assert_1.assert)(setup.length > 0);
+        for (const { label, maxProcs } of setup) {
+            const pool = new ProcessingPool(label, maxProcs, logError);
+            this.pools.set(pool.label, pool);
+        }
+        Object.seal(this);
+    }
+    add(task, queueIfNotRunning = false) {
+        if (!this.isRunning && !queueIfNotRunning) {
+            return;
+        }
+        const label = task.neededExecutor();
+        if (!label) {
+            return;
+        }
+        const pool = this.pools.get(label);
+        if (!pool) {
+            throw new Error(`Task needs unknown pool ${label}`);
+        }
+        pool.add(task);
+    }
+    start() {
+        if (this.isRunning) {
+            return;
+        }
+        this.isRunning = true;
+        for (const pool of this.pools.values()) {
+            pool.start();
+        }
+    }
+    pause() {
+        this.isRunning = false;
+    }
+    async stop() {
+        if (!this.isRunning) {
+            return;
+        }
+        this.isRunning = false;
+        const cancelations = Array.from(this.pools.values())
+            .map(pool => pool.stop());
+        await Promise.all(cancelations);
+    }
+}
+exports.LabelledExecPools = LabelledExecPools;
+Object.freeze(ProcessingPool.prototype);
+Object.freeze(ProcessingPool);
+Object.freeze(exports);

package/build/lib-common/processes/pressure.d.ts

@@ -0,0 +1,7 @@
+export declare class PressureValve {
+    private stopper;
+    constructor();
+    toggle(flag: boolean): void;
+    pressWithError(err: any): void;
+    readonly pressure: () => Promise<void>;
+}

package/build/lib-common/processes/pressure.js

@@ -0,0 +1,56 @@
+"use strict";
+/*
+ Copyright (C) 2015, 2017, 2019 - 2022 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PressureValve = void 0;
+const error_1 = require("../exceptions/error");
+const deferred_1 = require("./deferred");
+class PressureValve {
+    constructor() {
+        this.stopper = undefined;
+        this.pressure = async () => {
+            if (!this.stopper) {
+                return;
+            }
+            await this.stopper.promise;
+        };
+        Object.seal(this);
+    }
+    toggle(flag) {
+        if (flag) {
+            if (this.stopper) {
+                return;
+            }
+            this.stopper = (0, deferred_1.defer)();
+        }
+        else {
+            if (!this.stopper) {
+                return;
+            }
+            this.stopper.resolve();
+            this.stopper = undefined;
+        }
+    }
+    pressWithError(err) {
+        this.toggle(true);
+        this.stopper.reject((0, error_1.errWithCause)(err, `Backpressure error`));
+    }
+}
+exports.PressureValve = PressureValve;
+Object.freeze(PressureValve.prototype);
+Object.freeze(PressureValve);
+Object.freeze(exports);

package/build/lib-common/processes/sleep.d.ts

@@ -0,0 +1 @@
+export declare function sleep(millis: number): Promise<void>;

package/build/lib-common/processes/sleep.js

@@ -0,0 +1,26 @@
+"use strict";
+/*
+ Copyright (C) 2015 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = void 0;
+function sleep(millis) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, millis).unref();
+    });
+}
+exports.sleep = sleep;
+Object.freeze(exports);

package/build/lib-common/{processes.d.ts → processes/synced.d.ts}

@@ -1,4 +1,3 @@
-export declare function sleep(millis: number): Promise<void>;
 /**
  * This represents a function that will create a promise, potentially starting
  * some background process, only when it is called. Such wrap of code is needed
@@ -68,46 +67,7 @@ export declare class SingleProc {
     private runIfIdle;
     startOrChain<T>(action: Action<T>): Promise<T>;
 }
-export declare class DeduppedRunner<T> {
-    private readonly action;
-    private proc;
-    private waiting;
-    constructor(action: Action<T>);
-    trigger(): Promise<T>;
-    private startAction;
-}
 /**
  * This wraps given function/method into syncing wrap.
  */
 export declare function makeSyncedFunc<T extends Function>(syncProc: SingleProc, thisArg: any, func: T): T;
-export interface Deferred<T> {
-    promise: Promise<T>;
-    resolve: (result?: T | PromiseLike<T>) => void;
-    reject: (err: any) => void;
-}
-export declare function defer<T>(): Deferred<T>;
-export declare class PressureValve {
-    private stopper;
-    constructor();
-    toggle(flag: boolean): void;
-    pressWithError(err: any): void;
-    readonly pressure: () => Promise<void>;
-}
-export declare function callWithTimeout<T>(f: () => Promise<T>, timeout: number, timeoutErr: () => any): Promise<T>;
-export declare class Worker<T> {
-    private readonly process;
-    private readonly stopPendingIn;
-    private readonly queue;
-    private readonly set;
-    private isRunning;
-    private readonly procs;
-    private maxProcs;
-    constructor(process: (w: T) => Promise<void>, stopPendingIn: (queue: T[]) => Promise<void>);
-    add(w: T, queueIfNotRunning?: boolean): void;
-    private addToQueueOnce;
-    private getFromQueueHead;
-    private runQueued;
-    start(maxNumOfProcs: number): void;
-    pause(): void;
-    stop(): Promise<void>;
-}