intelicoreact 1.8.69 → 2.0.0

package/dist/utils.cjs

@@ -0,0 +1,700 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  addBitDepthPoints: () => addBitDepthPoints,
+  assertions: () => assertions_default,
+  capitalized: () => capitalized,
+  changeMeta: () => changeMeta,
+  checkedRef: () => checkedRef,
+  clone: () => clone,
+  compare: () => compare,
+  compareAlphabetical: () => compareAlphabetical,
+  debounce: () => debounce,
+  downloadEmulation: () => downloadEmulation,
+  downloadFile: () => downloadFile,
+  firstLetterCapital: () => firstLetterCapital,
+  getBase64: () => getBase64,
+  getColorById: () => getColorById,
+  getCorrectTestId: () => getCorrectTestId,
+  getIsOnlyAnObject: () => getIsOnlyAnObject,
+  getOS: () => getOS,
+  getResponseClone: () => getResponseClone,
+  getStyles: () => getStyles,
+  getUniqueFileExtensions: () => getUniqueFileExtensions,
+  handleObjectChange: () => handleObjectChange,
+  logout: () => logout,
+  omitKeys: () => omitKeys,
+  renderFileSize: () => renderFileSize,
+  safeValue: () => safeValue_default,
+  setCarretToEnd: () => setCarretToEnd,
+  throttle: () => throttle,
+  transformDateOrTimeOrTogetherToFormat: () => transformDateOrTimeOrTogetherToFormat,
+  transformDateOrTimeOrTogetherToFormattedLocal: () => transformDateOrTimeOrTogetherToFormattedLocal,
+  transformLocalTimeToUTC: () => transformLocalTimeToUTC,
+  transformUTCHoursToLocal: () => transformUTCHoursToLocal,
+  transformUTCTimeToLocal: () => transformUTCTimeToLocal,
+  typesGuards: () => typeGuards_default,
+  useOutsideToggle: () => useOutsideToggle,
+  uuid: () => uuid
+});
+module.exports = __toCommonJS(utils_exports);
+
+// src/Functions/guards/typeGuards.ts
+var isArray = (value) => Array.isArray(value);
+function isObject(value) {
+  return typeof value === "object" && value !== null && !isArray(value);
+}
+var isNumber = (value) => typeof value === "number";
+var isString = (value) => typeof value === "string";
+var isBoolean = (value) => typeof value === "boolean";
+var isFunction = (value) => typeof value === "function";
+var isInstanceOf = (value, classType) => value instanceof classType;
+function isEnumValue(enumObject, value) {
+  return Object.values(enumObject).includes(value);
+}
+function isNullOrUndefined(value) {
+  return value === null || value === void 0;
+}
+var isTruthy = (value) => !!value;
+var isEmptyObject = (value) => isObject(value) && Object.keys(value).length === 0;
+function isTypedArray(value, type) {
+  return isArray(value) && value.every((item) => item instanceof type);
+}
+function isArrayWithLength(value, length) {
+  return isArray(value) && value.length === length;
+}
+var isEmptyArray = (value) => Array.isArray(value) && value.length === 0;
+function isTypeOrNull(value, type) {
+  return value === null || value instanceof type;
+}
+var nonNullable = (value) => value !== null && value !== void 0;
+var isDate = (value) => value instanceof Date;
+var isPromise = (value) => value instanceof Promise;
+var isRegExp = (value) => value instanceof RegExp;
+function isPrimitive(value) {
+  return value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+var isError = (value) => value instanceof Error;
+var isSymbol = (value) => typeof value === "symbol";
+var isMap = (value) => value instanceof Map;
+var isSet = (value) => value instanceof Set;
+function isReactElement(value) {
+  return isObject(value) && "type" in value && "props" in value && "$$typeof" in value;
+}
+function isReactComponent(value) {
+  return isFunction(value) || isObject(value) && "render" in value;
+}
+function isComponentType(value, componentType) {
+  return isReactElement(value) && value.type === componentType;
+}
+function isReactEvent(value) {
+  return isObject(value) && "nativeEvent" in value && "currentTarget" in value && "target" in value;
+}
+function isRef(value) {
+  return isObject(value) && "current" in value;
+}
+function isContext(value) {
+  return isObject(value) && "Provider" in value && "Consumer" in value;
+}
+function isType(value) {
+  const type = typeof value;
+  return type === "string" || type === "number" || type === "boolean" || type === "object" || type === "function" || type === "undefined" || type === "symbol" || type === "bigint";
+}
+var typesGuards = {
+  isArray,
+  isObject,
+  isNumber,
+  isString,
+  isBoolean,
+  isFunction,
+  isInstanceOf,
+  isEnumValue,
+  isNullOrUndefined,
+  isTruthy,
+  isEmptyObject,
+  isEmptyArray,
+  isTypedArray,
+  isArrayWithLength,
+  isTypeOrNull,
+  nonNullable,
+  isDate,
+  isPromise,
+  isRegExp,
+  isPrimitive,
+  isError,
+  isSymbol,
+  isMap,
+  isSet,
+  isReactElement,
+  isReactComponent,
+  isComponentType,
+  isReactEvent,
+  isRef,
+  isContext,
+  isType
+};
+var typeGuards_default = typesGuards;
+
+// src/Functions/guards/assertions.ts
+function assertArray(value, message) {
+  if (!Array.isArray(value)) {
+    throw new TypeError(message || "Expected value to be an array");
+  }
+}
+function assertObject(value, message) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new TypeError(message || "Expected value to be an object");
+  }
+}
+function assertNumber(value, message) {
+  if (typeof value !== "number") {
+    throw new TypeError(message || "Expected value to be a number");
+  }
+}
+function assertString(value, message) {
+  if (typeof value !== "string") {
+    throw new TypeError(message || "Expected value to be a string");
+  }
+}
+function assertBoolean(value, message) {
+  if (typeof value !== "boolean") {
+    throw new TypeError(message || "Expected value to be a boolean");
+  }
+}
+function assertFunction(value, message) {
+  if (typeof value !== "function") {
+    throw new TypeError(message || "Expected value to be a function");
+  }
+}
+function assertInstanceOf(value, classType, message) {
+  if (!(value instanceof classType)) {
+    throw new TypeError(message || `Expected value to be an instance of ${classType.name}`);
+  }
+}
+function assertEnumValue(enumObject, value, message) {
+  if (!Object.values(enumObject).includes(value)) {
+    throw new TypeError(
+      message || `Expected value to be one of: ${Object.values(enumObject).join(", ")}`
+    );
+  }
+}
+function assertReactElement(value, message) {
+  if (!(typeGuards_default.isObject(value) && "type" in value && "props" in value && "$$typeof" in value)) {
+    throw new TypeError(message || "Expected value to be a React element");
+  }
+}
+function assertReactComponent(value, message) {
+  if (!(typeof value === "function" || typeGuards_default.isObject(value) && "render" in value)) {
+    throw new TypeError(message || "Expected value to be a React component");
+  }
+}
+function assertNonNullable(value, message) {
+  if (value === null || value === void 0) {
+    throw new TypeError(message || "Expected value to be non-nullable");
+  }
+}
+function assertTruthy(value, message) {
+  if (!value) {
+    throw new TypeError(message || "Expected value to be truthy");
+  }
+}
+function assertFalsy(value, message) {
+  if (value) {
+    throw new TypeError(message || "Expected value to be falsy");
+  }
+}
+function assertDefined(value, message) {
+  if (value === void 0) {
+    throw new TypeError(message || "Expected value to be defined");
+  }
+}
+function assertNotEmptyString(value, message) {
+  if (value === "") {
+    throw new TypeError(message || "Expected string to be not empty");
+  }
+}
+function assertPositiveNumber(value, message) {
+  if (value <= 0) {
+    throw new TypeError(message || "Expected number to be positive");
+  }
+}
+function assertNegativeNumber(value, message) {
+  if (value >= 0) {
+    throw new TypeError(message || "Expected number to be negative");
+  }
+}
+function assertArrayNotEmpty(value, message) {
+  if (value.length === 0) {
+    throw new TypeError(message || "Expected array to be not empty");
+  }
+}
+var assertions = {
+  assertArray,
+  assertObject,
+  assertNumber,
+  assertString,
+  assertBoolean,
+  assertFunction,
+  assertInstanceOf,
+  assertEnumValue,
+  assertReactElement,
+  assertReactComponent,
+  assertNonNullable,
+  assertTruthy,
+  assertFalsy,
+  assertDefined,
+  assertNotEmptyString,
+  assertPositiveNumber,
+  assertNegativeNumber,
+  assertArrayNotEmpty
+};
+var assertions_default = assertions;
+
+// src/Constants/index.constants.js
+var KEYBOARD_SERVICE_KEYS = [
+  "Escape",
+  "F1",
+  "F2",
+  "F3",
+  "F4",
+  "F5",
+  "F6",
+  "F7",
+  "F8",
+  "F9",
+  "F10",
+  "F11",
+  "F12",
+  "Tab",
+  "CapsLock",
+  "Shift",
+  "Control",
+  "Meta",
+  "Option",
+  "Alt",
+  "ContextMenu",
+  "ArrowLeft",
+  "ArrowRight",
+  "ArrowUp",
+  "ArrowDown",
+  "NumLock",
+  "Backspace",
+  "Delete",
+  "Enter",
+  "Return",
+  "Insert",
+  "Home",
+  "End",
+  "PageUp",
+  "PageDown",
+  "PrintScreen",
+  "ScrollLock",
+  "Pause"
+];
+var MAX_PHONE_LENGTH = 10;
+var MAX_NAME_LENGTH = 128;
+var DEFAULT_DATE_MASK_NO_VALUE_SYMBOL = "_";
+var DEFAULT_COLORS = [
+  "#D9C1FF",
+  "#FFBAF0",
+  "#FFB8CE",
+  "#FFC3A2",
+  "#FFDB7C",
+  "#F9F871",
+  "#C3FCF1",
+  "#F6F2CB",
+  "#E0F8D1",
+  "#B1DFFB",
+  "#8DECFE",
+  "#76F7ED",
+  "#8AFEC8"
+];
+var KEYBOARD_KEY_CODES = {
+  Backspace: 8,
+  Delete: 46,
+  ARROW_LEFT: 37,
+  ARROW_RIGHT: 39
+};
+var OS = {
+  iOS: "iOS",
+  Android: "Android",
+  WP: "Windows Phone",
+  Linux: "Linux",
+  Windows: "Windows",
+  MacOS: "MacOS",
+  Unknown: "unknown"
+};
+
+// src/Functions/utils.js
+var import_react = require("react");
+var import_moment_timezone = __toESM(require("moment-timezone"), 1);
+var uuid = () => Date.now().toString(36) + Math.random().toString(36).substring(2);
+var getIsOnlyAnObject = (input) => {
+  return typeof input === "object" && // "отбивает" примитивы и функции
+  input instanceof Object && // "отбивает" null
+  !Array.isArray(input) && // "отбивает" массивы
+  !(input instanceof Set) && // "отбивает" сеты
+  !(input instanceof Map);
+};
+var handleObjectChange = (updateObject, updateFunction) => (data, prop = "", isNumber2) => {
+  let value;
+  if (data?.target) {
+    value = data.target.type === "checkbox" ? data.target.checked : data.target.value;
+  } else value = data;
+  value = isNumber2 ? Number(value) : value;
+  const props = prop.split(".");
+  const currentObject = props.reduce((res, chapter, index) => {
+    if (props.length !== index + 1) res = res[chapter];
+    return res;
+  }, updateObject);
+  currentObject[props.pop()] = value;
+  updateFunction();
+};
+var useOutsideToggle = (ref, setOut, open) => {
+  function handleClickOutside(event) {
+    if (ref.current && !ref.current.contains(event.target)) {
+      setOut(open);
+    }
+  }
+  (0, import_react.useEffect)(() => {
+    document.addEventListener("mouseup", handleClickOutside);
+    return () => {
+      document.removeEventListener("mouseup", handleClickOutside);
+    };
+  }, [ref]);
+};
+var clone = (input) => {
+  if (input === null || typeof input !== "object") return input;
+  const data = input instanceof Array ? [] : {};
+  for (const i in input) data[i] = clone(input[i]);
+  return data;
+};
+var getResponseClone = async (res) => await (typeof res?.clone === "function" ? res.clone() : clone(res));
+function transformUTCTimeToLocal(date, format = "YYYY-MM-DD HH:mm:ss") {
+  if (!date) return;
+  const utcDate = import_moment_timezone.default.utc(date).toDate();
+  return (0, import_moment_timezone.default)(utcDate, format).local().format(format);
+}
+function transformLocalTimeToUTC(date, format = "YYYY-MM-DD HH:mm:ss") {
+  if (!date) return;
+  return (0, import_moment_timezone.default)(date, format).utc().format(format);
+}
+function transformUTCHoursToLocal(time, format = "HH:mm:ss") {
+  if (!time) return;
+  const splitedTime = time.split(":");
+  const offset = (0, import_moment_timezone.default)().utcOffset();
+  let HH = Number(splitedTime[0]);
+  let mm = Number(splitedTime[1]);
+  const ss = splitedTime[2];
+  mm = mm + offset;
+  while (mm > 59) {
+    mm -= 60;
+    HH += 1;
+  }
+  if (HH > 23) HH -= 24;
+  while (mm < 0) {
+    mm += 60;
+    HH -= 1;
+  }
+  if (HH < 0) HH += 24;
+  return `${HH}:${mm}:${ss}`;
+}
+function transformDateOrTimeOrTogetherToFormat(data, outputFormat = "HH:mm", additional) {
+  const ERROR_VALUE = "Invalid date";
+  const ERROR_MESSGE = `Invalid input data for ${outputFormat} format`;
+  const { parseFormat, isReturnAsMomentInstance } = getIsOnlyAnObject(
+    additional
+  ) ? additional : {};
+  if (typeof data !== "string" && typeof data !== "number") {
+    return isReturnAsMomentInstance ? (0, import_moment_timezone.default)("error") : ERROR_MESSGE;
+  }
+  const momentArgs = [
+    data,
+    ...!Number.isNaN(Number(data)) || typeof parseFormat === "string" ? [] : [parseFormat]
+  ];
+  const momentInstance = (() => {
+    let instance = (0, import_moment_timezone.default)(...momentArgs);
+    if (instance.format(outputFormat) !== ERROR_VALUE) return instance;
+    else if (/^\d\d.\d\d/.test(data)) {
+      instance = (0, import_moment_timezone.default)();
+      const symbols = data.split("");
+      const timeArr = symbols.reduce(
+        (acc, symbol, idx) => {
+          if (Number.isNaN(Number(symbol))) {
+            if (acc.group) acc.result.push(acc.group);
+            acc.group = "";
+          } else acc.group = `${acc.group}${symbol}`;
+          if (idx === symbols.length - 1 && acc.group)
+            acc.result.push(acc.group);
+          return acc;
+        },
+        { result: [], group: "" }
+      ).result.reverse();
+      instance.hours(Number(timeArr.pop()));
+      instance.minutes(Number(timeArr.pop()));
+      instance.seconds(timeArr.length ? Number(timeArr.pop()) : 0);
+      instance.milliseconds(timeArr.length ? Number(timeArr.pop()) : 0);
+    } else instance = (0, import_moment_timezone.default)("error");
+    return instance;
+  })();
+  if (isReturnAsMomentInstance) return momentInstance;
+  const output = momentInstance.format(outputFormat);
+  return output === ERROR_VALUE ? ERROR_MESSGE : output;
+}
+function transformDateOrTimeOrTogetherToFormattedLocal(data, outputFormat = "HH:mm", additional) {
+  const ERROR_VALUE = "Invalid date";
+  const ERROR_MESSGE = `Invalid input data for ${outputFormat} format`;
+  if (additional && !getIsOnlyAnObject(additional)) {
+    throw new Error(
+      "Bad additional [transformDateOrTimeOrTogetherToFormattedLocal]"
+    );
+  }
+  const compositeAdditional = {
+    ...additional || {},
+    isReturnAsMomentInstance: true
+  };
+  const date = transformDateOrTimeOrTogetherToFormat(
+    data,
+    outputFormat,
+    compositeAdditional
+  );
+  const dateWithLocale = date.add((0, import_moment_timezone.default)().utcOffset(), "minutes");
+  const output = dateWithLocale.format(outputFormat);
+  return output === ERROR_VALUE ? ERROR_MESSGE : output;
+}
+var omitKeys = (obj = {}, keys = []) => keys.reduce((acc, key) => {
+  const { [key]: omit, ...rest } = acc;
+  return rest;
+}, obj);
+var logout = () => {
+  window.localStorage.removeItem("accessToken");
+  window.localStorage.removeItem("tokenExpires");
+  window.location.reload();
+};
+var getStyles = (el, prop) => {
+  if (!el) return null;
+  if (!prop) return window.getComputedStyle(el);
+  return window.getComputedStyle(el).getPropertyValue(prop);
+};
+var getColorById = (id, colors) => {
+  if (!id) return "#FF7D00";
+  const idToArr = Array.from(id);
+  const colorsArr = colors && colors.length > 0 ? colors : DEFAULT_COLORS;
+  let number = idToArr.reduce((acc, item) => {
+    if (Number(item)) {
+      return acc + Number(item);
+    }
+    return acc;
+  }, 0);
+  while (number >= colorsArr.length) {
+    number -= colorsArr.length;
+  }
+  return colorsArr[number];
+};
+var debounce = (fn, ms) => {
+  let id = null;
+  return (...args) => {
+    clearTimeout(id);
+    id = setTimeout(() => {
+      clearTimeout(id);
+      fn(...args);
+    }, ms);
+  };
+};
+var throttle = (fn, ms) => {
+  let id = null;
+  return (...args) => {
+    if (id) return;
+    fn(...args);
+    id = setTimeout(() => {
+      clearTimeout(id);
+      id = null;
+    }, ms);
+  };
+};
+var addBitDepthPoints = (value, step = 3) => {
+  const isFraction = value?.includes(".");
+  const valueBeforeDot = isFraction ? value?.slice(0, value?.indexOf(".")) : value;
+  const intPart = valueBeforeDot.split("").reverse().reduce(
+    (acc, item, idx) => idx % step === 0 && idx !== 0 ? [...acc, ",", item] : [...acc, item],
+    []
+  ).reverse().join("");
+  return isFraction ? intPart + value?.slice(value?.indexOf(".")) : intPart;
+};
+var changeMeta = (key, items = []) => {
+  const defaultMeta = items.find((i) => i.key === "default");
+  if (key) {
+    const item = items.find((i) => i.key === key);
+    document.title = item?.title ?? defaultMeta?.title;
+    document.querySelector('meta[name="description"]').setAttribute("content", item?.description ?? defaultMeta?.description);
+  }
+};
+var firstLetterCapital = (str) => typeof str === "string" ? `${str.charAt(0).toUpperCase()}${str.slice(1)}` : str;
+var capitalized = firstLetterCapital;
+var checkedRef = (ref) => ref ? typeof ref === "function" ? (node) => ref(node) : ref : null;
+function downloadEmulation(data, filename, type = "image/*") {
+  const file = new Blob([data], { type });
+  if (window.navigator.msSaveOrOpenBlob)
+    window.navigator.msSaveOrOpenBlob(file, filename);
+  else {
+    const a = document.createElement("a"), url = URL.createObjectURL(file);
+    a.href = url;
+    a.download = filename;
+    document.body.appendChild(a);
+    a.click();
+    setTimeout(() => {
+      document.body.removeChild(a);
+      window.URL.revokeObjectURL(url);
+    }, 0);
+  }
+}
+var downloadFile = async ({ url, name, type = null }) => {
+  const response = await fetch(url).then(async (res) => ({
+    data: await res.blob(),
+    type: type ?? res.headers.get("content-type")
+  }));
+  downloadEmulation(response.data, name, response.type);
+};
+var compare = (first, second, keys = []) => {
+  if (typeof first !== typeof second) return false;
+  if (Array.isArray(first) !== Array.isArray(second)) return false;
+  if (!(first instanceof Object)) return first === second;
+  const getComparationStructure = (data) => {
+    if (typeof data === "function") return data.toString();
+    if (!(data instanceof Object)) return data;
+    return Object.entries(data).sort((a, b) => a[0].localeCompare(b[0])).map(([key, value]) => [key, getComparationStructure(data[key])]);
+  };
+  const structureForComparingOfFirst = getComparationStructure(first);
+  const structureForComparingOfSecond = getComparationStructure(second);
+  return JSON.stringify(structureForComparingOfFirst) === JSON.stringify(structureForComparingOfSecond);
+};
+var setCarretToEnd = (input) => {
+  setTimeout(() => {
+    const tmp = input.value;
+    input.value = "";
+    input.value = tmp;
+  }, 10);
+};
+var compareAlphabetical = (a, b, key = "label") => {
+  let item1 = a?.[key];
+  let item2 = b?.[key];
+  if (typeof item1 !== "string" || typeof item2 !== "string") return 0;
+  item1 = item1?.toLowerCase();
+  item2 = item2?.toLowerCase();
+  if (item1 < item2) {
+    return -1;
+  }
+  if (item1 > item2) {
+    return 1;
+  }
+  return 0;
+};
+var getBase64 = (file) => {
+  if (file) {
+    return new Promise(function(resolve, reject) {
+      const reader = new FileReader();
+      reader.readAsDataURL(file);
+      reader.onload = () => resolve(reader.result);
+      reader.onerror = (error) => reject("Error: ", error);
+    });
+  }
+};
+var renderFileSize = (bytes, decimals = 2) => {
+  if (!Number(bytes)) return "0 Bytes";
+  const k = 1024;
+  const dm = decimals < 0 ? 0 : decimals;
+  const sizes = ["Bytes", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(dm))} ${sizes[i]}`;
+};
+var getUniqueFileExtensions = (extListString) => {
+  const extArray = extListString?.split(",").map((ext) => ext.trim().toUpperCase());
+  const uniqueExts = [...new Set(extArray)];
+  return uniqueExts.join(", ");
+};
+var getOS = () => {
+  let userAgent = window.navigator.userAgent, platform = window.navigator?.userAgentData?.platform || window.navigator.platform, macosPlatforms = ["Macintosh", "MacIntel", "MacPPC", "Mac68K"], windowsPlatforms = ["Win32", "Win64", "Windows", "WinCE"], iosPlatforms = ["iPhone", "iPad", "iPod"], os = OS.Unknown;
+  if (macosPlatforms.indexOf(platform) !== -1) {
+    os = OS.MacOS;
+  } else if (iosPlatforms.indexOf(platform) !== -1) {
+    os = OS.iOS;
+  } else if (windowsPlatforms.indexOf(platform) !== -1) {
+    os = OS.Windows;
+  } else if (/Android/.test(userAgent)) {
+    os = OS.Android;
+  } else if (/Linux/.test(platform)) {
+    os = OS.Linux;
+  }
+  return os;
+};
+String.prototype.longerThan = function(compareWith) {
+  return this?.length > compareWith?.length;
+};
+String.prototype.lastIndexEqualsTo = function(index) {
+  return this?.length - 1 === index;
+};
+var getCorrectTestId = ({ testId = "", withTier = true }) => testId && testId !== void 0 ? `${withTier ? "-" : ""}${testId}` : "";
+
+// src/Functions/guards/safeValue.ts
+function stringValue(value) {
+  if (typeof value === "string" && value !== "") return value;
+  return "";
+}
+function objectValue(value) {
+  if (typeof value === "object" && value !== null && Object.keys(value).length > 0) {
+    return clone(value);
+  }
+  return {};
+}
+function numberValue(value) {
+  if (!Number.isNaN(value) && typeof value === "number") return value;
+  return 0;
+}
+var arrayValue = (value) => Array.isArray(value) ? clone(value) : [];
+function booleanValue(value) {
+  if (typeGuards_default.isBoolean(value)) {
+    return value;
+  }
+  return false;
+}
+function notNullValue(value, defaultValue) {
+  return value !== null && value !== void 0 ? value : defaultValue;
+}
+var safeValue = {
+  booleanValue,
+  stringValue,
+  objectValue,
+  numberValue,
+  arrayValue,
+  notNullValue
+};
+var safeValue_default = safeValue;
+//# sourceMappingURL=utils.cjs.map