foreslash 0.3.2 → 0.3.4

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Change Log
 
+## Version 0.3.4 - 2025-11-
+
+Unstable version
+
+- Feat 🥥 Functions added: `omit` `pick`
+- Other fixes and improvements
+
+不稳定版本
+
+- 功能 🥥 添加函数: `omit` `pick`
+- 其他修复与优化
+
+## 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

package/lib/index.cmn.cjs

@@ -45,6 +45,10 @@ function cartesianProduct(...arrList) {
     return res;
 }
 
+function castArray(value) {
+    return Array.isArray(value) ? value.slice() : [value];
+}
+
 function chunk(array, size = 2) {
     const res = [];
     if (size < 1 || isNaN(size))
@@ -609,6 +613,201 @@ function format(num, options) {
         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, 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)
@@ -1240,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';
@@ -1866,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);
     }
@@ -2242,6 +2489,27 @@ function not(value) {
     return !Boolean(value);
 }
 
+function omit(obj, keys) {
+    const res = (Object.getPrototypeOf(obj) ? {} : Object.create(null));
+    const ownKeys = Reflect.ownKeys(obj);
+    if (isFunction(keys)) {
+        for (let i = 0; i < ownKeys.length; i++) {
+            const key = ownKeys[i];
+            if (!keys(obj[key], key, obj))
+                res[key] = obj[key];
+        }
+    }
+    else {
+        const keysSet = new Set((isArray(keys) ? keys : [keys]).map((k) => (isNumber(k) ? String(k) : k)));
+        for (let i = 0; i < ownKeys.length; i++) {
+            const key = ownKeys[i];
+            if (!keysSet.has(key))
+                res[key] = obj[key];
+        }
+    }
+    return res;
+}
+
 function pass(value) {
     return value;
 }
@@ -2252,6 +2520,31 @@ function passWith(fn) {
     });
 }
 
+function pick(obj, keys) {
+    const res = (Object.getPrototypeOf(obj) ? {} : Object.create(null));
+    const ownKeys = Reflect.ownKeys(obj);
+    if (isFunction(keys)) {
+        for (let i = 0; i < ownKeys.length; i++) {
+            const key = ownKeys[i];
+            if (keys(obj[key], key, obj))
+                res[key] = obj[key];
+        }
+    }
+    else if (isArray(keys)) {
+        const keysSet = new Set(ownKeys);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            if (keysSet.has(isNumber(key) ? String(key) : key))
+                res[key] = obj[key];
+        }
+    }
+    else if (isString(keys) || isNumber(keys) || isSymbol(keys)) {
+        if (ownKeys.includes(isNumber(keys) ? String(keys) : keys))
+            res[keys] = obj[keys];
+    }
+    return res;
+}
+
 function pipe(...pipeFunc) {
     if (pipeFunc.length === 0) {
         throw new Error('Invalid pipeFunc parameter: pipeFunc is empty');
@@ -2289,6 +2582,7 @@ exports.caseConvert = caseConvert;
 exports.caseKebab = caseKebab;
 exports.casePascal = casePascal;
 exports.caseSnake = caseSnake;
+exports.castArray = castArray;
 exports.chunk = chunk;
 exports.clamp = clamp;
 exports.compose = compose;
@@ -2304,6 +2598,7 @@ exports.format = format;
 exports.getAcceptableExtByMIME = getAcceptableExtByMIME;
 exports.getAcceptableMIMEByExt = getAcceptableMIMEByExt;
 exports.getGlobalThis = getGlobalThis;
+exports.getInitP = getInitP;
 exports.getTag = getTag;
 exports.indent = indent;
 exports.isArray = isArray;
@@ -2360,16 +2655,20 @@ exports.isWrapperObject = isWrapperObject;
 exports.isWrapperString = isWrapperString;
 exports.isWrapperSymbol = isWrapperSymbol;
 exports.kebabCase = kebabCase;
+exports.lerp = lerp;
 exports.memo = memo;
 exports.noop = noop;
 exports.not = not;
+exports.omit = omit;
 exports.parallel = parallel;
 exports.pascalCase = pascalCase;
 exports.pass = pass;
 exports.passWith = passWith;
+exports.pick = pick;
 exports.pipe = pipe;
 exports.randomBase32String = randomBase32String;
 exports.randomChoice = randomChoice;
+exports.randomDistribution = randomDistribution;
 exports.randomHexString = randomHexString;
 exports.randomInt = randomInt;
 exports.randomIntFloor = randomIntFloor;
@@ -2377,11 +2676,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;