@synerise/ds-core 1.5.0 → 1.5.2

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;

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,14 @@
+import { type FormatDateOptions, type IntlShape } from 'react-intl';
+import { type DateToFormatOptions, type Delimiter } from '../types';
+export declare const getDateParts: (value: Date, dateFormatIntl: IntlShape, option?: FormatDateOptions) => Intl.DateTimeFormatPart[];
+export declare const getTimeParts: (value: Date, timeFormatIntl: IntlShape, option?: FormatDateOptions) => Intl.DateTimeFormatPart[];
+export declare const getWeekdayLongDateParts: (value: Date, dateFormatIntl: IntlShape, option?: FormatDateOptions) => Intl.DateTimeFormatPart[];
+export declare const getWeekdayShortDateParts: (value: Date, dateFormatIntl: IntlShape, option?: FormatDateOptions) => Intl.DateTimeFormatPart[];
+export declare const getMonthLongDateParts: (value: Date, dateFormatIntl: IntlShape, option?: FormatDateOptions) => Intl.DateTimeFormatPart[];
+export declare const getMonthShortDateParts: (value: Date, dateFormatIntl: IntlShape, option?: FormatDateOptions) => Intl.DateTimeFormatPart[];
+export declare const getDateTimePartsSubset: (dateTimeParts: Intl.DateTimeFormatPart[], subsetTypes: Intl.DateTimeFormatPartTypes[]) => Intl.DateTimeFormatPart[];
+export declare const nbspToSpace: (text: string) => string;
+export declare const numberPartsToString: (numberParts: Intl.NumberFormatPart[], thousandDelimiter: Delimiter, decimalDelimiter: Delimiter) => string;
+export declare const dateTimePartsToString: (dateTimeParts: Intl.DateTimeFormatPart[]) => string;
+export declare const replaceDateTimeParts: (dateTimeParts: Intl.DateTimeFormatPart[], replacementDateTimeParts: Intl.DateTimeFormatPart[], replacementDateTimeFormatPartTypes: Intl.DateTimeFormatPartTypes[]) => Intl.DateTimeFormatPart[];
+export declare const translateDateTimeParts: (dateTimeParts: Intl.DateTimeFormatPart[], dateTimePartsFromLanguageIntl: Intl.DateTimeFormatPart[], options?: DateToFormatOptions) => Intl.DateTimeFormatPart[];

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

