react-intl 7.1.14 → 8.0.1

package/lib/index.js

@@ -1,26 +0,0 @@
-import { createFormattedComponent, createFormattedDateTimePartsComponent, } from './src/components/createFormattedComponent';
-import { createIntl } from './src/components/createIntl';
-import FormattedDateTimeRange from './src/components/dateTimeRange';
-import injectIntl, { Context as IntlContext, Provider as RawIntlProvider, } from './src/components/injectIntl';
-import FormattedMessage from './src/components/message';
-import FormattedPlural from './src/components/plural';
-import IntlProvider from './src/components/provider';
-import FormattedRelativeTime from './src/components/relative';
-import useIntl from './src/components/useIntl';
-export { createIntlCache, InvalidConfigError, MessageFormatError, MissingDataError, MissingTranslationError, IntlError as ReactIntlError, IntlErrorCode as ReactIntlErrorCode, UnsupportedFormatterError, } from '@formatjs/intl';
-export { createIntl, FormattedDateTimeRange, FormattedMessage, FormattedPlural, FormattedRelativeTime, injectIntl, IntlContext, IntlProvider, RawIntlProvider, useIntl, };
-export function defineMessages(msgs) {
-    return msgs;
-}
-export function defineMessage(msg) {
-    return msg;
-}
-// IMPORTANT: Explicit here to prevent api-extractor from outputing `import('./src/types').CustomFormatConfig`
-export var FormattedDate = createFormattedComponent('formatDate');
-export var FormattedTime = createFormattedComponent('formatTime');
-export var FormattedNumber = createFormattedComponent('formatNumber');
-export var FormattedList = createFormattedComponent('formatList');
-export var FormattedDisplayName = createFormattedComponent('formatDisplayName');
-export var FormattedDateParts = createFormattedDateTimePartsComponent('formatDate');
-export var FormattedTimeParts = createFormattedDateTimePartsComponent('formatTime');
-export { FormattedListParts, FormattedNumberParts, } from './src/components/createFormattedComponent';

package/lib/src/components/createFormattedComponent.d.ts

@@ -1,27 +0,0 @@
-import { FormatDateOptions, FormatDisplayNameOptions, FormatListOptions, FormatNumberOptions } from '@formatjs/intl';
-import * as React from 'react';
-import { IntlShape } from '../types';
-type Formatter = {
-    formatDate: FormatDateOptions;
-    formatTime: FormatDateOptions;
-    formatNumber: FormatNumberOptions;
-    formatList: FormatListOptions;
-    formatDisplayName: FormatDisplayNameOptions;
-};
-export declare const FormattedNumberParts: React.FC<Formatter['formatNumber'] & {
-    value: Parameters<IntlShape['formatNumber']>[0];
-    children(val: Intl.NumberFormatPart[]): React.ReactElement | null;
-}>;
-export declare const FormattedListParts: React.FC<Formatter['formatList'] & {
-    value: Parameters<IntlShape['formatList']>[0];
-    children(val: ReturnType<Intl.ListFormat['formatToParts']>): React.ReactElement | null;
-}>;
-export declare function createFormattedDateTimePartsComponent<Name extends 'formatDate' | 'formatTime'>(name: Name): React.FC<Formatter[Name] & {
-    value: Parameters<IntlShape[Name]>[0];
-    children(val: Intl.DateTimeFormatPart[]): React.ReactElement | null;
-}>;
-export declare function createFormattedComponent<Name extends keyof Formatter>(name: Name): React.FC<Formatter[Name] & {
-    value: Parameters<IntlShape[Name]>[0];
-    children?(val: string): React.ReactElement | null;
-}>;
-export {};

package/lib/src/components/createFormattedComponent.js

