@kizmann/pico-js 1.0.13 → 2.0.0

package/types/dom/DomAttribute.d.ts

@@ -0,0 +1,137 @@
+/**
+ * @memberof PicoDom
+ */
+export class PicoDomAttributeStatic {
+}
+/**
+ * @memberof PicoDom
+ * @extends {PicoDom}
+ */
+export class PicoDomAttributeInstance {
+    /**
+     * Get or set attribute
+     *
+     * @example Dom.find("div").attr("id")
+     *
+     * @param {string} key Attr key
+     * @param {any} [value] Attr value
+     * @param {any} [fallback] Fallback value
+     * @returns {any|this} Attr value or instance
+     */
+    attr(key: string, value?: any, fallback?: any): any | this;
+    /**
+     * Get or set data attribute
+     *
+     * @example Dom.find("div").data("id")
+     *
+     * @param {string} key Data key
+     * @param {any} [value] Data value
+     * @param {any} [fallback] Fallback value
+     * @returns {any|this} Data value or instance
+     */
+    data(key: string, value?: any, fallback?: any): any | this;
+    /**
+     * Get computed style
+     *
+     * @example Dom.find("div").computed("width")
+     *
+     * @param {any} [key] Style key
+     * @param {any} [fallback] Fallback value
+     * @returns {any} Computed style
+     */
+    computed(key?: any, fallback?: any): any;
+    /**
+     * Get or set style
+     *
+     * @example Dom.find("div").style({ color: "red" })
+     *
+     * @param {any} [value] Style value
+     * @param {boolean} [combine] Combine style
+     * @returns {any|this} Style or instance
+     */
+    style(value?: any, combine?: boolean): any | this;
+    /**
+     * Get or set classes
+     *
+     * @example Dom.find("div").class(["active"])
+     *
+     * @param {any} [value] Class value
+     * @param {boolean} [combine] Combine classes
+     * @returns {any|this} Classes or instance
+     */
+    class(value?: any, combine?: boolean): any | this;
+    /**
+     * Get or set inner HTML
+     *
+     * @example Dom.find("div").html("<span></span>")
+     *
+     * @param {any} [html] HTML content
+     * @returns {string|this} HTML or instance
+     */
+    html(html?: any): string | this;
+    /**
+     * Get actual style value
+     *
+     * @example Dom.find("div").actual((el) => el.offsetWidth, { display: "block" })
+     *
+     * @param {function} cb Callback fn
+     * @param {any} [style] Temp style
+     * @returns {any} Callback result
+     */
+    actual(cb: Function, style?: any): any;
+    /**
+     * Check if has class
+     *
+     * @example Dom.find("div").hasClass("active") // => true
+     *
+     * @param {any} cls Class name
+     * @returns {boolean} True if has class
+     */
+    hasClass(cls: any): boolean;
+    /**
+     * Add class to element
+     *
+     * @example Dom.find("div").addClass("active")
+     *
+     * @param {any} cls Class name
+     * @returns {this} Current instance
+     */
+    addClass(cls: any): this;
+    /**
+     * Remove class from element
+     *
+     * @example Dom.find("div").remClass("active")
+     *
+     * @param {any} cls Class name
+     * @returns {this} Current instance
+     */
+    remClass(cls: any): this;
+    /**
+     * Toggle class on element
+     *
+     * @example Dom.find("div").toggleClass("active")
+     *
+     * @param {any} cls Class name
+     * @returns {this} Current instance
+     */
+    toggleClass(cls: any): this;
+    /**
+     * Set class by state
+     *
+     * @example Dom.find("div").stateClass("active", true)
+     *
+     * @param {any} cls Class name
+     * @param {boolean} [state] Target state
+     * @returns {this} Current instance
+     */
+    stateClass(cls: any, state?: boolean): this;
+    /**
+     * @see PicoDom.style
+     */
+    css(...args: any[]): any;
+    /**
+     * @see PicoDom.remClass
+     */
+    removeClass(...args: any[]): PicoDomAttributeInstance;
+}
+export function PicoDomAttributePlugin(self: any): typeof import("#src/utils/Dom.js").PicoDom;

package/types/dom/DomBuilder.d.ts

