@codady/utils 0.0.38 → 0.0.40

package/dist/utils.umd.js

@@ -1,8 +1,8 @@
 
 /*!
- * @since Last modified: 2026-1-16 15:18:30
+ * @since Last modified: 2026-2-5 17:4:41
  * @name Utils for web front-end.
- * @version 0.0.38
+ * @version 0.0.40
  * @author AXUI development team <3217728223@qq.com>
  * @description This is a set of general-purpose JavaScript utility functions developed by the AXUI team. All functions are pure and do not involve CSS or other third-party libraries. They are suitable for any web front-end environment.
  * @see {@link https://www.axui.cn|Official website}
@@ -947,30 +947,31 @@
         let type = getDataType(data), flag;
         if (!data) {
             //0,'',false,undefined,null
-            flag = true;
+            return true;
         }
-        else {
-            //function(){}|()=>{}
-            //[null]|[undefined]|['']|[""]
-            //[]|{}
-            //Symbol()|Symbol.for()
-            //Set,Map
-            //Date/Regex
-            flag = (type === 'Object') ? (Object.keys(data).length === 0) :
-                (type === 'Array') ? data.join('') === '' :
-                    (type === 'Function') ? (data.toString().replace(/\s+/g, '').match(/{.*}/g)[0] === '{}') :
-                        (type === 'Symbol') ? (data.toString().replace(/\s+/g, '').match(/\(.*\)/g)[0] === '()') :
-                            (type === 'Set' || type === 'Map') ? data.size === 0 :
-                                type === 'Date' ? isNaN(data.getTime()) :
-                                    type === 'RegExp' ? data.source === '' :
-                                        type === 'ArrayBuffer' ? data.byteLength === 0 :
-                                            (type === 'NodeList' || type === 'HTMLCollection') ? data.length === 0 :
-                                                ('length' in data && typeof data.length === 'number') ? data.length === 0 :
-                                                    ('size' in data && typeof data.size === 'number') ? data.size === 0 :
-                                                        (type === 'Error' || data instanceof Error) ? data.message === '' :
-                                                            (type.includes('Array') && (['Uint8Array', 'Int8Array', 'Uint16Array', 'Int16Array', 'Uint32Array', 'Int32Array', 'Float32Array', 'Float64Array'].includes(type))) ? data.length === 0 :
-                                                                false;
+        if (['String', 'Number', 'Boolean'].includes(type)) {
+            return false;
         }
+        //function(){}|()=>{}
+        //[null]|[undefined]|['']|[""]
+        //[]|{}
+        //Symbol()|Symbol.for()
+        //Set,Map
+        //Date/Regex
+        flag = (type === 'Object') ? (Object.keys(data).length === 0) :
+            (type === 'Array') ? data.join('') === '' :
+                (type === 'Function') ? (data.toString().replace(/\s+/g, '').match(/{.*}/g)[0] === '{}') :
+                    (type === 'Symbol') ? (data.toString().replace(/\s+/g, '').match(/\(.*\)/g)[0] === '()') :
+                        (type === 'Set' || type === 'Map') ? data.size === 0 :
+                            type === 'Date' ? isNaN(data.getTime()) :
+                                type === 'RegExp' ? data.source === '' :
+                                    type === 'ArrayBuffer' ? data.byteLength === 0 :
+                                        (type === 'NodeList' || type === 'HTMLCollection') ? data.length === 0 :
+                                            ('length' in data && typeof data.length === 'number') ? data.length === 0 :
+                                                ('size' in data && typeof data.size === 'number') ? data.size === 0 :
+                                                    (type === 'Error' || data instanceof Error) ? data.message === '' :
+                                                        (type.includes('Array') && (['Uint8Array', 'Int8Array', 'Uint16Array', 'Int16Array', 'Uint32Array', 'Int32Array', 'Float32Array', 'Float64Array'].includes(type))) ? data.length === 0 :
+                                                            false;
         return flag;
     };
 
@@ -1344,6 +1345,549 @@
         return textArea.value; // Get the decoded string from the text area
     };
 
+    const getBodyHTML = (htmlText, selector) => {
+        // Return early if the input is not a valid string or doesn't look like HTML
+        if (!htmlText || typeof htmlText !== 'string') {
+            return '';
+        }
+        try {
+            
+            const parser = new DOMParser(), 
+            
+            doc = parser.parseFromString(htmlText, 'text/html'), 
+            
+            bodyContent = doc.body.innerHTML;
+            if (selector) {
+                // Normalize hash: ensure it's a valid ID selector
+                const targetEl = doc.querySelector(selector);
+                if (targetEl) {
+                    return targetEl.innerHTML;
+                }
+                // If hash is provided but element not found, we fallback to body or warn
+                console.warn(`Element with selector "${selector}" not found in the HTML.`);
+            }
+            return bodyContent ? bodyContent.trim() : htmlText;
+        }
+        catch (error) {
+            
+            console.error("Failed to parse HTML content using DOMParser:", error);
+            return htmlText;
+        }
+    };
+
+    const getUrlHash = (url) => {
+        // Return empty if input is null, undefined, or not a string
+        if (!url || typeof url !== 'string') {
+            return '';
+        }
+        try {
+            
+            const baseUrl = window?.location?.origin || 'https://www.axui.cn', urlObj = new URL(url, baseUrl);
+            return urlObj.hash;
+        }
+        catch (error) {
+            
+            return '';
+        }
+    };
+
+    const cleanQueryString = (data) => {
+        return typeof data === 'string' && (data.startsWith('?') || data.startsWith('&'))
+            ? data.slice(1) // Remove the leading '?' or '&'
+            : data; // Return the string as-is if no leading character is present
+    };
+
+    const buildUrl = ({ url, data, cacheBustKey = '_t', appendCacheBust = true }) => {
+        // 1. Extract and remove the hash (e.g., /page#section -> hash="#section")
+        const hashIndex = url.indexOf('#');
+        let hash = '', pureUrl = url;
+        // If a hash exists, separate it from the base URL
+        if (hashIndex !== -1) {
+            hash = url.slice(hashIndex);
+            pureUrl = url.slice(0, hashIndex);
+        }
+        // 2. Use the URL object to handle the base URL and existing query parameters.
+        // `window.location.origin` ensures the support for relative paths (e.g., '/api/list').
+        const urlObj = new URL(pureUrl, window.location.origin);
+        // 3. Append business data (query parameters) to the URL if data is not empty
+        if (!isEmpty(data)) {
+            let params, dataType = getDataType(data);
+            // If the data is a URLSearchParams object, directly use it
+            if (dataType === 'URLSearchParams') {
+                params = data;
+            }
+            else if (dataType === 'object') {
+                // If the data is an object, convert it to URLSearchParams
+                params = new URLSearchParams(data);
+            }
+            else {
+                // If the data is a string, clean it up (remove leading '?' or '&')
+                params = new URLSearchParams(cleanQueryString(data));
+            }
+            // Append new parameters to the existing URL search parameters
+            params.forEach((value, key) => {
+                urlObj.searchParams.append(key, value);
+            });
+        }
+        // 4. Optionally add the cache-busting parameter if the flag is set
+        appendCacheBust && cacheBustKey && urlObj.searchParams.set(cacheBustKey, Date.now().toString());
+        // 5. Return the final URL: base URL + query parameters + original hash (if any)
+        return urlObj.toString() + hash;
+    };
+
+    const capitalize = (str) => {
+        // Check if the input string is empty or undefined
+        if (!str)
+            return str;
+        // Capitalize the first letter and return the new string
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    };
+
+    const ajax = (options) => {
+        // Validation
+        if (isEmpty(options)) {
+            return Promise.reject(new Error('Options are required'));
+        }
+        if (!options.url || typeof options.url !== 'string') {
+            return Promise.reject(new Error('URL is required and must be a string'));
+        }
+        // Default configuration
+        const config = {
+            url: '',
+            method: 'POST',
+            async: true,
+            selector: '',
+            data: null,
+            timeout: 3600000,
+            headers: {},
+            responseType: '',
+            catchError: false,
+            signal: null,
+            xhrFields: {},
+            cacheBustKey: '_t',
+            precision: 2,
+            //
+            onAbort: null,
+            onTimeout: null,
+            //
+            onBeforeSend: null,
+            //
+            onCreated: null,
+            onOpened: null,
+            onHeadersReceived: null,
+            onLoading: null,
+            //
+            onSuccess: null,
+            onFailure: null,
+            onInformation: null,
+            onRedirection: null,
+            onClientError: null,
+            onServerError: null,
+            onUnknownError: null,
+            onError: null,
+            onFinish: null,
+            //
+            onDownload: null,
+            onUpload: null,
+            onComplete: null,
+        };
+        //合并参数
+        Object.assign(config, options);
+        //
+        const method = config.method.toUpperCase() || 'POST', methodsWithoutBody = ['GET', 'HEAD', 'TRACE'];
+        //创建XMLHttpRequest
+        let xhr = new XMLHttpRequest(), 
+        //设置发送数据和预设请求头
+        requestData = null, headerContentType = config?.headers?.['Content-Type'] || config?.headers?.['content-type'], removeHeader = () => {
+            if (headerContentType) {
+                delete config.headers['Content-Type'];
+                delete config.headers['content-type'];
+            }
+        };
+        if (!isEmpty(config.data)) {
+            let dataType = getDataType(config.data);
+            if (dataType === 'FormData') {
+                //如果是new FormData格式，直接相等
+                requestData = config.data;
+                // 不需要手动设置Content-Type，浏览器会自动设置
+                //config.contType = 'multipart/form-data';
+                removeHeader();
+            }
+            else if (dataType === 'Object') {
+                //如果是对象格式{name:'',age:''}
+                //并且此时已经设置了contType
+                if (!headerContentType) {
+                    //如果未设置则默认设为如下contType
+                    //Content-Type=application/x-www-form-urlencoded
+                    
+                    requestData = new URLSearchParams(config.data).toString();
+                    //URLSearchParams.toString => `a=1&b=3`
+                    //非get、head方法修正content-type
+                    if (!methodsWithoutBody.includes(method)) {
+                        config.headers['Content-Type'] = 'application/x-www-form-urlencoded';
+                    }
+                }
+                else if (headerContentType?.includes('application/json')) {
+                    //Content-Type=application/json或contentType=application/json
+                    requestData = JSON.stringify(config.data);
+                }
+                else {
+                    requestData = config.data;
+                }
+            }
+            else if (dataType === 'String') {
+                //未设置或，已经设置了Content-Type=application/x-www-form-urlencoded
+                if (!headerContentType || headerContentType.includes('urlencoded')) {
+                    //如果是name=''&age=''字符串
+                    //?name=''&age=''或&name=''&age=''统一去掉第一个&/?
+                    requestData = cleanQueryString(config.data.trim());
+                    //非get、head方法修正content-type
+                    if (!methodsWithoutBody.includes(method) && !headerContentType) {
+                        config.headers['Content-Type'] = 'application/x-www-form-urlencoded';
+                    }
+                }
+                else {
+                    requestData = config.data;
+                }
+            }
+            else {
+                requestData = config.data;
+            }
+        }
+        //设置超时时间
+        xhr.timeout = config.timeout;
+        // 响应类型
+        if (config.responseType) {
+            xhr.responseType = config.responseType;
+        }
+        //返回promise
+        const result = new Promise((resolve, reject) => {
+            //超时监听
+            const timeoutHandler = () => {
+                cleanup();
+                let resp = { ...context, status: xhr.status, content: xhr.response, type: 'timeout' };
+                //回调，status和content在此确认
+                config?.onTimeout?.(resp);
+                //reject只能接受一个参数
+                config.catchError ? reject(resp) : resolve(resp);
+                //超时也是不能获得数据的行为，定义为failure
+                config?.onFailure?.(resp);
+                //timeout会经过onreadystatechange，但是被及时的return了，所以这里多加一行
+                config?.onFinish?.(resp);
+            }, 
+            //报错监听
+            errorHandler = (resp) => {
+                //这几个错误来自xhr.onreadystatechange
+                if (resp.type === 'client-error') {
+                    config?.onClientError?.({ ...context });
+                }
+                else if (resp.type === 'server-error') {
+                    config?.onServerError?.({ ...context });
+                }
+                else if (resp.type === 'unknown-error') {
+                    config?.onUnknownError?.({ ...context });
+                }
+                //此外还会有xhr.onerror的错误，所以需要统一使用onError监听
+                config?.onError?.(resp);
+                //reject只能接受一个参数
+                config.catchError ? reject(resp) : resolve(resp);
+            }, 
+            //取消监听
+            abortHandler = () => {
+                cleanup();
+                const resp = { ...context, status: xhr.status, type: 'abort' };
+                config.catchError ? reject(resp) : resolve(resp);
+                //回调，status和content在此确认
+                config?.onAbort?.(resp);
+                //abort行为不会经过onreadystatechange，这里需要多这一行以表示xhr的完成（结束）
+                config?.onFinish?.(resp);
+            }, abortHandlerWithSignal = () => {
+                //先中止请求，防止触发其他 readystate 事件
+                xhr.abort();
+                abortHandler();
+            }, 
+            //成功监听
+            successHandler = (resp) => {
+                //成功回调
+                config?.onSuccess?.(resp);
+                //resolve只能接受一个参数
+                resolve(resp);
+            }, 
+            //统一处理abort
+            cleanup = () => {
+                // 如果使用了AbortSignal，则移除它的事件监听器
+                config.signal && config.signal.removeEventListener('abort', abortHandlerWithSignal);
+                // 移除各类事件监听器
+                config.onError && xhr.removeEventListener('error', errorHandler);
+                config.onTimeout && xhr.removeEventListener('timeout', timeoutHandler);
+                // 解绑上传/下载进度事件
+                config.onUpload && xhr.upload.removeEventListener('progress', uploadProgressHandler);
+                config.onDownload && xhr.removeEventListener('progress', downloadProgressHandler);
+                //销毁
+                xhr.onreadystatechange = null;
+            }, 
+            // Context object to track state
+            context = {
+                //原始xhr
+                xhr,
+                //发送的数据
+                data: requestData,
+                //可取消的函数
+                abort: abortHandler,
+                //xhr.status
+                status: '',
+                //响应的内容
+                content: null,
+                //0~4阶段编号
+                stage: 0,
+                //阶段名称
+                type: 'unset',
+                //上传和下载进度
+                progress: {}
+            }, getProgressValues = (ratio) => {
+                let text = (ratio * 100).toFixed(config.precision);
+                return { percent: parseFloat(text), text };
+            }, 
+            //定义进度函数
+            progressHandler = (name, data, callback) => {
+                if (data.lengthComputable) {
+                    const resp = { ...context, status: xhr.status }, ratio = data.loaded / data.total, { percent, text } = getProgressValues(ratio);
+                    resp.progress = {
+                        name,
+                        loaded: data.loaded,
+                        total: data.total,
+                        timestamp: (new Date(data.timeStamp)).getTime(),
+                        ratio,
+                        percent,
+                        text,
+                    };
+                    callback?.(resp);
+                    if (ratio >= 1) {
+                        Object.assign(resp.progress, getProgressValues(1));
+                        config?.onComplete?.(resp);
+                    }
+                }
+            }, uploadProgressHandler = (data) => {
+                progressHandler('upload', data, (resp) => config.onUpload(resp));
+            }, downloadProgressHandler = (data) => {
+                progressHandler('download', data, (resp) => config.onDownload(resp));
+            };
+            //使用AbortSignal
+            if (config.signal) {
+                if (config.signal.aborted)
+                    return abortHandlerWithSignal();
+                config.signal.addEventListener('abort', abortHandlerWithSignal);
+            }
+            //监听上传进度
+            config.onUpload && xhr.upload.addEventListener('progress', uploadProgressHandler);
+            //监听下载进度
+            config.onDownload && xhr.addEventListener('progress', downloadProgressHandler);
+            // 事件监听器
+            config.onError && xhr.addEventListener('error', errorHandler);
+            config.onTimeout && xhr.addEventListener('timeout', timeoutHandler);
+            config.onAbort && xhr.addEventListener('abort', abortHandler);
+            // 手动触发 Created 状态
+            config.onCreated?.({ ...context, type: 'created' });
+            //状态判断
+            xhr.onreadystatechange = function () {
+                context.stage = xhr.readyState;
+                context.status = xhr.status;
+                const statusMap = { 1: 'opened', 2: 'headersReceived', 3: 'loading' };
+                //0=created放在外侧确保能触发，如果放在.onreadystatechange可能触发不了
+                if (xhr.readyState < 4) {
+                    if (!xhr.readyState)
+                        return;
+                    context.type = statusMap[xhr.readyState];
+                    config[`on${capitalize(context.type)}`]?.({ ...context });
+                    return;
+                }
+                //tiemeout事件也会执行这里，此时需要让它触发onTimeout事件
+                //abort和timeout行为的status是0
+                //不过abort行为不会执行到这里
+                if (xhr.status === 0 && context.type !== 'abort') {
+                    return;
+                }
+                //已经请求成功，不会有timeout事件，也不需要abort了，所以移除abort事件
+                cleanup();
+                //根据状态码判断响应结果
+                const isInformation = xhr.status >= 100 && xhr.status < 200, isSuccess = (xhr.status >= 200 && xhr.status < 300) || xhr.status === 304, isRedirection = xhr.status >= 300 && xhr.status < 400, isClientError = xhr.status >= 400 && xhr.status < 500, isServerError = xhr.status >= 500 && xhr.status < 600;
+                //已经获得返回数据
+                if (isSuccess) {
+                    if (!config.responseType || xhr.responseType === 'text') {
+                        //可能返回字符串类型的对象，wordpress的REST API
+                        let trim = xhr.responseText.trim(), content = '';
+                        if ((trim.startsWith('[') && trim.endsWith(']')) || (trim.startsWith('{') && trim.endsWith('}'))) {
+                            //通过判断开头字符是{或[来确定异步页面是否是JSON内容，如果是则转成JSON对象
+                            try {
+                                content = JSON.parse(trim);
+                            }
+                            catch {
+                                console.warn('Malformed JSON detected, falling back to text.');
+                                content = xhr.responseText;
+                            }
+                        }
+                        else if (/(<\/html>|<\/body>)/i.test(trim)) {
+                            //请求了一个HTML页面
+                            //返回文本类型DOMstring
+                            let urlHash = getUrlHash(config.url);
+                            content = getBodyHTML(trim, config.selector || urlHash);
+                        }
+                        else {
+                            //普通文本，不做任何处理
+                            content = xhr.responseText;
+                        }
+                        //content=文本字符串/json
+                        context.content = content;
+                    }
+                    else {
+                        //content=json、blob、document、arraybuffer等类型，如果知道服务器返回的XML， xhr.responseType应该为document
+                        context.content = xhr.response;
+                    }
+                    context.type = 'success';
+                    successHandler({ ...context });
+                }
+                else {
+                    //失败回调
+                    context.content = xhr.response;
+                    context.type = isInformation ? 'infomation' : isRedirection ? 'redirection' : isClientError ? 'client-error' : isServerError ? 'server-error' : 'unknown-error';
+                    //
+                    if (isInformation) {
+                        config?.onInformation?.({ ...context });
+                    }
+                    else if (isRedirection) {
+                        config?.onRedirection?.({ ...context });
+                    }
+                    else {
+                        errorHandler({ ...context });
+                    }
+                    //
+                    config?.onFailure?.({ ...context });
+                }
+                config?.onFinish?.({ ...context });
+            };
+            //发送异步请求
+            let openParams = [method, config.url, config.async];
+            if (methodsWithoutBody.includes(method)) {
+                // 拼接url => xxx.com?a=0&b=1#hello
+                const url = buildUrl({
+                    url: config.url,
+                    data: requestData,
+                    cacheBustKey: config.cacheBustKey,
+                    appendCacheBust: true,
+                });
+                openParams = [method, url, config.async];
+            }
+            //设置xhr其他字段
+            for (let k in config.xhrFields) {
+                config.xhrFields.hasOwnProperty(k) && (xhr[k] = config.xhrFields[k]);
+            }
+            //与服务器建立连接
+            xhr.open(...openParams);
+            //有则设置，仅跳过空内容
+            for (let k in config.headers) {
+                config.headers.hasOwnProperty(k) && !isEmpty(config.headers[k]) && xhr.setRequestHeader(k, config.headers[k]);
+            }
+            config?.onBeforeSend?.(({ ...context, status: xhr.status, type: 'beforeSend' }));
+            //发送请求，get和head不需要发送数据
+            xhr.send(methodsWithoutBody.includes(method) ? null : (requestData || null));
+            //open和send阶段已经是异步了，无法使用try+catch捕获错误
+        });
+        //绑定xhr和abort
+        result.xhr = xhr;
+        result.abort = () => xhr.abort();
+        return result;
+    };
+    // Static Helper Methods
+    //get、head、trace是不需要发送数据的，data将被转为url参数处理
+    ['post', 'put', 'delete', 'patch', 'options', 'get', 'head', 'trace'].forEach(method => {
+        ajax[method] = (url, data, options = { url: '' }) => ajax({ ...options, method, url, data });
+    });
+    ajax.all = (requests) => Promise.all(requests.map(ajax));
+
+    const stringToEncodings = (name, options = {}) => {
+        // Default: Supplementary Private Use Area (Plane 15 and Plane 16)
+        //1,114,110 places,5000 strings => 0 collision
+        const start = options.start ?? 0xF0000, end = options.end ?? 0x10FFFD, range = BigInt(end - start + 1), registry = options.registryMap, 
+        
+        formatResult = (name, codePoint, hash, collision) => {
+            const hex = codePoint.toString(16).toUpperCase();
+            return {
+                name,
+                unicode: `U+${hex}`,
+                htmlDec: `&#${codePoint};`,
+                htmlHex: `&#x${hex};`,
+                hex,
+                codePoint,
+                hash,
+                collision,
+            };
+        };
+        // -----------------------------
+        // 1. Compute FNV-1a 64-bit hash
+        // -----------------------------
+        let hash = BigInt("0xcbf29ce484222325");
+        const prime = BigInt("0x100000001b3");
+        for (const ch of name) {
+            hash ^= BigInt(ch.codePointAt(0));
+            hash *= prime;
+        }
+        const hashHex = hash.toString(16).toUpperCase();
+        // -----------------------------
+        // 2. Stateless mode (no registry)
+        // -----------------------------
+        if (!registry) {
+            const offset = Number(hash % range), codePoint = start + offset;
+            return formatResult(name, codePoint, hashHex, false);
+        }
+        // -----------------------------
+        // 3. Registry mode (0 collision)
+        // -----------------------------
+        // Already assigned → return stable mapping
+        if (registry.has(name)) {
+            return formatResult(name, registry.get(name), hashHex, false);
+        }
+        // Initial candidate from hash
+        let offset = Number(hash % range), codePoint = start + offset, collision = false;
+        const used = new Set(registry.values());
+        // Linear probing to resolve collisions
+        while (used.has(codePoint)) {
+            collision = true;
+            offset = (offset + 1) % Number(range);
+            codePoint = start + offset;
+        }
+        // Commit allocation
+        registry.set(name, codePoint);
+        return formatResult(name, codePoint, hashHex, collision);
+    };
+
+    const unicodeToEncodings = (input) => {
+        let codePoint;
+        if (typeof input === "number") {
+            codePoint = input;
+        }
+        else {
+            const cleaned = input.trim()
+                .replace(/^U\+/i, "")
+                .replace(/^0x/i, "");
+            codePoint = /^[0-9A-F]+$/i.test(cleaned)
+                ? parseInt(cleaned, 16)
+                : parseInt(cleaned, 10);
+        }
+        // Validate parsed code point
+        if (!Number.isFinite(codePoint)) {
+            throw new Error("Invalid Unicode input");
+        }
+        // Convert code point to uppercase hexadecimal representation
+        const hex = codePoint.toString(16).toUpperCase();
+        return {
+            unicode: `U+${hex}`,
+            hex,
+            codePoint,
+            htmlDec: `&#${codePoint};`,
+            htmlHex: `&#x${hex};`,
+        };
+    };
+
     const utils = {
         //executeStr,
         getDataType,
@@ -1387,6 +1931,14 @@
         escapeHTML,
         toSingleLine,
         renderTpl,
+        getBodyHTML,
+        getUrlHash,
+        buildUrl,
+        ajax,
+        capitalize,
+        cleanQueryString,
+        stringToEncodings,
+        unicodeToEncodings,
     };
 
     return utils;