zhiaiwan-utils 1.0.3

package/dist/cjs/function/after.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = after;
+/**
+ * 创建一个跳过前 `n - 1` 次调用的函数；从第 n 次起执行 func。
+ *
+ * @param n - 开始执行的调用序号（从 1 起计）
+ * @param func - 要延迟执行的函数
+ * @returns 包装后的新函数
+ *
+ * @example
+ * ```ts
+ * let count = 0;
+ * const delayed = after(3, () => ++count);
+ * delayed(); // => undefined
+ * delayed(); // => undefined
+ * delayed(); // => 1
+ * ```
+ *
+ * @since 1.0.0
+ * @category Function
+ */
+function after(n, func) {
+    let remaining = n;
+    let result;
+    return function (...args) {
+        if (--remaining < 1) {
+            result = func.apply(this, args);
+        }
+        return result;
+    };
+}

package/dist/cjs/function/before.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = before;
+/**
+ * 创建一个最多调用 func `n - 1` 次的函数；达到上限后返回最后一次调用结果。
+ *
+ * @param n - 调用次数上限（不含第 n 次实际执行）
+ * @param func - 要限制的函数
+ * @returns 限制后的新函数
+ *
+ * @example
+ * ```ts
+ * let count = 0;
+ * const limited = before(3, () => ++count);
+ * limited(); // => 1
+ * limited(); // => 2
+ * limited(); // => 2
+ * ```
+ *
+ * @since 1.0.0
+ * @category Function
+ */
+function before(n, func) {
+    let remaining = n;
+    let result;
+    return function (...args) {
+        if (--remaining > 0) {
+            result = func.apply(this, args);
+        }
+        return result;
+    };
+}

package/dist/cjs/function/curry.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.curryPlaceholder = void 0;
+exports.default = curry;
+const FUNC_ERROR_TEXT = 'Expected a function';
+exports.curryPlaceholder = {};
+function mergeArgs(previous, next) {
+    const result = [...previous];
+    let nextIndex = 0;
+    for (let index = 0; index < result.length; index++) {
+        if (result[index] === exports.curryPlaceholder && nextIndex < next.length) {
+            result[index] = next[nextIndex++];
+        }
+    }
+    while (nextIndex < next.length) {
+        result.push(next[nextIndex++]);
+    }
+    return result;
+}
+function countProvided(args) {
+    return args.filter((arg) => arg !== exports.curryPlaceholder).length;
+}
+/**
+ * 创建可柯里化的函数。
+ *
+ * @param func - 原函数
+ * @param arity - 参数个数，默认 func.length
+ * @returns 柯里化函数
+ *
+ * @example
+ * ```ts
+ * const curried = zhiaiwanUtils.curry((a: number, b: number, c: number) => [a, b, c]);
+ * curried(1)(2)(3);
+ * // => [1, 2, 3]
+ * ```
+ *
+ * @since 1.0.0
+ * @category Function
+ */
+function curry(func, arity = func.length) {
+    if (typeof func !== 'function') {
+        throw new TypeError(FUNC_ERROR_TEXT);
+    }
+    function wrapper(...args) {
+        const merged = mergeArgs([], args);
+        if (countProvided(merged) >= arity) {
+            const finalArgs = merged.slice(0, arity);
+            return func(...finalArgs);
+        }
+        const next = (...nextArgs) => wrapper(...mergeArgs(merged, nextArgs));
+        next.placeholder = exports.curryPlaceholder;
+        return next;
+    }
+    wrapper.placeholder = exports.curryPlaceholder;
+    return wrapper;
+}
+curry.placeholder = exports.curryPlaceholder;