@@ -1,62 +0,0 @@
-import { __rest } from "tslib";
-import * as React from 'react';
-import useIntl from './useIntl';
-var DisplayName;
-(function (DisplayName) {
-    DisplayName["formatDate"] = "FormattedDate";
-    DisplayName["formatTime"] = "FormattedTime";
-    DisplayName["formatNumber"] = "FormattedNumber";
-    DisplayName["formatList"] = "FormattedList";
-    // Note that this DisplayName is the locale display name, not to be confused with
-    // the name of the enum, which is for React component display name in dev tools.
-    DisplayName["formatDisplayName"] = "FormattedDisplayName";
-})(DisplayName || (DisplayName = {}));
-var DisplayNameParts;
-(function (DisplayNameParts) {
-    DisplayNameParts["formatDate"] = "FormattedDateParts";
-    DisplayNameParts["formatTime"] = "FormattedTimeParts";
-    DisplayNameParts["formatNumber"] = "FormattedNumberParts";
-    DisplayNameParts["formatList"] = "FormattedListParts";
-})(DisplayNameParts || (DisplayNameParts = {}));
-export var FormattedNumberParts = function (props) {
-    var intl = useIntl();
-    var value = props.value, children = props.children, formatProps = __rest(props, ["value", "children"]);
-    return children(intl.formatNumberToParts(value, formatProps));
-};
-FormattedNumberParts.displayName = 'FormattedNumberParts';
-export var FormattedListParts = function (props) {
-    var intl = useIntl();
-    var value = props.value, children = props.children, formatProps = __rest(props, ["value", "children"]);
-    return children(intl.formatListToParts(value, formatProps));
-};
-FormattedNumberParts.displayName = 'FormattedNumberParts';
-export function createFormattedDateTimePartsComponent(name) {
-    var ComponentParts = function (props) {
-        var intl = useIntl();
-        var value = props.value, children = props.children, formatProps = __rest(props, ["value", "children"]);
-        var date = typeof value === 'string' ? new Date(value || 0) : value;
-        var formattedParts = name === 'formatDate'
-            ? intl.formatDateToParts(date, formatProps)
-            : intl.formatTimeToParts(date, formatProps);
-        return children(formattedParts);
-    };
-    ComponentParts.displayName = DisplayNameParts[name];
-    return ComponentParts;
-}
-export function createFormattedComponent(name) {
-    var Component = function (props) {
-        var intl = useIntl();
-        var value = props.value, children = props.children, formatProps = __rest(props
-        // TODO: fix TS type definition for localeMatcher upstream
-        , ["value", "children"]);
-        // TODO: fix TS type definition for localeMatcher upstream
-        var formattedValue = intl[name](value, formatProps);
-        if (typeof children === 'function') {
-            return children(formattedValue);
-        }
-        var Text = intl.textComponent || React.Fragment;
-        return React.createElement(Text, null, formattedValue);
-    };
-    Component.displayName = DisplayName[name];
-    return Component;
-}

package/lib/src/components/createIntl.d.ts

@@ -1,9 +0,0 @@
-import { CreateIntlFn } from '@formatjs/intl';
-import * as React from 'react';
-import type { IntlConfig, IntlShape } from '../types';
-/**
- * Create intl object
- * @param config intl config
- * @param cache cache for formatter instances to prevent memory leak
- */
-export declare const createIntl: CreateIntlFn<React.ReactNode, IntlConfig, IntlShape>;

package/lib/src/components/createIntl.js

