foreslash 0.2.3 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Change Log
 
+## Version 0.3.0 - 2025-07-01
+
+Unstable version
+
+- Feat 🥥 Functions added: `capitalize` `deepMerge` `isBlob` and so forth
+- Feat 🥥 Function change: `deepClone` now support `Blob` and `File`
+- Other fixes and improvements
+
+不稳定版本
+
+- 功能 🥥 添加函数: `capitalize` `deepMerge` `isBlob` 等
+- 功能 🥥 变更函数: `deepClone` 现在支持 `Blob` 和 `File`
+- 其他修复与优化
+
+## Version 0.2.4 - 2025-05-29
+
+Unstable version
+
+- Feat 🥥 Functions added: `retry` `parallel`
+- Change 🥟 Dependencies change: upgrade devDependencies `rollup` `@rollup/plugin-typescript` `rollup-plugin-dts` `vitepress`
+- Other fixes and improvements
+
+不稳定版本
+
+- 功能 🥥 添加函数: `retry` `parallel`
+- 变更 🥟 依赖变更: 升级开发依赖 `rollup` `@rollup/plugin-typescript` `rollup-plugin-dts` `vitepress`
+- 其他修复与优化
+
 ## Version 0.2.3 - 2025-03-28
 
 Unstable version

package/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2024 moushu
+Copyright (c) 2024-2025 moushu
 foreslash is licensed under Mulan PSL v2.
 You can use this software according to the terms and conditions of the Mulan PSL v2.
 You may obtain a copy of Mulan PSL v2 at:

package/lib/index.cmn.cjs

