@synerise/ds-core 1.5.1 → 1.6.0

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

@@ -0,0 +1,52 @@
+export var DEFAULT_FORMAT_NUMBER_OPTIONS = {
+  maximumFractionDigits: 2,
+  useGrouping: true
+};
+export var DEFAULT_FORMAT_DATE_OPTIONS = {
+  year: 'numeric',
+  month: 'numeric',
+  day: 'numeric'
+};
+export var DEFAULT_FORMAT_TIME_OPTIONS = {
+  hour: 'numeric',
+  minute: 'numeric'
+};
+export var DEFAULT_FORMAT_WEEKDAY_LONG_OPTIONS = {
+  weekday: 'long'
+};
+export var DEFAULT_FORMAT_WEEKDAY_SHORT_OPTIONS = {
+  weekday: 'short'
+};
+export var DEFAULT_FORMAT_MONTH_LONG_OPTIONS = {
+  month: 'long'
+};
+export var DEFAULT_FORMAT_MONTH_SHORT_OPTIONS = {
+  month: 'short'
+};
+export var DATE = 'date';
+export var TIME = 'time';
+export var DATETIME = 'datetime';
+export var RELATIVE_FROM = 'relative-from';
+export var RELATIVE_TO = 'relative-to';
+export var RELATIVE_FROM_WITHOUT_SUFFIX = 'relative-from-without-suffix';
+export var RELATIVE_TO_WITHOUT_SUFFIX = 'relative-to-without-suffix';
+export var WEEKDAY_LONG = 'weekday-long';
+export var WEEKDAY_SHORT = 'weekday-short';
+export var MONTH_LONG = 'month-long';
+export var MONTH_SHORT = 'month-short';
+export var COMPACT_LARGER_NUMBER = 'compact-larger-number';
+export var COMPACT_DECIMAL_LARGER_NUMBER = 'compact-decimal-larger-number';
+export var LARGER_NUMBER_LIMIT = 999;
+export var UPPER_CASE = 'upperCase';
+export var UPPER_FIRST = 'upperFirst';
+export var LOWER_CASE = 'lowerCase';
+export var LOWER_FIRST = 'lowerFirst';
+export var US_THOUSAND_DELIMITER = ',';
+export var US_DECIMAL_DELIMITER = '.';
+export var EU_THOUSAND_DELIMITER = ' ';
+export var EU_DECIMAL_DELIMITER = ',';
+export var DATE_CONSTANTS_TARGET_FORMATS = ['months-long', 'months-short', 'weekdays-long', 'weekdays-short'];
+export var MONTHS_LONG = 'months-long';
+export var MONTHS_SHORT = 'months-short';
+export var WEEKDAYS_LONG = 'weekdays-long';
+export var WEEKDAYS_SHORT = 'weekdays-short';

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

@@ -0,0 +1,7 @@
+import { type IntlShape } from 'react-intl';
+import { type DataFormatConfig, type DataFormatNotationType } from '../types';
+export declare const EU_NOTATION: DataFormatNotationType;
+export declare const US_NOTATION: DataFormatNotationType;
+export declare const DEFAULT_DATA_FORMAT_NOTATION: DataFormatNotationType;
+export declare const DEFAULT_DATA_FORMAT_CONFIG: DataFormatConfig;
+export declare const DEFAULT_DATA_FORMAT_INTL: IntlShape;

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

@@ -0,0 +1,14 @@
+import { createIntl } from 'react-intl';
+export var EU_NOTATION = 'EU';
+export var US_NOTATION = 'US';
+export var DEFAULT_DATA_FORMAT_NOTATION = EU_NOTATION;
+export var DEFAULT_DATA_FORMAT_CONFIG = {
+  startWeekDayNotation: DEFAULT_DATA_FORMAT_NOTATION,
+  dateFormatNotation: DEFAULT_DATA_FORMAT_NOTATION,
+  timeFormatNotation: DEFAULT_DATA_FORMAT_NOTATION,
+  numberFormatNotation: DEFAULT_DATA_FORMAT_NOTATION,
+  applyTimeZoneOffset: false
+};
+export var DEFAULT_DATA_FORMAT_INTL = createIntl({
+  locale: 'pl'
+});

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