@@ -1,58 +0,0 @@
-/*
- * Copyright 2015, Yahoo Inc.
- * Copyrights licensed under the New BSD License.
- * See the accompanying LICENSE file for terms.
- */
-import { __assign, __rest, __spreadArray } from "tslib";
-import { createIntl as coreCreateIntl, formatMessage as coreFormatMessage, } from '@formatjs/intl';
-import { isFormatXMLElementFn, } from 'intl-messageformat';
-import { DEFAULT_INTL_CONFIG, assignUniqueKeysToParts, toKeyedReactNodeArray, } from '../utils';
-function assignUniqueKeysToFormatXMLElementFnArgument(values) {
-    if (!values) {
-        return values;
-    }
-    return Object.keys(values).reduce(function (acc, k) {
-        var v = values[k];
-        acc[k] = isFormatXMLElementFn(v)
-            ? assignUniqueKeysToParts(v)
-            : v;
-        return acc;
-    }, {});
-}
-var formatMessage = function (config, formatters, descriptor, rawValues) {
-    var rest = [];
-    for (var _i = 4; _i < arguments.length; _i++) {
-        rest[_i - 4] = arguments[_i];
-    }
-    var values = assignUniqueKeysToFormatXMLElementFnArgument(rawValues);
-    var chunks = coreFormatMessage.apply(void 0, __spreadArray([config,
-        formatters,
-        descriptor,
-        values], rest, false));
-    if (Array.isArray(chunks)) {
-        return toKeyedReactNodeArray(chunks);
-    }
-    return chunks;
-};
-/**
- * Create intl object
- * @param config intl config
- * @param cache cache for formatter instances to prevent memory leak
- */
-export var createIntl = function (_a, cache) {
-    var rawDefaultRichTextElements = _a.defaultRichTextElements, config = __rest(_a, ["defaultRichTextElements"]);
-    var defaultRichTextElements = assignUniqueKeysToFormatXMLElementFnArgument(rawDefaultRichTextElements);
-    var coreIntl = coreCreateIntl(__assign(__assign(__assign({}, DEFAULT_INTL_CONFIG), config), { defaultRichTextElements: defaultRichTextElements }), cache);
-    var resolvedConfig = {
-        locale: coreIntl.locale,
-        timeZone: coreIntl.timeZone,
-        fallbackOnEmptyString: coreIntl.fallbackOnEmptyString,
-        formats: coreIntl.formats,
-        defaultLocale: coreIntl.defaultLocale,
-        defaultFormats: coreIntl.defaultFormats,
-        messages: coreIntl.messages,
-        onError: coreIntl.onError,
-        defaultRichTextElements: defaultRichTextElements,
-    };
-    return __assign(__assign({}, coreIntl), { formatMessage: formatMessage.bind(null, resolvedConfig, coreIntl.formatters), $t: formatMessage.bind(null, resolvedConfig, coreIntl.formatters) });
-};

package/lib/src/components/dateTimeRange.d.ts

@@ -1,9 +0,0 @@
-import { FormatDateTimeRangeOptions } from '@formatjs/intl';
-import * as React from 'react';
-interface Props extends FormatDateTimeRangeOptions {
-    from: Parameters<Intl.DateTimeFormat['formatRange']>[0];
-    to: Parameters<Intl.DateTimeFormat['formatRange']>[1];
-    children?(value: React.ReactNode): React.ReactElement | null;
-}
-declare const FormattedDateTimeRange: React.FC<Props>;
-export default FormattedDateTimeRange;

package/lib/src/components/dateTimeRange.js

@@ -1,15 +0,0 @@
-import { __rest } from "tslib";
-import * as React from 'react';
-import useIntl from './useIntl';
-var FormattedDateTimeRange = function (props) {
-    var intl = useIntl();
-    var from = props.from, to = props.to, children = props.children, formatProps = __rest(props, ["from", "to", "children"]);
-    var formattedValue = intl.formatDateTimeRange(from, to, formatProps);
-    if (typeof children === 'function') {
-        return children(formattedValue);
-    }
-    var Text = intl.textComponent || React.Fragment;
-    return React.createElement(Text, null, formattedValue);
-};
-FormattedDateTimeRange.displayName = 'FormattedDateTimeRange';
-export default FormattedDateTimeRange;

package/lib/src/components/injectIntl.d.ts

