@etsoo/shared 1.2.45 → 1.2.46

package/README.md

@@ -241,8 +241,10 @@ Extend current class/object functioning
 |---:|---|
 |applyMixins|Apply mixins to current class|
 |delayedExecutor|Create delayed executor|
+|intervalFor|Repeat interval for callback|
 |promiseHandler|Promise handler to catch error|
 |sleep|Delay promise|
+|waitFor|Wait for condition meets and execute callback|
 
 ## NumberUtils
 Numbers related utilities

package/lib/cjs/ExtendUtils.d.ts

@@ -31,8 +31,15 @@ export declare namespace ExtendUtils {
      * Wait for condition meets and execute callback
      * requestAnimationFrame to replace setTimeout
      * @param callback Callback
-     * @param checkReady Check ready, when it's a number, similar to setTimeout
+     * @param checkReady Check ready, when it's a number as miliseconds, similar to setTimeout
      * @returns cancel callback
      */
     function waitFor(callback: () => void, checkReady: ((spanTime: number) => boolean) | number): () => void;
+    /**
+     * Repeat interval for callback
+     * @param callback Callback
+     * @param miliseconds Miliseconds
+     * @returns cancel callback
+     */
+    function intervalFor(callback: () => void, miliseconds: number): () => void;
 }

package/lib/cjs/ExtendUtils.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExtendUtils = void 0;
+const hasRequestAnimationFrame = typeof requestAnimationFrame === 'function';
 /**
  * Extend utilities
  */
@@ -85,38 +86,113 @@ var ExtendUtils;
      * Wait for condition meets and execute callback
      * requestAnimationFrame to replace setTimeout
      * @param callback Callback
