@synerise/ds-core 1.5.0 → 1.5.2

package/dist/js/DSProvider/ThemeProvider/breakpoints.d.ts

@@ -1,3 +1,7 @@
-import { type BreakpointsData } from '../../mediaQuery/mediaQuery';
+export type BreakpointKey = 'xsmall' | 'small' | 'medium' | 'large' | 'xlarge' | 'xxlarge';
+export type BreakpointsData = Record<BreakpointKey, {
+    min: number;
+    max: number;
+}>;
 export declare const breakpoints: BreakpointsData;
 export default breakpoints;

package/dist/js/data-format/components/FormattedDate.d.ts

@@ -0,0 +1,9 @@
+import { type Dayjs } from 'dayjs';
+import { type Moment } from 'moment';
+import React from 'react';
+import { type DateToFormatOptions } from '../types';
+export type FormattedDateProps = {
+    value: Date | Moment | Dayjs;
+    options?: DateToFormatOptions;
+};
+export declare const FormattedDate: React.FC<FormattedDateProps>;

package/dist/js/data-format/components/FormattedDate.js

@@ -0,0 +1,9 @@
+import React from 'react';
+import { useDataFormat } from '../hooks';
+export var FormattedDate = function FormattedDate(_ref) {
+  var value = _ref.value,
+    options = _ref.options;
+  var _useDataFormat = useDataFormat(),
+    formatValue = _useDataFormat.formatValue;
+  return /*#__PURE__*/React.createElement(React.Fragment, null, formatValue(value, options));
+};

package/dist/js/data-format/components/FormattedDateTime.d.ts

@@ -0,0 +1,9 @@
+import { type Dayjs } from 'dayjs';
+import { type Moment } from 'moment';
+import React from 'react';
+import { type DateToFormatOptions } from '../types';
+export type FormattedTimeProps = {
+    value: Date | Moment | Dayjs;
+    options?: DateToFormatOptions;
+};
+export declare const FormattedDateTime: React.FC<FormattedTimeProps>;

package/dist/js/data-format/components/FormattedDateTime.js

@@ -0,0 +1,13 @@
+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 { DATETIME } from '../constants';
+import { useDataFormat } from '../hooks';
+export var FormattedDateTime = function FormattedDateTime(_ref) {
+  var value = _ref.value,
+    options = _ref.options;
+  var _useDataFormat = useDataFormat(),
+    formatValue = _useDataFormat.formatValue;
+  return /*#__PURE__*/React.createElement(React.Fragment, null, formatValue(value, _extends({}, options, {
+    targetFormat: DATETIME
+  })));
+};

package/dist/js/data-format/components/FormattedNumber.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { type NumberToFormatOptions } from '../types';
+export type FormattedNumberProps = {
+    value: number;
+    options?: NumberToFormatOptions;
+};
+export declare const FormattedNumber: React.FC<FormattedNumberProps>;

package/dist/js/data-format/components/FormattedNumber.js

@@ -0,0 +1,9 @@
+import React from 'react';
+import { useDataFormat } from '../hooks';
+export var FormattedNumber = function FormattedNumber(_ref) {
+  var value = _ref.value,
+    options = _ref.options;
+  var _useDataFormat = useDataFormat(),
+    formatValue = _useDataFormat.formatValue;
+  return /*#__PURE__*/React.createElement(React.Fragment, null, formatValue(value, options));
+};

package/dist/js/data-format/components/FormattedRelativeDateTime.d.ts

@@ -0,0 +1,10 @@
+import { type Dayjs } from 'dayjs';
+import { type Moment } from 'moment';
+import { type DateToFormatOptions } from '../types';
+export type FormattedRelativeDateTimeProps = {
+    value: Date | Moment | Dayjs;
+    withoutSuffix?: boolean;
+    options?: DateToFormatOptions;
+};
+export declare const FormattedRelativeDateTimeTo: ({ value, withoutSuffix, options, }: FormattedRelativeDateTimeProps) => JSX.Element;
+export declare const FormattedRelativeDateTimeFrom: ({ value, withoutSuffix, options, }: FormattedRelativeDateTimeProps) => JSX.Element;

package/dist/js/data-format/components/FormattedRelativeDateTime.js

@@ -0,0 +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 { RELATIVE_FROM, RELATIVE_FROM_WITHOUT_SUFFIX, RELATIVE_TO, RELATIVE_TO_WITHOUT_SUFFIX } from '../constants';
+import { useDataFormat } from '../hooks';
+export var FormattedRelativeDateTimeTo = function FormattedRelativeDateTimeTo(_ref) {
+  var value = _ref.value,
+    withoutSuffix = _ref.withoutSuffix,
+    options = _ref.options;
+  var _useDataFormat = useDataFormat(),
+    formatValue = _useDataFormat.formatValue;
+  return /*#__PURE__*/React.createElement(React.Fragment, null, formatValue(value, _extends({}, options, {
+    targetFormat: withoutSuffix ? RELATIVE_TO_WITHOUT_SUFFIX : RELATIVE_TO
+  })));
+};
+export var FormattedRelativeDateTimeFrom = function FormattedRelativeDateTimeFrom(_ref2) {
+  var value = _ref2.value,
+    withoutSuffix = _ref2.withoutSuffix,
+    options = _ref2.options;
+  var _useDataFormat2 = useDataFormat(),
+    formatValue = _useDataFormat2.formatValue;
+  return /*#__PURE__*/React.createElement(React.Fragment, null, formatValue(value, _extends({}, options, {
+    targetFormat: withoutSuffix ? RELATIVE_FROM_WITHOUT_SUFFIX : RELATIVE_FROM
+  })));
+};