@@ -0,0 +1,67 @@
+/**
+ * @memberof PicoDom
+ */
+export class PicoDomBuilderStatic {
+    /**
+     * Create element from tag
+     *
+     * @example Dom.make("div", { class: "active" })
+     *
+     * @param {any} el Tag or element
+     * @param {any} [options] Attr options
+     * @returns {PicoDom} Dom instance
+     */
+    static make(el: any, options?: any): PicoDom;
+}
+/**
+ * @memberof PicoDom
+ * @extends {PicoDom}
+ */
+export class PicoDomBuilderInstance {
+    /**
+     * Prepend value to element
+     *
+     * @example Dom.find("div").prepend("<span></span>")
+     *
+     * @param {any} value Prepend value
+     * @returns {this} Current instance
+     */
+    prepend(value: any): this;
+    /**
+     * Prepend element to value
+     *
+     * @example Dom.find("span").prependTo("div")
+     *
+     * @param {any} value Target element
+     * @returns {this} Current instance
+     */
+    prependTo(value: any): this;
+    /**
+     * Append value to element
+     *
+     * @example Dom.find("div").append("<span></span>")
+     *
+     * @param {any} value Append value
+     * @returns {this} Current instance
+     */
+    append(value: any): this;
+    /**
+     * Append element to value
+     *
+     * @example Dom.find("span").appendTo("div")
+     *
+     * @param {any} value Target element
+     * @returns {this} Current instance
+     */
+    appendTo(value: any): this;
+    /**
+     * Replace element with value
+     *
+     * @example Dom.find("div").replace("<span></span>")
+     *
+     * @param {any} value Replacement value
+     * @returns {this} Current instance
+     */
+    replace(value: any): this;
+}
+export function PicoDomBuilderPlugin(self: any): typeof import("#src/utils/Dom.js").PicoDom;

package/types/dom/DomEvent.d.ts

@@ -0,0 +1,103 @@
+/**
+ * @memberof PicoDom
+ */
+export class PicoDomEventStatic {
+    static events: any[];
+}
+/**
+ * @memberof PicoDom
+ * @extends {PicoDom}
+ */
+export class PicoDomEventInstance {
+    /**
+     * Bind event listener
+     *
+     * @example Dom.bind(el, "click", cb)
+     *
+     * @param {Element} el Target element
+     * @param {string} event Event name
+     * @param {function} cb Callback fn
+     * @param {string} [selector] Event selector
+     * @param {boolean} [pause] Pause listener
+     * @param {any} [options] Listener options
+     * @returns {this} Current instance
+     */
+    bind(el: Element, event: string, cb: Function, selector?: string, pause?: boolean, options?: any): this;
+    /**
+     * Unbind event listener
+     *
+     * @example Dom.unbind(el, "click")
+     *
+     * @param {Element} el Target element
+     * @param {string} event Event name
+     * @param {string} [selector] Event selector
+     * @param {any} [options] Listener options
+     * @returns {this} Current instance
+     */
+    unbind(el: Element, event: string, selector?: string, options?: any): this;
+    /**
+     * Listen to event
+     *
+     * @example Dom.find("div").on("click", cb)
+     *
+     * @param {any} event Event name
+     * @param {function} cb Callback fn
+     * @param {any} [options] Listener options
+     * @param {boolean} [pause] Pause listener
+     * @param {string} [selector] Event selector
+     * @returns {this} Current instance
+     */
+    on(event: any, cb: Function, options?: any, pause?: boolean, selector?: string): this;
+    /**
+     * Stop listening to event
+     *
+     * @example Dom.find("div").off("click")
+     *
+     * @param {any} event Event name
+     * @param {string} [selector] Event selector
+     * @param {any} [options] Listener options
+     * @returns {this} Current instance
+     */
+    off(event: any, selector?: string, options?: any): this;
+    /**
+     * Listen to event once
+     *
+     * @example Dom.find("div").once("click", cb)
+     *
+     * @param {any} event Event name
+     * @param {function} cb Callback fn
+     * @param {any} [options] Listener options
+     * @returns {this} Current instance
+     */
+    once(event: any, cb: Function, options?: any): this;
+    /**
+     * Listen to live event
+     *
+     * @example Dom.find("div").live("click", "span", cb)
+     *
+     * @param {any} event Event name
+     * @param {string} selector Event selector
+     * @param {function} cb Callback fn
+     * @param {any} [options] Listener options
+     * @param {boolean} [pause] Pause listener
+     * @returns {this} Current instance
+     */
+    live(event: any, selector: string, cb: Function, options?: any, pause?: boolean): this;
+    /**
+     * Fire event on element
+     *
+     * @example Dom.find("div").fire("click")
+     *
+     * @param {string} event Event name
+     * @returns {this} Current instance
+     */
+    fire(event: string): this;
+    /**
+     * @see PicoDom.once
+     */
+    one(...args: any[]): PicoDomEventInstance;
+    delayed(): void;
+    pause(): void;
+    unpause(): void;
+}
+export function PicoDomEventPlugin(self: any): typeof import("#src/utils/Dom.js").PicoDom;

package/types/dom/DomFinder.d.ts

