zhiaiwan-utils 1.0.3

package/dist/cjs/verify/isTypedArray.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = isTypedArray;
+const TYPED_ARRAY_TAGS = new Set([
+    '[object Int8Array]',
+    '[object Uint8Array]',
+    '[object Uint8ClampedArray]',
+    '[object Int16Array]',
+    '[object Uint16Array]',
+    '[object Int32Array]',
+    '[object Uint32Array]',
+    '[object Float32Array]',
+    '[object Float64Array]',
+    '[object BigInt64Array]',
+    '[object BigUint64Array]',
+]);
+/**
+ * 检查 value 是否是 TypedArray 对象（不含 DataView）。
+ *
+ * @param value - 要检查的值
+ * @returns 如果 value 是 TypedArray，返回 true，否则返回 false
+ *
+ * @example
+ * ```ts
+ * isTypedArray(new Uint8Array(8));
+ * // => true
+ *
+ * isTypedArray(new DataView(new ArrayBuffer(8)));
+ * // => false
+ * ```
+ *
+ * @since 1.0.0
+ * @category Verify
+ */
+function isTypedArray(value) {
+    const tag = Object.prototype.toString.call(value);
+    return TYPED_ARRAY_TAGS.has(tag);
+}

package/dist/cjs/verify/isUndefined.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = isUndefined;
+/**
+ * 检查 value 是否是 undefined。
+ *
+ * @param value - 要检查的值
+ * @returns 如果 value 是 undefined，返回 true，否则返回 false
+ *
+ * @example
+ * ```ts
+ * isUndefined(void 0); // => true
+ * isUndefined(null);   // => false
+ * ```
+ *
+ * @since 1.0.0
+ * @category Verify
+ */
+function isUndefined(value) {
+    return value === undefined;
+}

package/dist/cjs/verify/isWeakMap.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = isWeakMap;
+/**
+ * 检查 value 是否是一个 WeakMap 对象。
+ *
+ * @param value - 要检查的值
+ * @returns 如果 value 是 WeakMap，返回 true，否则返回 false
+ *
+ * @example
+ * ```ts
+ * isWeakMap(new WeakMap());
+ * // => true
+ * ```
+ *
+ * @since 1.0.0
+ * @category Verify
+ */
+function isWeakMap(value) {
+    return Object.prototype.toString.call(value) === '[object WeakMap]';
+}

package/dist/cjs/verify/isWeakSet.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = isWeakSet;
+/**
+ * 检查 value 是否是一个 WeakSet 对象。
+ *
+ * @param value - 要检查的值
+ * @returns 如果 value 是 WeakSet，返回 true，否则返回 false
+ *
+ * @example
+ * ```ts
+ * isWeakSet(new WeakSet());
+ * // => true
+ * ```
+ *
+ * @since 1.0.0
+ * @category Verify
+ */
+function isWeakSet(value) {
+    return Object.prototype.toString.call(value) === '[object WeakSet]';
+}

package/dist/cjs/version.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.version = void 0;
+// 该文件由 cli 的 build/gen-version.mjs 自动生成，请勿手动修改。
+/**
+ * 当前库版本号，与 package.json 保持一致。
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.version;
+ * // => '1.0.3'
+ * ```
+ *
+ * @since 1.0.0
+ * @category Util
+ */
+exports.version = '1.0.3';

package/dist/esm/_internal/MapCache.js

@@ -0,0 +1,26 @@
+/**
+ * 内部辅助：memoize 默认缓存，接口对齐 Lodash MapCache。
+ *
+ * @internal
+ */
+export default class MapCache {
+    constructor() {
+        this.store = new Map();
+    }
+    clear() {
+        this.store.clear();
+    }
+    delete(key) {
+        return this.store.delete(key);
+    }
+    get(key) {
+        return this.store.get(key);
+    }
+    has(key) {
+        return this.store.has(key);
+    }
+    set(key, value) {
+        this.store.set(key, value);
+        return this;
+    }
+}

