@fbltd/async 1.0.6 → 1.0.8

package/README.md

@@ -1,10 +1,37 @@
-### R&D async tools ###
+# Async tools
 
-First of all, attention paid to creation of reactive model
-leveraging native JavaScript async features like Promises, (async) iterators
-and generators.
+## delay
+delay is a function that can be executed synchronous or asynchronous.
+The behaviour depends on passed arguments:
+```typescript
+// Returns a promise - asynchrounous running in a non-blocking manner;
+await delay(number);
+
+// Returns nothing - synchrounous running in a blocking manner;
+delay(number, true);
+```
+
+## getPromise
+getPromise is a function that creates and returns promise, its fulfillment functions
+and status flags.
+Returned type is:
+```typescript
+type IPromiseConfiguration<T> = {
+    resolve(arg: T): void, // function that resolves promise
+    reject(err: Error): void, // function that rejects promise
+    promise: Promise<T>,        // promise itself
+    readonly isPending: boolean, // promise status flag
+    readonly isFulfilled: boolean, // reverted promise status flag
+} 
+```
+There is no any management of passed data for resolving.
+Returned promise is usual ES promise so it is impossible to fulfill promise twice.
 
-The version is 0.0.0 so keep it in mind
+## DependencyStream
+### core
+Implementation of reactive model leveraging native JavaScript async features like
+Promises, (async) iterators and generators.
+The version is 0.0.x so keep it in mind
 
 ```typescript
 const counter = new DependencyStream<number>(0);
@@ -32,6 +59,8 @@ setInterval(() => {
 }, 1000)
 ```
 
+### Framework integrations
+#### React
 Of course, there is a React integration via useStream hook:
 
 ```typescript jsx
@@ -70,4 +99,5 @@ export const Counter: React.FC<ITest> = React.memo(({
 })
 ```
 
-Now this package is CommonJS module but should be ESM.
+## Disclaimer
+Now this package is CommonJS module but should be an ESM.

package/dist/bin/core/dependency-stream.js

@@ -7,26 +7,26 @@ function baseComparer(prev, cur) {
 }
 class DependencyStream {
     _value;
-    promiseConf;
+    reactionPromise;
     abortPromise = (0, utils_1.getPromise)();
     config;
     constructor(_value, config = {}) {
         this._value = _value;
         this.config = {
-            isEqual: baseComparer,
+            withCustomEquality: baseComparer,
+            withReactionOnSubscribe: false,
             ...config,
         };
     }
-    _set(v, force) {
-        if (!force) {
-            if (this.config.isEqual(this._value, v)) {
-                return;
-            }
-        }
-        if (v === this._value)
+    _set(v) {
+        if (this.config.withCustomEquality(this._value, v)) {
             return;
+        }
         this._value = v;
-        this.promiseConf && this.promiseConf.resolve(v);
+        if (this.reactionPromise) {
+            this.reactionPromise.resolve(v);
+            this.reactionPromise = undefined;
+        }
     }
     set value(v) {
         this._set(v);
@@ -37,28 +37,37 @@ class DependencyStream {
     [Symbol.asyncIterator]() {
         const totalDispose = this.abortPromise;
         const selfDispose = (0, utils_1.getPromise)();
+        const externalPromises = [totalDispose.promise, selfDispose.promise];
+        let firstPromise;
+        if (this.config.withReactionOnSubscribe) {
+            firstPromise = (0, utils_1.getPromise)();
+            firstPromise.resolve(this.value);
+            externalPromises.push(firstPromise.promise);
+        }
+        const owner = this;
         return {
-            owner: this,
+            owner,
             dispose: () => selfDispose.resolve(),
             next: async () => {
-                if (!this.promiseConf) {
-                    this.promiseConf = (0, utils_1.getPromise)();
+                if (!this.reactionPromise) {
+                    this.reactionPromise = (0, utils_1.getPromise)();
                     this._set(this._value);
                 }
                 await Promise.race([
-                    totalDispose.promise,
-                    selfDispose.promise,
-                    this.promiseConf.promise,
+                    ...externalPromises,
+                    this.reactionPromise.promise,
                 ]);
-                this.promiseConf = undefined;
                 if (totalDispose.isFulfilled || selfDispose.isFulfilled) {
                     return { done: true };
                 }
-                const value = this.value;
+                if (firstPromise) {
+                    firstPromise = undefined;
+                    externalPromises.pop();
+                }
                 return {
                     done: false,
                     get value() {
-                        return value;
+                        return owner.value;
                     }
                 };
             }
@@ -67,6 +76,7 @@ class DependencyStream {
     dispose() {
         this.abortPromise.resolve();
         this.abortPromise = (0, utils_1.getPromise)();
+        this.reactionPromise = undefined;
     }
 }
 exports.DependencyStream = DependencyStream;

package/dist/bin/utils/delay.js

@@ -2,11 +2,26 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.delay = delay;
 const get_promise_1 = require("./get-promise");
-function delay(ms = 0) {
+function delay(ms = 0, sync) {
     ms = Math.max(ms, 0);
-    const { promise, resolve } = (0, get_promise_1.getPromise)();
-    setTimeout(() => {
-        resolve();
-    }, ms);
-    return promise;
+    return delay.methods[typeof sync](ms);
 }
+Object.defineProperty(delay, 'methods', {
+    value: {
+        boolean: (ms) => {
+            const start = performance.now();
+            while (true) {
+                if (performance.now() - start >= ms) {
+                    return;
+                }
+            }
+        },
+        undefined: (ms) => {
+            const { promise, resolve } = (0, get_promise_1.getPromise)();
+            setTimeout(() => {
+                resolve();
+            }, ms);
+            return promise;
+        }
+    }
+});

package/dist/types/core/dependency-stream.d.ts

@@ -1,12 +1,13 @@
-interface ICompareFn<T> {
+interface IIsEquals<T> {
     (prev: T, cur: T): boolean;
 }
 type IDependencyStreamConfig<T> = {
-    isEqual: ICompareFn<T>;
+    withCustomEquality: IIsEquals<T>;
+    withReactionOnSubscribe: boolean;
 };
 export declare class DependencyStream<T = any> {
     private _value;
-    private promiseConf;
+    private reactionPromise;
     private abortPromise;
     private config;
     constructor(_value: T, config?: Partial<IDependencyStreamConfig<T>>);

package/dist/types/utils/delay.d.ts

@@ -1 +1,2 @@
+export declare function delay(ms: number, sync: true): void;
 export declare function delay(ms?: number): Promise<void>;

package/dist/types/utils/get-promise.d.ts

@@ -5,3 +5,4 @@ export declare function getPromise<TReturn = void>(): {
     readonly isFulfilled: boolean;
     promise: Promise<TReturn>;
 };
+export type IPromiseConfiguration<T = void> = ReturnType<typeof getPromise<T>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fbltd/async",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "R&D async tools",
   "exports": {
     "require": "./dist/bin/index.js",