@@ -0,0 +1,5 @@
+import { type DateTimePartFormat } from '../types';
+export declare const WEEKDAY: Intl.DateTimeFormatPartTypes;
+export declare const MONTH: Intl.DateTimeFormatPartTypes;
+export declare const LONG: DateTimePartFormat;
+export declare const SHORT: DateTimePartFormat;

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

@@ -0,0 +1,4 @@
+export var WEEKDAY = 'weekday';
+export var MONTH = 'month';
+export var LONG = 'long';
+export var SHORT = 'short';

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

@@ -0,0 +1,3 @@
+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';

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

@@ -0,0 +1,3 @@
+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';

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,2 @@
+export { DataFormatConfigContext } from './DataFormatConfigContext';
+export { DataFormatIntlsContext } from './DataFormatIntlsContext';

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

@@ -0,0 +1,2 @@
+export { DataFormatConfigContext } from './DataFormatConfigContext';
+export { DataFormatIntlsContext } from './DataFormatIntlsContext';

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

@@ -0,0 +1,4 @@
+import { type ComponentType } from 'react';
+import { type 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

@@ -0,0 +1,10 @@
+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);
+  };
+};

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

@@ -0,0 +1,5 @@
+export { useDataFormatConfig } from './useDataFormatConfig';
+export { useDataFormat, type UseDataFormatProps } from './useDataFormat';
+export { useDataFormatUtils } from './useDataFormatUtils';
+export { useSingleIntl } from './useSingleIntl';
+export { useDataFormatIntls } from './useDataFormatIntls';

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

@@ -0,0 +1,5 @@
+export { useDataFormatConfig } from './useDataFormatConfig';
+export { useDataFormat } from './useDataFormat';
+export { useDataFormatUtils } from './useDataFormatUtils';
+export { useSingleIntl } from './useSingleIntl';
+export { useDataFormatIntls } from './useDataFormatIntls';

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

@@ -0,0 +1,12 @@
+import { type Delimiter, type OverloadFormatMultipleValues, type OverloadFormatValue, type OverloadGetConstants } from '../types';
+export type UseDataFormatProps = {
+    firstDayOfWeek: number;
+    isSundayFirstWeekDay: boolean;
+    is12HoursClock: boolean;
+    formatValue: OverloadFormatValue;
+    formatMultipleValues: OverloadFormatMultipleValues;
+    getConstants: OverloadGetConstants;
+    thousandDelimiter: Delimiter;
+    decimalDelimiter: Delimiter;
+};
+export declare const useDataFormat: () => UseDataFormatProps;

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

@@ -0,0 +1,96 @@
+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();
+      }
+      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 (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));
+    }
+    return undefined;
+  }, [formatMultipleValues, isSundayFirstWeekDay]);
+  var thousandDelimiter = useMemo(function () {
+    return getThousandDelimiterFromNotation(numberFormatNotation);
+  }, [numberFormatNotation, getThousandDelimiterFromNotation]);
+  var decimalDelimiter = useMemo(function () {
+    return getDecimalDelimiterFromNotation(numberFormatNotation);
+  }, [numberFormatNotation, getDecimalDelimiterFromNotation]);
+  return {
+    firstDayOfWeek: firstDayOfWeek,
+    isSundayFirstWeekDay: isSundayFirstWeekDay,
+    is12HoursClock: is12HoursClock,
+    formatValue: formatValue,
+    formatMultipleValues: formatMultipleValues,
+    getConstants: getConstants,
+    thousandDelimiter: thousandDelimiter,
+    decimalDelimiter: decimalDelimiter
+  };
+};

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

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

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

@@ -0,0 +1,5 @@
+import { useContext } from 'react';
+import { DataFormatConfigContext } from '../contexts';
+export var useDataFormatConfig = function useDataFormatConfig() {
+  return useContext(DataFormatConfigContext);
+};

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

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

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

