sculp-js 1.7.2 → 1.8.1

package/lib/umd/index.js

@@ -1,5 +1,5 @@
 /*!
- * sculp-js v1.7.2
+ * sculp-js v1.8.1
  * (c) 2023-present chandq
  * Released under the MIT License.
  */
@@ -30,7 +30,7 @@
             }
         }
         else {
-            for (let idx = 0; idx < array.length; idx++) {
+            for (let idx = 0, len = array.length; idx < len; idx++) {
                 const val = array[idx];
                 const re = iterator(val, idx, array);
                 if (re === false)
@@ -55,7 +55,7 @@
             }
         }
         else {
-            for (let idx = 0; idx < array.length; idx++) {
+            for (let idx = 0, len = array.length; idx < len; idx++) {
                 const val = array[idx];
                 if ((await iterator(val, idx)) === false)
                     break;
@@ -92,7 +92,9 @@
             if (_expect(val, idx))
                 indexes.push(idx);
         });
-        indexes.forEach((val, idx) => array.splice(val - idx, 1));
+        arrayEach(indexes, (val, idx) => {
+            array.splice(val - idx, 1);
+        });
         return array;
     }
 
@@ -122,11 +124,17 @@
         return objectHas(any, 'length');
     }
     /**
-     * 判断任意值的数据类型
+     * 判断任意值的数据类型，检查非对象时不如typeof、instanceof的性能高
+     *
+     * 当检查类对象时是不可靠的，对象可以通过定义 Symbol.toStringTag 属性来更改检查结果
+     *
+     * 详见：https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/toString
      * @param {unknown} any
-     * @returns {string}
+     * @returns
      */
-    const typeIs = (any) => Object.prototype.toString.call(any).slice(8, -1);
+    function typeIs(any) {
+        return Object.prototype.toString.call(any).slice(8, -1);
+    }
     // 基本数据类型判断
     const isString = (any) => typeof any === 'string';
     const isBoolean = (any) => typeof any === 'boolean';
@@ -369,7 +377,7 @@
      */
     function objectAssign(source, ...targets) {
         const map = new Map();
-        for (let i = 0; i < targets.length; i++) {
+        for (let i = 0, len = targets.length; i < len; i++) {
             const target = targets[i];
             // eslint-disable-next-line @typescript-eslint/ban-ts-comment
             // @ts-ignore
@@ -394,6 +402,13 @@
         });
         return source;
     }