@@ -0,0 +1,86 @@
+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 { DEFAULT_FORMAT_DATE_OPTIONS, DEFAULT_FORMAT_MONTH_LONG_OPTIONS, DEFAULT_FORMAT_MONTH_SHORT_OPTIONS, DEFAULT_FORMAT_TIME_OPTIONS, DEFAULT_FORMAT_WEEKDAY_LONG_OPTIONS, DEFAULT_FORMAT_WEEKDAY_SHORT_OPTIONS, LONG, MONTH, MONTH_LONG, MONTH_SHORT, SHORT, WEEKDAY, WEEKDAY_LONG, WEEKDAY_SHORT } from '../constants';
+import { dateToIsoWithOffset } from './timeZone.utils';
+export var getDateParts = function getDateParts(value, dateFormatIntl, option) {
+  return dateFormatIntl.formatDateToParts(dateToIsoWithOffset(value, dateFormatIntl), _extends({}, DEFAULT_FORMAT_DATE_OPTIONS, option));
+};
+export var getTimeParts = function getTimeParts(value, timeFormatIntl, option) {
+  return timeFormatIntl.formatDateToParts(dateToIsoWithOffset(value, timeFormatIntl), _extends({}, DEFAULT_FORMAT_TIME_OPTIONS, option));
+};
+export var getWeekdayLongDateParts = function getWeekdayLongDateParts(value, dateFormatIntl, option) {
+  return dateFormatIntl.formatDateToParts(value, _extends({}, DEFAULT_FORMAT_WEEKDAY_LONG_OPTIONS, option));
+};
+export var getWeekdayShortDateParts = function getWeekdayShortDateParts(value, dateFormatIntl, option) {
+  return dateFormatIntl.formatDateToParts(value, _extends({}, DEFAULT_FORMAT_WEEKDAY_SHORT_OPTIONS, option));
+};
+export var getMonthLongDateParts = function getMonthLongDateParts(value, dateFormatIntl, option) {
+  return dateFormatIntl.formatDateToParts(value, _extends({}, DEFAULT_FORMAT_MONTH_LONG_OPTIONS, option));
+};
+export var getMonthShortDateParts = function getMonthShortDateParts(value, dateFormatIntl, option) {
+  return dateFormatIntl.formatDateToParts(value, _extends({}, DEFAULT_FORMAT_MONTH_SHORT_OPTIONS, option));
+};
+export var getDateTimePartsSubset = function getDateTimePartsSubset(dateTimeParts, subsetTypes) {
+  var resultDateTimeParts = [];
+  dateTimeParts.forEach(function (dateTimePart) {
+    if (subsetTypes.includes(dateTimePart.type)) {
+      resultDateTimeParts.push(dateTimePart);
+    }
+  });
+  return resultDateTimeParts;
+};
+export var nbspToSpace = function nbspToSpace(text) {
+  return text.replace(/&nbsp;/g, ' ').replace(/\u00A0/g, ' ');
+};
+export var numberPartsToString = function numberPartsToString(numberParts, thousandDelimiter, decimalDelimiter) {
+  var numberPartsWithReplacedDelimiters = numberParts.map(function (numberPart) {
+    var numberPartWithReplacedDelimiters = numberPart;
+    if (numberPartWithReplacedDelimiters.type === 'group') {
+      numberPartWithReplacedDelimiters.value = thousandDelimiter;
+    }
+    if (numberPartWithReplacedDelimiters.type === 'decimal') {
+      numberPartWithReplacedDelimiters.value = decimalDelimiter;
+    }
+    return numberPartWithReplacedDelimiters;
+  });
+  var joinedNumberParts = numberPartsWithReplacedDelimiters.map(function (numberPart) {
+    return numberPart.value;
+  }).join('');
+  return nbspToSpace(joinedNumberParts);
+};
+export var dateTimePartsToString = function dateTimePartsToString(dateTimeParts) {
+  var joinedDateTimeParts = dateTimeParts.map(function (dateTimePart) {
+    return dateTimePart.value;
+  }).join('');
+  return nbspToSpace(joinedDateTimeParts);
+};
+export var replaceDateTimeParts = function replaceDateTimeParts(dateTimeParts, replacementDateTimeParts, replacementDateTimeFormatPartTypes) {
+  return dateTimeParts.map(function (dateTimePart) {
+    var dateTimePartToReplace = dateTimePart;
+    if (replacementDateTimeFormatPartTypes != null && replacementDateTimeFormatPartTypes.includes(dateTimePartToReplace.type)) {
+      var foundedReplacementDateTimePart = replacementDateTimeParts == null ? void 0 : replacementDateTimeParts.find(function (replacementDateTimePart) {
+        return replacementDateTimePart.type === dateTimePartToReplace.type;
+      });
+      if (foundedReplacementDateTimePart) {
+        dateTimePartToReplace.value = foundedReplacementDateTimePart.value;
+      }
+    }
+    return dateTimePartToReplace;
+  });
+};
+export var translateDateTimeParts = function translateDateTimeParts(dateTimeParts, dateTimePartsFromLanguageIntl, options) {
+  var _options$dateOptions, _options$dateOptions2;
+  var replacementDateTimeFormatPartTypes = [];
+  if ((options == null ? void 0 : options.targetFormat) === WEEKDAY_LONG || (options == null ? void 0 : options.targetFormat) === WEEKDAY_SHORT) {
+    replacementDateTimeFormatPartTypes.push(WEEKDAY);
+  }
+  if ((options == null ? void 0 : options.targetFormat) === MONTH_LONG || (options == null ? void 0 : options.targetFormat) === MONTH_SHORT) {
+    replacementDateTimeFormatPartTypes.push(MONTH);
+  }
+  if ((options == null || (_options$dateOptions = options.dateOptions) == null ? void 0 : _options$dateOptions.month) === LONG || (options == null || (_options$dateOptions2 = options.dateOptions) == null ? void 0 : _options$dateOptions2.month) === SHORT) {
+    replacementDateTimeFormatPartTypes.push(MONTH);
+  }
+  if ((options == null ? void 0 : options.month) === LONG || (options == null ? void 0 : options.month) === SHORT) {
+    replacementDateTimeFormatPartTypes.push(MONTH);
+  }
+  return replaceDateTimeParts(dateTimeParts, dateTimePartsFromLanguageIntl, replacementDateTimeFormatPartTypes);
+};

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

@@ -0,0 +1,5 @@
+export { getDataFormatConfigFromNotation } from './dataFormatConfig.utils';
+export { getDateParts, getTimeParts, getWeekdayLongDateParts, getWeekdayShortDateParts, getDateTimePartsSubset, nbspToSpace, numberPartsToString, dateTimePartsToString, replaceDateTimeParts, translateDateTimeParts, getMonthLongDateParts, getMonthShortDateParts, } from './dateTimeParts.utils';
+export { convertNumberString, convertDateToDateTimeString, convertDateToRelativeToString, convertDateToRelativeFromString, convertDateToTimeString, convertDateToDateString, convertDateToWeekdayLongString, convertDateToWeekdayShortString, convertDateToMonthLongString, convertDateToMonthShortString, addPrefix, addSuffix, changeNamingConvention, getDefaultDataTimeOptions, } from './dataFormat.utils';
+export { getConstantDatesAndFormattingOptions } from './date.utils';
+export { applyTimezoneOffset, currentTimeInTimezone, getValueAsLocalDate, getTimeZone, dateStringTimeZoneParts, removeTimeZoneOffset, } from './timeZone.utils';

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

