foreslash 0.1.2 → 0.2.1

package/lib/index.cmn.cjs

@@ -11,6 +11,48 @@ See the Mulan PSL v2 for more details.
 */
 'use strict';
 
+function range(start, end, stepOrOptions) {
+    if (!isFinite(start))
+        throw new Error('start must be finite');
+    if (end == null)
+        return range(0, start);
+    if (!isFinite(end))
+        throw new Error('end must be finite');
+    let step = 1;
+    let getter = null;
+    if (typeof stepOrOptions === 'number') {
+        step = stepOrOptions;
+    }
+    else if (stepOrOptions) {
+        const { step: _step } = stepOrOptions;
+        if (_step)
+            step = _step;
+        if ('value' in stepOrOptions)
+            getter = () => stepOrOptions.value;
+        else if ('getter' in stepOrOptions)
+            getter = stepOrOptions.getter;
+    }
+    if (!isFinite(step))
+        throw new Error('step must be finite');
+    if (step === 0)
+        throw new Error('step must not be 0');
+    if ((start > end && step > 0) || (start < end && step < 0))
+        step = -step;
+    const res = [];
+    for (let i = start; step > 0 ? i <= end : i >= end; i += step) {
+        res.push(getter ? getter(i, res) : i);
+        if (step > 0 ? i + step > end : i + step < end)
+            break;
+    }
+    return res;
+}
+
+function sleep(time = 1000) {
+    return new Promise((res) => {
+        setTimeout(res, time);
+    });
+}
+
 const isArray = Array.isArray;
 
 const object2String = Object.prototype.toString;
@@ -19,22 +61,19 @@ function getTag(value) {
 }
 
 function getGlobalThis() {
-    if (typeof self !== 'undefined') {
+    if (typeof self !== 'undefined')
         return self;
-    }
-    if (typeof window !== 'undefined') {
+    if (typeof window !== 'undefined')
         return window;
-    }
-    if (typeof global !== 'undefined') {
+    if (typeof global !== 'undefined')
         return global;
-    }
     return Function('return this')();
 }
 