@@ -0,0 +1,321 @@
+/**
+ * @memberof PicoDom
+ */
+export class PicoDomFinderStatic {
+    /**
+     * Filter nodes by type
+     *
+     * @example Dom.filterNodes(nodes, 1)
+     *
+     * @param {any} nodes Source nodes
+     * @param {number} [filter] Node type
+     * @returns {Array<Element>} Filtered nodes
+     */
+    static filterNodes(nodes: any, filter?: number): Array<Element>;
+    /**
+     * Get nodes at point
+     *
+     * @example Dom.getNodePoint(100, 100)
+     *
+     * @param {number} posx X position
+     * @param {number} posy Y position
+     * @returns {Array<Element>} Nodes at point
+     */
+    static getNodePoint(posx: number, posy: number): Array<Element>;
+    /**
+     * Get target by selector
+     *
+     * @example Dom.getNodeEvent(".item", event)
+     *
+     * @param {string} selector Node selector
+     * @param {any} [event] Event object
+     * @returns {Element} Found element
+     */
+    static getNodeEvent(selector: string, event?: any): Element;
+}
+/**
+ * @memberof PicoDom
+ * @extends {PicoDom}
+ */
+export class PicoDomFinderInstance {
+    /**
+     * Resolve input elements
+     *
+     * @example Dom._constructFinder(".item")
+     *
+     * @param {any} el Input value
+     * @returns {any} Resolved elements
+     */
+    static _constructFinder(el: any): any;
+    /**
+     * Get node type
+     *
+     * @example Dom.find("div").getNodeType() // => 1
+     *
+     * @param {number} [fallback] Fallback value
+     * @returns {number} Node type
+     */
+    getNodeType(fallback?: number): number;
+    /**
+     * Get parent node
+     *
+     * @example Dom.find("div").getNodeParent() // => PicoDom
+     *
+     * @param {any} [fallback] Fallback value
+     * @returns {PicoDom} Parent instance
+     */
+    getNodeParent(fallback?: any): PicoDom;
+    /**
+     * Get previous node
+     *
+     * @example Dom.find("div").getNodePrev() // => PicoDom
+     *
+     * @param {any} [fallback] Fallback value
+     * @returns {PicoDom} Prev instance
+     */
+    getNodePrev(fallback?: any): PicoDom;
+    /**
+     * Get next node
+     *
+     * @example Dom.find("div").getNodeNext() // => PicoDom
+     *
+     * @param {any} [fallback] Fallback value
+     * @returns {PicoDom} Next instance
+     */
+    getNodeNext(fallback?: any): PicoDom;
+    /**
+     * Get child nodes
+     *
+     * @example Dom.find("div").getNodeChilds(1)
+     *
+     * @param {number} [type] Node type
+     * @param {any} [fallback] Fallback value
+     * @returns {Array<Element>} Child nodes
+     */
+    getNodeChilds(type?: number, fallback?: any): Array<Element>;
+    /**
+     * Filter instances nodes
+     *
+     * @example Dom.find("div").sanatize(1)
+     *
+     * @param {number} [filter] Node type
+     * @returns {this} Current instance
+     */
+    sanatize(filter?: number): this;
+    els: any;
+    /**
+     * Filter elements by selector
+     *
+     * @example Dom.find("div").filter(".active")
+     *
+     * @param {any} selector Filter selector
+     * @returns {Array<Element>} Filtered nodes
+     */
+    filter(selector: any): Array<Element>;
+    /**
+     * Exclude elements by selector
+     *
+     * @example Dom.find("div").except(".active")
+     *
+     * @param {any} selector Exclude selector
+     * @returns {Array<Element>} Filtered nodes
+     */
+    except(selector: any): Array<Element>;
+    /**
+     * Find elements in instance
+     *
+     * @example Dom.find("div").find(".item")
+     *
+     * @param {any} selector Search selector
+     * @returns {PicoDom} Dom instance
+     */
+    find(selector: any): PicoDom;
+    /**
+     * Get element by index
+     *
+     * @example Dom.find("div").get(0) // => Element
+     *
+     * @param {number} [index] Node index
+     * @returns {any} Found element
+     */
+    get(index?: number): any;
+    /**
+     * Get first element
+     *
+     * @example Dom.find("div").first() // => Element
+     *
+     * @param {number} [offset] Node offset
+     * @returns {any} Found element
+     */
+    first(offset?: number): any;
+    /**
+     * Get last element
+     *
+     * @example Dom.find("div").last() // => Element
+     *
+     * @param {number} [offset] Node offset
+     * @returns {any} Found element
+     */
+    last(offset?: number): any;
+    /**
+     * Iterate over elements
+     *
+     * @example Dom.find("div").each((el) => console.log(el))
+     *
+     * @param {function} cb Callback fn
+     * @returns {this} Current instance
+     */
+    each(cb: Function): this;
+    /**
+     * Loop through parent nodes
+     *
+     * @example Dom.find("div").loopParent((el) => console.log(el))
+     *
+     * @param {function} cb Callback fn
+     * @param {any} [boundry] Loop limit
+     * @returns {this} Current instance
+     */
+    loopParent(cb: Function, boundry?: any): this;
+    /**
+     * Get parent instance
+     *
+     * @example Dom.find("div").parent() // => PicoDom
+     *
+     * @returns {PicoDom} Parent instance
+     */
+    parent(): PicoDom;
+    /**
+     * Get first child match
+     *
+     * @example Dom.find("div").child(".item")
+     *
+     * @param {any} selector Child selector
+     * @param {number} [filter] Node type
+     * @returns {PicoDom} Child instance
+     */
+    child(selector: any, filter?: number): PicoDom;
+    /**
+     * Get child elements
+     *
+     * @example Dom.find("div").childs(".item")
+     *
+     * @param {any} [selector] Child selector
+     * @param {number} [filter] Node type
+     * @returns {Array<Element>} Child elements
+     */
+    childs(selector?: any, filter?: number): Array<Element>;
+    /**
+     * Get closest element
+     *
+     * @example Dom.find("div").closest(".container")
+     *
+     * @param {any} selector Target selector
+     * @returns {Element} Found element
+     */
+    closest(selector: any): Element;
+    /**
+     * Get previous element
+     *
+     * @example Dom.find("div").prev() // => PicoDom
+     *
+     * @param {number} [type] Node type
+     * @returns {PicoDom} Prev instance
+     */
+    prev(type?: number): PicoDom;
+    /**
+     * Get next element
+     *
+     * @example Dom.find("div").next() // => PicoDom
+     *
+     * @param {number} [type] Node type
+     * @returns {PicoDom} Next instance
+     */
+    next(type?: number): PicoDom;
+    /**
+     * Get number of elements
+     *
+     * @example Dom.find("div").length() // => 1
+     *
+     * @returns {number} Count value
+     */
+    length(): number;
+    /**
+     * Check if element matches
+     *
+     * @example Dom.find("div").is(".active") // => true
+     *
+     * @param {any} selector Test selector
+     * @returns {boolean} True if matches
+     */
+    is(selector: any): boolean;
+    /**
+     * Check if contains match
+     *
+     * @example Dom.find("div").matches(".active")
+     *
+     * @param {any} selector Test selector
+     * @returns {boolean} True if matches
+     */
+    matches(selector: any): boolean;
+    /**
+     * Check if instance is empty
+     *
+     * @example Dom.find(".none").empty() // => true
+     *
+     * @returns {boolean} True if empty
+     */
+    empty(): boolean;
+    /**
+     * Check if element is visible
+     *
+     * @example Dom.find("div").visible() // => true
+     *
+     * @returns {boolean} True if visible
+     */
+    visible(): boolean;
+    /**
+     * Check if parent matches
+     *
+     * @example Dom.find("div").above(".container")
+     *
+     * @param {any} selector Parent selector
+     * @returns {boolean} True if matches
+     */
+    above(selector: any): boolean;
+    /**
+     * Check if inside match
+     *
+     * @example Dom.find("div").inside(".container")
+     *
+     * @param {any} selector Target selector
+     * @returns {boolean} True if inside
+     */
+    inside(selector: any): boolean;
+    /**
+     * Check if contains match
+     *
+     * @example Dom.find("div").contains(".item")
+     *
+     * @param {any} selector Target selector
+     * @returns {boolean} True if contains
+     */
+    contains(selector: any): boolean;
+    /**
+     * @see PicoDom.above
+     */
+    isParent(...args: any[]): boolean;
+    /**
+     * @see PicoDom.prev
+     */
+    previous(): PicoDom;
+    /**
+     * @see PicoDom.filter
+     */
+    where(...args: any[]): Element[];
+    /**
+     * @see PicoDom.except
+     */
+    not(...args: any[]): Element[];
+    getNot(): void;
+}
+export function PicoDomFinderPlugin(self: any): typeof import("#src/utils/Dom.js").PicoDom;

package/types/dom/DomForm.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @memberof PicoDom
+ */
+export class PicoDomFormStatic {
+}
+/**
+ * @memberof PicoDom
+ * @extends {PicoDom}
+ */
+export class PicoDomFormInstance {
+    /**
+     * Get or set input value
+     *
+     * @example Dom.find("input").value("hello")
+     *
+     * @param {any} [value] Input value
+     * @returns {any|this} Value or instance
+     */
+    value(value?: any): any | this;
+}
+export function PicoDomFormPlugin(self: any): typeof import("#src/utils/Dom.js").PicoDom;