@v1nt1248/3nclient-lib 0.1.13 → 0.1.14

package/dist/utils/index.d.ts

@@ -1,5 +1,6 @@
+export * from './processes';
 export * from './textarea-max-rows';
-export * from './common.utils';
-export * from './ui.utils';
+export * from './common';
+export * from './ui';
 export { SQLiteOn3NStorage } from './sqlite-on-3nstorage';
 export type { BindParams, Database, QueryExecResult } from './sqlite-on-3nstorage';

package/dist/utils/processes.d.ts

@@ -0,0 +1,136 @@
+export declare function sleep(millis: number): Promise<void>;
+/**
+ * Standard Promise has no finally() method, when all respected libraries do.
+ * Inside of an async function one may use try-finally clause. But, when we
+ * work with raw promises, we need a compact finalization routine. And this is
+ * it for synchronous completion.
+ * @param promise
+ * @param fin is a synchronous function that performs necessary
+ * finalization/cleanup. Use finalizeAsync, when finalization is asynchronous.
+ * @return a finalized promise
+ */
+export declare function finalize<T>(promise: Promise<T>, fin: () => void): Promise<T>;
+/**
+ * Standard Promise has no finally() method, when all respected libraries do.
+ * Inside of an async function one may use try-finally clause. But, when we
+ * work with raw promises, we need a compact finalization routine. And this is
+ * it for an asynchronous completion.
+ * @param promise
+ * @param fin is an asynchronous function that performs necessary
+ * finalization/cleanup. Use finalize, when finalization is synchronous
+ * (is not returning promise).
+ * @return a finalized promise
+ */
+export declare function finalizeAsync<T>(promise: Promise<T>, fin: () => Promise<void>): Promise<T>;
+/**
+ * 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
+ * for scheduling, as very often any start of an action must be postponed till
+ * later time. Scheduler needs a not-yet-started activity, as scheduler has
+ * control action's start.
+ */
+export type Action<T> = () => Promise<T>;
+/**
+ * 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
+ * chain process, when needed.
+ *
+ * Common use of such class is to reuse getting of some expensive resource(s).
+ */
+export declare class NamedProcs {
+    private promises;
+    constructor();
+    /**
+     * @param id is a string key of a process
+     * @return a promise of a process' completion, or undefined, if process with
+     * given id is unknown.
+     */
+    getP<T>(id: string): Promise<T> | undefined;
+    private insertPromise;
+    /**
+     * This method will add a promise of an already started process.
+     * @param id is a string key of a process
+     * @param promise of an already started process
+     * @return a promise of a process' completion.
+     */
+    addStarted<T>(id: string, promise: Promise<T>): Promise<T>;
+    /**
+     * This method will start a given action only, if a process with a given id
+     * is not running.
+     * @param id is a string key of a process
+     * @param action is a function that starts some process
+     * @return a promise of a process' completion.
+     */
+    start<T>(id: string, action: Action<T>): Promise<T>;
+    /**
+     * This method will chain a given action to an already running process, or,
+     * if identified process is not running, this will start given action under
+     * a given id.
+     * @param id is a string key of a process
+     * @param action is a function that starts some process
+     * @return a promise of a process' completion.
+     */
+    startOrChain<T>(id: string, action: Action<T>): Promise<T>;
+}
+/**
+ * This is a container of process. It allows to track if a process is already
+ * in progress. It also allows to chain process, when needed.
+ *
+ * Common use of such class is to reuse getting of some expensive resource, or
+ * do ning something as an exclusive process.
+ */
+export declare class SingleProc {
+    private promise;
+    constructor();
+    private insertPromise;
+    getP<T>(): Promise<T> | undefined;
+    addStarted<T>(promise: Promise<T>): Promise<T>;
+    start<T>(action: Action<T>): Promise<T>;
+    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;
+/**
+ * This is a cycling process, that ensures single execution.
+ * It cycles while given "while" predicate returns true. When predicate returns
+ * false, process goes to idle. Pushing this process into action is done via
+ * startIfIdle() method.
+ */
+export declare class SingleCyclicProc {
+    private cycleWhile;
+    private action;
+    private proc;
+    /**
+     * @param cycleWhile is a "while" predicate. When it returns true, process
+     * continues to cycle, and when it returns false, process goes to idle.
+     * @param action is an async cycle body to run at each iteration.
+     */
+    constructor(cycleWhile: () => boolean, action: () => Promise<void>);
+    /**
+     * This starts process, if it is idle.
+     */
+    startIfIdle(): void;
+    private cycleOrIdle;
+    isRunning(): boolean;
+    /**
+     * This makes process unusable and unstartable. Waiting on a return promise,
+     * awaits the completion of the last iteration this process is in (if any).
+     */
+    close(): Promise<void>;
+}
+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/package.json

@@ -2,7 +2,7 @@
   "name": "@v1nt1248/3nclient-lib",
   "license": "AGPL-3.0-or-later",
   "author": "v1nt1248",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "description": "Library for 3NWeb clients",
   "type": "module",
   "files": [