zhiaiwan-utils 1.0.3

package/dist/esm/util/identity.js

@@ -0,0 +1,17 @@
+import identity from '../_internal/identity';
+/**
+ * 返回第一个参数。
+ *
+ * @param value - 任意值
+ * @returns 传入的 value
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.identity(42);
+ * // => 42
+ * ```
+ *
+ * @since 1.0.0
+ * @category Util
+ */
+export default identity;

package/dist/esm/util/inRange.js

@@ -0,0 +1,38 @@
+function toFinite(value) {
+    const result = Number(value);
+    if (result === Infinity || result === -Infinity) {
+        return result < 0 ? -Number.MAX_VALUE : Number.MAX_VALUE;
+    }
+    return result === result ? result : 0;
+}
+/**
+ * 检查 number 是否位于 [start, end) 区间内。
+ *
+ * @param number - 待检查的值
+ * @param start - 区间起点；仅传两参时表示 end，start 置 0
+ * @param end - 区间终点（不含）
+ * @returns 是否在区间内
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.inRange(3, 2, 4);
+ * // => true
+ * ```
+ *
+ * @since 1.0.0
+ * @category Util
+ */
+export default function inRange(number, start, end) {
+    let resolvedStart = toFinite(start);
+    let resolvedEnd = end;
+    if (resolvedEnd === undefined) {
+        resolvedEnd = resolvedStart;
+        resolvedStart = 0;
+    }
+    else {
+        resolvedEnd = toFinite(resolvedEnd);
+    }
+    const resolvedNumber = Number(number);
+    return (resolvedNumber >= Math.min(resolvedStart, resolvedEnd) &&
+        resolvedNumber < Math.max(resolvedStart, resolvedEnd));
+}

package/dist/esm/util/index.js

@@ -0,0 +1,21 @@
+export { default as noop } from './noop';
+export { default as identity } from './identity';
+export { default as delay } from './delay';
+export { default as defer } from './defer';
+export { default as now } from './now';
+export { default as uniqueId } from './uniqueId';
+export { default as sleep } from './sleep';
+export { default as validateFields } from './validateFields';
+export { default as defaultTo } from './defaultTo';
+export { default as size } from './size';
+export { default as range } from './range';
+export { default as times } from './times';
+export { default as constant } from './constant';
+export { default as negate } from './negate';
+export { default as iteratee } from './iteratee';
+export { default as property } from './property';
+export { default as matches } from './matches';
+export { default as matchesProperty } from './matchesProperty';
+export { default as clamp } from './clamp';
+export { default as inRange } from './inRange';
+export { default as random } from './random';

package/dist/esm/util/iteratee.js

@@ -0,0 +1,24 @@
+import baseClone from '../_internal/baseClone';
+import baseIteratee from '../_internal/baseIteratee';
+/**
+ * 将 value 转为统一 iteratee 回调。
+ *
+ * @param func - 函数、属性路径、匹配对象或数组
+ * @returns 回调函数
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.iteratee('user')({ user: 'fred' });
+ * // => 'fred'
+ * ```
+ *
+ * @since 1.0.0
+ * @category Util
+ */
+export default function iteratee(func) {
+    if (typeof func === 'function') {
+        return func;
+    }
+    const cloned = func == null ? func : baseClone(func, new WeakMap(), { deep: true });
+    return baseIteratee(cloned);
+}

package/dist/esm/util/matches.js

@@ -0,0 +1,21 @@
+import baseClone from '../_internal/baseClone';
+import baseIsMatch from '../_internal/baseIsMatch';
+/**
+ * 创建部分深度匹配 source 属性的断言函数。
+ *
+ * @param source - 要匹配的属性对象
+ * @returns 断言函数
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.matches({ a: 1 })({ a: 1, b: 2 });
+ * // => true
+ * ```
+ *
+ * @since 1.0.0
+ * @category Util
+ */
+export default function matches(source) {
+    const cloned = baseClone(source, new WeakMap(), { deep: true });
+    return (object) => baseIsMatch(object, cloned);
+}

package/dist/esm/util/matchesProperty.js

