@kizmann/pico-js 1.0.13 → 2.0.0

package/types/utils/Number.d.ts

@@ -0,0 +1,127 @@
+export class PicoNumber {
+    /**
+     * Format number with decimals
+     *
+     * @example Num.fixed(1.234, 2) // => "1.23"
+     * @example Num.fixed("2.4", 0) // => "2"
+     *
+     * @param {any} value Number value
+     * @param {number} decimals Decimals count
+     * @returns {string} Fixed string
+     */
+    static fixed(value: any, decimals?: number): string;
+    /**
+     * Parse value as float
+     *
+     * @example Num.float("2.2") // => 2.2
+     * @example Num.float(3) // => 3
+     *
+     * @param {any} value Numeric value
+     * @returns {number} Parsed float
+     */
+    static float(value: any): number;
+    /**
+     * Parse value as int
+     *
+     * @example Num.int("12") // => 12
+     * @example Num.int(12.9) // => 12
+     *
+     * @param {any} value Numeric value
+     * @returns {number} Parsed int
+     */
+    static int(value: any): number;
+    /**
+     * Round up to integer
+     *
+     * @example Num.ceil(1.1) // => 2
+     * @example Num.ceil("2.0") // => 2
+     *
+     * @param {any} value Numeric value
+     * @returns {number} Ceil value
+     */
+    static ceil(value: any): number;
+    /**
+     * Round down to integer
+     *
+     * @example Num.floor(1.9) // => 1
+     * @example Num.floor("2.0") // => 2
+     *
+     * @param {any} value Numeric value
+     * @returns {number} Floor value
+     */
+    static floor(value: any): number;
+    /**
+     * Round to nearest integer
+     *
+     * @example Num.round(1.5) // => 2
+     * @example Num.round("2.2") // => 2
+     *
+     * @param {any} value Numeric value
+     * @returns {number} Rounded value
+     */
+    static round(value: any): number;
+    /**
+     * Sum numbers in list
+     *
+     * @example Num.combine([1, 2]) // => 3
+     * @example Num.combine([5, -2]) // => 3
+     *
+     * @param {Array<number>} value Number list
+     * @returns {number} Sum value
+     */
+    static combine(value: Array<number>): number;
+    /**
+     * Subtract numbers in list
+     *
+     * @example Num.subtract([5, 2]) // => 3
+     * @example Num.subtract([10, 3]) // => 7
+     *
+     * @param {Array<number>} value Number list
+     * @returns {number} Result value
+     */
+    static subtract(value: Array<number>): number;
+    /**
+     * Get decade base (10s)
+     *
+     * @example Num.decade(27) // => 20
+     * @example Num.decade("99") // => 90
+     *
+     * @param {any} value Numeric value
+     * @returns {number} Decade value
+     */
+    static decade(value: any): number;
+    /**
+     * Convert number to power-of-2 list
+     *
+     * @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
+     * @returns {Array<number>} Power list
+     */
+    static matrix(num: number, limit?: number, base?: Array<number>): Array<number>;
+    /**
+     * Calculate distance between coords
+     *
+     * @example Num.distance({lat:0,lng:0},{lat:0,lng:1}) // => number
+     *
+     * @param {any} cord1 First coord
+     * @param {any} cord2 Second coord
+     * @param {boolean} [miles] Return miles if true
+     * @returns {number} Distance value
+     */
+    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 PicoNumber;

package/types/utils/Object.d.ts

@@ -0,0 +1,255 @@
+export class PicoObject {
+    /**
+     * Normalize key path to array
+     *
+     * @example Obj.keyoptim("a.b") // => ["a","b"]
+     * @example Obj.keyoptim(["a","b"]) // => ["a","b"]
+     *
+     * @param {any} keys Key path
+     * @param {boolean} [flatten] Flatten keys
+     * @param {boolean|null} [isstr] Is string flag
+     * @returns {Array<any>} Key segments
+     */
+    static keyoptim(keys: any, flatten?: boolean, isstr?: boolean | null): Array<any>;
+    /**
+     * Check if nested key exists
+     *
+     * @example Obj.has({a:{b:1}}, "a.b") // => true
+     * @example Obj.has({a:{}}, "a.b") // => false
+     *
+     * @param {any} target Target object
+     * @param {any} keys Key path
+     * @param {boolean} [flatten] Flatten keys
+     * @returns {boolean} True if exists
+     */
+    static has(target: any, keys: any, flatten?: boolean): boolean;
+    /**
+     * Get nested value or fallback
+     *
+     * @example Obj.get({a:{b:1}}, "a.b") // => 1
+     * @example Obj.get({}, "a.b", null) // => null
+     *
+     * @param {any} target Target object
+     * @param {any} keys Key path
+     * @param {any} [fallback] Fallback value
+     * @param {boolean} [flatten] Flatten keys
+     * @returns {any} Nested value
+     */
+    static get(target: any, keys: any, fallback?: any, flatten?: boolean): any;
+    /**
+     * Set nested value (mutates)
+     *
+     * @example Obj.set({}, "a.b", 1) // => object
+     * @example Obj.set({}, ["a","b"], 1) // => object
+     *
+     * @param {any} target Target object
+     * @param {any} keys Key path
+     * @param {any} value Value to set
+     * @param {boolean} [flatten] Flatten keys
+     * @returns {any} Mutated target
+     */
+    static set(target: any, keys: any, value: any, flatten?: boolean): any;
+    /**
+     * Unset nested value (mutates)
+     *
+     * @example Obj.unset({a:{b:1}}, "a.b")
+     * @example Obj.unset({a:{b:1}}, ["a","b"])
+     *
+     * @param {any} target Target object
+     * @param {any} keys Key path
+     * @param {boolean} [flatten] Flatten keys
+     * @returns {any} Mutated target
+     */
+    static unset(target: any, keys: any, flatten?: boolean): any;
+    /**
+     * Check if nested value is empty
+     *
+     * @example Obj.empty({a:null}, "a") // => true
+     * @example Obj.empty({a:1}, "a") // => false
+     *
+     * @param {any} target Target object
+     * @param {any} key Key path
+     * @returns {boolean} True if empty
+     */
+    static empty(target: any, key: any): boolean;
+    /**
+     * Unset multiple keys (mutates)
+     *
+     * @example Obj.remove({a:1,b:2}, ["a"]) // => object
+     *
+     * @param {any} target Target object
+     * @param {any} keys Keys list
+     * @returns {any} Mutated target
+     */
+    static remove(target: any, keys: any): any;
+    /**
+     * Map object values to object
+     *
+     * @example Obj.each({a:1}, v => v+1) // => {a:2}
+     *
+     * @param {any} value Source object
+     * @param {function} cb Map callback
+     * @param {any} [retval] Forced return
+     * @returns {any} Mapped object
+     */
+    static each(value: any, cb: Function, retval?: any): any;
+    /**
+     * Map object values to object
+     *
+     * @example Obj.map({a:1}, v => v+1) // => {a:2}
+     *
+     * @param {any} value Source object
+     * @param {function} cb Map callback
+     * @returns {Record<string, any>} Mapped object
+     */
+    static map(value: any, cb: Function): Record<string, any>;
+    /**
+     * Get filtered key indexes
+     *
+     * @example Obj.filterIndex({a:1,b:null}) // => ["a"]
+     *
+     * @param {any} value Source object
+     * @param {any} [filter] Filter spec
+     * @returns {Array<any>} Key list
+     */
+    static filterIndex(value: any, filter?: any): Array<any>;
+    /**
+     * Filter object by key filter
+     *
+     * @example Obj.filter({a:1,b:null}) // => {a:1}
+     *
+     * @param {any} value Source object
+     * @param {any} [filter] Filter spec
+     * @returns {Record<string, any>} Filtered object
+     */
+    static filter(value: any, filter?: any): Record<string, any>;
+    /**
+     * Flatten object into dot keys
+     *
+     * @example Obj.flatten({a:{b:1}}) // => {"a.b":1}
+     *
+     * @param {any} value Source object
+     * @param {string} [prefix] Key prefix
+     * @param {Record<string, any>} [result] Result map
+     * @returns {Record<string, any>} Flat map
+     */
+    static flatten(value: any, prefix?: string, result?: Record<string, any>): Record<string, any>;
+    /**
+     * Flatten object into form keys
+     *
+     * @example Obj.flattenForm({a:{b:1}}) // => {"a[b]":1}
+     *
+     * @param {any} value Source object
+     * @param {string} [prefix] Key prefix
+     * @param {Record<string, any>} [result] Result map
+     * @returns {Record<string, any>} Flat map
+     */
+    static flattenForm(value: any, prefix?: string, result?: Record<string, 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
+     */
+    static unpack(value: any, result?: Record<string, any>): Record<string, any>;
+    /**
+     * Assign objects (Object.assign)
+     *
+     * @example Obj.assign({}, {a:1}) // => {a:1}
+     *
+     * @param {...any} args Assign args
+     * @returns {any} Assigned object
+     */
+    static assign(...args: any[]): any;
+    /**
+     * Deep clone primitive/array/object
+     *
+     * @example Obj.clone({a:{b:1}}) // => new object
+     *
+     * @param {any} value Value to clone
+     * @param {any} [merge] Merge values
+     * @returns {any} Cloned value
+     */
+    static clone(value: any, merge?: any): any;
+    /**
+     * Get and remove nested value
+     *
+     * @example Obj.pluck({a:1}, "a") // => 1
+     *
+     * @param {any} value Source object
+     * @param {any} key Key path
+     * @param {any} [fallback] Fallback value
+     * @returns {any} Plucked value
+     */
+    static pluck(value: any, key: any, fallback?: any): any;
+    /**
+     * Pick only given keys
+     *
+     * @example Obj.only({a:1,b:2}, ["a"]) // => {a:1}
+     *
+     * @param {any} value Source object
+     * @param {Array<any>} keys Allowed keys
+     * @param {any} [merge] Merge values
+     * @returns {Record<string, any>} Picked object
+     */
+    static only(value: any, keys: Array<any>, merge?: any): Record<string, 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 {any} [merge] Merge values
+     * @returns {Record<string, any>} Picked object
+     */
+    static except(value: any, keys: Array<any>, merge?: any): Record<string, any>;
+    /**
+     * Check if value includes search
+     *
+     * @example Obj.includes({a:1}, {a:1}) // => true
+     * @example Obj.includes({a:1}, {a:2}) // => false
+     *
+     * @param {any} value Source value
+     * @param {any} search Search spec
+     * @returns {boolean} True if includes
+     */
+    static includes(value: any, search: any): boolean;
+    /**
+     * Check if value matches search
+     *
+     * @example Obj.matches({a:1}, {a:1}) // => true
+     * @example Obj.matches({a:1}, {b:1}) // => false
+     *
+     * @param {any} value Source value
+     * @param {any} search Search spec
+     * @returns {boolean} True if matches
+     */
+    static matches(value: any, search: any): boolean;
+}
+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;
+    /**
+     * @see PicoArray.sort
+     */
+    function sort(...args: any[]): any[];
+    /**
+     * @see PicoArray.sortDeep
+     */
+    function sortString(...args: any[]): any[];
+}
+export default PicoObject;

package/types/utils/Route.d.ts

@@ -0,0 +1,37 @@
+export class PicoRoute {
+    static $routes: {};
+    /**
+     * Store route template by key
+     *
+     * @example Route.set("home", "/") // stores
+     *
+     * @param {string} key Route key
+     * @param {string} value Route template
+     * @returns {void} No return value
+     */
+    static set(key: string, value: string): void;
+    /**
+     * Build route URL from template
+     *
+     * @example Route.get("home") // => "/"
+     * @example Route.get("/u/:id", {id:1}) // => "/u/1"
+     *
+     * @param {string} key Route key or url
+     * @param {any} [values] Token values
+     * @param {any} [query] Query params
+     * @returns {string} Built url
+     */
+    static get(key: string, values?: any, query?: any): string;
+    /**
+     * Navigate to built route URL
+     *
+     * @example Route.goto("home")
+     *
+     * @param {string} key Route key or url
+     * @param {any} [values] Token values
+     * @param {any} [params] Query params
+     * @returns {void} No return value
+     */
+    static goto(key: string, values?: any, params?: any): void;
+}
+export default PicoRoute;

package/types/utils/Runner.d.ts

@@ -0,0 +1,139 @@
+export class PicoRunner {
+    static $idler: {
+        native: {};
+        debounce: {};
+        throttle: {};
+    };
+    static $timer: {
+        date: number;
+        func: any;
+    };
+    static $buffer: any[];
+    /**
+     * Run callback after delay (id)
+     *
+     * @example Run.timeout(() => {}, 100) // => "t-..."
+     *
+     * @param {function} fn Callback to run
+     * @param {number} [delay] Delay ms
+     * @param {string|null} [index] Timer id
+     * @returns {string} Timer id
+     */
+    static timeout(fn: Function, delay?: number, index?: string | null): string;
+    /**
+     * Run callback on interval (id)
+     *
+     * @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
+     */
+    static interval(fn: Function, intval?: number, index?: string | null): string;
+    /**
+     * Clear timer(s) by id
+     *
+     * @example Run.clear("i-abc") // => Run
+     * @example Run.clear(["t-a","i-b"]) // => Run
+     *
+     * @param {string|Array<string>} index Timer id(s)
+     * @param {string} [scope] Idler scope key
+     * @returns {typeof PicoRunner} Runner class
+     */
+    static clear(index: string | Array<string>, scope?: string): typeof PicoRunner;
+    /**
+     * Poll until callback is true
+     *
+     * @example Run.wait(() => ready, 50) // polls
+     *
+     * @param {function} fn Condition callback
+     * @param {number} [intval] Poll interval ms
+     * @param {number} [limit] Max poll count
+     * @returns {void} No return value
+     */
+    static wait(fn: Function, intval?: number, limit?: number): void;
+    /**
+     * Run callback in next frame
+     *
+     * @example Run.frame(() => {}) // => Run
+     *
+     * @param {function} fn Callback to run
+     * @param {...any} [args] Callback args
+     * @returns {typeof PicoRunner} Runner class
+     */
+    static frame(fn: Function, ...args?: any[]): typeof PicoRunner;
+    /**
+     * Run callback async soon
+     *
+     * @example Run.async(() => {}) // => Run
+     *
+     * @param {function} fn Callback to run
+     * @param {...any} [args] Callback args
+     * @returns {typeof PicoRunner} Runner class
+     */
+    static async(fn: Function, ...args?: any[]): typeof PicoRunner;
+    /**
+     * Run callback after delay
+     *
+     * @example const cancel = Run.delay(() => {}, 50)
+     *
+     * @param {function} fn Callback to run
+     * @param {number} [delay] Delay ms
+     * @param {...any} [args] Callback args
+     * @returns {function} Cancel function
+     */
+    static delay(fn: Function, delay?: number, ...args?: any[]): Function;
+    /**
+     * Create debounced callback
+     *
+     * @example const fn = Run.debounce(cb, 100)
+     *
+     * @param {function} cb Callback to run
+     * @param {number} [timeout] Wait ms
+     * @param {string|null} [index] Debounce id
+     * @returns {function} Debounced fn
+     */
+    static debounce(cb: Function, timeout?: number, index?: string | null): Function;
+    /**
+     * Create throttled callback
+     *
+     * @example const fn = Run.throttle(cb, 100)
+     *
+     * @param {function} cb Callback to run
+     * @param {number} [timeout] Wait ms
+     * @param {string|null} [index] Throttle id
+     * @returns {function} Throttled fn
+     */
+    static throttle(cb: Function, timeout?: number, index?: string | null): Function;
+    /**
+     * Create framerate-limited callback
+     *
+     * @example const fn = Run.framerate(cb, 30)
+     *
+     * @param {function} cb Callback to run
+     * @param {number} [fps] Max frames per sec
+     * @returns {function} Rate-limited fn
+     */
+    static framerate(cb: Function, fps?: number): Function;
+    /**
+     * Buffer events into single frame
+     *
+     * @example el.onwheel = Run.framebuffer(cb,"wheel")
+     *
+     * @param {function} cb Callback to run
+     * @param {string} key Buffer key
+     * @param {number} [order] Sort order
+     * @returns {function} Buffered handler
+     */
+    static framebuffer(cb: Function, key: string, order?: number): Function;
+    /**
+     * Flush buffered frame events
+     *
+     * @example Run.runFramebuffer() // flush
+     *
+     * @returns {void} No return value
+     */
+    static runFramebuffer(): void;
+}
+export default PicoRunner;