package/dist/esm/_internal/assignSources.js

@@ -0,0 +1,21 @@
+/**
+ * 内部辅助：将 sources 的自有可枚举属性浅拷贝到 object。
+ *
+ * @internal
+ */
+export function assignSources(object, sources, onlyUndefined) {
+    const target = (object == null ? {} : object);
+    for (const source of sources) {
+        if (source == null || typeof source !== 'object') {
+            continue;
+        }
+        for (const key of Object.keys(source)) {
+            const value = source[key];
+            if (onlyUndefined && target[key] !== undefined) {
+                continue;
+            }
+            target[key] = value;
+        }
+    }
+    return target;
+}

package/dist/esm/_internal/assignValue.js

@@ -0,0 +1,17 @@
+/**
+ * 安全赋值，避免 __proto__ 污染，对齐 Lodash assignValue。
+ *
+ * @internal
+ */
+export default function assignValue(object, key, value) {
+    if (key === '__proto__') {
+        Object.defineProperty(object, key, {
+            configurable: true,
+            enumerable: true,
+            value,
+            writable: true,
+        });
+        return;
+    }
+    object[key] = value;
+}

package/dist/esm/_internal/baseClone.js

@@ -0,0 +1,187 @@
+function cloneArrayBuffer(buffer, deep, seen) {
+    if (deep) {
+        const cached = seen.get(buffer);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const result = buffer.slice(0);
+        seen.set(buffer, result);
+        return result;
+    }
+    const result = new ArrayBuffer(buffer.byteLength);
+    new Uint8Array(result).set(new Uint8Array(buffer));
+    return result;
+}
+function cloneDataView(dataView, deep, seen, options) {
+    const buffer = deep
+        ? baseClone(dataView.buffer, seen, options)
+        : cloneArrayBuffer(dataView.buffer, false, seen);
+    const result = new DataView(buffer, dataView.byteOffset, dataView.byteLength);
+    if (deep) {
+        seen.set(dataView, result);
+    }
+    return result;
+}
+function cloneTypedArray(typed, deep, seen, options) {
+    const buffer = deep
+        ? baseClone(typed.buffer, seen, options)
+        : typed.buffer;
+    const Ctor = typed.constructor;
+    const result = new Ctor(buffer, typed.byteOffset, typed.byteLength);
+    if (deep) {
+        seen.set(typed, result);
+    }
+    return result;
+}
+function cloneError(value) {
+    const Ctor = value.constructor;
+    const result = new Ctor(value.message);
+    result.name = value.name;
+    if (value.stack) {
+        result.stack = value.stack;
+    }
+    return result;
+}
+function cloneBoxedPrimitive(value) {
+    return Object(value.valueOf());
+}
+function cloneProperties(source, result, deep, seen, options) {
+    const { customizer } = options;
+    for (const key of Reflect.ownKeys(source)) {
+        const subValue = source[key];
+        if (customizer) {
+            const customized = customizer(subValue, key, result, seen);
+            if (customized !== undefined) {
+                result[key] = customized;
+                continue;
+            }
+        }
+        result[key] = deep ? baseClone(subValue, seen, options) : subValue;
+    }
+}
+/**
+ * 内部共享克隆实现，对齐 Lodash baseClone 的常见类型与 customizer 语义。
+ *
+ * @internal
+ */
+export default function baseClone(value, seen = new WeakMap(), options = {}) {
+    const { deep = false, customizer } = options;
+    if (customizer) {
+        const customized = customizer(value, undefined, undefined, seen);
+        if (customized !== undefined) {
+            return customized;
+        }
+    }
+    if (value === null || typeof value !== 'object') {
+        return value;
+    }
+    const objValue = value;
+    if (deep) {
+        const cached = seen.get(objValue);
+        if (cached !== undefined) {
+            return cached;
+        }
+    }
+    if (value instanceof Error) {
+        const result = cloneError(value);
+        if (deep) {
+            seen.set(objValue, result);
+        }
+        return result;
+    }
+    if (value instanceof WeakMap || value instanceof WeakSet) {
+        return value;
+    }
+    if (value instanceof Boolean ||
+        value instanceof Number ||
+        value instanceof String) {
+        return cloneBoxedPrimitive(value);
+    }
+    if (value instanceof Date) {
+        const result = new Date(value.getTime());
+        if (deep) {
+            seen.set(objValue, result);
+        }
+        return result;
+    }
+    if (value instanceof RegExp) {
+        const cloned = new RegExp(value.source, value.flags);
+        cloned.lastIndex = value.lastIndex;
+        if (deep) {
+            seen.set(objValue, cloned);
+        }
+        return cloned;
+    }
+    if (value instanceof ArrayBuffer || (typeof SharedArrayBuffer !== 'undefined' && value instanceof SharedArrayBuffer)) {
+        return cloneArrayBuffer(value, deep, seen);
+    }
+    if (value instanceof DataView) {
+        return cloneDataView(value, deep, seen, options);
+    }
+    if (ArrayBuffer.isView(value)) {
+        return cloneTypedArray(value, deep, seen, options);
+    }
+    if (Array.isArray(value)) {
+        const result = [];
+        if (deep) {
+            seen.set(objValue, result);
+        }
+        for (let i = 0; i < value.length; i++) {
+            const item = value[i];
+            if (customizer) {
+                const customized = customizer(item, i, result, seen);
+                if (customized !== undefined) {
+                    result[i] = customized;
+                    continue;
+                }
+            }
+            result[i] = deep ? baseClone(item, seen, options) : item;
+        }
+        return result;
+    }
+    if (value instanceof Map) {
+        const result = new Map();
+        if (deep) {
+            seen.set(objValue, result);
+        }
+        value.forEach((mapValue, mapKey) => {
+            let nextKey = mapKey;
+            let nextValue = mapValue;
+            if (customizer) {
+                const customizedKey = customizer(mapKey, undefined, result, seen);
+                if (customizedKey !== undefined) {
+                    nextKey = customizedKey;
+                }
+                const customizedValue = customizer(mapValue, undefined, result, seen);
+                if (customizedValue !== undefined) {
+                    nextValue = customizedValue;
+                }
+            }
+            result.set(deep ? baseClone(nextKey, seen, options) : nextKey, deep ? baseClone(nextValue, seen, options) : nextValue);
+        });
+        return result;
+    }
+    if (value instanceof Set) {
+        const result = new Set();
+        if (deep) {
+            seen.set(objValue, result);
+        }
+        value.forEach((setValue) => {
+            let nextValue = setValue;
+            if (customizer) {
+                const customized = customizer(setValue, undefined, result, seen);
+                if (customized !== undefined) {
+                    nextValue = customized;
+                }
+            }
+            result.add(deep ? baseClone(nextValue, seen, options) : nextValue);
+        });
+        return result;
+    }
+    const result = Object.create(Object.getPrototypeOf(value));
+    if (deep) {
+        seen.set(objValue, result);
+    }
+    cloneProperties(value, result, deep, seen, options);
+    return result;
+}

