@kizmann/pico-js 2.0.3 → 2.0.5

package/src/utils/Object.js

@@ -305,13 +305,11 @@ export class PicoObject
      */
     static map(value, cb)
     {
-        let result = {};
-
         for ( let key of Mix.keys(value) ) {
-            result[key] = cb(value[key], key);
+            value[key] = cb(value[key], key);
         }
 
-        return result;
+        return value;
     }
 
     /**
@@ -610,6 +608,56 @@ export class PicoObject
         return result;
     }
 
+    static sort(obj, key)
+    {
+        let keys = Mix.keys(obj);
+
+        if ( Mix.isFunction(key) ) {
+            keys = keys.sort((a, b) => {
+                return key.call({}, obj[a], obj[b]);
+            });
+        }
+
+        if ( !Mix.isFunction(key) ) {
+            keys = keys.sort((a, b) => {
+                return Mix.integer(this.get(obj[a], key)) - Mix.integer(this.get(obj[b], key));
+            })
+        }
+
+        let result = [];
+
+        Arr.each(keys, (key, index) => {
+            obj[key]['_key'] = key;
+            result[index] = obj[key];
+        });
+
+        return result;
+    }
+
+    static sortString(obj, key)
+    {
+        let keys = Mix.keys(obj);
+
+        if ( !Mix.isFunction(key) ) {
+            keys = keys.sort((a, b) => {
+
+                let va = Mix.string(this.get(obj[a], key)).toLowerCase();
+                let vb = Mix.string(this.get(obj[b], key)).toLowerCase();
+
+                return (va < vb) ? - 1 : (va > vb) ? 1 : 0;
+            })
+        }
+
+        let result = [];
+
+        Arr.each(keys, (key, index) => {
+            obj[key]['_key'] = key;
+            result[index] = obj[key];
+        });
+
+        return result;
+    }
+
 }
 
 /**
@@ -636,20 +684,20 @@ PicoObject.findIndex = (...args) => {
     return Arr.findIndex(...args);
 };
 
-/**
- * @see PicoArray.sort
- */
-PicoObject.sort = (...args) => {
-    console.warn('Obj.sort() is deprecated, use Arr.sort() instead.');
-    return Arr.sort(...args);
-};
-
-/**
- * @see PicoArray.sortDeep
- */
-PicoObject.sortString = (...args) => {
-    console.warn('Obj.sortString() is deprecated, use Arr.sortDeep() instead.');
-    return Arr.sortDeep(...args);
-};
+// /**
+//  * @see PicoArray.sort
+//  */
+// PicoObject.sort = (...args) => {
+//     console.warn('Obj.sort() is deprecated, use Arr.sort() instead.');
+//     return Arr.sort(...args);
+// };
+//
+// /**
+//  * @see PicoArray.sortDeep
+//  */
+// PicoObject.sortString = (...args) => {
+//     console.warn('Obj.sortString() is deprecated, use Arr.sortDeep() instead.');
+//     return Arr.sortDeep(...args);
+// };
 
 export default PicoObject

package/src/utils/Route.js

@@ -38,10 +38,12 @@ export class PicoRoute
             route = this.$routes[key] || key
         }
 
-        route = Locale.replace(route, values);
+        Obj.each(values, (val, key) => {
+            route = route.replace(new RegExp('{' + key + '}', 'g'), val);
+        });
 
         if ( ! Mix.isEmpty(query) ) {
-            route += '?' + For.castParams(values);
+            route += '?' + For.castParams(query);
         }
 
         return route;

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)
-     *
-     * @example Run.interval(() => {}, 250) // => "i-..."
+     * Request idle callback with fallback
      *
-     * @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);
         };
     }
 
