funda-ui 4.7.615 → 4.7.624

package/publish/lib/esm/Utils/libs/dom.ts

@@ -0,0 +1,150 @@
+/**
+ * Dom Utilities
+ * @param {HTMLElement} el      - Element
+ * @param  {?String} filter      - A filter string
+ * @returns HtmlElementCollection
+ */
+function matches(el: HTMLElement, filter: string | null): boolean {
+    if (el && el.nodeType === 1) {
+        if (filter) {
+            return el.matches(filter);
+        }
+        return true;
+    }
+    return false;
+}
+
+// the next siblings
+function getNextSiblings(el: HTMLElement, filter: string = ''): HTMLElement[] {
+    const sibs: HTMLElement[] = [];
+    while (el = el.nextSibling as HTMLElement) {
+        if (matches(el, filter)) {
+            sibs.push(el);
+        }
+    }
+    return sibs;
+}
+
+// previous siblings
+function getPreviousSiblings(el: HTMLElement, filter: string = ''): HTMLElement[] {
+    const sibs: HTMLElement[] = [];
+    while (el = el.previousSibling as HTMLElement) {
+        if (matches(el, filter)) {
+            sibs.push(el);
+        }
+    }
+    return sibs;
+}
+
+// parent and get all the siblings
+function getAllSiblings(el: HTMLElement, filter: string = ''): HTMLElement[] {
+    const sibs: HTMLElement[] = [];
+    el = el.parentNode!.firstChild as HTMLElement;
+    while (el = el.nextSibling as HTMLElement) {
+        if (matches(el, filter)) {
+            sibs.push(el);
+        }
+    }
+    return sibs;
+}
+
+// all parent nodes
+function getParents(el: HTMLElement, filter: string = ''): HTMLElement[] {
+    const parents: HTMLElement[] = [];
+    while (el = el.parentNode as HTMLElement) {
+        if (matches(el, filter)) {
+            parents.push(el);
+        }
+    }
+    return parents;
+}
+
+// all child nodes
+function getChildren(el: HTMLElement, filter: string = '', all: any[] = []): any[] {
+    all.push(...el.childNodes as any);
+    for (const child of el.childNodes as any) {
+        getChildren(child as HTMLElement, filter, all);
+    }
+
+    const res = all.filter((item) => matches(item as HTMLElement, filter));
+    return res;
+}
+
+function isRootElement(element: HTMLElement): boolean {
+    return element.matches('html,body');
+}
+
+function getDocument(node?: Node): Document {
+    if (typeof node === 'undefined') {
+        return document;
+    } else {
+        return node.ownerDocument!;
+    }
+}
+
+function isNode(value: any): value is Node {
+    return value instanceof Node;
+}
+
+function isElement(value: any): value is Element {
+    return value instanceof Element;
+}
+
+function isHTMLElement(value: any): value is HTMLElement {
+    return value instanceof HTMLElement;
+}
+
+function isShadowRoot(value: any): value is ShadowRoot {
+    // Browsers without `ShadowRoot` support.
+    if (typeof ShadowRoot === 'undefined') {
+        return false;
+    }
+
+    return value instanceof ShadowRoot;
+}
+
+/* console.log(nodeContains(document.body, document.getElementById('obj'))) */
+function nodeContains(parent: Node, child: Node): boolean {
+    if (!parent || !child) {
+        return false;
+    }
+
+    const rootNode = child.getRootNode?.();
+
+    // First, attempt with faster native method
+    if (parent.contains(child)) {
+        return true;
+    }
+
+    // then fallback to custom implementation with Shadow DOM support
+    if (rootNode && isShadowRoot(rootNode)) {
+        let next = child;
+        while (next) {
+            if (parent === next) {
+                return true;
+            }
+            // @ts-ignore
+            next = next.parentNode || next.host;
+        }
+    }
+
+    // Give up, the result is false
+    return false;
+}
+
+
+export {
+    getNextSiblings,
+    getPreviousSiblings,
+    getAllSiblings,
+    getParents,
+    getChildren,
+    isRootElement,
+    getDocument,
+    isNode,
+    isElement,
+    isHTMLElement,
+    isShadowRoot,
+    nodeContains
+}
+

package/publish/lib/esm/Utils/libs/easing.ts

