ziya-utils 1.1.5 → 1.1.7

package/es/node_modules/tslib/tslib.es6.js

@@ -15,6 +15,18 @@ PERFORMANCE OF THIS SOFTWARE.
 /* global Reflect, Promise, SuppressedError, Symbol */
 
 
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
 function __awaiter(thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -30,4 +42,4 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-export { __awaiter };
+export { __awaiter, __rest };

package/es/xhr/index.d.ts

@@ -10,9 +10,9 @@ interface InterceptRule {
     /** 拦截的 URL，模糊匹配 */
     url: string;
     /** 拦截响应的回调函数 */
-    responseCallback: (data: any) => any;
+    responseCallback: (data: any, url: string) => any;
     /** 拦截请求的回调函数 */
-    requestCallback?: (data: any) => any;
+    requestCallback?: (data: any, url: string) => any;
 }
 /**
  * 拦截器配置

package/es/xhr/index.js

@@ -46,7 +46,7 @@ class XHRInterceptor {
                 let processedBody = body;
                 if (matchingRule.requestCallback && body) {
                     try {
-                        processedBody = matchingRule.requestCallback(body);
+                        processedBody = matchingRule.requestCallback(body, requestUrl);
                     }
                     catch (error) {
                         console.error('XHR请求拦截器处理失败:', error);
@@ -62,7 +62,7 @@ class XHRInterceptor {
                             // 解析原始响应
                             const originalData = JSON.parse(xhr.responseText);
                             // 使用回调函数处理响应数据
-                            const modifiedData = matchingRule.responseCallback(originalData);
+                            const modifiedData = matchingRule.responseCallback(originalData, requestUrl);
                             // 重写响应属性
                             Object.defineProperty(xhr, "responseText", {
                                 writable: true,

package/lib/async/index.js

@@ -0,0 +1,59 @@
+'use strict';
+
+var tslib_es6 = require('../node_modules/tslib/tslib.es6.js');
+
+/**
+ * 创建异步任务，定时检查条件直到满足后执行初始化函数
+ * @param checkFun 检查函数，返回 true 值时表示条件满足
+ * @param initFun 初始化函数，在条件满足后执行
+ * @param options 配置选项
+ * @returns Promise，resolve 初始化函数的返回值
+ */
+function createAsyncTask(checkFun = () => null, initFun = () => undefined, options = {}) {
+    const { duration = 1, timeout, immediate = false } = options;
+    return new Promise((resolve, reject) => {
+        let timer = null;
+        let timeoutTimer = null;
+        // 清理定时器
+        const cleanup = () => {
+            if (timer) {
+                clearInterval(timer);
+                timer = null;
+            }
+            if (timeoutTimer) {
+                clearTimeout(timeoutTimer);
+                timeoutTimer = null;
+            }
+        };
+        // 检查逻辑
+        const check = () => tslib_es6.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const res = yield checkFun();
+                if (res) {
+                    cleanup();
+                    const res2 = yield initFun(res);
+                    resolve(res2);
+                }
+            }
+            catch (error) {
+                cleanup();
+                reject(error);
+            }
+        });
+        // 设置超时
+        if (timeout && timeout > 0) {
+            timeoutTimer = setTimeout(() => {
+                cleanup();
+                reject(new Error(`${timeout} 秒后任务将会超时。`));
+            }, timeout * 1000);
+        }
+        // 立即执行一次检查
+        if (immediate) {
+            check();
+        }
+        // 设置定时检查
+        timer = setInterval(check, duration * 1000);
+    });
+}
+
+exports.createAsyncTask = createAsyncTask;

package/lib/document/index.d.ts

@@ -3,6 +3,11 @@
  * @created 2025-04-02
  * @author glk
  */
+/**
+ * 向head追加一个样式表
+ * @param styStr
+ * @returns
+ */
 declare const addStyleStr: (styStr?: string) => HTMLStyleElement;
 /**
  * 创建一个全局唯一的遮罩 Loading
@@ -22,3 +27,4 @@ declare const createMaskLoading: (msg?: string, style?: string) => {
     updateMsg: (msg: string) => void;
 };
 export { addStyleStr, createMaskLoading };
+export * from "./script-dom-builder";

package/lib/document/index.js

@@ -1,12 +1,18 @@
 'use strict';
 
 var index = require('../constant/index.js');
+require('../node_modules/tslib/tslib.es6.js');
 
 /**
  * @fileoverview Document 模块
  * @created 2025-04-02
  * @author glk
  */