@@ -0,0 +1,31 @@
+import baseClone from '../_internal/baseClone';
+import baseIsEqual from '../_internal/baseIsEqual';
+import { getPathValue, hasPath } from '../_internal/basePath';
+import toPath from '../_internal/toPath';
+/**
+ * 创建比较 object 指定路径值与 srcValue 的断言函数。
+ *
+ * @param path - 属性路径
+ * @param srcValue - 期望值
+ * @returns 断言函数
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.matchesProperty('a', 1)({ a: 1, b: 2 });
+ * // => true
+ * ```
+ *
+ * @since 1.0.0
+ * @category Util
+ */
+export default function matchesProperty(path, srcValue) {
+    const keys = toPath(path);
+    const cloned = baseClone(srcValue, new WeakMap(), { deep: true });
+    return (object) => {
+        const value = getPathValue(object, keys);
+        if (value === undefined && value === srcValue) {
+            return hasPath(object, keys);
+        }
+        return baseIsEqual(cloned, value, new WeakMap());
+    };
+}

package/dist/esm/util/negate.js

@@ -0,0 +1,22 @@
+const FUNC_ERROR_TEXT = 'Expected a function';
+/**
+ * 创建一个对 predicate 结果取反的函数。
+ *
+ * @param predicate - 原断言函数
+ * @returns 取反后的函数
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.negate(Boolean)(1);
+ * // => false
+ * ```
+ *
+ * @since 1.0.0
+ * @category Util
+ */
+export default function negate(predicate) {
+    if (typeof predicate !== 'function') {
+        throw new TypeError(FUNC_ERROR_TEXT);
+    }
+    return (...args) => !predicate(...args);
+}

package/dist/esm/util/noop.js

@@ -0,0 +1,17 @@
+/**
+ * 一个什么都不做的函数，常用作默认回调。
+ *
+ * @returns `undefined`
+ *
+ * @example
+ * ```ts
+ * noop();
+ * // => undefined
+ * ```
+ *
+ * @since 1.0.0
+ * @category Util
+ */
+export default function noop() {
+    // 有意为空
+}

package/dist/esm/util/now.js

@@ -0,0 +1,17 @@
+/**
+ * 返回当前时间的毫秒时间戳，等效于 `Date.now()`。
+ *
+ * @returns 毫秒时间戳
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.now();
+ * // => 1700000000000
+ * ```
+ *
+ * @since 1.0.0
+ * @category Util
+ */
+export default function now() {
+    return Date.now();
+}

package/dist/esm/util/property.js

@@ -0,0 +1,27 @@
+import { getPathValue } from '../_internal/basePath';
+import toPath from '../_internal/toPath';
+function isKey(value) {
+    return value !== '' && !value.includes('.') && !value.includes('[');
+}
+/**
+ * 创建读取 object 指定路径值的访问器函数。
+ *
+ * @param path - 属性路径
+ * @returns 访问器函数
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.property('a')({ a: 1 });
+ * // => 1
+ * ```
+ *
+ * @since 1.0.0
+ * @category Util
+ */
+export default function property(path) {
+    if (typeof path === 'string' && isKey(path)) {
+        return (object) => object == null ? undefined : object[path];
+    }
+    const keys = toPath(path);
+    return (object) => getPathValue(object, keys);
+}

package/dist/esm/util/random.js

@@ -0,0 +1,68 @@
+function toFinite(value) {
+    const result = Number(value);
+    if (result === Infinity || result === -Infinity) {
+        return result < 0 ? -Number.MAX_VALUE : Number.MAX_VALUE;
+    }
+    return result === result ? result : 0;
+}
+function baseRandom(lower, upper) {
+    return lower + Math.floor(Math.random() * (upper - lower + 1));
+}
+/**
+ * 生成 [lower, upper] 范围内的随机数。
+ *
+ * @param lower - 下界，默认 0
+ * @param upper - 上界，默认 1
+ * @param floating - 是否返回浮点数
+ * @returns 随机数
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.random(0, 5);
+ * // => 0 到 5 的整数
+ * ```
+ *
+ * @since 1.0.0
+ * @category Util
+ */
+export default function random(lower = 0, upper, floating) {
+    let resolvedLower = lower;
+    let resolvedUpper = upper;
+    let resolvedFloating = floating;
+    if (typeof resolvedUpper === 'boolean' && resolvedFloating === undefined) {
+        resolvedFloating = resolvedUpper;
+        resolvedUpper = undefined;
+    }
+    else if (typeof resolvedLower === 'boolean' && resolvedFloating === undefined) {
+        resolvedFloating = resolvedLower;
+        resolvedLower = 0;
+        resolvedUpper = 1;
+    }
+    if (resolvedLower === undefined && resolvedUpper === undefined) {
+        resolvedLower = 0;
+        resolvedUpper = 1;
+    }
+    else {
+        resolvedLower = toFinite(resolvedLower);
+        if (resolvedUpper === undefined) {
+            resolvedUpper = resolvedLower;
+            resolvedLower = 0;
+        }
+        else {
+            resolvedUpper = toFinite(resolvedUpper);
+        }
+    }
+    let lowerBound = resolvedLower;
+    let upperBound = resolvedUpper;
+    if (lowerBound > upperBound) {
+        const temp = lowerBound;
+        lowerBound = upperBound;
+        upperBound = temp;
+    }
+    if (resolvedFloating || lowerBound % 1 || upperBound % 1) {
+        const rand = Math.random();
+        return Math.min(lowerBound +
+            rand * (upperBound - lowerBound + Number.parseFloat(`1e-${String(rand).length - 1}`)), upperBound);
+    }
+    return baseRandom(lowerBound, upperBound);
+}