@@ -0,0 +1,201 @@
+/*
+ * All easing functions
+ * @link: https://easings.net
+ * @param {Number} t   - time (Amount of time that has passed since the beginning of the animation. Usually starts at 0 and is slowly increased using a game loop or other update function.)
+ * @param {Number} b   - beginning value (The starting point of the animation. Usually it's a static value, you can start at 0 for example.)
+ * @param {Number} c   - change in value (The amount of change needed to go from starting point to end point. It's also usually a static value.)
+ * @param {Number} d   - duration (Amount of time the animation will take. Usually a static value aswell.)
+ * @return {number}
+ */
+function easeLinear (t: number, b: number, c: number, d: number): number {
+    return c * t / d + b;
+}
+
+function easeInQuad (t: number, b: number, c: number, d: number): number {
+    return c * (t /= d) * t + b;
+}
+
+function easeOutQuad (t: number, b: number, c: number, d: number): number {
+    return -c * (t /= d) * (t - 2) + b;
+}
+
+function easeInOutQuad (t: number, b: number, c: number, d: number): number {
+    if ((t /= d / 2) < 1) return c / 2 * t * t + b;
+    return -c / 2 * ((--t) * (t - 2) - 1) + b;
+}
+
+function easeInSine (t: number, b: number, c: number, d: number): number {
+    return -c * Math.cos(t / d * (Math.PI / 2)) + c + b;
+}
+
+function easeOutSine (t: number, b: number, c: number, d: number): number {
+    return c * Math.sin(t / d * (Math.PI / 2)) + b;
+}
+
+function easeInOutSine (t: number, b: number, c: number, d: number): number {
+    return -c / 2 * (Math.cos(Math.PI * t / d) - 1) + b;
+}
+
+function easeInExpo (t: number, b: number, c: number, d: number): number {
+    return (t == 0) ? b : c * Math.pow(2, 10 * (t / d - 1)) + b;
+}
+
+function easeOutExpo (t: number, b: number, c: number, d: number): number {
+    return (t == d) ? b + c : c * (-Math.pow(2, -10 * t / d) + 1) + b;
+}
+
+function easeInOutExpo (t: number, b: number, c: number, d: number): number {
+    if (t == 0) return b;
+    if (t == d) return b + c;
+    if ((t /= d / 2) < 1) return c / 2 * Math.pow(2, 10 * (t - 1)) + b;
+    return c / 2 * (-Math.pow(2, -10 * --t) + 2) + b;
+}
+
+function easeInCirc (t: number, b: number, c: number, d: number): number {
+    return -c * (Math.sqrt(1 - (t /= d) * t) - 1) + b;
+}
+
+function easeOutCirc (t: number, b: number, c: number, d: number): number {
+    return c * Math.sqrt(1 - (t = t / d - 1) * t) + b;
+}
+
+function easeInOutCirc (t: number, b: number, c: number, d: number): number {
+    if ((t /= d / 2) < 1) return -c / 2 * (Math.sqrt(1 - t * t) - 1) + b;
+    return c / 2 * (Math.sqrt(1 - (t -= 2) * t) + 1) + b;
+}
+
+function easeInCubic (t: number, b: number, c: number, d: number): number {
+    return c * (t /= d) * t * t + b;
+}
+
+function easeOutCubic (t: number, b: number, c: number, d: number): number {
+    return c * ((t = t / d - 1) * t * t + 1) + b;
+}
+
+function easeInOutCubic (t: number, b: number, c: number, d: number): number {
+    if ((t /= d / 2) < 1) return c / 2 * t * t * t + b;
+    return c / 2 * ((t -= 2) * t * t + 2) + b;
+}
+
+function easeInQuart (t: number, b: number, c: number, d: number): number {
+    return c * (t /= d) * t * t * t + b;
+}
+
+function easeOutQuart (t: number, b: number, c: number, d: number): number {
+    return -c * ((t = t / d - 1) * t * t * t - 1) + b;
+}
+
+function easeInOutQuart (t: number, b: number, c: number, d: number): number {
+    if ((t /= d / 2) < 1) return c / 2 * t * t * t * t + b;
+    return -c / 2 * ((t -= 2) * t * t * t - 2) + b;
+}
+
+function easeInQuint (t: number, b: number, c: number, d: number): number {
+    return c * (t /= d) * t * t * t * t + b;
+}
+
+function easeOutQuint (t: number, b: number, c: number, d: number): number {
+    return c * ((t = t / d - 1) * t * t * t * t + 1) + b;
+}
+
+
+function easeInOutQuint (t: number, b: number, c: number, d: number): number {
+    if ((t /= d / 2) < 1) return c / 2 * t * t * t * t * t + b;
+    return c / 2 * ((t -= 2) * t * t * t * t + 2) + b;
+}
+
+function easeInElastic (t: number, b: number, c: number, d: number): number {
+    var s: number = 1.70158;
+    var p: number = 0;
+    var a: number = c;
+    if (t == 0) return b;
+    if ((t /= d) == 1) return b + c;
+    if (!p) p = d * .3;
+    if (a < Math.abs(c)) {
+        a = c;
+        var s = p / 4;
+    }
+    else var s = p / (2 * Math.PI) * Math.asin(c / a);
+    return -(a * Math.pow(2, 10 * (t -= 1)) * Math.sin((t * d - s) * (2 * Math.PI) / p)) + b;
+}
+
+function easeOutElastic (t: number, b: number, c: number, d: number): number {
+    var s: number = 1.70158;
+    var p: number = 0;
+    var a: number = c;
+    if (t == 0) return b;
+    if ((t /= d) == 1) return b + c;
+    if (!p) p = d * .3;
+    if (a < Math.abs(c)) {
+        a = c;
+        var s = p / 4;
+    }
+    else var s = p / (2 * Math.PI) * Math.asin(c / a);
+    return a * Math.pow(2, -10 * t) * Math.sin((t * d - s) * (2 * Math.PI) / p) + c + b;
+}
+
+function easeInOutElastic (t: number, b: number, c: number, d: number): number {
+    var s: number = 1.70158;
+    var p: number = 0;
+    var a: number = c;
+    if (t == 0) return b;
+    if ((t /= d / 2) == 2) return b + c;
+    if (!p) p = d * (.3 * 1.5);
+    if (a < Math.abs(c)) {
+        a = c;
+        var s = p / 4;
+    }
+    else var s = p / (2 * Math.PI) * Math.asin(c / a);
+    if (t < 1) return -.5 * (a * Math.pow(2, 10 * (t -= 1)) * Math.sin((t * d - s) * (2 * Math.PI) / p)) + b;
+    return a * Math.pow(2, -10 * (t -= 1)) * Math.sin((t * d - s) * (2 * Math.PI) / p) * .5 + c + b;
+}
+
+function easeInBack (t: number, b: number, c: number, d: number): number {
+    var s: number = 1.70158;
+    if (s == undefined) s = 1.70158;
+    return c * (t /= d) * t * ((s + 1) * t - s) + b;
+}
+
+function easeOutBack (t: number, b: number, c: number, d: number): number {
+    var s: number = 1.70158;
+    if (s == undefined) s = 1.70158;
+    return c * ((t = t / d - 1) * t * ((s + 1) * t + s) + 1) + b;
+}
+
+function easeInOutBack (t: number, b: number, c: number, d: number): number {
+    var s: number = 1.70158;
+    if (s == undefined) s = 1.70158;
+    if ((t /= d / 2) < 1) return c / 2 * (t * t * (((s *= (1.525)) + 1) * t - s)) + b;
+    return c / 2 * ((t -= 2) * t * (((s *= (1.525)) + 1) * t + s) + 2) + b;
+}
+
+export { 
+    easeLinear, 
+    easeInQuad, 
+    easeOutQuad, 
+    easeInOutQuad, 
+    easeInSine, 
+    easeOutSine, 
+    easeInOutSine, 
+    easeInExpo, 
+    easeOutExpo, 
+    easeInOutExpo, 
+    easeInCirc, 
+    easeOutCirc, 
+    easeInOutCirc, 
+    easeInCubic, 
+    easeOutCubic, 
+    easeInOutCubic, 
+    easeInQuart, 
+    easeOutQuart, 
+    easeInOutQuart, 
+    easeInQuint, 
+    easeOutQuint, 
+    easeInOutQuint, 
+    easeInElastic, 
+    easeOutElastic, 
+    easeInOutElastic, 
+    easeInBack, 
+    easeOutBack, 
+    easeInOutBack
+};