+/**
+ * 向head追加一个样式表
+ * @param styStr
+ * @returns
+ */
 const addStyleStr = (styStr = "") => {
     let _style = document.createElement("style");
     _style.innerHTML = styStr;

package/lib/document/script-dom-builder.d.ts

@@ -0,0 +1,80 @@
+interface ElementConfig {
+    type: 'input' | 'button' | 'select' | 'textarea' | 'checkbox' | 'label' | 'div';
+    keyword?: string;
+    saveToLocal?: boolean;
+    inputType?: string;
+    placeholder?: string;
+    value?: string;
+    text?: string;
+    options?: Array<{
+        value?: string;
+        text?: string;
+        selected?: boolean;
+    } | string>;
+    rows?: number;
+    checked?: boolean;
+    html?: string;
+    props?: Record<string, any>;
+    onClick?: (event: Event) => void;
+    onChange?: (event: Event) => void;
+    onInput?: (event: Event) => void;
+    onFocus?: (event: Event) => void;
+    onBlur?: (event: Event) => void;
+    onMouseEnter?: (event: Event) => void;
+    onMouseLeave?: (event: Event) => void;
+}
+interface ContainerConfig {
+    [key: string]: any;
+}
+interface DOMBuilderReturn {
+    container: HTMLDivElement;
+    get: (keyword: string) => HTMLElement | null;
+    getValue: (keyword: string) => string | boolean | null;
+    setValue: (keyword: string, value: string | boolean) => void;
+    show: (keyword?: string) => void;
+    hide: (keyword?: string) => void;
+    remove: () => void;
+    on: (keyword: string, event: string, handler: (event: Event) => void) => void;
+    getData: (key: string) => any;
+    setData: (key: string, value: any) => void;
+}
+/**
+ * 开发浏览器脚本DOM构建器
+ */
+declare class ScriptDomBuilder {
+    private parentNode;
+    private container;
+    private elements;
+    private data;
+    private containerId;
+    private styleElement;
+    constructor(parentNode?: HTMLElement, containerId?: string);
+    createMain(items: ElementConfig[], styles?: string, containerConfig?: ContainerConfig): DOMBuilderReturn;
+    private createStyles;
+    private createItem;
+    private isFormElement;
+    private handleLocalStorage;
+    private createInput;
+    private createButton;
+    private createSelect;
+    private createTextarea;
+    private createCheckbox;
+    private createLabel;
+    private createDiv;
+    private createElement;
+    private bindEvents;
+    private getChild;
+    private setChild;
+    private getValue;
+    private setValue;
+    private show;
+    private hide;
+    private remove;
+    private on;
+    private getStorageKey;
+    private saveToLocalStorage;
+    private getFromLocalStorage;
+    private setData;
+    private getData;
+}
+export { ScriptDomBuilder };

package/lib/document/script-dom-builder.js

@@ -0,0 +1,368 @@
+'use strict';
+
+var tslib_es6 = require('../node_modules/tslib/tslib.es6.js');
+
+/**
+ * 开发浏览器脚本DOM构建器
+ */
+class ScriptDomBuilder {
+    constructor(parentNode = document.body, containerId = "glk-script-container") {
+        this.container = null;
+        this.elements = new Map();
+        this.data = new Map();
+        this.styleElement = null;
+        this.parentNode = parentNode;
+        this.containerId = containerId;
+    }
+    // 创建主容器和子元素
+    createMain(items, styles = "", containerConfig = {}) {
+        // 创建样式
+        if (styles) {
+            this.createStyles(styles);
+        }
+        // 创建容器
+        this.container = this.createElement("div", Object.assign({ id: this.containerId }, containerConfig));
+        // 创建子元素
+        items.forEach((item, index) => {
+            const element = this.createItem(item, index);
+            if (element) {
+                this.container.appendChild(element);
+            }
+        });
+        // 添加到父节点
+        this.parentNode.appendChild(this.container);
+        return {
+            container: this.container,
+            get: (keyword) => this.getChild(keyword),
+            getValue: (keyword) => this.getValue(keyword),
+            setValue: (keyword, value) => this.setValue(keyword, value),
+            show: (keyword) => this.show(keyword),
+            hide: (keyword) => this.hide(keyword),
+            remove: () => this.remove(),
+            on: (keyword, event, handler) => this.on(keyword, event, handler),
+            getData: (key) => this.getData(key),
+            setData: (key, value) => this.setData(key, value),
+        };
+    }
+    // 创建样式
+    createStyles(styles) {
+        this.styleElement = document.createElement("style");
+        this.styleElement.textContent = styles;
+        document.head.appendChild(this.styleElement);
+    }
+    // 创建单个元素
+    createItem(config, index) {
+        const { type, keyword } = config; tslib_es6.__rest(config, ["type", "keyword"]);
+        let element = null;
+        switch (type) {
+            case "input":
+                element = this.createInput(config);
+                break;
+            case "button":
+                element = this.createButton(config);
+                break;
+            case "select":
+                element = this.createSelect(config);
+                break;
+            case "textarea":
+                element = this.createTextarea(config);
+                break;
+            case "checkbox":
+                element = this.createCheckbox(config);
+                break;
+            case "label":
+                element = this.createLabel(config);
+                break;
+            case "div":
+                element = this.createDiv(config);
+                break;
+            default:
+                console.warn(`未支持的元素类型: ${type}`);
+                return null;
+        }
+        // 存储元素引用
+        if (keyword && element) {
+            this.setChild(keyword, element);
+            // 处理本地存储逻辑
+            if (config.saveToLocal && this.isFormElement(type)) {
+                this.handleLocalStorage(element, config, type);
+            }
+        }
+        return element;
+    }
+    // 判断是否为表单元素
+    isFormElement(type) {
+        return ["input", "textarea", "select", "checkbox"].includes(type);
+    }
+    // 处理本地存储逻辑
+    handleLocalStorage(element, config, type) {
+        const storageKey = this.getStorageKey(config.keyword);
+        const savedValue = this.getFromLocalStorage(storageKey);
+        // 设置初始值
+        if (savedValue !== null) {
+            // 有本地存储值，使用本地值
+            if (type === "checkbox") {
+                const checkbox = element.querySelector('input[type="checkbox"]');
+                if (checkbox) {
+                    checkbox.checked = savedValue === "true";
+                }
+            }
+            else {
+                const formElement = element;
+                formElement.value = savedValue;
+            }
+        }
+        else {
+            // 没有本地存储值，使用初始值或空值
+            if (type === "checkbox") {
+                const checkbox = element.querySelector('input[type="checkbox"]');
+                if (checkbox) {
+                    checkbox.checked = config.checked || false;
+                }
+            }
+            else {
+                const formElement = element;
+                formElement.value = config.value || "";
+            }
+        }
+        // 绑定实时保存事件
+        if (type === "checkbox") {
+            const checkbox = element.querySelector('input[type="checkbox"]');
+            if (checkbox) {
+                checkbox.addEventListener("change", (e) => {
+                    const target = e.target;
+                    this.saveToLocalStorage(storageKey, target.checked.toString());
+                });
+            }
+        }
+        else {
+            const eventType = type === "select" ? "change" : "input";
+            element.addEventListener(eventType, (e) => {
+                const target = e.target;
+                this.saveToLocalStorage(storageKey, target.value);
+            });
+        }
+    }
+    // 创建输入框
+    createInput(config) {
+        const input = this.createElement("input", Object.assign({ type: config.inputType || "text", name: config.keyword, placeholder: config.placeholder || "", value: config.value || "" }, config.props));
+        // 绑定事件
+        this.bindEvents(input, config);
+        return input;
+    }
+    // 创建按钮
+    createButton(config) {
+        const button = this.createElement("button", Object.assign({ textContent: config.text || config.keyword || "Button", name: config.keyword }, config.props));
+        // 绑定事件
+        this.bindEvents(button, config);
+        return button;
+    }
+    // 创建下拉框
+    createSelect(config) {
+        const select = this.createElement("select", Object.assign({ name: config.keyword }, config.props));
+        // 添加选项
+        if (config.options) {
+            config.options.forEach((option) => {
+                const optionEl = document.createElement("option");
+                if (typeof option === 'string') {
+                    optionEl.value = option;
+                    optionEl.textContent = option;
+                }
+                else {
+                    optionEl.value = option.value || option.text || '';
+                    optionEl.textContent = option.text || option.value || '';
+                    if (option.selected)
+                        optionEl.selected = true;
+                }
+                select.appendChild(optionEl);
+            });
+        }
+        // 绑定事件
+        this.bindEvents(select, config);
+        return select;
+    }
+    // 创建文本域
+    createTextarea(config) {
+        const textarea = this.createElement("textarea", Object.assign({ name: config.keyword, placeholder: config.placeholder || "", value: config.value || "", rows: config.rows || 3 }, config.props));
+        // 绑定事件
+        this.bindEvents(textarea, config);
+        return textarea;
+    }
+    // 创建复选框
+    createCheckbox(config) {
+        const wrapper = document.createElement("div");
+        const checkbox = this.createElement("input", Object.assign({ type: "checkbox", id: config.keyword, name: config.keyword, checked: config.checked || false }, config.props));
+        const label = document.createElement("label");
+        label.setAttribute("for", config.keyword || '');
+        label.textContent = config.text || config.keyword || "Checkbox";
+        // 绑定事件
+        this.bindEvents(checkbox, config);
+        wrapper.appendChild(checkbox);
+        wrapper.appendChild(label);
+        // 将checkbox存储为主要元素
+        if (config.keyword) {
+            this.setChild(config.keyword, checkbox);
+        }
+        return wrapper;
+    }
+    // 创建标签
+    createLabel(config) {
+        return this.createElement("label", Object.assign({ textContent: config.text || config.keyword || "", name: config.keyword }, config.props));
+    }
+    // 创建DIV
+    createDiv(config) {
+        const div = this.createElement("div", Object.assign({ textContent: config.text || "", innerHTML: config.html || undefined, name: config.keyword }, config.props));
+        // 绑定事件
+        this.bindEvents(div, config);
+        return div;
+    }
+    // 通用元素创建方法
+    createElement(tag, props = {}) {
+        const element = document.createElement(tag);
+        Object.keys(props).forEach((key) => {
+            if (key === "innerHTML") {
+                element.innerHTML = props[key];
+            }
+            else {
+                element[key] = props[key];
+            }
+        });
+        return element;
+    }
+    // 绑定事件
+    bindEvents(element, config) {
+        const eventTypes = ["onClick", "onChange", "onInput", "onFocus", "onBlur", "onMouseEnter", "onMouseLeave"];
+        eventTypes.forEach((eventType) => {
+            const handler = config[eventType];
+            if (handler) {
+                const eventName = eventType.slice(2).toLowerCase();
+                element.addEventListener(eventName, handler);
+            }
+        });
+    }
+    // 获取子元素
+    getChild(keyword) {
+        return this.elements.get(keyword) || null;
+    }
+    // 设置子元素
+    setChild(keyword, element) {
+        if (!this.elements.has(keyword)) {
+            this.elements.set(keyword, element);
+        }
+    }
+    // 获取元素值
+    getValue(keyword) {
+        const element = this.getChild(keyword);
+        if (!element)
+            return null;
+        if (element.type === "checkbox") {
+            return element.checked;
+        }
+        const formElement = element;
+        return formElement.value || element.textContent || null;
+    }
+    // 设置元素值
+    setValue(keyword, value) {
+        const element = this.getChild(keyword);
+        if (!element)
+            return;
+        if (element.type === "checkbox") {
+            element.checked = Boolean(value);
+        }
+        else {
+            const formElement = element;
+            if (formElement.value !== undefined) {
+                formElement.value = String(value);
+            }
+            else {
+                element.textContent = String(value);
+            }
+        }
+    }
+    // 显示容器或子元素
+    show(keyword) {
+        if (keyword) {
+            const element = this.getChild(keyword);
+            if (element) {
+                // 显示元素，如果是checkbox，显示其父容器
+                const targetElement = element.type === "checkbox" ? element.parentElement : element;
+                if (targetElement) {
+                    targetElement.style.display = "";
+                }
+            }
+        }
+        else {
+            if (this.container) {
+                this.container.style.display = "";
+            }
+        }
+    }
+    // 隐藏容器或子元素
+    hide(keyword) {
+        if (keyword) {
+            const element = this.getChild(keyword);
+            if (element) {
+                // 隐藏元素，如果是checkbox，隐藏其父容器
+                const targetElement = element.type === "checkbox" ? element.parentElement : element;
+                if (targetElement) {
+                    targetElement.style.display = "none";
+                }
+            }
+        }
+        else {
+            if (this.container) {
+                this.container.style.display = "none";
+            }
+        }
+    }
+    // 移除容器
+    remove() {
+        if (this.container) {
+            this.container.remove();
+            this.container = null;
+            this.elements.clear();
+        }
+        if (this.styleElement) {
+            this.styleElement.remove();
+            this.styleElement = null;
+        }
+    }
+    // 事件绑定
+    on(keyword, event, handler) {
+        const element = this.getChild(keyword);
+        if (element) {
+            element.addEventListener(event, handler);
+        }
+    }
+    // 获取存储key
+    getStorageKey(keyword) {
+        return `${this.containerId}_${keyword}`;
+    }
+    // 本地存储相关方法
+    saveToLocalStorage(key, value) {
+        try {
+            localStorage.setItem(key, value);
+        }
+        catch (e) {
+            console.warn("无法保存到本地存储:", e);
+        }
+    }
+    getFromLocalStorage(key) {
+        try {
+            return localStorage.getItem(key);
+        }
+        catch (e) {
+            console.warn("无法从本地存储读取:", e);
+            return null;
+        }
+    }
+    // 内存数据存储
+    setData(key, value) {
+        this.data.set(key, value);
+    }
+    getData(key) {
+        return this.data.get(key);
+    }
+}
+
+exports.ScriptDomBuilder = ScriptDomBuilder;

package/lib/form/index.d.ts

@@ -10,6 +10,12 @@ type FormDataInput = string | Record<string, FormDataValue | FormDataValue[] | R
  * @param data 要转换的数据，可以是查询字符串或对象
  * @returns FormData 对象
  */
-declare function createFormData(data: FormDataInput): FormData;
-export { createFormData };
+declare const createFormData: (data: FormDataInput) => FormData;
+/**
+ * json 转换为查询字符串
+ * @param json
+ * @returns
+ */
+declare const jsonToQueryString: (json: Record<string, any>) => string;
+export { createFormData, jsonToQueryString };
 export type { FormDataInput, FormDataValue };

package/lib/form/index.js

@@ -10,7 +10,7 @@
  * @param data 要转换的数据，可以是查询字符串或对象
  * @returns FormData 对象
  */
-function createFormData(data) {
+const createFormData = (data) => {
     const formData = new FormData();
     if (typeof data === "string") {
         // 处理查询字符串
@@ -48,6 +48,15 @@ function createFormData(data) {
         });
     }
     return formData;
-}
+};
+/**
+ * json 转换为查询字符串
+ * @param json
+ * @returns
+ */
+const jsonToQueryString = (json) => {
+    return new URLSearchParams(json).toString();
+};
 
 exports.createFormData = createFormData;
