zhiaiwan-utils 1.0.3

package/dist/esm/array/groupBy.js

@@ -0,0 +1,61 @@
+import baseIteratee from '../_internal/baseIteratee';
+import isArrayLike from '../_internal/isArrayLike';
+/**
+ * 根据 iteratee 返回值对 collection 分组，返回键为分组值、值为元素数组的对象。
+ *
+ * @param collection - 待分组的集合
+ * @param iteratee - 分组依据的函数或简写
+ * @returns 分组结果
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.groupBy([6.1, 4.2, 6.3], Math.floor);
+ * // => { '4': [4.2], '6': [6.1, 6.3] }
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function groupBy(collection, iteratee = baseIteratee()) {
+    var _a;
+    const resolvedIteratee = baseIteratee(iteratee);
+    const result = {};
+    const append = (value, indexOrKey, coll) => {
+        const key = resolvedIteratee(value, indexOrKey, coll);
+        const buckets = result;
+        if (!Object.prototype.hasOwnProperty.call(buckets, key)) {
+            buckets[key] = [];
+        }
+        buckets[key].push(value);
+    };
+    if (collection == null) {
+        return result;
+    }
+    if (typeof collection === 'string') {
+        const chars = [...collection];
+        for (let index = 0; index < chars.length; index++) {
+            append(chars[index], index, collection);
+        }
+        return result;
+    }
+    if (Array.isArray(collection)) {
+        for (let index = 0; index < collection.length; index++) {
+            append(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++) {
+            append(arrayLike[index], index, collection);
+        }
+        return result;
+    }
+    if (typeof collection === 'object') {
+        for (const key of Object.keys(collection)) {
+            append(collection[key], key, collection);
+        }
+    }
+    return result;
+}

package/dist/esm/array/head.js

@@ -0,0 +1,18 @@
+/**
+ * 获取 array 的第一个元素。
+ *
+ * @param array - 待查询的数组
+ * @returns 第一个元素
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.head([1, 2, 3]);
+ * // => 1
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function head(array) {
+    return (array === null || array === void 0 ? void 0 : array.length) ? array[0] : undefined;
+}

package/dist/esm/array/includes.js

@@ -0,0 +1,54 @@
+import isArrayLike from '../_internal/isArrayLike';
+import { baseValues } from '../_internal/baseCollectionKeys';
+function resolveFromIndex(fromIndex, length) {
+    return fromIndex < 0 ? Math.max(length + fromIndex, 0) : fromIndex;
+}
+function includesInArrayLike(collection, value, fromIndex) {
+    var _a;
+    const length = (_a = collection.length) !== null && _a !== void 0 ? _a : 0;
+    const start = resolveFromIndex(fromIndex, length);
+    for (let index = start; index < length; index++) {
+        if (Object.is(collection[index], value)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * 检查 collection 是否包含 value；数组与字符串支持 fromIndex。
+ *
+ * @param collection - 待检查的集合
+ * @param value - 要查找的值
+ * @param fromIndex - 数组或字符串的起始下标
+ * @returns 若包含返回 true，否则返回 false
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.includes([1, 2, 3], 2);
+ * // => true
+ *
+ * zhiaiwanUtils.includes({ a: 1, b: 2 }, 2);
+ * // => true
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function includes(collection, value, fromIndex = 0) {
+    if (collection == null) {
+        return false;
+    }
+    if (typeof collection === 'string') {
+        return includesInArrayLike(collection, value, fromIndex);
+    }
+    if (Array.isArray(collection)) {
+        return includesInArrayLike(collection, value, fromIndex);
+    }
+    if (isArrayLike(collection)) {
+        return includesInArrayLike(collection, value, fromIndex);
+    }
+    if (typeof collection === 'object') {
+        return baseValues(collection).some((item) => Object.is(item, value));
+    }
+    return false;
+}

package/dist/esm/array/index.js

@@ -0,0 +1,43 @@
+export { default as forEach } from './forEach';
+export { default as forEachRight } from './forEachRight';
+export { default as each } from './each';
+export { default as find } from './find';
+export { default as findLast } from './findLast';
+export { default as findIndex } from './findIndex';
+export { default as findLastIndex } from './findLastIndex';
+export { default as filter } from './filter';
+export { default as map } from './map';
+export { default as union } from './union';
+export { default as groupBy } from './groupBy';
+export { default as orderBy } from './orderBy';
+export { default as uniqBy } from './uniqBy';
+export { default as concat } from './concat';
+export { default as includes } from './includes';
+export { default as intersection } from './intersection';
+export { default as maxBy } from './maxBy';
+export { default as minBy } from './minBy';
+export { default as sortBy } from './sortBy';
+export { default as some } from './some';
+export { default as sum } from './sum';
+export { default as sumBy } from './sumBy';
+export { default as meanBy } from './meanBy';
+export { default as partition } from './partition';
+export { default as every } from './every';
+export { default as reduce } from './reduce';
+export { default as reduceRight } from './reduceRight';
+export { default as compact } from './compact';
+export { default as flatten } from './flatten';
+export { default as flattenDeep } from './flattenDeep';
+export { default as uniq } from './uniq';
+export { default as keyBy } from './keyBy';
+export { default as chunk } from './chunk';
+export { default as difference } from './difference';
+export { default as differenceBy } from './differenceBy';
+export { default as without } from './without';
+export { default as head } from './head';
+export { default as last } from './last';
+export { default as take } from './take';
+export { default as drop } from './drop';
+export { default as min } from './min';
+export { default as max } from './max';
+export { default as mean } from './mean';

package/dist/esm/array/intersection.js

@@ -0,0 +1,48 @@
+function arrayIncludes(array, value) {
+    for (const item of array) {
+        if (Object.is(item, value)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * 创建各数组按 SameValueZero 取交集后的新数组，保留首次出现顺序。
+ *
+ * @param arrays - 一个或多个数组
+ * @returns 交集数组
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.intersection([2, 1], [2, 3]);
+ * // => [2]
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function intersection(...arrays) {
+    if (!arrays.length) {
+        return [];
+    }
+    const first = arrays[0];
+    if (!Array.isArray(first)) {
+        return [];
+    }
+    const rest = arrays.slice(1).filter(Array.isArray);
+    if (!rest.length) {
+        return [...first];
+    }
+    const seen = new Set();
+    const result = [];
+    for (const value of first) {
+        if (seen.has(value)) {
+            continue;
+        }
+        if (rest.every((array) => arrayIncludes(array, value))) {
+            result.push(value);
+            seen.add(value);
+        }
+    }
+    return result;
+}

package/dist/esm/array/keyBy.js

@@ -0,0 +1,73 @@
+import baseIteratee from '../_internal/baseIteratee';
+import isArrayLike from '../_internal/isArrayLike';
+/**
+ * 根据 iteratee 返回值将 collection 转为键值对象，同键保留最后一个元素。
+ *
+ * @param collection - 待转换的集合
+ * @param iteratee - 生成键名的函数或简写
+ * @returns 键值映射对象
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.keyBy(
+ *   [
+ *     { dir: 'left', code: 97 },
+ *     { dir: 'right', code: 100 },
+ *   ],
+ *   'dir',
+ * );
+ * // => { left: { dir: 'left', code: 97 }, right: { dir: 'right', code: 100 } }
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function keyBy(collection, iteratee = baseIteratee()) {
+    var _a;
+    const resolvedIteratee = baseIteratee(iteratee);
+    const result = {};
+    const assign = (value, indexOrKey, coll) => {
+        const key = resolvedIteratee(value, indexOrKey, coll);
+        const buckets = result;
+        if (key === '__proto__') {
+            Object.defineProperty(buckets, key, {
+                configurable: true,
+                enumerable: true,
+                value,
+                writable: true,
+            });
+            return;
+        }
+        buckets[key] = value;
+    };
+    if (collection == null) {
+        return result;
+    }
+    if (typeof collection === 'string') {
+        const chars = [...collection];
+        for (let index = 0; index < chars.length; index++) {
+            assign(chars[index], index, collection);
+        }
+        return result;
+    }
+    if (Array.isArray(collection)) {
+        for (let index = 0; index < collection.length; index++) {
+            assign(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++) {
+            assign(arrayLike[index], index, collection);
+        }
+        return result;
+    }
+    if (typeof collection === 'object') {
+        for (const key of Object.keys(collection)) {
+            assign(collection[key], key, collection);
+        }
+    }
+    return result;
+}

package/dist/esm/array/last.js

@@ -0,0 +1,20 @@
+/**
+ * 获取 array 的最后一个元素。
+ *
+ * @param array - 待查询的数组
+ * @returns 最后一个元素
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.last([1, 2, 3]);
+ * // => 3
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function last(array) {
+    var _a;
+    const length = (_a = array === null || array === void 0 ? void 0 : array.length) !== null && _a !== void 0 ? _a : 0;
+    return length ? array[length - 1] : undefined;
+}

package/dist/esm/array/map.js

@@ -0,0 +1,20 @@
+import baseMap from '../_internal/baseMap';
+/**
+ * 遍历 collection，对每个元素执行 iteratee 并返回结果组成的新数组。
+ *
+ * @param collection - 待映射的集合
+ * @param iteratee - 每次迭代调用的函数或简写
+ * @returns 映射后的新数组
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.map([1, 2, 3], (n) => n * 2);
+ * // => [2, 4, 6]
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function map(collection, iteratee) {
+    return baseMap(collection, iteratee);
+}

package/dist/esm/array/max.js

@@ -0,0 +1,19 @@
+import baseExtremum from '../_internal/baseExtremum';
+/**
+ * 计算 array 中的最大值。
+ *
+ * @param array - 待计算的数组
+ * @returns 最大值；空数组返回 undefined
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.max([4, 2, 8, 6]);
+ * // => 8
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function max(array) {
+    return (array === null || array === void 0 ? void 0 : array.length) ? baseExtremum(array, undefined, true) : undefined;
+}

package/dist/esm/array/maxBy.js

@@ -0,0 +1,21 @@
+import baseExtremumBy from '../_internal/baseExtremumBy';
+import baseIteratee from '../_internal/baseIteratee';
+/**
+ * 返回 iteratee 返回值最大的元素。
+ *
+ * @param collection - 待查找的集合
+ * @param iteratee - 比较依据的函数或简写
+ * @returns 最大值对应的元素
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.maxBy([{ n: 1 }, { n: 2 }], 'n');
+ * // => { n: 2 }
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function maxBy(collection, iteratee = baseIteratee()) {
+    return baseExtremumBy(collection, iteratee, true);
+}

package/dist/esm/array/mean.js

@@ -0,0 +1,21 @@
+import baseSum from '../_internal/baseSum';
+/**
+ * 计算 array 数值的平均值。
+ *
+ * @param array - 待计算的数组
+ * @returns 平均值；空数组返回 NaN
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.mean([4, 2, 8, 6]);
+ * // => 5
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function mean(array) {
+    var _a;
+    const length = (_a = array === null || array === void 0 ? void 0 : array.length) !== null && _a !== void 0 ? _a : 0;
+    return length ? baseSum(array) / length : Number.NaN;
+}

package/dist/esm/array/meanBy.js

@@ -0,0 +1,24 @@
+import sumBy from './sumBy';
+import baseIteratee from '../_internal/baseIteratee';
+/**
+ * 计算 array 中 iteratee 返回值的平均值。
+ *
+ * @param array - 待计算的数组
+ * @param iteratee - 每次迭代调用的函数或简写
+ * @returns 平均值；空数组返回 NaN
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.meanBy([{ n: 4 }, { n: 2 }, { n: 8 }], 'n');
+ * // => 4.666666666666667
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function meanBy(array, iteratee = baseIteratee()) {
+    if (!Array.isArray(array) || array.length === 0) {
+        return Number.NaN;
+    }
+    return sumBy(array, iteratee) / array.length;
+}

package/dist/esm/array/min.js

@@ -0,0 +1,19 @@
+import baseExtremum from '../_internal/baseExtremum';
+/**
+ * 计算 array 中的最小值。
+ *
+ * @param array - 待计算的数组
+ * @returns 最小值；空数组返回 undefined
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.min([4, 2, 8, 6]);
+ * // => 2
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function min(array) {
+    return (array === null || array === void 0 ? void 0 : array.length) ? baseExtremum(array, undefined, false) : undefined;
+}

package/dist/esm/array/minBy.js

@@ -0,0 +1,21 @@
+import baseExtremumBy from '../_internal/baseExtremumBy';
+import baseIteratee from '../_internal/baseIteratee';
+/**
+ * 返回 iteratee 返回值最小的元素。
+ *
+ * @param collection - 待查找的集合
+ * @param iteratee - 比较依据的函数或简写
+ * @returns 最小值对应的元素
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.minBy([{ n: 1 }, { n: 2 }], 'n');
+ * // => { n: 1 }
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function minBy(collection, iteratee = baseIteratee()) {
+    return baseExtremumBy(collection, iteratee, false);
+}

package/dist/esm/array/orderBy.js

@@ -0,0 +1,89 @@
+import baseIteratee from '../_internal/baseIteratee';
+import { compareAsc } from '../_internal/compareValues';
+import isArrayLike from '../_internal/isArrayLike';
+function iterateCollection(collection, iteratee) {
+    var _a;
+    if (collection == null) {
+        return;
+    }
+    if (typeof collection === 'string') {
+        const chars = [...collection];
+        for (let index = 0; index < chars.length; index++) {
+            iteratee(chars[index], index, collection);
+        }
+        return;
+    }
+    if (Array.isArray(collection)) {
+        for (let index = 0; index < collection.length; index++) {
+            iteratee(collection[index], index, collection);
+        }
+        return;
+    }
+    if (isArrayLike(collection)) {
+        const arrayLike = collection;
+        const length = (_a = arrayLike.length) !== null && _a !== void 0 ? _a : 0;
+        for (let index = 0; index < length; index++) {
+            iteratee(arrayLike[index], index, collection);
+        }
+        return;
+    }
+    if (typeof collection === 'object') {
+        for (const key of Object.keys(collection)) {
+            iteratee(collection[key], key, collection);
+        }
+    }
+}
+/**
+ * 按 iteratee 与 orders 对 collection 排序并返回新数组。
+ *
+ * @param collection - 待排序的集合
+ * @param iteratees - 排序依据的函数、简写或数组
+ * @param orders - 排序方向 `'asc'` 或 `'desc'`，可为数组
+ * @returns 排序后的新数组
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.orderBy(
+ *   [{ user: 'fred', age: 48 }, { user: 'barney', age: 34 }],
+ *   ['user', 'age'],
+ *   ['asc', 'desc'],
+ * );
+ * // => [{ user: 'barney', age: 34 }, { user: 'fred', age: 48 }]
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function orderBy(collection, iteratees = baseIteratee(), orders = 'asc') {
+    if (collection == null) {
+        return [];
+    }
+    const iterateeList = (Array.isArray(iteratees) ? iteratees : [iteratees]).map((item) => baseIteratee(item));
+    const orderList = Array.isArray(orders)
+        ? iterateeList.map((_, index) => { var _a; return (_a = orders[index]) !== null && _a !== void 0 ? _a : 'asc'; })
+        : iterateeList.map(() => orders);
+    const mapped = [];
+    let sortIndex = 0;
+    iterateCollection(collection, (value) => {
+        mapped.push({
+            criteria: iterateeList.map((iteratee) => iteratee(value, sortIndex, collection)),
+            index: sortIndex++,
+            value,
+        });
+    });
+    mapped.sort((left, right) => {
+        var _a;
+        for (let index = 0; index < iterateeList.length; index++) {
+            const order = (_a = orderList[index]) !== null && _a !== void 0 ? _a : 'asc';
+            let compared = compareAsc(left.criteria[index], right.criteria[index]);
+            if (order === 'desc') {
+                compared = -compared;
+            }
+            if (compared !== 0) {
+                return compared;
+            }
+        }
+        return left.index - right.index;
+    });
+    return mapped.map((item) => item.value);
+}

package/dist/esm/array/partition.js

@@ -0,0 +1,62 @@
+import baseIteratee from '../_internal/baseIteratee';
+import isArrayLike from '../_internal/isArrayLike';
+/**
+ * 根据 predicate 将 collection 拆分为 `[匹配项, 未匹配项]` 两个数组。
+ *
+ * @param collection - 待拆分的集合
+ * @param predicate - 每次迭代调用的断言函数或简写
+ * @returns 二元组 `[truthy, falsy]`
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.partition([1, 2, 3, 4], (n) => n % 2);
+ * // => [[1, 3], [2, 4]]
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function partition(collection, predicate = baseIteratee()) {
+    var _a;
+    const resolvedPredicate = baseIteratee(predicate);
+    const truthy = [];
+    const falsy = [];
+    const append = (value, indexOrKey, coll) => {
+        if (resolvedPredicate(value, indexOrKey, coll)) {
+            truthy.push(value);
+        }
+        else {
+            falsy.push(value);
+        }
+    };
+    if (collection == null) {
+        return [truthy, falsy];
+    }
+    if (typeof collection === 'string') {
+        const chars = [...collection];
+        for (let index = 0; index < chars.length; index++) {
+            append(chars[index], index, collection);
+        }
+        return [truthy, falsy];
+    }
+    if (Array.isArray(collection)) {
+        for (let index = 0; index < collection.length; index++) {
+            append(collection[index], index, collection);
+        }
+        return [truthy, falsy];
+    }
+    if (isArrayLike(collection)) {
+        const arrayLike = collection;
+        const length = (_a = arrayLike.length) !== null && _a !== void 0 ? _a : 0;
+        for (let index = 0; index < length; index++) {
+            append(arrayLike[index], index, collection);
+        }
+        return [truthy, falsy];
+    }
+    if (typeof collection === 'object') {
+        for (const key of Object.keys(collection)) {
+            append(collection[key], key, collection);
+        }
+    }
+    return [truthy, falsy];
+}

package/dist/esm/array/reduce.js

@@ -0,0 +1,24 @@
+import baseIteratee from '../_internal/baseIteratee';
+import baseReduce from '../_internal/baseReduce';
+/**
+ * 将 collection 累约为单个值。
+ *
+ * @param collection - 待遍历的集合
+ * @param iteratee - 每次迭代调用的函数或简写
+ * @param accumulator - 初始累加值；未提供时使用首个元素
+ * @returns 累加结果
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.reduce([1, 2], (sum, n) => sum + (n as number), 0);
+ * // => 3
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function reduce(collection, iteratee = baseIteratee(), accumulator) {
+    const initAccum = arguments.length < 3;
+    const resolvedIteratee = baseIteratee(iteratee);
+    return baseReduce(collection, resolvedIteratee, accumulator, initAccum, false);
+}

package/dist/esm/array/reduceRight.js

@@ -0,0 +1,24 @@
+import baseIteratee from '../_internal/baseIteratee';
+import baseReduce from '../_internal/baseReduce';
+/**
+ * 从右向左将 collection 累约为单个值。
+ *
+ * @param collection - 待遍历的集合
+ * @param iteratee - 每次迭代调用的函数或简写
+ * @param accumulator - 初始累加值；未提供时使用末尾元素
+ * @returns 累加结果
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.reduceRight([[0, 1], [2, 3], [4, 5]], (flat, other) => flat.concat(other), []);
+ * // => [4, 5, 2, 3, 0, 1]
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function reduceRight(collection, iteratee = baseIteratee(), accumulator) {
+    const initAccum = arguments.length < 3;
+    const resolvedIteratee = baseIteratee(iteratee);
+    return baseReduce(collection, resolvedIteratee, accumulator, initAccum, true);
+}