package/dist/esm/_internal/baseCollectionKeys.js

@@ -0,0 +1,52 @@
+import isArrayLike from './isArrayLike';
+/**
+ * 返回集合的键名列表，语义对齐 Lodash keys。
+ *
+ * @internal
+ */
+export function baseKeys(collection) {
+    var _a;
+    if (collection == null) {
+        return [];
+    }
+    if (typeof collection === 'string') {
+        return [...collection].map((_, index) => String(index));
+    }
+    if (Array.isArray(collection)) {
+        return collection.map((_, index) => String(index));
+    }
+    if (isArrayLike(collection)) {
+        const length = (_a = collection.length) !== null && _a !== void 0 ? _a : 0;
+        return Array.from({ length }, (_, index) => String(index));
+    }
+    if (typeof collection === 'object') {
+        return Object.keys(collection);
+    }
+    return [];
+}
+/**
+ * 返回集合的值列表，语义对齐 Lodash values。
+ *
+ * @internal
+ */
+export function baseValues(collection) {
+    var _a;
+    if (collection == null) {
+        return [];
+    }
+    if (typeof collection === 'string') {
+        return [...collection];
+    }
+    if (Array.isArray(collection)) {
+        return [...collection];
+    }
+    if (isArrayLike(collection)) {
+        const arrayLike = collection;
+        const length = (_a = arrayLike.length) !== null && _a !== void 0 ? _a : 0;
+        return Array.from({ length }, (_, index) => arrayLike[index]);
+    }
+    if (typeof collection === 'object') {
+        return Object.values(collection);
+    }
+    return [];
+}