package/dist/esm/util/range.js

@@ -0,0 +1,40 @@
+import baseRange from '../_internal/baseRange';
+function toFinite(value) {
+    const result = Number(value);
+    if (result === Infinity || result === -Infinity) {
+        return result < 0 ? -Number.MAX_VALUE : Number.MAX_VALUE;
+    }
+    return result === result ? result : 0;
+}
+/**
+ * 创建从 start 到 end（不含）按 step 递增的数字数组。
+ *
+ * @param start - 起始值；仅传一个参数时表示 end，start 置 0
+ * @param end - 结束值（不含）
+ * @param step - 步长，默认 1 或 -1
+ * @returns 数字数组
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.range(4);
+ * // => [0, 1, 2, 3]
+ * ```
+ *
+ * @since 1.0.0
+ * @category Util
+ */
+export default function range(start, end, step) {
+    let resolvedStart = toFinite(start);
+    let resolvedEnd = end;
+    let resolvedStep = step;
+    if (resolvedEnd === undefined) {
+        resolvedEnd = resolvedStart;
+        resolvedStart = 0;
+    }
+    else {
+        resolvedEnd = toFinite(resolvedEnd);
+    }
+    resolvedStep =
+        resolvedStep === undefined ? (resolvedStart < resolvedEnd ? 1 : -1) : toFinite(resolvedStep);
+    return baseRange(resolvedStart, resolvedEnd, resolvedStep, false);
+}

package/dist/esm/util/size.js

@@ -0,0 +1,41 @@
+import isArrayLike from '../_internal/isArrayLike';
+/**
+ * 返回 collection 的长度；Map / Set 返回 size，对象返回自有可枚举键数量。
+ *
+ * @param collection - 待检查的集合
+ * @returns 集合长度
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.size([1, 2, 3]);
+ * // => 3
+ *
+ * zhiaiwanUtils.size({ a: 1, b: 2 });
+ * // => 2
+ *
+ * zhiaiwanUtils.size('abc');
+ * // => 3
+ * ```
+ *
+ * @since 1.0.0
+ * @category Util
+ */
+export default function size(collection) {
+    var _a;
+    if (collection == null) {
+        return 0;
+    }
+    if (typeof collection === 'string' || Array.isArray(collection)) {
+        return collection.length;
+    }
+    if (isArrayLike(collection)) {
+        return (_a = collection.length) !== null && _a !== void 0 ? _a : 0;
+    }
+    if (collection instanceof Map || collection instanceof Set) {
+        return collection.size;
+    }
+    if (typeof collection === 'object') {
+        return Object.keys(collection).length;
+    }
+    return 0;
+}

package/dist/esm/util/sleep.js

@@ -0,0 +1,19 @@
+/**
+ * 返回一个在 ms 毫秒后 resolve 的 Promise，用于异步等待。
+ *
+ * @param ms - 等待毫秒数
+ * @returns Promise
+ *
+ * @example
+ * ```ts
+ * await sleep(1000);
+ * ```
+ *
+ * @since 1.0.0
+ * @category Util
+ */
+export default function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}

package/dist/esm/util/times.js

