@codady/utils 0.0.38 → 0.0.40

package/dist/utils.esm.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}
@@ -941,30 +941,31 @@ const isEmpty = (data) => {
     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;
 };
 
@@ -1338,6 +1339,549 @@ const decodeHtmlEntities = (text) => {
     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,
@@ -1381,6 +1925,14 @@ const utils = {
     escapeHTML,
     toSingleLine,
     renderTpl,
+    getBodyHTML,
+    getUrlHash,
+    buildUrl,
+    ajax,
+    capitalize,
+    cleanQueryString,
+    stringToEncodings,
+    unicodeToEncodings,
 };
 
 export { utils as default };