@synerise/ds-core 1.11.0 → 1.11.2

package/dist/js/data-format/hooks/useRelativeDateTimeUpdate.js

@@ -1,37 +1,33 @@
-import { useEffect, useState } from 'react';
-var getIntervalForTimeDifference = function getIntervalForTimeDifference(timeDiffMs) {
-  // https://day.js.org/docs/en/display/from-now#list-of-breakdown-range
-  var UNDER_45_MINUTES = 45 * 60 * 1000;
-  var UNDER_22_HOURS = 22 * 60 * 60 * 1000;
+import { useState, useEffect } from "react";
+const getIntervalForTimeDifference = (timeDiffMs) => {
+  const UNDER_45_MINUTES = 45 * 60 * 1e3;
+  const UNDER_22_HOURS = 22 * 60 * 60 * 1e3;
   if (timeDiffMs < UNDER_45_MINUTES) {
-    return 60 * 1000; // 60 seconds
+    return 60 * 1e3;
   }
   if (timeDiffMs < UNDER_22_HOURS) {
-    return 60 * 60 * 1000; // 60 minutes
+    return 60 * 60 * 1e3;
   }
-  return null; // no interval
+  return null;
 };
-export var useRelativeDateTimeUpdate = function useRelativeDateTimeUpdate(value) {
-  var _useState = useState(0),
-    updateTrigger = _useState[0],
-    setUpdateTrigger = _useState[1];
-  useEffect(function () {
+const useRelativeDateTimeUpdate = (value) => {
+  const [updateTrigger, setUpdateTrigger] = useState(0);
+  useEffect(() => {
     if (!(value instanceof Date)) {
       return;
     }
-    var timeDiffMs = Math.abs(value.getTime() - Date.now());
-    var interval = getIntervalForTimeDifference(timeDiffMs);
+    const timeDiffMs = Math.abs(value.getTime() - Date.now());
+    const interval = getIntervalForTimeDifference(timeDiffMs);
     if (interval === null) {
       return;
     }
-    var timeoutId = setTimeout(function () {
-      setUpdateTrigger(function (prev) {
-        return prev + 1;
-      });
+    const timeoutId = setTimeout(() => {
+      setUpdateTrigger((prev) => prev + 1);
     }, interval);
-    return function () {
-      return clearTimeout(timeoutId);
-    };
+    return () => clearTimeout(timeoutId);
   }, [value, updateTrigger]);
   return updateTrigger;
-};
+};
+export {
+  useRelativeDateTimeUpdate
+};

package/dist/js/data-format/hooks/useSingleIntl.d.ts

@@ -1,4 +1,4 @@
-import { type IntlShape } from 'react-intl';
+import { IntlShape } from 'react-intl';
 export declare const useSingleIntl: (locale: string) => {
     intl: IntlShape;
 };

package/dist/js/data-format/hooks/useSingleIntl.js

@@ -1,12 +1,15 @@
-import { createIntl, createIntlCache, useIntl } from 'react-intl';
-export var useSingleIntl = function useSingleIntl(locale) {
-  var cache = createIntlCache();
-  var globalIntl = useIntl();
-  var intl = createIntl({
-    locale: locale,
+import { createIntlCache, useIntl, createIntl } from "react-intl";
+const useSingleIntl = (locale) => {
+  const cache = createIntlCache();
+  const globalIntl = useIntl();
+  const intl = createIntl({
+    locale,
     timeZone: globalIntl.timeZone
   }, cache);
   return {
-    intl: intl
+    intl
   };
-};
+};
+export {
+  useSingleIntl
+};

package/dist/js/data-format/index.js

@@ -1,7 +1,83 @@
-export { DataFormatConfigProvider } from './providers/DataFormatConfigProvider';
-export { FormattedDate, FormattedDateTime, FormattedNumber, FormattedTime, FormattedRelativeDateTimeFrom, FormattedRelativeDateTimeTo } from './components';
-export { useDataFormat, useDataFormatUtils, useDataFormatConfig, useDataFormatIntls } from './hooks';
-export { withDataFormat } from './hocs/withDataFormat';
-export { getDataFormatConfigFromNotation, getDefaultDataTimeOptions } from './utils';
-export * from './constants';
-export { DataFormatConfigContext, DataFormatIntlsContext } from './contexts';
+import { DataFormatConfigProvider } from "./providers/DataFormatConfigProvider.js";
+import { FormattedDate } from "./components/FormattedDate.js";
+import { FormattedDateTime } from "./components/FormattedDateTime.js";
+import { FormattedNumber } from "./components/FormattedNumber.js";
+import { FormattedTime } from "./components/FormattedTime.js";
+import { FormattedRelativeDateTimeFrom, FormattedRelativeDateTimeTo } from "./components/FormattedRelativeDateTime.js";
+import { useDataFormatConfig } from "./hooks/useDataFormatConfig.js";
+import { useDataFormat } from "./hooks/useDataFormat.js";
+import { useDataFormatUtils } from "./hooks/useDataFormatUtils.js";
+import "react-intl";
+import { useDataFormatIntls } from "./hooks/useDataFormatIntls.js";
+import "react";
+import { withDataFormat } from "./hocs/withDataFormat.js";
+import { getDataFormatConfigFromNotation } from "./utils/dataFormatConfig.utils.js";
+import { DEFAULT_DATA_FORMAT_CONFIG, DEFAULT_DATA_FORMAT_INTL, DEFAULT_DATA_FORMAT_NOTATION, EU_NOTATION, US_NOTATION } from "./constants/dataFormatConfig.constants.js";
+import { COMPACT_DECIMAL_LARGER_NUMBER, COMPACT_LARGER_NUMBER, DATE, DATETIME, DATE_CONSTANTS_TARGET_FORMATS, DEFAULT_FORMAT_DATE_OPTIONS, DEFAULT_FORMAT_MONTH_LONG_OPTIONS, DEFAULT_FORMAT_MONTH_SHORT_OPTIONS, DEFAULT_FORMAT_NUMBER_OPTIONS, DEFAULT_FORMAT_TIME_OPTIONS, DEFAULT_FORMAT_WEEKDAY_LONG_OPTIONS, DEFAULT_FORMAT_WEEKDAY_SHORT_OPTIONS, EU_DECIMAL_DELIMITER, EU_THOUSAND_DELIMITER, LARGER_NUMBER_LIMIT, LOWER_CASE, LOWER_FIRST, MONTHS_LONG, MONTHS_SHORT, MONTH_LONG, MONTH_SHORT, RELATIVE_FROM, RELATIVE_FROM_WITHOUT_SUFFIX, RELATIVE_TO, RELATIVE_TO_WITHOUT_SUFFIX, TIME, UPPER_CASE, UPPER_FIRST, US_DECIMAL_DELIMITER, US_THOUSAND_DELIMITER, WEEKDAYS_LONG, WEEKDAYS_SHORT, WEEKDAY_LONG, WEEKDAY_SHORT } from "./constants/dataFormat.constants.js";
+import { LONG, MONTH, SHORT, WEEKDAY } from "./constants/dateTimeParts.constants.js";
+import "./utils/timeZone.utils.js";
+import { getDefaultDataTimeOptions } from "./utils/dataFormat.utils.js";
+import "dayjs";
+import { DataFormatConfigContext } from "./contexts/DataFormatConfigContext.js";
+import { DataFormatIntlsContext } from "./contexts/DataFormatIntlsContext.js";
+export {
+  COMPACT_DECIMAL_LARGER_NUMBER,
+  COMPACT_LARGER_NUMBER,
+  DATE,
+  DATETIME,
+  DATE_CONSTANTS_TARGET_FORMATS,
+  DEFAULT_DATA_FORMAT_CONFIG,
+  DEFAULT_DATA_FORMAT_INTL,
+  DEFAULT_DATA_FORMAT_NOTATION,
+  DEFAULT_FORMAT_DATE_OPTIONS,
+  DEFAULT_FORMAT_MONTH_LONG_OPTIONS,
+  DEFAULT_FORMAT_MONTH_SHORT_OPTIONS,
+  DEFAULT_FORMAT_NUMBER_OPTIONS,
+  DEFAULT_FORMAT_TIME_OPTIONS,
+  DEFAULT_FORMAT_WEEKDAY_LONG_OPTIONS,
+  DEFAULT_FORMAT_WEEKDAY_SHORT_OPTIONS,
+  DataFormatConfigContext,
+  DataFormatConfigProvider,
+  DataFormatIntlsContext,
+  EU_DECIMAL_DELIMITER,
+  EU_NOTATION,
+  EU_THOUSAND_DELIMITER,
+  FormattedDate,
+  FormattedDateTime,
+  FormattedNumber,
+  FormattedRelativeDateTimeFrom,
+  FormattedRelativeDateTimeTo,
+  FormattedTime,
+  LARGER_NUMBER_LIMIT,
+  LONG,
+  LOWER_CASE,
+  LOWER_FIRST,
+  MONTH,
+  MONTHS_LONG,
+  MONTHS_SHORT,
+  MONTH_LONG,
+  MONTH_SHORT,
+  RELATIVE_FROM,
+  RELATIVE_FROM_WITHOUT_SUFFIX,
+  RELATIVE_TO,
+  RELATIVE_TO_WITHOUT_SUFFIX,
+  SHORT,
+  TIME,
+  UPPER_CASE,
+  UPPER_FIRST,
+  US_DECIMAL_DELIMITER,
+  US_NOTATION,
+  US_THOUSAND_DELIMITER,
+  WEEKDAY,
+  WEEKDAYS_LONG,
+  WEEKDAYS_SHORT,
+  WEEKDAY_LONG,
+  WEEKDAY_SHORT,
+  getDataFormatConfigFromNotation,
+  getDefaultDataTimeOptions,
+  useDataFormat,
+  useDataFormatConfig,
+  useDataFormatIntls,
+  useDataFormatUtils,
+  withDataFormat
+};

package/dist/js/data-format/providers/DataFormatConfigProvider.d.ts

@@ -1,5 +1,5 @@
-import React, { type ReactNode } from 'react';
-import { type DataFormatConfig } from '../types';
+import { default as React, ReactNode } from 'react';
+import { DataFormatConfig } from '../types';
 export type DataFormatConfigProviderProps = {
     dataFormatConfig?: DataFormatConfig;
     children?: ReactNode;

package/dist/js/data-format/providers/DataFormatConfigProvider.js

@@ -1,26 +1,37 @@
-import React from 'react';
-import { DEFAULT_DATA_FORMAT_CONFIG } from '../constants';
-import { DataFormatConfigContext, DataFormatIntlsContext } from '../contexts';
-import { useDataFormatUtils, useSingleIntl } from '../hooks';
-export var DataFormatConfigProvider = function DataFormatConfigProvider(_ref) {
-  var dataFormatConfigFromProps = _ref.dataFormatConfig,
-    children = _ref.children;
-  var dataFormatConfig = dataFormatConfigFromProps != null ? dataFormatConfigFromProps : DEFAULT_DATA_FORMAT_CONFIG;
-  var _useDataFormatUtils = useDataFormatUtils(),
-    getLocaleFromNotation = _useDataFormatUtils.getLocaleFromNotation;
-  var _useSingleIntl = useSingleIntl(getLocaleFromNotation(dataFormatConfig == null ? void 0 : dataFormatConfig.numberFormatNotation)),
-    numberFormatIntl = _useSingleIntl.intl;
-  var _useSingleIntl2 = useSingleIntl(getLocaleFromNotation(dataFormatConfig == null ? void 0 : dataFormatConfig.dateFormatNotation)),
-    dateFormatIntl = _useSingleIntl2.intl;
-  var _useSingleIntl3 = useSingleIntl(getLocaleFromNotation(dataFormatConfig == null ? void 0 : dataFormatConfig.timeFormatNotation)),
-    timeFormatIntl = _useSingleIntl3.intl;
-  return /*#__PURE__*/React.createElement(DataFormatIntlsContext.Provider, {
-    value: {
-      numberFormatIntl: numberFormatIntl,
-      dateFormatIntl: dateFormatIntl,
-      timeFormatIntl: timeFormatIntl
-    }
-  }, /*#__PURE__*/React.createElement(DataFormatConfigContext.Provider, {
-    value: dataFormatConfig
-  }, children));
-};
+import { jsx } from "react/jsx-runtime";
+import { DEFAULT_DATA_FORMAT_CONFIG } from "../constants/dataFormatConfig.constants.js";
+import { DataFormatConfigContext } from "../contexts/DataFormatConfigContext.js";
+import { DataFormatIntlsContext } from "../contexts/DataFormatIntlsContext.js";
+import "react";
+import "dayjs";
+import "moment";
+import "../utils/timeZone.utils.js";
+import "../utils/dataFormat.utils.js";
+import { useDataFormatUtils } from "../hooks/useDataFormatUtils.js";
+import { useSingleIntl } from "../hooks/useSingleIntl.js";
+const DataFormatConfigProvider = ({
+  dataFormatConfig: dataFormatConfigFromProps,
+  children
+}) => {
+  const dataFormatConfig = dataFormatConfigFromProps ?? DEFAULT_DATA_FORMAT_CONFIG;
+  const {
+    getLocaleFromNotation
+  } = useDataFormatUtils();
+  const {
+    intl: numberFormatIntl
+  } = useSingleIntl(getLocaleFromNotation(dataFormatConfig?.numberFormatNotation));
+  const {
+    intl: dateFormatIntl
+  } = useSingleIntl(getLocaleFromNotation(dataFormatConfig?.dateFormatNotation));
+  const {
+    intl: timeFormatIntl
+  } = useSingleIntl(getLocaleFromNotation(dataFormatConfig?.timeFormatNotation));
+  return /* @__PURE__ */ jsx(DataFormatIntlsContext.Provider, { value: {
+    numberFormatIntl,
+    dateFormatIntl,
+    timeFormatIntl
+  }, children: /* @__PURE__ */ jsx(DataFormatConfigContext.Provider, { value: dataFormatConfig, children }) });
+};
+export {
+  DataFormatConfigProvider
+};

package/dist/js/data-format/types/dataFormat.types.d.ts

@@ -1,6 +1,6 @@
-import { type Dayjs, type default as dayjs } from 'dayjs';
-import { type Moment } from 'moment';
-import { type FormatDateOptions, type FormatNumberOptions, type FormatPluralOptions } from 'react-intl';
+import { Dayjs, default as dayjs } from 'dayjs';
+import { Moment } from 'moment';
+import { FormatDateOptions, FormatNumberOptions, FormatPluralOptions } from 'react-intl';
 declare const _DATE_TARGET_FORMATS: readonly ["date", "datetime", "relative-from", "relative-to", "relative-from-without-suffix", "relative-to-without-suffix", "time", "weekday-long", "weekday-short", "month-long", "month-short"];
 export type DateTargetFormat = (typeof _DATE_TARGET_FORMATS)[number];
 declare const _NUMBER_TARGET_FORMATS: readonly ["compact-larger-number", "compact-decimal-larger-number"];

package/dist/js/data-format/types/dataFormat.types.js

@@ -1,5 +1 @@
-var _DATE_TARGET_FORMATS = ['date', 'datetime', 'relative-from', 'relative-to', 'relative-from-without-suffix', 'relative-to-without-suffix', 'time', 'weekday-long', 'weekday-short', 'month-long', 'month-short'];
-var _NUMBER_TARGET_FORMATS = ['compact-larger-number', 'compact-decimal-larger-number'];
-var _NAMING_CONVENTIONS = ['upperCase', 'upperFirst', 'lowerCase', 'lowerFirst'];
-var _DELIMITERS = [',', '.', ' '];
-export {};
+

package/dist/js/data-format/types/dataFormatConfig.types.d.ts

@@ -1,4 +1,4 @@
-import { type IntlShape } from 'react-intl';
+import { IntlShape } from 'react-intl';
 declare const _DATA_FORMAT_NOTATION_TYPES: readonly ["US", "EU"];
 export type DataFormatNotationType = (typeof _DATA_FORMAT_NOTATION_TYPES)[number];
 export type DataFormatConfig = {

package/dist/js/data-format/types/dataFormatConfig.types.js

@@ -1,2 +1 @@
-var _DATA_FORMAT_NOTATION_TYPES = ['US', 'EU'];
-export {};
+

package/dist/js/data-format/types/dateTimeParts.types.js

@@ -1,2 +1 @@
-var _DATE_TIME_PART_FORMAT = ['long', 'short', 'numeric'];
-export {};
+

package/dist/js/data-format/types/index.js

@@ -1 +1 @@
-export {};
+

package/dist/js/data-format/utils/dataFormat.utils.d.ts

@@ -1,5 +1,5 @@
-import { type IntlShape } from 'react-intl';
-import { type CommonFormatOptions, type DateToFormatOptions, type Delimiter, type NumberToFormatOptions } from '../types';
+import { IntlShape } from 'react-intl';
+import { CommonFormatOptions, DateToFormatOptions, Delimiter, NumberToFormatOptions } from '../types';
 export declare const convertNumberString: (value: number, numberFormatIntl: IntlShape, languageIntl: IntlShape, thousandDelimiter: Delimiter, decimalDelimiter: Delimiter, numberOptions?: NumberToFormatOptions) => string;
 export declare const convertDateToDateTimeString: (value: Date, dateFormatIntl: IntlShape, timeFormatIntl: IntlShape, languageIntl: IntlShape, options?: DateToFormatOptions) => string;
 export declare const convertDateToRelativeToString: (value: Date, withoutSuffix?: boolean) => string;

package/dist/js/data-format/utils/dataFormat.utils.js

@@ -1,98 +1,101 @@
-function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
-import dayjs from 'dayjs';
-import relativeTimePlugin from 'dayjs/plugin/relativeTime';
-import { COMPACT_DECIMAL_LARGER_NUMBER, COMPACT_LARGER_NUMBER, DATE, DATETIME, DEFAULT_FORMAT_MONTH_SHORT_OPTIONS, DEFAULT_FORMAT_NUMBER_OPTIONS, LARGER_NUMBER_LIMIT, LOWER_CASE, LOWER_FIRST, UPPER_CASE, UPPER_FIRST } from '../constants';
-import { dateTimePartsToString, getDateParts, getDateTimePartsSubset, getMonthLongDateParts, getMonthShortDateParts, getTimeParts, getWeekdayLongDateParts, getWeekdayShortDateParts, numberPartsToString, translateDateTimeParts } from './dateTimeParts.utils';
+import dayjs from "dayjs";
+import relativeTimePlugin from "dayjs/plugin/relativeTime";
+import "../constants/dataFormatConfig.constants.js";
+import { UPPER_FIRST, DEFAULT_FORMAT_MONTH_SHORT_OPTIONS, DATETIME, DATE, LOWER_FIRST, LOWER_CASE, UPPER_CASE, COMPACT_LARGER_NUMBER, LARGER_NUMBER_LIMIT, COMPACT_DECIMAL_LARGER_NUMBER, DEFAULT_FORMAT_NUMBER_OPTIONS } from "../constants/dataFormat.constants.js";
+import { getDateParts, translateDateTimeParts, dateTimePartsToString, getTimeParts, getMonthLongDateParts, getDateTimePartsSubset, getMonthShortDateParts, getWeekdayLongDateParts, getWeekdayShortDateParts, numberPartsToString } from "./dateTimeParts.utils.js";
 dayjs.extend(relativeTimePlugin);
-export var convertNumberString = function convertNumberString(value, numberFormatIntl, languageIntl, thousandDelimiter, decimalDelimiter, numberOptions) {
-  var updatedNumberOptions = numberOptions;
-  if (updatedNumberOptions != null && updatedNumberOptions.pluralOptions) {
+const convertNumberString = (value, numberFormatIntl, languageIntl, thousandDelimiter, decimalDelimiter, numberOptions) => {
+  const updatedNumberOptions = numberOptions;
+  if (updatedNumberOptions?.pluralOptions) {
     return numberFormatIntl.formatPlural(value, updatedNumberOptions);
   }
-  if ((updatedNumberOptions == null ? void 0 : updatedNumberOptions.targetFormat) === COMPACT_LARGER_NUMBER && value > LARGER_NUMBER_LIMIT) {
+  if (updatedNumberOptions?.targetFormat === COMPACT_LARGER_NUMBER && value > LARGER_NUMBER_LIMIT) {
     if (!updatedNumberOptions.notation) {
-      updatedNumberOptions.notation = 'compact';
+      updatedNumberOptions.notation = "compact";
     }
   }
-  if ((updatedNumberOptions == null ? void 0 : updatedNumberOptions.targetFormat) === COMPACT_DECIMAL_LARGER_NUMBER && value > LARGER_NUMBER_LIMIT) {
+  if (updatedNumberOptions?.targetFormat === COMPACT_DECIMAL_LARGER_NUMBER && value > LARGER_NUMBER_LIMIT) {
     if (!updatedNumberOptions.notation) {
-      updatedNumberOptions.notation = 'compact';
+      updatedNumberOptions.notation = "compact";
     }
     if (!updatedNumberOptions.minimumFractionDigits && updatedNumberOptions.minimumFractionDigits !== 0) {
       updatedNumberOptions.minimumFractionDigits = 1;
     }
   }
-  var numberParts = languageIntl.formatNumberToParts(value, _extends({}, DEFAULT_FORMAT_NUMBER_OPTIONS, updatedNumberOptions));
+  const numberParts = languageIntl.formatNumberToParts(value, {
+    ...DEFAULT_FORMAT_NUMBER_OPTIONS,
+    ...updatedNumberOptions
+  });
   return numberPartsToString(numberParts, thousandDelimiter, decimalDelimiter);
 };
-export var convertDateToDateTimeString = function convertDateToDateTimeString(value, dateFormatIntl, timeFormatIntl, languageIntl, options) {
-  var dateParts = getDateParts(value, dateFormatIntl, options == null ? void 0 : options.dateOptions);
-  var datePartsByLanguageIntl = getDateParts(value, languageIntl, options == null ? void 0 : options.dateOptions);
-  var translatedDateParts = translateDateTimeParts(dateParts, datePartsByLanguageIntl, options);
-  var date = dateTimePartsToString(translatedDateParts);
-  var time = dateTimePartsToString(getTimeParts(value, timeFormatIntl, options == null ? void 0 : options.timeOptions));
-  return date + ", " + time;
+const convertDateToDateTimeString = (value, dateFormatIntl, timeFormatIntl, languageIntl, options) => {
+  const dateParts = getDateParts(value, dateFormatIntl, options?.dateOptions);
+  const datePartsByLanguageIntl = getDateParts(value, languageIntl, options?.dateOptions);
+  const translatedDateParts = translateDateTimeParts(dateParts, datePartsByLanguageIntl, options);
+  const date = dateTimePartsToString(translatedDateParts);
+  const time = dateTimePartsToString(getTimeParts(value, timeFormatIntl, options?.timeOptions));
+  return `${date}, ${time}`;
 };
-export var convertDateToRelativeToString = function convertDateToRelativeToString(value, withoutSuffix) {
+const convertDateToRelativeToString = (value, withoutSuffix) => {
   return dayjs().to(dayjs(value), withoutSuffix);
 };
-export var convertDateToRelativeFromString = function convertDateToRelativeFromString(value, withoutSuffix) {
+const convertDateToRelativeFromString = (value, withoutSuffix) => {
   return dayjs().from(dayjs(value), withoutSuffix);
 };
-export var convertDateToTimeString = function convertDateToTimeString(value, timeFormatIntl, options) {
+const convertDateToTimeString = (value, timeFormatIntl, options) => {
   return dateTimePartsToString(getTimeParts(value, timeFormatIntl, options));
 };
-export var convertDateToDateString = function convertDateToDateString(value, dateFormatIntl, languageIntl, options) {
-  var dateParts = getDateParts(value, dateFormatIntl, options);
-  var datePartsByLanguageIntl = getDateParts(value, languageIntl, options);
-  var translatedDateParts = translateDateTimeParts(dateParts, datePartsByLanguageIntl, options);
+const convertDateToDateString = (value, dateFormatIntl, languageIntl, options) => {
+  const dateParts = getDateParts(value, dateFormatIntl, options);
+  const datePartsByLanguageIntl = getDateParts(value, languageIntl, options);
+  const translatedDateParts = translateDateTimeParts(dateParts, datePartsByLanguageIntl, options);
   return dateTimePartsToString(translatedDateParts);
 };
-export var convertDateToWeekdayLongString = function convertDateToWeekdayLongString(value, dateFormatIntl, languageIntl, options) {
-  var weekdayLongDateParts = getWeekdayLongDateParts(value, dateFormatIntl, options);
-  var weekdayLongDatePartsByLanguageIntl = getWeekdayLongDateParts(value, languageIntl, options);
-  var translatedDateTimeParts = translateDateTimeParts(weekdayLongDateParts, weekdayLongDatePartsByLanguageIntl, options);
-  var reducedDateTimeParts = getDateTimePartsSubset(translatedDateTimeParts, ['weekday']);
+const convertDateToWeekdayLongString = (value, dateFormatIntl, languageIntl, options) => {
+  const weekdayLongDateParts = getWeekdayLongDateParts(value, dateFormatIntl, options);
+  const weekdayLongDatePartsByLanguageIntl = getWeekdayLongDateParts(value, languageIntl, options);
+  const translatedDateTimeParts = translateDateTimeParts(weekdayLongDateParts, weekdayLongDatePartsByLanguageIntl, options);
+  const reducedDateTimeParts = getDateTimePartsSubset(translatedDateTimeParts, ["weekday"]);
   return dateTimePartsToString(reducedDateTimeParts);
 };
-export var convertDateToWeekdayShortString = function convertDateToWeekdayShortString(value, dateFormatIntl, languageIntl, options) {
-  var weekdayShortDateParts = getWeekdayShortDateParts(value, dateFormatIntl, options);
-  var weekdayShortDatePartsByLanguageIntl = getWeekdayShortDateParts(value, languageIntl, options);
-  var translatedDateTimeParts = translateDateTimeParts(weekdayShortDateParts, weekdayShortDatePartsByLanguageIntl, options);
-  var reducedDateTimeParts = getDateTimePartsSubset(translatedDateTimeParts, ['weekday']);
+const convertDateToWeekdayShortString = (value, dateFormatIntl, languageIntl, options) => {
+  const weekdayShortDateParts = getWeekdayShortDateParts(value, dateFormatIntl, options);
+  const weekdayShortDatePartsByLanguageIntl = getWeekdayShortDateParts(value, languageIntl, options);
+  const translatedDateTimeParts = translateDateTimeParts(weekdayShortDateParts, weekdayShortDatePartsByLanguageIntl, options);
+  const reducedDateTimeParts = getDateTimePartsSubset(translatedDateTimeParts, ["weekday"]);
   return dateTimePartsToString(reducedDateTimeParts);
 };
-export var convertDateToMonthLongString = function convertDateToMonthLongString(value, dateFormatIntl, languageIntl, options) {
-  var monthLongDateParts = getMonthLongDateParts(value, dateFormatIntl, options);
-  var monthLongDatePartsByLanguageIntl = getMonthLongDateParts(value, languageIntl, options);
-  var translatedDateTimeParts = translateDateTimeParts(monthLongDateParts, monthLongDatePartsByLanguageIntl, options);
-  var reducedDateTimeParts = getDateTimePartsSubset(translatedDateTimeParts, ['month']);
+const convertDateToMonthLongString = (value, dateFormatIntl, languageIntl, options) => {
+  const monthLongDateParts = getMonthLongDateParts(value, dateFormatIntl, options);
+  const monthLongDatePartsByLanguageIntl = getMonthLongDateParts(value, languageIntl, options);
+  const translatedDateTimeParts = translateDateTimeParts(monthLongDateParts, monthLongDatePartsByLanguageIntl, options);
+  const reducedDateTimeParts = getDateTimePartsSubset(translatedDateTimeParts, ["month"]);
   return dateTimePartsToString(reducedDateTimeParts);
 };
-export var convertDateToMonthShortString = function convertDateToMonthShortString(value, dateFormatIntl, languageIntl, options) {
-  var monthShortDateParts = getMonthShortDateParts(value, dateFormatIntl, options);
-  var monthShortDatePartsByLanguageIntl = getMonthShortDateParts(value, languageIntl, options);
-  var translatedDateTimeParts = translateDateTimeParts(monthShortDateParts, monthShortDatePartsByLanguageIntl, options);
-  var reducedDateTimeParts = getDateTimePartsSubset(translatedDateTimeParts, ['month']);
+const convertDateToMonthShortString = (value, dateFormatIntl, languageIntl, options) => {
+  const monthShortDateParts = getMonthShortDateParts(value, dateFormatIntl, options);
+  const monthShortDatePartsByLanguageIntl = getMonthShortDateParts(value, languageIntl, options);
+  const translatedDateTimeParts = translateDateTimeParts(monthShortDateParts, monthShortDatePartsByLanguageIntl, options);
+  const reducedDateTimeParts = getDateTimePartsSubset(translatedDateTimeParts, ["month"]);
   return dateTimePartsToString(reducedDateTimeParts);
 };
-export var addPrefix = function addPrefix(value, options) {
-  var result = value;
-  if (options != null && options.prefix) {
-    result = (options == null ? void 0 : options.prefix) + result;
+const addPrefix = (value, options) => {
+  let result = value;
+  if (options?.prefix) {
+    result = options?.prefix + result;
   }
   return result;
 };
-export var addSuffix = function addSuffix(value, options) {
-  var result = value;
-  if (options != null && options.suffix) {
-    result += options == null ? void 0 : options.suffix;
+const addSuffix = (value, options) => {
+  let result = value;
+  if (options?.suffix) {
+    result += options?.suffix;
   }
   return result;
 };
-export var changeNamingConvention = function changeNamingConvention(value, options) {
-  var result = value;
-  switch (options == null ? void 0 : options.namingConvention) {
+const changeNamingConvention = (value, options) => {
+  let result = value;
+  switch (options?.namingConvention) {
     case UPPER_CASE:
       result = result.toUpperCase();
       break;
@@ -105,15 +108,27 @@ export var changeNamingConvention = function changeNamingConvention(value, optio
     case LOWER_FIRST:
       result = result.charAt(0).toLowerCase() + result.slice(1);
       break;
-    default:
-      break;
   }
   return result;
 };
-export var getDefaultDataTimeOptions = function getDefaultDataTimeOptions(showTime) {
-  return {
-    targetFormat: showTime ? DATETIME : DATE,
-    dateOptions: DEFAULT_FORMAT_MONTH_SHORT_OPTIONS,
-    namingConvention: UPPER_FIRST
-  };
-};
+const getDefaultDataTimeOptions = (showTime) => ({
+  targetFormat: showTime ? DATETIME : DATE,
+  dateOptions: DEFAULT_FORMAT_MONTH_SHORT_OPTIONS,
+  namingConvention: UPPER_FIRST
+});
+export {
+  addPrefix,
+  addSuffix,
+  changeNamingConvention,
+  convertDateToDateString,
+  convertDateToDateTimeString,
+  convertDateToMonthLongString,
+  convertDateToMonthShortString,
+  convertDateToRelativeFromString,
+  convertDateToRelativeToString,
+  convertDateToTimeString,
+  convertDateToWeekdayLongString,
+  convertDateToWeekdayShortString,
+  convertNumberString,
+  getDefaultDataTimeOptions
+};

package/dist/js/data-format/utils/dataFormatConfig.utils.d.ts

@@ -1,2 +1,2 @@
-import { type DataFormatConfig, type DataFormatNotationType } from '../types';
+import { DataFormatConfig, DataFormatNotationType } from '../types';
 export declare const getDataFormatConfigFromNotation: (notation: DataFormatNotationType) => DataFormatConfig;

package/dist/js/data-format/utils/dataFormatConfig.utils.js

@@ -1,8 +1,9 @@
-export var getDataFormatConfigFromNotation = function getDataFormatConfigFromNotation(notation) {
-  return {
-    startWeekDayNotation: notation,
-    dateFormatNotation: notation,
-    timeFormatNotation: notation,
-    numberFormatNotation: notation
-  };
-};
+const getDataFormatConfigFromNotation = (notation) => ({
+  startWeekDayNotation: notation,
+  dateFormatNotation: notation,
+  timeFormatNotation: notation,
+  numberFormatNotation: notation
+});
+export {
+  getDataFormatConfigFromNotation
+};

package/dist/js/data-format/utils/date.utils.d.ts

@@ -1,5 +1,5 @@
-import dayjs from 'dayjs';
-import { type DateConstantsTargetFormat, type DateToFormatOptions } from '../types';
+import { default as dayjs } from 'dayjs';
+import { DateConstantsTargetFormat, DateToFormatOptions } from '../types';
 export declare const getDatesRange: (start: Date, end: Date, interval: dayjs.UnitType) => Date[];
 export declare const isValidDate: (date: Date) => boolean;
 export declare const getConstantDatesAndFormattingOptions: (targetFormat: DateConstantsTargetFormat, isSundayFirstWeekDay: boolean, customStartDate?: Date, customEndDate?: Date, customInterval?: dayjs.UnitType) => {

package/dist/js/data-format/utils/date.utils.js

@@ -1,50 +1,54 @@
-import dayjs from 'dayjs';
-import { MONTHS_LONG, MONTHS_SHORT, MONTH_LONG, MONTH_SHORT, UPPER_FIRST, WEEKDAYS_LONG, WEEKDAYS_SHORT, WEEKDAY_LONG, WEEKDAY_SHORT } from '../constants';
-export var getDatesRange = function getDatesRange(start, end, interval) {
-  var startDate = dayjs(start);
-  var endDate = dayjs(end);
-  var diffInUnits = endDate.diff(startDate, interval);
-  return Array.from(Array(diffInUnits + 1).keys()).map(function (i) {
+import dayjs from "dayjs";
+import "../constants/dataFormatConfig.constants.js";
+import { WEEKDAYS_SHORT, WEEKDAYS_LONG, MONTHS_SHORT, MONTHS_LONG, MONTH_LONG, UPPER_FIRST, WEEKDAY_SHORT, WEEKDAY_LONG, MONTH_SHORT } from "../constants/dataFormat.constants.js";
+const getDatesRange = (start, end, interval) => {
+  const startDate = dayjs(start);
+  const endDate = dayjs(end);
+  const diffInUnits = endDate.diff(startDate, interval);
+  return Array.from(Array(diffInUnits + 1).keys()).map((i) => {
     return startDate.add(i, interval).toDate();
   });
 };
-export var isValidDate = function isValidDate(date) {
+const isValidDate = (date) => {
   return !isNaN(date.getTime());
 };
-export var getConstantDatesAndFormattingOptions = function getConstantDatesAndFormattingOptions(targetFormat, isSundayFirstWeekDay, customStartDate, customEndDate, customInterval) {
-  var startDate = new Date(2023, 0, isSundayFirstWeekDay ? 1 : 2);
-  var endDate = new Date(2023, 0, isSundayFirstWeekDay ? 1 : 2);
-  var defaultTargetFormat = MONTH_LONG;
-  var interval = 'month';
+const getConstantDatesAndFormattingOptions = (targetFormat, isSundayFirstWeekDay, customStartDate, customEndDate, customInterval) => {
+  const startDate = new Date(2023, 0, isSundayFirstWeekDay ? 1 : 2);
+  const endDate = new Date(2023, 0, isSundayFirstWeekDay ? 1 : 2);
+  let defaultTargetFormat = MONTH_LONG;
+  let interval = "month";
   switch (targetFormat) {
     case MONTHS_LONG:
       endDate.setMonth(11);
-      interval = 'month';
+      interval = "month";
       defaultTargetFormat = MONTH_LONG;
       break;
     case MONTHS_SHORT:
       endDate.setMonth(11);
-      interval = 'month';
+      interval = "month";
       defaultTargetFormat = MONTH_SHORT;
       break;
     case WEEKDAYS_LONG:
       endDate.setDate(isSundayFirstWeekDay ? 7 : 8);
-      interval = 'day';
+      interval = "day";
       defaultTargetFormat = WEEKDAY_LONG;
       break;
     case WEEKDAYS_SHORT:
       endDate.setDate(isSundayFirstWeekDay ? 7 : 8);
-      interval = 'day';
+      interval = "day";
       defaultTargetFormat = WEEKDAY_SHORT;
       break;
-    default:
-      break;
   }
   return {
-    constantDates: getDatesRange(customStartDate != null ? customStartDate : startDate, customEndDate != null ? customEndDate : endDate, customInterval != null ? customInterval : interval),
+    constantDates: getDatesRange(customStartDate ?? startDate, customEndDate ?? endDate, customInterval ?? interval),
     defaultOptions: {
       namingConvention: UPPER_FIRST,
       targetFormat: defaultTargetFormat
     }
   };
-};
+};
+export {
+  getConstantDatesAndFormattingOptions,
+  getDatesRange,
+  isValidDate
+};

package/dist/js/data-format/utils/dateTimeParts.utils.d.ts

@@ -1,5 +1,5 @@
-import { type FormatDateOptions, type IntlShape } from 'react-intl';
-import { type DateToFormatOptions, type Delimiter } from '../types';
+import { FormatDateOptions, IntlShape } from 'react-intl';
+import { DateToFormatOptions, Delimiter } from '../types';
 export declare const getDateParts: (value: Date, dateFormatIntl: IntlShape, option?: FormatDateOptions) => Intl.DateTimeFormatPart[];
 export declare const getTimeParts: (value: Date, timeFormatIntl: IntlShape, option?: FormatDateOptions) => Intl.DateTimeFormatPart[];
 export declare const getWeekdayLongDateParts: (value: Date, dateFormatIntl: IntlShape, option?: FormatDateOptions) => Intl.DateTimeFormatPart[];