@kizmann/pico-js 2.0.7 → 2.0.9

package/types/utils/Number.d.ts

@@ -1,4 +1,4 @@
-export class PicoNumber {
+export declare class PicoNumber {
     /**
      * Format number with decimals
      *
@@ -66,20 +66,20 @@ export class PicoNumber {
      * @example Num.combine([1, 2]) // => 3
      * @example Num.combine([5, -2]) // => 3
      *
-     * @param {Array<number>} value Number list
+     * @param {number[]} value Number list
      * @returns {number} Sum value
      */
-    static combine(value: Array<number>): number;
+    static combine(value: number[]): number;
     /**
      * Subtract numbers in list
      *
      * @example Num.subtract([5, 2]) // => 3
      * @example Num.subtract([10, 3]) // => 7
      *
-     * @param {Array<number>} value Number list
+     * @param {number[]} value Number list
      * @returns {number} Result value
      */
-    static subtract(value: Array<number>): number;
+    static subtract(value: number[]): number;
     /**
      * Get decade base (10s)
      *
@@ -96,12 +96,11 @@ export class PicoNumber {
      * @example Num.matrix(5) // => [4, 1]
      * @example Num.matrix(8) // => [8]
      *
-     * @param {number} num Input number
-     * @param {number} [limit] Unused (legacy)
-     * @param {Array<number>} [base] Result base
+     * @param {any} num Input number
+     * @param {number[]} [base] Result base
      * @returns {Array<number>} Power list
      */
-    static matrix(num: number, limit?: number, base?: Array<number>): Array<number>;
+    static matrix(num: any, base?: number[]): Array<number>;
     /**
      * Calculate distance between coords
      *
@@ -114,14 +113,4 @@ export class PicoNumber {
      */
     static distance(cord1: any, cord2: any, miles?: boolean): number;
 }
-export namespace PicoNumber {
-    /**
-     * @see PicoStr.number
-     */
-    function format(value: any, ...args: any[]): any;
-    /**
-     * @see PicoHash.number
-     */
-    function random(...args: any[]): number;
-}
-export default Num;
+export default PicoNumber;

package/types/utils/Object.d.ts

@@ -1,4 +1,4 @@
-export class PicoObject {
+export declare class PicoObject {
     /**
      * Normalize key path to array
      *
@@ -7,10 +7,10 @@ export class PicoObject {
      *
      * @param {any} keys Key path
      * @param {boolean} [flatten] Flatten keys
-     * @param {boolean|null} [isstr] Is string flag
+     * @param {boolean} [isstr] Is string flag
      * @returns {Array<any>} Key segments
      */
-    static keyoptim(keys: any, flatten?: boolean, isstr?: boolean | null): Array<any>;
+    static keyoptim(keys: any, flatten?: boolean, isstr?: boolean): Array<any>;
     /**
      * Check if nested key exists
      *
@@ -88,7 +88,7 @@ export class PicoObject {
      * @example Obj.each({a:1}, v => v+1) // => {a:2}
      *
      * @param {any} value Source object
-     * @param {function} cb Map callback
+     * @param {Function} cb Map callback
      * @param {any} [retval] Forced return
      * @returns {any} Mapped object
      */
@@ -99,7 +99,7 @@ export class PicoObject {
      * @example Obj.map({a:1}, v => v+1) // => {a:2}
      *
      * @param {any} value Source object
-     * @param {function} cb Map callback
+     * @param {Function} cb Map callback
      * @returns {Record<string, any>} Mapped object
      */
     static map(value: any, cb: Function): Record<string, any>;
@@ -130,10 +130,10 @@ export class PicoObject {
      *
      * @param {any} value Source object
      * @param {string} [prefix] Key prefix
-     * @param {Record<string, any>} [result] Result map
+     * @param {any} [result] Result map
      * @returns {Record<string, any>} Flat map
      */
-    static flatten(value: any, prefix?: string, result?: Record<string, any>): Record<string, any>;
+    static flatten(value: any, prefix?: string, result?: any): Record<string, any>;
     /**
      * Flatten object into form keys
      *
@@ -141,29 +141,29 @@ export class PicoObject {
      *
      * @param {any} value Source object
      * @param {string} [prefix] Key prefix
-     * @param {Record<string, any>} [result] Result map
+     * @param {any} [result] Result map
      * @returns {Record<string, any>} Flat map
      */
-    static flattenForm(value: any, prefix?: string, result?: Record<string, any>): Record<string, any>;
+    static flattenForm(value: any, prefix?: string, result?: any): Record<string, any>;
     /**
      * Unpack dotted keys into object
      *
      * @example Obj.unpack({"a.b":1}) // => {a:{b:1}}
      *
      * @param {any} value Flat key map
-     * @param {Record<string, any>} [result] Result object
-     * @returns {Record<string, any>} Unpacked object
+     * @param {any} [result] Result object
+     * @returns {any} Unpacked object
      */
-    static unpack(value: any, result?: Record<string, any>): Record<string, any>;
+    static unpack(value: any, result?: any): any;
     /**
      * Assign objects (Object.assign)
      *
      * @example Obj.assign({}, {a:1}) // => {a:1}
      *
-     * @param {...any} args Assign args
+     * @param {[...any]} args Assign args
      * @returns {any} Assigned object
      */
-    static assign(...args: any[]): any;
+    static assign(...args: [...any]): any;
     /**
      * Deep clone primitive/array/object
      *
@@ -191,22 +191,22 @@ export class PicoObject {
      * @example Obj.only({a:1,b:2}, ["a"]) // => {a:1}
      *
      * @param {any} value Source object
-     * @param {Array<any>} keys Allowed keys
+     * @param {string[]} keys Allowed keys
      * @param {any} [merge] Merge values
-     * @returns {Record<string, any>} Picked object
+     * @returns {any} Picked object
      */
-    static only(value: any, keys: Array<any>, merge?: any): Record<string, any>;
+    static only(value: any, keys: string[], merge?: any): any;
     /**
      * Pick all keys except given
      *
      * @example Obj.except({a:1,b:2}, ["a"]) // => {b:2}
      *
      * @param {any} value Source object
-     * @param {Array<any>} keys Excluded keys
+     * @param {string[]} keys Excluded keys
      * @param {any} [merge] Merge values
-     * @returns {Record<string, any>} Picked object
+     * @returns {any} Picked object
      */
-    static except(value: any, keys: Array<any>, merge?: any): Record<string, any>;
+    static except(value: any, keys: string[], merge?: any): any;
     /**
      * Check if value includes search
      *
@@ -229,21 +229,6 @@ 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 {
-    /**
-     * @see PicoMixed.vals
-     */
-    function values(...args: any[]): any[];
-    /**
-     * @see PicoArray.find
-     */
-    function find(...args: any[]): any;
-    /**
-     * @see PicoArray.findIndex
-     */
-    function findIndex(...args: any[]): number;
+    static sort(value: any, key: string): any;
 }
 export default PicoObject;

package/types/utils/Route.d.ts

@@ -1,5 +1,8 @@
-export class PicoRoute {
-    static $routes: {};
+export declare class PicoRoute {
+    /**
+     * @type {any}
+     */
+    static $routes: any;
     /**
      * Store route template by key
      *

package/types/utils/Runner.d.ts

@@ -1,23 +1,42 @@
-export class PicoRunner {
+export declare class PicoRunner {
+    /**
+     * @type {any}
+     */
     static $idler: any;
+    /**
+     * @type {number}
+     */
     static $timer: number;
+    /**
+     * @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): Function;
     /**
      * Clear timer or call function
      *
      * @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: any): typeof PicoRunner;
+    static clear(timer: any): 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: Function): typeof PicoRunner;
+    static tryin(cb: Function): PicoRunner;
     /**
      * Wait for condition to be true
      *
@@ -26,7 +45,7 @@ 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: Function, intval?: number, limit?: number): Function;
     /**
@@ -34,50 +53,37 @@ export class PicoRunner {
      *
      * @example Run.frame(cb)
      *
-     * @param {function} fn Callback function
-     * @param {any} [...args] Callback arguments
-     * @returns {function} Noop clear function
-     */
-    static frame(fn: Function, ...args: any[]): Function;
-    /**
-     * 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
+     * @param {Function} fn Callback function
+     * @returns {Function} Noop clear function
      */
-    static idle(fn: Function, ...args: any[]): Function;
+    static frame(fn: Function): Function;
     /**
      * Run function asynchronously
      *
      * @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: Function, ...args: any[]): Function;
+    static async(fn: Function): Function;
     /**
      * Run function after delay
      *
      * @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: Function, delay?: number, ...args: any[]): Function;
+    static delay(fn: Function, delay?: number): Function;
     /**
      * Create debounced callback
      *
      * @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: Function, timeout?: number): Function;
     /**
@@ -85,9 +91,9 @@ 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: Function, timeout?: number): Function;
     /**
@@ -95,20 +101,21 @@ 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: Function, fps?: number): Function;
+    static framerate(cb: Function, fps?: number, finish?: boolean): Function;
     /**
      * Buffer events into single frame
      *
      * @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: Function, key: string, priority?: number): Function;
     /**

package/types/utils/Signal.d.ts

@@ -1,4 +1,4 @@
-export class PicoSignal {
+export declare class PicoSignal {
     static $events: any[];
     /**
      * Bind callback to event name
@@ -6,24 +6,24 @@ 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: any, cb: Function, options?: any, paused?: boolean): typeof PicoSignal;
+    static bind(event: string | string[], cb: Function, options?: any, paused?: boolean): PicoSignal;
     /**
      * Unbind callback(s) from event
      *
      * @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: any, options?: any): typeof PicoSignal;
+    static unbind(event: string | string[], options?: any): PicoSignal;
     /**
      * Fire event with arguments
      *
@@ -31,28 +31,28 @@ 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: string, ...args: any[]): typeof PicoSignal;
+    static fire(event: string, ...args: Parameters<any>): PicoSignal;
     /**
      * Pause listeners for event
      *
      * @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: any, options?: any): typeof PicoSignal;
+    static pause(event: string | string[], options?: any): PicoSignal;
     /**
      * Unpause listeners for event
      *
      * @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: any, options?: any): typeof PicoSignal;
+    static unpause(event: string | string[], options?: any): PicoSignal;
 }
 export default PicoSignal;