@@ -1,39 +0,0 @@
-import * as React from 'react';
-import { IntlShape } from '../types';
-declare global {
-    interface Window {
-        /**
-         * Set this to `true` prior to mounting to bypass using a globally-exposed context.
-         */
-        __REACT_INTL_BYPASS_GLOBAL_CONTEXT__: boolean | undefined;
-        __REACT_INTL_CONTEXT__: React.Context<IntlShape> | undefined;
-    }
-}
-export declare const Provider: React.Provider<IntlShape>;
-export declare const Context: React.Context<IntlShape>;
-export interface Opts<IntlPropName extends string = 'intl', ForwardRef extends boolean = false> {
-    intlPropName?: IntlPropName;
-    forwardRef?: ForwardRef;
-    enforceContext?: boolean;
-}
-export type WrappedComponentProps<IntlPropName extends string = 'intl'> = {
-    [k in IntlPropName]: IntlShape;
-};
-/**
- * Utility type to help deal with the fact that `Omit` doesn't play well with unions:
- * - https://github.com/microsoft/TypeScript/issues/31501
- * - https://github.com/microsoft/TypeScript/issues/28339
- *
- * @example
- *      DistributedOmit<X | Y, K>  -->  Omit<X, K> | Omit<Y, K>
- */
-export type DistributedOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
-export type WithIntlProps<P> = DistributedOmit<P, keyof WrappedComponentProps> & {
-    forwardedRef?: React.Ref<any>;
-};
-export default function injectIntl<IntlPropName extends string = 'intl', P extends WrappedComponentProps<IntlPropName> = WrappedComponentProps<any>>(WrappedComponent: React.ComponentType<P>, options?: Opts<IntlPropName, false>): React.FC<WithIntlProps<P>> & {
-    WrappedComponent: React.ComponentType<P>;
-};
-export default function injectIntl<IntlPropName extends string = 'intl', P extends WrappedComponentProps<IntlPropName> = WrappedComponentProps<any>, T extends React.ComponentType<P> = any>(WrappedComponent: React.ComponentType<P>, options?: Opts<IntlPropName, true>): React.ForwardRefExoticComponent<React.PropsWithoutRef<WithIntlProps<React.PropsWithChildren<P>>> & React.RefAttributes<T>> & {
-    WrappedComponent: React.ComponentType<P>;
-};

package/lib/src/components/injectIntl.js

@@ -1,35 +0,0 @@
-import { __assign } from "tslib";
-import hoistNonReactStatics from 'hoist-non-react-statics';
-import * as React from 'react';
-import { invariantIntlContext } from '../utils';
-function getDisplayName(Component) {
-    return Component.displayName || Component.name || 'Component';
-}
-// This is primarily dealing with packaging systems where multiple copies of react-intl
-// might exist
-var IntlContext = typeof window !== 'undefined' && !window.__REACT_INTL_BYPASS_GLOBAL_CONTEXT__
-    ? window.__REACT_INTL_CONTEXT__ ||
-        (window.__REACT_INTL_CONTEXT__ = React.createContext(null))
-    : React.createContext(null);
-var IntlConsumer = IntlContext.Consumer, IntlProvider = IntlContext.Provider;
-export var Provider = IntlProvider;
-export var Context = IntlContext;
-export default function injectIntl(WrappedComponent, options) {
-    var _a = options || {}, _b = _a.intlPropName, intlPropName = _b === void 0 ? 'intl' : _b, _c = _a.forwardRef, forwardRef = _c === void 0 ? false : _c, _d = _a.enforceContext, enforceContext = _d === void 0 ? true : _d;
-    var WithIntl = function (props) { return (React.createElement(IntlConsumer, null, function (intl) {
-        var _a;
-        if (enforceContext) {
-            invariantIntlContext(intl);
-        }
-        var intlProp = (_a = {}, _a[intlPropName] = intl, _a);
-        return (React.createElement(WrappedComponent, __assign({}, props, intlProp, { ref: forwardRef ? props.forwardedRef : null })));
-    })); };
-    WithIntl.displayName = "injectIntl(".concat(getDisplayName(WrappedComponent), ")");
-    WithIntl.WrappedComponent = WrappedComponent;
-    if (forwardRef) {
-        return hoistNonReactStatics(
-        // @ts-expect-error
-        React.forwardRef(function (props, ref) { return (React.createElement(WithIntl, __assign({}, props, { forwardedRef: ref }))); }), WrappedComponent);
-    }
-    return hoistNonReactStatics(WithIntl, WrappedComponent);
-}