@@ -289,23 +257,23 @@ 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(() => {
             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

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/index.esm.d.ts

@@ -1,3 +1,8 @@
+/**
+ * @type {typeof PicoMixed}
+ */
+export const Any: typeof PicoMixed;
+export function UUID(): string;
 /**
  * @type {typeof PicoDom}
  */
@@ -10,51 +15,16 @@ export const Now: typeof PicoNow;
  * @type {typeof PicoFormat}
  */
 export const For: typeof PicoFormat;
-/**
- * @type {typeof PicoRunner}
- */
-export const Run: typeof PicoRunner;
-/**
- * @type {typeof PicoString}
- */
-export const Str: typeof PicoString;
-/**
- * @type {typeof PicoNumber}
- */
-export const Num: typeof PicoNumber;
-/**
- * @type {typeof PicoArray}
- */
-export const Arr: typeof PicoArray;
-/**
- * @type {typeof PicoObject}
- */
-export const Obj: typeof PicoObject;
-/**
- * @type {typeof PicoMixed}
- */
-export const Mix: typeof PicoMixed;
-/**
- * @type {typeof PicoHash}
- */
-export const Hash: typeof PicoHash;
-/**
- * @type {typeof PicoEvent}
- */
-export const Event: typeof PicoEvent;
-/**
- * @type {typeof PicoLocale}
- */
-export const Locale: typeof PicoLocale;
-/**
- * @type {typeof PicoCookie}
- */
-export const Cookie: typeof PicoCookie;
-/**
- * @type {typeof PicoMixed}
- */
-export const Any: typeof PicoMixed;
-export function UUID(): string;
+import { default as Run } from "./utils/Runner.js";
+import { default as Str } from "./utils/String.js";
+import { default as Num } from "./utils/Number.js";
+import { default as Arr } from "./utils/Array.js";
+import { default as Obj } from "./utils/Object.js";
+import { default as Mix } from "./utils/Mixed.js";
+import { default as Hash } from "./utils/Hash.js";
+import { default as Event } from "./utils/Event.js";
+import { default as Locale } from "./utils/Locale.js";
+import { default as Cookie } from "./utils/Cookie.js";
 import { go } from "./tool/scope.js";
 import { browser } from "./tool/scope.js";
 import { device } from "./tool/scope.js";
@@ -62,17 +32,8 @@ import { default as Map } from "./wip/Map.js";
 import { default as Data } from "./utils/Data.js";
 import { default as Route } from "./utils/Route.js";
 import { default as Element } from "./wip/Element.js";
+import { PicoMixed } from "./utils/Mixed.js";
 import { PicoDom } from "./utils/Dom.js";
 import { PicoNow } from "./utils/Now.js";
 import { PicoFormat } from "./utils/Format.js";
-import { default as PicoRunner } from "./utils/Runner.js";
-import { default as PicoString } from "./utils/String.js";
-import { default as PicoNumber } from "./utils/Number.js";
-import { default as PicoArray } from "./utils/Array.js";
-import { default as PicoObject } from "./utils/Object.js";
-import { default as PicoMixed } from "./utils/Mixed.js";
-import { default as PicoHash } from "./utils/Hash.js";
-import { default as PicoEvent } from "./utils/Event.js";
-import { default as PicoLocale } from "./utils/Locale.js";
-import { default as PicoCookie } from "./utils/Cookie.js";
-export { go, browser, device, Map, Data, Route, Element };
+export { Run, Str, Num, Arr, Obj, Mix, Hash, Event, Locale, Cookie, go, browser, device, Map, Data, Route, Element };

package/types/now/NowDefault.d.ts

@@ -179,6 +179,70 @@ export class PicoNowDefaultInstance {
      * @returns {PicoNow} Current instance
      */
     applyTime(value: any, format?: string): PicoNow;
+    /**
+     * @see PicoNow.add
+     */
+    addSecond(value: any): PicoNow;
+    /**
+     * @see PicoNow.sub
+     */
+    subSecond(value: any): PicoNow;
+    /**
+     * @see PicoNow.add
+     */
+    addMinute(value: any): PicoNow;
+    /**
+     * @see PicoNow.sub
+     */
+    subMinute(value: any): PicoNow;
+    /**
+     * @see PicoNow.add
+     */
+    addHour(value: any): PicoNow;
+    /**
+     * @see PicoNow.sub
+     */
+    subHour(value: any): PicoNow;
+    /**
+     * @see PicoNow.add
+     */
+    addDates(value: any): PicoNow;
+    /**
+     * @see PicoNow.sub
+     */
+    subDates(value: any): PicoNow;
+    /**
+     * @see PicoNow.add
+     */
+    addMonths(value: any): PicoNow;
+    /**
+     * @see PicoNow.sub
+     */
+    subMonths(value: any): PicoNow;
+    /**
+     * @see PicoNow.add
+     */
+    addYears(value: any): PicoNow;
+    /**
+     * @see PicoNow.sub
+     */
+    subYears(value: any): PicoNow;
+    /**
+     * @see PicoNow.add
+     */
+    addDecades(value: any): PicoNow;
+    /**
+     * @see PicoNow.sub
+     */
+    subDecades(value: any): PicoNow;
+    /**
+     * @see PicoNow.day
+     */
+    humanDay(): number | PicoNow;
+    /**
+     * @see PicoNow.month
+     */
+    humanMonth(): number | PicoNow;
 }
 export function PicoNowDefaultPlugin(self: typeof PicoNow): typeof PicoNow;
 import { PicoNow } from "../utils/Now.js";