@@ -0,0 +1,5 @@
+export { getDataFormatConfigFromNotation } from './dataFormatConfig.utils';
+export { getDateParts, getTimeParts, getWeekdayLongDateParts, getWeekdayShortDateParts, getDateTimePartsSubset, nbspToSpace, numberPartsToString, dateTimePartsToString, replaceDateTimeParts, translateDateTimeParts, getMonthLongDateParts, getMonthShortDateParts } from './dateTimeParts.utils';
+export { convertNumberString, convertDateToDateTimeString, convertDateToRelativeToString, convertDateToRelativeFromString, convertDateToTimeString, convertDateToDateString, convertDateToWeekdayLongString, convertDateToWeekdayShortString, convertDateToMonthLongString, convertDateToMonthShortString, addPrefix, addSuffix, changeNamingConvention, getDefaultDataTimeOptions } from './dataFormat.utils';
+export { getConstantDatesAndFormattingOptions } from './date.utils';
+export { applyTimezoneOffset, currentTimeInTimezone, getValueAsLocalDate, getTimeZone, dateStringTimeZoneParts, removeTimeZoneOffset } from './timeZone.utils';

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

@@ -0,0 +1,16 @@
+import { type IntlShape } from 'react-intl';
+export declare const TIMEZONE_OFFSET_REGEX: RegExp;
+export declare const dateToIsoWithOffset: (value: Date, intlObject: IntlShape) => string;
+export declare const applyTimezoneOffset: (date: Date | undefined, timezoneOffset: true | string | undefined, intl?: IntlShape) => string | Date | undefined;
+export declare const removeTimeZoneOffset: (dateString: string | Date) => string;
+export declare const extractTimeZoneOffset: (datestring: string) => string | null;
+export declare const dateStringTimeZoneParts: (dateTimeIsoString: string) => {
+    dateTimeString: string;
+    offsetString: string | null;
+};
+export declare const getLocalDateInTimeZone: (dateIsoString: string, timezone: string) => Date;
+export declare function toIsoString(date: Date, timeZone?: string | undefined): string;
+export declare const currentTimeInTimezone: (timezoneString: string) => Date;
+export declare const dateTimeStringToLocalDate: (value?: string, timeZone?: string) => Date;
+export declare const getValueAsLocalDate: (value?: Date | string, timeZone?: string) => Date;
+export declare const getTimeZone: (timeZone?: boolean | string, intl?: IntlShape) => string | undefined;

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