@@ -1,5 +1,5 @@
 /*!
-Copyright (c) 2024 moushu
+Copyright (c) 2024-2025 moushu
 foreslash is licensed under Mulan PSL v2.
 You can use this software according to the terms and conditions of the Mulan PSL v2.
 You may obtain a copy of Mulan PSL v2 at:
@@ -116,8 +116,8 @@ function getGlobalThis() {
     return Function('return this')();
 }
 
-const global$7 = getGlobalThis();
-const ArrayBuffer$1 = global$7.ArrayBuffer;
+const global$8 = getGlobalThis();
+const ArrayBuffer$1 = global$8.ArrayBuffer;
 function isArrayBuffer(val) {
     return !!ArrayBuffer$1 && val instanceof ArrayBuffer$1;
 }
@@ -134,6 +134,16 @@ function isBigInt(value) {
     return typeof value === 'bigint';
 }
 
+function isObject(value) {
+    return typeof value === 'object' && value !== null;
+}
+
+const global$7 = getGlobalThis();
+const Blob = global$7.Blob;
+function isBlob(value) {
+    return !!Blob && isObject(value) && getTag(value) === 'Blob';
+}
+
 function isBoolean(value) {
     return typeof value === 'boolean';
 }
@@ -142,10 +152,6 @@ const global$6 = getGlobalThis();
 const Buffer = global$6.Buffer;
 const isBuffer = (Buffer && Buffer.isBuffer) || (() => false);
 
-function isObject(value) {
-    return typeof value === 'object' && value !== null;
-}
-
 function isDataView(value) {
     return isObject(value) && getTag(value) === 'DataView';
 }
@@ -155,9 +161,9 @@ function isDate(value) {
 }
 
 const global$5 = getGlobalThis();
-const File = global$5.File;
+const File$1 = global$5.File;
 function isFile(value) {
-    return !!File && value instanceof File;
+    return !!File$1 && isObject(value) && getTag(value) === 'File';
 }
 
 const global$4 = getGlobalThis();
@@ -351,12 +357,100 @@ function defer(asyncFunction, options) {
     });
 }
 
+function clamp(num, min, max, options) {
+    var _a, _b;
+    if (isNaN(min))
+        throw new Error('Invalid min parameter');
+    if (isNaN(max))
+        throw new Error('Invalid max parameter');
+    if (max < min) {
+        [min, max] = [max, min];
+    }
+    const { default: def, defaultMin: _dMin, defaultMax: _dMax } = options || {};
+    const defaultMin = (_a = _dMin !== null && _dMin !== void 0 ? _dMin : def) !== null && _a !== void 0 ? _a : min;
+    const defaultMax = (_b = _dMax !== null && _dMax !== void 0 ? _dMax : def) !== null && _b !== void 0 ? _b : max;
+    if (isNaN(num))
+        return defaultMin;
+    return num < min ? defaultMin : num > max ? defaultMax : num;
+}
+
+function parallel(args, fn, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!args.length)
+            return [];
+        const { limit: _limit = 5 } = options || {};
+        const limit = clamp(Math.floor(_limit), 1, 100);
+        let current = 0;
+        const results = [];
+        const errors = [];
+        const asyncFn = tryit(fn);
+        const processor = () => __awaiter(this, void 0, void 0, function* () {
+            while (current < args.length) {
+                const index = current++;
+                const [err, result] = yield asyncFn(args[index]);
+                if (err)
+                    errors.push({ index, error: err });
+                else
+                    results[index] = result;
+            }
+        });
+        const tasks = [];
+        for (let i = 0; i < Math.min(args.length, limit); i++) {
+            tasks.push(processor());
+        }
+        yield Promise.all(tasks);
+        if (errors.length) {
+            throw new Error(`Parallel execution failed on index: ${errors.map((e) => e.index).join(', ')}`, { cause: errors });
+        }
+        return results;
+    });
+}
+
 function sleep(time = 1000) {
     return new Promise((res) => {
         setTimeout(res, time);
     });
 }
 
+function retry(asyncFunction, option) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let retryCounts = 0;
+        const times = isNumber(option === null || option === void 0 ? void 0 : option.times) ? option.times : 3;
+        const delay = isFunction(option === null || option === void 0 ? void 0 : option.delay)
+            ? option.delay
+            : isNumber(option === null || option === void 0 ? void 0 : option.delay)
+                ? () => option.delay
+                : null;
+        const gap = isFunction(option === null || option === void 0 ? void 0 : option.gap) ? option.gap : isNumber(option === null || option === void 0 ? void 0 : option.gap) ? () => option.gap : null;
+        let lastRunTime = 0;
+        const getDelayTime = !option || (!delay && !gap)
+            ? () => 0
+            : gap
+                ? (retryCounts) => {
+                    const time = gap(retryCounts);
+                    return time - Date.now() + lastRunTime;
+                }
+                : delay;
+        while (1) {
+            lastRunTime = Date.now();
+            const [err, res] = yield tryit(asyncFunction)((err) => {
+                throw { $$exit_retry: err };
+            });
+            if (!err)
+                return res;
+            retryCounts++;
+            if (err && err.$$exit_retry)
+                throw err.$$exit_retry;
+            if (retryCounts >= times)
+                throw err;
+            const delayTime = getDelayTime(retryCounts);
+            if (delayTime > 0)
+                yield sleep(delayTime);
+        }
+        throw new Error('retry failed');
+    });
+}
+
 const noop = function noop() { };
 
 function withResolvers(PromiseLike = Promise) {
@@ -370,23 +464,6 @@ function withResolvers(PromiseLike = Promise) {
     return { promise, resolve, reject };
 }
 
-function clamp(num, min, max, options) {
-    var _a, _b;
-    if (isNaN(min))
-        throw new Error('Invalid min parameter');
-    if (isNaN(max))
-        throw new Error('Invalid max parameter');
-    if (max < min) {
-        [min, max] = [max, min];
-    }
-    const { default: def, defaultMin: _dMin, defaultMax: _dMax } = options || {};
-    const defaultMin = (_a = _dMin !== null && _dMin !== void 0 ? _dMin : def) !== null && _a !== void 0 ? _a : min;
-    const defaultMax = (_b = _dMax !== null && _dMax !== void 0 ? _dMax : def) !== null && _b !== void 0 ? _b : max;
-    if (isNaN(num))
-        return defaultMin;
-    return num < min ? defaultMin : num > max ? defaultMax : num;
-}
-
 const mimeMap = {
     application: {
         acrobat: ['pdf'],
@@ -1180,6 +1257,12 @@ function titleCase(str, options) {
         : ({ code }) => code.slice(0, 1).toUpperCase() + code.slice(1).toLowerCase());
 }
 
+function capitalize(str) {
+    if (!str)
+        return str;
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
 function caseConvert(str, joiner = '', handler) {
     const hc = handler ? handler : (token) => token.code;
     return _caseConvert(_splitVar(str), joiner, hc);
@@ -1227,6 +1310,12 @@ function splitWords(str) {
     return _splitVar(str).map(({ code }) => code);
 }
 
+function uncapitalize(str) {
+    if (!str)
+        return str;
+    return str.charAt(0).toLowerCase() + str.slice(1);
+}
+
 function compose(...composeFunc) {
     if (composeFunc.length === 0) {
         throw new Error('Invalid composeFunc parameter: composeFunc is empty');
@@ -1468,6 +1557,16 @@ function _cloneArrayBuffer(obj, map) {
     new Uint8Array(res).set(new Uint8Array(obj));
     return res;
 }
+function _cloneBlob(obj, map) {
+    const res = obj.slice(0, obj.size, obj.type);
+    map.set(obj, res);
+    return res;
+}
+function _cloneFile(obj, map) {
+    const res = new File([obj], obj.name, { type: obj.type, lastModified: obj.lastModified });
+    map.set(obj, res);
+    return res;
+}
 
 function _deepClone(obj, map, options) {
     if (map.has(obj))
@@ -1512,6 +1611,12 @@ function _deepClone(obj, map, options) {
         res = new DataView(map.has(obj.buffer) ? map.get(obj.buffer) : _cloneArrayBuffer(obj.buffer, map), obj.byteOffset, obj.byteLength);
         map.set(obj, res);
     }
+    else if (isFile(obj)) {
+        res = _cloneFile(obj, map);
+    }
+    else if (isBlob(obj)) {
+        res = _cloneBlob(obj, map);
+    }
     else if (isWrapperObject(obj)) {
         res = Object(obj.valueOf());
         map.set(obj, res);
@@ -1546,6 +1651,201 @@ function deepClone(obj, options, map) {
     return res;
 }
 
+const $$Empty = Object.freeze({ '@@merge/placeholder': true });
+function getMergeStrategy(targetType, sourceType, strategy) {
+    return (strategy[`${sourceType}2${targetType}`] ||
+        strategy[`${sourceType}2Any`] ||
+        strategy[`Any2${targetType}`] ||
+        strategy[`Any2Any`] ||
+        'override');
+}
+function getBaseMargeType(obj) {
+    if (isMergeEmptyPlaceholder(obj))
+        return 'Empty';
+    const _tag = getTag(obj);
+    if (/Function/.test(_tag))
+        return 'Function';
+    if (/Iterator/.test(_tag))
+        return 'Iterator';
+    if (/(?:8|16|32|64)Array/.test(_tag))
+        return 'TypedArray';
+    if (/Error/.test(_tag))
+        return 'Error';
+    return _tag;
+}
+function isMergeEmptyPlaceholder(arg) {
+    return typeof arg === 'object' && Boolean(arg) && arg['@@merge/placeholder'] === true;
+}
+
+function _deepMergeBase(target, source, option, map, path, cloner) {
+    const targetType = getBaseMargeType(target);
+    const sourceType = getBaseMargeType(source);
+    const strategy = getMergeStrategy(targetType, sourceType, option.typeStrategy);
+    if (isFunction(strategy)) {
+        const merger = _curryMore(_deepMergeBase)(_, _, option, map, _, cloner);
+        const mergeRes = strategy({
+            target,
+            source,
+            cloner,
+            merger,
+            path,
+            typeStrategy: option.typeStrategy,
+            unhandledValue: $$Empty,
+            map,
+        });
+        if (!isMergeEmptyPlaceholder(mergeRes))
+            return mergeRes;
+    }
+    if (strategy === 'keep') {
+        if (isMergeEmptyPlaceholder(target))
+            return $$Empty;
+        return cloner(target);
+    }
+    else if (strategy === 'override') {
+        return cloner(source);
+    }
+    else {
+        return cloner(source);
+    }
+}
+const defaultMergeStrategy = {
+    Any2Any: 'override',
+    Any2Empty: 'override',
+    Any2Null: 'override',
+    Any2Undefined: 'override',
+    Null2Any: 'keep',
+    Undefined2Any: 'keep',
+    Null2Empty: 'override',
+    Undefined2Empty: 'override',
+    Number2Any: 'keep',
+    Number2Number: 'override',
+    String2Any: 'keep',
+    String2String: 'override',
+    Boolean2Any: 'keep',
+    Boolean2Boolean: 'override',
+    Symbol2Any: 'keep',
+    Symbol2Symbol: 'override',
+    BigInt2Any: 'keep',
+    BigInt2BigInt: 'override',
+    Number2Empty: 'override',
+    String2Empty: 'override',
+    Boolean2Empty: 'override',
+    Symbol2Empty: 'override',
+    BigInt2Empty: 'override',
+    Number2Null: 'override',
+    String2Null: 'override',
+    Boolean2Null: 'override',
+    Symbol2Null: 'override',
+    BigInt2Null: 'override',
+    Number2Undefined: 'override',
+    String2Undefined: 'override',
+    Boolean2Undefined: 'override',
+    Symbol2Undefined: 'override',
+    BigInt2Undefined: 'override',
+    Object2Object: (({ target, source, cloner, path, merger }) => {
+        const res = cloner(target);
+        Reflect.ownKeys(source).forEach((key) => {
+            const newPath = [...path, key];
+            if (key in res) {
+                res[key] = merger(res[key], source[key], newPath);
+            }
+            else {
+                const mergeRes = merger($$Empty, source[key], newPath);
+                if (!isMergeEmptyPlaceholder(mergeRes))
+                    res[key] = mergeRes;
+            }
+        });
+        return res;
+    }),
+    Object2FormData: (({ target, source, cloner, path, merger }) => {
+        const res = cloner(target);
+        Reflect.ownKeys(source).forEach((key) => {
+            if (isSymbol(key))
+                return;
+            const newPath = [...path, key];
+            if (res.has(key)) {
+                res.set(key, merger(res.get(key), source[key], newPath));
+            }
+            else {
+                const mergeRes = merger($$Empty, source[key], newPath);
+                if (!isMergeEmptyPlaceholder(mergeRes))
+                    res.set(key, mergeRes);
+            }
+        });
+        return res;
+    }),
+    FormData2Object: (({ target, source, cloner, path, merger }) => {
+        const res = cloner(target);
+        source.forEach((val, key) => {
+            const newPath = [...path, key];
+            if (key in res) {
+                res[key] = merger(res[key], val, newPath);
+            }
+            else {
+                const mergeRes = merger($$Empty, val, newPath);
+                if (!isMergeEmptyPlaceholder(mergeRes))
+                    res[key] = mergeRes;
+            }
+        });
+        return res;
+    }),
+    FormData2FormData: (({ target, source, cloner, path, merger }) => {
+        const res = cloner(target);
+        source.forEach((val, key) => {
+            const newPath = [...path, key];
+            if (res.has(key)) {
+                res.set(key, merger(res.get(key), val, newPath));
+            }
+            else {
+                const mergeRes = merger($$Empty, val, newPath);
+                if (!isMergeEmptyPlaceholder(mergeRes))
+                    res.set(key, mergeRes);
+            }
+        });
+        return res;
+    }),
+    Set2Set: (({ target, source, cloner }) => {
+        const res = cloner(target);
+        for (const item of source)
+            res.add(cloner(item));
+        return res;
+    }),
+    Map2Map: (({ target, source, cloner }) => {
+        const res = cloner(target);
+        for (const [key, val] of source)
+            res.set(cloner(key), cloner(val));
+        return res;
+    }),
+    Array2Array: (({ target, source, cloner }) => {
+        const res = cloner(target);
+        for (const item of source)
+            res.push(cloner(item));
+        return res;
+    }),
+    Set2Array: (({ target, source, cloner }) => {
+        const res = cloner(target);
+        for (const item of source)
+            res.push(cloner(item));
+        return res;
+    }),
+    Array2Set: (({ target, source, cloner }) => {
+        const res = cloner(target);
+        for (const item of source)
+            res.add(cloner(item));
+        return res;
+    }),
+};
+
+function deepMerge(target, source, option) {
+    const typeStrategy = Object.assign(Object.assign({}, defaultMergeStrategy), ((option === null || option === void 0 ? void 0 : option.typeStrategy) || {}));
+    const cloneOptions = Object.assign({ cloneSymbol: true, clonePrototype: false, cloneDescriptor: false, customCloner: [] }, ((option === null || option === void 0 ? void 0 : option.cloneOptions) || {}));
+    const map = new Map();
+    const cloner = _curryMore(_deepClone)(_, map, cloneOptions);
+    const res = _deepMergeBase(target, source, { typeStrategy, cloneOptions }, map, [], cloner);
+    map.clear();
+    return res;
+}
+
 function _fastClone(obj, map) {
     if (map.has(obj))
         return map.get(obj);
@@ -1703,10 +2003,12 @@ function throttle(fn, delay, options) {
     return _throttle(fn, delay, Object.assign({ trailing: false, leading: true }, options));
 }
 
+exports.$$Empty = $$Empty;
 exports._ = _;
 exports.acceptableFileName = acceptableFileName;
 exports.acceptableFileType = acceptableFileType;
 exports.camelCase = camelCase;
+exports.capitalize = capitalize;
 exports.caseCamel = caseCamel;
 exports.caseConvert = caseConvert;
 exports.caseKebab = caseKebab;
@@ -1717,6 +2019,7 @@ exports.compose = compose;
 exports.curry = _curryMore;
 exports.debounce = debounce;
 exports.deepClone = deepClone;
+exports.deepMerge = deepMerge;
 exports.defer = defer;
 exports.fastClone = fastClone;
 exports.getAcceptableExtByMIME = getAcceptableExtByMIME;
@@ -1729,6 +2032,7 @@ exports.isArrayLike = isArrayLike;
 exports.isBigInt = isBigInt;
 exports.isBigInt64Array = isBigInt64Array;
 exports.isBigUint64Array = isBigUint64Array;
+exports.isBlob = isBlob;
 exports.isBoolean = isBoolean;
 exports.isBuffer = isBuffer;
 exports.isDataView = isDataView;
@@ -1745,6 +2049,7 @@ exports.isInt8Array = isInt8Array;
 exports.isInteger = isInteger;
 exports.isIterable = isIterable;
 exports.isMap = isMap;
+exports.isMergeEmptyPlaceholder = isMergeEmptyPlaceholder;
 exports.isNil = isNil;
 exports.isNull = isNull;
 exports.isNumber = isNumber;
@@ -1775,6 +2080,7 @@ exports.kebabCase = kebabCase;
 exports.memo = memo;
 exports.noop = noop;
 exports.not = not;
+exports.parallel = parallel;
 exports.pascalCase = pascalCase;
 exports.pass = pass;
 exports.passWith = passWith;
@@ -1787,6 +2093,7 @@ exports.randomIntFloor = randomIntFloor;
 exports.randomString = randomString;
 exports.range = range;
 exports.remove = remove;
+exports.retry = retry;
 exports.shuffle = shuffle;
 exports.sleep = sleep;
 exports.snakeCase = snakeCase;
@@ -1795,6 +2102,7 @@ exports.throttle = throttle;
 exports.titleCase = titleCase;
 exports.tryit = tryit;
 exports.ulid = ulid;
+exports.uncapitalize = uncapitalize;
 exports.uuidNil = uuidNil;
 exports.uuidV4 = uuidV4;
 exports.withResolvers = withResolvers;