@qrvey/utils 1.16.1-9 → 1.17.0-1

package/dist/format/duration/addDurationFormat.js

@@ -1,16 +1,4 @@
 import { DurationFormatter } from "./durationFormatter";
-/** [TODO: The decimals dots are not working correctly, we need to reviewing (fractionDigits)]
- * "Convert a number of seconds to a human readable string."
- *
- * `addDurationFormat` is a function that takes a number, a format, an optional locale, and an optional
- * number of fraction digits, and returns a string
- * @param {number} number - The number of milliseconds to format.
- * @param {string} format - The format string.
- * @param {string} [locale] - The locale to use for formatting. If not specified, the default locale is
- * used.
- * @param {number} [fractionDigits] - The number of digits to show after the decimal point.
- * @returns A string
- */
 export function addDurationFormat(number, format, locale, fractionDigits) {
     return new DurationFormatter({
         template: format,

package/dist/format/duration/durationFormatter.d.ts

@@ -5,17 +5,6 @@ export declare class DurationFormatter {
     private numberFactor;
     private template;
     private numberFormatOptions;
-    /**
-     * The constructor function takes in a template string and an options object. It then sets the
-     * options object to the default options object if no options object is passed in. It then parses
-     * the template string and sets the parts to the parsed template string. It then tries to set the
-     * valueFormatter to a new Intl.NumberFormat object with the locale and fractionDigits options. If
-     * it fails, it sets the valueFormatter to a new Intl.NumberFormat object with the default locale
-     * and fractionDigits options. It then sets the numberFactor to the duration parts object with the
-     * name of the unit option. If it can't find the unit option, it sets the numberFactor to 1
-     * @param [template] - The template string that will be used to format the duration.
-     * @param options - This is an object that contains the following properties: unit, locale and fractionDigits
-     */
     constructor(options: {
         template: string;
         options?: {
@@ -26,54 +15,12 @@ export declare class DurationFormatter {
         intlNumberFormat?: Intl.NumberFormat;
     });
     private setOptions;
-    /**
-     * It sets the locale formatter for the number.
-     */
     private setLocaleFormatter;
-    /**
-     * It returns a new instance of the Intl.NumberFormat class, which is a built-in JavaScript class
-     * that formats numbers
-     * @param {string | string[]} locale - string | string[]
-     * @returns A new instance of the Intl.NumberFormat class.
-     */
     private getNewNumberFormat;
-    /**
-     * It takes a template string and sets the parts property to the result of calling the
-     * parseFormatTemplate function with the template string as an argument
-     * @param {string} template - The format template string.
-     */
     private setParts;
-    /**
-     * It replaces the H and D characters in the template with h and d respectively
-     * @param {string} template - The template string to be used for the date format.
-     * @returns The template string with all instances of H replaced with h and all instances of D
-     * replaced with d.
-     */
     private static matchFormatsReplace;
-    /**
-     * It sets the numberFactor to the value of the duration part that matches the unit.
-     */
     private setNumberFactor;
-    /**
-     * It takes a string, splits it into an array of strings, then maps each string to a config object,
-     * then filters out any falsy values, then reverses the array
-     * @param {string} template - string - the template string that we want to parse
-     * @returns An array of objects that have the order and the name of the part of the duration.
-     */
     private parseFormatTemplate;
-    /**
-     * It takes a number, multiplies it by a factor, then uses the parts array to calculate the number
-     * of each part in the number, then uses the template to format the number
-     * @param {number} number - The number of milliseconds to format.
-     * @returns The template string with the values replaced.
-     */
     format(number: number): string;
-    /**
-     * It takes a dictionary of values and a list of keys, and returns a formatted string
-     * @param parts - { [x: string]: any; }
-     * @param {string | (string | number)[]} part - This is the part of the date that we're
-     * formatting.
-     * @returns The value of the part of the date that is being formatted.
-     */
     private formatValue;
 }

package/dist/format/duration/durationFormatter.js

@@ -1,45 +1,24 @@
 import { isEmpty } from "../../general/mix/isEmpty";
 import { DEFAULT_OPTIONS, DURATION_PARTS, PARTS_REGEX } from "../definition";
-/* It takes a template string and a number of milliseconds and returns a string that is formatted to
-the user's preference
-this class is based on moment format:
-     years:   Y or y
-     months:  M
-     weeks:   W or w
-     days:    D or d
-     hours:   H or h
-     minutes: m
-     seconds: s
-     ms:      S
-*/
 export class DurationFormatter {
-    /**
-     * The constructor function takes in a template string and an options object. It then sets the
-     * options object to the default options object if no options object is passed in. It then parses
-     * the template string and sets the parts to the parsed template string. It then tries to set the
-     * valueFormatter to a new Intl.NumberFormat object with the locale and fractionDigits options. If
-     * it fails, it sets the valueFormatter to a new Intl.NumberFormat object with the default locale
-     * and fractionDigits options. It then sets the numberFactor to the duration parts object with the
-     * name of the unit option. If it can't find the unit option, it sets the numberFactor to 1
-     * @param [template] - The template string that will be used to format the duration.
-     * @param options - This is an object that contains the following properties: unit, locale and fractionDigits
-     */
+    options;
+    parts;
+    valueFormatter;
+    numberFactor;
+    template;
+    numberFormatOptions = {
+        minimumFractionDigits: DEFAULT_OPTIONS.fractionDigits,
+        maximumFractionDigits: DEFAULT_OPTIONS.fractionDigits,
+    };
     constructor(options) {
-        this.numberFormatOptions = {
-            minimumFractionDigits: DEFAULT_OPTIONS.fractionDigits,
-            maximumFractionDigits: DEFAULT_OPTIONS.fractionDigits,
-        };
         this.setOptions(options.options);
         this.setParts(options.template);
         this.setLocaleFormatter(options.intlNumberFormat);
         this.setNumberFactor();
     }
     setOptions(options) {
-        this.options = Object.assign(Object.assign({}, DEFAULT_OPTIONS), options);
+        this.options = { ...DEFAULT_OPTIONS, ...options };
     }
-    /**
-     * It sets the locale formatter for the number.
-     */
     setLocaleFormatter(intlNumberFormat) {
         try {
             if (intlNumberFormat) {
@@ -49,7 +28,7 @@ export class DurationFormatter {
                 this.valueFormatter = this.getNewNumberFormat(this.options.locale);
             }
         }
-        catch (e) {
+        catch {
             if (intlNumberFormat) {
                 this.valueFormatter = intlNumberFormat;
             }
@@ -58,47 +37,21 @@ export class DurationFormatter {
             }
         }
     }
-    /**
-     * It returns a new instance of the Intl.NumberFormat class, which is a built-in JavaScript class
-     * that formats numbers
-     * @param {string | string[]} locale - string | string[]
-     * @returns A new instance of the Intl.NumberFormat class.
-     */
     getNewNumberFormat(locale) {
         return new Intl.NumberFormat(locale, this.numberFormatOptions);
     }
-    /**
-     * It takes a template string and sets the parts property to the result of calling the
-     * parseFormatTemplate function with the template string as an argument
-     * @param {string} template - The format template string.
-     */
     setParts(template) {
         this.template = DurationFormatter.matchFormatsReplace(template);
         this.parts = this.parseFormatTemplate(template);
     }
-    /**
-     * It replaces the H and D characters in the template with h and d respectively
-     * @param {string} template - The template string to be used for the date format.
-     * @returns The template string with all instances of H replaced with h and all instances of D
-     * replaced with d.
-     */
     static matchFormatsReplace(template) {
         return isEmpty(template) ? template : template.replace(/H/g, "h");
     }
-    /**
-     * It sets the numberFactor to the value of the duration part that matches the unit.
-     */
     setNumberFactor() {
-        var _a;
         this.numberFactor =
-            ((_a = Object.values(DURATION_PARTS).find((d) => d.name === this.options.unit)) === null || _a === void 0 ? void 0 : _a.ms) || 1;
+            Object.values(DURATION_PARTS).find((d) => d.name === this.options.unit)
+                ?.ms || 1;
     }
-    /**
-     * It takes a string, splits it into an array of strings, then maps each string to a config object,
-     * then filters out any falsy values, then reverses the array
-     * @param {string} template - string - the template string that we want to parse
-     * @returns An array of objects that have the order and the name of the part of the duration.
-     */
     parseFormatTemplate(template) {
         this.template = isEmpty(template) ? "" : template;
         const templateParts = this.template.match(PARTS_REGEX) || [];
@@ -112,12 +65,6 @@ export class DurationFormatter {
             .filter(Boolean)
             .reverse();
     }
-    /**
-     * It takes a number, multiplies it by a factor, then uses the parts array to calculate the number
-     * of each part in the number, then uses the template to format the number
-     * @param {number} number - The number of milliseconds to format.
-     * @returns The template string with the values replaced.
-     */
     format(number) {
         if (number === null)
             return null;
@@ -144,16 +91,8 @@ export class DurationFormatter {
             return $1 || this.formatValue(durationParts, match);
         });
     }
-    /**
-     * It takes a dictionary of values and a list of keys, and returns a formatted string
-     * @param parts - { [x: string]: any; }
-     * @param {string | (string | number)[]} part - This is the part of the date that we're
-     * formatting.
-     * @returns The value of the part of the date that is being formatted.
-     */
     formatValue(parts, part) {
-        var _a;
-        const value = (_a = parts[part[0]]) !== null && _a !== void 0 ? _a : 0;
+        const value = parts[part[0]] ?? 0;
         const formatted = this.valueFormatter.format(value);
         const isNegative = formatted.startsWith("-");
         const numericPart = isNegative ? formatted.slice(1) : formatted;

package/dist/format/format.d.ts

@@ -1,22 +1,8 @@
 import { IFormatConfig } from "../interfaces/format/IFormatConfig.Interface";
 export declare function formatDate(dateString: any, format: any, offset: any): any;
 export declare function formatAbbreviated(num: any, decimals: any): any;
-/**
- * Set convert Bytes into MB
- * @param bytes type number
- */
 export declare function formatFileSize(bytes: number): string;
-/**
- * It returns true if the given string is a valid time string, and false otherwise
- * @param {string} [timeString] - The time string to validate.
- * @returns A boolean value.
- */
 export declare function isValidTimeString(timeString?: string): boolean;
-/**
- * It takes a time string and a format string and returns a formatted time string
- * @param {any} timeString - The time string to be formatted.
- * @param {string} format - The format of the time string.
- */
 export declare function formatTime(timeString: any, format: string): any;
 export declare const addFormat: (value: any, outputFormat?: any, config?: IFormatConfig) => any;
 export declare const parseFormulaType: (type: string) => "NUMERIC" | "DATE" | "TEXT_LABEL";

package/dist/format/format.js

@@ -1,14 +1,12 @@
 import { format as d3Format } from "d3-format";
 import dayjs from "dayjs";
 import { DATEGROUP_FORMATTING_UNSUPPORT, appliesFormatting, hasfileSizeProperty, isTextColumn, DEFAULT_DATE, } from "./definition";
-//* *dayjs plugins */
 import isoWeek from "dayjs/plugin/isoWeek";
 import advancedFormat from "dayjs/plugin/advancedFormat";
 import utc from "dayjs/plugin/utc";
 import weekYear from "dayjs/plugin/weekYear";
 import weekOfYear from "dayjs/plugin/weekOfYear";
 import updateLocale from "dayjs/plugin/updateLocale";
-//* * end dayjs plugin imports */
 import { isEmpty } from "../general/mix/isEmpty";
 import { _get } from "../general/object/get";
 import { COLUMN } from "../columns/constants/COLUMN";
@@ -23,18 +21,14 @@ dayjs.extend(updateLocale);
 dayjs.updateLocale("en", {
     yearStart: 4,
 });
-dayjs.extend(isoWeek); // Add support for iso week format https://github.com/iamkun/dayjs/issues/1328
-dayjs.extend(advancedFormat); // Add support to advanced formats https://day.js.org/docs/en/plugin/advanced-format
+dayjs.extend(isoWeek);
+dayjs.extend(advancedFormat);
 dayjs.extend(utc);
 dayjs.extend(weekYear);
 dayjs.extend(weekOfYear);
-/**
- * Apply to the given date format to a date value
- * @param bytes type number
- */
 function isValidDateString(dateString = "") {
-    return (/^\d{2}\/\d{2}\/\d{4}/.test(dateString) || // MM/DD/YYY OR DD/MM/YYYY
-        /^\d{4}-\d{2}-\d{2}/.test(dateString)); // YYYY-MM-DD
+    return (/^\d{2}\/\d{2}\/\d{4}/.test(dateString) ||
+        /^\d{4}-\d{2}-\d{2}/.test(dateString));
 }
 export function formatDate(dateString, format, offset) {
     let _format = objectCopy(format);
@@ -44,7 +38,7 @@ export function formatDate(dateString, format, offset) {
         return dateString;
     if (!isValidDateString(dateString))
         return dateString;
-    const dateStringCleaned = dateString === null || dateString === void 0 ? void 0 : dateString.replace(/Z$/i, "");
+    const dateStringCleaned = dateString?.replace(/Z$/i, "");
     const firstPartOfDateString = dayjs(dateStringCleaned.split(".")[0]);
     const newDateValue = !isEmpty(offset)
         ? firstPartOfDateString.utcOffset(offset)
@@ -69,7 +63,7 @@ function formatNumber(num, outputFormat, config) {
     try {
         _num = +(_num || 0);
     }
-    catch (e) {
+    catch {
         _num = 0;
     }
     if (isNaN(_num))
@@ -104,18 +98,14 @@ function formatNumber(num, outputFormat, config) {
     }
 }
 function getCurrencySymbolFromConfig(num, outputFormat, config) {
-    const { currency } = outputFormat !== null && outputFormat !== void 0 ? outputFormat : {};
+    const { currency } = outputFormat ?? {};
     const currencySymbol = isDefaultCurrent(currency)
-        ? getCurrencySymbolByCode(config === null || config === void 0 ? void 0 : config.currencyFormatOverride)
+        ? getCurrencySymbolByCode(config?.currencyFormatOverride)
         : null;
     return currencySymbol
         ? currencySymbol
         : `${num < 0 ? "-" : ""} ${_get(outputFormat, "currency.label", "$")}`;
 }
-/**
- * Set convert Bytes into MB
- * @param bytes type number
- */
 export function formatFileSize(bytes) {
     const fixDecimals = (num) => {
         return parseFloat(`${(num * 100) / 100}`).toFixed(2);
@@ -128,20 +118,10 @@ export function formatFileSize(bytes) {
         ? `${fixDecimals(megaBytes)} MB`
         : `${Math.round(megaBytes)} MB`;
 }
-/**
- * It returns true if the given string is a valid time string, and false otherwise
- * @param {string} [timeString] - The time string to validate.
- * @returns A boolean value.
- */
 export function isValidTimeString(timeString = "") {
     const regex = new RegExp("^(?:[01]\\d|2[0-3]):(?:[0-5]\\d):(?:[0-5]\\d)$", "g");
     return regex.test(timeString);
 }
-/**
- * It takes a time string and a format string and returns a formatted time string
- * @param {any} timeString - The time string to be formatted.
- * @param {string} format - The format of the time string.
- */
 export function formatTime(timeString, format) {
     if (!format || isEmpty(timeString) || !isNaN(timeString))
         return timeString;
@@ -150,28 +130,27 @@ export function formatTime(timeString, format) {
     return dayjs(`${DEFAULT_DATE} ${timeString}`).format(format.replace("HH24", "HH").replace("MI", "mm").replace("SS", "ss"));
 }
 export const addFormat = (value, outputFormat = "None", config) => {
-    var _a, _b, _c, _d;
     if (isEmpty(value) || (typeof value === "object" && isEmpty(value[0])))
         return value;
     switch (outputFormat.type) {
         case "TIME":
-            return formatTime(value, (outputFormat === null || outputFormat === void 0 ? void 0 : outputFormat.format) === "Default" &&
-                ((_a = outputFormat === null || outputFormat === void 0 ? void 0 : outputFormat.originalFormat) === null || _a === void 0 ? void 0 : _a.format)
-                ? (_b = outputFormat === null || outputFormat === void 0 ? void 0 : outputFormat.originalFormat) === null || _b === void 0 ? void 0 : _b.format
-                : outputFormat === null || outputFormat === void 0 ? void 0 : outputFormat.format);
+            return formatTime(value, outputFormat?.format === "Default" &&
+                outputFormat?.originalFormat?.format
+                ? outputFormat?.originalFormat?.format
+                : outputFormat?.format);
         case "DATE":
         case "DATETIME":
-            return (config === null || config === void 0 ? void 0 : config.lang) && outputFormat.format === "Default"
+            return config?.lang && outputFormat.format === "Default"
                 ? formatWithLocale(value, outputFormat, config)
-                : formatDate(value, (outputFormat === null || outputFormat === void 0 ? void 0 : outputFormat.format) === "Default" &&
-                    ((_c = outputFormat === null || outputFormat === void 0 ? void 0 : outputFormat.originalFormat) === null || _c === void 0 ? void 0 : _c.format)
-                    ? (_d = outputFormat === null || outputFormat === void 0 ? void 0 : outputFormat.originalFormat) === null || _d === void 0 ? void 0 : _d.format
-                    : outputFormat === null || outputFormat === void 0 ? void 0 : outputFormat.format, config === null || config === void 0 ? void 0 : config.offset);
+                : formatDate(value, outputFormat?.format === "Default" &&
+                    outputFormat?.originalFormat?.format
+                    ? outputFormat?.originalFormat?.format
+                    : outputFormat?.format, config?.offset);
         case "NUMERIC": {
             const parse = parseFloat(value);
-            const withLocale = (outputFormat !== "None" && (config === null || config === void 0 ? void 0 : config.lang)) ||
-                (outputFormat === null || outputFormat === void 0 ? void 0 : outputFormat.format) === "Duration" ||
-                DURATION_PARTS_LIST.includes[outputFormat === null || outputFormat === void 0 ? void 0 : outputFormat.format];
+            const withLocale = (outputFormat !== "None" && config?.lang) ||
+                outputFormat?.format === "Duration" ||
+                DURATION_PARTS_LIST.includes[outputFormat?.format];
             if (isNaN(parse)) {
                 return value;
             }

package/dist/format/helpers/getCurrencySymbolByCode.d.ts

@@ -1,7 +1,2 @@
 export declare const fixCurrencyFormatOverride: (currencyFormatOverride: string) => string | undefined;
-/**
- * Gets the currency symbol for a given currency code.
- * @param currencyCode The ISO 4217 currency code (e.g., "USD", "EUR").
- * @returns The currency symbol (e.g., "$", "€") or null if the code is invalid.
- */
 export declare function getCurrencySymbolByCode(currencyCode: string): string | null;

package/dist/format/helpers/getCurrencySymbolByCode.js

@@ -5,11 +5,6 @@ export const fixCurrencyFormatOverride = (currencyFormatOverride) => {
     }
     return currencyFormatOverride;
 };
-/**
- * Gets the currency symbol for a given currency code.
- * @param currencyCode The ISO 4217 currency code (e.g., "USD", "EUR").
- * @returns The currency symbol (e.g., "$", "€") or null if the code is invalid.
- */
 export function getCurrencySymbolByCode(currencyCode) {
     if (isEmpty(currencyCode))
         return null;
@@ -25,7 +20,7 @@ export function getCurrencySymbolByCode(currencyCode) {
             return symbolPart.value;
         }
     }
-    catch (error) {
+    catch {
         return null;
     }
 }

package/dist/format/helpers/isDateTimeFormat.d.ts

@@ -1,7 +1,2 @@
 import { IFormatOutputFormat } from "../../interfaces/format/IFormatOutputFormat.Interface";
-/**
- * It checks if the outputFormat is a date time format.
- * @param {IFormatOutputFormat} outputFormat - IFormatOutputFormat
- * @returns A boolean
- */
 export declare const isDateTimeFormat: (outputFormat: IFormatOutputFormat) => boolean;

package/dist/format/helpers/isDateTimeFormat.js

@@ -1,15 +1,9 @@
 import { DATETIME_COLUMN_FORMAT } from "../../dates/constants/DATETIME_COLUMN_FORMAT";
-/**
- * It checks if the outputFormat is a date time format.
- * @param {IFormatOutputFormat} outputFormat - IFormatOutputFormat
- * @returns A boolean
- */
 export const isDateTimeFormat = (outputFormat) => {
-    var _a, _b;
-    const format = (outputFormat === null || outputFormat === void 0 ? void 0 : outputFormat.format) === "Default" && ((_a = outputFormat === null || outputFormat === void 0 ? void 0 : outputFormat.originalFormat) === null || _a === void 0 ? void 0 : _a.format)
-        ? (_b = outputFormat === null || outputFormat === void 0 ? void 0 : outputFormat.originalFormat) === null || _b === void 0 ? void 0 : _b.format
-        : outputFormat === null || outputFormat === void 0 ? void 0 : outputFormat.format;
+    const format = outputFormat?.format === "Default" && outputFormat?.originalFormat?.format
+        ? outputFormat?.originalFormat?.format
+        : outputFormat?.format;
     if (typeof format !== "string")
         return false;
-    return DATETIME_COLUMN_FORMAT.some((opt) => format === null || format === void 0 ? void 0 : format.includes(opt));
+    return DATETIME_COLUMN_FORMAT.some((opt) => format?.includes(opt));
 };

package/dist/format/helpers/isDefaultCurrent.d.ts

@@ -1,7 +1,2 @@
 import { IFormatCurrency } from "../../interfaces/format/IFormatCurrency.Interface";
-/**
- * Checks if the given currency is the default currency
- * @param currency The currency to check
- * @returns true if the currency is the default currency, false otherwise
- */
 export declare function isDefaultCurrent(currency: IFormatCurrency): boolean;

package/dist/format/helpers/isDefaultCurrent.js

@@ -1,8 +1,3 @@
-/**
- * Checks if the given currency is the default currency
- * @param currency The currency to check
- * @returns true if the currency is the default currency, false otherwise
- */
 export function isDefaultCurrent(currency) {
-    return (((currency === null || currency === void 0 ? void 0 : currency.key) == null || (currency === null || currency === void 0 ? void 0 : currency.key) === "default"));
+    return ((currency?.key == null || currency?.key === "default"));
 }

package/dist/format/localization.js

@@ -13,9 +13,8 @@ export const getLang = (locale) => {
     return { lang: locale === "browser" ? window.navigator.language : locale };
 };
 export const chooseLang = (config) => {
-    var _a;
-    const lang = ((_a = config === null || config === void 0 ? void 0 : config.i18n) === null || _a === void 0 ? void 0 : _a.lang) || (config === null || config === void 0 ? void 0 : config.lang);
-    return (lang === null || lang === void 0 ? void 0 : lang.lang) || lang || LANG_DEFAULT;
+    const lang = config?.i18n?.lang || config?.lang;
+    return lang?.lang || lang || LANG_DEFAULT;
 };
 export const formatWithLocale = (value, outputFormat, config = {}) => {
     switch (outputFormat.type) {
@@ -37,10 +36,10 @@ function getDateWithOffset(dateValue, offset) {
 const DATE_FORMAT_CACHE = [];
 function formatLocaleDate(value, outputFormat, config) {
     const { lang = LANG_DEFAULT, options } = config;
-    const dateValue = value === null || value === void 0 ? void 0 : value.replace(/Z$/i, "");
-    const dateParam = getDateWithOffset(dateValue, config === null || config === void 0 ? void 0 : config.offset);
+    const dateValue = value?.replace(/Z$/i, "");
+    const dateParam = getDateWithOffset(dateValue, config?.offset);
     let langOpts = options;
-    if ((outputFormat === null || outputFormat === void 0 ? void 0 : outputFormat.originalFormat) && isDateTimeFormat(outputFormat)) {
+    if (outputFormat?.originalFormat && isDateTimeFormat(outputFormat)) {
         langOpts = DATETIME_OPTIONS;
     }
     try {
@@ -52,7 +51,7 @@ function formatLocaleDate(value, outputFormat, config) {
         }
         return formatter.format(dateParam);
     }
-    catch (error) {
+    catch {
         return isEmpty(dateParam)
             ? value
             : new Intl.DateTimeFormat(LANG_DEFAULT, langOpts).format(dateParam);
@@ -62,24 +61,23 @@ const NUMBER_FORMAT_CACHE = [];
 function formatLocaleNumber(value, outputFormat, config) {
     const { lang = LANG_DEFAULT, options } = config;
     let langOpts = options || getLocaleOptions(outputFormat);
-    const valueToFormat = (outputFormat === null || outputFormat === void 0 ? void 0 : outputFormat.format) === "Percentage" /* LOCALE_FORMATS.PERCENTAGE */ ? value / 100 : value;
+    const valueToFormat = outputFormat?.format === "Percentage" ? value / 100 : value;
     try {
         const fixedCurrencyCode = fixCurrencyFormatOverride(config.currencyFormatOverride);
-        if (isDefaultCurrent(outputFormat.currency) &&
-            !!fixedCurrencyCode) {
-            langOpts = Object.assign(Object.assign({}, langOpts), { currency: fixedCurrencyCode });
+        if (isDefaultCurrent(outputFormat.currency) && !!fixedCurrencyCode) {
+            langOpts = { ...langOpts, currency: fixedCurrencyCode };
         }
-        const key = (outputFormat === null || outputFormat === void 0 ? void 0 : outputFormat.format) +
+        const key = outputFormat?.format +
             lang +
             JSON.stringify(langOpts) +
-            ((outputFormat === null || outputFormat === void 0 ? void 0 : outputFormat.template) ? outputFormat.template : "");
+            (outputFormat?.template ? outputFormat.template : "");
         let formatter = NUMBER_FORMAT_CACHE[key];
         if (!formatter) {
             const intlNumberFormat = new Intl.NumberFormat([lang, LANG_DEFAULT], langOpts);
             formatter =
-                (outputFormat === null || outputFormat === void 0 ? void 0 : outputFormat.format) === "Duration" /* LOCALE_FORMATS.DURATION */
+                outputFormat?.format === "Duration"
                     ? new DurationFormatter({
-                        template: outputFormat === null || outputFormat === void 0 ? void 0 : outputFormat.template,
+                        template: outputFormat?.template,
                         intlNumberFormat,
                     })
                     : intlNumberFormat;
@@ -87,14 +85,14 @@ function formatLocaleNumber(value, outputFormat, config) {
         }
         return formatter.format(valueToFormat);
     }
-    catch (e) {
+    catch {
         return new Intl.NumberFormat(LANG_DEFAULT, langOpts).format(valueToFormat);
     }
 }
 function getLocaleOptions(outputFormat) {
     const { format, decimals, currency } = outputFormat;
     switch (format) {
-        case "Currency" /* LOCALE_FORMATS.CURRENCY */: {
+        case "Currency": {
             let iso = isEmpty(currency)
                 ? CURRENCY_DEFAULT
                 : currencyISO.find((item) => item.label === currency.label);
@@ -105,40 +103,40 @@ function getLocaleOptions(outputFormat) {
                 });
             }
             return {
-                style: "currency" /* LOCALE_STYLES.CURRENCY */,
+                style: "currency",
                 currency: iso.label,
                 maximumFractionDigits: decimals,
                 minimumFractionDigits: decimals,
                 currencyDisplay: "narrowSymbol",
             };
         }
-        case "Scientific" /* LOCALE_FORMATS.SCIENTIFIC */:
+        case "Scientific":
             return {
-                style: "decimal" /* LOCALE_STYLES.DECIMAL */,
-                notation: "scientific" /* LOCALE_STYLES.SCIENTIFIC */,
+                style: "decimal",
+                notation: "scientific",
                 maximumFractionDigits: decimals,
                 minimumFractionDigits: decimals,
             };
-        case "Percentage" /* LOCALE_FORMATS.PERCENTAGE */:
+        case "Percentage":
             return {
-                style: "percent" /* LOCALE_STYLES.PERCENT */,
+                style: "percent",
                 maximumFractionDigits: decimals,
                 minimumFractionDigits: decimals,
             };
-        case "Abbreviated" /* LOCALE_FORMATS.ABBREVIATED */:
+        case "Abbreviated":
             return {
-                notation: "compact" /* LOCALE_STYLES.COMPACT */,
+                notation: "compact",
                 maximumFractionDigits: decimals,
                 minimumFractionDigits: decimals,
             };
-        case "Duration" /* LOCALE_FORMATS.DURATION */:
+        case "Duration":
             return {
                 maximumFractionDigits: 0,
                 minimumFractionDigits: 0,
             };
         default:
             return {
-                style: "decimal" /* LOCALE_STYLES.DECIMAL */,
+                style: "decimal",
                 maximumFractionDigits: decimals,
                 minimumFractionDigits: decimals,
             };

package/dist/general/array/addPropertyToArrayOfObjects.d.ts

@@ -1,18 +1,3 @@
-/**
- * It takes an array of objects, adds a property to each object, and returns the new array.
- * @param {Object} info - Information needed to add property to the array of objects.
- * @param {Array} info.array - The array of objects you want to add a property to.
- * @param {string} info.property - The property you want to add to the object.
- * @param {any} info.value - - The value to be added to the array of objects.
- * ----------------------------------------------------------------------------------------------
- * @example <caption>Example usage of addPropertyToArrayOfObjects.</caption>
- * addPropertyToArrayOfObjects({
- * 	array: [{ name: "John", lastName: "Doe" }, { name: "Chris", lastName: "Musk" }],
- * 	property: "lastName",
- * 	value: 'Peck'
- * });
- * @returns the new array created.
- */
 export declare function addPropertyToArrayOfObjects(obj: AddPropertyToArrayOfObjectsParams): any[];
 type AddPropertyToArrayOfObjectsParams = {
     array: any[];