@@ -0,0 +1,5 @@
+import { useContext } from 'react';
+import { DataFormatIntlsContext } from '../contexts';
+export var useDataFormatIntls = function useDataFormatIntls() {
+  return useContext(DataFormatIntlsContext);
+};

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

@@ -0,0 +1,16 @@
+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';
+export declare const useDataFormatUtils: () => {
+    getLocaleFromNotation: (notation?: DataFormatNotationType) => string;
+    getFirstDayOfWeekFromNotation: (notation?: DataFormatNotationType) => number;
+    getIs12HoursClockFromNotation: (notation?: DataFormatNotationType) => boolean;
+    getFormattedNumber: (value: number, numberFormatIntl: IntlShape, options?: NumberToFormatOptions) => string;
+    getFormattedDate: (value: Date, dateFormatIntl: IntlShape, timeFormatIntl: IntlShape, options?: DateToFormatOptions) => string;
+    getFormattedDateFromMoment: (value: Moment, dateFormatIntl: IntlShape, timeFormatIntl: IntlShape, options?: DateToFormatOptions) => string;
+    getFormattedDateFromDayjs: (value: Dayjs, dateFormatIntl: IntlShape, timeFormatIntl: IntlShape, options?: DateToFormatOptions) => string;
+    getFormattedValueUsingCommonOptions: (value: string, options?: CommonFormatOptions) => string;
+    getThousandDelimiterFromNotation: (notation?: DataFormatNotationType) => Delimiter;
+    getDecimalDelimiterFromNotation: (notation?: DataFormatNotationType) => Delimiter;
+};

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

@@ -0,0 +1,113 @@
+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) {
+    switch (notation) {
+      case EU_NOTATION:
+        return 'pl';
+      case US_NOTATION:
+        return 'en-US';
+      default:
+        return 'pl';
+    }
+  }, []);
+  var getFirstDayOfWeekFromNotation = useCallback(function (notation) {
+    switch (notation) {
+      case EU_NOTATION:
+        return 1;
+      case US_NOTATION:
+        return 0;
+      default:
+        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);
+    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 _value$toString;
+    var valueInTimezone = globalTimeZone && applyTimeZoneOffset ? getLocalDateInTimeZone(value.toISOString(), globalTimeZone) : value;
+    if ((options == null ? void 0 : options.targetFormat) === DATETIME) {
+      return convertDateToDateTimeString(valueInTimezone, dateFormatIntl, timeFormatIntl, languageIntl, options);
+    }
+    if ((options == null ? void 0 : options.targetFormat) === TIME) {
+      return convertDateToTimeString(valueInTimezone, timeFormatIntl, options);
+    }
+    if ((options == null ? void 0 : options.targetFormat) === RELATIVE_TO) {
+      return convertDateToRelativeToString(value);
+    }
+    if ((options == null ? void 0 : options.targetFormat) === RELATIVE_TO_WITHOUT_SUFFIX) {
+      return convertDateToRelativeToString(value, true);
+    }
+    if ((options == null ? void 0 : options.targetFormat) === RELATIVE_FROM) {
+      return convertDateToRelativeFromString(value);
+    }
+    if ((options == null ? void 0 : options.targetFormat) === RELATIVE_FROM_WITHOUT_SUFFIX) {
+      return convertDateToRelativeFromString(value, true);
+    }
+    if ((options == null ? void 0 : options.targetFormat) === WEEKDAY_LONG) {
+      return convertDateToWeekdayLongString(valueInTimezone, dateFormatIntl, languageIntl, options);
+    }
+    if ((options == null ? void 0 : options.targetFormat) === WEEKDAY_SHORT) {
+      return convertDateToWeekdayShortString(valueInTimezone, dateFormatIntl, languageIntl, options);
+    }
+    if ((options == null ? void 0 : options.targetFormat) === MONTH_LONG) {
+      return convertDateToMonthLongString(valueInTimezone, dateFormatIntl, languageIntl, options);
+    }
+    if ((options == null ? void 0 : options.targetFormat) === MONTH_SHORT) {
+      return convertDateToMonthShortString(valueInTimezone, dateFormatIntl, languageIntl, options);
+    }
+    if ((options == null ? void 0 : options.targetFormat) === DATE || !(options != null && options.targetFormat)) {
+      return convertDateToDateString(valueInTimezone, dateFormatIntl, languageIntl, options);
+    }
+    return (_value$toString = value == null ? void 0 : value.toString()) != null ? _value$toString : '';
+  }, [globalTimeZone, applyTimeZoneOffset, languageIntl]);
+  var getFormattedDateFromMoment = useCallback(function (value, dateFormatIntl, timeFormatIntl, options) {
+    return getFormattedDate(moment(value).toDate(), dateFormatIntl, timeFormatIntl, options);
+  }, [getFormattedDate]);
+  var getFormattedDateFromDayjs = useCallback(function (value, dateFormatIntl, timeFormatIntl, options) {
+    return getFormattedDate(dayjs(value).toDate(), dateFormatIntl, timeFormatIntl, options);
+  }, [getFormattedDate]);
+  var getFormattedValueUsingCommonOptions = useCallback(function (value, options) {
+    var 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
+  };
+};

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

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

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

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

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

