@synerise/ds-core 1.5.1 → 1.5.2

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;

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