package/lib/src/components/message.d.ts

@@ -1,11 +0,0 @@
-import type { FormatXMLElementFn, Options as IntlMessageFormatOptions, PrimitiveType } from 'intl-messageformat';
-import * as React from 'react';
-import { MessageDescriptor } from '@formatjs/intl';
-export interface Props<V extends Record<string, any> = Record<string, React.ReactNode | PrimitiveType | FormatXMLElementFn<React.ReactNode>>> extends MessageDescriptor {
-    values?: V;
-    tagName?: React.ElementType<any>;
-    children?(nodes: React.ReactNode[]): React.ReactNode | null;
-    ignoreTag?: IntlMessageFormatOptions['ignoreTag'];
-}
-declare const MemoizedFormattedMessage: React.ComponentType<Props>;
-export default MemoizedFormattedMessage;

package/lib/src/components/message.js

@@ -1,35 +0,0 @@
-/*
- * Copyright 2015, Yahoo Inc.
- * Copyrights licensed under the New BSD License.
- * See the accompanying LICENSE file for terms.
- */
-import { __rest } from "tslib";
-import * as React from 'react';
-import { shallowEqual } from '../utils';
-import useIntl from './useIntl';
-function areEqual(prevProps, nextProps) {
-    var values = prevProps.values, otherProps = __rest(prevProps, ["values"]);
-    var nextValues = nextProps.values, nextOtherProps = __rest(nextProps, ["values"]);
-    return (shallowEqual(nextValues, values) &&
-        shallowEqual(otherProps, nextOtherProps));
-}
-function FormattedMessage(props) {
-    var intl = useIntl();
-    var formatMessage = intl.formatMessage, _a = intl.textComponent, Text = _a === void 0 ? React.Fragment : _a;
-    var id = props.id, description = props.description, defaultMessage = props.defaultMessage, values = props.values, children = props.children, _b = props.tagName, Component = _b === void 0 ? Text : _b, ignoreTag = props.ignoreTag;
-    var descriptor = { id: id, description: description, defaultMessage: defaultMessage };
-    var nodes = formatMessage(descriptor, values, {
-        ignoreTag: ignoreTag,
-    });
-    if (typeof children === 'function') {
-        return children(Array.isArray(nodes) ? nodes : [nodes]);
-    }
-    if (Component) {
-        return React.createElement(Component, null, nodes);
-    }
-    return React.createElement(React.Fragment, null, nodes);
-}
-FormattedMessage.displayName = 'FormattedMessage';
-var MemoizedFormattedMessage = React.memo(FormattedMessage, areEqual);
-MemoizedFormattedMessage.displayName = 'MemoizedFormattedMessage';
-export default MemoizedFormattedMessage;

package/lib/src/components/plural.d.ts

@@ -1,14 +0,0 @@
-import * as React from 'react';
-import { FormatPluralOptions } from '@formatjs/intl';
-interface Props extends FormatPluralOptions {
-    value: number;
-    other: React.ReactNode;
-    zero?: React.ReactNode;
-    one?: React.ReactNode;
-    two?: React.ReactNode;
-    few?: React.ReactNode;
-    many?: React.ReactNode;
-    children?(value: React.ReactNode): React.ReactElement | null;
-}
-declare const FormattedPlural: React.FC<Props>;
-export default FormattedPlural;

package/lib/src/components/plural.js

@@ -1,23 +0,0 @@
-/*
- * Copyright 2015, Yahoo Inc.
- * Copyrights licensed under the New BSD License.
- * See the accompanying LICENSE file for terms.
- */
-import * as React from 'react';
-import useIntl from './useIntl';
-var FormattedPlural = function (props) {
-    var _a = useIntl(), formatPlural = _a.formatPlural, Text = _a.textComponent;
-    var value = props.value, other = props.other, children = props.children;
-    var pluralCategory = formatPlural(value, props);
-    var formattedPlural = props[pluralCategory] || other;
-    if (typeof children === 'function') {
-        return children(formattedPlural);
-    }
-    if (Text) {
-        return React.createElement(Text, null, formattedPlural);
-    }
-    // Work around @types/react where React.FC cannot return string
-    return formattedPlural;
-};
-FormattedPlural.displayName = 'FormattedPlural';
-export default FormattedPlural;

