sculp-js 1.7.1 → 1.8.0

package/lib/umd/index.js

@@ -1,5 +1,5 @@
 /*!
- * sculp-js v1.7.0
+ * sculp-js v1.8.0
  * (c) 2023-present chandq
  * Released under the MIT License.
  */
@@ -122,11 +122,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';
@@ -309,7 +315,7 @@
         return obj2;
     }
     /**
-     * 对象祛除
+     * 对象去除
      * @param {O} obj
      * @param {K} keys
      * @returns {Pick<O, ArrayElements<K>>}
@@ -394,6 +400,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(/^\./, '');
@@ -424,12 +437,16 @@
     }
     /**
      * 深拷贝堪称完全体 即：任何类型的数据都会被深拷贝
+     *
+     * 包含对null、原始值、对象循环引用的处理
+     *
+     * 对Map、Set、ArrayBuffer、Date、RegExp、Array、Object及原型链属性方法执行深拷贝
      * @param {T} source
      * @param {WeakMap} map
      * @returns {T}
      */
     function cloneDeep(source, map = new WeakMap()) {
-        // 处理原始类型（非对象/数组）和 null/undefined
+        // 处理原始类型和 null/undefined
         if (source === null || typeof source !== 'object') {
             return source;
         }
@@ -437,28 +454,33 @@
         if (map.has(source)) {
             return map.get(source);
         }
-        // 处理 Date 类型
+        // 处理 ArrayBuffer
+        if (source instanceof ArrayBuffer) {
+            const copy = new ArrayBuffer(source.byteLength);
+            new Uint8Array(copy).set(new Uint8Array(source));
+            map.set(source, copy);
+            return copy;
+        }
+        // 处理 DataView 和 TypedArray (Uint8Array 等)
+        if (ArrayBuffer.isView(source)) {
+            const constructor = source.constructor;
+            const bufferCopy = cloneDeep(source.buffer, map);
+            return new constructor(bufferCopy, source.byteOffset, source.length);
+        }
+        // 处理 Date 对象
         if (source instanceof Date) {
             const copy = new Date(source.getTime());
             map.set(source, copy);
             return copy;
         }
-        // 处理 RegExp 类型
+        // 处理 RegExp 对象
         if (source instanceof RegExp) {
             const copy = new RegExp(source.source, source.flags);
+            copy.lastIndex = source.lastIndex; // 保留匹配状态
             map.set(source, copy);
             return copy;
         }
-        // 处理数组类型
-        if (Array.isArray(source)) {
-            const copy = [];
-            map.set(source, copy);
-            for (const item of source) {
-                copy.push(cloneDeep(item, map));
-            }
-            return copy;
-        }
-        // 处理 Map 类型
+        // 处理 Map
         if (source instanceof Map) {
             const copy = new Map();
             map.set(source, copy);
@@ -467,7 +489,7 @@
             });
             return copy;
         }
-        // 处理 Set 类型
+        // 处理 Set
         if (source instanceof Set) {
             const copy = new Set();
             map.set(source, copy);
@@ -476,22 +498,171 @@
             });
             return copy;
         }