-const global$5 = getGlobalThis();
-const ArrayBuffer = global$5.ArrayBuffer;
+const global$7 = getGlobalThis();
+const ArrayBuffer$1 = global$7.ArrayBuffer;
 function isArrayBuffer(val) {
-    return !!ArrayBuffer && val instanceof ArrayBuffer;
+    return !!ArrayBuffer$1 && val instanceof ArrayBuffer$1;
 }
 
 function isInteger(value) {
@@ -53,20 +92,36 @@ function isBoolean(value) {
     return typeof value === 'boolean';
 }
 
-const global$4 = getGlobalThis();
-const Buffer = global$4.Buffer;
+const global$6 = getGlobalThis();
+const Buffer = global$6.Buffer;
 const isBuffer = (Buffer && Buffer.isBuffer) || (() => false);
 
-function isFunction(value) {
-    return typeof value === 'function';
+function isObject(value) {
+    return typeof value === 'object' && value !== null;
 }
 
-const global$3 = getGlobalThis();
-function isMap(value) {
-    return !!global$3.Map && value instanceof Map;
+function isDataView(value) {
+    return isObject(value) && getTag(value) === 'DataView';
 }
-function isWeakMap(value) {
-    return !!global$3.WeakMap && value instanceof WeakMap;
+
+function isDate(value) {
+    return isObject(value) && getTag(value) === 'Date';
+}
+
+const global$5 = getGlobalThis();
+const File = global$5.File;
+function isFile(value) {
+    return !!File && value instanceof File;
+}
+
+const global$4 = getGlobalThis();
+const FormData$1 = global$4.FormData;
+function isFormData(value) {
+    return !!FormData$1 && value instanceof FormData$1;
+}
+
+function isFunction(value) {
+    return typeof value === 'function';
 }
 
 function isNil(value) {
@@ -79,12 +134,20 @@ function isUndefined(value) {
     return value === void 0;
 }
 
-function isNumber(value) {
-    return typeof value === 'number';
+function isIterable(value) {
+    return !isNil(value) && typeof value[Symbol.iterator] === 'function';
 }
 
-function isObject(value) {
-    return typeof value === 'object' && value !== null;
+const global$3 = getGlobalThis();
+function isMap(value) {
+    return !!global$3.Map && value instanceof Map;
+}
+function isWeakMap(value) {
+    return !!global$3.WeakMap && value instanceof WeakMap;
+}
+
+function isNumber(value) {
+    return typeof value === 'number';
 }
 
 function isPrimitive(value) {
@@ -99,6 +162,10 @@ function isPromiseLike(value) {
     return isObject(value) && isFunction(value.then);
 }
 
+function isRegExp(value) {
+    return isObject(value) && getTag(value) === 'RegExp';
+}
+
 const global$2 = getGlobalThis();
 function isSet(value) {
     return !!global$2.Set && value instanceof Set;
@@ -115,6 +182,56 @@ function isSymbol(value) {
     return typeof value === 'symbol';
 }
 
+const allTypedArrayTags = new Set([
+    'Int8Array',
+    'Int16Array',
+    'Int32Array',
+    'Uint8Array',
+    'Uint8ClampedArray',
+    'Uint16Array',
+    'Uint32Array',
+    'Float32Array',
+    'Float64Array',
+    'BigInt64Array',
+    'BigUint64Array',
+]);
+function isTypedArray(value) {
+    return isObject(value) && allTypedArrayTags.has(getTag(value));
+}
+function isInt8Array(value) {
+    return isObject(value) && getTag(value) === 'Int8Array';
+}
+function isInt16Array(value) {
+    return isObject(value) && getTag(value) === 'Int16Array';
+}
+function isInt32Array(value) {
+    return isObject(value) && getTag(value) === 'Int32Array';
+}
+function isUint8Array(value) {
+    return isObject(value) && getTag(value) === 'Uint8Array';
+}
+function isUint8ClampedArray(value) {
+    return isObject(value) && getTag(value) === 'Uint8ClampedArray';
+}
+function isUint16Array(value) {
+    return isObject(value) && getTag(value) === 'Uint16Array';
+}
+function isUint32Array(value) {
+    return isObject(value) && getTag(value) === 'Uint32Array';
+}
+function isFloat32Array(value) {
+    return isObject(value) && getTag(value) === 'Float32Array';
+}
+function isFloat64Array(value) {
+    return isObject(value) && getTag(value) === 'Float64Array';
+}
+function isBigInt64Array(value) {
+    return isObject(value) && getTag(value) === 'BigInt64Array';
+}
+function isBigUint64Array(value) {
+    return isObject(value) && getTag(value) === 'BigUint64Array';
+}
+
 const global$1 = getGlobalThis();
 function isWrapperObject(value) {
     return (!!value &&
@@ -141,6 +258,33 @@ function isWrapperBigInt(value) {
     return !!global$1.BigInt && value instanceof BigInt;
 }
 
+function tryit(fn) {
+    return function tryitConvert(...args) {
+        try {
+            const res = fn.apply(this, args);
+            return isPromise(res)
+                ? res.then((val) => [undefined, val], (err) => [err, undefined])
+                : [undefined, res];
+        }
+        catch (err) {
+            return [err, undefined];
+        }
+    };
+}
+
+const noop = function noop() { };
+
+function withResolvers(PromiseLike = Promise) {
+    let promise;
+    let resolve = noop;
+    let reject = noop;
+    promise = new PromiseLike((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return { promise, resolve, reject };
+}
+
 const mimeMap = {
     application: {
         acrobat: ['pdf'],
@@ -877,6 +1021,63 @@ function _caseConvert(tokens, joiner, handler) {
         .filter((s) => s.length)
         .join(joiner);
 }
+
+function camelCase(str, options) {
+    const { keepLetterCase = false, keepNumber = true } = options || {};
+    let tokens = _splitVar(str);
+    if (!keepNumber)
+        tokens = tokens.filter(({ number }) => !number);
+    return _caseConvert(tokens, '', keepLetterCase
+        ? ({ code }, index) => {
+            if (index)
+                return code.slice(0, 1).toUpperCase() + code.slice(1);
+            else
+                return code;
+        }
+        : ({ code }, index) => {
+            if (index)
+                return code.slice(0, 1).toUpperCase() + code.slice(1).toLowerCase();
+            else
+                return code.toLowerCase();
+        });
+}
+
+function kebabCase(str, options) {
+    const { keepLetterCase = false, keepNumber = true } = options || {};
+    let tokens = _splitVar(str);
+    if (!keepNumber)
+        tokens = tokens.filter(({ number }) => !number);
+    return _caseConvert(tokens, '-', keepLetterCase ? ({ code }) => code : ({ code }) => code.toLowerCase());
+}
+
+function pascalCase(str, options) {
+    const { keepLetterCase = false, keepNumber = true } = options || {};
+    let tokens = _splitVar(str);
+    if (!keepNumber)
+        tokens = tokens.filter(({ number }) => !number);
+    return _caseConvert(tokens, '', keepLetterCase
+        ? ({ code }) => code.slice(0, 1).toUpperCase() + code.slice(1)
+        : ({ code }) => code.slice(0, 1).toUpperCase() + code.slice(1).toLowerCase());
+}
+
+function snakeCase(str, options) {
+    const { keepLetterCase = false, keepNumber = true } = options || {};
+    let tokens = _splitVar(str);
+    if (!keepNumber)
+        tokens = tokens.filter(({ number }) => !number);
+    return _caseConvert(tokens, '_', keepLetterCase ? ({ code }) => code : ({ code }) => code.toLowerCase());
+}
+
+function titleCase(str, options) {
+    const { keepLetterCase = false, keepNumber = true } = options || {};
+    let tokens = _splitVar(str);
+    if (!keepNumber)
+        tokens = tokens.filter(({ number }) => !number);
+    return _caseConvert(tokens, ' ', keepLetterCase
+        ? ({ code }) => code.slice(0, 1).toUpperCase() + code.slice(1)
+        : ({ code }) => code.slice(0, 1).toUpperCase() + code.slice(1).toLowerCase());
+}
+
 function caseConvert(str, joiner = '', handler) {
     const hc = handler ? handler : (token) => token.code;
     return _caseConvert(_splitVar(str), joiner, hc);
@@ -920,6 +1121,10 @@ function caseSnake(str, keepLetterCase = false, keepNumber = true) {
     return _caseConvert(tokens, '_', keepLetterCase ? ({ code }) => code : ({ code }) => code.toLowerCase());
 }
 
+function splitWords(str) {
+    return _splitVar(str).map(({ code }) => code);
+}
+
 function compose(...composeFunc) {
     if (composeFunc.length === 0) {
         throw new Error('Invalid composeFunc parameter: composeFunc is empty');
@@ -1100,6 +1305,97 @@ function _cloneSet(obj, map, cloner, ...args) {
     obj.forEach((item) => res.add(cloner(item, map, ...args)));
     return res;
 }
+function _cloneFormData(obj, map, cloner, ...args) {
+    const res = new FormData();
+    map.set(obj, res);
+    obj.forEach((value, key) => {
+        res.append(key, cloner(value, map, ...args));
+    });
+    return res;
+}
+function _cloneArrayBuffer(obj, map) {
+    const res = new ArrayBuffer(obj.byteLength);
+    map.set(obj, res);
+    new Uint8Array(res).set(new Uint8Array(obj));
+    return res;
+}
+
+function _deepClone(obj, map, options) {
+    if (map.has(obj))
+        return map.get(obj);
+    if (options.customCloner.length) {
+        for (let i = 0; i < options.customCloner.length; i++) {
+            const { cloner, judger } = options.customCloner[i];
+            if (judger(obj)) {
+                const res = cloner(obj, map);
+                map.set(obj, res);
+                return res;
+            }
+        }
+    }
+    if (!isObject(obj) || isFunction(obj) || isWeakMap(obj) || isWeakSet(obj) || isPromise(obj))
+        return obj;
+    if (isArray(obj))
+        return _cloneArray(obj, map, _deepClone, options);
+    if (isMap(obj))
+        return _cloneMap(obj, map, _deepClone, options);
+    if (isSet(obj))
+        return _cloneSet(obj, map, _deepClone, options);
+    if (isFormData(obj))
+        return _cloneFormData(obj, map, _deepClone, options);
+    let res;
+    if (obj instanceof Date) {
+        res = new Date(obj.valueOf());
+        map.set(obj, res);
+    }
+    else if (obj instanceof RegExp) {
+        res = new RegExp(obj.source, obj.flags);
+        map.set(obj, res);
+    }
+    else if (obj instanceof ArrayBuffer) {
+        res = _cloneArrayBuffer(obj, map);
+    }
+    else if (isTypedArray(obj)) {
+        res = new obj.constructor(_cloneArrayBuffer(obj.buffer, map), obj.byteOffset, obj.length);
+        map.set(obj, res);
+    }
+    else if (obj instanceof DataView) {
+        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 (isWrapperObject(obj)) {
+        res = Object(obj.valueOf());
+        map.set(obj, res);
+    }
+    else {
+        res = options.clonePrototype ? Object.create(Object.getPrototypeOf(obj)) : {};
+        map.set(obj, res);
+        Reflect.ownKeys(obj).forEach((key) => {
+            if (!options.cloneSymbol && typeof key === 'symbol')
+                return;
+            if (options.cloneDescriptor) {
+                const val = Object.getOwnPropertyDescriptor(obj, key);
+                if (!val)
+                    return;
+                if (val.value)
+                    val.value = _deepClone(val.value, map, options);
+                Object.defineProperty(res, key, val);
+            }
+            else {
+                Reflect.set(res, key, _deepClone(Reflect.get(obj, key), map, options));
+            }
+        });
+    }
+    return res;
+}
+
+function deepClone(obj, options, map) {
+    if (!isMap(map))
+        map = new Map();
+    const res = _deepClone(obj, map, Object.assign({ cloneSymbol: true, clonePrototype: false, cloneDescriptor: false, customCloner: [] }, options));
+    map.clear();
+    return res;
+}
 
 function _fastClone(obj, map) {
     if (map.has(obj))
@@ -1112,6 +1408,8 @@ function _fastClone(obj, map) {
         return _cloneMap(obj, map, _fastClone);
     if (isSet(obj))
         return _cloneSet(obj, map, _fastClone);
+    if (isFormData(obj))
+        return _cloneFormData(obj, map, _fastClone);
     let res;
     if (obj instanceof Date) {
         res = new Date(obj.valueOf());
@@ -1140,7 +1438,7 @@ function fastClone(obj, map) {
 }
 
 function isEmpty(value) {
-    if (value == null)
+    if (value === null || value === undefined)
         return true;
     if (typeof value !== 'object') {
         if (value === '' || value === 0)
@@ -1150,18 +1448,72 @@ function isEmpty(value) {
         return false;
     }
     else {
-        if (isArrayLike(value)) {
+        if (isArrayLike(value))
             return !value.length;
-        }
         if (isBuffer(value) || isArrayBuffer(value))
             return !value.byteLength;
+        if (isDate(value))
+            return isNaN(value.getTime());
         if (isSet(value) || isMap(value))
             return !value.size;
-        return !Object.getOwnPropertyNames(value).length;
+        for (const key in value) {
+            if (Object.prototype.hasOwnProperty.call(value, key))
+                return false;
+        }
+        return true;
     }
 }
 
-const noop = function noop() { };
+function _getKey(args) {
+    function toString(item) {
+        if (isBigInt(item))
+            return String(item) + 'n';
+        if (isRegExp(item))
+            return 'RegExp' + String(item);
+        if (isDate(item))
+            return 'Date' + item.toISOString();
+        try {
+            return JSON.stringify(item);
+        }
+        catch (e) {
+            return String(item);
+        }
+    }
+    let res = 'ForeSlashMemoKey:[';
+    for (let i = 0; i < args.length; i++) {
+        res += toString(args[i]) + ',';
+    }
+    return res + ']';
+}
+function memo(fn, options) {
+    const map = new Map();
+    const getKey = (options === null || options === void 0 ? void 0 : options.getKey) ? options.getKey : _getKey;
+    const setTtl = (options === null || options === void 0 ? void 0 : options.ttl) ? options.ttl : 0;
+    const setCount = (options === null || options === void 0 ? void 0 : options.count) ? options.count : 0;
+    return function (...args) {
+        const key = getKey(args);
+        if (map.has(key)) {
+            const item = map.get(key);
+            const { res, ttl, count } = item;
+            const isValidCache = ttl >= Date.now() && count > 0;
+            item.count -= 1;
+            if (item.count <= 0)
+                map.delete(key);
+            if (ttl < Date.now())
+                map.delete(key);
+            if (isValidCache)
+                return res;
+        }
+        const res = fn.apply(this, args);
+        const memoItem = { res, ttl: Infinity, count: Infinity };
+        if (setCount > 0)
+            memoItem.count = setCount;
+        if (setTtl > 0)
+            memoItem.ttl = Date.now() + setTtl;
+        map.set(key, memoItem);
+        return res;
+    };
+}
 
 function not(value) {
     return !Boolean(value);
@@ -1195,13 +1547,10 @@ function pipe(...pipeFunc) {
     };
 }
 
-function splitWords(str) {
-    return _splitVar(str).map(({ code }) => code);
-}
-
 exports._ = _;
 exports.acceptableFileName = acceptableFileName;
 exports.acceptableFileType = acceptableFileType;
+exports.camelCase = camelCase;
 exports.caseCamel = caseCamel;
 exports.caseConvert = caseConvert;
 exports.caseKebab = caseKebab;
@@ -1209,6 +1558,7 @@ exports.casePascal = casePascal;
 exports.caseSnake = caseSnake;
 exports.compose = compose;
 exports.curry = _curryMore;
+exports.deepClone = deepClone;
 exports.fastClone = fastClone;
 exports.getAcceptableExtByMIME = getAcceptableExtByMIME;
 exports.getAcceptableMIMEByExt = getAcceptableMIMEByExt;
@@ -1218,11 +1568,23 @@ exports.isArray = isArray;
 exports.isArrayBuffer = isArrayBuffer;
 exports.isArrayLike = isArrayLike;
 exports.isBigInt = isBigInt;
+exports.isBigInt64Array = isBigInt64Array;
+exports.isBigUint64Array = isBigUint64Array;
 exports.isBoolean = isBoolean;
 exports.isBuffer = isBuffer;
+exports.isDataView = isDataView;
+exports.isDate = isDate;
 exports.isEmpty = isEmpty;
+exports.isFile = isFile;
+exports.isFloat32Array = isFloat32Array;
+exports.isFloat64Array = isFloat64Array;
+exports.isFormData = isFormData;
 exports.isFunction = isFunction;
+exports.isInt16Array = isInt16Array;
+exports.isInt32Array = isInt32Array;
+exports.isInt8Array = isInt8Array;
 exports.isInteger = isInteger;
+exports.isIterable = isIterable;
 exports.isMap = isMap;
 exports.isNil = isNil;
 exports.isNull = isNull;
@@ -1232,9 +1594,15 @@ exports.isPlaceholder = isPlaceholder;
 exports.isPrimitive = isPrimitive;
 exports.isPromise = isPromise;
 exports.isPromiseLike = isPromiseLike;
+exports.isRegExp = isRegExp;
 exports.isSet = isSet;
 exports.isString = isString;
 exports.isSymbol = isSymbol;
+exports.isTypedArray = isTypedArray;
+exports.isUint16Array = isUint16Array;
+exports.isUint32Array = isUint32Array;
+exports.isUint8Array = isUint8Array;
+exports.isUint8ClampedArray = isUint8ClampedArray;
 exports.isUndefined = isUndefined;
 exports.isWeakMap = isWeakMap;
 exports.isWeakSet = isWeakSet;
@@ -1244,8 +1612,11 @@ exports.isWrapperNumber = isWrapperNumber;
 exports.isWrapperObject = isWrapperObject;
 exports.isWrapperString = isWrapperString;
 exports.isWrapperSymbol = isWrapperSymbol;
+exports.kebabCase = kebabCase;
+exports.memo = memo;
 exports.noop = noop;
 exports.not = not;
+exports.pascalCase = pascalCase;
 exports.pass = pass;
 exports.passWith = passWith;
 exports.pipe = pipe;
@@ -1255,8 +1626,14 @@ exports.randomHexString = randomHexString;
 exports.randomInt = randomInt;
 exports.randomIntFloor = randomIntFloor;
 exports.randomString = randomString;
+exports.range = range;
 exports.shuffle = shuffle;
+exports.sleep = sleep;
+exports.snakeCase = snakeCase;
 exports.splitWords = splitWords;
+exports.titleCase = titleCase;
+exports.tryit = tryit;
 exports.ulid = ulid;
 exports.uuidNil = uuidNil;
 exports.uuidV4 = uuidV4;
+exports.withResolvers = withResolvers;