zhiaiwan-utils 1.0.3

package/dist/esm/_internal/validateFieldRule.js

@@ -0,0 +1,132 @@
+import isArray from '../verify/isArray';
+import isBoolean from '../verify/isBoolean';
+import isDate from '../verify/isDate';
+import isInteger from '../verify/isInteger';
+import isNumber from '../verify/isNumber';
+import isPlainObject from './isPlainObject';
+import isString from '../verify/isString';
+import isEmptyValue from './isEmptyValue';
+const EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+const URL_PATTERN = /^(https?:\/\/|ftp:\/\/)/i;
+function resolveMessage(value, rule, fallback) {
+    var _a;
+    if (typeof rule.message === 'function') {
+        return rule.message(value, rule);
+    }
+    return (_a = rule.message) !== null && _a !== void 0 ? _a : fallback;
+}
+function checkType(value, type) {
+    switch (type) {
+        case 'string':
+            return isString(value);
+        case 'number':
+            return isNumber(value);
+        case 'boolean':
+            return isBoolean(value);
+        case 'integer':
+            return isInteger(value);
+        case 'array':
+            return isArray(value);
+        case 'object':
+            return isPlainObject(value);
+        case 'email':
+            return isString(value) && EMAIL_PATTERN.test(value);
+        case 'url':
+            return isString(value) && URL_PATTERN.test(value);
+        case 'date':
+            return isDate(value);
+        default:
+            return true;
+    }
+}
+function checkLenMinMax(value, rule) {
+    const { len, min, max, type } = rule;
+    if (len == null && min == null && max == null) {
+        return null;
+    }
+    let size;
+    let numericValue = null;
+    if (type === 'number' || type === 'integer' || (type == null && isNumber(value))) {
+        if (!isNumber(value)) {
+            return null;
+        }
+        numericValue = value;
+        size = value;
+    }
+    else if (isString(value) || isArray(value)) {
+        size = value.length;
+    }
+    else {
+        return null;
+    }
+    if (len != null && size !== len) {
+        return resolveMessage(value, rule, `长度须为 ${len}`);
+    }
+    if (min != null) {
+        const actual = numericValue !== null && numericValue !== void 0 ? numericValue : size;
+        if (actual < min) {
+            return resolveMessage(value, rule, `不能小于 ${min}`);
+        }
+    }
+    if (max != null) {
+        const actual = numericValue !== null && numericValue !== void 0 ? numericValue : size;
+        if (actual > max) {
+            return resolveMessage(value, rule, `不能大于 ${max}`);
+        }
+    }
+    return null;
+}
+function resolveValidatorResult(value, rule, result) {
+    if (result === true || result === undefined || result === '') {
+        return null;
+    }
+    if (typeof result === 'string') {
+        return result;
+    }
+    if (result === false) {
+        return resolveMessage(value, rule, '校验失败');
+    }
+    return null;
+}
+function runValidator(ctx, rule) {
+    const raw = rule.validator(ctx);
+    if (raw instanceof Promise) {
+        return raw.then((result) => resolveValidatorResult(ctx.value, rule, result));
+    }
+    return resolveValidatorResult(ctx.value, rule, raw);
+}
+/**
+ * 执行单条字段规则，失败时返回错误文案，通过时返回 null。
+ *
+ * @internal
+ */
+export default function validateFieldRule(ctx) {
+    const { value, rule } = ctx;
+    const empty = isEmptyValue(value);
+    if (rule.required && empty) {
+        return resolveMessage(value, rule, '该字段必填');
+    }
+    if (!rule.required && empty) {
+        if (rule.validator) {
+            return runValidator(ctx, rule);
+        }
+        return null;
+    }
+    if (rule.type && !checkType(value, rule.type)) {
+        return resolveMessage(value, rule, `类型应为 ${rule.type}`);
+    }
+    if (rule.enum && !rule.enum.includes(value)) {
+        return resolveMessage(value, rule, '值不在允许的范围内');
+    }
+    const lenError = checkLenMinMax(value, rule);
+    if (lenError) {
+        return lenError;
+    }
+    if (rule.pattern && !rule.pattern.test(String(value))) {
+        return resolveMessage(value, rule, '格式不正确');
+    }
+    if (rule.validator) {
+        return runValidator(ctx, rule);
+    }
+    return null;
+}

