foreslash 0.3.1 → 0.3.3

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Change Log
 
+## Version 0.3.3 - 2025-11-05
+
+Unstable version
+
+- Feat 🥥 Functions added: `lerp` `scientificNotation` `castArray` `romanNumerals` `randomDistribution` and so forth
+- Fix 🥕 Document: Added version tags to `memo` and description to several methods
+- Other fixes and improvements
+
+不稳定版本
+
+- 功能 🥥 添加函数: `lerp` `scientificNotation` `castArray` `randomDistribution` 等
+- 修复 🥕 文档: 补充 `memo` 的版本标签和部分方法的说明
+- 其他修复与优化
+
+## Version 0.3.2 - 2025-09-23
+
+Unstable version
+
+- Feat 🥥 Functions added: `chunk` `decimalNotation` `round` `format` `isPlainObject` `cartesianProduct` **and** so forth
+- Feat 🥥 Type Utils: `Not` `IsNegative` `IsZero` `IsPositive` `Stringify`
+- Fix 🥕 Document: Added version tags to 19 methods
+- Other fixes and improvements
+
+不稳定版本
+
+- 功能 🥥 添加函数: `chunk` `decimalNotation` `round` `format` `isPlainObject` `cartesianProduct` 等
+- 功能 🥥 类型工具: `Not` `IsNegative` `IsZero` `IsPositive` `Stringify`
+- 修复 🥕 文档: 补充 19 个方法的版本标签
+- 其他修复与优化
+
 ## Version 0.3.1 - 2025-08-14
 
 Unstable version

package/lib/index.cmn.cjs

@@ -11,6 +11,57 @@ See the Mulan PSL v2 for more details.
 */
 'use strict';
 
+function cartesianProduct(...arrList) {
+    const arrLen = arrList.length;
+    const pList = Array(arrLen).fill(0);
+    const lastIndex = arrLen - 1;
+    const res = [];
+    for (let i = 0; i < arrLen; i++) {
+        if (!arrList[i].length)
+            return [];
+    }
+    while (1) {
+        const temp = [];
+        for (let i = 0; i < arrLen; i++) {
+            temp.push(arrList[i][pList[i]]);
+        }
+        res.push(temp);
+        pList[lastIndex] += 1;
+        for (let i = lastIndex; i >= 0; i--) {
+            if (pList[i] >= arrList[i].length) {
+                if (i > 0) {
+                    pList[i] = 0;
+                    pList[i - 1] += 1;
+                }
+                else
+                    break;
+            }
+            else
+                break;
+        }
+        if (pList[0] >= arrList[0].length)
+            break;
+    }
+    return res;
+}
+
+function castArray(value) {
+    return Array.isArray(value) ? value.slice() : [value];
+}
+
+function chunk(array, size = 2) {
+    const res = [];
+    if (size < 1 || isNaN(size))
+        return res;
+    let start = 0, end = size;
+    while (start < array.length) {
+        res.push(Array.prototype.slice.call(array, start, end));
+        start = end;
+        end += size;
+    }
+    return res;
+}
+
 function range(start, end, stepOrOptions) {
     if (!isFinite(start))
         throw new Error('start must be finite');
@@ -202,6 +253,22 @@ function isNumber(value) {
     return typeof value === 'number';
 }
 
+const fnToString = Function.prototype.toString;
+const objProtoContString = fnToString.call(Object.prototype.constructor);
+function isPlainObject(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype === null)
+        return true;
+    if (!Object.prototype.hasOwnProperty.call(prototype, "constructor"))
+        return false;
+    const constructorFn = prototype.constructor;
+    if (!isFunction(constructorFn) || fnToString.call(constructorFn) !== objProtoContString)
+        return false;
+    return (Object.getPrototypeOf(prototype) === null);
+}
+
 function isPrimitive(value) {
     return value === undefined || value === null || (typeof value !== 'object' && typeof value !== 'function');
 }