@@ -0,0 +1,35 @@
+import toInteger from '../_internal/toInteger';
+import identity from '../_internal/identity';
+const MAX_SAFE_INTEGER = 9007199254740991;
+const MAX_ARRAY_LENGTH = 4294967295;
+/**
+ * 调用 iteratee n 次并收集结果。
+ *
+ * @param n - 调用次数
+ * @param iteratee - 每次调用函数，接收 index
+ * @returns 结果数组
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.times(3, String);
+ * // => ['0', '1', '2']
+ * ```
+ *
+ * @since 1.0.0
+ * @category Util
+ */
+export default function times(n, iteratee = identity) {
+    const resolved = toInteger(n);
+    if (resolved < 1 || resolved > MAX_SAFE_INTEGER) {
+        return [];
+    }
+    const length = Math.min(resolved, MAX_ARRAY_LENGTH);
+    const result = new Array(length);
+    for (let index = 0; index < length; index++) {
+        result[index] = iteratee(index);
+    }
+    for (let index = MAX_ARRAY_LENGTH; index < resolved; index++) {
+        iteratee(index);
+    }
+    return result;
+}

package/dist/esm/util/uniqueId.js

@@ -0,0 +1,23 @@
+let idCounter = 0;
+/**
+ * 生成递增的唯一 ID 字符串，可选前缀 prefix。
+ *
+ * @param prefix - 可选前缀，null/undefined 视为空字符串
+ * @returns 唯一 ID 字符串
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.uniqueId();
+ * // => '1'
+ *
+ * zhiaiwanUtils.uniqueId('contact_');
+ * // => 'contact_2'
+ * ```
+ *
+ * @since 1.0.0
+ * @category Util
+ */
+export default function uniqueId(prefix) {
+    const id = ++idCounter;
+    return `${prefix == null ? '' : String(prefix)}${id}`;
+}

package/dist/esm/util/validateFields.js

@@ -0,0 +1,100 @@
+import validateFieldRule from '../_internal/validateFieldRule';
+import toPath from '../_internal/toPath';
+function getValueByPath(object, path) {
+    const keys = toPath(path);
+    let current = object;
+    for (const key of keys) {
+        if (current == null) {
+            return undefined;
+        }
+        current = current[key];
+    }
+    return current;
+}
+function normalizeRules(rule) {
+    return Array.isArray(rule) ? rule : [rule];
+}
+function buildResult(fieldErrors) {
+    const errorFields = Object.keys(fieldErrors);
+    if (errorFields.length === 0) {
+        return { valid: true, errors: {} };
+    }
+    const field = errorFields[0];
+    return {
+        valid: false,
+        errors: fieldErrors,
+        firstError: { field, message: fieldErrors[field][0] },
+    };
+}
+function collectFieldErrors(cells) {
+    const fieldErrors = {};
+    for (const cell of cells) {
+        if (cell.messages.length > 0) {
+            fieldErrors[cell.field] = cell.messages;
+        }
+    }
+    return fieldErrors;
+}
+/**
+ * 按规则对象校验表单/数据对象。rules 的 key 为字段路径（与 `get` 相同的路径写法），
+ * value 为单条规则或规则数组。自定义 `validator` 返回 `true` / `void` 表示通过，
+ * 返回 `false` 或非空字符串表示失败。
+ *
+ * @param values - 待校验的数据对象
+ * @param rules - 字段路径到规则的映射
+ * @param options - 可选配置
+ * @returns 校验结果；存在异步 validator 时返回 Promise
+ *
+ * @example
+ * ```ts
+ * validateFields(
+ *   { user: { name: '' }, password: 'abc', confirmPassword: '456' },
+ *   {
+ *     'user.name': { required: true, message: '请输入姓名' },
+ *     confirmPassword: {
+ *       validator: ({ value, values }) => {
+ *         if (value !== values.password) return '两次密码不一致';
+ *       },
+ *     },
+ *   },
+ * );
+ * // => { valid: false, errors: { 'user.name': ['请输入姓名'], ... } }
+ * ```
+ *
+ * @since 1.0.0
+ * @category Util
+ */
+export default function validateFields(values, rules, options) {
+    var _a;
+    const data = values !== null && values !== void 0 ? values : {};
+    const fields = (_a = options === null || options === void 0 ? void 0 : options.fields) !== null && _a !== void 0 ? _a : Object.keys(rules);
+    const cells = [];
+    for (const field of fields) {
+        const fieldRules = rules[field];
+        if (!fieldRules) {
+            continue;
+        }
+        const value = getValueByPath(data, field);
+        const cell = { field, messages: [], promises: [] };
+        for (const rule of normalizeRules(fieldRules)) {
+            const ctx = { value, values: data, field, rule };
+            const outcome = validateFieldRule(ctx);
+            if (outcome instanceof Promise) {
+                cell.promises.push(outcome.then((error) => {
+                    if (error) {
+                        cell.messages.push(error);
+                    }
+                }));
+            }
+            else if (outcome) {
+                cell.messages.push(outcome);
+            }
+        }
+        cells.push(cell);
+    }
+    const asyncTasks = cells.flatMap((cell) => cell.promises);
+    if (asyncTasks.length > 0) {
+        return Promise.all(asyncTasks).then(() => buildResult(collectFieldErrors(cells)));
+    }
+    return buildResult(collectFieldErrors(cells));
+}