package/dist/esm/_internal/baseDefaultsDeep.js

@@ -0,0 +1,53 @@
+import isPlainObject from './isPlainObject';
+function shouldRecurse(target, source) {
+    return ((isPlainObject(target) && isPlainObject(source)) ||
+        (Array.isArray(target) && Array.isArray(source)));
+}
+function defaultsDeepArray(target, source) {
+    const length = source.length;
+    for (let index = 0; index < length; index++) {
+        const srcValue = source[index];
+        const objValue = target[index];
+        if (objValue === undefined) {
+            target[index] = srcValue;
+            continue;
+        }
+        if (shouldRecurse(objValue, srcValue)) {
+            baseDefaultsDeep(objValue, srcValue);
+        }
+    }
+}
+function defaultsDeepObject(target, source) {
+    for (const key of Object.keys(source)) {
+        const srcValue = source[key];
+        const objValue = target[key];
+        if (objValue === undefined) {
+            target[key] = srcValue;
+            continue;
+        }
+        if (shouldRecurse(objValue, srcValue)) {
+            baseDefaultsDeep(objValue, srcValue);
+        }
+    }
+}
+/**
+ * 将 source 深合并到 object，仅填充 undefined 属性，语义对齐 Lodash defaultsDeep。
+ *
+ * @internal
+ */
+export default function baseDefaultsDeep(object, source) {
+    if (source == null || object == null) {
+        return;
+    }
+    if (Array.isArray(source)) {
+        if (!Array.isArray(object)) {
+            return;
+        }
+        defaultsDeepArray(object, source);
+        return;
+    }
+    if (!isPlainObject(source) || !isPlainObject(object)) {
+        return;
+    }
+    defaultsDeepObject(object, source);
+}

package/dist/esm/_internal/baseDifference.js

@@ -0,0 +1,22 @@
+/**
+ * difference / without / differenceBy 共享内核。
+ *
+ * @internal
+ */
+export default function baseDifference(array, values, iteratee) {
+    if (!array.length) {
+        return [];
+    }
+    const mappedValues = iteratee ? values.map(iteratee) : values;
+    const result = [];
+    outer: for (const value of array) {
+        const computed = iteratee ? iteratee(value) : value;
+        for (const excluded of mappedValues) {
+            if (Object.is(excluded, computed)) {
+                continue outer;
+            }
+        }
+        result.push(value);
+    }
+    return result;
+}

package/dist/esm/_internal/baseExtremum.js

@@ -0,0 +1,28 @@
+import identity from './identity';
+import { compareAsc } from './compareValues';
+function isComparable(value) {
+    return value != null && typeof value !== 'symbol';
+}
+/**
+ * min / max 共享内核，对齐 Lodash baseExtremum。
+ *
+ * @internal
+ */
+export default function baseExtremum(array, iteratee = identity, preferMax) {
+    let result;
+    let computedResult;
+    for (const value of array) {
+        const current = iteratee(value);
+        const shouldUpdate = current != null &&
+            (computedResult === undefined
+                ? isComparable(current)
+                : preferMax
+                    ? compareAsc(current, computedResult) > 0
+                    : compareAsc(current, computedResult) < 0);
+        if (shouldUpdate) {
+            result = value;
+            computedResult = current;
+        }
+    }
+    return result;
+}