+exports.jsonToQueryString = jsonToQueryString;

package/lib/index.d.ts

@@ -8,3 +8,4 @@ export * from "./count";
 export * from "./xhr";
 export * from "./constant";
 export * from "./document";
+export * from "./async";

package/lib/index.js

@@ -10,6 +10,8 @@ var index$6 = require('./count/index.js');
 var index$7 = require('./xhr/index.js');
 var index$8 = require('./constant/index.js');
 var index$9 = require('./document/index.js');
+var index$a = require('./async/index.js');
+var scriptDomBuilder = require('./document/script-dom-builder.js');
 
 
 
@@ -26,9 +28,12 @@ exports.getUuid = index$3.getUuid;
 exports.RegexPatterns = index$4.RegexPatterns;
 exports.RegexValidator = index$4.RegexValidator;
 exports.createFormData = index$5.createFormData;
+exports.jsonToQueryString = index$5.jsonToQueryString;
 exports.precisionFormat = index$6.precisionFormat;
 exports.XHRInterceptor = index$7.XHRInterceptor;
 exports.xhrInterceptor = index$7.xhrInterceptor;
 exports.Lib_Name = index$8.Lib_Name;
 exports.addStyleStr = index$9.addStyleStr;
 exports.createMaskLoading = index$9.createMaskLoading;
+exports.createAsyncTask = index$a.createAsyncTask;
+exports.ScriptDomBuilder = scriptDomBuilder.ScriptDomBuilder;