core-3nweb-client-lib 0.25.6 → 0.27.0

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

@@ -16,14 +16,8 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Worker = exports.callWithTimeout = exports.PressureValve = exports.defer = exports.makeSyncedFunc = exports.DeduppedRunner = exports.SingleProc = exports.NamedProcs = exports.sleep = void 0;
-const error_1 = require("./exceptions/error");
-function sleep(millis) {
-    return new Promise((resolve) => {
-        setTimeout(resolve, millis).unref();
-    });
-}
-exports.sleep = sleep;
+exports.makeSyncedFunc = exports.SingleProc = exports.NamedProcs = void 0;
+const deferred_1 = require("./deferred");
 /**
  * This is a container of processes, labeled by some ids. It allows to track if
  * there is a process already in progress with a given id. And, it allows to
@@ -155,7 +149,7 @@ class SingleProc {
         }
     }
     startOrChain(action) {
-        const deferred = defer();
+        const deferred = (0, deferred_1.defer)();
         this.actions.push({ action, deferred });
         this.runIfIdle();
         return deferred.promise;
@@ -164,52 +158,49 @@ class SingleProc {
 exports.SingleProc = SingleProc;
 Object.freeze(SingleProc.prototype);
 Object.freeze(SingleProc);
-class DeduppedRunner {
-    constructor(action) {
-        this.action = action;
-        this.proc = undefined;
-        this.waiting = undefined;
-        Object.seal(this);
-    }
-    trigger() {
-        if (this.proc) {
-            if (!this.waiting) {
-                this.waiting = defer();
-            }
-            return this.waiting.promise;
-        }
-        else {
-            this.proc = this.startAction();
-            return this.proc;
-        }
-    }
-    async startAction() {
-        const deferredBeforeStart = this.waiting;
-        this.waiting = undefined;
-        try {
-            const result = await this.action();
-            if (deferredBeforeStart) {
-                deferredBeforeStart.resolve(result);
-            }
-            return result;
-        }
-        catch (err) {
-            if (deferredBeforeStart) {
-                deferredBeforeStart.reject(err);
-            }
-            throw err;
-        }
-        finally {
-            this.proc = undefined;
-            if (this.waiting) {
-                this.proc = this.startAction();
-            }
-        }
-    }
-}
-exports.DeduppedRunner = DeduppedRunner;
-Object.freeze(DeduppedRunner.prototype);
-Object.freeze(DeduppedRunner);
+// export class DeduppedRunner<T> {
+// 	private proc: Promise<T>|undefined = undefined;
+// 	private waiting: Deferred<T>|undefined = undefined;
+// 	constructor(
+// 		private readonly action: Action<T>
+// 	) {
+// 		Object.seal(this);
+// 	}
+// 	trigger(): Promise<T> {
+// 		if (this.proc) {
+// 			if (!this.waiting) {
+// 				this.waiting = defer();
+// 			}
+// 			return this.waiting.promise;
+// 		} else {
+// 			this.proc = this.startAction();
+// 			return this.proc;
+// 		}
+// 	}
+// 	private async startAction(): Promise<T> {
+// 		const deferredBeforeStart = this.waiting;
+// 		this.waiting = undefined;
+// 		try {
+// 			const result = await this.action();
+// 			if (deferredBeforeStart) {
+// 				deferredBeforeStart.resolve(result);
+// 			}
+// 			return result;
+// 		} catch (err) {
+// 			if (deferredBeforeStart) {
+// 				deferredBeforeStart.reject(err);
+// 			}
+// 			throw err;
+// 		} finally {
+// 			this.proc = undefined;
+// 			if (this.waiting) {
+// 				this.proc = this.startAction();
+// 			}
+// 		}
+// 	}
+// }
+// Object.freeze(DeduppedRunner.prototype);
+// Object.freeze(DeduppedRunner);
 /**
  * This wraps given function/method into syncing wrap.
  */
@@ -217,153 +208,145 @@ function makeSyncedFunc(syncProc, thisArg, func) {
     return ((...args) => syncProc.startOrChain(() => func.apply(thisArg, args)));
 }
 exports.makeSyncedFunc = makeSyncedFunc;
