@kizmann/pico-js 2.0.4 → 2.0.6

package/src/utils/Runner.js

@@ -1,169 +1,147 @@
-import { Arr, Hash, Mix } from "../index.esm.js";
+import { Arr, Hash, Mix, Obj } from "../index.esm.js";
 
 export class PicoRunner
 {
-    static $idler = {
-        native: {}, debounce: {}, throttle: {}
-    };
+    static $idler = null;
 
-    static $timer = {
-        date: 0, func: null
-    };
+    static $timer = 0;
 
     static $buffer = [];
 
     /**
-     * Run callback after delay (id)
+     * Clear timer or call function
      *
-     * @example Run.timeout(() => {}, 100) // => "t-..."
+     * @example Run.clear(timer)
      *
-     * @param {function} fn Callback to run
-     * @param {number} [delay] Delay ms
-     * @param {string|null} [index] Timer id
-     * @returns {string} Timer id
+     * @param {any} timer Timer ID, array of IDs, or function
+     * @returns {typeof PicoRunner} Static class
      */
-    static timeout(fn, delay = 0, index = null)
+    static clear(timer)
     {
-        let idler = PicoRunner.$idler.native;
+        if ( Mix.isArr(timer) ) {
+            return Arr.each(timer, (t) => this.clear(t), this);
+        }
 
-        if ( index == null ) {
-            index = Hash.make(12);
+        if ( Mix.isFunc(timer) ) {
+            return (timer(), this);
         }
 
-        idler[(index = 't-' + index)] = setInterval(() => {
-            fn();
-        }, delay);
+        clearTimeout(timer);
+        clearInterval(timer);
 
-        return index;
+        return this;
     }
 
     /**
-     * Run callback on interval (id)
+     * Request idle callback with fallback
      *
-     * @example Run.interval(() => {}, 250) // => "i-..."
-     *
-     * @param {function} fn Callback to run
-     * @param {number} [intval] Interval ms
-     * @param {string|null} [index] Timer id
-     * @returns {string} Timer id
+     * @param {function} cb Callback function
+     * @returns {typeof PicoRunner} Static class
      */
-    static interval(fn, intval = 0, index = null)
+    static tryin(cb)
     {
-        let idler = PicoRunner.$idler.native;
-
-        if ( index == null ) {
-            index = Hash.make(12);
+        try {
+            requestIdleCallback(cb);
+        } catch (e) {
+            //
         }
 
-        idler[(index = 'i-' + index)] = setInterval(() => {
-            fn();
-        }, intval);
-
-        return index;
+        return this;
     }
 
     /**
-     * Clear timer(s) by id
+     * Wait for condition to be true
      *
-     * @example Run.clear("i-abc") // => Run
-     * @example Run.clear(["t-a","i-b"]) // => Run
+     * @example Run.wait(() => window.foo, 10, 100)
      *
-     * @param {string|Array<string>} index Timer id(s)
-     * @param {string} [scope] Idler scope key
-     * @returns {typeof PicoRunner} Runner class
+     * @param {function} fn Condition function
+     * @param {number} [intval] Interval ms
+     * @param {number} [limit] Max iterations
+     * @returns {function} Clear function
      */
-    static clear(index, scope = 'native')
+    static wait(fn, intval = 0, limit = 500)
     {
-        if ( Mix.isArr(index) ) {
-            return (Arr.each(index, (e) => this.clear(e, scope)), this);
-        }
-
-        let idler = PicoRunner.$idler[scope];
+        let idler, timer;
 
-        if ( /^i-/.test(index) === false ) {
-            clearInterval(idler[index]);
-        }
+        timer = setTimeout(() => {
+            this.clear([idler, timer]);
+        }, intval * limit);
 
-        if ( /^t-/.test(index) === false ) {
-            clearTimeout(idler[index]);
-        }
+        idler = setInterval(() => {
+            if ( fn() ) this.clear([timer, idler]);
+        }, intval);
 
-        return this;
+        return () => clearInterval(idler);
     }
 
     /**
-     * Poll until callback is true
+     * Run function in next animation frame
      *
-     * @example Run.wait(() => ready, 50) // polls
+     * @example Run.frame(cb)
      *
-     * @param {function} fn Condition callback
-     * @param {number} [intval] Poll interval ms
-     * @param {number} [limit] Max poll count
-     * @returns {void} No return value
+     * @param {function} fn Callback function
+     * @param {any} [...args] Callback arguments
+     * @returns {function} Noop clear function
      */
-    static wait(fn, intval = 0, limit = 500)
+    static frame(fn, ...args)
     {
-        let idler, timer;
-
-        timer = this.timeout(() => {
-            this.clear([idler, timer]);
-        }, intval * limit);
+        requestAnimationFrame(() => {
+            fn(...args)
+        });
 
-        idler = this.interval(() => {
-            if ( fn() ) this.clear([idler, timer]);
-        }, intval);
+        return () => null;
     }
 
     /**
-     * Run callback in next frame
+     * Run function when browser is idle
      *
-     * @example Run.frame(() => {}) // => Run
+     * @example Run.idle(cb)
      *
-     * @param {function} fn Callback to run
-     * @param {...any} args Callback args
-     * @returns {typeof PicoRunner} Runner class
+     * @param {function} fn Callback function
+     * @param {any} [...args] Callback arguments
+     * @returns {function} Noop clear function
      */
-    static frame(fn, ...args)
+    static idle(fn, ...args)
     {
-        requestAnimationFrame(function() {
-            fn(...args);
+        requestIdleCallback(() => {
+            fn(...args)
         });
 
-        return this;
+        return () => null;
     }
 
     /**
-     * Run callback async soon
+     * Run function asynchronously
      *
-     * @example Run.async(() => {}) // => Run
+     * @example Run.async(cb)
      *
-     * @param {function} fn Callback to run
-     * @param {...any} args Callback args
-     * @returns {typeof PicoRunner} Runner class
+     * @param {function} fn Callback function
+     * @param {any} [...args] Callback arguments
+     * @returns {function} Noop clear function
      */
     static async(fn, ...args)
     {
         setTimeout(() => {
-            fn(...args);
+            fn(...args)
         });
 
-        return this;
+        return () => null;
     }
 
     /**
-     * Run callback after delay
+     * Run function after delay
      *
-     * @example const cancel = Run.delay(() => {}, 50)
+     * @example Run.delay(cb, 100)
      *
-     * @param {function} fn Callback to run
+     * @param {function} fn Callback function
      * @param {number} [delay] Delay ms
-     * @param {...any} args Callback args
-     * @returns {function} Cancel function
+     * @param {any} [...args] Callback arguments
+     * @returns {function} Clear function
      */
     static delay(fn, delay = 0, ...args)
     {
         let idler = setTimeout(() => {
-            this.async(fn, ...args);
+            fn(...args);
         }, delay);
 
         return () => clearTimeout(idler);
@@ -176,24 +154,19 @@ export class PicoRunner
      *
      * @param {function} cb Callback to run
      * @param {number} [timeout] Wait ms
-     * @param {string|null} [index] Debounce id
      * @returns {function} Debounced fn
      */
-    static debounce(cb, timeout = 100, index = null)
+    static debounce(cb, timeout = 100)
     {
-        let idler = PicoRunner.$idler.debounce;
-
-        if ( index == null ) {
-            index = Hash.make(12);
-        }
+        let idler = null;
 
         return (...args) => {
 
-            if ( idler[index] ) {
-                clearTimeout(idler[index]);
+            if ( idler ) {
+                clearTimeout(idler);
             }
 
-            idler[index] = setTimeout(() => {
+            idler = setTimeout(() => {
                 this.frame(cb, ...args);
             }, timeout);
         };
@@ -206,24 +179,19 @@ export class PicoRunner
      *
      * @param {function} cb Callback to run
      * @param {number} [timeout] Wait ms
-     * @param {string|null} [index] Throttle id
      * @returns {function} Throttled fn
      */
-    static throttle(cb, timeout = 100, index = null)
+    static throttle(cb, timeout = 100)
     {
-        let queued, idler = PicoRunner.$idler.throttle;
-
-        if ( index == null ) {
-            index = Hash.make(12);
-        }
+        let queued, idler = null;
 
         return (...args) => {
 
-            if ( idler[index] ) {
-                clearTimeout(idler[index]);
+            if ( idler ) {
+                clearTimeout(idler);
             }
 
-            idler[index] = setTimeout(() => {
+            idler = setTimeout(() => {
                 queued = false;
             }, timeout);
 
@@ -231,7 +199,7 @@ export class PicoRunner
                 return;
             }
 
-            (this.frame(cb, ...args), queued = true)
+            (this.frame(cb, ...args), queued = true);
         };
     }
 
@@ -265,18 +233,28 @@ export class PicoRunner
      *
      * @param {function} cb Callback to run
      * @param {string} key Buffer key
-     * @param {number} [order] Sort order
+     * @param {number} [priority] Sort priority
      * @returns {function} Buffered handler
      */
-    static framebuffer(cb, key, order = 1000)
+    static framebuffer(cb, key, priority = 1000)
     {
+        const item = {
+            key, cb, priority, args: [], active: false
+        };
+
+        Arr.add(this.$buffer, item);
+
+        let fn = () => {
+            this.runFramebuffer();
+        };
+
         return (e, ...args) => {
 
-            Arr.replace(PicoRunner.$buffer, {
-                key, cb, order, args: [e, ...args], active: true
-            }, { key });
+            Obj.assign(item, {
+                args: [e, ...args], active: true
+            });
 
-            (e.preventDefault(), PicoRunner.runFramebuffer());
+            (e.preventDefault(), fn());
         };
     }
 
@@ -289,23 +267,24 @@ export class PicoRunner
      */
     static runFramebuffer()
     {
-        if ( this.$timer.func ) {
-            this.$timer.func();
+        if ( this.$idler ) {
+            clearTimeout(this.$idler);
         }
 
-        this.$timer.func = this.delay(() => {
+        this.$idler = setTimeout(() => {
+            console.log('delayed runFramebuffer')
             this.runFramebuffer();
         }, 50);
 
-        if ( Date.now() - this.$timer.date <= 50 ) {
+        if ( Date.now() - this.$timer < 50 ) {
             return;
         }
 
-        if ( this.$timer.func ) {
-            this.$timer.func();
+        if ( this.$idler ) {
+            clearTimeout(this.$idler);
         }
 
-        this.$timer.date = Date.now();
+        this.$timer = Date.now();
 
         let buffer = Arr.filter(this.$buffer, {
             active: true
@@ -315,10 +294,10 @@ export class PicoRunner
             return;
         }
 
-        this.frame(() => {
-            Arr.each(Arr.sort(buffer, 'order'), (item) => {
-                item.cb(...item.args); item.active = false;
-            });
+        buffer = Arr.sort(buffer, 'priority');
+
+        Arr.each(buffer.reverse(), (item) => {
+            item.cb(...item.args); item.active = false;
         });
     }
 

package/types/dom/DomEvent.d.ts

@@ -2,7 +2,7 @@
  * @memberof PicoDom
  */
 export class PicoDomEventStatic {
-    static events: any[];
+    static $events: any[];
 }
 /**
  * @memberof PicoDom
@@ -59,6 +59,15 @@ export class PicoDomEventInstance {
      * @returns {PicoDom} Current instance
      */
     off(event: any, selector?: string, options?: any): PicoDom;
+    /**
+     * Stop listening to event with specific options
+     *
+     * @example Dom.find("div").optoff({ id: "my-id" })
+     *
+     * @param {any} [options] Listener options
+     * @returns {PicoDom} Current instance
+     */
+    optoff(options?: any): PicoDom;
     /**
      * Listen to event once
      *

package/types/utils/Array.d.ts

@@ -134,6 +134,17 @@ export class PicoArray {
      * @returns {any} Mapped array
      */
     static each(value: any, cb: Function, retval?: any): any;
+    /**
+     * Iterate over object keys
+     *
+     * @example Arr.eachObj({a:1}, (v,k) => v+1) // => [2]
+     *
+     * @param {any} value Input object
+     * @param {function} cb Iterate callback
+     * @param {any} [retval] Return value override
+     * @returns {any} Mapped values or retval
+     */
+    static eachObj(value: any, cb: Function, retval?: any): any;
     /**
      * Map values in place (mutates)
      *
@@ -166,6 +177,16 @@ export class PicoArray {
      * @returns {Array<string>} Matching keys
      */
     static filterIndex(value: any, filter?: any): Array<string>;
+    /**
+     * Remove values matching filter (mutates)
+     *
+     * @example Arr.filterRemove([1,2], 2) // => [1]
+     *
+     * @param {any} value Input list
+     * @param {any} [filter] Filter spec
+     * @returns {any} Mutated list
+     */
+    static filterRemove(value: any, filter?: any): any;
     /**
      * Filter values by filter
      *
@@ -455,26 +476,26 @@ export namespace PicoArray {
     /**
      * @see PicoArray.sortPrim
      */
-    function sortString(...args: any[]): any;
+    function sortString(...args: any[]): any[];
     /**
      * @see PicoArray.append
      */
-    function push(...args: any[]): any;
+    function push(...args: any[]): any[];
     /**
      * @see PicoArray.merge
      */
-    function concat(...args: any[]): any;
+    function concat(...args: any[]): any[];
     /**
      * @see PicoArray.matches
      */
-    function equal(...args: any[]): any;
+    function equal(...args: any[]): boolean;
     /**
      * @see PicoArray.diff
      */
-    function diffrence(...args: any[]): any;
+    function diffrence(...args: any[]): any[];
     /**
      * @see PicoArray.isect
      */
-    function intersect(...args: any[]): any;
+    function intersect(...args: any[]): any[];
 }
 export default PicoArray;

package/types/utils/Mixed.d.ts

@@ -457,7 +457,7 @@ export namespace PicoMixed {
     function isPlain(...args: any[]): boolean;
     function float(...args: any[]): any;
     function delay(...args: any[]): Function;
-    function async(...args: any[]): typeof Run;
+    function async(...args: any[]): Function;
     function debounce(...args: any[]): Function;
     function throttle(...args: any[]): Function;
     function framerate(...args: any[]): Function;
@@ -468,4 +468,3 @@ export namespace PicoMixed {
 }
 export default Mix;
 import { Mix } from "../index.esm.js";
-import { Run } from "../index.esm.js";

package/types/utils/Object.d.ts

@@ -229,6 +229,8 @@ export class PicoObject {
      * @returns {boolean} True if matches
      */
     static matches(value: any, search: any): boolean;
+    static sort(obj: any, key: any): any[];
+    static sortString(obj: any, key: any): any[];
 }
 export namespace PicoObject {
     /**
@@ -243,13 +245,5 @@ export namespace PicoObject {
      * @see PicoArray.findIndex
      */
     function findIndex(...args: any[]): number;
-    /**
-     * @see PicoArray.sort
-     */
-    function sort(...args: any[]): any[];
-    /**
-     * @see PicoArray.sortDeep
-     */
-    function sortString(...args: any[]): any[];
 }
 export default PicoObject;