@rzl-zone/utils-js 3.9.1 → 3.11.0

package/dist/chunk-J4TT33ZX.js

@@ -1,584 +0,0 @@
-/*!
- * ====================================================
- * Rzl Utils-JS.
- * ----------------------------------------------------
- * Version: 3.9.1.
- * Author: Rizalvin Dwiky.
- * Repository: https://github.com/rzl-zone/utils-js.
- * ====================================================
- */
-var isBoolean = (value) => {
-  return typeof value === "boolean";
-};
-
-var isFunction = (value) => {
-  return typeof value === "function";
-};
-
-function isNil(value) {
-  return value == null;
-}
-
-function isArray(value) {
-  return Array.isArray(value);
-}
-
-function isObject(value) {
-  return typeof value === "object" && !isNil(value) && !isArray(value);
-}
-
-function isPlainObject(value) {
-  if (!isObject(value)) return false;
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
-}
-
-var isString = (value) => {
-  return typeof value === "string";
-};
-
-function isNumberObject(value) {
-  return isObject(value) && Object.prototype.toString.call(value) === "[object Number]";
-}
-
-function isNaN(value) {
-  return typeof value === "number" ? Number.isNaN(value) : isNumberObject(value) && Number.isNaN(value.valueOf());
-}
-
-var isNull = (val) => val === null;
-
-var assertIsBoolean = (value, options = {}) => {
-  if (isBoolean(value)) return;
-  resolveErrorMessageAssertions({
-    value,
-    options,
-    requiredValidType: "boolean"
-  });
-};
-
-var isNumber = (value, options = {}) => {
-  assertIsPlainObject(options, {
-    message: ({ currentType, validType: validType2 }) => `Second parameter (\`options\`) must be of type \`${validType2}\`, but received: \`${currentType}\`.`
-  });
-  const includeNaN = isPlainObject(options) && isBoolean(options.includeNaN) ? options.includeNaN : false;
-  assertIsBoolean(includeNaN, {
-    message: ({ currentType, validType: validType2 }) => `Parameter \`includeNaN\` property of the \`options\` (second parameter) must be of type \`${validType2}\`, but received: \`${currentType}\`.`
-  });
-  const aNumber = typeof value === "number";
-  return includeNaN ? aNumber : aNumber && !Number.isNaN(value);
-};
-
-var isSymbol = (value) => {
-  return typeof value === "symbol";
-};
-
-var isUndefined = (value) => {
-  return typeof value === "undefined";
-};
-
-function isObjectOrArray(value) {
-  return isArray(value) || isObject(value);
-}
-
-function hasOwnProp(obj, key, options = {}) {
-  if (!isString(obj) && !isObjectOrArray(obj) && !isFunction(obj)) return false;
-  assertIsPlainObject(options, {
-    message: ({ currentType, validType: validType2 }) => `Third parameter (\`options\`) must be of type \`${validType2}\`, but received: \`${currentType}\`.`
-  });
-  const discardUndefined = options.discardUndefined === void 0 ? true : options.discardUndefined;
-  const discardNull = options.discardNull === void 0 ? false : options.discardNull;
-  assertIsBoolean(discardUndefined, {
-    message: ({ currentType, validType: validType2 }) => `Parameter \`discardUndefined\` property of the \`options\` (third parameter) must be of type \`${validType2}\`, but received: \`${currentType}\`.`
-  });
-  assertIsBoolean(discardNull, {
-    message: ({ currentType, validType: validType2 }) => `Parameter \`discardNull\` property of the \`options\` (third parameter) must be of type \`${validType2}\`, but received: \`${currentType}\`.`
-  });
-  const path = [];
-  if (isString(key) && key.trim().length > 0 || isNumber(key, { includeNaN: true })) {
-    const strKey = isNumber(key, { includeNaN: true }) ? String(key) : key;
-    strKey.split(".").forEach((k) => {
-      const bracketMatch = k.match(/^\[(\d+)\]$/);
-      const symbolMatch = k.match(/^Symbol\((.+)\)$/);
-      if (bracketMatch) path.push(Number(bracketMatch[1]));
-      else if (symbolMatch) path.push(Symbol.for(symbolMatch[1]));
-      else if (!isNaN(Number(k))) path.push(Number(k));
-      else path.push(k);
-    });
-  } else if (isSymbol(key)) {
-    path.push(key);
-  } else {
-    return false;
-  }
-  let current = isString(obj) && obj.trim().length > 0 ? Object(obj) : obj;
-  for (const k of path) {
-    if (isString(k) && k.trim().length > 0 || isNumber(k, { includeNaN: true })) {
-      if (isNull(current) || !Object.prototype.hasOwnProperty.call(current, k)) {
-        return false;
-      }
-      current = current[k];
-    } else if (isSymbol(k)) {
-      if (isNull(current) || typeof current !== "object" && !isFunction(current)) {
-        return false;
-      }
-      const symbols = Object.getOwnPropertySymbols(current);
-      const matched = symbols.find((s) => s === k || s.description === k.description);
-      if (!matched) return false;
-      current = current[matched];
-    } else {
-      return false;
-    }
-  }
-  if (discardUndefined && isUndefined(current)) return false;
-  if (discardNull && isNull(current)) return false;
-  return true;
-}
-
-var isNonEmptyString = (value, options = {}) => {
-  if (!isString(value)) return false;
-  assertIsPlainObject(options, {
-    message: ({ currentType, validType: validType2 }) => `Second parameter (\`options\`) must be of type \`${validType2}\`, but received: \`${currentType}\`.`
-  });
-  const trim = hasOwnProp(options, "trim") ? options.trim : true;
-  assertIsBoolean(trim, {
-    message: ({ currentType, validType: validType2 }) => `Parameter \`trim\` property of the \`options\` (second parameter) must be of type \`${validType2}\`, but received: \`${currentType}\`.`
-  });
-  const str = trim ? value.trim() : value;
-  return str.length > 0;
-};
-
-var isError = (error) => {
-  return Object.prototype.toString.call(error) === "[object Error]" || error instanceof Error;
-};
-
-var isBuffer = (value) => {
-  return typeof Buffer !== "undefined" && typeof Buffer.isBuffer === "function" && Buffer.isBuffer(value);
-};
-
-function isStringObject(value) {
-  return isObject(value) && Object.prototype.toString.call(value) === "[object String]";
-}
-
-function isBooleanObject(value) {
-  return isObject(value) && Object.prototype.toString.call(value) === "[object Boolean]";
-}
-
-function isInfinityNumber(value) {
-  if (typeof value === "number" || isNumberObject(value)) {
-    const num = Number(value);
-    return num === Infinity || num === -Infinity;
-  }
-  return false;
-}
-
-var __internalAcronyms__ = Object.freeze([
-  "URI",
-  "URL",
-  "HTTP",
-  "HTTPS",
-  "HTML",
-  "XML",
-  "CSS",
-  "JS",
-  "JSON",
-  "SVG",
-  "DOM",
-  "UTC",
-  "XHR",
-  "RTC",
-  "ICE",
-  "TLS",
-  "TCP",
-  "UDP",
-  "IDB",
-  "ID"
-]);
-var FIXES_RAW = {
-  // primitives
-  string: "String",
-  number: "Number",
-  boolean: "Boolean",
-  bigint: "Big Int",
-  symbol: "Symbol",
-  undefined: "Undefined",
-  null: "Null",
-  regexp: "Reg Exp",
-  // reflect / proxy / atomics
-  reflect: "Reflect",
-  proxy: "Proxy",
-  atomics: "Atomics",
-  // core / objects
-  object: "Object",
-  array: "Array",
-  arguments: "Arguments",
-  function: "Function",
-  // functions
-  asyncfunction: "Async Function",
-  generatorfunction: "Generator Function",
-  asyncgeneratorfunction: "Async Generator Function",
-  generator: "Generator",
-  promise: "Promise",
-  // errors
-  evalerror: "Eval Error",
-  rangeerror: "Range Error",
-  referenceerror: "Reference Error",
-  syntaxerror: "Syntax Error",
-  typeerror: "Type Error",
-  urierror: "URI Error",
-  aggregateerror: "Aggregate Error",
-  error: "Error",
-  // typed arrays & binary
-  int8array: "Int 8 Array",
-  uint8array: "Uint 8 Array",
-  uint8clampedarray: "Uint 8 Clamped Array",
-  int16array: "Int 16 Array",
-  uint16array: "Uint 16 Array",
-  int32array: "Int 32 Array",
-  uint32array: "Uint 32 Array",
-  float32array: "Float 32 Array",
-  float64array: "Float 64 Array",
-  bigint64array: "Big Int 64 Array",
-  biguint64array: "Big Uint 64 Array",
-  arraybuffer: "Array Buffer",
-  sharedarraybuffer: "Shared Array Buffer",
-  dataview: "Data View",
-  arraybufferview: "Array Buffer View",
-  // collections
-  map: "Map",
-  set: "Set",
-  weakmap: "Weak Map",
-  weakset: "Weak Set",
-  // iterators (note: toString tag can be "Map Iterator" etc.)
-  mapiterator: "Map Iterator",
-  setiterator: "Set Iterator",
-  arrayiterator: "Array Iterator",
-  stringiterator: "String Iterator",
-  // streams / fetch / web
-  readablestream: "Readable Stream",
-  writablestream: "Writable Stream",
-  transformstream: "Transform Stream",
-  readablestreamdefaultreader: "Readable Stream Default Reader",
-  writablestreamdefaultwriter: "Writable Stream Default Writer",
-  readablestreamdefaultcontroller: "Readable Stream Default Controller",
-  transformstreamdefaultcontroller: "Transform Stream Default Controller",
-  abortcontroller: "Abort Controller",
-  abortsignal: "Abort Signal",
-  fetch: "fetch",
-  request: "Request",
-  response: "Response",
-  headers: "Headers",
-  formdata: "FormData",
-  blob: "Blob",
-  file: "File",
-  filelist: "FileList",
-  filereader: "FileReader",
-  // intl
-  intl: "Intl",
-  collator: "Intl. Collator",
-  datetimeformat: "Intl. Date Time Format",
-  listformat: "Intl. List Format",
-  numberformat: "Intl. Number Format",
-  pluralrules: "Intl. Plural Rules",
-  relativetimeformat: "Intl. Relative Time Format",
-  segmenter: "Intl. Segmenter",
-  locale: "Intl. Locale",
-  displaynames: "Intl. Display Names",
-  // es2021+
-  finalizationregistry: "Finalization Registry",
-  weakref: "Weak Ref",
-  structuredclone: "structured Clone",
-  urlpattern: "URL Pattern",
-  // performance / observers
-  performance: "Performance",
-  performanceobserver: "Performance Observer",
-  performanceentry: "Performance Entry",
-  performancemark: "Performance Mark",
-  performancemeasure: "Performance Measure",
-  // webassembly
-  webassembly: "Web Assembly",
-  wasmmodule: "WebAssembly .Module",
-  wasminstance: "WebAssembly. Instance",
-  wasmmemory: "WebAssembly. Memory",
-  wasmtable: "WebAssembly. Table",
-  // node-ish / common hosts
-  buffer: "Buffer",
-  process: "Process",
-  eventemitter: "Event Emitter",
-  stream: "Stream",
-  fs: "fs",
-  path: "path",
-  url: "URL",
-  urlsearchparams: "URL Search Params",
-  // DOM basics
-  node: "Node",
-  element: "Element",
-  htmlelement: "HTML Element",
-  svgelement: "SVG Element",
-  document: "Document",
-  documentfragment: "Document Fragment",
-  shadowroot: "Shadow Root",
-  nodelist: "Node List",
-  htmlcollection: "HTML Collection",
-  // observers / misc DOM
-  mutationobserver: "Mutation Observer",
-  intersectionobserver: "Intersection Observer",
-  resizeobserver: "Resize Observer"
-};
-
-function isNonEmptyArray(value) {
-  return Array.isArray(value) && value.length > 0;
-}
-
-function isSet(value) {
-  return Object.prototype.toString.call(value) === "[object Set]" || value instanceof Set;
-}
-
-var validateCaseInputWordsCase = (input) => {
-  let result = "";
-  if (isArray(input)) {
-    result = input.map((x) => isNonEmptyString(x) ? x.trim() : "").filter((x) => x.length).join("-");
-  } else if (isNonEmptyString(input)) {
-    result = input.trim();
-  }
-  return result.split(/[^\p{L}\p{N}]+/u).filter(Boolean);
-};
-var validateCaseIgnoreWordsCase = (ignoreWord) => {
-  const result = /* @__PURE__ */ new Set([]);
-  const normalizeWord = (word) => word.trim().split(/[^\p{L}\p{N}]+/u).filter(Boolean).join("");
-  if (isNonEmptyString(ignoreWord)) {
-    const clean = normalizeWord(ignoreWord);
-    if (clean) result.add(clean);
-  }
-  if (isNonEmptyArray(ignoreWord)) {
-    ignoreWord.forEach((w) => {
-      if (isNonEmptyString(w)) {
-        const clean = normalizeWord(w);
-        if (clean) result.add(clean);
-      }
-    });
-  }
-  if (isSet(ignoreWord)) {
-    ignoreWord.forEach((w) => {
-      if (isNonEmptyString(w)) {
-        const clean = normalizeWord(w);
-        if (clean) result.add(clean);
-      }
-    });
-  }
-  return result;
-};
-
-var slugify = (input, ignoreWord) => {
-  if (!isNonEmptyArray(input) && !isNonEmptyString(input)) return "";
-  const wordsValidated = validateCaseInputWordsCase(input);
-  const ignoreWordsValidated = validateCaseIgnoreWordsCase(ignoreWord);
-  const slug = wordsValidated.map((word) => {
-    if (ignoreWordsValidated.has(word)) return word;
-    return word.toLowerCase();
-  }).join("-");
-  return slug.replace(/^-+|-+$/g, "");
-};
-
-var toDotCase = (input, ignoreWord) => {
-  if (!isNonEmptyArray(input) && !isNonEmptyString(input)) return "";
-  const wordsValidated = validateCaseInputWordsCase(input);
-  const ignoreWordsValidated = validateCaseIgnoreWordsCase(ignoreWord);
-  return wordsValidated.map((word) => {
-    if (ignoreWordsValidated.has(word)) return word;
-    return word.toLowerCase();
-  }).join(".");
-};
-
-var toCamelCase = (input, ignoreWord) => {
-  if (!isNonEmptyArray(input) && !isNonEmptyString(input)) return "";
-  const wordsValidated = validateCaseInputWordsCase(input);
-  const ignoreWordsValidated = validateCaseIgnoreWordsCase(ignoreWord);
-  return wordsValidated.map((word, index) => {
-    if (ignoreWordsValidated.has(word)) return word;
-    return index === 0 ? word.toLowerCase() : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
-  }).join("");
-};
-
-var toKebabCase = (input, ignoreWord) => {
-  if (!isNonEmptyArray(input) && !isNonEmptyString(input)) return "";
-  const wordsValidated = validateCaseInputWordsCase(input);
-  const ignoreWordsValidated = validateCaseIgnoreWordsCase(ignoreWord);
-  return wordsValidated.map((word) => {
-    if (ignoreWordsValidated.has(word)) return word;
-    return word.toLowerCase();
-  }).join("-");
-};
-
-var toSnakeCase = (input, ignoreWord) => {
-  if (!isNonEmptyArray(input) && !isNonEmptyString(input)) return "";
-  const wordsValidated = validateCaseInputWordsCase(input);
-  const ignoreWordsValidated = validateCaseIgnoreWordsCase(ignoreWord);
-  return wordsValidated.map((word) => {
-    if (ignoreWordsValidated.has(word)) return word;
-    return word.toLowerCase();
-  }).join("_");
-};
-
-var toLowerCase = (input, ignoreWord) => {
-  if (!isNonEmptyArray(input) && !isNonEmptyString(input)) return "";
-  const wordsValidated = validateCaseInputWordsCase(input);
-  const ignoreWordsValidated = validateCaseIgnoreWordsCase(ignoreWord);
-  return wordsValidated.map((word) => {
-    if (ignoreWordsValidated.has(word)) return word;
-    return word.toLowerCase();
-  }).join(" ");
-};
-
-var toPascalCase = (input, ignoreWord) => {
-  if (!isNonEmptyArray(input) && !isNonEmptyString(input)) return "";
-  const wordsValidated = validateCaseInputWordsCase(input);
-  const ignoreWordsValidated = validateCaseIgnoreWordsCase(ignoreWord);
-  return wordsValidated.map((word) => {
-    if (ignoreWordsValidated.has(word)) return word;
-    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
-  }).join("");
-};
-
-var toPascalCaseSpace = (input, ignoreWord) => {
-  if (!isNonEmptyArray(input) && !isNonEmptyString(input)) return "";
-  const wordsValidated = validateCaseInputWordsCase(input);
-  const ignoreWordsValidated = validateCaseIgnoreWordsCase(ignoreWord);
-  return wordsValidated.map((word) => {
-    if (ignoreWordsValidated.has(word)) return word;
-    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
-  }).join(" ");
-};
-
-var normalizeKey = (k) => k.replace(/[\s_\-]+/g, "").toLowerCase();
-var FIXES = Object.entries(FIXES_RAW).reduce((acc, [k, v]) => {
-  acc[normalizeKey(k)] = v;
-  return acc;
-}, {});
-function isProxy(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const tag = Object.prototype.toString.call(value);
-  const skipTags = [
-    "[object Array]",
-    "[object Date]",
-    "[object RegExp]",
-    "[object Map]",
-    "[object Set]",
-    "[object WeakMap]",
-    "[object WeakSet]",
-    "[object Function]",
-    "[object Error]",
-    "[object Promise]",
-    "[object Generator]",
-    "[object GeneratorFunction]",
-    "[object AsyncFunction]"
-  ];
-  if (skipTags.includes(tag)) return false;
-  try {
-    Reflect.defineProperty(value, "__proxy_detect__", {
-      configurable: true,
-      value: 1
-    });
-    Reflect.deleteProperty(value, "__proxy_detect__");
-    return false;
-  } catch {
-    return true;
-  }
-}
-var converterHelper = (input, formatCase) => {
-  if (formatCase === "toPascalCaseSpace")
-    return toPascalCaseSpace(input, __internalAcronyms__);
-  if (formatCase === "slugify") return slugify(input, __internalAcronyms__);
-  if (formatCase === "toCamelCase") return toCamelCase(input, __internalAcronyms__);
-  if (formatCase === "toDotCase") return toDotCase(input, __internalAcronyms__);
-  if (formatCase === "toKebabCase") return toKebabCase(input, __internalAcronyms__);
-  if (formatCase === "toPascalCase") return toPascalCase(input, __internalAcronyms__);
-  if (formatCase === "toSnakeCase") return toSnakeCase(input, __internalAcronyms__);
-  return toLowerCase(input, __internalAcronyms__);
-};
-var getPreciseType = (value, options = { formatCase: "toLowerCase" }) => {
-  if (!isPlainObject(options)) options = {};
-  const formatCase = options.formatCase;
-  if (isNull(value)) {
-    return converterHelper(FIXES[normalizeKey("null")] ?? "Null", formatCase);
-  }
-  if (isNaN(value)) return "NaN";
-  if (isInfinityNumber(value)) return String(value);
-  if (isNumberObject(value)) return converterHelper("Number Constructor", formatCase);
-  if (isStringObject(value)) return converterHelper("String Constructor", formatCase);
-  if (isBooleanObject(value)) return converterHelper("Boolean Constructor", formatCase);
-  const prim = typeof value;
-  if (!isObjectOrArray(value) && !isFunction(value)) {
-    return converterHelper(FIXES[normalizeKey(prim)] ?? prim, formatCase);
-  }
-  if (isBuffer(value)) {
-    return converterHelper(FIXES[normalizeKey("buffer")] ?? "Buffer", formatCase);
-  }
-  if (isProxy(value)) {
-    return converterHelper(FIXES[normalizeKey("proxy")] ?? "Proxy", formatCase);
-  }
-  if (isObject(value) && isFunction(value?.next) && isFunction(value?.throw)) {
-    return converterHelper(FIXES[normalizeKey("generator")] ?? "Generator", formatCase);
-  }
-  if (isError(value)) {
-    const ctorName2 = value.constructor?.name ?? "Error";
-    return converterHelper(
-      FIXES[normalizeKey(ctorName2)] ?? FIXES[normalizeKey(ctorName2.replace(/\s+/g, ""))] ?? ctorName2,
-      formatCase
-    );
-  }
-  if (isNull(Object.getPrototypeOf(value))) {
-    return converterHelper(FIXES[normalizeKey("object")] ?? "Object", formatCase);
-  }
-  const tag = Object.prototype.toString.call(value).slice(8, -1) || "Object";
-  const mapped = FIXES[normalizeKey(tag)];
-  if (mapped) return converterHelper(mapped, formatCase);
-  const ctorName = value?.constructor?.name;
-  if (ctorName && ctorName !== "Object") {
-    return converterHelper(FIXES[normalizeKey(ctorName)] ?? ctorName, formatCase);
-  }
-  return converterHelper(tag, formatCase);
-};
-var determineErrorTypeAssertion = (type, message) => {
-  switch (type) {
-    case "Error":
-      throw new Error(message);
-    case "EvalError":
-      throw new EvalError(message);
-    case "RangeError":
-      throw new RangeError(message);
-    case "ReferenceError":
-      throw new ReferenceError(message);
-    case "SyntaxError":
-      throw new SyntaxError(message);
-    case "URIError":
-      throw new URIError(message);
-    case "TypeError":
-      throw new TypeError(message);
-    default:
-      throw new TypeError(message);
-  }
-};
-function resolveErrorMessageAssertions(params) {
-  const { requiredValidType, value, options } = params || {};
-  const {
-    message,
-    formatCase,
-    errorType = "TypeError"
-  } = isPlainObject(options) ? options : {};
-  const validType2 = toKebabCase(requiredValidType);
-  const currentType = getPreciseType(value, { formatCase });
-  const messageFnOptions = { currentType, validType: validType2 };
-  const defaultMessage = `Parameter input (\`value\`) must be of type \`${validType2}\`, but received: \`${currentType}\`.`;
-  const errorMessage = isFunction(message) ? isNonEmptyString(message(messageFnOptions)) ? message(messageFnOptions).trim() : defaultMessage : isNonEmptyString(message) ? message.trim() : defaultMessage;
-  return determineErrorTypeAssertion(errorType, errorMessage);
-}
-
-function assertIsPlainObject(value, options = {}) {
-  if (isPlainObject(value)) return;
-  resolveErrorMessageAssertions({
-    value,
-    options,
-    requiredValidType: "plain object"
-  });
-}
-
-export { assertIsBoolean, assertIsPlainObject, getPreciseType, hasOwnProp, isArray, isBoolean, isBooleanObject, isBuffer, isError, isFunction, isInfinityNumber, isNaN, isNil, isNonEmptyArray, isNonEmptyString, isNull, isNumber, isNumberObject, isObject, isObjectOrArray, isPlainObject, isSet, isString, isStringObject, isSymbol, isUndefined, resolveErrorMessageAssertions, slugify, toCamelCase, toDotCase, toKebabCase, toLowerCase, toPascalCase, toPascalCaseSpace, toSnakeCase };