sculp-js 1.7.2 → 1.8.0

package/lib/umd/index.js

@@ -1,5 +1,5 @@
 /*!
- * sculp-js v1.7.2
+ * 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';
@@ -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(/^\./, '');
@@ -529,6 +542,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; i < a.length; i++) {
+            if (!deepEqual(a[i], b[i], compared))
+                return false;
+        }
+        // 比较数组对象的其他属性
+        return compareObjects(a, b, compared);
+    }
 
     /**
      * 将字符串转换为驼峰格式
@@ -773,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
@@ -2376,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
@@ -2943,7 +2967,6 @@
     exports.arrayLike = arrayLike;
     exports.arrayRemove = arrayRemove;
     exports.asyncMap = asyncMap;
-    exports.buildTree = buildTree;
     exports.calculateDate = calculateDate;
     exports.calculateDateTime = calculateDateTime;
     exports.chooseLocalFile = chooseLocalFile;
@@ -2984,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;
@@ -2998,6 +3021,7 @@
     exports.isNaN = isNaN;
     exports.isNull = isNull;
     exports.isNullOrUnDef = isNullOrUnDef;
+    exports.isNullish = isNullOrUnDef;
     exports.isNumber = isNumber;
     exports.isNumerical = isNumerical;
     exports.isObject = isObject;
@@ -3024,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.2",
+  "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": {