-        // 处理 ArrayBuffer 类型
-        if (source instanceof ArrayBuffer) {
-            const copy = new ArrayBuffer(source.byteLength);
-            new Uint8Array(copy).set(new Uint8Array(source));
+        // 处理数组 (包含稀疏数组)
+        if (Array.isArray(source)) {
+            const copy = Array.from({ length: source.length });
             map.set(source, copy);
+            // 克隆所有有效索引
+            for (let i = 0; i < source.length; i++) {
+                if (i in source) {
+                    // 保留空位
+                    copy[i] = cloneDeep(source[i], map);
+                }
+            }
+            // 克隆数组的自定义属性
+            const descriptors = Object.getOwnPropertyDescriptors(source);
+            for (const key of Reflect.ownKeys(descriptors)) {
+                Object.defineProperty(copy, key, {
+                    ...descriptors[key],
+                    value: cloneDeep(descriptors[key].value, map)
+                });
+            }
             return copy;
         }
-        // 处理普通对象（包括原型链继承）
+        // 处理普通对象和类实例
         const copy = Object.create(Object.getPrototypeOf(source));
         map.set(source, copy);
-        for (const key of Reflect.ownKeys(source)) {
-            const value = source[key];
-            copy[key] = cloneDeep(value, map);
+        const descriptors = Object.getOwnPropertyDescriptors(source);
+        for (const key of Reflect.ownKeys(descriptors)) {
+            const descriptor = descriptors[key];
+            if ('value' in descriptor) {
+                // 克隆数据属性
+                descriptor.value = cloneDeep(descriptor.value, map);
+            }
+            else {
+                // 处理访问器属性 (getter/setter)
+                if (descriptor.get) {
+                    descriptor.get = cloneDeep(descriptor.get, map);
+                }
+                if (descriptor.set) {
+                    descriptor.set = cloneDeep(descriptor.set, map);
+                }
+            }
+            Object.defineProperty(copy, key, descriptor);
         }
         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; i < a.length; i++) {
+            if (!deepEqual(a[i], b[i], compared))
+                return false;
+        }
+        // 比较数组对象的其他属性
+        return compareObjects(a, b, compared);
+    }
 
     /**
      * 将字符串转换为驼峰格式
@@ -736,31 +907,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
@@ -2179,7 +2325,8 @@
     const defaultSearchTreeOptions = {
         childField: 'children',
         nameField: 'name',
-        ignoreEmptyChild: false
+        removeEmptyChild: false,
+        ignoreCase: true
     };
     /**
      * 深度优先遍历函数(支持continue和break操作), 可用于insert tree item 和 remove tree item
@@ -2236,7 +2383,9 @@
         walk(tree, null);
     }
     /**
-     * 深度优先遍历的Map函数(支持continue和break操作), 可用于insert tree item 和 remove tree item
+     * 创建一个新数组, 深度优先遍历的Map函数(支持continue和break操作), 可用于insert tree item 和 remove tree item
+     *
+     * 可遍历任何带有 length 属性和数字键的类数组对象
      * @param {ArrayLike<V>} tree  树形数据
      * @param {Function} iterator  迭代函数, 返回值为true时continue, 返回值为false时break
      * @param {string} children 定制子元素的key
@@ -2336,91 +2485,6 @@
         };
         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
@@ -2472,20 +2536,36 @@
     }
     /**
      * 模糊搜索函数，返回包含搜索字符的节点及其祖先节点, 适用于树型组件的字符过滤功能
-     * @param {any[]} nodes
-     * @param {string} query
+     * 以下搜索条件二选一，按先后优先级处理：
+     * 1. 过滤函数filter, 返回true/false
+     * 2. 匹配关键词，支持是否启用忽略大小写来判断
+     *
+     * 有以下特性：
+     * 1. 可配置removeEmptyChild字段，来决定是否移除搜索结果中的空children字段
+     * 2. 若无任何过滤条件或keyword模式匹配且keyword为空串，返回原对象；其他情况返回新数组
+     * @param {V[]} nodes
+     * @param {IFilterCondition} filterCondition
      * @param {ISearchTreeOpts} options
-     * @returns {any[]}
+     * @returns {V[]}
      */
-    function fuzzySearchTree(nodes, query, options = defaultSearchTreeOptions) {
+    function fuzzySearchTree(nodes, filterCondition, options = defaultSearchTreeOptions) {
+        if (!objectHas(filterCondition, 'filter') &&
+            (!objectHas(filterCondition, 'keyword') || isEmpty(filterCondition.keyword))) {
+            return nodes;
+        }
         const result = [];
         for (const node of nodes) {
             // 递归检查子节点是否匹配
             const matchedChildren = node[options.childField] && node[options.childField].length > 0
-                ? fuzzySearchTree(node[options.childField] || [], query, options)
+                ? fuzzySearchTree(node[options.childField] || [], filterCondition, options)
                 : [];
             // 检查当前节点是否匹配或者有匹配的子节点
-            if (node[options.nameField].toLowerCase().includes(query.toLowerCase()) || matchedChildren.length > 0) {
+            if ((objectHas(filterCondition, 'filter')
+                ? filterCondition.filter(node)
+                : !options.ignoreCase
+                    ? node[options.nameField].includes(filterCondition.keyword)
+                    : node[options.nameField].toLowerCase().includes(filterCondition.keyword.toLowerCase())) ||
+                matchedChildren.length > 0) {
                 // 将当前节点加入结果中
                 if (node[options.childField]) {
                     if (matchedChildren.length > 0) {
@@ -2494,7 +2574,7 @@
                             [options.childField]: matchedChildren // 包含匹配的子节点
                         });
                     }
-                    else if (options.ignoreEmptyChild) {
+                    else if (options.removeEmptyChild) {
                         node[options.childField] && delete node[options.childField];
                         result.push({
                             ...node
@@ -2887,7 +2967,6 @@
     exports.arrayLike = arrayLike;
     exports.arrayRemove = arrayRemove;
     exports.asyncMap = asyncMap;
-    exports.buildTree = buildTree;
     exports.calculateDate = calculateDate;
     exports.calculateDateTime = calculateDateTime;
     exports.chooseLocalFile = chooseLocalFile;
@@ -2928,9 +3007,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;
@@ -2942,6 +3021,7 @@
     exports.isNaN = isNaN;
     exports.isNull = isNull;
     exports.isNullOrUnDef = isNullOrUnDef;
+    exports.isNullish = isNullOrUnDef;
     exports.isNumber = isNumber;
     exports.isNumerical = isNumerical;
     exports.isObject = isObject;
@@ -2968,7 +3048,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.1",
+  "version": "1.8.0",
   "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": {