package/dist/js/data-format/components/FormattedTime.d.ts

@@ -0,0 +1,9 @@
+import { type Dayjs } from 'dayjs';
+import { type Moment } from 'moment';
+import React from 'react';
+import { type DateToFormatOptions } from '../types';
+export type FormattedTimeProps = {
+    value: Date | Moment | Dayjs;
+    options?: DateToFormatOptions;
+};
+export declare const FormattedTime: React.FC<FormattedTimeProps>;

package/dist/js/data-format/components/FormattedTime.js

@@ -0,0 +1,13 @@
+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 { TIME } from '../constants';
+import { useDataFormat } from '../hooks';
+export var FormattedTime = function FormattedTime(_ref) {
+  var value = _ref.value,
+    options = _ref.options;
+  var _useDataFormat = useDataFormat(),
+    formatValue = _useDataFormat.formatValue;
+  return /*#__PURE__*/React.createElement(React.Fragment, null, formatValue(value, _extends({}, options, {
+    targetFormat: TIME
+  })));
+};

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

@@ -0,0 +1,5 @@
+export { FormattedDate } from './FormattedDate';
+export { FormattedDateTime } from './FormattedDateTime';
+export { FormattedNumber } from './FormattedNumber';
+export { FormattedTime } from './FormattedTime';
+export { FormattedRelativeDateTimeFrom, FormattedRelativeDateTimeTo, } from './FormattedRelativeDateTime';

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

@@ -0,0 +1,5 @@
+export { FormattedDate } from './FormattedDate';
+export { FormattedDateTime } from './FormattedDateTime';
+export { FormattedNumber } from './FormattedNumber';
+export { FormattedTime } from './FormattedTime';
+export { FormattedRelativeDateTimeFrom, FormattedRelativeDateTimeTo } from './FormattedRelativeDateTime';

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

@@ -0,0 +1,36 @@
+import { type FormatDateOptions, type FormatNumberOptions } from 'react-intl';
+import { type DateConstantsTargetFormat, type DateTargetFormat, type Delimiter, type NamingConvention, type NumberTargetFormat } from '../types';
+export declare const DEFAULT_FORMAT_NUMBER_OPTIONS: FormatNumberOptions;
+export declare const DEFAULT_FORMAT_DATE_OPTIONS: FormatDateOptions;
+export declare const DEFAULT_FORMAT_TIME_OPTIONS: FormatDateOptions;
+export declare const DEFAULT_FORMAT_WEEKDAY_LONG_OPTIONS: FormatDateOptions;
+export declare const DEFAULT_FORMAT_WEEKDAY_SHORT_OPTIONS: FormatDateOptions;
+export declare const DEFAULT_FORMAT_MONTH_LONG_OPTIONS: FormatDateOptions;
+export declare const DEFAULT_FORMAT_MONTH_SHORT_OPTIONS: FormatDateOptions;
+export declare const DATE: DateTargetFormat;
+export declare const TIME: DateTargetFormat;
+export declare const DATETIME: DateTargetFormat;
+export declare const RELATIVE_FROM: DateTargetFormat;
+export declare const RELATIVE_TO: DateTargetFormat;
+export declare const RELATIVE_FROM_WITHOUT_SUFFIX: DateTargetFormat;
+export declare const RELATIVE_TO_WITHOUT_SUFFIX: DateTargetFormat;
+export declare const WEEKDAY_LONG: DateTargetFormat;
+export declare const WEEKDAY_SHORT: DateTargetFormat;
+export declare const MONTH_LONG: DateTargetFormat;
+export declare const MONTH_SHORT: DateTargetFormat;
+export declare const COMPACT_LARGER_NUMBER: NumberTargetFormat;
+export declare const COMPACT_DECIMAL_LARGER_NUMBER: NumberTargetFormat;
+export declare const LARGER_NUMBER_LIMIT = 999;
+export declare const UPPER_CASE: NamingConvention;
+export declare const UPPER_FIRST: NamingConvention;
+export declare const LOWER_CASE: NamingConvention;
+export declare const LOWER_FIRST: NamingConvention;
+export declare const US_THOUSAND_DELIMITER: Delimiter;
+export declare const US_DECIMAL_DELIMITER: Delimiter;
+export declare const EU_THOUSAND_DELIMITER: Delimiter;
+export declare const EU_DECIMAL_DELIMITER: Delimiter;
+export declare const DATE_CONSTANTS_TARGET_FORMATS: DateConstantsTargetFormat[];
+export declare const MONTHS_LONG: DateConstantsTargetFormat;
+export declare const MONTHS_SHORT: DateConstantsTargetFormat;
+export declare const WEEKDAYS_LONG: DateConstantsTargetFormat;
+export declare const WEEKDAYS_SHORT: DateConstantsTargetFormat;

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;
+};