package/lib/src/components/provider.d.ts

@@ -1,29 +0,0 @@
-import { IntlCache } from '@formatjs/intl';
-import * as React from 'react';
-import type { IntlConfig, IntlShape } from '../types';
-import { DefaultIntlConfig } from '../utils';
-interface State {
-    /**
-     * Explicit intl cache to prevent memory leaks
-     */
-    cache: IntlCache;
-    /**
-     * Intl object we created
-     */
-    intl?: IntlShape;
-    /**
-     * list of memoized config we care about.
-     * This is important since creating intl is
-     * very expensive
-     */
-    prevConfig: IntlConfig;
-}
-export default class IntlProvider extends React.PureComponent<React.PropsWithChildren<IntlConfig>, State> {
-    static displayName: string;
-    static defaultProps: DefaultIntlConfig;
-    private cache;
-    state: State;
-    static getDerivedStateFromProps(props: Readonly<IntlConfig>, { prevConfig, cache }: State): Partial<State> | null;
-    render(): React.JSX.Element;
-}
-export {};

package/lib/src/components/provider.js

@@ -1,59 +0,0 @@
-/*
- * Copyright 2015, Yahoo Inc.
- * Copyrights licensed under the New BSD License.
- * See the accompanying LICENSE file for terms.
- */
-import { __extends } from "tslib";
-import { createIntlCache } from '@formatjs/intl';
-import * as React from 'react';
-import { DEFAULT_INTL_CONFIG, invariantIntlContext, shallowEqual, } from '../utils';
-import { createIntl } from './createIntl';
-import { Provider } from './injectIntl';
-function processIntlConfig(config) {
-    return {
-        locale: config.locale,
-        timeZone: config.timeZone,
-        fallbackOnEmptyString: config.fallbackOnEmptyString,
-        formats: config.formats,
-        textComponent: config.textComponent,
-        messages: config.messages,
-        defaultLocale: config.defaultLocale,
-        defaultFormats: config.defaultFormats,
-        onError: config.onError,
-        onWarn: config.onWarn,
-        wrapRichTextChunksInFragment: config.wrapRichTextChunksInFragment,
-        defaultRichTextElements: config.defaultRichTextElements,
-    };
-}
-var IntlProvider = /** @class */ (function (_super) {
-    __extends(IntlProvider, _super);
-    function IntlProvider() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.cache = createIntlCache();
-        _this.state = {
-            cache: _this.cache,
-            intl: createIntl(processIntlConfig(_this.props), _this.cache),
-            prevConfig: processIntlConfig(_this.props),
-        };
-        return _this;
-    }
-    IntlProvider.getDerivedStateFromProps = function (props, _a) {
-        var prevConfig = _a.prevConfig, cache = _a.cache;
-        var config = processIntlConfig(props);
-        if (!shallowEqual(prevConfig, config)) {
-            return {
-                intl: createIntl(config, cache),
-                prevConfig: config,
-            };
-        }
-        return null;
-    };
-    IntlProvider.prototype.render = function () {
-        invariantIntlContext(this.state.intl);
-        return React.createElement(Provider, { value: this.state.intl }, this.props.children);
-    };
-    IntlProvider.displayName = 'IntlProvider';
-    IntlProvider.defaultProps = DEFAULT_INTL_CONFIG;
-    return IntlProvider;
-}(React.PureComponent));
-export default IntlProvider;

package/lib/src/components/relative.d.ts