@@ -0,0 +1,8 @@
+export { DataFormatConfigProvider, type DataFormatConfigProviderProps, } from './providers/DataFormatConfigProvider';
+export { FormattedDate, FormattedDateTime, FormattedNumber, FormattedTime, FormattedRelativeDateTimeFrom, FormattedRelativeDateTimeTo, } from './components';
+export { useDataFormat, useDataFormatUtils, useDataFormatConfig, useDataFormatIntls, type UseDataFormatProps, } from './hooks';
+export { withDataFormat, type WithDataFormatProps, } from './hocs/withDataFormat';
+export { getDataFormatConfigFromNotation, getDefaultDataTimeOptions, } from './utils';
+export * from './constants';
+export { DataFormatConfigContext, DataFormatIntlsContext } from './contexts';
+export type { DataFormatNotationType, NumberToFormatOptions, DateToFormatOptions, DataFormatConfig, Delimiter, DateTargetFormat, NumberTargetFormat, NamingConvention, DateToFormat, OverloadFormatValue, OverloadFormatMultipleValues, CommonFormatOptions, DateConstantsTargetFormat, OverloadGetConstants, DateTimePartFormat, DataFormatIntls, } from './types';

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

@@ -0,0 +1,7 @@
+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';

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

@@ -0,0 +1,7 @@
+import React, { type ReactNode } from 'react';
+import { type DataFormatConfig } from '../types';
+export type DataFormatConfigProviderProps = {
+    dataFormatConfig?: DataFormatConfig;
+    children?: ReactNode;
+};
+export declare const DataFormatConfigProvider: ({ dataFormatConfig: dataFormatConfigFromProps, children, }: DataFormatConfigProviderProps) => React.JSX.Element;

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

@@ -0,0 +1,26 @@
+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));
+};

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