+    /**
+     * 获取对象指定层级下的属性值（现在可用ES6+的可选链?.来替代）
+     * @param {AnyObject} obj
+     * @param {string} path
+     * @param {boolean} strict
+     * @returns
+     */
     function objectGet(obj, path, strict = false) {
         path = path.replace(/\[(\w+)\]/g, '.$1');
         path = path.replace(/^\./, '');
@@ -487,10 +502,10 @@
         }
         // 处理数组 (包含稀疏数组)
         if (Array.isArray(source)) {
-            const copy = Array.from({ length: source.length });
+            const copy = new Array(source.length);
             map.set(source, copy);
             // 克隆所有有效索引
-            for (let i = 0; i < source.length; i++) {
+            for (let i = 0, len = source.length; i < len; i++) {
                 if (i in source) {
                     // 保留空位
                     copy[i] = cloneDeep(source[i], map);
@@ -529,6 +544,127 @@
         }
         return copy;
     }
+    /**
+     * 比较两值是否相等，适用所有数据类型
+     * @param {Comparable} a
+     * @param {Comparable} b
+     * @returns {boolean}
+     */
+    function isEqual(a, b) {
+        return deepEqual(a, b);
+    }
+    function deepEqual(a, b, compared = new WeakMap()) {
+        // 相同值快速返回
+        if (Object.is(a, b))
+            return true;
+        // 类型不同直接返回false
+        const typeA = Object.prototype.toString.call(a);
+        const typeB = Object.prototype.toString.call(b);
+        if (typeA !== typeB)
+            return false;
+        // 只缓存对象类型
+        if (isObject(a) && isObject(b)) {
+            if (compared.has(a))
+                return compared.get(a) === b;
+            compared.set(a, b);
+            compared.set(b, a);
+        }
+        // 处理特殊对象类型
+        switch (typeA) {
+            case '[object Date]':
+                return a.getTime() === b.getTime();
+            case '[object RegExp]':
+                return a.toString() === b.toString();
+            case '[object Map]':
+                return compareMap(a, b, compared);
+            case '[object Set]':
+                return compareSet(a, b, compared);
+            case '[object ArrayBuffer]':
+                return compareArrayBuffer(a, b);
+            case '[object DataView]':
+                return compareDataView(a, b, compared);
+            case '[object Int8Array]':
+            case '[object Uint8Array]':
+            case '[object Uint8ClampedArray]':
+            case '[object Int16Array]':
+            case '[object Uint16Array]':
+            case '[object Int32Array]':
+            case '[object Uint32Array]':
+            case '[object Float32Array]':
+            case '[object Float64Array]':
+                return compareTypedArray(a, b, compared);
+            case '[object Object]':
+                return compareObjects(a, b, compared);
+            case '[object Array]':
+                return compareArrays(a, b, compared);
+        }
+        return false;
+    }
+    // 辅助比较函数
+    function compareMap(a, b, compared) {
+        if (a.size !== b.size)
+            return false;
+        for (const [key, value] of a) {
+            if (!b.has(key) || !deepEqual(value, b.get(key), compared))
+                return false;
+        }
+        return true;
+    }
+    function compareSet(a, b, compared) {
+        if (a.size !== b.size)
+            return false;
+        for (const value of a) {
+            let found = false;
+            for (const bValue of b) {
+                if (deepEqual(value, bValue, compared)) {
+                    found = true;
+                    break;
+                }
+            }
+            if (!found)
+                return false;
+        }
+        return true;
+    }
+    function compareArrayBuffer(a, b) {
+        if (a.byteLength !== b.byteLength)
+            return false;
+        return new DataView(a).getInt32(0) === new DataView(b).getInt32(0);
+    }
+    function compareDataView(a, b, compared) {
+        return a.byteLength === b.byteLength && deepEqual(new Uint8Array(a.buffer), new Uint8Array(b.buffer), compared);
+    }
+    function compareTypedArray(a, b, compared) {
+        return a.byteLength === b.byteLength && deepEqual(Array.from(a), Array.from(b), compared);
+    }
+    function compareObjects(a, b, compared) {
+        const keysA = Reflect.ownKeys(a);
+        const keysB = Reflect.ownKeys(b);
+        if (keysA.length !== keysB.length)
+            return false;
+        for (const key of keysA) {
+            if (!keysB.includes(key))
+                return false;
+            if (!deepEqual(a[key], b[key], compared))
+                return false;
+        }
+        // 原型链比较
+        return Object.getPrototypeOf(a) === Object.getPrototypeOf(b);
+    }
+    function compareArrays(a, b, compared) {
+        // 增加有效索引检查
+        const keysA = Object.keys(a).map(Number);
+        const keysB = Object.keys(b).map(Number);
+        if (keysA.length !== keysB.length)
+            return false;
+        // 递归比较每个元素
+        for (let i = 0, len = a.length; i < len; i++) {
+            if (!deepEqual(a[i], b[i], compared))
+                return false;
+        }
+        // 比较数组对象的其他属性
+        return compareObjects(a, b, compared);
+    }
 
     /**
      * 将字符串转换为驼峰格式
@@ -773,31 +909,6 @@
             render();
         });
     }
-    const domReadyCallbacks = [];
-    const eventType = 'DOMContentLoaded';
-    const listener = () => {
-        domReadyCallbacks.forEach(callback => callback());
-        domReadyCallbacks.length = 0;
-        document.removeEventListener(eventType, listener);
-    };
-    document.addEventListener(eventType, listener);
-    let readied = false;
-    function isDomReady() {
-        if (readied)
-            return true;
-        readied = ['complete', 'loaded', 'interactive'].indexOf(document.readyState) !== -1;
-        return readied;
-    }
-    function onDomReady(callback) {
-        // document readied
-        if (isDomReady()) {
-            setTimeout(callback, 0);
-        }
-        // listen document to ready
-        else {
-            domReadyCallbacks.push(callback);
-        }
-    }
     /**
      * 获取元素样式属性的计算值
      * @param {HTMLElement} el
@@ -1121,7 +1232,7 @@
      * @returns {string}
      */
     const pathNormalize = (path) => {
-        const slicees = path
+        const slices = path
             .replace(/\\/g, '/')
             .replace(/\/{2,}/g, '/')
             .replace(/\.{3,}/g, '..')
@@ -1146,7 +1257,7 @@
                 points.pop();
             }
         };
-        slicees.forEach(slice => {
+        slices.forEach(slice => {
             const isCurrent = isCurrentSlice(slice);
             const isParent = isParentSlice(slice);
             // 未进入实际路径
@@ -1451,7 +1562,7 @@
     // eslint-disable-next-line
     const b64re = /^(?:[A-Za-z\d+\/]{4})*?(?:[A-Za-z\d+\/]{2}(?:==)?|[A-Za-z\d+\/]{3}=?)?$/;
     /**
-     * 字符串编码成Base64 （适用于任何环境，包括小程序）
+     * 字符串编码成Base64, 平替浏览器的btoa, 不包含中文的处理 （适用于任何环境，包括小程序）
      * @param {string} string
      * @returns {string}
      */
@@ -1459,8 +1570,9 @@
         // 同window.btoa: 字符串编码成Base64
         string = String(string);
         let bitmap, a, b, c, result = '', i = 0;
-        const rest = string.length % 3;
-        for (; i < string.length;) {
+        const strLen = string.length;
+        const rest = strLen % 3;
+        for (; i < strLen;) {
             if ((a = string.charCodeAt(i++)) > 255 || (b = string.charCodeAt(i++)) > 255 || (c = string.charCodeAt(i++)) > 255)
                 throw new TypeError("Failed to execute 'btoa' on 'Window': The string to be encoded contains characters outside of the Latin1 range.");
             bitmap = (a << 16) | (b << 8) | c;
@@ -1473,7 +1585,7 @@
         return rest ? result.slice(0, rest - 3) + '==='.substring(rest) : result;
     }
     /**
-     * Base64解码为原始字符串（适用于任何环境，包括小程序）
+     * Base64解码为原始字符串，平替浏览器的atob, 不包含中文的处理（适用于任何环境，包括小程序）
      * @param {string} string
      * @returns {string}
      */
@@ -1484,7 +1596,7 @@
             throw new TypeError("Failed to execute 'atob' on 'Window': The string to be decoded is not correctly encoded.");
         string += '=='.slice(2 - (string.length & 3));
         let bitmap, result = '', r1, r2, i = 0;
-        for (; i < string.length;) {
+        for (const strLen = string.length; i < strLen;) {
             bitmap =
                 (b64.indexOf(string.charAt(i++)) << 18) |
                     (b64.indexOf(string.charAt(i++)) << 12) |
@@ -2251,7 +2363,7 @@
                 }
             }
             else {
-                for (let i = 0; i < arr.length; i++) {
+                for (let i = 0, len = arr.length; i < len; i++) {
                     if (isBreak) {
                         break;
                     }
@@ -2377,92 +2489,7 @@
         return getIds(toFlatArray(tree));
     }
     /**
-     * 使用迭代函数转换数组
-     * @param {T} array
-     * @param {Function} callback 迭代函数
-     * @returns {Array}
-     */
-    function flatMap(array, callback) {
-        const result = [];
-        array.forEach((value, index) => {
-            result.push(...callback(value, index, array));
-        });
-        return result;
-    }
-    /**
-     * 根据 idProp 与 parentIdProp 从对象数组中构建对应的树
-     * 当 A[parentIdProp] === B[idProp] 时，对象A会被移动到对象B的children。
-     * 当一个对象的 parentIdProp 不与其他对象的 idProp 字段相等时，该对象被作为树的顶层节点
-     * @param {string} idProp 元素ID
-     * @param {string} parentIdProp 父元素ID
-     * @param {object[]} items 一维数组
-     * @returns {WithChildren<T>[]} 树
-     * @example
-     * const array = [
-     *   { id: 'node-1', parent: 'root' },
-     *   { id: 'node-2', parent: 'root' },
-     *   { id: 'node-3', parent: 'node-2' },
-     *   { id: 'node-4', parent: 'node-2' },
-     *   { id: 'node-5', parent: 'node-4' },
-     * ]
-     * const tree = buildTree('id', 'parent', array)
-     * expect(tree).toEqual([
-     *   { id: 'node-1', parent: 'root' },
-     *   {
-     *     id: 'node-2',
-     *     parent: 'root',
-     *     children: [
-     *       { id: 'node-3', parent: 'node-2' },
-     *       {
-     *         id: 'node-4',
-     *         parent: 'node-2',
-     *         children: [{ id: 'node-5', parent: 'node-4' }],
-     *       },
-     *     ],
-     *   },
-     * ])
-     */
-    function buildTree(idProp, parentIdProp, items) {
-        const wrapperMap = new Map();
-        const ensure = (id) => {
-            if (wrapperMap.has(id)) {
-                return wrapperMap.get(id);
-            }
-            //@ts-ignore
-            const wrapper = { id, parent: null, item: null, children: [] };
-            wrapperMap.set(id, wrapper);
-            return wrapper;
-        };
-        for (const item of items) {
-            const parentWrapper = ensure(item[parentIdProp]);
-            const itemWrapper = ensure(item[idProp]);
-            //@ts-ignore
-            itemWrapper.parent = parentWrapper;
-            //@ts-ignore
-            parentWrapper.children.push(itemWrapper);
-            //@ts-ignore
-            itemWrapper.item = item;
-        }
-        const topLevelWrappers = flatMap(Array.from(wrapperMap.values()).filter(wrapper => wrapper.parent === null), wrapper => wrapper.children);
-        return unwrapRecursively(topLevelWrappers);
-        function unwrapRecursively(wrapperArray) {
-            const result = [];
-            for (const wrapper of wrapperArray) {
-                if (wrapper.children.length === 0) {
-                    result.push(wrapper.item);
-                }
-                else {
-                    result.push({
-                        ...wrapper.item,
-                        children: unwrapRecursively(wrapper.children)
-                    });
-                }
-            }
-            return result;
-        }
-    }
-    /**
-     * 扁平化数组转换成树(效率高于buildTree)
+     * 扁平化数组转换成树
      * @param {any[]} list
      * @param {IFieldOptions} options
      * @returns {any[]}
@@ -2471,10 +2498,10 @@
         const { keyField, childField, pidField } = options;
         const treeArr = [];
         const sourceMap = {};
-        list.forEach(item => {
+        arrayEach(list, item => {
             sourceMap[item[keyField]] = item;
         });
-        list.forEach(item => {
+        arrayEach(list, item => {
             const parent = sourceMap[item[pidField]];
             if (parent) {
                 (parent[childField] || (parent[childField] = [])).push(item);
@@ -2493,7 +2520,8 @@
      */
     function flatTree(treeList, options = defaultFieldOptions) {
         const { childField, keyField, pidField } = options;
-        return treeList.reduce((res, node) => {
+        let res = [];
+        arrayEach(treeList, node => {
             const item = {
                 ...node,
                 [childField]: [] // 清空子级
@@ -2507,8 +2535,8 @@
                 }));
                 res = res.concat(flatTree(children, options));
             }
-            return res;
-        }, []);
+        });
+        return res;
     }
     /**
      * 模糊搜索函数，返回包含搜索字符的节点及其祖先节点, 适用于树型组件的字符过滤功能
@@ -2530,7 +2558,7 @@
             return nodes;
         }
         const result = [];
-        for (const node of nodes) {
+        arrayEach(nodes, node => {
             // 递归检查子节点是否匹配
             const matchedChildren = node[options.childField] && node[options.childField].length > 0
                 ? fuzzySearchTree(node[options.childField] || [], filterCondition, options)
@@ -2570,7 +2598,7 @@
                     });
                 }
             }
-        }
+        });
         return result;
     }
 
@@ -2943,7 +2971,6 @@
     exports.arrayLike = arrayLike;
     exports.arrayRemove = arrayRemove;
     exports.asyncMap = asyncMap;
-    exports.buildTree = buildTree;
     exports.calculateDate = calculateDate;
     exports.calculateDateTime = calculateDateTime;
     exports.chooseLocalFile = chooseLocalFile;
@@ -2984,9 +3011,9 @@
     exports.isBoolean = isBoolean;
     exports.isDate = isDate;
     exports.isDigit = isDigit;
-    exports.isDomReady = isDomReady;
     exports.isEmail = isEmail;
     exports.isEmpty = isEmpty;
+    exports.isEqual = isEqual;
     exports.isError = isError;
     exports.isFloat = isFloat;
     exports.isFunction = isFunction;
@@ -2998,6 +3025,7 @@
     exports.isNaN = isNaN;
     exports.isNull = isNull;
     exports.isNullOrUnDef = isNullOrUnDef;
+    exports.isNullish = isNullOrUnDef;
     exports.isNumber = isNumber;
     exports.isNumerical = isNumerical;
     exports.isObject = isObject;
@@ -3024,7 +3052,6 @@
     exports.objectMerge = objectAssign;
     exports.objectOmit = objectOmit;
     exports.objectPick = objectPick;
-    exports.onDomReady = onDomReady;
     exports.once = once;
     exports.parseQueryParams = parseQueryParams;
     exports.parseVarFromString = parseVarFromString;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "sculp-js",
-  "version": "1.7.2",
+  "version": "1.8.1",
   "packageManager": "npm@8.19.2",
-  "description": "js工具库",
+  "description": "js utils library, includes function library、class library",
   "scripts": {
     "prepare": "husky install",
     "build": "rollup  --bundleConfigAsCjs --config rollup.config.js",
@@ -19,7 +19,6 @@
     "release:major": "standard-version --release-as major",
     "commit": "git-cz"
   },
-  "author": "chendq <deqiaochen@gmail.com>",
   "main": "lib/cjs/index.js",
   "module": "lib/es/index.js",
   "browser": "lib/umd/index.js",
@@ -49,8 +48,7 @@
   "license": "MIT",
   "homepage": "https://github.com/chandq/sculp-js#readme",
   "dependencies": {
-    "bezier-easing": "^2.1.0",
-    "core-js": "^3.33.0"
+    "bezier-easing": "^2.1.0"
   },
   "devDependencies": {
     "@babel/core": "^7.23.2",
@@ -89,11 +87,6 @@
     "rollup-plugin-dts": "^6.1.0",
     "rollup-plugin-subpath-externals": "^3.4.0",
     "standard-version": "^9.5.0",
-    "stylelint": "14.16",
-    "stylelint-config-css-modules": "^4.3.0",
-    "stylelint-config-prettier": "^9.0.5",
-    "stylelint-config-standard": "^20.0.0",
-    "ts-loader": "^9.5.0",
     "typescript": "5.0.4"
   },
   "config": {