@@ -374,6 +441,373 @@ function clamp(num, min, max, options) {
     return num < min ? defaultMin : num > max ? defaultMax : num;
 }
 
+function decimalNotation(num) {
+    const n = isNumber(num) ? num : Number(num);
+    if (!isFinite(n))
+        return String(n);
+    let str = String(n);
+    if (!/e/i.test(str))
+        return str;
+    const match = str.match(/^(-?)(\d+)\.?(\d*)e([+-]?)(\d+)$/);
+    const [_, sign, mantissaI, mantissaF, expSign, _exponent] = match;
+    const exponent = Number(_exponent);
+    let mantissa = mantissaI + mantissaF;
+    let dotPos = mantissaI.length;
+    if (expSign === '-') {
+        const zeroCount = exponent - dotPos + 1;
+        if (zeroCount > 0)
+            mantissa = '0'.repeat(zeroCount) + mantissa;
+        return sign + mantissa[0] + '.' + mantissa.substring(1);
+    }
+    else {
+        const zeroCount = exponent + dotPos - mantissa.length;
+        if (zeroCount > 0)
+            mantissa = mantissa + '0'.repeat(zeroCount);
+        return sign + mantissa.substring(0, exponent + dotPos);
+    }
+}
+
+function isOdd(num) {
+    return !!(num & 1);
+}
+function isEven(num) {
+    return !(num & 1);
+}
+
+function round(num, precision, type) {
+    const str = decimalNotation(num);
+    if (/NaN|Inf/.test(str))
+        return str;
+    let [_integer, _fractional] = str.split('.');
+    let sign = '';
+    if (/^-/.test(_integer)) {
+        _integer = _integer.substring(1);
+        sign = '-';
+    }
+    _fractional = _fractional !== null && _fractional !== void 0 ? _fractional : '';
+    const roundMap = { round: roundBase, banker: roundBank, floor: roundFloor, ceil: roundCeil };
+    const [integer, fractional] = (roundMap[type || 'round'] || roundBase)(_integer, _fractional, precision, !!sign);
+    if (precision > 0)
+        return sign + integer + '.' + fractional;
+    else
+        return sign + integer;
+}
+function roundBase(integer, fractional, precision) {
+    if (fractional.length > precision) {
+        const splitF = fractional.substring(0, precision);
+        if (Number(fractional[precision]) > 4)
+            return increase(integer, splitF);
+        return [integer, splitF];
+    }
+    if (fractional.length < precision) {
+        fractional += '0'.repeat(precision - fractional.length);
+    }
+    return [integer, fractional];
+}
+function roundBank(integer, fractional, precision) {
+    if (fractional.length > precision) {
+        const splitF = fractional.substring(0, precision);
+        const rightNumber = Number(fractional[precision]);
+        if (rightNumber < 5)
+            return [integer, splitF];
+        if (rightNumber > 5)
+            return increase(integer, splitF);
+        const rightNumbers = fractional.substring(precision);
+        if (!/^50*$/.test(rightNumbers))
+            return increase(integer, splitF);
+        const leftNumber = Number(precision ? fractional[precision - 1] : integer[integer.length - 1]);
+        if (isEven(leftNumber))
+            return [integer, splitF];
+        else
+            return increase(integer, splitF);
+    }
+    if (fractional.length < precision) {
+        fractional += '0'.repeat(precision - fractional.length);
+    }
+    return [integer, fractional];
+}
+function roundFloor(integer, fractional, precision, isNegative) {
+    if (fractional.length > precision) {
+        const splitF = fractional.substring(0, precision);
+        if (isNegative)
+            return increase(integer, splitF);
+        return [integer, splitF];
+    }
+    if (fractional.length < precision) {
+        fractional += '0'.repeat(precision - fractional.length);
+    }
+    return [integer, fractional];
+}
+function roundCeil(integer, fractional, precision, isNegative) {
+    if (fractional.length > precision) {
+        const splitF = fractional.substring(0, precision);
+        if (!isNegative)
+            return increase(integer, splitF);
+        return [integer, splitF];
+    }
+    if (fractional.length < precision) {
+        fractional += '0'.repeat(precision - fractional.length);
+    }
+    return [integer, fractional];
+}
+function increase(integer, fractional) {
+    if (fractional) {
+        const _fractional = _increase(fractional);
+        if (_fractional.length > fractional.length) {
+            return [_increase(integer), _fractional.substring(1)];
+        }
+        return [integer, _fractional];
+    }
+    return [_increase(integer), ''];
+}
+function _increase(num) {
+    const numList = num.split('').map(Number).reverse();
+    numList[0] += 1;
+    numList.push(0);
+    for (let i = 0; i < numList.length; i++) {
+        if (numList[i] > 9) {
+            numList[i] -= 10;
+            numList[i + 1] += 1;
+        }
+        else
+            break;
+    }
+    if (numList[numList.length - 1] === 0)
+        numList.pop();
+    return numList.reverse().map(String).join('');
+}
+
+function format(num, options) {
+    var _a;
+    const str = decimalNotation(num);
+    if (/NaN|Inf/.test(str))
+        return str;
+    const separator = (options || {}).separator || ',';
+    const separate = clamp((options || {}).separate || 3, 1, Infinity);
+    const decimal = (options || {}).decimal || '.';
+    const precision = clamp((_a = (options || {}).precision) !== null && _a !== void 0 ? _a : 2, 0, Infinity);
+    const round = (options || {}).round || 'round';
+    let [integer, fractional] = str.split('.');
+    let sign = '';
+    if (/^-/.test(integer)) {
+        integer = integer.substring(1);
+        sign = '-';
+    }
+    fractional = fractional !== null && fractional !== void 0 ? fractional : '';
+    if (fractional.length > precision) {
+        const roundMap = { round: roundBase, banker: roundBank, floor: roundFloor, ceil: roundCeil };
+        [integer, fractional] = (roundMap[round] || roundBase)(integer, fractional, precision, !!sign);
+    }
+    else if (fractional.length < precision) {
+        fractional += '0'.repeat(precision - fractional.length);
+    }
+    if (integer.length > separate) {
+        integer = chunk(Array.from(integer).reverse(), separate)
+            .map((part) => part.join(''))
+            .join(separator);
+        integer = Array.from(integer).reverse().join('');
+    }
+    if (precision > 0)
+        return sign + integer + decimal + fractional;
+    else
+        return sign + integer;
+}
+
+function lerp(val1, val2, t) {
+    if (isNumber(val1)) {
+        if (!isNumber(val2))
+            throw new Error('Invalid val2 parameter: val2 should be a number');
+        return _lerp(val1, val2, t);
+    }
+    else if (isArray(val1)) {
+        if (!isArray(val2))
+            throw new Error('Invalid val2 parameter: val2 should be an Array');
+        if (val1.length !== val2.length) {
+            throw new Error(`Invalid val2 parameter: the length of val2 (${val2.length}) should be consistent with val1 (${val1.length})`);
+        }
+        if (val1.length === 0)
+            return [];
+        if (isNumber(val1[0])) {
+            if (!isNumber(val2[0]))
+                throw new Error('Invalid val2 parameter: val2 should be an Array<number>');
+            return val1.map((v1, index) => _lerp(v1, val2[index], t));
+        }
+        else if (isArray(val1[0])) {
+            const res = [];
+            for (let i = 0; i < val1.length; i++) {
+                const arr1 = val1[i];
+                const arr2 = val2[i];
+                if (arr1.length !== arr2.length) {
+                    throw new Error(`Invalid val2 parameter: The length of array at index ${i} in val2 (${arr2.length}) must match the length of the corresponding array in val1 (${arr1.length})`);
+                }
+                res.push(arr1.map((v1, index) => _lerp(v1, arr2[index], t)));
+            }
+            return res;
+        }
+    }
+    throw new Error('Invalid val1 parameter: val1 should be a number or Array');
+}
+function _lerp(val1, val2, t) {
+    return val1 + (val2 - val1) * t;
+}
+
+function romanNumerals(num, options) {
+    const str = decimalNotation(num);
+    if (/NaN|Inf/.test(str))
+        return str;
+    const type = (options || {}).type || 'unicode';
+    const thousand = (options || {}).thousand || 'normal';
+    const forceSplitThousand = thousand === 'strict';
+    const integer = str.split('.')[0].replace('-', '');
+    if (integer === '0') {
+        const zero = (options || {}).zero || '0';
+        if (type === 'json')
+            return `["${zero}"]`;
+        else
+            return zero;
+    }
+    if (integer === '1') {
+        const one = (options || {}).one || 'I';
+        if (type === 'json')
+            return `["${one}"]`;
+        else
+            return one;
+    }
+    const chunks = chunk(Array.from(integer).reverse(), 3);
+    const romanChunks = [];
+    for (let i = 0; i < chunks.length; i++) {
+        const val = Number(chunks[i].reverse().join(''));
+        if (i === chunks.length - 2 && !forceSplitThousand && Number(chunks[i + 1]) < 4) {
+            romanChunks.push(number2roman(val + Number(chunks[i + 1]) * 1000));
+            break;
+        }
+        else {
+            romanChunks.push(number2roman(val));
+        }
+    }
+    switch (type) {
+        case 'js':
+            return romanChunks
+                .map((str, index) => str
+                .split('')
+                .map((s) => s + '\\\\u0305'.repeat(index))
+                .join(''))
+                .reverse()
+                .join('');
+        case 'html':
+            return romanChunks
+                .map((str, index) => str
+                .split('')
+                .map((s) => s + '&#x0305;'.repeat(index))
+                .join(''))
+                .reverse()
+                .join('');
+        case 'json':
+            return `[${romanChunks.map((str) => `"${str}"`).join(', ')}]`;
+        case 'unicode':
+        default:
+            return romanChunks
+                .map((str, index) => str
+                .split('')
+                .map((s) => s + '\u0305'.repeat(index))
+                .join(''))
+                .reverse()
+                .join('');
+    }
+}
+function number2roman(num) {
+    const symbols = [
+        [1000, 'M'],
+        [900, 'CM'],
+        [500, 'D'],
+        [400, 'CD'],
+        [100, 'C'],
+        [90, 'XC'],
+        [50, 'L'],
+        [40, 'XL'],
+        [10, 'X'],
+        [9, 'IX'],
+        [5, 'V'],
+        [4, 'IV'],
+        [1, 'I'],
+    ];
+    let roman = '';
+    for (const [val, str] of symbols) {
+        while (num >= val) {
+            num -= val;
+            roman += str;
+        }
+        if (num == 0)
+            break;
+    }
+    return roman;
+}
+
+function scientificNotation(num, options) {
+    const str = decimalNotation(num);
+    if (/NaN|Inf/.test(str))
+        return str;
+    const type = (options || {}).type || 'unicode';
+    const _precision = (options || {}).precision;
+    const precision = isNumber(_precision) ? clamp(_precision !== null && _precision !== void 0 ? _precision : 2, 0, Infinity) : null;
+    const round = (options || {}).round || 'round';
+    let [integer, fractional] = str.split('.');
+    let sign = '';
+    if (/^-/.test(integer)) {
+        integer = integer.substring(1);
+        sign = '-';
+    }
+    fractional = fractional !== null && fractional !== void 0 ? fractional : '';
+    let exp = 0;
+    let n = '';
+    if (integer === '0') {
+        exp = /^(0+)/.test(fractional) ? -(fractional.match(/^(0+)/)[0].length + 1) : -1;
+        [integer, fractional] = [fractional.slice(-exp - 1, -exp), fractional.slice(-exp)];
+    }
+    else {
+        exp = integer.length - 1;
+        [integer, fractional] = [integer.slice(0, 1), integer.slice(1) + fractional];
+    }
+    if (isNumber(precision)) {
+        if (fractional.length > precision) {
+            const roundMap = { round: roundBase, banker: roundBank, floor: roundFloor, ceil: roundCeil };
+            [integer, fractional] = (roundMap[round] || roundBase)(integer, fractional, precision, !!sign);
+        }
+        else if (fractional.length < precision) {
+            fractional += '0'.repeat(precision - fractional.length);
+        }
+    }
+    else {
+        fractional = fractional.replace(/0+$/, '');
+    }
+    if ((precision === null && fractional) || (isNumber(precision) && precision > 0)) {
+        n = sign + integer + '.' + fractional;
+    }
+    else
+        n = sign + integer;
+    switch (type) {
+        case 'exp':
+            return `${n}e${exp < 0 ? '' : '+'}${exp}`;
+        case 'js':
+            return `${n}*10**${exp}`;
+        case 'code':
+            return `${n}*10^${exp}`;
+        case 'html':
+            return `${n}&#x00d7;10<sup>${exp}</sup>`;
+        case 'json':
+            return `{"number":"${n}","exp":${exp}}`;
+        case 'unicode':
+        default:
+            return `${n}×10${transferNumberToUniCode(String(exp))}`;
+    }
+}
+function transferNumberToUniCode(n) {
+    const strMap = Object.assign(Object.assign({}, Array.from('⁰¹²³⁴⁵⁶⁷⁸⁹')), { '-': '⁻', '+': '⁺' });
+    return Array.from(n)
+        .map((s) => (strMap[s] ? strMap[s] : s))
+        .join('');
+}
+
 function parallel(args, fn, options) {
     return __awaiter(this, void 0, void 0, function* () {
         if (!args.length)
@@ -1005,6 +1439,54 @@ function randomChoice(arr, weights) {
     return arr[index];
 }
 
+function randomDistribution(p, options) {
+    const threshold = (options === null || options === void 0 ? void 0 : options.threshold) ? Math.max(options.threshold, Number.MIN_VALUE * 2) : 5e-6;
+    const C = getInitP(p, threshold);
+    let current = C;
+    return function getRandomDistribution() {
+        const res = Math.random() < current;
+        if (res)
+            current = C;
+        else
+            current += C;
+        return res;
+    };
+}
+function getInitP(targetP, threshold = 5e-6) {
+    if (targetP <= 0)
+        return 0;
+    if (targetP >= 1)
+        return 1;
+    let [down, up] = [0, 1];
+    let mid = 1;
+    let tempP = 1;
+    let tempPLast = 1;
+    let step = 64;
+    while (step-- > 0) {
+        mid = (down + up) / 2;
+        tempP = getRealPFromInitP(mid);
+        if (Math.abs(tempPLast - tempP) < threshold)
+            break;
+        if (tempP > targetP)
+            up = mid;
+        else
+            down = mid;
+    }
+    return mid;
+}
+function getRealPFromInitP(initP) {
+    let sum = 0;
+    let prod = 0;
+    let cur = 0;
+    let max = Math.ceil(1 / initP);
+    for (let n = 1; n <= max; n++) {
+        cur = Math.min(1, n * initP) * (1 - prod);
+        prod += cur;
+        sum += n * cur;
+    }
+    return 1 / sum;
+}
+
 const radix32 = '0123456789abcdefghijklmnopqrstuv';
 const base32Chars = 'abcdefghijklmnopqrstuvwxyz234567';
 const base32Crockford = '0123456789abcdefghjkmnpqrstvwxyz';
@@ -1631,22 +2113,22 @@ function _deepClone(obj, map, options) {
     if (isFormData(obj))
         return _cloneFormData(obj, map, _deepClone, options);
     let res;
-    if (obj instanceof Date) {
+    if (isDate(obj)) {
         res = new Date(obj.valueOf());
         map.set(obj, res);
     }
-    else if (obj instanceof RegExp) {
+    else if (isRegExp(obj)) {
         res = new RegExp(obj.source, obj.flags);
         map.set(obj, res);
     }
-    else if (obj instanceof ArrayBuffer) {
+    else if (isArrayBuffer(obj)) {
         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) {
+    else if (isDataView(obj)) {
         res = new DataView(map.has(obj.buffer) ? map.get(obj.buffer) : _cloneArrayBuffer(obj.buffer, map), obj.byteOffset, obj.byteLength);
         map.set(obj, res);
     }
@@ -2048,23 +2530,29 @@ exports.acceptableFileName = acceptableFileName;
 exports.acceptableFileType = acceptableFileType;
 exports.camelCase = camelCase;
 exports.capitalize = capitalize;
+exports.cartesianProduct = cartesianProduct;
 exports.caseCamel = caseCamel;
 exports.caseConvert = caseConvert;
 exports.caseKebab = caseKebab;
 exports.casePascal = casePascal;
 exports.caseSnake = caseSnake;
+exports.castArray = castArray;
+exports.chunk = chunk;
 exports.clamp = clamp;
 exports.compose = compose;
 exports.curry = _curryMore;
 exports.debounce = debounce;
+exports.decimalNotation = decimalNotation;
 exports.dedent = dedent;
 exports.deepClone = deepClone;
 exports.deepMerge = deepMerge;
 exports.defer = defer;
 exports.fastClone = fastClone;
+exports.format = format;
 exports.getAcceptableExtByMIME = getAcceptableExtByMIME;
 exports.getAcceptableMIMEByExt = getAcceptableMIMEByExt;
 exports.getGlobalThis = getGlobalThis;
+exports.getInitP = getInitP;
 exports.getTag = getTag;
 exports.indent = indent;
 exports.isArray = isArray;
@@ -2079,6 +2567,7 @@ exports.isBuffer = isBuffer;
 exports.isDataView = isDataView;
 exports.isDate = isDate;
 exports.isEmpty = isEmpty;
+exports.isEven = isEven;
 exports.isFile = isFile;
 exports.isFloat32Array = isFloat32Array;
 exports.isFloat64Array = isFloat64Array;
@@ -2095,7 +2584,9 @@ exports.isNil = isNil;
 exports.isNull = isNull;
 exports.isNumber = isNumber;
 exports.isObject = isObject;
+exports.isOdd = isOdd;
 exports.isPlaceholder = isPlaceholder;
+exports.isPlainObject = isPlainObject;
 exports.isPrimitive = isPrimitive;
 exports.isPromise = isPromise;
 exports.isPromiseLike = isPromiseLike;
@@ -2118,6 +2609,7 @@ exports.isWrapperObject = isWrapperObject;
 exports.isWrapperString = isWrapperString;
 exports.isWrapperSymbol = isWrapperSymbol;
 exports.kebabCase = kebabCase;
+exports.lerp = lerp;
 exports.memo = memo;
 exports.noop = noop;
 exports.not = not;
@@ -2128,6 +2620,7 @@ exports.passWith = passWith;
 exports.pipe = pipe;
 exports.randomBase32String = randomBase32String;
 exports.randomChoice = randomChoice;
+exports.randomDistribution = randomDistribution;
 exports.randomHexString = randomHexString;
 exports.randomInt = randomInt;
 exports.randomIntFloor = randomIntFloor;
@@ -2135,6 +2628,13 @@ exports.randomString = randomString;
 exports.range = range;
 exports.remove = remove;
 exports.retry = retry;
+exports.romanNumerals = romanNumerals;
+exports.round = round;
+exports.roundBank = roundBank;
+exports.roundBase = roundBase;
+exports.roundCeil = roundCeil;
+exports.roundFloor = roundFloor;
+exports.scientificNotation = scientificNotation;
 exports.shuffle = shuffle;
 exports.sleep = sleep;
 exports.snakeCase = snakeCase;