-     * @param checkReady Check ready, when it's a number, similar to setTimeout
+     * @param checkReady Check ready, when it's a number as miliseconds, similar to setTimeout
      * @returns cancel callback
      */
     function waitFor(callback, checkReady) {
-        let startTime;
         let requestID;
-        function doWait(time) {
-            // Reset request id
-            requestID = undefined;
-            // First time
-            if (startTime == null)
-                startTime = time;
-            // Ignore
-            if (startTime === 0)
-                return;
-            const spanTime = startTime == null || time == null ? 0 : time - startTime;
-            if (time != null &&
-                (typeof checkReady === 'number'
-                    ? spanTime >= checkReady
-                    : checkReady(spanTime))) {
-                callback();
+        if (hasRequestAnimationFrame) {
+            let lastTime;
+            function loop(timestamp) {
+                // Cancelled
+                if (requestID == null)
+                    return;
+                if (lastTime === undefined) {
+                    lastTime = timestamp;
+                }
+                const elapsed = timestamp - lastTime;
+                const isReady = typeof checkReady === 'number'
+                    ? elapsed >= checkReady
+                    : checkReady(elapsed);
+                if (isReady) {
+                    callback();
+                }
+                else if (requestID != null) {
+                    // May also be cancelled in callback or somewhere
+                    requestID = requestAnimationFrame(loop);
+                }
             }
-            else {
-                requestID = requestAnimationFrame(doWait);
+            requestID = requestAnimationFrame(loop);
+        }
+        else if (typeof checkReady === 'number') {
+            requestID = setTimeout(callback, checkReady);
+        }
+        else {
+            // Bad practice to use setTimeout in this way, only for compatibility
+            const ms = 20;
+            let spanTime = 0;
+            let cr = checkReady;
+            function loop() {
+                // Cancelled
+                if (requestID == null)
+                    return;
+                spanTime += ms;
+                if (cr(spanTime)) {
+                    callback();
+                }
+                else if (requestID != null) {
+                    // May also be cancelled in callback or somewhere
+                    requestID = setTimeout(loop, ms);
+                }
             }
+            requestID = setTimeout(loop, ms);
         }
-        doWait();
         return () => {
-            if (requestID)
-                cancelAnimationFrame(requestID);
-            startTime = undefined;
+            if (requestID) {
+                if (hasRequestAnimationFrame && typeof requestID === 'number') {
+                    cancelAnimationFrame(requestID);
+                }
+                else {
+                    clearTimeout(requestID);
+                }
+                requestID = undefined;
+            }
         };
     }
     ExtendUtils.waitFor = waitFor;
+    /**
+     * Repeat interval for callback
+     * @param callback Callback
+     * @param miliseconds Miliseconds
+     * @returns cancel callback
+     */
+    function intervalFor(callback, miliseconds) {
+        let requestID;
+        if (hasRequestAnimationFrame) {
+            let lastTime;
+            function loop(timestamp) {
+                // Cancelled
+                if (requestID == null)
+                    return;
+                if (lastTime === undefined) {
+                    lastTime = timestamp;
+                }
+                const elapsed = timestamp - lastTime;
+                if (elapsed >= miliseconds) {
+                    lastTime = timestamp;
+                    callback();
+                }
+                if (requestID != null) {
+                    // May also be cancelled in callback or somewhere
+                    requestID = requestAnimationFrame(loop);
+                }
+            }
+            requestID = requestAnimationFrame(loop);
+        }
+        else {
+            requestID = setInterval(callback, miliseconds);
+        }
+        return () => {
+            if (requestID) {
+                if (hasRequestAnimationFrame && typeof requestID === 'number') {
+                    cancelAnimationFrame(requestID);
+                }
+                else {
+                    clearInterval(requestID);
+                }
+                requestID = undefined;
+            }
+        };
+    }
+    ExtendUtils.intervalFor = intervalFor;
 })(ExtendUtils || (exports.ExtendUtils = ExtendUtils = {}));

package/lib/mjs/ExtendUtils.d.ts

@@ -31,8 +31,15 @@ export declare namespace ExtendUtils {
      * Wait for condition meets and execute callback
      * requestAnimationFrame to replace setTimeout
      * @param callback Callback
-     * @param checkReady Check ready, when it's a number, similar to setTimeout
+     * @param checkReady Check ready, when it's a number as miliseconds, similar to setTimeout
      * @returns cancel callback
      */
     function waitFor(callback: () => void, checkReady: ((spanTime: number) => boolean) | number): () => void;
+    /**
+     * Repeat interval for callback
+     * @param callback Callback
+     * @param miliseconds Miliseconds
+     * @returns cancel callback
+     */
+    function intervalFor(callback: () => void, miliseconds: number): () => void;
 }

package/lib/mjs/ExtendUtils.js

@@ -1,3 +1,4 @@
+const hasRequestAnimationFrame = typeof requestAnimationFrame === 'function';
 /**
  * Extend utilities
  */
@@ -82,38 +83,113 @@ export var ExtendUtils;
      * Wait for condition meets and execute callback
      * requestAnimationFrame to replace setTimeout
      * @param callback Callback
-     * @param checkReady Check ready, when it's a number, similar to setTimeout
+     * @param checkReady Check ready, when it's a number as miliseconds, similar to setTimeout
      * @returns cancel callback
      */
     function waitFor(callback, checkReady) {
-        let startTime;
         let requestID;
-        function doWait(time) {
-            // Reset request id
-            requestID = undefined;
-            // First time
-            if (startTime == null)
-                startTime = time;
-            // Ignore
-            if (startTime === 0)
-                return;
-            const spanTime = startTime == null || time == null ? 0 : time - startTime;
-            if (time != null &&
-                (typeof checkReady === 'number'
-                    ? spanTime >= checkReady
-                    : checkReady(spanTime))) {
-                callback();
+        if (hasRequestAnimationFrame) {
+            let lastTime;
+            function loop(timestamp) {
+                // Cancelled
+                if (requestID == null)
+                    return;
+                if (lastTime === undefined) {
+                    lastTime = timestamp;
+                }
+                const elapsed = timestamp - lastTime;
+                const isReady = typeof checkReady === 'number'
+                    ? elapsed >= checkReady
+                    : checkReady(elapsed);
+                if (isReady) {
+                    callback();
+                }
+                else if (requestID != null) {
+                    // May also be cancelled in callback or somewhere
+                    requestID = requestAnimationFrame(loop);
+                }
             }
-            else {
-                requestID = requestAnimationFrame(doWait);
+            requestID = requestAnimationFrame(loop);
+        }
+        else if (typeof checkReady === 'number') {
+            requestID = setTimeout(callback, checkReady);
+        }
+        else {
+            // Bad practice to use setTimeout in this way, only for compatibility
+            const ms = 20;
+            let spanTime = 0;
+            let cr = checkReady;
+            function loop() {
+                // Cancelled
+                if (requestID == null)
+                    return;
+                spanTime += ms;
+                if (cr(spanTime)) {
+                    callback();
+                }
+                else if (requestID != null) {
+                    // May also be cancelled in callback or somewhere
+                    requestID = setTimeout(loop, ms);
+                }
             }
+            requestID = setTimeout(loop, ms);
         }
-        doWait();
         return () => {
-            if (requestID)
-                cancelAnimationFrame(requestID);
-            startTime = undefined;
+            if (requestID) {
+                if (hasRequestAnimationFrame && typeof requestID === 'number') {
+                    cancelAnimationFrame(requestID);
+                }
+                else {
+                    clearTimeout(requestID);
+                }
+                requestID = undefined;
+            }
         };
     }
     ExtendUtils.waitFor = waitFor;
+    /**
+     * Repeat interval for callback
+     * @param callback Callback
+     * @param miliseconds Miliseconds
+     * @returns cancel callback
+     */
+    function intervalFor(callback, miliseconds) {
+        let requestID;
+        if (hasRequestAnimationFrame) {
+            let lastTime;
+            function loop(timestamp) {
+                // Cancelled
+                if (requestID == null)
+                    return;
+                if (lastTime === undefined) {
+                    lastTime = timestamp;
+                }
+                const elapsed = timestamp - lastTime;
+                if (elapsed >= miliseconds) {
+                    lastTime = timestamp;
+                    callback();
+                }
+                if (requestID != null) {
+                    // May also be cancelled in callback or somewhere
+                    requestID = requestAnimationFrame(loop);
+                }
+            }
+            requestID = requestAnimationFrame(loop);
+        }
+        else {
+            requestID = setInterval(callback, miliseconds);
+        }
+        return () => {
+            if (requestID) {
+                if (hasRequestAnimationFrame && typeof requestID === 'number') {
+                    cancelAnimationFrame(requestID);
+                }
+                else {
+                    clearInterval(requestID);
+                }
+                requestID = undefined;
+            }
+        };
+    }
+    ExtendUtils.intervalFor = intervalFor;
 })(ExtendUtils || (ExtendUtils = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@etsoo/shared",
-    "version": "1.2.45",
+    "version": "1.2.46",
     "description": "TypeScript shared utilities and functions",
     "main": "lib/cjs/index.js",
     "module": "lib/mjs/index.js",

package/src/ExtendUtils.ts

@@ -1,5 +1,7 @@
 import { DelayedExecutorType } from './types/DelayedExecutorType';
 
+const hasRequestAnimationFrame = typeof requestAnimationFrame === 'function';
+
 /**
  * Extend utilities
  */
@@ -89,44 +91,119 @@ export namespace ExtendUtils {
      * Wait for condition meets and execute callback
      * requestAnimationFrame to replace setTimeout
      * @param callback Callback
-     * @param checkReady Check ready, when it's a number, similar to setTimeout
+     * @param checkReady Check ready, when it's a number as miliseconds, similar to setTimeout
      * @returns cancel callback
      */
     export function waitFor(
         callback: () => void,
         checkReady: ((spanTime: number) => boolean) | number
     ) {
-        let startTime: number | undefined;
-        let requestID: number | undefined;
-        function doWait(time?: number) {
-            // Reset request id
-            requestID = undefined;
-
-            // First time
-            if (startTime == null) startTime = time;
-
-            // Ignore
-            if (startTime === 0) return;
-
-            const spanTime =
-                startTime == null || time == null ? 0 : time - startTime;
-            if (
-                time != null &&
-                (typeof checkReady === 'number'
-                    ? spanTime >= checkReady
-                    : checkReady(spanTime))
-            ) {
-                callback();
-            } else {
-                requestID = requestAnimationFrame(doWait);
+        let requestID: number | undefined | NodeJS.Timeout;
+
+        if (hasRequestAnimationFrame) {
+            let lastTime: number | undefined;
+            function loop(timestamp: number) {
+                // Cancelled
+                if (requestID == null) return;
+
+                if (lastTime === undefined) {
+                    lastTime = timestamp;
+                }
+
+                const elapsed = timestamp - lastTime;
+
+                const isReady =
+                    typeof checkReady === 'number'
+                        ? elapsed >= checkReady
+                        : checkReady(elapsed);
+
+                if (isReady) {
+                    callback();
+                } else if (requestID != null) {
+                    // May also be cancelled in callback or somewhere
+                    requestID = requestAnimationFrame(loop);
+                }
             }
+            requestID = requestAnimationFrame(loop);
+        } else if (typeof checkReady === 'number') {
+            requestID = setTimeout(callback, checkReady);
+        } else {
+            // Bad practice to use setTimeout in this way, only for compatibility
+            const ms = 20;
+            let spanTime = 0;
+            let cr = checkReady;
+            function loop() {
+                // Cancelled
+                if (requestID == null) return;
+
+                spanTime += ms;
+
+                if (cr(spanTime)) {
+                    callback();
+                } else if (requestID != null) {
+                    // May also be cancelled in callback or somewhere
+                    requestID = setTimeout(loop, ms);
+                }
+            }
+            requestID = setTimeout(loop, ms);
         }
 
-        doWait();
+        return () => {
+            if (requestID) {
+                if (hasRequestAnimationFrame && typeof requestID === 'number') {
+                    cancelAnimationFrame(requestID);
+                } else {
+                    clearTimeout(requestID);
+                }
+                requestID = undefined;
+            }
+        };
+    }
+
+    /**
+     * Repeat interval for callback
+     * @param callback Callback
+     * @param miliseconds Miliseconds
+     * @returns cancel callback
+     */
+    export function intervalFor(callback: () => void, miliseconds: number) {
+        let requestID: number | undefined | NodeJS.Timer;
+
+        if (hasRequestAnimationFrame) {
+            let lastTime: number | undefined;
+            function loop(timestamp: number) {
+                // Cancelled
+                if (requestID == null) return;
+
+                if (lastTime === undefined) {
+                    lastTime = timestamp;
+                }
+
+                const elapsed = timestamp - lastTime;
+                if (elapsed >= miliseconds) {
+                    lastTime = timestamp;
+                    callback();
+                }
+
+                if (requestID != null) {
+                    // May also be cancelled in callback or somewhere
+                    requestID = requestAnimationFrame(loop);
+                }
+            }
+            requestID = requestAnimationFrame(loop);
+        } else {
+            requestID = setInterval(callback, miliseconds);
+        }
 
         return () => {
-            if (requestID) cancelAnimationFrame(requestID);
-            startTime = undefined;
+            if (requestID) {
+                if (hasRequestAnimationFrame && typeof requestID === 'number') {
+                    cancelAnimationFrame(requestID);
+                } else {
+                    clearInterval(requestID);
+                }
+                requestID = undefined;
+            }
         };
     }
 }