@@ -0,0 +1,42 @@
+import { type Dayjs, type default as dayjs } from 'dayjs';
+import { type Moment } from 'moment';
+import { type FormatDateOptions, type FormatNumberOptions, type 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"];
+export type NumberTargetFormat = (typeof _NUMBER_TARGET_FORMATS)[number];
+declare const _NAMING_CONVENTIONS: readonly ["upperCase", "upperFirst", "lowerCase", "lowerFirst"];
+export type NamingConvention = (typeof _NAMING_CONVENTIONS)[number];
+export type DateConstantsTargetFormat = 'months-long' | 'months-short' | 'weekdays-long' | 'weekdays-short';
+export type DateToFormat = Date | Moment | Dayjs;
+export type CommonFormatOptions = {
+    prefix?: string;
+    suffix?: string;
+    namingConvention?: NamingConvention;
+};
+export type NumberToFormatOptions = FormatNumberOptions & CommonFormatOptions & {
+    pluralOptions?: FormatPluralOptions;
+    targetFormat?: NumberTargetFormat;
+};
+export type DateToFormatOptions = FormatDateOptions & CommonFormatOptions & {
+    dateOptions?: FormatDateOptions;
+    timeOptions?: FormatDateOptions;
+    targetFormat?: DateTargetFormat;
+    applyTimeZoneOffset?: boolean;
+};
+export type OverloadFormatValue = {
+    (value: number, options?: NumberToFormatOptions): string;
+    (value: Date | Moment | Dayjs, options?: DateToFormatOptions): string;
+    (value: string, options?: CommonFormatOptions): string;
+};
+export type OverloadFormatMultipleValues = {
+    (values: number[], options?: NumberToFormatOptions): string[];
+    (values: Date[] | Moment[] | Dayjs[], options?: DateToFormatOptions): string[];
+    (values: string[], options?: CommonFormatOptions): string[];
+};
+export type OverloadGetConstants = {
+    (targetFormat: DateConstantsTargetFormat, options?: DateToFormatOptions, customStartDate?: Date, customEndDate?: Date, customInterval?: dayjs.UnitType): string[] | undefined;
+};
+declare const _DELIMITERS: readonly [",", ".", " "];
+export type Delimiter = (typeof _DELIMITERS)[number];
+export {};

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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,16 @@
+import { type 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 = {
+    startWeekDayNotation?: DataFormatNotationType;
+    dateFormatNotation?: DataFormatNotationType;
+    timeFormatNotation?: DataFormatNotationType;
+    numberFormatNotation?: DataFormatNotationType;
+    applyTimeZoneOffset?: boolean;
+};
+export type DataFormatIntls = {
+    numberFormatIntl: IntlShape;
+    dateFormatIntl: IntlShape;
+    timeFormatIntl: IntlShape;
+};
+export {};

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

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

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

@@ -0,0 +1,3 @@
+declare const _DATE_TIME_PART_FORMAT: readonly ["long", "short", "numeric"];
+export type DateTimePartFormat = (typeof _DATE_TIME_PART_FORMAT)[number];
+export {};

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

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

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

@@ -0,0 +1,3 @@
+export type { NumberToFormatOptions, DateToFormatOptions, CommonFormatOptions, DateTargetFormat, NumberTargetFormat, NamingConvention, DateToFormat, OverloadFormatValue, OverloadFormatMultipleValues, OverloadGetConstants, Delimiter, DateConstantsTargetFormat, } from './dataFormat.types';
+export type { DataFormatNotationType, DataFormatConfig, DataFormatIntls, } from './dataFormatConfig.types';
+export type { DateTimePartFormat } from './dateTimeParts.types';

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

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

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

@@ -0,0 +1,16 @@
+import { type IntlShape } from 'react-intl';
+import { type CommonFormatOptions, type DateToFormatOptions, type Delimiter, type 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;
+export declare const convertDateToRelativeFromString: (value: Date, withoutSuffix?: boolean) => string;
+export declare const convertDateToTimeString: (value: Date, timeFormatIntl: IntlShape, options?: DateToFormatOptions) => string;
+export declare const convertDateToDateString: (value: Date, dateFormatIntl: IntlShape, languageIntl: IntlShape, options?: DateToFormatOptions) => string;
+export declare const convertDateToWeekdayLongString: (value: Date, dateFormatIntl: IntlShape, languageIntl: IntlShape, options?: DateToFormatOptions) => string;
+export declare const convertDateToWeekdayShortString: (value: Date, dateFormatIntl: IntlShape, languageIntl: IntlShape, options?: DateToFormatOptions) => string;
+export declare const convertDateToMonthLongString: (value: Date, dateFormatIntl: IntlShape, languageIntl: IntlShape, options?: DateToFormatOptions) => string;
+export declare const convertDateToMonthShortString: (value: Date, dateFormatIntl: IntlShape, languageIntl: IntlShape, options?: DateToFormatOptions) => string;
+export declare const addPrefix: (value: string, options?: CommonFormatOptions) => string;
+export declare const addSuffix: (value: string, options?: CommonFormatOptions) => string;
+export declare const changeNamingConvention: (value: string, options?: CommonFormatOptions) => string;
+export declare const getDefaultDataTimeOptions: (showTime?: boolean) => DateToFormatOptions;