package/dist/esm/_internal/baseExtremumBy.js

@@ -0,0 +1,57 @@
+import baseIteratee from './baseIteratee';
+import { compareAsc } from './compareValues';
+import isArrayLike from './isArrayLike';
+/**
+ * 按 iteratee 返回值查找最大或最小元素。
+ *
+ * @internal
+ */
+export default function baseExtremumBy(collection, iteratee, preferMax) {
+    var _a;
+    const resolvedIteratee = baseIteratee(iteratee);
+    let result;
+    let computedResult;
+    const compare = (value, indexOrKey, coll) => {
+        const computed = resolvedIteratee(value, indexOrKey, coll);
+        if (computedResult === undefined) {
+            result = value;
+            computedResult = computed;
+            return;
+        }
+        const compared = compareAsc(computed, computedResult);
+        if (preferMax ? compared > 0 : compared < 0) {
+            result = value;
+            computedResult = computed;
+        }
+    };
+    if (collection == null) {
+        return undefined;
+    }
+    if (typeof collection === 'string') {
+        const chars = [...collection];
+        for (let index = 0; index < chars.length; index++) {
+            compare(chars[index], index, collection);
+        }
+        return result;
+    }
+    if (Array.isArray(collection)) {
+        for (let index = 0; index < collection.length; index++) {
+            compare(collection[index], index, collection);
+        }
+        return result;
+    }
+    if (isArrayLike(collection)) {
+        const arrayLike = collection;
+        const length = (_a = arrayLike.length) !== null && _a !== void 0 ? _a : 0;
+        for (let index = 0; index < length; index++) {
+            compare(arrayLike[index], index, collection);
+        }
+        return result;
+    }
+    if (typeof collection === 'object') {
+        for (const key of Object.keys(collection)) {
+            compare(collection[key], key, collection);
+        }
+    }
+    return result;
+}

package/dist/esm/_internal/baseFilter.js

@@ -0,0 +1,55 @@
+import isArrayLike from './isArrayLike';
+import baseIteratee from './baseIteratee';
+/**
+ * 遍历集合并保留 predicate 为真值的元素，语义对齐 Lodash filter。
+ *
+ * @internal
+ */
+export default function baseFilter(collection, predicate = baseIteratee()) {
+    var _a;
+    const resolvedPredicate = baseIteratee(predicate);
+    const result = [];
+    if (collection == null) {
+        return result;
+    }
+    if (typeof collection === 'string') {
+        const chars = [...collection];
+        for (let index = 0; index < chars.length; index++) {
+            const value = chars[index];
+            if (resolvedPredicate(value, index, collection)) {
+                result.push(value);
+            }
+        }
+        return result;
+    }
+    if (Array.isArray(collection)) {
+        for (let index = 0; index < collection.length; index++) {
+            const value = collection[index];
+            if (resolvedPredicate(value, index, collection)) {
+                result.push(value);
+            }
+        }
+        return result;
+    }
+    if (isArrayLike(collection)) {
+        const arrayLike = collection;
+        const length = (_a = arrayLike.length) !== null && _a !== void 0 ? _a : 0;
+        for (let index = 0; index < length; index++) {
+            const value = arrayLike[index];
+            if (resolvedPredicate(value, index, collection)) {
+                result.push(value);
+            }
+        }
+        return result;
+    }
+    if (typeof collection === 'object') {
+        const keys = Object.keys(collection);
+        for (const key of keys) {
+            const value = collection[key];
+            if (resolvedPredicate(value, key, collection)) {
+                result.push(value);
+            }
+        }
+    }
+    return result;
+}