sculp-js 1.7.1 → 1.8.0

package/lib/es/object.js

@@ -1,5 +1,5 @@
 /*!
- * sculp-js v1.7.0
+ * sculp-js v1.8.0
  * (c) 2023-present chandq
  * Released under the MIT License.
  */
@@ -81,7 +81,7 @@ function objectPick(obj, keys) {
     return obj2;
 }
 /**
- * 对象祛除
+ * 对象去除
  * @param {O} obj
  * @param {K} keys
  * @returns {Pick<O, ArrayElements<K>>}
@@ -166,6 +166,13 @@ function objectFill(source, target, fillable) {
     });
     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(/^\./, '');
@@ -196,12 +203,16 @@ function objectGet(obj, path, strict = false) {
 }
 /**
  * 深拷贝堪称完全体 即：任何类型的数据都会被深拷贝
+ *
+ * 包含对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;
     }
@@ -209,28 +220,33 @@ function cloneDeep(source, map = new WeakMap()) {
     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);
@@ -239,7 +255,7 @@ function cloneDeep(source, map = new WeakMap()) {
         });
         return copy;
     }
-    // 处理 Set 类型
+    // 处理 Set
     if (source instanceof Set) {
         const copy = new Set();
         map.set(source, copy);
@@ -248,21 +264,170 @@ function cloneDeep(source, map = new WeakMap()) {
         });
         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);
+}
 
-export { cloneDeep, isPlainObject, objectAssign, objectEach, objectEachAsync, objectFill, objectGet, objectMap, objectAssign as objectMerge, objectOmit, objectPick };
+export { cloneDeep, isEqual, isPlainObject, objectAssign, objectEach, objectEachAsync, objectFill, objectGet, objectMap, objectAssign as objectMerge, objectOmit, objectPick };

package/lib/es/path.js

@@ -1,5 +1,5 @@
 /*!
- * sculp-js v1.7.0
+ * sculp-js v1.8.0
  * (c) 2023-present chandq
  * Released under the MIT License.
  */

package/lib/es/qs.js

@@ -1,5 +1,5 @@
 /*!
- * sculp-js v1.7.0
+ * sculp-js v1.8.0
  * (c) 2023-present chandq
  * Released under the MIT License.
  */

package/lib/es/random.js

@@ -1,5 +1,5 @@
 /*!
- * sculp-js v1.7.0
+ * sculp-js v1.8.0
  * (c) 2023-present chandq
  * Released under the MIT License.
  */

package/lib/es/string.js

@@ -1,5 +1,5 @@
 /*!
- * sculp-js v1.7.0
+ * sculp-js v1.8.0
  * (c) 2023-present chandq
  * Released under the MIT License.
  */

package/lib/es/tooltip.js

@@ -1,5 +1,5 @@
 /*!
- * sculp-js v1.7.0
+ * sculp-js v1.8.0
  * (c) 2023-present chandq
  * Released under the MIT License.
  */

package/lib/es/tree.js

@@ -1,16 +1,18 @@
 /*!
- * sculp-js v1.7.0
+ * sculp-js v1.8.0
  * (c) 2023-present chandq
  * Released under the MIT License.
  */
 
 import { objectOmit } from './object.js';
+import { objectHas, isEmpty } from './type.js';
 
 const defaultFieldOptions = { keyField: 'key', childField: 'children', pidField: 'pid' };
 const defaultSearchTreeOptions = {
     childField: 'children',
     nameField: 'name',
-    ignoreEmptyChild: false
+    removeEmptyChild: false,
+    ignoreCase: true
 };
 /**
  * 深度优先遍历函数(支持continue和break操作), 可用于insert tree item 和 remove tree item
@@ -67,7 +69,9 @@ function forEachDeep(tree, iterator, children = 'children', isReverse = false) {
     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
@@ -167,91 +171,6 @@ function searchTreeById(tree, nodeId, config) {
     };
     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
@@ -303,20 +222,36 @@ function flatTree(treeList, options = defaultFieldOptions) {
 }
 /**
  * 模糊搜索函数，返回包含搜索字符的节点及其祖先节点, 适用于树型组件的字符过滤功能
- * @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) {
@@ -325,7 +260,7 @@ function fuzzySearchTree(nodes, query, options = defaultSearchTreeOptions) {
                         [options.childField]: matchedChildren // 包含匹配的子节点
                     });
                 }
-                else if (options.ignoreEmptyChild) {
+                else if (options.removeEmptyChild) {
                     node[options.childField] && delete node[options.childField];
                     result.push({
                         ...node
@@ -349,4 +284,4 @@ function fuzzySearchTree(nodes, query, options = defaultSearchTreeOptions) {
     return result;
 }
 
-export { buildTree, flatTree, forEachDeep, formatTree, fuzzySearchTree, mapDeep, searchTreeById };
+export { flatTree, forEachDeep, formatTree, fuzzySearchTree, mapDeep, searchTreeById };

package/lib/es/type.js

@@ -1,5 +1,5 @@
 /*!
- * sculp-js v1.7.0
+ * sculp-js v1.8.0
  * (c) 2023-present chandq
  * Released under the MIT License.
  */
@@ -30,11 +30,17 @@ function arrayLike(any) {
     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';
@@ -114,4 +120,4 @@ function isEmpty(value) {
     return !Object.keys(value).length;
 }
 
-export { arrayLike, typeIs as default, isArray, isBigInt, isBoolean, isDate, isEmpty, isError, isFunction, isJsonString, isNaN, isNull, isNullOrUnDef, isNumber, isObject, isPrimitive, isRegExp, isString, isSymbol, isUndefined, objectHas, typeIs };
+export { arrayLike, typeIs as default, isArray, isBigInt, isBoolean, isDate, isEmpty, isError, isFunction, isJsonString, isNaN, isNull, isNullOrUnDef, isNullOrUnDef as isNullish, isNumber, isObject, isPrimitive, isRegExp, isString, isSymbol, isUndefined, objectHas, typeIs };

package/lib/es/unique.js

@@ -1,5 +1,5 @@
 /*!
- * sculp-js v1.7.0
+ * sculp-js v1.8.0
  * (c) 2023-present chandq
  * Released under the MIT License.
  */

package/lib/es/url.js

@@ -1,5 +1,5 @@
 /*!
- * sculp-js v1.7.0
+ * sculp-js v1.8.0
  * (c) 2023-present chandq
  * Released under the MIT License.
  */

package/lib/es/validator.js

@@ -1,5 +1,5 @@
 /*!
- * sculp-js v1.7.0
+ * sculp-js v1.8.0
  * (c) 2023-present chandq
  * Released under the MIT License.
  */

package/lib/es/variable.js

@@ -1,5 +1,5 @@
 /*!
- * sculp-js v1.7.0
+ * sculp-js v1.8.0
  * (c) 2023-present chandq
  * Released under the MIT License.
  */

package/lib/es/watermark.js

@@ -1,5 +1,5 @@
 /*!
- * sculp-js v1.7.0
+ * sculp-js v1.8.0
  * (c) 2023-present chandq
  * Released under the MIT License.
  */

package/lib/es/we-decode.js

@@ -1,5 +1,5 @@
 /*!
- * sculp-js v1.7.0
+ * sculp-js v1.8.0
  * (c) 2023-present chandq
  * Released under the MIT License.
  */