@kizmann/pico-js 2.0.7 → 2.0.9

package/src/utils/{Runner.js → Runner.ts}

@@ -1,12 +1,39 @@
-import { Arr, Hash, Mix, Obj } from "../index.esm.js";
+import { Arr, Mix, Obj } from "../index.esm.ts";
 
 export class PicoRunner
 {
-    static $idler = null;
+    /**
+     * @type {any}
+     */
+    static $idler : any = null;
 
-    static $timer = 0;
+    /**
+     * @type {number}
+     */
+    static $timer : number = 0;
 
-    static $buffer = [];
+    /**
+     * @type {any[]}
+     */
+    static $buffer : any[] = [];
+
+    /**
+     * Run interval and return clear function
+     *
+     * @example Run.interval(cb, 100)
+     *
+     * @param {Function} fn Callback function
+     * @param {number} [intval] Callback interval
+     * @returns {Function} Noop clear function
+     */
+    static interval(fn : Function, intval : number = 0) : Function
+    {
+        const idle = setInterval(() => {
+            fn();
+        }, intval);
+
+        return () => clearInterval(idle);
+    }
 
     /**
      * Clear timer or call function
@@ -14,12 +41,12 @@ export class PicoRunner
      * @example Run.clear(timer)
      *
      * @param {any} timer Timer ID, array of IDs, or function
-     * @returns {typeof PicoRunner} Static class
+     * @returns {PicoRunner} Static class
      */
-    static clear(timer)
+    static clear(timer : any) : PicoRunner
     {
         if ( Mix.isArr(timer) ) {
-            return Arr.each(timer, (t) => this.clear(t), this);
+            return Arr.each(timer, (t : any) => this.clear(t), this);
         }
 
         if ( Mix.isFunc(timer) ) {
@@ -35,13 +62,13 @@ export class PicoRunner
     /**
      * Request idle callback with fallback
      *
-     * @param {function} cb Callback function
-     * @returns {typeof PicoRunner} Static class
+     * @param {Function} cb Callback function
+     * @returns {PicoRunner} Static class
      */
-    static tryin(cb)
+    static tryin(cb : Function) : PicoRunner
     {
         try {
-            requestIdleCallback(cb);
+            cb();
         } catch (e) {
             //
         }
@@ -57,11 +84,11 @@ export class PicoRunner
      * @param {function} fn Condition function
      * @param {number} [intval] Interval ms
      * @param {number} [limit] Max iterations
-     * @returns {function} Clear function
+     * @returns {Function} Clear function
      */
-    static wait(fn, intval = 0, limit = 500)
+    static wait(fn : Function, intval : number = 0, limit : number = 500) : Function
     {
-        let idler, timer;
+        let idler : any, timer : any;
 
         timer = setTimeout(() => {
             this.clear([idler, timer]);
@@ -79,35 +106,16 @@ export class PicoRunner
      *
      * @example Run.frame(cb)
      *
-     * @param {function} fn Callback function
-     * @param {any} [...args] Callback arguments
-     * @returns {function} Noop clear function
+     * @param {Function} fn Callback function
+     * @returns {Function} Noop clear function
      */
-    static frame(fn, ...args)
+    static frame(fn : Function) : Function
     {
-        requestAnimationFrame(() => {
-            fn(...args)
+        const frame = requestAnimationFrame(() => {
+            fn();
         });
 
-        return () => null;
-    }
-
-    /**
-     * Run function when browser is idle
-     *
-     * @example Run.idle(cb)
-     *
-     * @param {function} fn Callback function
-     * @param {any} [...args] Callback arguments
-     * @returns {function} Noop clear function
-     */
-    static idle(fn, ...args)
-    {
-        requestIdleCallback(() => {
-            fn(...args)
-        });
-
-        return () => null;
+        return () => cancelAnimationFrame(frame);
     }
 
     /**
@@ -115,17 +123,16 @@ export class PicoRunner
      *
      * @example Run.async(cb)
      *
-     * @param {function} fn Callback function
-     * @param {any} [...args] Callback arguments
-     * @returns {function} Noop clear function
+     * @param {Function} fn Callback function
+     * @returns {Function} Noop clear function
      */
-    static async(fn, ...args)
+    static async(fn : Function) : Function
     {
-        setTimeout(() => {
-            fn(...args)
+        const idle = setTimeout(() => {
+            fn()
         });
 
-        return () => null;
+        return () => clearTimeout(idle);
     }
 
     /**
@@ -133,15 +140,14 @@ export class PicoRunner
      *
      * @example Run.delay(cb, 100)
      *
-     * @param {function} fn Callback function
+     * @param {Function} fn Callback function
      * @param {number} [delay] Delay ms
-     * @param {any} [...args] Callback arguments
-     * @returns {function} Clear function
+     * @returns {Function} Clear function
      */
-    static delay(fn, delay = 0, ...args)
+    static delay(fn : Function, delay : number = 0) : Function
     {
         let idler = setTimeout(() => {
-            fn(...args);
+            fn();
         }, delay);
 
         return () => clearTimeout(idler);
@@ -152,22 +158,22 @@ export class PicoRunner
      *
      * @example const fn = Run.debounce(cb, 100)
      *
-     * @param {function} cb Callback to run
+     * @param {Function} cb Callback to run
      * @param {number} [timeout] Wait ms
-     * @returns {function} Debounced fn
+     * @returns {Function} Debounced fn
      */
-    static debounce(cb, timeout = 100)
+    static debounce(cb : Function, timeout : number = 100) : Function
     {
         let idler = null;
 
-        return (...args) => {
+        return (...args : any[]) => {
 
             if ( idler ) {
                 clearTimeout(idler);
             }
 
             idler = setTimeout(() => {
-                this.frame(cb, ...args);
+                this.frame(() => cb(...args));
             }, timeout);
         };
     }
@@ -177,15 +183,15 @@ export class PicoRunner
      *
      * @example const fn = Run.throttle(cb, 100)
      *
-     * @param {function} cb Callback to run
+     * @param {Function} cb Callback to run
      * @param {number} [timeout] Wait ms
-     * @returns {function} Throttled fn
+     * @returns {Function} Throttled fn
      */
-    static throttle(cb, timeout = 100)
+    static throttle(cb : Function, timeout : number = 100) : Function
     {
-        let queued, idler = null;
+        let queued : any, idler : any = null;
 
-        return (...args) => {
+        return (...args : any[]) => {
 
             if ( idler ) {
                 clearTimeout(idler);
@@ -199,7 +205,7 @@ export class PicoRunner
                 return;
             }
 
-            (this.frame(cb, ...args), queued = true);
+            (this.frame(() => cb(...args)), queued = true);
         };
     }
 
@@ -208,22 +214,27 @@ export class PicoRunner
      *
      * @example const fn = Run.framerate(cb, 30)
      *
-     * @param {function} cb Callback to run
+     * @param {Function} cb Callback to run
      * @param {number} [fps] Max frames per sec
-     * @returns {function} Rate-limited fn
+     * @param {boolean} [finish] Finish last frame
+     * @returns {Function} Rate-limited fn
      */
-    static framerate(cb, fps = 30)
+    static framerate(cb : Function, fps : number = 30, finish : boolean = true) : Function
     {
-        let last = 0;
+        let timer : any, last = 0, hertz = 1000 / fps;
 
-        return (...args) => {
+        const fn = (...args : any) => {
 
-            if ( Date.now() - last <= (1000 / fps) ) {
-                return;
+            clearTimeout(timer);
+
+            if ( Date.now() - last <= hertz ) {
+                return finish && (timer = setTimeout(fn, hertz + 1));
             }
 
-            (this.frame(cb, ...args), last = Date.now());
+            (this.frame(() => cb(...args)), last = Date.now());
         };
+
+        return fn;
     }
 
     /**
@@ -231,12 +242,12 @@ export class PicoRunner
      *
      * @example el.onwheel = Run.framebuffer(cb,"wheel")
      *
-     * @param {function} cb Callback to run
+     * @param {Function} cb Callback to run
      * @param {string} key Buffer key
      * @param {number} [priority] Sort priority
-     * @returns {function} Buffered handler
+     * @returns {Function} Buffered handler
      */
-    static framebuffer(cb, key, priority = 1000)
+    static framebuffer(cb : Function, key : string, priority : number = 1000) : Function
     {
         const item = {
             key, cb, priority, args: [], active: false
@@ -244,7 +255,7 @@ export class PicoRunner
 
         Arr.add(this.$buffer, item);
 
-        return (e, ...args) => {
+        return (e : any, ...args : any) => {
 
             if ( /^drag/.test(e.type) ) {
                 e.preventDefault();
@@ -265,7 +276,7 @@ export class PicoRunner
      *
      * @returns {void} No return value
      */
-    static runFramebuffer()
+    static runFramebuffer() : void
     {
         if ( this.$idler ) {
             clearTimeout(this.$idler);
@@ -295,8 +306,9 @@ export class PicoRunner
 
         buffer = Arr.sort(buffer, 'priority');
 
-        Arr.each(buffer.reverse(), (item) => {
-            item.cb(...item.args); item.active = false;
+        Arr.each(buffer.reverse(), (item : any) => {
+            item.cb(...item.args);
+            item.active = false;
         });
     }
 

package/src/utils/{Signal.js → Signal.ts}

@@ -1,4 +1,4 @@
-import { Str, Event, For, Mix, Arr } from "../index.esm.js";
+import { Str, Event, For, Mix, Arr } from "../index.esm.ts";
 
 export class PicoSignal
 {
@@ -10,16 +10,21 @@ export class PicoSignal
      * @example Event.bind("x", cb) // => Event
      * @example Event.bind(["a","b"], cb) // => Event
      *
-     * @param {any} event Event name(s)
-     * @param {function} cb Event callback
+     * @param {string|string[]} event Event name(s)
+     * @param {Function} cb Event callback
      * @param {any} [options] Listener options
      * @param {boolean} [paused] Start paused
-     * @returns {typeof PicoSignal} Event class
+     * @returns {PicoSignal} Event class
      */
-    static bind(event, cb, options = {}, paused = false)
+    static bind(event : string | string[], cb : Function, options : any = {}, paused : boolean = false) : PicoSignal
     {
+        const args : any[] = [
+            cb, options, paused
+        ];
+
         if ( Mix.isArr(event) ) {
-            return Arr.each(event, (e) => this.bind(e, ...arguments), this);
+            // @ts-ignore
+            return Arr.each(event, (e : any) => this.bind(e, ...args), this);
         }
 
         if ( Mix.isPrim(options) ) {
@@ -39,14 +44,18 @@ export class PicoSignal
      * @example Event.unbind("x") // => Event
      * @example Event.unbind(["a","b"]) // => Event
      *
-     * @param {any} event Event name(s)
+     * @param {string|string[]} event Event name(s)
      * @param {any} [options] Listener options
-     * @returns {typeof PicoSignal} Event class
+     * @returns {PicoSignal} Event class
      */
-    static unbind(event, options = {})
+    static unbind(event : string | string[], options : any = {}) : PicoSignal
     {
+        const args : any[] = [
+            options,
+        ];
+
         if ( Mix.isArr(event) ) {
-            return Arr.each(event, (e) => this.unbind(e, ...arguments), this);
+            return Arr.each(event, (e : any) => this.unbind(e, ...args), this);
         }
 
         if ( Mix.isPrim(options) ) {
@@ -67,16 +76,16 @@ export class PicoSignal
      *
      * @param {string} event Event name
      * @param {...any} args Event args
-     * @returns {typeof PicoSignal} Event class
+     * @returns {PicoSignal} Event class
      */
-    static fire(event, ...args)
+    static fire(event : string, ...args : Parameters<any>) : PicoSignal
     {
         let events = this.$events.filter((item) => {
             return item.event === event;
         });
 
-        Arr.each(events, (e) => {
-            if ( ! e.paused ) {
+        Arr.each(events, (e : any) => {
+            if ( !e.paused ) {
                 e.cb.call({}, ...args);
             }
         });
@@ -89,14 +98,18 @@ export class PicoSignal
      *
      * @example Event.pause("x") // => Event
      *
-     * @param {any} event Event name(s)
+     * @param {string|string[]} event Event name(s)
      * @param {any} [options] Listener options
-     * @returns {typeof PicoSignal} Event class
+     * @returns {PicoSignal} Event class
      */
-    static pause(event, options = {})
+    static pause(event : string | string[], options : any = {}) : PicoSignal
     {
+        const args : any[] = [
+            options,
+        ];
+
         if ( Mix.isArr(event) ) {
-            return Arr.each(event, (e) => this.pause(e, ...arguments), this);
+            return Arr.each(event, (e : any) => this.pause(e, ...args), this);
         }
 
         let value = Arr.find(this.$events, {
@@ -115,14 +128,14 @@ export class PicoSignal
      *
      * @example Event.unpause("x") // => Event
      *
-     * @param {any} event Event name(s)
+     * @param {string|string[]} event Event name(s)
      * @param {any} [options] Listener options
-     * @returns {typeof PicoSignal} Event class
+     * @returns {PicoSignal} Event class
      */
-    static unpause(event, options = {})
+    static unpause(event : string | string[], options : any = {}) : PicoSignal
     {
         if ( Mix.isArr(event) ) {
-            return Arr.each(event, (e) => this.pause(e, ...arguments), this);
+            return Arr.each(event, (e : any) => this.pause(e, ...arguments), this);
         }
 
         let value = Arr.find(this.$events, {