zhiaiwan-utils 1.0.3

package/dist/cjs/_internal/baseFind.js

@@ -0,0 +1,153 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baseFind = baseFind;
+exports.baseFindIndex = baseFindIndex;
+exports.baseFindKey = baseFindKey;
+const isArrayLike_1 = __importDefault(require("./isArrayLike"));
+function defaultPredicate(value) {
+    return Boolean(value);
+}
+function resolveFromIndex(fromIndex, length) {
+    return fromIndex < 0 ? Math.max(length + fromIndex, 0) : fromIndex;
+}
+function resolveFromLastIndex(fromIndex, length) {
+    if (fromIndex == null) {
+        return length - 1;
+    }
+    const index = fromIndex < 0 ? length + fromIndex : fromIndex;
+    return Math.min(Math.max(index, 0), Math.max(length - 1, 0));
+}
+/**
+ * 在集合中查找首个匹配元素；fromIndex 仅对类数组生效。
+ *
+ * @internal
+ */
+function baseFind(collection, predicate = defaultPredicate, fromIndex, fromRight = false) {
+    var _a;
+    if (collection == null) {
+        return undefined;
+    }
+    if (typeof collection === 'string') {
+        const chars = [...collection];
+        const length = chars.length;
+        if (fromRight) {
+            const start = resolveFromLastIndex(fromIndex, length);
+            for (let index = start; index >= 0; index--) {
+                if (predicate(chars[index], index, collection)) {
+                    return chars[index];
+                }
+            }
+            return undefined;
+        }
+        const start = resolveFromIndex(fromIndex !== null && fromIndex !== void 0 ? fromIndex : 0, length);
+        for (let index = start; index < length; index++) {
+            if (predicate(chars[index], index, collection)) {
+                return chars[index];
+            }
+        }
+        return undefined;
+    }
+    if (Array.isArray(collection)) {
+        const length = collection.length;
+        if (fromRight) {
+            const start = resolveFromLastIndex(fromIndex, length);
+            for (let index = start; index >= 0; index--) {
+                if (predicate(collection[index], index, collection)) {
+                    return collection[index];
+                }
+            }
+            return undefined;
+        }
+        const start = resolveFromIndex(fromIndex !== null && fromIndex !== void 0 ? fromIndex : 0, length);
+        for (let index = start; index < length; index++) {
+            if (predicate(collection[index], index, collection)) {
+                return collection[index];
+            }
+        }
+        return undefined;
+    }
+    if ((0, isArrayLike_1.default)(collection)) {
+        const arrayLike = collection;
+        const length = (_a = arrayLike.length) !== null && _a !== void 0 ? _a : 0;
+        if (fromRight) {
+            const start = resolveFromLastIndex(fromIndex, length);
+            for (let index = start; index >= 0; index--) {
+                if (predicate(arrayLike[index], index, collection)) {
+                    return arrayLike[index];
+                }
+            }
+            return undefined;
+        }
+        const start = resolveFromIndex(fromIndex !== null && fromIndex !== void 0 ? fromIndex : 0, length);
+        for (let index = start; index < length; index++) {
+            if (predicate(arrayLike[index], index, collection)) {
+                return arrayLike[index];
+            }
+        }
+        return undefined;
+    }
+    if (typeof collection === 'object') {
+        const keys = Object.keys(collection);
+        const orderedKeys = fromRight ? [...keys].reverse() : keys;
+        for (const key of orderedKeys) {
+            const value = collection[key];
+            if (predicate(value, key, collection)) {
+                return value;
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * 在类数组中查找首个匹配下标。
+ *
+ * @internal
+ */
+function baseFindIndex(array, predicate = defaultPredicate, fromIndex, fromRight = false) {
+    var _a;
+    if (array == null || !(0, isArrayLike_1.default)(array)) {
+        return -1;
+    }
+    const arrayLike = array;
+    const length = (_a = arrayLike.length) !== null && _a !== void 0 ? _a : 0;
+    if (!length) {
+        return -1;
+    }
+    if (fromRight) {
+        const start = resolveFromLastIndex(fromIndex, length);
+        for (let index = start; index >= 0; index--) {
+            if (predicate(arrayLike[index], index, array)) {
+                return index;
+            }
+        }
+        return -1;
+    }
+    const start = resolveFromIndex(fromIndex !== null && fromIndex !== void 0 ? fromIndex : 0, length);
+    for (let index = start; index < length; index++) {
+        if (predicate(arrayLike[index], index, array)) {
+            return index;
+        }
+    }
+    return -1;
+}
+/**
+ * 在对象中查找首个匹配键名。
+ *
+ * @internal
+ */
+function baseFindKey(object, predicate = defaultPredicate, fromRight = false) {
+    if (object == null) {
+        return undefined;
+    }
+    const keys = Object.keys(object);
+    const orderedKeys = fromRight ? [...keys].reverse() : keys;
+    for (const key of orderedKeys) {
+        if (predicate(object[key], key, object)) {
+            return key;
+        }
+    }
+    return undefined;
+}

package/dist/cjs/_internal/baseFlatten.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = baseFlatten;
+const isFlattenable_1 = __importDefault(require("./isFlattenable"));
+/**
+ * 按指定深度展平数组，语义对齐 Lodash baseFlatten。
+ *
+ * @internal
+ */
+function baseFlatten(array, depth, result = []) {
+    for (let index = 0; index < array.length; index++) {
+        const value = array[index];
+        if (depth > 0 && (0, isFlattenable_1.default)(value)) {
+            const nested = value;
+            if (depth > 1) {
+                baseFlatten(nested, depth - 1, result);
+            }
+            else {
+                for (let nestedIndex = 0; nestedIndex < nested.length; nestedIndex++) {
+                    result.push(nested[nestedIndex]);
+                }
+            }
+        }
+        else {
+            result.push(value);
+        }
+    }
+    return result;
+}

package/dist/cjs/_internal/baseForEach.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = baseForEach;
+const isArrayLike_1 = __importDefault(require("./isArrayLike"));
+/**
+ * iteratee 仅在为 false 时中断，与 Lodash forEach 语义一致。
+ *
+ * @internal
+ */
+function shouldBreak(result) {
+    return result === false;
+}
+/**
+ * 集合遍历内核；fromRight 控制逆序。
+ *
+ * @internal
+ */
+function baseForEach(collection, iteratee, fromRight = false) {
+    var _a;
+    if (collection == null) {
+        return collection;
+    }
+    if (typeof collection === 'string') {
+        const chars = [...collection];
+        const length = chars.length;
+        if (fromRight) {
+            for (let i = length - 1; i >= 0; i--) {
+                if (shouldBreak(iteratee(chars[i], i, collection))) {
+                    break;
+                }
+            }
+        }
+        else {
+            for (let i = 0; i < length; i++) {
+                if (shouldBreak(iteratee(chars[i], i, collection))) {
+                    break;
+                }
+            }
+        }
+        return collection;
+    }
+    if (Array.isArray(collection)) {
+        const length = collection.length;
+        if (fromRight) {
+            for (let i = length - 1; i >= 0; i--) {
+                if (shouldBreak(iteratee(collection[i], i, collection))) {
+                    break;
+                }
+            }
+        }
+        else {
+            for (let i = 0; i < length; i++) {
+                if (shouldBreak(iteratee(collection[i], i, collection))) {
+                    break;
+                }
+            }
+        }
+        return collection;
+    }
+    if ((0, isArrayLike_1.default)(collection)) {
+        const arrayLike = collection;
+        const length = (_a = arrayLike.length) !== null && _a !== void 0 ? _a : 0;
+        if (fromRight) {
+            for (let i = length - 1; i >= 0; i--) {
+                if (shouldBreak(iteratee(arrayLike[i], i, collection))) {
+                    break;
+                }
+            }
+        }
+        else {
+            for (let i = 0; i < length; i++) {
+                if (shouldBreak(iteratee(arrayLike[i], i, collection))) {
+                    break;
+                }
+            }
+        }
+        return collection;
+    }
+    if (typeof collection === 'object') {
+        const keys = Object.keys(collection);
+        const orderedKeys = fromRight ? [...keys].reverse() : keys;
+        for (const key of orderedKeys) {
+            if (shouldBreak(iteratee(collection[key], key, collection))) {
+                break;
+            }
+        }
+    }
+    return collection;
+}

package/dist/cjs/_internal/baseForOwn.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baseForOwn = baseForOwn;
+exports.baseForIn = baseForIn;
+const baseCollectionKeys_1 = require("./baseCollectionKeys");
+const baseKeysIn_1 = __importDefault(require("./baseKeysIn"));
+function baseFor(object, iteratee, keysProvider) {
+    for (const key of keysProvider(object)) {
+        if (iteratee(object[key], key, object) === false) {
+            break;
+        }
+    }
+    return object;
+}
+/**
+ * 遍历对象自有可枚举属性，对齐 Lodash baseForOwn。
+ *
+ * @internal
+ */
+function baseForOwn(object, iteratee) {
+    return baseFor(object, iteratee, baseCollectionKeys_1.baseKeys);
+}
+/**
+ * 遍历对象自有与继承的可枚举属性，对齐 Lodash forIn 内核。
+ *
+ * @internal
+ */
+function baseForIn(object, iteratee) {
+    return baseFor(object, iteratee, baseKeysIn_1.default);
+}

package/dist/cjs/_internal/baseIsEqual.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = baseIsEqual;
+function compareArrayBuffer(left, right) {
+    if (left.byteLength !== right.byteLength) {
+        return false;
+    }
+    const leftView = new Uint8Array(left);
+    const rightView = new Uint8Array(right);
+    for (let i = 0; i < leftView.length; i++) {
+        if (leftView[i] !== rightView[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+function isArrayBufferLike(value) {
+    return (value instanceof ArrayBuffer ||
+        (typeof SharedArrayBuffer !== 'undefined' && value instanceof SharedArrayBuffer));
+}
+function isBoxedPrimitive(value) {
+    return value instanceof Boolean || value instanceof Number || value instanceof String;
+}
+/**
+ * 深比较实现，对齐 Lodash baseIsEqual 的常见类型与 customizer 语义。
+ *
+ * @internal
+ */
+function baseIsEqual(value, other, seen, options = {}, key, object) {
+    const { customizer } = options;
+    if (customizer) {
+        const customized = customizer(value, other, key, object, seen);
+        if (customized !== undefined) {
+            return customized;
+        }
+    }
+    if (Object.is(value, other)) {
+        return true;
+    }
+    if (value == null || other == null) {
+        return false;
+    }
+    if (isBoxedPrimitive(value) || isBoxedPrimitive(other)) {
+        if (!isBoxedPrimitive(value) || !isBoxedPrimitive(other)) {
+            return false;
+        }
+        return Object.is(value.valueOf(), other.valueOf());
+    }
+    if (typeof value !== 'object' || typeof other !== 'object') {
+        return false;
+    }
+    const valueObj = value;
+    const otherObj = other;
+    const cached = seen.get(valueObj);
+    if (cached === otherObj) {
+        return true;
+    }
+    seen.set(valueObj, otherObj);
+    if (value instanceof Date && other instanceof Date) {
+        return value.getTime() === other.getTime();
+    }
+    if (value instanceof RegExp && other instanceof RegExp) {
+        return value.source === other.source && value.flags === other.flags;
+    }
+    if (isArrayBufferLike(value) && isArrayBufferLike(other)) {
+        return compareArrayBuffer(value, other);
+    }
+    if (value instanceof DataView && other instanceof DataView) {
+        return (value.byteOffset === other.byteOffset &&
+            value.byteLength === other.byteLength &&
+            compareArrayBuffer(value.buffer, other.buffer));
+    }
+    if (ArrayBuffer.isView(value) && ArrayBuffer.isView(other)) {
+        if (value.constructor !== other.constructor) {
+            return false;
+        }
+        const left = value;
+        const right = other;
+        if (left.byteLength !== right.byteLength) {
+            return false;
+        }
+        for (let i = 0; i < left.byteLength; i++) {
+            if (left[i] !== right[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (Array.isArray(value)) {
+        if (!Array.isArray(other) || value.length !== other.length) {
+            return false;
+        }
+        for (let i = 0; i < value.length; i++) {
+            if (!baseIsEqual(value[i], other[i], seen, options, i, valueObj)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (value instanceof Map && other instanceof Map) {
+        if (value.size !== other.size) {
+            return false;
+        }
+        const otherEntries = [...other.entries()];
+        const matched = new Set();
+        outer: for (const [mapKey, mapValue] of value.entries()) {
+            for (let i = 0; i < otherEntries.length; i++) {
+                if (matched.has(i)) {
+                    continue;
+                }
+                const [otherKey, otherVal] = otherEntries[i];
+                if (baseIsEqual(mapKey, otherKey, seen, options, undefined, valueObj) &&
+                    baseIsEqual(mapValue, otherVal, seen, options, undefined, valueObj)) {
+                    matched.add(i);
+                    continue outer;
+                }
+            }
+            return false;
+        }
+        return true;
+    }
+    if (value instanceof Set && other instanceof Set) {
+        if (value.size !== other.size) {
+            return false;
+        }
+        const otherValues = [...other.values()];
+        const matched = new Set();
+        outer: for (const setValue of value.values()) {
+            for (let i = 0; i < otherValues.length; i++) {
+                if (matched.has(i)) {
+                    continue;
+                }
+                if (baseIsEqual(setValue, otherValues[i], seen, options, undefined, valueObj)) {
+                    matched.add(i);
+                    continue outer;
+                }
+            }
+            return false;
+        }
+        return true;
+    }
+    if (Object.getPrototypeOf(value) !== Object.getPrototypeOf(other)) {
+        return false;
+    }
+    const valueKeys = Reflect.ownKeys(value);
+    const otherKeys = Reflect.ownKeys(other);
+    if (valueKeys.length !== otherKeys.length) {
+        return false;
+    }
+    for (const currentKey of valueKeys) {
+        if (!Object.prototype.hasOwnProperty.call(other, currentKey)) {
+            return false;
+        }
+        const left = value[currentKey];
+        const right = other[currentKey];
+        if (!baseIsEqual(left, right, seen, options, currentKey, valueObj)) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/cjs/_internal/baseIsMatch.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = baseIsMatch;
+const baseIsEqual_1 = __importDefault(require("./baseIsEqual"));
+function isMatchableObject(value) {
+    return typeof value === 'object' && value !== null;
+}
+function matchValues(objectValue, sourceValue, options, key, object, source) {
+    const { customizer } = options;
+    if (customizer) {
+        const customized = customizer(objectValue, sourceValue, key, object, source);
+        if (customized !== undefined) {
+            return customized;
+        }
+    }
+    if (sourceValue == null) {
+        return objectValue == null;
+    }
+    if (!isMatchableObject(sourceValue)) {
+        return Object.is(objectValue, sourceValue);
+    }
+    if (Array.isArray(sourceValue)) {
+        if (!Array.isArray(objectValue) || sourceValue.length !== objectValue.length) {
+            return false;
+        }
+        for (let i = 0; i < sourceValue.length; i++) {
+            if (!matchValues(objectValue[i], sourceValue[i], options, i, objectValue, sourceValue)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (sourceValue instanceof Date) {
+        return objectValue instanceof Date && objectValue.getTime() === sourceValue.getTime();
+    }
+    if (sourceValue instanceof RegExp) {
+        return (objectValue instanceof RegExp &&
+            objectValue.source === sourceValue.source &&
+            objectValue.flags === sourceValue.flags);
+    }
+    if (sourceValue instanceof Map || sourceValue instanceof Set) {
+        return (0, baseIsEqual_1.default)(objectValue, sourceValue, new WeakMap());
+    }
+    if (isMatchableObject(objectValue)) {
+        return baseIsMatch(objectValue, sourceValue, options);
+    }
+    return Object.is(objectValue, sourceValue);
+}
+/**
+ * 判断 object 是否包含 source 定义的全部属性值（部分匹配）。
+ *
+ * @internal
+ */
+function baseIsMatch(object, source, options = {}) {
+    if (source == null) {
+        return true;
+    }
+    if (object == null) {
+        return false;
+    }
+    if (!isMatchableObject(source)) {
+        return Object.is(object, source);
+    }
+    if (Array.isArray(source)) {
+        return matchValues(object, source, options);
+    }
+    const sourceObj = source;
+    const objectObj = object;
+    for (const key of Reflect.ownKeys(sourceObj)) {
+        const sourceValue = sourceObj[key];
+        const objectValue = objectObj[key];
+        if (!matchValues(objectValue, sourceValue, options, key, objectObj, sourceObj)) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/cjs/_internal/baseIteratee.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = baseIteratee;
+const baseIsMatch_1 = __importDefault(require("./baseIsMatch"));
+const identity_1 = __importDefault(require("./identity"));
+const toPath_1 = __importDefault(require("./toPath"));
+function getProperty(object, path) {
+    if (object == null) {
+        return undefined;
+    }
+    const keys = (0, toPath_1.default)(path);
+    let current = object;
+    for (const key of keys) {
+        if (current == null) {
+            return undefined;
+        }
+        current = current[key];
+    }
+    return current;
+}
+/**
+ * 将 Lodash 风格 iteratee 简写解析为统一回调。
+ *
+ * @internal
+ */
+function baseIteratee(iteratee = identity_1.default) {
+    if (iteratee == null) {
+        return identity_1.default;
+    }
+    if (typeof iteratee === 'function') {
+        return iteratee;
+    }
+    if (Array.isArray(iteratee)) {
+        const path = iteratee[0];
+        const matchValue = iteratee[1];
+        return (value) => Object.is(getProperty(value, path), matchValue);
+    }
+    if (typeof iteratee === 'object') {
+        const source = iteratee;
+        return (value) => (0, baseIsMatch_1.default)(value, source);
+    }
+    return (value) => getProperty(value, iteratee);
+}

package/dist/cjs/_internal/baseKeysIn.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = baseKeysIn;
+const baseCollectionKeys_1 = require("./baseCollectionKeys");
+const isArrayLike_1 = __importDefault(require("./isArrayLike"));
+const objectProto = Object.prototype;
+const hasOwnProperty = objectProto.hasOwnProperty;
+function isPrototype(value) {
+    const ctor = value.constructor;
+    const proto = ctor === null || ctor === void 0 ? void 0 : ctor.prototype;
+    return value === proto;
+}
+/**
+ * 返回对象自有与继承的可枚举键名，语义对齐 Lodash keysIn。
+ *
+ * @internal
+ */
+function baseKeysIn(object) {
+    if (object == null) {
+        return [];
+    }
+    if ((0, isArrayLike_1.default)(object)) {
+        return (0, baseCollectionKeys_1.baseKeys)(object);
+    }
+    if (typeof object !== 'object') {
+        const result = [];
+        const wrapped = Object(object);
+        for (const key in wrapped) {
+            result.push(key);
+        }
+        return result;
+    }
+    const isProto = isPrototype(object);
+    const result = [];
+    for (const key in object) {
+        if (!(key === 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
+            result.push(key);
+        }
+    }
+    return result;
+}

package/dist/cjs/_internal/baseMap.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = baseMap;
+const isArrayLike_1 = __importDefault(require("./isArrayLike"));
+const baseIteratee_1 = __importDefault(require("./baseIteratee"));
+/**
+ * 遍历集合并映射为新数组，语义对齐 Lodash map。
+ *
+ * @internal
+ */
+function baseMap(collection, iteratee = (0, baseIteratee_1.default)()) {
+    var _a;
+    const resolvedIteratee = (0, baseIteratee_1.default)(iteratee);
+    const result = [];
+    if (collection == null) {
+        return result;
+    }
+    if (typeof collection === 'string') {
+        const chars = [...collection];
+        for (let index = 0; index < chars.length; index++) {
+            result.push(resolvedIteratee(chars[index], index, collection));
+        }
+        return result;
+    }
+    if (Array.isArray(collection)) {
+        for (let index = 0; index < collection.length; index++) {
+            result.push(resolvedIteratee(collection[index], index, collection));
+        }
+        return result;
+    }
+    if ((0, isArrayLike_1.default)(collection)) {
+        const arrayLike = collection;
+        const length = (_a = arrayLike.length) !== null && _a !== void 0 ? _a : 0;
+        for (let index = 0; index < length; index++) {
+            result.push(resolvedIteratee(arrayLike[index], index, collection));
+        }
+        return result;
+    }
+    if (typeof collection === 'object') {
+        const keys = Object.keys(collection);
+        for (const key of keys) {
+            result.push(resolvedIteratee(collection[key], key, collection));
+        }
+    }
+    return result;
+}