@whitesev/utils 2.7.5 → 2.7.7

package/dist/index.iife.js

@@ -4208,7 +4208,7 @@ var Utils = (function () {
     class UtilsDictionary {
         items;
         constructor(key, value) {
-            this.items = {};
+            this.items = new Map();
             if (key != null) {
                 this.set(key, value);
             }
@@ -4245,35 +4245,16 @@ var Utils = (function () {
          * @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);
         }
         /**
          * 为字典添加某一个值
@@ -4284,57 +4265,44 @@ var Utils = (function () {
             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;
         }
         /**
          * 返回字典本身
@@ -4347,16 +4315,46 @@ var Utils = (function () {
          * @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;
         }
     }
 
@@ -5478,7 +5476,7 @@ var Utils = (function () {
             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类型");
@@ -5808,19 +5806,19 @@ var Utils = (function () {
                 }
                 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);
             }
         }
         /**
@@ -6320,12 +6318,17 @@ var Utils = (function () {
          */
         getReactObj(element) {
             let result = {};
-            Object.keys(element).forEach((domPropsName) => {
+            if (element == null) {
+                return result;
+            }
+            const keys = Object.keys(element);
+            keys.forEach((domPropsName) => {
                 if (domPropsName.startsWith("__react")) {
-                    let propsName = domPropsName.replace(/__(.+)\$.+/i, "$1");
+                    const propsName = domPropsName.replace(/__(.+)\$.+/i, "$1");
+                    const propsValue = Reflect.get(element, domPropsName);
                     if (propsName in result) ;
                     else {
-                        result[propsName] = element[domPropsName];
+                        Reflect.set(result, propsName, propsValue);
                     }
                 }
             });