package/dist/esm/verify/index.js

@@ -0,0 +1,36 @@
+export { default as isString } from './isString';
+export { default as isNumber } from './isNumber';
+export { default as isBoolean } from './isBoolean';
+export { default as isArray } from './isArray';
+export { default as isArguments } from './isArguments';
+export { default as isArrayBuffer } from './isArrayBuffer';
+export { default as isTypedArray } from './isTypedArray';
+export { default as isBuffer } from './isBuffer';
+export { default as isFunction } from './isFunction';
+export { default as isNative } from './isNative';
+export { default as isObject } from './isObject';
+export { default as isPlainObject } from './isPlainObject';
+export { default as isUndefined } from './isUndefined';
+export { default as isNull } from './isNull';
+export { default as isNil } from './isNil';
+export { default as isDate } from './isDate';
+export { default as isRegExp } from './isRegExp';
+export { default as isSymbol } from './isSymbol';
+export { default as isInteger } from './isInteger';
+export { default as isSafeInteger } from './isSafeInteger';
+export { default as isLength } from './isLength';
+export { default as isEmpty } from './isEmpty';
+export { default as isMap } from './isMap';
+export { default as isSet } from './isSet';
+export { default as isWeakMap } from './isWeakMap';
+export { default as isWeakSet } from './isWeakSet';
+export { default as isError } from './isError';
+export { default as isEqual } from './isEqual';
+export { default as isEqualWith } from './isEqualWith';
+export { default as isNaN } from './isNaN';
+export { default as isFinite } from './isFinite';
+export { default as isMatch } from './isMatch';
+export { default as isMatchWith } from './isMatchWith';
+export { default as isArrayLike } from './isArrayLike';
+export { default as isObjectLike } from './isObjectLike';
+export { default as isElement } from './isElement';

package/dist/esm/verify/isArguments.js

@@ -0,0 +1,18 @@
+/**
+ * 检查 value 是否是 `arguments` 对象。
+ *
+ * @param value - 要检查的值
+ * @returns 如果 value 是 arguments 对象，返回 true，否则返回 false
+ *
+ * @example
+ * ```ts
+ * (function () {
+ *   return zhiaiwanUtils.isArguments(arguments);
+ * })();
+ * // => true
+ * ```
+ *
+ * @since 1.0.0
+ * @category Verify
+ */
+export { default } from '../_internal/isArguments';

package/dist/esm/verify/isArray.js

@@ -0,0 +1,18 @@
+/**
+ * 检查 value 是否是一个数组。
+ *
+ * @param value - 要检查的值
+ * @returns 如果 value 是数组，返回 true，否则返回 false
+ *
+ * @example
+ * ```ts
+ * isArray([1, 2, 3]); // => true
+ * isArray('abc');     // => false
+ * ```
+ *
+ * @since 1.0.0
+ * @category Verify
+ */
+export default function isArray(value) {
+    return Array.isArray(value);
+}

package/dist/esm/verify/isArrayBuffer.js

@@ -0,0 +1,18 @@
+/**
+ * 检查 value 是否是 `ArrayBuffer` 对象。
+ *
+ * @param value - 要检查的值
+ * @returns 如果 value 是 ArrayBuffer，返回 true，否则返回 false
+ *
+ * @example
+ * ```ts
+ * isArrayBuffer(new ArrayBuffer(8));
+ * // => true
+ * ```
+ *
+ * @since 1.0.0
+ * @category Verify
+ */
+export default function isArrayBuffer(value) {
+    return Object.prototype.toString.call(value) === '[object ArrayBuffer]';
+}