@@ -1,10 +0,0 @@
-import * as React from 'react';
-import { FormatRelativeTimeOptions } from '@formatjs/intl';
-export interface Props extends FormatRelativeTimeOptions {
-    value?: number;
-    unit?: Intl.RelativeTimeFormatUnit;
-    updateIntervalInSeconds?: number;
-    children?(value: string): React.ReactElement | null;
-}
-declare const FormattedRelativeTime: React.FC<Props>;
-export default FormattedRelativeTime;

package/lib/src/components/relative.js

@@ -1,125 +0,0 @@
-import { __assign, __rest } from "tslib";
-/*
- * Copyright 2015, Yahoo Inc.
- * Copyrights licensed under the New BSD License.
- * See the accompanying LICENSE file for terms.
- */
-import * as React from 'react';
-import { invariant } from '../utils';
-import useIntl from './useIntl';
-var MINUTE = 60;
-var HOUR = 60 * 60;
-var DAY = 60 * 60 * 24;
-function selectUnit(seconds) {
-    var absValue = Math.abs(seconds);
-    if (absValue < MINUTE) {
-        return 'second';
-    }
-    if (absValue < HOUR) {
-        return 'minute';
-    }
-    if (absValue < DAY) {
-        return 'hour';
-    }
-    return 'day';
-}
-function getDurationInSeconds(unit) {
-    switch (unit) {
-        case 'second':
-            return 1;
-        case 'minute':
-            return MINUTE;
-        case 'hour':
-            return HOUR;
-        default:
-            return DAY;
-    }
-}
-function valueToSeconds(value, unit) {
-    if (!value) {
-        return 0;
-    }
-    switch (unit) {
-        case 'second':
-            return value;
-        case 'minute':
-            return value * MINUTE;
-        default:
-            return value * HOUR;
-    }
-}
-var INCREMENTABLE_UNITS = [
-    'second',
-    'minute',
-    'hour',
-];
-function canIncrement(unit) {
-    if (unit === void 0) { unit = 'second'; }
-    return INCREMENTABLE_UNITS.indexOf(unit) > -1;
-}
-var SimpleFormattedRelativeTime = function (props) {
-    var _a = useIntl(), formatRelativeTime = _a.formatRelativeTime, Text = _a.textComponent;
-    var children = props.children, value = props.value, unit = props.unit, otherProps = __rest(props, ["children", "value", "unit"]);
-    var formattedRelativeTime = formatRelativeTime(value || 0, unit, otherProps);
-    if (typeof children === 'function') {
-        return children(formattedRelativeTime);
-    }
-    if (Text) {
-        return React.createElement(Text, null, formattedRelativeTime);
-    }
-    return React.createElement(React.Fragment, null, formattedRelativeTime);
-};
-var FormattedRelativeTime = function (_a) {
-    var _b = _a.value, value = _b === void 0 ? 0 : _b, _c = _a.unit, unit = _c === void 0 ? 'second' : _c, updateIntervalInSeconds = _a.updateIntervalInSeconds, otherProps = __rest(_a, ["value", "unit", "updateIntervalInSeconds"]);
-    invariant(!updateIntervalInSeconds ||
-        !!(updateIntervalInSeconds && canIncrement(unit)), 'Cannot schedule update with unit longer than hour');
-    var _d = React.useState(), prevUnit = _d[0], setPrevUnit = _d[1];
-    var _e = React.useState(0), prevValue = _e[0], setPrevValue = _e[1];
-    var _f = React.useState(0), currentValueInSeconds = _f[0], setCurrentValueInSeconds = _f[1];
-    var updateTimer;
-    if (unit !== prevUnit || value !== prevValue) {
-        setPrevValue(value || 0);
-        setPrevUnit(unit);
-        setCurrentValueInSeconds(canIncrement(unit) ? valueToSeconds(value, unit) : 0);
-    }
-    React.useEffect(function () {
-        function clearUpdateTimer() {
-            clearTimeout(updateTimer);
-        }
-        clearUpdateTimer();
-        // If there's no interval and we cannot increment this unit, do nothing
-        if (!updateIntervalInSeconds || !canIncrement(unit)) {
-            return clearUpdateTimer;
-        }
-        // Figure out the next interesting time
-        var nextValueInSeconds = currentValueInSeconds - updateIntervalInSeconds;
-        var nextUnit = selectUnit(nextValueInSeconds);
-        // We've reached the max auto incrementable unit, don't schedule another update
-        if (nextUnit === 'day') {
-            return clearUpdateTimer;
-        }
-        var unitDuration = getDurationInSeconds(nextUnit);
-        var remainder = nextValueInSeconds % unitDuration;
-        var prevInterestingValueInSeconds = nextValueInSeconds - remainder;
-        var nextInterestingValueInSeconds = prevInterestingValueInSeconds >= currentValueInSeconds
-            ? prevInterestingValueInSeconds - unitDuration
-            : prevInterestingValueInSeconds;
-        var delayInSeconds = Math.abs(nextInterestingValueInSeconds - currentValueInSeconds);
-        if (currentValueInSeconds !== nextInterestingValueInSeconds) {
-            updateTimer = setTimeout(function () { return setCurrentValueInSeconds(nextInterestingValueInSeconds); }, delayInSeconds * 1e3);
-        }
-        return clearUpdateTimer;
-    }, [currentValueInSeconds, updateIntervalInSeconds, unit]);
-    var currentValue = value || 0;
-    var currentUnit = unit;
-    if (canIncrement(unit) &&
-        typeof currentValueInSeconds === 'number' &&
-        updateIntervalInSeconds) {
-        currentUnit = selectUnit(currentValueInSeconds);
-        var unitDuration = getDurationInSeconds(currentUnit);
-        currentValue = Math.round(currentValueInSeconds / unitDuration);
-    }
-    return (React.createElement(SimpleFormattedRelativeTime, __assign({ value: currentValue, unit: currentUnit }, otherProps)));
-};
-FormattedRelativeTime.displayName = 'FormattedRelativeTime';
-export default FormattedRelativeTime;