package/publish/lib/esm/Utils/libs/extract.ts

@@ -0,0 +1,160 @@
+/**
+ * Determine whether an extractor is included
+ * @param {String} str    =>  input string. such as 'a[1], b[2]', '{a[1]}'
+ * @returns {Boolean} 
+ */
+function extractorExist(str: string | undefined | null): boolean {
+    if (typeof str === 'undefined' || str === null || str === '') {
+        return false;
+    }
+
+    let res: boolean = false;
+    if ( str?.match(/(\[.*?\])/gi) ) {
+        res = true;
+    }
+    return res;
+}
+
+/**
+ * Extract the contents of square brackets
+ * @param {String} str    =>  input string. such as '[1,2] [f][c]'
+ * @param {Boolean} commaSeparated    =>  flag to determine if the result should be comma separated or not
+ * @returns {Array<string>|string} such as: ['1,2','f','c']
+ */
+function extractContentsOfBrackets(str: string, commaSeparated: boolean = false): Array<string> | string {
+    if (typeof str === 'undefined' || str === null || str === '') {
+        return !commaSeparated ? [] : '';
+    }
+
+    const res = str.match(/[^\[]+(?=(\[ \])|\])/g);
+    if (commaSeparated) {
+        return res === null ? '' : res.join(',').replace(/\,+$/, '');
+    } else {
+        return res === null ? '' : res;
+    }
+    
+}
+
+/**
+ * Extract the contents of curly braces
+ * @param {String} str    =>  input string. such as '{1,2} {f}{c}'
+ * @param {Boolean} commaSeparated    =>  flag to determine if the result should be comma separated or not
+ * @returns {Array<string>|string} such as: ['1,2','f','c']
+ */
+function extractContentsOfBraces(str: string, commaSeparated: boolean = false): Array<string> | string {
+    if (typeof str === 'undefined' || str === null || str === '') {
+        return !commaSeparated ? [] : '';
+    }
+
+    const res = str.match(/[^\{]+(?=(\{ \})|\})/g);
+    if (commaSeparated) {
+        return res === null ? '' : res.join(',').replace(/\,+$/, '');
+    } else {
+        return res === null ? '' : res;
+    }
+    
+}
+
+/**
+ * Extract the contents of parentheses
+ * @param {String} str    =>  input string. such as '(1,2) (f)(c)'
+ * @param {Boolean} commaSeparated    =>  flag to determine if the result should be comma separated or not
+ * @returns {Array<string>|string} such as: ['1,2','f','c']
+ */
+function extractContentsOfParentheses(str: string, commaSeparated: boolean = false): Array<string> | string {
+    if (typeof str === 'undefined' || str === null || str === '') {
+        return !commaSeparated ? [] : '';
+    }
+
+    const res = str.match(/[^\(]+(?=(\( \))|\))/g);
+    if (commaSeparated) {
+        return res === null ? '' : res.join(',').replace(/\,+$/, '');
+    } else {
+        return res === null ? '' : res;
+    }
+    
+}
+
+
+/**
+ * Parses a braces-separated string of `{label[value]}` pairs into an array of objects.
+ *
+ * Example:
+ *   Input: "{Poor[c]}{Sub-option 4[c-2]}{Empty[]}"
+ *   Input: "{{Poor[c]}{Sub-option 4[c-2]}{Empty[]}[]}"
+ * 
+ *   Output: [
+ *     { label: "Poor", value: "c" },
+ *     { label: "Sub-option 4", value: "c-2" },
+ *     { label: "Empty", value: "" }
+ *   ]
+ *
+ * @param {string} str - The input string containing one or more `{label[value]}` segments.
+ * @returns {Array<{label: string, value: string}>} - An array of extracted label-value objects.
+ */
+function extractContentsOfMixedCharactersWithBraces(str: string): {
+    label: string;
+    value: string | number;
+}[] {
+    // Fix the extra '{' at the beginning
+    const cleaned = str.replace(/^{{/, '{');
+
+    // Remove empty {} or {[]} tail
+    const trimmed = cleaned.replace(/\{\[\]\}$/, '');
+
+    // The match is like {label[value]}
+    const pattern = /\{(.*?)\[(.*?)\]\}/g;
+    const matches = Array.from(trimmed.matchAll(pattern));
+
+    return matches.map(match => ({
+        label: match[1],
+        value: match[2]
+    }));
+}
+
+
+
+
+/**
+ * Parses a comma-separated string of `label[value]` pairs into an array of objects.
+ *
+ * Example:
+ *   Input: "Poor[c],Sub-option 4[c-2],Empty[]"
+ *   Output: [
+ *     { label: "Poor", value: "c" },
+ *     { label: "Sub-option 4", value: "c-2" },
+ *     { label: "Empty", value: "" }
+ *   ]
+ *
+ * @param {string} str - A string containing label-value pairs in the format `label[value]`, separated by commas.
+ * @returns {Array<{ label: string, value: string }>} - An array of parsed objects.
+ */
+function extractContentsOfMixedCharactersWithComma(str: string): {
+    label: string;
+    value: string | number;
+}[] {
+    return str
+        .split(",")
+        .map(item => item.trim())
+        .map(item => {
+            const match = item.match(/^(.*?)\[(.*?)\]$/);
+            if (match) {
+                return {
+                    label: match[1],
+                    value: match[2]
+                };
+            }
+            return null;
+        })
+        .filter(Boolean) as { label: string; value: string | number }[];
+}
+
+
+export {
+    extractorExist,
+    extractContentsOfBrackets,
+    extractContentsOfBraces,
+    extractContentsOfParentheses,
+    extractContentsOfMixedCharactersWithBraces,
+    extractContentsOfMixedCharactersWithComma
+}

package/publish/lib/esm/Utils/libs/format-string.ts

@@ -0,0 +1,116 @@
+/**
+ * String formatting utility functions
+ */
+
+/**
+ * Remove all special characters except space from a string
+ * @param {string} input - The input string to process
+ * @returns {string} The processed string
+ */
+function rmSpec(input: string): string {
+    return input?.replace(/[^a-zA-Z0-9 \u4E00-\u9FFF]/g, "");
+}
+
+/**
+ * Allow only numbers and letters in a string
+ * @param {string} input - The input string to process
+ * @returns {string} The processed string
+ */
+function onlyNumAndLetter(input: string): string {
+    return input?.replace(/[^a-zA-Z0-9 ]/g, "");
+}
+
+/**
+ * Remove all spaces including those in the middle
+ * @param {string} input - The input string to process
+ * @returns {string} The processed string
+ */
+function rmAllSpace(input: string): string {
+    return input?.replace(/\s/g, "");
+}
+
+/**
+ * Remove whitespace from both sides of a string
+ * @param {string} input - The input string to process
+ * @returns {string} The processed string
+ */
+function trimAll(input: string): string {
+    return input?.replace(/(^\s+)|(\s+$)/g, "");
+}
+
+/**
+ * Replace multiple spaces with a single space
+ * @param {string} input - The input string to process
+ * @returns {string} The processed string
+ */
+function multiSpacesToSingle(input: string): string {
+    return input?.replace(/\s+(\W)/g, ' ');
+}
+
+/**
+ * Convert HTML text to plain text (Remove html tag content)
+ * @param {string} input - The input string to process
+ * @returns {string} The processed string
+ */
+/*
+Examples:
+console.log(htmlToPlain("<p>Hello <b>World</b></p>"));   // Hello World
+*/
+function htmlToPlain(input: string): string {
+    return input?.replace(/(<([^>]+)>)/ig, '');
+}
+
+/**
+ * Strip HTML tags and their content 
+ * !!!Important: It will remove nested tags
+ * @param {string} input - The input string to process
+ * @returns {string} The processed string
+ */
+/*
+Examples:
+console.log(stripTagsAndContent("<p>Hello <b>World</b></p>"));  // World
+console.log(stripTagsAndContent("Hello <b>World</b>"));  // Hello
+*/
+function stripTagsAndContent(input: string): string {
+    return input?.replace(/<\/?[^>]+(>|$)(.*?)<\/?[^>]+(>|$)/ig, '');
+}
+
+/**
+ * Remove first and last slash from a URL
+ * @param {string} input - The input URL to process
+ * @returns {string} The processed URL
+ */
+function removeFirstLastSlash(input: string): string {
+    return input?.replace(/^\/|\/$/g, '');
+}
+
+/**
+ * Remove trailing slash from a URL
+ * @param {string} input - The input URL to process
+ * @returns {string} The processed URL
+ */
+function removeTrailingSlash(input: string): string {
+    return input?.replace(/\/+$/, '');
+}
+
+/**
+ * Remove first slash from a URL
+ * @param {string} input - The input URL to process
+ * @returns {string} The processed URL
+ */
+function removeFirstSlash(input: string): string {
+    return input?.replace(/\//, '');
+}
+
+export {
+    rmSpec,
+    onlyNumAndLetter,
+    rmAllSpace,
+    trimAll,
+    multiSpacesToSingle,
+    htmlToPlain,
+    stripTagsAndContent,
+    removeFirstLastSlash,
+    removeTrailingSlash,
+    removeFirstSlash
+};