foreslash 0.3.1 → 0.3.3

package/lib/index.umd.js

@@ -15,6 +15,57 @@ See the Mulan PSL v2 for more details.
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.foreslash = {}));
 })(this, (function (exports) { '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');
@@ -206,6 +257,22 @@ See the Mulan PSL v2 for more details.
       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');
   }
@@ -378,6 +445,373 @@ See the Mulan PSL v2 for more details.
       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)
@@ -1009,6 +1443,54 @@ See the Mulan PSL v2 for more details.
       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';
@@ -1635,22 +2117,22 @@ See the Mulan PSL v2 for more details.
       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);
       }
@@ -2052,23 +2534,29 @@ See the Mulan PSL v2 for more details.
   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;
@@ -2083,6 +2571,7 @@ See the Mulan PSL v2 for more details.
   exports.isDataView = isDataView;
   exports.isDate = isDate;
   exports.isEmpty = isEmpty;
+  exports.isEven = isEven;
   exports.isFile = isFile;
   exports.isFloat32Array = isFloat32Array;
   exports.isFloat64Array = isFloat64Array;
@@ -2099,7 +2588,9 @@ See the Mulan PSL v2 for more details.
   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;
@@ -2122,6 +2613,7 @@ See the Mulan PSL v2 for more details.
   exports.isWrapperString = isWrapperString;
   exports.isWrapperSymbol = isWrapperSymbol;
   exports.kebabCase = kebabCase;
+  exports.lerp = lerp;
   exports.memo = memo;
   exports.noop = noop;
   exports.not = not;
@@ -2132,6 +2624,7 @@ See the Mulan PSL v2 for more details.
   exports.pipe = pipe;
   exports.randomBase32String = randomBase32String;
   exports.randomChoice = randomChoice;
+  exports.randomDistribution = randomDistribution;
   exports.randomHexString = randomHexString;
   exports.randomInt = randomInt;
   exports.randomIntFloor = randomIntFloor;
@@ -2139,6 +2632,13 @@ See the Mulan PSL v2 for more details.
   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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "foreslash",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Foreslash is a Javascript utilities lib which contains plenty of practical functions.",
   "author": "moushu",
   "license": "Mulan PSL v2",
@@ -35,11 +35,11 @@
   "scripts": {
     "dev": "rollup -c -w",
     "build": "rollup -c",
-    "test": "jest --coverage",
-    "prepublishOnly": "npm run build && npm run test",
-    "docs:dev": "vitepress dev docs",
-    "docs:build": "vitepress build docs",
-    "docs:preview": "vitepress preview docs"
+    "test": "tsd --files /test/**/*.test-d.ts && jest --coverage",
+    "prepublishOnly": "jest --coverage && npm run build",
+    "docs:dev": "rollup -c && vitepress dev docs",
+    "docs:build": "rollup -c && vitepress build docs",
+    "docs:preview": "rollup -c && vitepress preview docs"
   },
   "keywords": [
     "foreslash",
@@ -57,6 +57,7 @@
     "rollup-plugin-dts": "^6.2.1",
     "sass-embedded": "^1.90.0",
     "ts-jest": "^29.2.5",
+    "tsd": "^0.33.0",
     "tslib": "^2.7.0",
     "typescript": "^5.5.4",
     "vitepress": "^1.6.3",