-function defer() {
-    const d = {};
-    d.promise = new Promise((resolve, reject) => {
-        d.resolve = resolve;
-        d.reject = reject;
-    });
-    Object.freeze(d);
-    return d;
-}
-exports.defer = defer;
-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 = defer();
-        }
-        else {
-            if (!this.stopper) {
-                return;
-            }
-            this.stopper.resolve();
-            this.stopper = undefined;
-        }
-    }
-    pressWithError(err) {
-        this.toggle(true);
-        this.stopper.reject(error_1.errWithCause(err, `Backpressure error`));
-    }
-}
-exports.PressureValve = PressureValve;
-Object.freeze(PressureValve.prototype);
-Object.freeze(PressureValve);
-function callWithTimeout(f, timeout, timeoutErr) {
-    let isDone = false;
-    const deferred = defer();
-    f().then(res => {
-        if (isDone) {
-            return;
-        }
-        isDone = true;
-        deferred.resolve(res);
-    }, err => {
-        if (isDone) {
-            return;
-        }
-        isDone = true;
-        deferred.reject(err);
-    });
-    sleep(timeout).then(() => {
-        if (isDone) {
-            return;
-        }
-        isDone = true;
-        const err = timeoutErr();
-        if (err) {
-            deferred.reject(err);
-        }
-    });
-    return deferred.promise;
-}
-exports.callWithTimeout = callWithTimeout;
-class Worker {
-    constructor(process, stopPendingIn) {
-        this.process = process;
-        this.stopPendingIn = stopPendingIn;
-        this.queue = [];
-        this.set = new Set();
-        this.isRunning = false;
-        this.procs = [];
-        this.maxProcs = 1;
-        Object.seal(this);
-    }
-    add(w, queueIfNotRunning = false) {
-        if (this.isRunning) {
-            this.addToQueueOnce(w);
-            this.runQueued();
-        }
-        else if (queueIfNotRunning) {
-            this.addToQueueOnce(w);
-        }
-    }
-    addToQueueOnce(w) {
-        if (!this.set.has(w)) {
-            this.queue.push(w);
-            this.set.add(w);
-        }
-    }
-    getFromQueueHead() {
-        const w = this.queue.shift();
-        if (!w) {
-            return;
-        }
-        this.set.delete(w);
-        return w;
-    }
-    async runQueued() {
-        if (!this.isRunning || (this.procs.length >= this.maxProcs)) {
-            return;
-        }
-        const w = this.getFromQueueHead();
-        if (!w) {
-            return;
-        }
-        const proc = this.process(w);
-        this.procs.push(proc);
-        try {
-            await proc;
-        }
-        finally {
-            const i = this.procs.indexOf(proc);
-            if (i >= 0) {
-                this.procs.splice(i, 1);
-            }
-            this.runQueued();
-        }
-    }
-    start(maxNumOfProcs) {
-        this.maxProcs = maxNumOfProcs;
-        this.isRunning = true;
-        this.runQueued();
-    }
-    pause() {
-        this.isRunning = false;
-    }
-    async stop() {
-        this.isRunning = false;
-        const queue = this.queue.splice(0, this.queue.length);
-        this.set.clear();
-        await this.stopPendingIn(queue);
-        while (this.procs.length > 0) {
-            await this.procs.pop();
-        }
-    }
-}
-exports.Worker = Worker;
-Object.freeze(Worker.prototype);
-Object.freeze(Worker);
+// export interface Deferred<T> {
+// 	promise: Promise<T>;
+// 	resolve: (result?: T|PromiseLike<T>) => void;
+// 	reject: (err: any) => void;
+// }
+// export function defer<T>(): Deferred<T> {
+// 	const d = <Deferred<T>> {};
+// 	d.promise = new Promise<T>((resolve, reject) => {
+// 		d.resolve = resolve;
+// 		d.reject = reject;
+// 	});
+// 	Object.freeze(d);
+// 	return d;
+// }
+// export class PressureValve {
+// 	private stopper: Deferred<void>|undefined = undefined;
+// 	constructor() {
+// 		Object.seal(this);
+// 	}
+// 	toggle(flag: boolean): void {
+// 		if (flag) {
+// 			if (this.stopper) { return; }
+// 			this.stopper = defer();
+// 		} else {
+// 			if (!this.stopper) { return; }
+// 			this.stopper.resolve();
+// 			this.stopper = undefined;
+// 		}
+// 	}
+// 	pressWithError(err: any): void {
+// 		this.toggle(true);
+// 		this.stopper!.reject(errWithCause(err, `Backpressure error`));
+// 	}
+// 	readonly pressure = async (): Promise<void> => {
+// 		if (!this.stopper) { return; }
+// 		await this.stopper.promise;
+// 	}
+// }
+// Object.freeze(PressureValve.prototype);
+// Object.freeze(PressureValve);
+// export function callWithTimeout<T>(
+// 	f: () => Promise<T>, timeout: number, timeoutErr: () => any
+// ): Promise<T> {
+// 	let isDone = false;
+// 	const deferred = defer<T>();
+// 	f().then(res => {
+// 		if (isDone) { return; }
+// 		isDone = true;
+// 		deferred.resolve(res);
+// 	}, err => {
+// 		if (isDone) { return; }
+// 		isDone = true;
+// 		deferred.reject(err);
+// 	});
+// 	sleep(timeout).then(() => {
+// 		if (isDone) { return; }
+// 		isDone = true;
+// 		const err = timeoutErr();
+// 		if (err) {
+// 			deferred.reject(err);
+// 		}
+// 	});
+// 	return deferred.promise;
+// }
+// export interface WorkerTask<WorkerLabel extends string> {
+// 	neededWorker(): WorkerLabel|undefined;
+// 	process(): Promise<void>;
+// 	cancel(): Promise<void>;
+// }
+// interface Worker {
+// 	readonly procs: Promise<void>[];
+// 	readonly maxProcs: number;
+// }
+// export class QueueAndWorkers<WorkerLabel extends string> {
+// 	private readonly queue: WorkerTask<WorkerLabel>[] = [];
+// 	private readonly workers = new Map<WorkerLabel, Worker>();
+// 	// private readonly set = new Set<WorkerTask>();
+// 	private isRunning = false;
+// 	// private readonly procs: Promise<void>[] = [];
+// 	// private maxProcs = 1;
+// 	constructor() {
+// 		Object.seal(this);
+// 	}
+// 	add(w: WorkerTask<WorkerLabel>, queueIfNotRunning = false): void {
+// 		if (this.isRunning) {
+// 			this.queue.push();
+// 			this.processNextQueued();
+// 		} else if (queueIfNotRunning) {
+// 			this.addToQueueOnce(w);
+// 		}
+// 	}
+// 	private addToQueueOnce(w: WorkerTask<WorkerLabel>): void {
+// 		if (!this.set.has(w)) {
+// 			this.queue.push(w);
+// 			this.set.add(w);
+// 		}
+// 	}
+// 	private getFromQueueHead(): WorkerTask<WorkerLabel>|undefined {
+// 		const w = this.queue.shift();
+// 		if (!w) { return; }
+// 		this.set.delete(w);
+// 		return w;
+// 	}
+// 	private async processNextQueued(): Promise<void> {
+// 		if (!this.isRunning || (this.procs.length >= this.maxProcs)) { return; }
+// 		const w = this.getFromQueueHead();
+// 		if (!w) { return; }
+// 		const proc = w.process();
+// 		this.procs.push(proc);
+// 		try {
+// 			await proc;
+// 		} finally {
+// 			const i = this.procs.indexOf(proc);
+// 			if (i >= 0) {
+// 				this.procs.splice(i, 1);
+// 			}
+// 			this.processNextQueued();
+// 		}
+// 	}
+// 	start(maxNumOfProcs = 1): void {
+// 		this.maxProcs = maxNumOfProcs;
+// 		this.isRunning = true;
+// 		this.processNextQueued();
+// 	}
+// 	pause(): void {
+// 		this.isRunning = false;
+// 	}
+// 	async stop(): Promise<void> {
+// 		this.isRunning = false;
+// 		const queue = this.queue.splice(0, this.queue.length);
+// 		this.set.clear();
+// 		for (const w of queue) {
+// 			await w.cancel();
+// 		}
+// 		while (this.procs.length > 0) {
+// 			await this.procs.pop();
+// 		}
+// 	}
+// }
+// Object.freeze(Worker.prototype);
+// Object.freeze(Worker);
 Object.freeze(exports);

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

