@synerise/ds-core 1.11.0 → 1.11.1

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

@@ -1,3 +1,48 @@
-export { DEFAULT_DATA_FORMAT_CONFIG, DEFAULT_DATA_FORMAT_INTL, DEFAULT_DATA_FORMAT_NOTATION, EU_NOTATION, US_NOTATION } from './dataFormatConfig.constants';
-export { DEFAULT_FORMAT_DATE_OPTIONS, DEFAULT_FORMAT_TIME_OPTIONS, DEFAULT_FORMAT_WEEKDAY_LONG_OPTIONS, DEFAULT_FORMAT_WEEKDAY_SHORT_OPTIONS, DEFAULT_FORMAT_MONTH_LONG_OPTIONS, DEFAULT_FORMAT_MONTH_SHORT_OPTIONS, DATE, TIME, RELATIVE_TO, RELATIVE_FROM, RELATIVE_TO_WITHOUT_SUFFIX, RELATIVE_FROM_WITHOUT_SUFFIX, DATETIME, WEEKDAY_LONG, WEEKDAY_SHORT, MONTH_LONG, MONTH_SHORT, UPPER_CASE, UPPER_FIRST, LOWER_CASE, LOWER_FIRST, US_THOUSAND_DELIMITER, US_DECIMAL_DELIMITER, EU_THOUSAND_DELIMITER, EU_DECIMAL_DELIMITER, DATE_CONSTANTS_TARGET_FORMATS, MONTHS_LONG, MONTHS_SHORT, WEEKDAYS_LONG, WEEKDAYS_SHORT, COMPACT_LARGER_NUMBER, COMPACT_DECIMAL_LARGER_NUMBER, LARGER_NUMBER_LIMIT, DEFAULT_FORMAT_NUMBER_OPTIONS } from './dataFormat.constants';
-export { WEEKDAY, MONTH, LONG, SHORT } from './dateTimeParts.constants';
+import { DEFAULT_DATA_FORMAT_CONFIG, DEFAULT_DATA_FORMAT_INTL, DEFAULT_DATA_FORMAT_NOTATION, EU_NOTATION, US_NOTATION } from "./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 "./dataFormat.constants.js";
+import { LONG, MONTH, SHORT, WEEKDAY } from "./dateTimeParts.constants.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,
+  EU_DECIMAL_DELIMITER,
+  EU_NOTATION,
+  EU_THOUSAND_DELIMITER,
+  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
+};

package/dist/js/data-format/contexts/DataFormatConfigContext.d.ts

@@ -1,2 +1,2 @@
-import { type DataFormatConfig } from '../types';
-export declare const DataFormatConfigContext: import("react").Context<DataFormatConfig>;
+import { DataFormatConfig } from '../types';
+export declare const DataFormatConfigContext: import('react').Context<DataFormatConfig>;

package/dist/js/data-format/contexts/DataFormatConfigContext.js

@@ -1,3 +1,6 @@
-import { createContext } from 'react';
-import { DEFAULT_DATA_FORMAT_CONFIG } from '../constants';
-export var DataFormatConfigContext = /*#__PURE__*/createContext(DEFAULT_DATA_FORMAT_CONFIG);
+import { createContext } from "react";
+import { DEFAULT_DATA_FORMAT_CONFIG } from "../constants/dataFormatConfig.constants.js";
+const DataFormatConfigContext = createContext(DEFAULT_DATA_FORMAT_CONFIG);
+export {
+  DataFormatConfigContext
+};

package/dist/js/data-format/contexts/DataFormatIntlsContext.d.ts

@@ -1,2 +1,2 @@
-import { type DataFormatIntls } from '../types';
-export declare const DataFormatIntlsContext: import("react").Context<DataFormatIntls>;
+import { DataFormatIntls } from '../types';
+export declare const DataFormatIntlsContext: import('react').Context<DataFormatIntls>;

package/dist/js/data-format/contexts/DataFormatIntlsContext.js