package/dist/cjs/function/debounce.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = debounce;
+function debounce(func, wait = 0, options = {}) {
+    if (typeof func !== 'function') {
+        throw new TypeError('Expected a function');
+    }
+    let lastArgs;
+    let lastThis;
+    let maxWait = 0;
+    let result;
+    let timerId;
+    let lastCallTime;
+    let lastInvokeTime = 0;
+    let leading = false;
+    let maxing = false;
+    let trailing = true;
+    const normalizedWait = Number(wait) || 0;
+    if (options && typeof options === 'object') {
+        leading = !!options.leading;
+        maxing = 'maxWait' in options;
+        maxWait = maxing ? Math.max(Number(options.maxWait) || 0, normalizedWait) : 0;
+        trailing = 'trailing' in options ? !!options.trailing : trailing;
+    }
+    function invokeFunc(time) {
+        const args = lastArgs;
+        const thisArg = lastThis;
+        lastArgs = lastThis = undefined;
+        lastInvokeTime = time;
+        if (args) {
+            result = func.apply(thisArg, args);
+        }
+        return result;
+    }
+    function leadingEdge(time) {
+        lastInvokeTime = time;
+        timerId = setTimeout(timerExpired, normalizedWait);
+        return leading ? invokeFunc(time) : result;
+    }
+    function remainingWait(time) {
+        const timeSinceLastCall = time - (lastCallTime !== null && lastCallTime !== void 0 ? lastCallTime : 0);
+        const timeSinceLastInvoke = time - lastInvokeTime;
+        const timeWaiting = normalizedWait - timeSinceLastCall;
+        return maxing ? Math.min(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;
+    }
+    function shouldInvoke(time) {
+        const timeSinceLastCall = time - (lastCallTime !== null && lastCallTime !== void 0 ? lastCallTime : 0);
+        const timeSinceLastInvoke = time - lastInvokeTime;
+        return (lastCallTime === undefined ||
+            timeSinceLastCall >= normalizedWait ||
+            timeSinceLastCall < 0 ||
+            (maxing && timeSinceLastInvoke >= maxWait));
+    }
+    function timerExpired() {
+        const time = Date.now();
+        if (shouldInvoke(time)) {
+            trailingEdge(time);
+        }
+        else {
+            timerId = setTimeout(timerExpired, remainingWait(time));
+        }
+    }
+    function trailingEdge(time) {
+        timerId = undefined;
+        if (trailing && lastArgs) {
+            return invokeFunc(time);
+        }
+        lastArgs = lastThis = undefined;
+        return result;
+    }
+    function cancel() {
+        if (timerId !== undefined) {
+            clearTimeout(timerId);
+        }
+        lastInvokeTime = 0;
+        lastArgs = lastCallTime = lastThis = timerId = undefined;
+    }
+    function flush() {
+        return timerId === undefined ? result : trailingEdge(Date.now());
+    }
+    function debounced(...args) {
+        const time = Date.now();
+        const isInvoking = shouldInvoke(time);
+        lastArgs = args;
+        // 延迟执行需保留调用方 this，与 Lodash debounce 行为一致
+        // eslint-disable-next-line @typescript-eslint/no-this-alias -- 异步 invoke 须缓存调用方 this
+        lastThis = this;
+        lastCallTime = time;
+        if (isInvoking) {
+            if (timerId === undefined) {
+                return leadingEdge(lastCallTime);
+            }
+            if (maxing) {
+                clearTimeout(timerId);
+                timerId = setTimeout(timerExpired, normalizedWait);
+                return invokeFunc(lastCallTime);
+            }
+        }
+        if (timerId === undefined) {
+            timerId = setTimeout(timerExpired, normalizedWait);
+        }
+        return result;
+    }
+    debounced.cancel = cancel;
+    debounced.flush = flush;
+    return debounced;
+}

package/dist/cjs/function/flow.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const FUNC_ERROR_TEXT = 'Expected a function';
+function flattenFlowArgs(funcs) {
+    const result = [];
+    for (const item of funcs) {
+        if (Array.isArray(item)) {
+            result.push(...item);
+        }
+        else {
+            result.push(item);
+        }
+    }
+    return result;
+}
+function createFlow(fromRight) {
+    return (...funcs) => {
+        const pipeline = flattenFlowArgs(funcs);
+        if (fromRight) {
+            pipeline.reverse();
+        }
+        for (const func of pipeline) {
+            if (typeof func !== 'function') {
+                throw new TypeError(FUNC_ERROR_TEXT);
+            }
+        }
+        return function flowed(...args) {
+            let result = pipeline[0].apply(this, args);
+            for (let index = 1; index < pipeline.length; index++) {
+                result = pipeline[index].call(this, result);
+            }
+            return result;
+        };
+    };
+}
+/**
+ * 创建一个按顺序组合多个函数的复合函数。
+ *
+ * @param funcs - 待组合的函数（可传数组）
+ * @returns 复合函数
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.flow([(a: number) => a + 1, (a: number) => a * 2])(1);
+ * // => 4
+ * ```
+ *
+ * @since 1.0.0
+ * @category Function
+ */
+exports.default = createFlow(false);

package/dist/cjs/function/flowRight.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = flowRight;
+const FUNC_ERROR_TEXT = 'Expected a function';
+function flattenFlowArgs(funcs) {
+    const result = [];
+    for (const item of funcs) {
+        if (Array.isArray(item)) {
+            result.push(...item);
+        }
+        else {
+            result.push(item);
+        }
+    }
+    return result;
+}
+/**
+ * 创建一个从右向左组合多个函数的复合函数。
+ *
+ * @param funcs - 待组合的函数（可传数组）
+ * @returns 复合函数
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.flowRight([(a: number) => a + 1, (a: number) => a * 2])(1);
+ * // => 3
+ * ```
+ *
+ * @since 1.0.0
+ * @category Function
+ */
+function flowRight(...funcs) {
+    const pipeline = flattenFlowArgs(funcs).reverse();
+    for (const func of pipeline) {
+        if (typeof func !== 'function') {
+            throw new TypeError(FUNC_ERROR_TEXT);
+        }
+    }
+    return function flowed(...args) {
+        let result = pipeline[0].apply(this, args);
+        for (let index = 1; index < pipeline.length; index++) {
+            result = pipeline[index].call(this, result);
+        }
+        return result;
+    };
+}

package/dist/cjs/function/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.curryPlaceholder = exports.curry = exports.flowRight = exports.flow = exports.partialRight = exports.partialPlaceholder = exports.partial = exports.memoize = exports.after = exports.before = exports.throttle = exports.debounce = exports.once = void 0;
+var once_1 = require("./once");
+Object.defineProperty(exports, "once", { enumerable: true, get: function () { return __importDefault(once_1).default; } });
+var debounce_1 = require("./debounce");
+Object.defineProperty(exports, "debounce", { enumerable: true, get: function () { return __importDefault(debounce_1).default; } });
+var throttle_1 = require("./throttle");
+Object.defineProperty(exports, "throttle", { enumerable: true, get: function () { return __importDefault(throttle_1).default; } });
+var before_1 = require("./before");
+Object.defineProperty(exports, "before", { enumerable: true, get: function () { return __importDefault(before_1).default; } });
+var after_1 = require("./after");
+Object.defineProperty(exports, "after", { enumerable: true, get: function () { return __importDefault(after_1).default; } });
+var memoize_1 = require("./memoize");
+Object.defineProperty(exports, "memoize", { enumerable: true, get: function () { return __importDefault(memoize_1).default; } });
+var partial_1 = require("./partial");
+Object.defineProperty(exports, "partial", { enumerable: true, get: function () { return __importDefault(partial_1).default; } });
+Object.defineProperty(exports, "partialPlaceholder", { enumerable: true, get: function () { return partial_1.partialPlaceholder; } });
+var partialRight_1 = require("./partialRight");
+Object.defineProperty(exports, "partialRight", { enumerable: true, get: function () { return __importDefault(partialRight_1).default; } });
+var flow_1 = require("./flow");
+Object.defineProperty(exports, "flow", { enumerable: true, get: function () { return __importDefault(flow_1).default; } });
+var flowRight_1 = require("./flowRight");
+Object.defineProperty(exports, "flowRight", { enumerable: true, get: function () { return __importDefault(flowRight_1).default; } });
+var curry_1 = require("./curry");
+Object.defineProperty(exports, "curry", { enumerable: true, get: function () { return __importDefault(curry_1).default; } });
+Object.defineProperty(exports, "curryPlaceholder", { enumerable: true, get: function () { return curry_1.curryPlaceholder; } });

package/dist/cjs/function/memoize.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = memoize;
+const MapCache_1 = __importDefault(require("../_internal/MapCache"));
+function memoize(func, resolver) {
+    if (typeof func !== 'function') {
+        throw new TypeError('Expected a function');
+    }
+    const Cache = memoize.Cache;
+    const cache = new Cache();
+    const memoized = function (...args) {
+        const key = resolver ? resolver.apply(this, args) : args[0];
+        if (cache.has(key)) {
+            return cache.get(key);
+        }
+        const result = func.apply(this, args);
+        cache.set(key, result);
+        return result;
+    };
+    memoized.cache = cache;
+    return memoized;
+}
+memoize.Cache = MapCache_1.default;

package/dist/cjs/function/once.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = once;
+/**
+ * 创建一个只能调用 func 一次的函数。重复调用返回首次调用的结果。
+ *
+ * @param func - 要限制的函数
+ * @returns 限制后的新函数
+ *
+ * @example
+ * ```ts
+ * let count = 0;
+ * const init = once(() => ++count);
+ * init(); // => 1
+ * init(); // => 1
+ * ```
+ *
+ * @since 1.0.0
+ * @category Function
+ */
+function once(func) {
+    let called = false;
+    let result;
+    return function (...args) {
+        if (!called) {
+            called = true;
+            result = func.apply(this, args);
+        }
+        return result;
+    };
+}

package/dist/cjs/function/partial.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.partialPlaceholder = void 0;
+exports.default = partial;
+const composePartials_1 = require("../_internal/composePartials");
+Object.defineProperty(exports, "partialPlaceholder", { enumerable: true, get: function () { return composePartials_1.partialPlaceholder; } });
+/**
+ * 创建一个偏函数，将 partials 参数预置到 func 参数列表前部。
+ * 可用 `partial.placeholder` 占位，调用时再填入实参。
+ *
+ * @param func - 原函数
+ * @param partials - 预置参数
+ * @returns 偏函数
+ *
+ * @example
+ * ```ts
+ * const fn = (a: number, b: number, c: number) => [a, b, c];
+ * const preset = partial(fn, partial.placeholder, 2);
+ * preset(1, 3);
+ * // => [1, 2, 3]
+ * ```
+ *
+ * @since 1.0.0
+ * @category Function
+ */
+function partial(func, ...partials) {
+    if (typeof func !== 'function') {
+        throw new TypeError('Expected a function');
+    }
+    return function (...args) {
+        const composed = (0, composePartials_1.mergePartialArgs)(args, partials, 'left');
+        return func.apply(this, composed);
+    };
+}
+partial.placeholder = composePartials_1.partialPlaceholder;

package/dist/cjs/function/partialRight.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = partialRight;
+const composePartials_1 = require("../_internal/composePartials");
+/**
+ * 创建一个偏函数，将 partials 参数预置到 func 参数列表尾部。
+ * 可用 `partialRight.placeholder` 占位，调用时再填入实参。
+ *
+ * @param func - 原函数
+ * @param partials - 预置参数
+ * @returns 偏函数
+ *
+ * @example
+ * ```ts
+ * const fn = (a: number, b: number, c: number) => [a, b, c];
+ * const preset = partialRight(fn, 2, partialRight.placeholder);
+ * preset(1, 3);
+ * // => [1, 2, 3]
+ * ```
+ *
+ * @since 1.0.0
+ * @category Function
+ */
+function partialRight(func, ...partials) {
+    if (typeof func !== 'function') {
+        throw new TypeError('Expected a function');
+    }
+    return function (...args) {
+        const composed = (0, composePartials_1.mergePartialArgs)(args, partials, 'right');
+        return func.apply(this, composed);
+    };
+}
+partialRight.placeholder = composePartials_1.partialPlaceholder;

package/dist/cjs/function/throttle.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = throttle;
+const debounce_1 = __importDefault(require("./debounce"));
+function throttle(func, wait = 0, options = {}) {
+    if (typeof func !== 'function') {
+        throw new TypeError('Expected a function');
+    }
+    const leading = 'leading' in options ? !!options.leading : true;
+    const trailing = 'trailing' in options ? !!options.trailing : true;
+    const normalizedWait = Number(wait) || 0;
+    return (0, debounce_1.default)(func, normalizedWait, {
+        leading,
+        maxWait: normalizedWait,
+        trailing,
+    });
+}

package/dist/cjs/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.version = void 0;
+var version_1 = require("./version");
+Object.defineProperty(exports, "version", { enumerable: true, get: function () { return version_1.version; } });
+__exportStar(require("./array"), exports);
+__exportStar(require("./object"), exports);
+__exportStar(require("./string"), exports);
+__exportStar(require("./convert"), exports);
+__exportStar(require("./tree"), exports);
+__exportStar(require("./util"), exports);
+__exportStar(require("./verify"), exports);
+__exportStar(require("./function"), exports);
+__exportStar(require("./color"), exports);

package/dist/cjs/object/assign.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = assign;
+const assignSources_1 = require("../_internal/assignSources");
+/**
+ * 将 sources 的自有可枚举属性浅合并到 object，后续来源覆盖先前值。
+ *
+ * @param object - 目标对象
+ * @param sources - 一个或多个源对象
+ * @returns 合并后的 object
+ *
+ * @example
+ * ```ts
+ * const obj = { a: 1 };
+ * zhiaiwanUtils.assign(obj, { b: 2 }, { b: 3, c: 4 });
+ * // => { a: 1, b: 3, c: 4 }
+ * ```
+ *
+ * @since 1.0.0
+ * @category Object
+ */
+function assign(object, ...sources) {
+    return (0, assignSources_1.assignSources)(object, sources, false);
+}

package/dist/cjs/object/clone.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = clone;
+const baseClone_1 = __importDefault(require("../_internal/baseClone"));
+/**
+ * 创建 `value` 的浅拷贝。数组、Map、Set 会复制一层容器；
+ * `ArrayBuffer` 会复制字节；`TypedArray` 共享底层 buffer；嵌套引用仍与源值共享。
+ *
+ * @param value - 要拷贝的值
+ * @returns 浅拷贝后的新值
+ *
+ * @example
+ * ```ts
+ * const obj = { a: { b: 1 } };
+ * const copy = zhiaiwanUtils.clone(obj);
+ * copy.a.b = 2;
+ * obj.a.b;
+ * // => 2
+ * ```
+ *
+ * @since 1.0.0
+ * @category Object
+ */
+function clone(value) {
+    return (0, baseClone_1.default)(value);
+}

package/dist/cjs/object/cloneDeep.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = cloneDeep;
+const baseClone_1 = __importDefault(require("../_internal/baseClone"));
+/**
+ * 递归创建 `value` 的深拷贝。支持数组、普通对象、`Date`、`RegExp`、`Map`、`Set`、
+ * `ArrayBuffer`、`DataView`、`TypedArray`、`Error`、包装对象以及循环引用；
+ * `WeakMap`/`WeakSet` 与函数会原样返回。
+ *
+ * @param value - 要深拷贝的值
+ * @returns 深拷贝后的新值
+ *
+ * @example
+ * ```ts
+ * const obj = { a: [{ b: 1 }] };
+ * const copy = zhiaiwanUtils.cloneDeep(obj);
+ * copy.a[0].b = 2;
+ * obj.a[0].b;
+ * // => 1
+ * ```
+ *
+ * @since 1.0.0
+ * @category Object
+ */
+function cloneDeep(value) {
+    return (0, baseClone_1.default)(value, new WeakMap(), { deep: true });
+}

package/dist/cjs/object/cloneDeepWith.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = cloneDeepWith;
+const baseClone_1 = __importDefault(require("../_internal/baseClone"));
+/**
+ * 递归创建 `value` 的深拷贝，并通过 `customizer` 自定义克隆结果。
+ * 当 `customizer` 返回 `undefined` 时，回退到默认深拷贝逻辑。
+ *
+ * @param value - 要深拷贝的值
+ * @param customizer - 自定义克隆函数，签名为 `(value, key?, object?, stack?)`
+ * @returns 深拷贝后的新值
+ *
+ * @example
+ * ```ts
+ * const copy = zhiaiwanUtils.cloneDeepWith({ a: { b: 1 } }, (val) => {
+ *   if (typeof val === 'number') {
+ *     return 0;
+ *   }
+ * });
+ * ```
+ *
+ * @since 1.0.0
+ * @category Object
+ */
+function cloneDeepWith(value, customizer) {
+    return (0, baseClone_1.default)(value, new WeakMap(), { deep: true, customizer });
+}