@rzl-zone/utils-js 3.7.1 → 3.9.0

package/dist/{chunk-YS27V6LS.js → chunk-3LE6NX57.js}

@@ -2,185 +2,14 @@
  * ====================================================
  * Rzl Utils-JS.
  * ----------------------------------------------------
- * Version: 3.7.1.
+ * Version: 3.9.0.
  * Author: Rizalvin Dwiky.
  * Repository: https://github.com/rzl-zone/utils-js.
  * ====================================================
  */
-import { safeStableStringify } from './chunk-2VO2CBTU.js';
-import { isString, assertIsPlainObject, isBoolean, getPreciseType } from './chunk-3KTD3QDI.js';
-
-var maxInt = 2147483647;
-var base = 36;
-var tMin = 1;
-var tMax = 26;
-var skew = 38;
-var damp = 700;
-var initialBias = 72;
-var initialN = 128;
-var delimiter = "-";
-var regexPunycode = /^xn--/;
-var regexNonASCII = /[^\0-\x7F]/;
-var regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g;
-var errors = {
-  overflow: "Overflow: input needs wider integers to process",
-  "not-basic": "Illegal input >= 0x80 (not a basic code point)",
-  "invalid-input": "Invalid input"
-};
-var floor = Math.floor;
-var stringFromCharCode = String.fromCharCode;
-function error(type) {
-  throw new RangeError(errors[type]);
-}
-function map(array, fn) {
-  const result = [];
-  let length = array.length;
-  while (length--) result[length] = fn(array[length]);
-  return result;
-}
-function mapDomain(domain, fn) {
-  const parts = domain.split("@");
-  let result = "";
-  if (parts.length > 1) {
-    result = parts[0] + "@";
-    domain = parts[1];
-  }
-  domain = domain.replace(regexSeparators, ".");
-  const labels = domain.split(".");
-  return result + map(labels, fn).join(".");
-}
-function ucs2decode(input) {
-  const output = [];
-  let counter = 0;
-  const length = input.length;
-  while (counter < length) {
-    const value = input.charCodeAt(counter++);
-    if (value >= 55296 && value <= 56319 && counter < length) {
-      const extra = input.charCodeAt(counter++);
-      if ((extra & 64512) === 56320)
-        output.push(((value & 1023) << 10) + (extra & 1023) + 65536);
-      else {
-        output.push(value);
-        counter--;
-      }
-    } else output.push(value);
-  }
-  return output;
-}
-var ucs2encode = (points) => String.fromCodePoint(...points);
-function basicToDigit(codePoint) {
-  if (codePoint >= 48 && codePoint < 58) return 26 + (codePoint - 48);
-  if (codePoint >= 65 && codePoint < 91) return codePoint - 65;
-  if (codePoint >= 97 && codePoint < 123) return codePoint - 97;
-  return base;
-}
-function digitToBasic(digit, flag) {
-  return digit + 22 + 75 * (digit < 26 ? 1 : 0) - Number(flag !== 0) * 32;
-}
-function adapt(delta, numPoints, firstTime) {
-  let k = 0;
-  delta = firstTime ? floor(delta / damp) : delta >> 1;
-  delta += floor(delta / numPoints);
-  while (delta > (base - tMin) * tMax >> 1) {
-    delta = floor(delta / (base - tMin));
-    k += base;
-  }
-  return floor(k + (base - tMin + 1) * delta / (delta + skew));
-}
-function decode(input) {
-  const output = [];
-  const inputLength = input.length;
-  let i = 0, n = initialN, bias = initialBias;
-  let basic = input.lastIndexOf(delimiter);
-  if (basic < 0) basic = 0;
-  for (let j = 0; j < basic; j++) {
-    if (input.charCodeAt(j) >= 128) error("not-basic");
-    output.push(input.charCodeAt(j));
-  }
-  for (let index = basic > 0 ? basic + 1 : 0; index < inputLength; ) {
-    const oldi = i;
-    let w = 1;
-    for (let k = base; ; k += base) {
-      if (index >= inputLength) error("invalid-input");
-      const digit = basicToDigit(input.charCodeAt(index++));
-      if (digit >= base) error("invalid-input");
-      if (digit > floor((maxInt - i) / w)) error("overflow");
-      i += digit * w;
-      const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
-      if (digit < t) break;
-      const baseMinusT = base - t;
-      if (w > floor(maxInt / baseMinusT)) error("overflow");
-      w *= baseMinusT;
-    }
-    const out = output.length + 1;
-    bias = adapt(i - oldi, out, oldi === 0);
-    if (floor(i / out) > maxInt - n) error("overflow");
-    n += floor(i / out);
-    i %= out;
-    output.splice(i++, 0, n);
-  }
-  return String.fromCodePoint(...output);
-}
-function encode(input) {
-  const output = [];
-  const points = ucs2decode(input);
-  const inputLength = points.length;
-  let n = initialN, delta = 0, bias = initialBias;
-  for (const cp of points) if (cp < 128) output.push(stringFromCharCode(cp));
-  const basicLength = output.length;
-  let handledCPCount = basicLength;
-  if (basicLength) output.push(delimiter);
-  while (handledCPCount < inputLength) {
-    let m = maxInt;
-    for (const cp of points) if (cp >= n && cp < m) m = cp;
-    const handledCPCountPlusOne = handledCPCount + 1;
-    if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) error("overflow");
-    delta += (m - n) * handledCPCountPlusOne;
-    n = m;
-    for (const cp of points) {
-      if (cp < n) delta++;
-      if (cp === n) {
-        let q = delta;
-        for (let k = base; ; k += base) {
-          const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
-          if (q < t) break;
-          output.push(stringFromCharCode(digitToBasic(t + (q - t) % (base - t), 0)));
-          q = floor((q - t) / (base - t));
-        }
-        output.push(stringFromCharCode(digitToBasic(q, 0)));
-        bias = adapt(delta, handledCPCountPlusOne, handledCPCount === basicLength);
-        delta = 0;
-        handledCPCount++;
-      }
-    }
-    delta++;
-    n++;
-  }
-  return output.join("");
-}
-function toUnicode(input) {
-  return mapDomain(
-    input,
-    (str) => regexPunycode.test(str) ? decode(str.slice(4).toLowerCase()) : str
-  );
-}
-function toASCII(input) {
-  return mapDomain(
-    input,
-    (str) => regexNonASCII.test(str) ? "xn--" + encode(str) : str
-  );
-}
-var punycodeUtilsJS = {
-  version: "1.0.0",
-  ucs2: {
-    decode: ucs2decode,
-    encode: ucs2encode
-  },
-  decode,
-  encode,
-  toASCII,
-  toUnicode
-};
+import { punycodeUtilsJS } from './chunk-GKDSBOYE.js';
+import { safeStableStringify } from './chunk-X6ULJZ3X.js';
+import { isString, assertIsPlainObject, isBoolean, getPreciseType } from './chunk-J4TT33ZX.js';
 
 var sldMap_default = {
   "com.ac": true,
@@ -1991,4 +1820,4 @@ ${msg}`
   });
 }
 
-export { isValidDomain, punycodeUtilsJS };
+export { isValidDomain };

package/dist/{chunk-PZQC3FZY.js → chunk-44X74C26.js}

@@ -2,14 +2,14 @@
  * ====================================================
  * Rzl Utils-JS.
  * ----------------------------------------------------
- * Version: 3.7.1.
+ * Version: 3.9.0.
  * Author: Rizalvin Dwiky.
  * Repository: https://github.com/rzl-zone/utils-js.
  * ====================================================
  */
-import { isEmptyString } from './chunk-JY4HLZ4W.js';
-import { isEmptyArray, isEmptyObject } from './chunk-VCVND6CH.js';
-import { assertIsPlainObject, hasOwnProp, assertIsBoolean, isNil, isNaN, isString, isArray, isObject } from './chunk-3KTD3QDI.js';
+import { isEmptyString } from './chunk-5O66AUEC.js';
+import { isEmptyArray, isEmptyObject } from './chunk-M5QB2GM5.js';
+import { assertIsPlainObject, hasOwnProp, assertIsBoolean, isNil, isNaN, isString, isArray, isObject } from './chunk-J4TT33ZX.js';
 
 var isEmptyValue = (value, options = {}) => {
   assertIsPlainObject(options, {

package/dist/{chunk-4ACKNPL5.js → chunk-5KDVIEVO.js}

@@ -2,12 +2,12 @@
  * ====================================================
  * Rzl Utils-JS.
  * ----------------------------------------------------
- * Version: 3.7.1.
+ * Version: 3.9.0.
  * Author: Rizalvin Dwiky.
  * Repository: https://github.com/rzl-zone/utils-js.
  * ====================================================
  */
-import { isNonEmptyString, isPlainObject } from './chunk-3KTD3QDI.js';
+import { isNonEmptyString, isPlainObject } from './chunk-J4TT33ZX.js';
 
 var removeSpaces = (value, options = {
   trimOnly: false

package/dist/{chunk-JY4HLZ4W.js → chunk-5O66AUEC.js}

@@ -2,12 +2,12 @@
  * ====================================================
  * Rzl Utils-JS.
  * ----------------------------------------------------
- * Version: 3.7.1.
+ * Version: 3.9.0.
  * Author: Rizalvin Dwiky.
  * Repository: https://github.com/rzl-zone/utils-js.
  * ====================================================
  */
-import { isNonEmptyString } from './chunk-3KTD3QDI.js';
+import { isNonEmptyString } from './chunk-J4TT33ZX.js';
 
 var isEmptyString = (value, options = {}) => {
   return !isNonEmptyString(value, options);

package/dist/chunk-5Y6JL47L.js

@@ -0,0 +1,302 @@
+/*!
+ * ====================================================
+ * Rzl Utils-JS.
+ * ----------------------------------------------------
+ * Version: 3.9.0.
+ * Author: Rizalvin Dwiky.
+ * Repository: https://github.com/rzl-zone/utils-js.
+ * ====================================================
+ */
+import { isInteger } from './chunk-WVSPXFTY.js';
+import { safeStableStringify } from './chunk-X6ULJZ3X.js';
+import { isNonEmptyArray, getPreciseType, isNumber, isPlainObject, assertIsBoolean, isNaN, isNonEmptyString, isBoolean } from './chunk-J4TT33ZX.js';
+
+function getRandomItem(array) {
+  if (!isNonEmptyArray(array)) return void 0;
+  const randomIndex = Math.floor(Math.random() * (array.length || 0));
+  return array[randomIndex];
+}
+
+var randomInt = (min, max) => {
+  if (!isInteger(min) || !isInteger(max)) {
+    throw new TypeError(
+      `First parameter (\`min\`) and second parameter (\`max\`) must be of type \`integer-number\`${minValueNote(
+        min,
+        max
+      )}value, but received: ['min': \`${getPreciseType(
+        min
+      )}\` - (with value: \`${safeStableStringify(min, {
+        keepUndefined: true
+      })})\`, 'max': \`${getPreciseType(max)}\` - (with value: \`${safeStableStringify(
+        max,
+        {
+          keepUndefined: true
+        }
+      )}\`)].`
+    );
+  }
+  if (min > max) {
+    throw new RangeError(
+      `First parameter (\`min\`) must be less than or equal to second parameter (\`max\`), but received: ['min': ${formatValue(
+        min
+      )} - (with value: \`${safeStableStringify(min, {
+        keepUndefined: true
+      })})\`, 'max': ${formatValue(max)} - (with value: \`${safeStableStringify(max, {
+        keepUndefined: true
+      })})\`].`
+    );
+  }
+  min = Math.max(1, min);
+  max = Math.min(Number.MAX_SAFE_INTEGER, max);
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+};
+var formatValue = (value) => {
+  return isNumber(value, { includeNaN: true }) ? value === Number.MIN_VALUE ? "`Number.MIN_VALUE`" : `${value}` : `\`${getPreciseType(value)}\``;
+};
+var minValueNote = (...values) => {
+  return values.some((v) => isNumber(v, { includeNaN: true }) && v === Number.MIN_VALUE) ? " and can't be `Number.MIN_VALUE` " : " ";
+};
+
+var randomIntByLength = (options) => {
+  if (!isPlainObject(options)) {
+    options = {};
+  }
+  const { minLength = 1, maxLength = 16, avoidZero = false } = options;
+  assertIsBoolean(avoidZero, {
+    message({ currentType, validType }) {
+      return `Parameters \`avoidZero\` must be of type \`${validType}\`, but received: \`${currentType}\`.`;
+    }
+  });
+  if (!isInteger(minLength) || !isInteger(maxLength)) {
+    throw new TypeError(
+      `Parameters \`minLength\` and \`maxLength\` must be of type \`integer-number\`, but received: ['minLength': \`${getPreciseType(
+        minLength
+      )}\` - (with value: ${safeStableStringify(minLength, {
+        keepUndefined: true
+      })}), 'maxLength': \`${getPreciseType(
+        maxLength
+      )}\` - (with value: ${safeStableStringify(maxLength, {
+        keepUndefined: true
+      })})].`
+    );
+  }
+  if (minLength < 1 || maxLength > 16 || minLength > maxLength) {
+    throw new RangeError(
+      `Invalid range at parameters \`minLength\` must be \u2265 1, \`maxLength\` must be \u2264 16, and \`minLength\` \u2264 \`maxLength\`, but received: ['minLength': \`${minLength}\`, 'maxLength': \`${maxLength}\`].`
+    );
+  }
+  const randomLength = minLength === maxLength ? minLength : randomInt(minLength, maxLength);
+  const minValue = 10 ** (randomLength - 1);
+  const maxValue = 10 ** randomLength - 1;
+  let result = randomInt(minValue, maxValue);
+  if (avoidZero && result === 0) {
+    result = minValue;
+  }
+  return result;
+};
+
+var randomStr = (options) => {
+  if (!isPlainObject(options)) {
+    options = {};
+  }
+  const {
+    minLength = 40,
+    maxLength = 40,
+    type = "string",
+    avoidWhiteSpace = true
+  } = options;
+  assertIsBoolean(avoidWhiteSpace, {
+    message({ currentType, validType }) {
+      return `Parameters \`avoidWhiteSpace\` property of the \`options\` (first-parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.`;
+    }
+  });
+  if (!isInteger(minLength) || !isInteger(maxLength)) {
+    throw new TypeError(
+      `Parameters \`minLength\` and \`maxLength\` must be of type \`integer-number\`, but received: ['minLength': \`${getPreciseType(
+        minLength
+      )}\` - (with value: ${safeStableStringify(minLength, {
+        keepUndefined: true
+      })}), 'maxLength': \`${getPreciseType(
+        maxLength
+      )}\` - (with value: ${safeStableStringify(maxLength, {
+        keepUndefined: true
+      })})].`
+    );
+  }
+  if (minLength < 1 || maxLength > 5e3 || minLength > maxLength) {
+    throw new RangeError(
+      `Invalid range at parameters \`minLength\` must be \u2265 1, \`maxLength\` must be \u2264 5000, and \`minLength\` \u2264 \`maxLength\`, but received: ['minLength': \`${minLength}\`, 'maxLength': \`${maxLength}\`].`
+    );
+  }
+  if (type !== "string" && type !== "number") {
+    throw new TypeError(
+      `Parameter \`type\` must be of type \`string\` with value one of "string" | "number", but received: \`${getPreciseType(
+        type
+      )}\`, with value: ${safeStableStringify(type, {
+        keepUndefined: true
+      })}.`
+    );
+  }
+  const length = randomInt(minLength, maxLength);
+  const cleanCharacters = (charSet) => {
+    return avoidWhiteSpace ? charSet.replace(/\s|\n|\t/g, "") : charSet;
+  };
+  const defaultNumberSet = "0123456789";
+  const defaultStringSet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  const baseCharSet = type === "number" ? (!isNaN(Number(options.replaceGenInt)) ? options.replaceGenInt : void 0) ?? defaultNumberSet : (options.replaceGenStr ? options.replaceGenStr : void 0) ?? defaultStringSet;
+  const characterSet = cleanCharacters(baseCharSet) + (options.addChar || "");
+  if (!characterSet.length) {
+    const errCharSet = () => {
+      if (type === "number") {
+        if (avoidWhiteSpace) {
+          return `If \`avoidWhiteSpace\` is true, and \`replaceGenInt\` cant be empty-string value, ensure \`replaceGenInt\` has valid characters and non-nan string number.`;
+        }
+        return `Ensure \`replaceGenInt\` has valid characters and not a NaN number string while convert to number.`;
+      }
+      return `Ensure \`replaceGenStr\` has valid characters and non empty string.`;
+    };
+    throw new Error(`Character set is empty. ${errCharSet()}`);
+  }
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += characterSet.charAt(Math.floor(Math.random() * characterSet.length));
+  }
+  return result;
+};
+
+function randomUUID(options = {}) {
+  if (!isPlainObject(options)) {
+    throw new TypeError(
+      `First parameter (\`options\`) must be a plain object with optional properties \`version\` and \`monotonic\`, but received: \`${getPreciseType(
+        options
+      )}\` - (with value: \`${safeStableStringify(options, { keepUndefined: true })}\`).`
+    );
+  }
+  const { version = "v4", monotonic = false } = options;
+  if (!isNonEmptyString(version)) {
+    throw new TypeError(
+      `Parameter \`version\` property of the \`options\` (first parameter) must be a \`string\` of either "v4" or "v7", but received type: \`${getPreciseType(
+        version
+      )}\` - (with value: \`${safeStableStringify(version, { keepUndefined: true })}\`).`
+    );
+  }
+  if (version !== "v4" && version !== "v7") {
+    throw new RangeError(
+      `Unsupported UUID version. Allowed values are "v4" or "v7". (received: \`${safeStableStringify(
+        version,
+        {
+          keepUndefined: true
+        }
+      )}\`).`
+    );
+  }
+  if (!isBoolean(monotonic)) {
+    throw new TypeError(
+      `Parameter \`monotonic\` property of the \`options\` (first parameter) must be a \`boolean\` when provided, but received type: \`${getPreciseType(
+        monotonic
+      )}\` - (with value: \`${safeStableStringify(monotonic, {
+        keepUndefined: true
+      })}\`).`
+    );
+  }
+  if (monotonic && version !== "v7") {
+    throw new TypeError(
+      `Parameter \`monotonic\` property of the \`options\` (first parameter) is only supported for version "v7". Received: version=${safeStableStringify(
+        version,
+        { keepUndefined: true }
+      )}.`
+    );
+  }
+  if (version === "v4") {
+    return generateUUIDv4();
+  }
+  return generateUUIDv7({ monotonic });
+}
+function hasCryptoGetRandomValues() {
+  return typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function";
+}
+function hasCryptoRandomUUID() {
+  return typeof crypto !== "undefined" && typeof crypto.randomUUID === "function";
+}
+function getRandomBytes(len) {
+  if (hasCryptoGetRandomValues()) {
+    return crypto.getRandomValues(new Uint8Array(len));
+  }
+  const arr = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    arr[i] = Math.floor(Math.random() * 256);
+  }
+  return arr;
+}
+var byteToHex = (() => {
+  const arr = [];
+  for (let i = 0; i < 256; ++i) {
+    arr.push((i + 256).toString(16).substring(1));
+  }
+  return arr;
+})();
+function generateUUIDv4() {
+  if (hasCryptoRandomUUID()) {
+    return crypto.randomUUID();
+  }
+  if (hasCryptoGetRandomValues()) {
+    const rnd = crypto.getRandomValues(new Uint8Array(16));
+    rnd[6] = rnd[6] & 15 | 64;
+    rnd[8] = rnd[8] & 63 | 128;
+    return byteToHex[rnd[0]] + byteToHex[rnd[1]] + byteToHex[rnd[2]] + byteToHex[rnd[3]] + "-" + byteToHex[rnd[4]] + byteToHex[rnd[5]] + "-" + byteToHex[rnd[6]] + byteToHex[rnd[7]] + "-" + byteToHex[rnd[8]] + byteToHex[rnd[9]] + "-" + byteToHex[rnd[10]] + byteToHex[rnd[11]] + byteToHex[rnd[12]] + byteToHex[rnd[13]] + byteToHex[rnd[14]] + byteToHex[rnd[15]];
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+var monotonicState = {
+  lastTimestampMs: -1,
+  lastRand: null
+};
+function incrementUint8ArrayBigEndian(arr) {
+  for (let i = arr.length - 1; i >= 0; i--) {
+    if (arr[i] === 255) {
+      arr[i] = 0;
+      continue;
+    }
+    arr[i] = arr[i] + 1 & 255;
+    return false;
+  }
+  return true;
+}
+function generateUUIDv7({ monotonic = false } = {}) {
+  const nowMs = Date.now();
+  const tsHex = BigInt(nowMs).toString(16).padStart(12, "0");
+  let rand = getRandomBytes(10);
+  if (monotonic) {
+    if (monotonicState.lastTimestampMs === nowMs && monotonicState.lastRand) {
+      const copy = new Uint8Array(monotonicState.lastRand);
+      const overflow = incrementUint8ArrayBigEndian(copy);
+      if (overflow) {
+        throw new RangeError(
+          "Monotonic UUID sequence overflow: too many UUIDs generated within the same millisecond."
+        );
+      }
+      rand = copy;
+      monotonicState.lastRand = copy;
+    } else {
+      const fresh = getRandomBytes(10);
+      monotonicState.lastRand = new Uint8Array(fresh);
+      monotonicState.lastTimestampMs = nowMs;
+      rand = fresh;
+    }
+  }
+  rand[0] = rand[0] & 15 | 112;
+  rand[2] = rand[2] & 63 | 128;
+  const randHex = Array.from(rand, (b) => byteToHex[b]).join("");
+  const part1 = tsHex.slice(0, 8);
+  const part2 = tsHex.slice(8, 12);
+  const part3 = randHex.slice(0, 4);
+  const part4 = randHex.slice(4, 8);
+  const part5 = randHex.slice(8, 20);
+  return [part1, part2, part3, part4, part5].join("-");
+}
+
+export { getRandomItem, randomInt, randomIntByLength, randomStr, randomUUID };