core-3nweb-client-lib 0.25.6 → 0.26.0

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>;
-}

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 = 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 = deferred_1.defer();
+    f().then(res => {
+        if (isDone) {
+            return;
+        }
+        isDone = true;
+        deferred.resolve(res);
+    }, err => {
+        if (isDone) {
+            return;
+        }
+        isDone = true;
+        deferred.reject(err);
+    });
+    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/service-api/3nstorage/owner.d.ts

@@ -67,10 +67,11 @@ export interface GetObjQueryOpts {
 }
 export interface PutObjFirstQueryOpts {
     /**
-     * This is a new object version parameter. When it is 1 (one), new object
-     * should be created. If it is greater than one, changes are accepted only
-     * when a current version on the server is (ver-1), ensuring that a client
-     * knows current version on server to advance it.
+     * This is a flag to indicate that new object should be created.
+     */
+    create?: boolean;
+    /**
+     * This parameter is object's new version.
      */
     ver: number;
     /**

package/build/lib-common/service-api/3nstorage/owner.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2015 - 2017, 2019 3NSoft Inc.
+ 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
@@ -13,7 +13,8 @@
  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/>. */
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.objRemoved = exports.objChanged = exports.wsEventChannel = exports.archiveRoot = exports.archiveObj = exports.cancelRootTransaction = exports.cancelTransaction = exports.addDiffSectionTo = exports.sanitizedDiff = exports.archivedRootVersion = exports.archivedObjVersion = exports.currentRootObj = exports.currentObj = exports.keyDerivParams = exports.PARAM_SC = exports.sessionParams = exports.closeSession = exports.midLogin = exports.BIN_TYPE = exports.HTTP_HEADER = exports.ERR_SC = void 0;
 /**

package/build/lib-common/utils-for-observables.d.ts

@@ -1,4 +1,4 @@
-import { Observable } from 'rxjs';
+import { Observable, PartialObserver } from 'rxjs';
 /**
  * This is a pipeable operator that runs given async process on completion and
  * sends result downstream, followed by complete signal.
@@ -22,3 +22,17 @@ export declare function allowOnlySingleStart<T>(): (src: Observable<T>) => Obser
  * @param onComplete
  */
 export declare function flatTap<T>(onNext: ((x: T) => Promise<void>) | undefined | null, onError?: ((err: any) => Promise<void>) | undefined | null, onComplete?: (() => Promise<void>) | undefined | null): (src: Observable<T>) => Observable<T>;
+/**
+ * @param obs
+ * @return given observer, or one with noop's in place of missing functions
+ */
+export declare function toRxObserver<T>(obs: web3n.Observer<T>): PartialObserver<T>;
+export declare class Broadcast<T> {
+    private readonly src;
+    readonly event$: Observable<T>;
+    private sub;
+    constructor();
+    next(ev: T): void;
+    done(err?: any): void;
+    isON(): boolean;
+}