@fbltd/async 1.0.4 → 1.0.6

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

@@ -2,23 +2,36 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DependencyStream = void 0;
 const utils_1 = require("../utils");
+function baseComparer(prev, cur) {
+    return prev === cur;
+}
 class DependencyStream {
     _value;
-    promise;
+    promiseConf;
     abortPromise = (0, utils_1.getPromise)();
-    constructor(_value) {
+    config;
+    constructor(_value, config = {}) {
         this._value = _value;
+        this.config = {
+            isEqual: baseComparer,
+            ...config,
+        };
     }
-    _set(v) {
+    _set(v, force) {
+        if (!force) {
+            if (this.config.isEqual(this._value, v)) {
+                return;
+            }
+        }
         if (v === this._value)
             return;
         this._value = v;
-        this.promise && this.promise.resolve(v);
+        this.promiseConf && this.promiseConf.resolve(v);
     }
-    set = (v) => {
+    set value(v) {
         this._set(v);
-    };
-    get() {
+    }
+    get value() {
         return this._value;
     }
     [Symbol.asyncIterator]() {
@@ -26,22 +39,22 @@ class DependencyStream {
         const selfDispose = (0, utils_1.getPromise)();
         return {
             owner: this,
-            dispose: () => selfDispose.resolve(undefined),
+            dispose: () => selfDispose.resolve(),
             next: async () => {
-                if (!this.promise) {
-                    this.promise = (0, utils_1.getPromise)();
+                if (!this.promiseConf) {
+                    this.promiseConf = (0, utils_1.getPromise)();
                     this._set(this._value);
                 }
                 await Promise.race([
                     totalDispose.promise,
                     selfDispose.promise,
-                    this.promise.promise,
+                    this.promiseConf.promise,
                 ]);
-                this.promise = undefined;
+                this.promiseConf = undefined;
                 if (totalDispose.isFulfilled || selfDispose.isFulfilled) {
                     return { done: true };
                 }
-                const value = this.get();
+                const value = this.value;
                 return {
                     done: false,
                     get value() {
@@ -52,7 +65,7 @@ class DependencyStream {
         };
     }
     dispose() {
-        this.abortPromise.resolve(undefined);
+        this.abortPromise.resolve();
         this.abortPromise = (0, utils_1.getPromise)();
     }
 }

package/dist/bin/core/utils.js

@@ -37,7 +37,7 @@ function anyStream(...deps) {
                     if (disposed) {
                         return { done: true };
                     }
-                    return { done: false, value: streams.map(s => s.owner.get()) };
+                    return { done: false, value: streams.map(s => s.owner.value) };
                 }
             };
         }

package/dist/bin/react/src/use-stream.js

@@ -23,7 +23,7 @@ class StreamController {
     };
 }
 function useStream(...streams) {
-    const [value, setValue] = (0, react_1.useState)(streams.map(s => s.get()));
+    const [value, setValue] = (0, react_1.useState)(streams.map(s => s.value));
     const [obj] = (0, react_1.useState)(() => ({ controller: new StreamController(...streams) }));
     obj.controller.setValue = setValue;
     (0, react_1.useEffect)(() => {

package/dist/bin/utils/delay.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.delay = delay;
+const get_promise_1 = require("./get-promise");
+function delay(ms = 0) {
+    ms = Math.max(ms, 0);
+    const { promise, resolve } = (0, get_promise_1.getPromise)();
+    setTimeout(() => {
+        resolve();
+    }, ms);
+    return promise;
+}

package/dist/bin/utils/get-promise.js

@@ -7,11 +7,11 @@ function getPromise() {
     let isPending = true;
     let isFulfilled = false;
     const promise = new Promise((res, rej) => {
-        resolve = (value) => {
+        resolve = ((value) => {
             res(value);
             isPending = false;
             isFulfilled = true;
-        };
+        });
         reject = (error) => {
             rej(error);
             isPending = false;

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

@@ -1,11 +1,18 @@
+interface ICompareFn<T> {
+    (prev: T, cur: T): boolean;
+}
+type IDependencyStreamConfig<T> = {
+    isEqual: ICompareFn<T>;
+};
 export declare class DependencyStream<T = any> {
     private _value;
-    private promise;
+    private promiseConf;
     private abortPromise;
-    constructor(_value: T);
+    private config;
+    constructor(_value: T, config?: Partial<IDependencyStreamConfig<T>>);
     private _set;
-    set: (v: T) => void;
-    get(): T;
+    set value(v: T);
+    get value(): T;
     [Symbol.asyncIterator](this: DependencyStream<T>): {
         owner: DependencyStream<T>;
         dispose: () => void;
@@ -19,3 +26,4 @@ export declare class DependencyStream<T = any> {
     };
     dispose(this: DependencyStream<T>): void;
 }
+export {};

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

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

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

@@ -1,4 +1,4 @@
-export declare function getPromise<TReturn>(): {
+export declare function getPromise<TReturn = void>(): {
     resolve: (value: TReturn) => void;
     reject: (value: Error) => void;
     readonly isPending: boolean;

package/package.json

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