@@ -1,7 +1,10 @@
-import { createContext } from 'react';
-import { DEFAULT_DATA_FORMAT_INTL } from '../constants';
-export var DataFormatIntlsContext = /*#__PURE__*/createContext({
+import { createContext } from "react";
+import { DEFAULT_DATA_FORMAT_INTL } from "../constants/dataFormatConfig.constants.js";
+const DataFormatIntlsContext = createContext({
   timeFormatIntl: DEFAULT_DATA_FORMAT_INTL,
   numberFormatIntl: DEFAULT_DATA_FORMAT_INTL,
   dateFormatIntl: DEFAULT_DATA_FORMAT_INTL
-});
+});
+export {
+  DataFormatIntlsContext
+};

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

@@ -1,2 +1,6 @@
-export { DataFormatConfigContext } from './DataFormatConfigContext';
-export { DataFormatIntlsContext } from './DataFormatIntlsContext';
+import { DataFormatConfigContext } from "./DataFormatConfigContext.js";
+import { DataFormatIntlsContext } from "./DataFormatIntlsContext.js";
+export {
+  DataFormatConfigContext,
+  DataFormatIntlsContext
+};

package/dist/js/data-format/hocs/withDataFormat.d.ts

@@ -1,4 +1,4 @@
-import { type ComponentType } from 'react';
-import { type UseDataFormatProps } from '../hooks';
+import { ComponentType } from 'react';
+import { UseDataFormatProps } from '../hooks';
 export type WithDataFormatProps = UseDataFormatProps;
 export declare const withDataFormat: <Props extends object>(WrappedComponent: ComponentType<Props>) => ComponentType<Omit<Props, keyof UseDataFormatProps>>;

package/dist/js/data-format/hocs/withDataFormat.js