@@ -0,0 +1 @@
+export declare function callWithTimeout<T>(f: () => Promise<T>, timeout: number, timeoutErr: () => any): Promise<T>;

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

@@ -0,0 +1,51 @@
+"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.callWithTimeout = void 0;
+const deferred_1 = require("./deferred");
+const sleep_1 = require("./sleep");
+function callWithTimeout(f, timeout, timeoutErr) {
+    let isDone = false;
+    const deferred = (0, deferred_1.defer)();
+    f().then(res => {
+        if (isDone) {
+            return;
+        }
+        isDone = true;
+        deferred.resolve(res);
+    }, err => {
+        if (isDone) {
+            return;
+        }
+        isDone = true;
+        deferred.reject(err);
+    });
+    (0, sleep_1.sleep)(timeout).then(() => {
+        if (isDone) {
+            return;
+        }
+        isDone = true;
+        const err = timeoutErr();
+        if (err) {
+            deferred.reject(err);
+        }
+    });
+    return deferred.promise;
+}
+exports.callWithTimeout = callWithTimeout;
+Object.freeze(exports);

package/build/lib-common/random-node.js

@@ -19,11 +19,11 @@ exports.stringOfB64Chars = exports.stringOfB64UrlSafeChars = exports.stringOfB64
 const buffer_utils_1 = require("./buffer-utils");
 const crypto_1 = require("crypto");
 function bytesSync(numOfBytes) {
-    return crypto_1.randomBytes(numOfBytes);
+    return (0, crypto_1.randomBytes)(numOfBytes);
 }
 exports.bytesSync = bytesSync;
 function bytes(numOfBytes) {
-    return new Promise((res, rej) => crypto_1.randomBytes(numOfBytes, (err, buf) => {
+    return new Promise((res, rej) => (0, crypto_1.randomBytes)(numOfBytes, (err, buf) => {
         if (err) {
             rej(err);
         }
@@ -34,15 +34,15 @@ function bytes(numOfBytes) {
 }
 exports.bytes = bytes;
 function uint8Sync() {
-    return crypto_1.randomBytes(1)[0];
+    return (0, crypto_1.randomBytes)(1)[0];
 }
 exports.uint8Sync = uint8Sync;
 async function uint8() {
-    return (await crypto_1.randomBytes(1))[0];
+    return (await (0, crypto_1.randomBytes)(1))[0];
 }
 exports.uint8 = uint8;
 function uint48Sync() {
-    const b = crypto_1.randomBytes(6);
+    const b = (0, crypto_1.randomBytes)(6);
     const l = b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
     const h = b[4] + (b[5] << 8);
     return h * 0x100000000 + l;
@@ -57,13 +57,13 @@ async function uint48() {
 exports.uint48 = uint48;
 function stringOfB64UrlSafeCharsSync(numOfChars) {
     const numOfbytes = 3 * (1 + Math.floor(numOfChars / 4));
-    const byteArr = crypto_1.randomBytes(numOfbytes);
+    const byteArr = (0, crypto_1.randomBytes)(numOfbytes);
     return buffer_utils_1.base64urlSafe.pack(byteArr).substring(0, numOfChars);
 }
 exports.stringOfB64UrlSafeCharsSync = stringOfB64UrlSafeCharsSync;
 function stringOfB64CharsSync(numOfChars) {
     const numOfbytes = 3 * (1 + Math.floor(numOfChars / 4));
-    return crypto_1.randomBytes(numOfbytes).toString('base64').substring(0, numOfChars);
+    return (0, crypto_1.randomBytes)(numOfbytes).toString('base64').substring(0, numOfChars);
 }
 exports.stringOfB64CharsSync = stringOfB64CharsSync;
 async function stringOfB64UrlSafeChars(numOfChars) {