package/dist/esm/_internal/words.js

@@ -0,0 +1,10 @@
+const DEFAULT_WORD_PATTERN = /[A-Z]?[a-z\d]+|[A-Z]+(?![a-z])|\d+/g;
+/**
+ * 拆分字符串为单词数组，对齐 Lodash words 默认 pattern。
+ *
+ * @internal
+ */
+export default function words(string) {
+    var _a;
+    return (_a = string.match(DEFAULT_WORD_PATTERN)) !== null && _a !== void 0 ? _a : [];
+}

package/dist/esm/array/chunk.js

@@ -0,0 +1,31 @@
+import toInteger from '../_internal/toInteger';
+/**
+ * 将 array 按指定长度切分为多个子数组。
+ *
+ * @param array - 待切分的数组
+ * @param size - 每个分块的长度，默认 1
+ * @returns 分块后的二维数组
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.chunk(['a', 'b', 'c', 'd'], 2);
+ * // => [['a', 'b'], ['c', 'd']]
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function chunk(array, size = 1) {
+    var _a;
+    const resolvedSize = Math.max(toInteger(size), 0);
+    const length = (_a = array === null || array === void 0 ? void 0 : array.length) !== null && _a !== void 0 ? _a : 0;
+    if (!length || resolvedSize < 1) {
+        return [];
+    }
+    const result = [];
+    let index = 0;
+    while (index < length) {
+        result.push(array.slice(index, (index += resolvedSize)));
+    }
+    return result;
+}

package/dist/esm/array/compact.js

@@ -0,0 +1,31 @@
+/**
+ * 移除数组中所有假值（`false`、`null`、`0`、`""`、`undefined`、`NaN`）。
+ *
+ * @param array - 待处理的数组
+ * @returns 过滤后的新数组
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.compact([0, 1, false, 2, '', 3]);
+ * // => [1, 2, 3]
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function compact(array) {
+    var _a;
+    if (array == null) {
+        return [];
+    }
+    const length = (_a = array.length) !== null && _a !== void 0 ? _a : 0;
+    const result = [];
+    const source = array;
+    for (let index = 0; index < length; index++) {
+        const value = source[index];
+        if (value) {
+            result.push(value);
+        }
+    }
+    return result;
+}

package/dist/esm/array/concat.js

@@ -0,0 +1,34 @@
+/**
+ * 创建一个新数组，按顺序拼接各参数；数组参数会展开一层。
+ *
+ * @param array - 第一个数组或元素
+ * @param values - 后续数组或元素
+ * @returns 拼接后的新数组
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.concat([1], 2, [3], [[4]]);
+ * // => [1, 2, 3, [4]]
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function concat(array, ...values) {
+    const result = [];
+    if (Array.isArray(array)) {
+        result.push(...array);
+    }
+    else if (array !== undefined) {
+        result.push(array);
+    }
+    for (const value of values) {
+        if (Array.isArray(value)) {
+            result.push(...value);
+        }
+        else {
+            result.push(value);
+        }
+    }
+    return result;
+}

package/dist/esm/array/difference.js

@@ -0,0 +1,38 @@
+import baseDifference from '../_internal/baseDifference';
+import isArrayLikeObject from '../_internal/isArrayLikeObject';
+function flattenValueArrays(values) {
+    var _a;
+    const result = [];
+    for (const value of values) {
+        if (isArrayLikeObject(value)) {
+            const arrayLike = value;
+            const length = (_a = arrayLike.length) !== null && _a !== void 0 ? _a : 0;
+            for (let index = 0; index < length; index++) {
+                result.push(arrayLike[index]);
+            }
+        }
+    }
+    return result;
+}
+/**
+ * 创建按 SameValueZero 排除其余数组元素后的新数组。
+ *
+ * @param array - 待处理的数组
+ * @param values - 要排除的数组（可传多个）
+ * @returns 差集数组
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.difference([2, 1], [2, 3]);
+ * // => [1]
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function difference(array, ...values) {
+    if (!isArrayLikeObject(array)) {
+        return [];
+    }
+    return baseDifference(array, flattenValueArrays(values));
+}

package/dist/esm/array/differenceBy.js

@@ -0,0 +1,49 @@
+import baseDifference from '../_internal/baseDifference';
+import baseIteratee from '../_internal/baseIteratee';
+import isArrayLikeObject from '../_internal/isArrayLikeObject';
+function flattenValueArrays(values) {
+    var _a;
+    const result = [];
+    for (const value of values) {
+        if (isArrayLikeObject(value)) {
+            const arrayLike = value;
+            const length = (_a = arrayLike.length) !== null && _a !== void 0 ? _a : 0;
+            for (let index = 0; index < length; index++) {
+                result.push(arrayLike[index]);
+            }
+        }
+    }
+    return result;
+}
+/**
+ * 类似 difference，但按 iteratee 返回值比较排除项。
+ *
+ * @param array - 待处理的数组
+ * @param values - 要排除的数组（可传多个），最后一项可为 iteratee
+ * @param iteratee - 比较依据的函数或简写
+ * @returns 差集数组
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor);
+ * // => [1.2]
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function differenceBy(array, ...args) {
+    if (!isArrayLikeObject(array)) {
+        return [];
+    }
+    let iteratee = baseIteratee();
+    let valueGroups = args;
+    const last = valueGroups[valueGroups.length - 1];
+    if (!isArrayLikeObject(last)) {
+        iteratee = last;
+        valueGroups = valueGroups.slice(0, -1);
+    }
+    const resolvedIteratee = baseIteratee(iteratee);
+    const mapper = (value) => resolvedIteratee(value, 0, array);
+    return baseDifference(array, flattenValueArrays(valueGroups), mapper);
+}

package/dist/esm/array/drop.js

@@ -0,0 +1,25 @@
+import toInteger from '../_internal/toInteger';
+/**
+ * 从 array 头部跳过 n 个元素。
+ *
+ * @param array - 待处理的数组
+ * @param n - 跳过数量，默认 1
+ * @returns 剩余元素组成的新数组
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.drop([1, 2, 3], 2);
+ * // => [3]
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function drop(array, n = 1) {
+    if (!(array === null || array === void 0 ? void 0 : array.length)) {
+        return [];
+    }
+    const resolved = n === undefined ? 1 : toInteger(n);
+    const start = resolved < 0 ? 0 : resolved;
+    return array.slice(start);
+}

package/dist/esm/array/each.js

@@ -0,0 +1,18 @@
+import forEach from './forEach';
+/**
+ * `forEach` 的别名，遍历集合元素；iteratee 返回 `false` 时立即停止。
+ *
+ * @param collection - 待遍历的集合（数组、对象、字符串或类数组）
+ * @param iteratee - 每次迭代调用的函数，接收 `(value, index|key, collection)`
+ * @returns 原集合
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.each([1, 2, 3], (n) => console.log(n));
+ * // => [1, 2, 3]
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default forEach;

package/dist/esm/array/every.js

@@ -0,0 +1,63 @@
+import baseIteratee from '../_internal/baseIteratee';
+import isArrayLike from '../_internal/isArrayLike';
+/**
+ * 检查 collection 中是否所有元素均满足 predicate。
+ *
+ * @param collection - 待检查的集合
+ * @param predicate - 每次迭代调用的断言函数或简写
+ * @returns 若全部通过返回 true；空集合返回 true
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.every([true, 1, null, 'yes'], Boolean);
+ * // => false
+ *
+ * zhiaiwanUtils.every([], Boolean);
+ * // => true
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function every(collection, predicate = baseIteratee()) {
+    var _a;
+    const resolvedPredicate = baseIteratee(predicate);
+    if (collection == null) {
+        return true;
+    }
+    if (typeof collection === 'string') {
+        const chars = [...collection];
+        for (let index = 0; index < chars.length; index++) {
+            if (!resolvedPredicate(chars[index], index, collection)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (Array.isArray(collection)) {
+        for (let index = 0; index < collection.length; index++) {
+            if (!resolvedPredicate(collection[index], index, collection)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (isArrayLike(collection)) {
+        const arrayLike = collection;
+        const length = (_a = arrayLike.length) !== null && _a !== void 0 ? _a : 0;
+        for (let index = 0; index < length; index++) {
+            if (!resolvedPredicate(arrayLike[index], index, collection)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (typeof collection === 'object') {
+        for (const key of Object.keys(collection)) {
+            if (!resolvedPredicate(collection[key], key, collection)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}

package/dist/esm/array/filter.js

@@ -0,0 +1,20 @@
+import baseFilter from '../_internal/baseFilter';
+/**
+ * 遍历 collection，返回 predicate 为真值的所有元素组成的新数组。
+ *
+ * @param collection - 待筛选的集合
+ * @param predicate - 每次迭代调用的断言函数或简写
+ * @returns 筛选后的新数组
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.filter([1, 2, 3, 4], (n) => n % 2 === 0);
+ * // => [2, 4]
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function filter(collection, predicate) {
+    return baseFilter(collection, predicate);
+}

package/dist/esm/array/find.js

@@ -0,0 +1,26 @@
+import { baseFind } from '../_internal/baseFind';
+/**
+ * 返回集合中第一个满足 `predicate` 的元素。
+ *
+ * @param collection - 待查找的集合（数组、对象、字符串或类数组）
+ * @param predicate - 匹配函数，接收 `(value, index|key, collection)`，默认匹配真值
+ * @param fromIndex - 类数组的起始下标
+ * @returns 匹配元素，未找到时返回 `undefined`
+ *
+ * @example
+ * ```ts
+ * const users = [
+ *   { user: 'barney', age: 36, active: true },
+ *   { user: 'fred', age: 40, active: false },
+ * ];
+ *
+ * find(users, ({ age }) => age < 40);
+ * // => { user: 'barney', age: 36, active: true }
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function find(collection, predicate, fromIndex = 0) {
+    return baseFind(collection, predicate, fromIndex, false);
+}

package/dist/esm/array/findIndex.js

@@ -0,0 +1,21 @@
+import { baseFindIndex } from '../_internal/baseFind';
+/**
+ * 返回数组中第一个满足 `predicate` 的下标。
+ *
+ * @param array - 待查找的数组或类数组
+ * @param predicate - 匹配函数，接收 `(value, index, array)`，默认匹配真值
+ * @param fromIndex - 起始下标
+ * @returns 匹配下标，未找到时返回 `-1`
+ *
+ * @example
+ * ```ts
+ * findIndex([1, 2, 3, 4], (n) => n % 2 === 0);
+ * // => 1
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function findIndex(array, predicate, fromIndex = 0) {
+    return baseFindIndex(array, predicate, fromIndex, false);
+}

package/dist/esm/array/findLast.js

@@ -0,0 +1,21 @@
+import { baseFind } from '../_internal/baseFind';
+/**
+ * 从右往左返回集合中最后一个满足 `predicate` 的元素。
+ *
+ * @param collection - 待查找的集合（数组、对象、字符串或类数组）
+ * @param predicate - 匹配函数，接收 `(value, index|key, collection)`，默认匹配真值
+ * @param fromIndex - 类数组的起始下标
+ * @returns 匹配元素，未找到时返回 `undefined`
+ *
+ * @example
+ * ```ts
+ * findLast([1, 2, 3, 4], (n) => n % 2 === 1);
+ * // => 3
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function findLast(collection, predicate, fromIndex) {
+    return baseFind(collection, predicate, fromIndex, true);
+}

package/dist/esm/array/findLastIndex.js

@@ -0,0 +1,21 @@
+import { baseFindIndex } from '../_internal/baseFind';
+/**
+ * 从右往左返回数组中最后一个满足 `predicate` 的下标。
+ *
+ * @param array - 待查找的数组或类数组
+ * @param predicate - 匹配函数，接收 `(value, index, array)`，默认匹配真值
+ * @param fromIndex - 起始下标
+ * @returns 匹配下标，未找到时返回 `-1`
+ *
+ * @example
+ * ```ts
+ * findLastIndex([1, 2, 3, 4], (n) => n % 2 === 1);
+ * // => 2
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function findLastIndex(array, predicate, fromIndex) {
+    return baseFindIndex(array, predicate, fromIndex, true);
+}

package/dist/esm/array/flatten.js

@@ -0,0 +1,21 @@
+import baseFlatten from '../_internal/baseFlatten';
+/**
+ * 将 array 展平一层。
+ *
+ * @param array - 待展平的数组
+ * @returns 展平后的新数组
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.flatten([1, [2, [3, [4]], 5]]);
+ * // => [1, 2, [3, [4]], 5]
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function flatten(array) {
+    var _a;
+    const length = array == null ? 0 : (_a = array.length) !== null && _a !== void 0 ? _a : 0;
+    return length ? baseFlatten(array, 1) : [];
+}

package/dist/esm/array/flattenDeep.js

@@ -0,0 +1,22 @@
+import baseFlatten from '../_internal/baseFlatten';
+const INFINITY = 1 / 0;
+/**
+ * 递归展平 array 的所有嵌套层级。
+ *
+ * @param array - 待展平的数组
+ * @returns 完全展平后的新数组
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.flattenDeep([1, [2, [3, [4]], 5]]);
+ * // => [1, 2, 3, 4, 5]
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function flattenDeep(array) {
+    var _a;
+    const length = array == null ? 0 : (_a = array.length) !== null && _a !== void 0 ? _a : 0;
+    return length ? baseFlatten(array, INFINITY) : [];
+}

package/dist/esm/array/forEach.js

@@ -0,0 +1,26 @@
+import baseForEach from '../_internal/baseForEach';
+/**
+ * 遍历集合元素；iteratee 返回 `false` 时立即停止。
+ *
+ * @param collection - 待遍历的集合（数组、对象、字符串或类数组）
+ * @param iteratee - 每次迭代调用的函数，接收 `(value, index|key, collection)`
+ * @returns 原集合
+ *
+ * @example
+ * ```ts
+ * forEach([1, 2, 3], (n) => {
+ *   if (n === 2) return false;
+ *   console.log(n);
+ * });
+ * // 输出 1
+ *
+ * forEach({ a: 1, b: 2 }, (value, key) => console.log(key, value));
+ * // => { a: 1, b: 2 }
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function forEach(collection, iteratee) {
+    return baseForEach(collection, iteratee, false);
+}

package/dist/esm/array/forEachRight.js

@@ -0,0 +1,23 @@
+import baseForEach from '../_internal/baseForEach';
+/**
+ * 从右向左遍历集合元素；iteratee 返回 `false` 时立即停止。
+ *
+ * @param collection - 待遍历的集合（数组、对象、字符串或类数组）
+ * @param iteratee - 每次迭代调用的函数，接收 `(value, index|key, collection)`
+ * @returns 原集合
+ *
+ * @example
+ * ```ts
+ * forEachRight([1, 2, 3], (n) => console.log(n));
+ * // 输出 3, 2, 1
+ *
+ * forEachRight({ a: 1, b: 2 }, (value, key) => console.log(key, value));
+ * // 输出 b 2, a 1
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function forEachRight(collection, iteratee) {
+    return baseForEach(collection, iteratee, true);
+}