@@ -1,10 +1,24 @@
-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 React from 'react';
-import { useDataFormat } from '../hooks';
-export var withDataFormat = function withDataFormat(WrappedComponent) {
-  return function (props) {
-    var dataFormatProps = useDataFormat();
-    var newProps = _extends({}, props, dataFormatProps);
-    return /*#__PURE__*/React.createElement(WrappedComponent, newProps);
+import { jsx } from "react/jsx-runtime";
+import "react";
+import "../contexts/DataFormatConfigContext.js";
+import "../contexts/DataFormatIntlsContext.js";
+import { useDataFormat } from "../hooks/useDataFormat.js";
+import "dayjs";
+import "moment";
+import "react-intl";
+import "../constants/dataFormatConfig.constants.js";
+import "../utils/timeZone.utils.js";
+import "../utils/dataFormat.utils.js";
+const withDataFormat = (WrappedComponent) => {
+  return (props) => {
+    const dataFormatProps = useDataFormat();
+    const newProps = {
+      ...props,
+      ...dataFormatProps
+    };
+    return /* @__PURE__ */ jsx(WrappedComponent, { ...newProps });
   };
-};
+};
+export {
+  withDataFormat
+};

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

@@ -1,6 +1,14 @@
-export { useDataFormatConfig } from './useDataFormatConfig';
-export { useDataFormat } from './useDataFormat';
-export { useDataFormatUtils } from './useDataFormatUtils';
-export { useSingleIntl } from './useSingleIntl';
-export { useDataFormatIntls } from './useDataFormatIntls';
-export { useRelativeDateTimeUpdate } from './useRelativeDateTimeUpdate';
+import { useDataFormatConfig } from "./useDataFormatConfig.js";
+import { useDataFormat } from "./useDataFormat.js";
+import { useDataFormatUtils } from "./useDataFormatUtils.js";
+import { useSingleIntl } from "./useSingleIntl.js";
+import { useDataFormatIntls } from "./useDataFormatIntls.js";
+import { useRelativeDateTimeUpdate } from "./useRelativeDateTimeUpdate.js";
+export {
+  useDataFormat,
+  useDataFormatConfig,
+  useDataFormatIntls,
+  useDataFormatUtils,
+  useRelativeDateTimeUpdate,
+  useSingleIntl
+};

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

@@ -1,4 +1,4 @@
-import { type Delimiter, type OverloadFormatMultipleValues, type OverloadFormatValue, type OverloadGetConstants } from '../types';
+import { Delimiter, OverloadFormatMultipleValues, OverloadFormatValue, OverloadGetConstants } from '../types';
 export type UseDataFormatProps = {
     firstDayOfWeek: number;
     isSundayFirstWeekDay: boolean;

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

@@ -1,96 +1,99 @@
-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 { isDayjs } from 'dayjs';
-import moment from 'moment';
-import { useCallback, useMemo } from 'react';
-import { DATE_CONSTANTS_TARGET_FORMATS } from '../constants';
-import { getConstantDatesAndFormattingOptions } from '../utils';
-import { isValidDate } from '../utils/date.utils';
-import { useDataFormatConfig } from './useDataFormatConfig';
-import { useDataFormatIntls } from './useDataFormatIntls';
-import { useDataFormatUtils } from './useDataFormatUtils';
-export var useDataFormat = function useDataFormat() {
-  var _useDataFormatIntls = useDataFormatIntls(),
-    numberFormatIntl = _useDataFormatIntls.numberFormatIntl,
-    timeFormatIntl = _useDataFormatIntls.timeFormatIntl,
-    dateFormatIntl = _useDataFormatIntls.dateFormatIntl;
-  var _useDataFormatConfig = useDataFormatConfig(),
-    startWeekDayNotation = _useDataFormatConfig.startWeekDayNotation,
-    timeFormatNotation = _useDataFormatConfig.timeFormatNotation,
-    numberFormatNotation = _useDataFormatConfig.numberFormatNotation;
-  var _useDataFormatUtils = useDataFormatUtils(),
-    getFirstDayOfWeekFromNotation = _useDataFormatUtils.getFirstDayOfWeekFromNotation,
-    getIs12HoursClockFromNotation = _useDataFormatUtils.getIs12HoursClockFromNotation,
-    getFormattedNumber = _useDataFormatUtils.getFormattedNumber,
-    getFormattedDate = _useDataFormatUtils.getFormattedDate,
-    getFormattedDateFromMoment = _useDataFormatUtils.getFormattedDateFromMoment,
-    getFormattedDateFromDayjs = _useDataFormatUtils.getFormattedDateFromDayjs,
-    getFormattedValueUsingCommonOptions = _useDataFormatUtils.getFormattedValueUsingCommonOptions,
-    getThousandDelimiterFromNotation = _useDataFormatUtils.getThousandDelimiterFromNotation,
-    getDecimalDelimiterFromNotation = _useDataFormatUtils.getDecimalDelimiterFromNotation;
-  var firstDayOfWeek = useMemo(function () {
-    return getFirstDayOfWeekFromNotation(startWeekDayNotation);
-  }, [startWeekDayNotation, getFirstDayOfWeekFromNotation]);
-  var isSundayFirstWeekDay = useMemo(function () {
-    return firstDayOfWeek === 0;
-  }, [firstDayOfWeek]);
-  var is12HoursClock = useMemo(function () {
-    return getIs12HoursClockFromNotation(timeFormatNotation);
-  }, [timeFormatNotation, getIs12HoursClockFromNotation]);
-  var formatValue = useCallback(
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  function (value, options) {
-    var result = '';
-    if (value instanceof moment) {
-      result = getFormattedDateFromMoment(value, dateFormatIntl, timeFormatIntl, options);
-    }
-    if (isDayjs(value)) {
-      result = getFormattedDateFromDayjs(value, dateFormatIntl, timeFormatIntl, options);
-    }
-    if (value instanceof Date) {
-      if (!isValidDate(value)) {
-        console.warn('invalid date', value);
-        return value.toString();
+import { isDayjs } from "dayjs";
+import moment from "moment";
+import { useMemo, useCallback } from "react";
+import "../constants/dataFormatConfig.constants.js";
+import { DATE_CONSTANTS_TARGET_FORMATS } from "../constants/dataFormat.constants.js";
+import "../utils/timeZone.utils.js";
+import "../utils/dataFormat.utils.js";
+import { isValidDate, getConstantDatesAndFormattingOptions } from "../utils/date.utils.js";
+import { useDataFormatConfig } from "./useDataFormatConfig.js";
+import { useDataFormatIntls } from "./useDataFormatIntls.js";
+import { useDataFormatUtils } from "./useDataFormatUtils.js";
+const useDataFormat = () => {
+  const {
+    numberFormatIntl,
+    timeFormatIntl,
+    dateFormatIntl
+  } = useDataFormatIntls();
+  const {
+    startWeekDayNotation,
+    timeFormatNotation,
+    numberFormatNotation
+  } = useDataFormatConfig();
+  const {
+    getFirstDayOfWeekFromNotation,
+    getIs12HoursClockFromNotation,
+    getFormattedNumber,
+    getFormattedDate,
+    getFormattedDateFromMoment,
+    getFormattedDateFromDayjs,
+    getFormattedValueUsingCommonOptions,
+    getThousandDelimiterFromNotation,
+    getDecimalDelimiterFromNotation
+  } = useDataFormatUtils();
+  const firstDayOfWeek = useMemo(() => getFirstDayOfWeekFromNotation(startWeekDayNotation), [startWeekDayNotation, getFirstDayOfWeekFromNotation]);
+  const isSundayFirstWeekDay = useMemo(() => firstDayOfWeek === 0, [firstDayOfWeek]);
+  const is12HoursClock = useMemo(() => getIs12HoursClockFromNotation(timeFormatNotation), [timeFormatNotation, getIs12HoursClockFromNotation]);
+  const formatValue = useCallback(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (value, options) => {
+      let result = "";
+      if (value instanceof moment) {
+        result = getFormattedDateFromMoment(value, dateFormatIntl, timeFormatIntl, options);
       }
-      result = getFormattedDate(value, dateFormatIntl, timeFormatIntl, options);
-    }
-    if (typeof value === 'number') {
-      result = getFormattedNumber(value, numberFormatIntl, options);
-    }
-    if (typeof value === 'string') {
-      result = value;
-    }
-    return getFormattedValueUsingCommonOptions(result, options);
-  }, [numberFormatIntl, dateFormatIntl, timeFormatIntl, getFormattedDate, getFormattedDateFromMoment, getFormattedNumber, getFormattedDateFromDayjs, getFormattedValueUsingCommonOptions]);
-  var formatMultipleValues = useCallback(
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  function (values, options) {
-    return values.map(function (value) {
-      return formatValue(value, options);
-    });
-  }, [formatValue]);
-  var getConstants = useCallback(function (targetFormat, options, customStartDate, customEndDate, interval) {
+      if (isDayjs(value)) {
+        result = getFormattedDateFromDayjs(value, dateFormatIntl, timeFormatIntl, options);
+      }
+      if (value instanceof Date) {
+        if (!isValidDate(value)) {
+          console.warn("invalid date", value);
+          return value.toString();
+        }
+        result = getFormattedDate(value, dateFormatIntl, timeFormatIntl, options);
+      }
+      if (typeof value === "number") {
+        result = getFormattedNumber(value, numberFormatIntl, options);
+      }
+      if (typeof value === "string") {
+        result = value;
+      }
+      return getFormattedValueUsingCommonOptions(result, options);
+    },
+    [numberFormatIntl, dateFormatIntl, timeFormatIntl, getFormattedDate, getFormattedDateFromMoment, getFormattedNumber, getFormattedDateFromDayjs, getFormattedValueUsingCommonOptions]
+  );
+  const formatMultipleValues = useCallback(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (values, options) => {
+      return values.map((value) => formatValue(value, options));
+    },
+    [formatValue]
+  );
+  const getConstants = useCallback((targetFormat, options, customStartDate, customEndDate, interval) => {
     if (DATE_CONSTANTS_TARGET_FORMATS.includes(targetFormat)) {
-      var _getConstantDatesAndF = getConstantDatesAndFormattingOptions(targetFormat, isSundayFirstWeekDay, customStartDate, customEndDate, interval),
-        constantDates = _getConstantDatesAndF.constantDates,
-        defaultOptions = _getConstantDatesAndF.defaultOptions;
-      return formatMultipleValues(constantDates, _extends({}, defaultOptions, options));
+      const {
+        constantDates,
+        defaultOptions
+      } = getConstantDatesAndFormattingOptions(targetFormat, isSundayFirstWeekDay, customStartDate, customEndDate, interval);
+      return formatMultipleValues(constantDates, {
+        ...defaultOptions,
+        ...options
+      });
     }
-    return undefined;
+    return void 0;
   }, [formatMultipleValues, isSundayFirstWeekDay]);
-  var thousandDelimiter = useMemo(function () {
-    return getThousandDelimiterFromNotation(numberFormatNotation);
-  }, [numberFormatNotation, getThousandDelimiterFromNotation]);
-  var decimalDelimiter = useMemo(function () {
-    return getDecimalDelimiterFromNotation(numberFormatNotation);
-  }, [numberFormatNotation, getDecimalDelimiterFromNotation]);
+  const thousandDelimiter = useMemo(() => getThousandDelimiterFromNotation(numberFormatNotation), [numberFormatNotation, getThousandDelimiterFromNotation]);
+  const decimalDelimiter = useMemo(() => getDecimalDelimiterFromNotation(numberFormatNotation), [numberFormatNotation, getDecimalDelimiterFromNotation]);
   return {
-    firstDayOfWeek: firstDayOfWeek,
-    isSundayFirstWeekDay: isSundayFirstWeekDay,
-    is12HoursClock: is12HoursClock,
-    formatValue: formatValue,
-    formatMultipleValues: formatMultipleValues,
-    getConstants: getConstants,
-    thousandDelimiter: thousandDelimiter,
-    decimalDelimiter: decimalDelimiter
+    firstDayOfWeek,
+    isSundayFirstWeekDay,
+    is12HoursClock,
+    formatValue,
+    formatMultipleValues,
+    getConstants,
+    thousandDelimiter,
+    decimalDelimiter
   };
-};
+};
+export {
+  useDataFormat
+};

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

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

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

@@ -1,5 +1,9 @@
-import { useContext } from 'react';
-import { DataFormatConfigContext } from '../contexts';
-export var useDataFormatConfig = function useDataFormatConfig() {
+import { useContext } from "react";
+import { DataFormatConfigContext } from "../contexts/DataFormatConfigContext.js";
+import "../contexts/DataFormatIntlsContext.js";
+const useDataFormatConfig = () => {
   return useContext(DataFormatConfigContext);
-};
+};
+export {
+  useDataFormatConfig
+};

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

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

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

@@ -1,5 +1,9 @@
-import { useContext } from 'react';
-import { DataFormatIntlsContext } from '../contexts';
-export var useDataFormatIntls = function useDataFormatIntls() {
+import { useContext } from "react";
+import "../contexts/DataFormatConfigContext.js";
+import { DataFormatIntlsContext } from "../contexts/DataFormatIntlsContext.js";
+const useDataFormatIntls = () => {
   return useContext(DataFormatIntlsContext);
-};
+};
+export {
+  useDataFormatIntls
+};

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

@@ -1,7 +1,7 @@
-import { type Dayjs } from 'dayjs';
-import { type Moment } from 'moment';
-import { type IntlShape } from 'react-intl';
-import { type CommonFormatOptions, type DataFormatNotationType, type DateToFormatOptions, type Delimiter, type NumberToFormatOptions } from '../types';
+import { Dayjs } from 'dayjs';
+import { Moment } from 'moment';
+import { IntlShape } from 'react-intl';
+import { CommonFormatOptions, DataFormatNotationType, DateToFormatOptions, Delimiter, NumberToFormatOptions } from '../types';
 export declare const useDataFormatUtils: () => {
     getLocaleFromNotation: (notation?: DataFormatNotationType) => string;
     getFirstDayOfWeekFromNotation: (notation?: DataFormatNotationType) => number;

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

@@ -1,27 +1,29 @@
-import dayjs from 'dayjs';
-import moment from 'moment';
-import { useCallback } from 'react';
-import { useIntl } from 'react-intl';
-import { DATE, DATETIME, EU_DECIMAL_DELIMITER, EU_NOTATION, EU_THOUSAND_DELIMITER, MONTH_LONG, MONTH_SHORT, RELATIVE_FROM, RELATIVE_FROM_WITHOUT_SUFFIX, RELATIVE_TO, RELATIVE_TO_WITHOUT_SUFFIX, TIME, US_DECIMAL_DELIMITER, US_NOTATION, US_THOUSAND_DELIMITER, WEEKDAY_LONG, WEEKDAY_SHORT } from '../constants';
-import { addPrefix, addSuffix, changeNamingConvention, convertDateToDateString, convertDateToDateTimeString, convertDateToMonthLongString, convertDateToMonthShortString, convertDateToRelativeFromString, convertDateToRelativeToString, convertDateToTimeString, convertDateToWeekdayLongString, convertDateToWeekdayShortString, convertNumberString } from '../utils';
-import { getLocalDateInTimeZone } from '../utils/timeZone.utils';
-import { useDataFormatConfig } from './useDataFormatConfig';
-export var useDataFormatUtils = function useDataFormatUtils() {
-  var languageIntl = useIntl();
-  var _useDataFormatConfig = useDataFormatConfig(),
-    numberFormatNotation = _useDataFormatConfig.numberFormatNotation,
-    applyTimeZoneOffset = _useDataFormatConfig.applyTimeZoneOffset;
-  var getLocaleFromNotation = useCallback(function (notation) {
+import dayjs from "dayjs";
+import moment from "moment";
+import { useCallback } from "react";
+import { useIntl } from "react-intl";
+import { US_NOTATION, EU_NOTATION } from "../constants/dataFormatConfig.constants.js";
+import { US_THOUSAND_DELIMITER, EU_THOUSAND_DELIMITER, US_DECIMAL_DELIMITER, EU_DECIMAL_DELIMITER, DATETIME, TIME, RELATIVE_TO, RELATIVE_TO_WITHOUT_SUFFIX, RELATIVE_FROM, RELATIVE_FROM_WITHOUT_SUFFIX, WEEKDAY_LONG, WEEKDAY_SHORT, MONTH_LONG, MONTH_SHORT, DATE } from "../constants/dataFormat.constants.js";
+import { getLocalDateInTimeZone } from "../utils/timeZone.utils.js";
+import { convertNumberString, convertDateToDateTimeString, convertDateToTimeString, convertDateToRelativeToString, convertDateToRelativeFromString, convertDateToWeekdayLongString, convertDateToWeekdayShortString, convertDateToMonthLongString, convertDateToMonthShortString, convertDateToDateString, addPrefix, addSuffix, changeNamingConvention } from "../utils/dataFormat.utils.js";
+import { useDataFormatConfig } from "./useDataFormatConfig.js";
+const useDataFormatUtils = () => {
+  const languageIntl = useIntl();
+  const {
+    numberFormatNotation,
+    applyTimeZoneOffset
+  } = useDataFormatConfig();
+  const getLocaleFromNotation = useCallback((notation) => {
     switch (notation) {
       case EU_NOTATION:
-        return 'pl';
+        return "pl";
       case US_NOTATION:
-        return 'en-US';
+        return "en-US";
       default:
-        return 'pl';
+        return "pl";
     }
   }, []);
-  var getFirstDayOfWeekFromNotation = useCallback(function (notation) {
+  const getFirstDayOfWeekFromNotation = useCallback((notation) => {
     switch (notation) {
       case EU_NOTATION:
         return 1;
@@ -31,84 +33,81 @@ export var useDataFormatUtils = function useDataFormatUtils() {
         return 1;
     }
   }, []);
-  var getThousandDelimiterFromNotation = useCallback(function (notation) {
-    return notation === US_NOTATION ? US_THOUSAND_DELIMITER : EU_THOUSAND_DELIMITER;
-  }, []);
-  var getDecimalDelimiterFromNotation = useCallback(function (notation) {
-    return notation === US_NOTATION ? US_DECIMAL_DELIMITER : EU_DECIMAL_DELIMITER;
-  }, []);
-  var getIs12HoursClockFromNotation = useCallback(function (notation) {
-    return notation === US_NOTATION;
-  }, []);
-  var getFormattedNumber = useCallback(function (value, numberFormatIntl, options) {
-    var thousandDelimiter = getThousandDelimiterFromNotation(numberFormatNotation);
-    var decimalDelimiter = getDecimalDelimiterFromNotation(numberFormatNotation);
+  const getThousandDelimiterFromNotation = useCallback((notation) => notation === US_NOTATION ? US_THOUSAND_DELIMITER : EU_THOUSAND_DELIMITER, []);
+  const getDecimalDelimiterFromNotation = useCallback((notation) => notation === US_NOTATION ? US_DECIMAL_DELIMITER : EU_DECIMAL_DELIMITER, []);
+  const getIs12HoursClockFromNotation = useCallback((notation) => notation === US_NOTATION, []);
+  const getFormattedNumber = useCallback((value, numberFormatIntl, options) => {
+    const thousandDelimiter = getThousandDelimiterFromNotation(numberFormatNotation);
+    const decimalDelimiter = getDecimalDelimiterFromNotation(numberFormatNotation);
     return convertNumberString(value, numberFormatIntl, languageIntl, thousandDelimiter, decimalDelimiter, options);
   }, [languageIntl, numberFormatNotation, getThousandDelimiterFromNotation, getDecimalDelimiterFromNotation]);
-  var _useIntl = useIntl(),
-    globalTimeZone = _useIntl.timeZone;
-  var getFormattedDate = useCallback(function (value, dateFormatIntl, timeFormatIntl, options) {
-    var _options$applyTimeZon, _value$toString;
-    var valueInContextTimeZone = (_options$applyTimeZon = options == null ? void 0 : options.applyTimeZoneOffset) != null ? _options$applyTimeZon : applyTimeZoneOffset;
-    var valueInTimezone = globalTimeZone && valueInContextTimeZone ? getLocalDateInTimeZone(value.toISOString(), globalTimeZone) : value;
-    if ((options == null ? void 0 : options.targetFormat) === DATETIME) {
+  const {
+    timeZone: globalTimeZone
+  } = useIntl();
+  const getFormattedDate = useCallback((value, dateFormatIntl, timeFormatIntl, options) => {
+    const valueInContextTimeZone = options?.applyTimeZoneOffset ?? applyTimeZoneOffset;
+    const valueInTimezone = globalTimeZone && valueInContextTimeZone ? getLocalDateInTimeZone(value.toISOString(), globalTimeZone) : value;
+    if (options?.targetFormat === DATETIME) {
       return convertDateToDateTimeString(valueInTimezone, dateFormatIntl, timeFormatIntl, languageIntl, options);
     }
-    if ((options == null ? void 0 : options.targetFormat) === TIME) {
+    if (options?.targetFormat === TIME) {
       return convertDateToTimeString(valueInTimezone, timeFormatIntl, options);
     }
-    if ((options == null ? void 0 : options.targetFormat) === RELATIVE_TO) {
+    if (options?.targetFormat === RELATIVE_TO) {
       return convertDateToRelativeToString(value);
     }
-    if ((options == null ? void 0 : options.targetFormat) === RELATIVE_TO_WITHOUT_SUFFIX) {
+    if (options?.targetFormat === RELATIVE_TO_WITHOUT_SUFFIX) {
       return convertDateToRelativeToString(value, true);
     }
-    if ((options == null ? void 0 : options.targetFormat) === RELATIVE_FROM) {
+    if (options?.targetFormat === RELATIVE_FROM) {
       return convertDateToRelativeFromString(value);
     }
-    if ((options == null ? void 0 : options.targetFormat) === RELATIVE_FROM_WITHOUT_SUFFIX) {
+    if (options?.targetFormat === RELATIVE_FROM_WITHOUT_SUFFIX) {
       return convertDateToRelativeFromString(value, true);
     }
-    if ((options == null ? void 0 : options.targetFormat) === WEEKDAY_LONG) {
+    if (options?.targetFormat === WEEKDAY_LONG) {
       return convertDateToWeekdayLongString(valueInTimezone, dateFormatIntl, languageIntl, options);
     }
-    if ((options == null ? void 0 : options.targetFormat) === WEEKDAY_SHORT) {
+    if (options?.targetFormat === WEEKDAY_SHORT) {
       return convertDateToWeekdayShortString(valueInTimezone, dateFormatIntl, languageIntl, options);
     }
-    if ((options == null ? void 0 : options.targetFormat) === MONTH_LONG) {
+    if (options?.targetFormat === MONTH_LONG) {
       return convertDateToMonthLongString(valueInTimezone, dateFormatIntl, languageIntl, options);
     }
-    if ((options == null ? void 0 : options.targetFormat) === MONTH_SHORT) {
+    if (options?.targetFormat === MONTH_SHORT) {
       return convertDateToMonthShortString(valueInTimezone, dateFormatIntl, languageIntl, options);
     }
-    if ((options == null ? void 0 : options.targetFormat) === DATE || !(options != null && options.targetFormat)) {
+    if (options?.targetFormat === DATE || !options?.targetFormat) {
       return convertDateToDateString(valueInTimezone, dateFormatIntl, languageIntl, options);
     }
-    return (_value$toString = value == null ? void 0 : value.toString()) != null ? _value$toString : '';
+    return value?.toString() ?? "";
   }, [globalTimeZone, applyTimeZoneOffset, languageIntl]);
-  var getFormattedDateFromMoment = useCallback(function (value, dateFormatIntl, timeFormatIntl, options) {
+  const getFormattedDateFromMoment = useCallback((value, dateFormatIntl, timeFormatIntl, options) => {
     return getFormattedDate(moment(value).toDate(), dateFormatIntl, timeFormatIntl, options);
   }, [getFormattedDate]);
-  var getFormattedDateFromDayjs = useCallback(function (value, dateFormatIntl, timeFormatIntl, options) {
+  const getFormattedDateFromDayjs = useCallback((value, dateFormatIntl, timeFormatIntl, options) => {
     return getFormattedDate(dayjs(value).toDate(), dateFormatIntl, timeFormatIntl, options);
   }, [getFormattedDate]);
-  var getFormattedValueUsingCommonOptions = useCallback(function (value, options) {
-    var result = value;
+  const getFormattedValueUsingCommonOptions = useCallback((value, options) => {
+    let result = value;
     result = addPrefix(result, options);
     result = addSuffix(result, options);
     result = changeNamingConvention(result, options);
     return result;
   }, []);
   return {
-    getLocaleFromNotation: getLocaleFromNotation,
-    getFirstDayOfWeekFromNotation: getFirstDayOfWeekFromNotation,
-    getIs12HoursClockFromNotation: getIs12HoursClockFromNotation,
-    getFormattedNumber: getFormattedNumber,
-    getFormattedDate: getFormattedDate,
-    getFormattedDateFromMoment: getFormattedDateFromMoment,
-    getFormattedDateFromDayjs: getFormattedDateFromDayjs,
-    getFormattedValueUsingCommonOptions: getFormattedValueUsingCommonOptions,
-    getThousandDelimiterFromNotation: getThousandDelimiterFromNotation,
-    getDecimalDelimiterFromNotation: getDecimalDelimiterFromNotation
+    getLocaleFromNotation,
+    getFirstDayOfWeekFromNotation,
+    getIs12HoursClockFromNotation,
+    getFormattedNumber,
+    getFormattedDate,
+    getFormattedDateFromMoment,
+    getFormattedDateFromDayjs,
+    getFormattedValueUsingCommonOptions,
+    getThousandDelimiterFromNotation,
+    getDecimalDelimiterFromNotation
   };
-};
+};
+export {
+  useDataFormatUtils
+};

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

@@ -1,3 +1,3 @@
-import { type Dayjs } from 'dayjs';
-import { type Moment } from 'moment';
+import { Dayjs } from 'dayjs';
+import { Moment } from 'moment';
 export declare const useRelativeDateTimeUpdate: (value: Date | Moment | Dayjs) => number;