@whitesev/utils 2.7.4 → 2.7.6

package/dist/index.system.js

@@ -4210,7 +4210,7 @@ System.register('Utils', [], (function (exports) {
             class UtilsDictionary {
                 items;
                 constructor(key, value) {
-                    this.items = {};
+                    this.items = new Map();
                     if (key != null) {
                         this.set(key, value);
                     }
@@ -4247,35 +4247,16 @@ System.register('Utils', [], (function (exports) {
                  * @param key 键
                  */
                 has(key) {
-                    return Reflect.has(this.items, key);
+                    return this.items.has(key);
                 }
                 /**
-                 * 检查已有的键中是否以xx开头
-                 * @param key 需要匹配的键
-                 */
-                startsWith(key) {
-                    let allKeys = this.keys();
-                    for (const keyName of allKeys) {
-                        if (String(keyName).startsWith(String(key))) {
-                            return true;
-                        }
-                    }
-                    return false;
-                }
-                /**
-                 * 获取以xx开头的键的值
-                 * @param key 需要匹配的键
+                 * 获取某个键的值
+                 * https://github.com/microsoft/TypeScript/issues/9619
+                 * 微软到现在都没有实现has和get的联动
+                 * @param key 键
                  */
-                getStartsWith(key) {
-                    let allKeys = this.keys();
-                    let result = void 0;
-                    for (const keyName of allKeys) {
-                        if (String(keyName).startsWith(String(key))) {
-                            result = this.get(keyName);
-                            break;
-                        }
-                    }
-                    return result;
+                get(key) {
+                    return this.items.get(key);
                 }
                 /**
                  * 为字典添加某一个值
@@ -4286,57 +4267,44 @@ System.register('Utils', [], (function (exports) {
                     if (key === void 0) {
                         throw new Error("Utils.Dictionary().set 参数 key 不能为空");
                     }
-                    Reflect.set(this.items, key, val);
+                    this.items.set(key, val);
                 }
                 /**
                  * 删除某一个键
                  * @param key 键
+                 * @returns
+                 * + true：键存在且成功删除
+                 * + false：键不存在
                  */
                 delete(key) {
                     if (this.has(key)) {
-                        return Reflect.deleteProperty(this.items, key);
+                        return this.items.delete(key);
                     }
                     return false;
                 }
                 /**
-                 * 获取某个键的值
-                 * https://github.com/microsoft/TypeScript/issues/9619
-                 * 微软到现在都没有修复has和get的联动
-                 * @param key 键
+                 * 获取字典所有的键
                  */
-                get(key) {
-                    return Reflect.get(this.items, key);
+                keys() {
+                    return this.items.keys().toArray();
                 }
                 /**
                  * 返回字典中的所有值
                  */
                 values() {
-                    let resultList = [];
-                    for (let prop in this.getItems()) {
-                        if (this.has(prop)) {
-                            resultList.push(this.get(prop));
-                        }
-                    }
-                    return resultList;
+                    return this.items.values().toArray();
                 }
                 /**
                  * 清空字典
                  */
                 clear() {
-                    this.items = null;
-                    this.items = {};
+                    this.items.clear();
                 }
                 /**
                  * 获取字典的长度
                  */
                 size() {
-                    return Object.keys(this.getItems()).length;
-                }
-                /**
-                 * 获取字典所有的键
-                 */
-                keys() {
-                    return Reflect.ownKeys(this.items);
+                    return this.items.size;
                 }
                 /**
                  * 返回字典本身
@@ -4349,16 +4317,46 @@ System.register('Utils', [], (function (exports) {
                  * @param data 需要合并的字典
                  */
                 concat(data) {
-                    this.items = commonUtil.assign(this.items, data.getItems());
+                    data.forEach((value, key) => {
+                        this.items.set(key, value);
+                    });
                 }
                 /**
                  * 迭代字典
                  * @param callbackfn 回调函数
                  */
                 forEach(callbackfn) {
-                    for (const key in this.getItems()) {
-                        callbackfn(this.get(key), key, this.getItems());
+                    this.items.forEach((value, key, self) => {
+                        callbackfn(value, key, this);
+                    });
+                }
+                /**
+                 * 检查已有的键中是否以xx开头
+                 * @param key 需要匹配的键
+                 */
+                startsWith(key) {
+                    const keys = this.keys();
+                    for (const keyName of keys) {
+                        if (String(keyName).startsWith(key)) {
+                            return true;
+                        }
                     }
+                    return false;
+                }
+                /**
+                 * 获取以xx开头的键的值
+                 * @param key 需要匹配的键
+                 */
+                getStartsWith(key) {
+                    let result = void 0;
+                    const keys = this.keys();
+                    for (const keyName of keys) {
+                        if (String(keyName).startsWith(String(key))) {
+                            result = this.get(keyName);
+                            break;
+                        }
+                    }
+                    return result;
                 }
             }
 
@@ -4370,10 +4368,10 @@ System.register('Utils', [], (function (exports) {
                     globalThis: globalThis,
                     self: self,
                     top: top,
-                    setTimeout: globalThis.setTimeout,
-                    setInterval: globalThis.setInterval,
-                    clearTimeout: globalThis.clearTimeout,
-                    clearInterval: globalThis.clearInterval,
+                    setTimeout: globalThis.setTimeout.bind(globalThis),
+                    setInterval: globalThis.setInterval.bind(globalThis),
+                    clearTimeout: globalThis.clearTimeout.bind(globalThis),
+                    clearInterval: globalThis.clearInterval.bind(globalThis),
                 };
                 /** 使用的配置 */
                 api;
@@ -5480,7 +5478,7 @@ System.register('Utils', [], (function (exports) {
                     this.windowApi = new WindowApi(option);
                 }
                 /** 版本号 */
-                version = "2025.8.21";
+                version = "2025.9.8";
                 addStyle(cssText) {
                     if (typeof cssText !== "string") {
                         throw new Error("Utils.addStyle 参数cssText 必须为String类型");
@@ -5810,19 +5808,19 @@ System.register('Utils', [], (function (exports) {
                         }
                         else {
                             let textElement = Array.from(element.childNodes).filter((ele) => ele.nodeType === Node.TEXT_NODE);
-                            for (let ele of textElement) {
-                                if (ele.textContent.includes(text)) {
+                            for (let $child of textElement) {
+                                if ($child.textContent.includes(text)) {
                                     let filterResult = typeof filter === "function" ? filter(element) : false;
                                     if (!filterResult) {
-                                        yield ele;
+                                        yield $child;
                                     }
                                 }
                             }
                         }
                     }
                     for (let index = 0; index < element.children.length; index++) {
-                        let childElement = element.children[index];
-                        yield* that.findElementsWithText(childElement, text, filter);
+                        let $child = element.children[index];
+                        yield* that.findElementsWithText($child, text, filter);
                     }
                 }
                 /**