@@ -0,0 +1,94 @@
+import { format, getTimezoneOffset, utcToZonedTime } from 'date-fns-tz';
+export var TIMEZONE_OFFSET_REGEX = /([+-]\d\d:\d\d)|([Z])$/;
+var defaultTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+export var dateToIsoWithOffset = function dateToIsoWithOffset(value, intlObject) {
+  return format(value, "yyyy-MM-dd'T'HH:mm:ssxxx", {
+    timeZone: (intlObject == null ? void 0 : intlObject.timeZone) || defaultTimezone
+  });
+};
+export var applyTimezoneOffset = function applyTimezoneOffset(date, timezoneOffset, intl) {
+  if (!timezoneOffset) {
+    return date;
+  }
+  var timezoneString = getTimeZone(timezoneOffset, intl);
+  return toIsoString(date, timezoneString);
+};
+export var removeTimeZoneOffset = function removeTimeZoneOffset(dateString) {
+  var date = dateString instanceof Date ? dateString.toISOString() : dateString;
+  var finalDate = date.replace(TIMEZONE_OFFSET_REGEX, '');
+  return finalDate;
+};
+export var extractTimeZoneOffset = function extractTimeZoneOffset(datestring) {
+  var date = datestring.toString();
+  var found = date.match(TIMEZONE_OFFSET_REGEX);
+  return found && found[0];
+};
+export var dateStringTimeZoneParts = function dateStringTimeZoneParts(dateTimeIsoString) {
+  return {
+    dateTimeString: removeTimeZoneOffset(dateTimeIsoString),
+    offsetString: extractTimeZoneOffset(dateTimeIsoString)
+  };
+};
+export var getLocalDateInTimeZone = function getLocalDateInTimeZone(dateIsoString, timezone) {
+  var _dateStringTimeZonePa = dateStringTimeZoneParts(dateIsoString),
+    offsetString = _dateStringTimeZonePa.offsetString,
+    dateTimeString = _dateStringTimeZonePa.dateTimeString;
+  var localDate = new Date(dateTimeString);
+  var localTimezoneOffset = getTimezoneOffset(timezone, localDate); // +2
+  var dateTimezoneOffset = offsetString ? getTimezoneOffset(offsetString, localDate) : 0; // -4
+
+  var offsetDiff = localTimezoneOffset - dateTimezoneOffset;
+  localDate.setMilliseconds(localDate.getMilliseconds() + offsetDiff);
+  return localDate;
+};
+var pad = function pad(num) {
+  return (num < 10 ? '0' : '') + num;
+};
+export function toIsoString(date, timeZone) {
+  if (timeZone === void 0) {
+    timeZone = 'UTC';
+  }
+  if (!timeZone) {
+    return date.toISOString();
+  }
+  var timeZoneOffset = getTimezoneOffset(timeZone, date);
+  var dif = timeZoneOffset >= 0 ? '+' : '-';
+  var tzHours = pad(Math.floor(Math.abs(timeZoneOffset) / 60 / 60 / 1000));
+  var tzMinutes = pad(Math.abs(timeZoneOffset) / 60 / 1000 % 60);
+  return date.getFullYear() + "-" + pad(date.getMonth() + 1) + "-" + pad(date.getDate()) + "T" + pad(date.getHours()) + ":" + pad(date.getMinutes()) + ":" + pad(date.getSeconds()) + dif + tzHours + ":" + tzMinutes;
+}
+export var currentTimeInTimezone = function currentTimeInTimezone(timezoneString) {
+  var now = new Date();
+  return utcToZonedTime(now.toISOString(), timezoneString);
+};
+export var dateTimeStringToLocalDate = function dateTimeStringToLocalDate(value, timeZone) {
+  if (!value || !timeZone) {
+    return new Date();
+  }
+  if (timeZone !== undefined) {
+    return getLocalDateInTimeZone(value, timeZone);
+  }
+  // FIXME ????
+  return typeof value === 'string' ? new Date(value) : value;
+};
+export var getValueAsLocalDate = function getValueAsLocalDate(value, timeZone) {
+  if (!value) {
+    return new Date();
+  }
+  if (timeZone !== undefined) {
+    if (typeof value !== 'string') {
+      return getLocalDateInTimeZone(value.toISOString(), timeZone);
+    }
+    return getLocalDateInTimeZone(value, timeZone);
+  }
+  return typeof value === 'string' ? new Date(value) : value;
+};
+export var getTimeZone = function getTimeZone(timeZone, intl) {
+  if (!timeZone) {
+    return undefined;
+  }
+  if (timeZone === true) {
+    return (intl == null ? void 0 : intl.timeZone) || defaultTimezone;
+  }
+  return timeZone;
+};

package/dist/js/index.d.ts

@@ -1,3 +1,6 @@
 export { default as DSProvider, type DSProviderProps } from './DSProvider';
 export { default as mediaQuery } from './mediaQuery/mediaQuery';
 export { theme, useTheme, defaultColorsOrder, themeVariables, type ThemePropsVars, type ThemeProps, type WithTheme, type DefaultColor, } from './DSProvider/ThemeProvider/theme';
+export * from './data-format';
+export * from './testing';
+export * from './toaster';

package/dist/js/index.js

@@ -1,3 +1,6 @@
 export { default as DSProvider } from './DSProvider';
 export { default as mediaQuery } from './mediaQuery/mediaQuery';
-export { theme, useTheme, defaultColorsOrder, themeVariables } from './DSProvider/ThemeProvider/theme';
+export { theme, useTheme, defaultColorsOrder, themeVariables } from './DSProvider/ThemeProvider/theme';
+export * from './data-format';
+export * from './testing';
+export * from './toaster';

package/dist/js/mediaQuery/mediaQuery.d.ts

@@ -1,9 +1,5 @@
 import { type FlattenSimpleInterpolation, type SimpleInterpolation } from 'styled-components';
-export type BreakpointKey = 'xsmall' | 'small' | 'medium' | 'large' | 'xlarge' | 'xxlarge';
-export type BreakpointsData = Record<BreakpointKey, {
-    min: number;
-    max: number;
-}>;
+import { type BreakpointKey } from '../DSProvider/ThemeProvider/breakpoints';
 export type Media = {
     from: BreakpointsType;
     to: BreakpointsType;

package/dist/js/testing/index.d.ts

@@ -0,0 +1,2 @@
+export { default as renderWithProvider } from './renderWithProvider/renderWithProvider';
+export { sleep } from './sleep';