package/lib/src/components/useIntl.d.ts

@@ -1,2 +0,0 @@
-import { IntlShape } from '../types';
-export default function useIntl(this: void): IntlShape;

package/lib/src/components/useIntl.js

@@ -1,8 +0,0 @@
-import * as React from 'react';
-import { invariantIntlContext } from '../utils';
-import { Context } from './injectIntl';
-export default function useIntl() {
-    var intl = React.useContext(Context);
-    invariantIntlContext(intl);
-    return intl;
-}

package/lib/src/types.d.ts

@@ -1,14 +0,0 @@
-import { ResolvedIntlConfig as CoreResolvedIntlConfig, Formatters, IntlFormatters, MessageDescriptor } from '@formatjs/intl';
-import { FormatXMLElementFn, Options as IntlMessageFormatOptions, PrimitiveType } from 'intl-messageformat';
-import * as React from 'react';
-import { DEFAULT_INTL_CONFIG } from './utils';
-export type IntlConfig = Omit<ResolvedIntlConfig, keyof typeof DEFAULT_INTL_CONFIG> & Partial<typeof DEFAULT_INTL_CONFIG>;
-export interface ResolvedIntlConfig extends CoreResolvedIntlConfig<React.ReactNode> {
-    textComponent?: React.ComponentType | keyof React.JSX.IntrinsicElements;
-    wrapRichTextChunksInFragment?: boolean;
-}
-export interface IntlShape extends ResolvedIntlConfig, IntlFormatters<React.ReactNode> {
-    formatMessage(this: void, descriptor: MessageDescriptor, values?: Record<string, PrimitiveType | FormatXMLElementFn<string, string>>, opts?: IntlMessageFormatOptions): string;
-    formatMessage(this: void, descriptor: MessageDescriptor, values?: Record<string, React.ReactNode | PrimitiveType | FormatXMLElementFn<string, React.ReactNode>>, opts?: IntlMessageFormatOptions): Array<React.ReactNode>;
-    formatters: Formatters;
-}

package/lib/src/types.js

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