react-intl 10.1.0 → 10.1.2

package/server.d.ts

@@ -1,10 +1,34 @@
-import { type MessageDescriptor } from "@formatjs/intl";
-export { createIntlCache, type IntlCache, type MessageDescriptor } from "@formatjs/intl";
-export { createIntl } from "./src/components/createIntl.js";
-export type { IntlConfig, IntlShape, ResolvedIntlConfig } from "./src/types.js";
-export declare function defineMessages<
-	K extends keyof any,
-	T = MessageDescriptor,
-	U extends Record<K, T> = Record<K, T>
->(msgs: U): U;
-export declare function defineMessage<T extends MessageDescriptor>(msg: T): T;
+import { CreateIntlFn, Formatters, IntlCache, IntlFormatters, MessageDescriptor, MessageDescriptor as MessageDescriptor$1, ResolvedIntlConfig as ResolvedIntlConfig$1, createIntlCache } from "@formatjs/intl";
+import { FormatXMLElementFn, Options, PrimitiveType } from "intl-messageformat";
+import * as React from "react";
+
+//#region packages/react-intl/utils.d.ts
+type DefaultIntlConfig = Pick<ResolvedIntlConfig, "fallbackOnEmptyString" | "formats" | "messages" | "timeZone" | "textComponent" | "defaultLocale" | "defaultFormats" | "onError">;
+declare const DEFAULT_INTL_CONFIG$1: DefaultIntlConfig;
+//#endregion
+//#region packages/react-intl/types.d.ts
+type IntlConfig = Omit<ResolvedIntlConfig, keyof typeof DEFAULT_INTL_CONFIG$1> & Partial<typeof DEFAULT_INTL_CONFIG$1>;
+interface ResolvedIntlConfig extends ResolvedIntlConfig$1<React.ReactNode> {
+  textComponent?: React.ComponentType | keyof React.JSX.IntrinsicElements;
+  wrapRichTextChunksInFragment?: boolean;
+}
+interface IntlShape extends ResolvedIntlConfig, IntlFormatters<React.ReactNode> {
+  formatMessage(this: void, descriptor: MessageDescriptor$1, values?: Record<string, PrimitiveType | FormatXMLElementFn<string, string>>, opts?: Options): string;
+  formatMessage(this: void, descriptor: MessageDescriptor$1, values?: Record<string, React.ReactNode | PrimitiveType | FormatXMLElementFn<string, React.ReactNode>>, opts?: Options): Array<React.ReactNode>;
+  formatters: Formatters;
+}
+//#endregion
+//#region packages/react-intl/components/createIntl.d.ts
+/**
+* Create intl object
+* @param config intl config
+* @param cache cache for formatter instances to prevent memory leak
+*/
+declare const createIntl: CreateIntlFn<React.ReactNode, IntlConfig, IntlShape>;
+//#endregion
+//#region packages/react-intl/server.d.ts
+declare function defineMessages<K extends keyof any, T = MessageDescriptor$1, U extends Record<K, T> = Record<K, T>>(msgs: U): U;
+declare function defineMessage<T extends MessageDescriptor$1>(msg: T): T;
+//#endregion
+export { type IntlCache, type IntlConfig, type IntlShape, type MessageDescriptor, type ResolvedIntlConfig, createIntl, createIntlCache, defineMessage, defineMessages };
+//# sourceMappingURL=server.d.ts.map

package/server.js

@@ -1,10 +1,92 @@
-import "@formatjs/intl";
-export { createIntlCache } from "@formatjs/intl";
-export { createIntl } from "./src/components/createIntl.js";
-// Identity functions — duplicated here to avoid importing from "use client" index
-export function defineMessages(msgs) {
+import { DEFAULT_INTL_CONFIG, createIntl as createIntl$1, createIntlCache, formatMessage } from "@formatjs/intl";
+import { isFormatXMLElementFn } from "intl-messageformat";
+import * as React from "react";
+import { jsx } from "react/jsx-runtime";
+//#region packages/react-intl/utils.tsx
+const DEFAULT_INTL_CONFIG$1 = {
+	...DEFAULT_INTL_CONFIG,
+	textComponent: React.Fragment
+};
+/**
+* Builds an array of {@link React.ReactNode}s with index-based keys, similar to
+* {@link React.Children.toArray}. However, this function tells React that it
+* was intentional, so they won't produce a bunch of warnings about it.
+*
+* React doesn't recommend doing this because it makes reordering inefficient,
+* but we mostly need this for message chunks, which don't tend to reorder to
+* begin with.
+*
+*/
+const toKeyedReactNodeArray = (children) => {
+	return React.Children.toArray(children).map((child, index) => {
+		if (React.isValidElement(child)) return /* @__PURE__ */ jsx(React.Fragment, { children: child }, index);
+		return child;
+	});
+};
+/**
+* Takes a `formatXMLElementFn`, and composes it in function, which passes
+* argument `parts` through, assigning unique key to each part, to prevent
+* "Each child in a list should have a unique "key"" React error.
+* @param formatXMLElementFn
+*/
+function assignUniqueKeysToParts(formatXMLElementFn) {
+	return function(parts) {
+		return formatXMLElementFn(toKeyedReactNodeArray(parts));
+	};
+}
+//#endregion
+//#region packages/react-intl/components/createIntl.ts
+function assignUniqueKeysToFormatXMLElementFnArgument(values) {
+	if (!values) return values;
+	return Object.keys(values).reduce((acc, k) => {
+		const v = values[k];
+		acc[k] = isFormatXMLElementFn(v) ? assignUniqueKeysToParts(v) : v;
+		return acc;
+	}, {});
+}
+const formatMessage$1 = (config, formatters, descriptor, rawValues, ...rest) => {
+	const chunks = formatMessage(config, formatters, descriptor, assignUniqueKeysToFormatXMLElementFnArgument(rawValues), ...rest);
+	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
+*/
+const createIntl = ({ defaultRichTextElements: rawDefaultRichTextElements, ...config }, cache) => {
+	const defaultRichTextElements = assignUniqueKeysToFormatXMLElementFnArgument(rawDefaultRichTextElements);
+	const coreIntl = createIntl$1({
+		...DEFAULT_INTL_CONFIG$1,
+		...config,
+		defaultRichTextElements
+	}, cache);
+	const 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
+	};
+	return {
+		...coreIntl,
+		formatMessage: formatMessage$1.bind(null, resolvedConfig, coreIntl.formatters),
+		$t: formatMessage$1.bind(null, resolvedConfig, coreIntl.formatters)
+	};
+};
+//#endregion
+//#region packages/react-intl/server.ts
+function defineMessages(msgs) {
 	return msgs;
 }
-export function defineMessage(msg) {
+function defineMessage(msg) {
 	return msg;
 }
+//#endregion
+export { createIntl, createIntlCache, defineMessage, defineMessages };
+
+//# sourceMappingURL=server.js.map

package/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","names":["DEFAULT_INTL_CONFIG","CORE_DEFAULT_INTL_CONFIG","formatMessage","coreFormatMessage","coreCreateIntl","DEFAULT_INTL_CONFIG"],"sources":["../utils.tsx","../components/createIntl.ts","../server.ts"],"sourcesContent":["import {type FormatXMLElementFn} from 'intl-messageformat'\nimport * as React from 'react'\nimport {type ResolvedIntlConfig} from '#packages/react-intl/types.js'\n\nimport {DEFAULT_INTL_CONFIG as CORE_DEFAULT_INTL_CONFIG} from '@formatjs/intl'\n\nexport function invariant(\n  condition: boolean,\n  message: string,\n  Err: any = Error\n): asserts condition {\n  if (!condition) {\n    throw new Err(message)\n  }\n}\n\nexport function invariantIntlContext(intl?: any): asserts intl {\n  invariant(\n    intl,\n    '[React Intl] Could not find required `intl` object. ' +\n      '<IntlProvider> needs to exist in the component ancestry.'\n  )\n}\n\nexport type DefaultIntlConfig = Pick<\n  ResolvedIntlConfig,\n  | 'fallbackOnEmptyString'\n  | 'formats'\n  | 'messages'\n  | 'timeZone'\n  | 'textComponent'\n  | 'defaultLocale'\n  | 'defaultFormats'\n  | 'onError'\n>\n\nexport const DEFAULT_INTL_CONFIG: DefaultIntlConfig = {\n  ...CORE_DEFAULT_INTL_CONFIG,\n  textComponent: React.Fragment,\n}\n\n/**\n * Builds an array of {@link React.ReactNode}s with index-based keys, similar to\n * {@link React.Children.toArray}. However, this function tells React that it\n * was intentional, so they won't produce a bunch of warnings about it.\n *\n * React doesn't recommend doing this because it makes reordering inefficient,\n * but we mostly need this for message chunks, which don't tend to reorder to\n * begin with.\n *\n */\nexport const toKeyedReactNodeArray: typeof React.Children.toArray =\n  children => {\n    const childrenArray = React.Children.toArray(children)\n\n    return childrenArray.map((child, index) => {\n      // For React elements, wrap in a keyed Fragment\n      // This creates a new element with a key rather than trying to add one after creation\n      if (React.isValidElement(child)) {\n        return <React.Fragment key={index}>{child}</React.Fragment>\n      }\n      return child\n    })\n  }\n\n/**\n * Takes a `formatXMLElementFn`, and composes it in function, which passes\n * argument `parts` through, assigning unique key to each part, to prevent\n * \"Each child in a list should have a unique \"key\"\" React error.\n * @param formatXMLElementFn\n */\nexport function assignUniqueKeysToParts(\n  formatXMLElementFn: FormatXMLElementFn<React.ReactNode>\n): FormatXMLElementFn<React.ReactNode> {\n  return function (parts: any) {\n    // eslint-disable-next-line prefer-rest-params\n    return formatXMLElementFn(toKeyedReactNodeArray(parts)) as any\n  }\n}\n\nexport function shallowEqual<\n  T extends Record<string, unknown> = Record<string, unknown>,\n>(objA?: T, objB?: T): boolean {\n  if (objA === objB) {\n    return true\n  }\n\n  if (!objA || !objB) {\n    return false\n  }\n\n  var aKeys = Object.keys(objA)\n  var bKeys = Object.keys(objB)\n  var len = aKeys.length\n\n  if (bKeys.length !== len) {\n    return false\n  }\n\n  for (var i = 0; i < len; i++) {\n    var key = aKeys[i]\n\n    if (\n      objA[key] !== objB[key] ||\n      !Object.prototype.hasOwnProperty.call(objB, key)\n    ) {\n      return false\n    }\n  }\n\n  return true\n}\n","/*\n * Copyright 2015, Yahoo Inc.\n * Copyrights licensed under the New BSD License.\n * See the accompanying LICENSE file for terms.\n */\n\nimport {\n  type CreateIntlFn,\n  type FormatMessageFn,\n  createIntl as coreCreateIntl,\n  formatMessage as coreFormatMessage,\n} from '@formatjs/intl'\nimport {\n  type FormatXMLElementFn,\n  type PrimitiveType,\n  isFormatXMLElementFn,\n} from 'intl-messageformat'\nimport * as React from 'react'\nimport type {\n  IntlConfig,\n  IntlShape,\n  ResolvedIntlConfig,\n} from '#packages/react-intl/types.js'\nimport {\n  DEFAULT_INTL_CONFIG,\n  assignUniqueKeysToParts,\n  toKeyedReactNodeArray,\n} from '#packages/react-intl/utils.js'\n\nfunction assignUniqueKeysToFormatXMLElementFnArgument<\n  T extends Record<\n    string,\n    | PrimitiveType\n    | React.ReactNode\n    | FormatXMLElementFn<React.ReactNode, React.ReactNode>\n  > = Record<\n    string,\n    | PrimitiveType\n    | React.ReactNode\n    | FormatXMLElementFn<React.ReactNode, React.ReactNode>\n  >,\n>(values?: T): T | undefined {\n  if (!values) {\n    return values\n  }\n  return Object.keys(values).reduce((acc: T, k) => {\n    const v = values[k]\n    ;(acc as any)[k] = isFormatXMLElementFn<React.ReactNode>(v)\n      ? assignUniqueKeysToParts(v)\n      : v\n    return acc\n  }, {} as T)\n}\n\nconst formatMessage: FormatMessageFn<React.ReactNode> = (\n  config,\n  formatters,\n  descriptor,\n  rawValues,\n  ...rest\n) => {\n  const values = assignUniqueKeysToFormatXMLElementFnArgument(rawValues)\n  const chunks = coreFormatMessage(\n    config,\n    formatters,\n    descriptor,\n    values as any,\n    ...rest\n  )\n  if (Array.isArray(chunks)) {\n    return toKeyedReactNodeArray(chunks)\n  }\n  return chunks\n}\n\n/**\n * Create intl object\n * @param config intl config\n * @param cache cache for formatter instances to prevent memory leak\n */\nexport const createIntl: CreateIntlFn<\n  React.ReactNode,\n  IntlConfig,\n  IntlShape\n> = (\n  {defaultRichTextElements: rawDefaultRichTextElements, ...config},\n  cache\n) => {\n  const defaultRichTextElements = assignUniqueKeysToFormatXMLElementFnArgument(\n    rawDefaultRichTextElements\n  )\n  const coreIntl = coreCreateIntl<React.ReactNode>(\n    {\n      ...DEFAULT_INTL_CONFIG,\n      ...config,\n      defaultRichTextElements,\n    },\n    cache\n  )\n\n  const resolvedConfig: ResolvedIntlConfig = {\n    locale: coreIntl.locale,\n    timeZone: coreIntl.timeZone,\n    fallbackOnEmptyString: coreIntl.fallbackOnEmptyString,\n    formats: coreIntl.formats,\n    defaultLocale: coreIntl.defaultLocale,\n    defaultFormats: coreIntl.defaultFormats,\n    messages: coreIntl.messages,\n    onError: coreIntl.onError,\n    defaultRichTextElements,\n  }\n\n  return {\n    ...coreIntl,\n    formatMessage: formatMessage.bind(\n      null,\n      resolvedConfig,\n      coreIntl.formatters\n    ),\n    $t: formatMessage.bind(null, resolvedConfig, coreIntl.formatters),\n  } as any\n}\n","import {type MessageDescriptor} from '@formatjs/intl'\n\nexport {\n  createIntlCache,\n  type IntlCache,\n  type MessageDescriptor,\n} from '@formatjs/intl'\nexport {createIntl} from '#packages/react-intl/components/createIntl.js'\nexport type {\n  IntlConfig,\n  IntlShape,\n  ResolvedIntlConfig,\n} from '#packages/react-intl/types.js'\n\n// Identity functions — duplicated here to avoid importing from \"use client\" index\nexport function defineMessages<\n  K extends keyof any,\n  T = MessageDescriptor,\n  U extends Record<K, T> = Record<K, T>,\n>(msgs: U): U {\n  return msgs\n}\n\nexport function defineMessage<T extends MessageDescriptor>(msg: T): T {\n  return msg\n}\n"],"mappings":";;;;;AAoCA,MAAaA,wBAAyC;CACpD,GAAGC;CACH,eAAe,MAAM;CACtB;;;;;;;;;;;AAYD,MAAa,yBACX,aAAY;AAGV,QAFsB,MAAM,SAAS,QAAQ,SAAS,CAEjC,KAAK,OAAO,UAAU;AAGzC,MAAI,MAAM,eAAe,MAAM,CAC7B,QAAO,oBAAC,MAAM,UAAP,EAAA,UAA6B,OAAuB,EAA/B,MAA+B;AAE7D,SAAO;GACP;;;;;;;;AASN,SAAgB,wBACd,oBACqC;AACrC,QAAO,SAAU,OAAY;AAE3B,SAAO,mBAAmB,sBAAsB,MAAM,CAAC;;;;;AC/C3D,SAAS,6CAYP,QAA2B;AAC3B,KAAI,CAAC,OACH,QAAO;AAET,QAAO,OAAO,KAAK,OAAO,CAAC,QAAQ,KAAQ,MAAM;EAC/C,MAAM,IAAI,OAAO;AACf,MAAY,KAAK,qBAAsC,EAAE,GACvD,wBAAwB,EAAE,GAC1B;AACJ,SAAO;IACN,EAAE,CAAM;;AAGb,MAAMC,mBACJ,QACA,YACA,YACA,WACA,GAAG,SACA;CAEH,MAAM,SAASC,cACb,QACA,YACA,YAJa,6CAA6C,UAAU,EAMpE,GAAG,KACJ;AACD,KAAI,MAAM,QAAQ,OAAO,CACvB,QAAO,sBAAsB,OAAO;AAEtC,QAAO;;;;;;;AAQT,MAAa,cAKX,EAAC,yBAAyB,4BAA4B,GAAG,UACzD,UACG;CACH,MAAM,0BAA0B,6CAC9B,2BACD;CACD,MAAM,WAAWC,aACf;EACE,GAAGC;EACH,GAAG;EACH;EACD,EACD,MACD;CAED,MAAM,iBAAqC;EACzC,QAAQ,SAAS;EACjB,UAAU,SAAS;EACnB,uBAAuB,SAAS;EAChC,SAAS,SAAS;EAClB,eAAe,SAAS;EACxB,gBAAgB,SAAS;EACzB,UAAU,SAAS;EACnB,SAAS,SAAS;EAClB;EACD;AAED,QAAO;EACL,GAAG;EACH,eAAeH,gBAAc,KAC3B,MACA,gBACA,SAAS,WACV;EACD,IAAIA,gBAAc,KAAK,MAAM,gBAAgB,SAAS,WAAW;EAClE;;;;ACzGH,SAAgB,eAId,MAAY;AACZ,QAAO;;AAGT,SAAgB,cAA2C,KAAW;AACpE,QAAO"}

package/src/components/context.d.ts

@@ -1,5 +0,0 @@
-import * as React from "react";
-import { type IntlShape } from "../types.js";
-declare const IntlContext: React.Context<IntlShape>;
-declare const Provider: React.Provider<IntlShape>;
-export { Provider, IntlContext as Context };

package/src/components/context.js

@@ -1,5 +0,0 @@
-import * as React from "react";
-import "../types.js";
-const IntlContext = React.createContext(null);
-const Provider = IntlContext.Provider;
-export { Provider, IntlContext as Context };

package/src/components/createFormattedComponent.d.ts

@@ -1,27 +0,0 @@
-import { type FormatDateOptions, type FormatDisplayNameOptions, type FormatListOptions, type FormatNumberOptions } from "@formatjs/intl";
-import * as React from "react";
-import { type IntlShape } from "../types.js";
-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/src/components/createFormattedComponent.js

@@ -1,60 +0,0 @@
-import "@formatjs/intl";
-import * as React from "react";
-import "../types.js";
-import useIntl from "./useIntl.js";
-import { jsx as _jsx } from "react/jsx-runtime";
-var DisplayName = /* @__PURE__ */ 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";
-	return DisplayName;
-}(DisplayName || {});
-var DisplayNameParts = /* @__PURE__ */ function(DisplayNameParts) {
-	DisplayNameParts["formatDate"] = "FormattedDateParts";
-	DisplayNameParts["formatTime"] = "FormattedTimeParts";
-	DisplayNameParts["formatNumber"] = "FormattedNumberParts";
-	DisplayNameParts["formatList"] = "FormattedListParts";
-	return DisplayNameParts;
-}(DisplayNameParts || {});
-export const FormattedNumberParts = (props) => {
-	const intl = useIntl();
-	const { value, children, ...formatProps } = props;
-	return children(intl.formatNumberToParts(value, formatProps));
-};
-FormattedNumberParts.displayName = "FormattedNumberParts";
-export const FormattedListParts = (props) => {
-	const intl = useIntl();
-	const { value, children, ...formatProps } = props;
-	return children(intl.formatListToParts(value, formatProps));
-};
-FormattedNumberParts.displayName = "FormattedNumberParts";
-export function createFormattedDateTimePartsComponent(name) {
-	const ComponentParts = (props) => {
-		const intl = useIntl();
-		const { value, children, ...formatProps } = props;
-		const date = typeof value === "string" ? new Date(value || 0) : value;
-		const formattedParts = name === "formatDate" ? intl.formatDateToParts(date, formatProps) : intl.formatTimeToParts(date, formatProps);
-		return children(formattedParts);
-	};
-	ComponentParts.displayName = DisplayNameParts[name];
-	return ComponentParts;
-}
-export function createFormattedComponent(name) {
-	const Component = (props) => {
-		const intl = useIntl();
-		const { value, children, ...formatProps } = props;
-		// TODO: fix TS type definition for localeMatcher upstream
-		const formattedValue = intl[name](value, formatProps);
-		if (typeof children === "function") {
-			return children(formattedValue);
-		}
-		const Text = intl.textComponent || React.Fragment;
-		return /* @__PURE__ */ _jsx(Text, { children: formattedValue });
-	};
-	Component.displayName = DisplayName[name];
-	return Component;
-}

package/src/components/createIntl.d.ts

@@ -1,9 +0,0 @@
-import { type CreateIntlFn } from "@formatjs/intl";
-import * as React from "react";
-import type { IntlConfig, IntlShape } from "../types.js";
-/**
-* 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/src/components/createIntl.js

@@ -1,56 +0,0 @@
-/*
-* Copyright 2015, Yahoo Inc.
-* Copyrights licensed under the New BSD License.
-* See the accompanying LICENSE file for terms.
-*/
-import { createIntl as coreCreateIntl, formatMessage as coreFormatMessage } from "@formatjs/intl";
-import { isFormatXMLElementFn } from "intl-messageformat";
-import * as React from "react";
-import { DEFAULT_INTL_CONFIG, assignUniqueKeysToParts, toKeyedReactNodeArray } from "../utils.js";
-function assignUniqueKeysToFormatXMLElementFnArgument(values) {
-	if (!values) {
-		return values;
-	}
-	return Object.keys(values).reduce((acc, k) => {
-		const v = values[k];
-		acc[k] = isFormatXMLElementFn(v) ? assignUniqueKeysToParts(v) : v;
-		return acc;
-	}, {});
-}
-const formatMessage = (config, formatters, descriptor, rawValues, ...rest) => {
-	const values = assignUniqueKeysToFormatXMLElementFnArgument(rawValues);
-	const chunks = coreFormatMessage(config, formatters, descriptor, values, ...rest);
-	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 const createIntl = ({ defaultRichTextElements: rawDefaultRichTextElements, ...config }, cache) => {
-	const defaultRichTextElements = assignUniqueKeysToFormatXMLElementFnArgument(rawDefaultRichTextElements);
-	const coreIntl = coreCreateIntl({
-		...DEFAULT_INTL_CONFIG,
-		...config,
-		defaultRichTextElements
-	}, cache);
-	const 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
-	};
-	return {
-		...coreIntl,
-		formatMessage: formatMessage.bind(null, resolvedConfig, coreIntl.formatters),
-		$t: formatMessage.bind(null, resolvedConfig, coreIntl.formatters)
-	};
-};

package/src/components/dateTimeRange.d.ts

@@ -1,9 +0,0 @@
-import { type 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/src/components/dateTimeRange.js

@@ -1,16 +0,0 @@
-import "@formatjs/intl";
-import * as React from "react";
-import useIntl from "./useIntl.js";
-import { jsx as _jsx } from "react/jsx-runtime";
-const FormattedDateTimeRange = (props) => {
-	const intl = useIntl();
-	const { from, to, children, ...formatProps } = props;
-	const formattedValue = intl.formatDateTimeRange(from, to, formatProps);
-	if (typeof children === "function") {
-		return children(formattedValue);
-	}
-	const Text = intl.textComponent || React.Fragment;
-	return /* @__PURE__ */ _jsx(Text, { children: formattedValue });
-};
-FormattedDateTimeRange.displayName = "FormattedDateTimeRange";
-export default FormattedDateTimeRange;

package/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 { type 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/src/components/message.js

@@ -1,32 +0,0 @@
-import * as React from "react";
-import "@formatjs/intl";
-import { shallowEqual } from "../utils.js";
-import useIntl from "./useIntl.js";
-import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
-function areEqual(prevProps, nextProps) {
-	const { values, ...otherProps } = prevProps;
-	const { values: nextValues, ...nextOtherProps } = nextProps;
-	return shallowEqual(nextValues, values) && shallowEqual(otherProps, nextOtherProps);
-}
-function FormattedMessage(props) {
-	const intl = useIntl();
-	const { formatMessage, textComponent: Text = React.Fragment } = intl;
-	const { id, description, defaultMessage, values, children, tagName: Component = Text, ignoreTag } = props;
-	const descriptor = {
-		id,
-		description,
-		defaultMessage
-	};
-	const nodes = formatMessage(descriptor, values, { ignoreTag });
-	if (typeof children === "function") {
-		return children(Array.isArray(nodes) ? nodes : [nodes]);
-	}
-	if (Component) {
-		return /* @__PURE__ */ _jsx(Component, { children: nodes });
-	}
-	return /* @__PURE__ */ _jsx(_Fragment, { children: nodes });
-}
-FormattedMessage.displayName = "FormattedMessage";
-const MemoizedFormattedMessage = React.memo(FormattedMessage, areEqual);
-MemoizedFormattedMessage.displayName = "MemoizedFormattedMessage";
-export default MemoizedFormattedMessage;

package/src/components/plural.d.ts

@@ -1,14 +0,0 @@
-import * as React from "react";
-import { type 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/src/components/plural.js

@@ -1,25 +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 "@formatjs/intl";
-import useIntl from "./useIntl.js";
-import { jsx as _jsx } from "react/jsx-runtime";
-const FormattedPlural = (props) => {
-	const { formatPlural, textComponent: Text } = useIntl();
-	const { value, other, children } = props;
-	const pluralCategory = formatPlural(value, props);
-	const formattedPlural = props[pluralCategory] || other;
-	if (typeof children === "function") {
-		return children(formattedPlural);
-	}
-	if (Text) {
-		return /* @__PURE__ */ _jsx(Text, { children: formattedPlural });
-	}
-	// Work around @types/react where React.FC cannot return string
-	return formattedPlural;
-};
-FormattedPlural.displayName = "FormattedPlural";
-export default FormattedPlural;

package/src/components/provider.d.ts

@@ -1,4 +0,0 @@
-import * as React from "react";
-import type { IntlConfig } from "../types.js";
-declare const IntlProvider: React.FC<React.PropsWithChildren<IntlConfig>>;
-export default IntlProvider;

package/src/components/provider.js

@@ -1,57 +0,0 @@
-/*
-* Copyright 2015, Yahoo Inc.
-* Copyrights licensed under the New BSD License.
-* See the accompanying LICENSE file for terms.
-*/
-import { createIntlCache } from "@formatjs/intl";
-import * as React from "react";
-import { DEFAULT_INTL_CONFIG, invariantIntlContext, shallowEqual } from "../utils.js";
-import { createIntl } from "./createIntl.js";
-import { Provider } from "./context.js";
-import { jsx as _jsx } from "react/jsx-runtime";
-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
-	};
-}
-function IntlProviderImpl(props) {
-	const cacheRef = React.useRef(createIntlCache());
-	const prevConfigRef = React.useRef(undefined);
-	const intlRef = React.useRef(undefined);
-	// Filter out undefined values from props so they don't override defaults.
-	// React's defaultProps treated `prop={undefined}` as "not provided"; we
-	// replicate that behaviour here after converting to a function component.
-	const filteredProps = {};
-	for (const key in props) {
-		if (props[key] !== undefined) {
-			filteredProps[key] = props[key];
-		}
-	}
-	const config = processIntlConfig({
-		...DEFAULT_INTL_CONFIG,
-		...filteredProps
-	});
-	if (!prevConfigRef.current || !shallowEqual(prevConfigRef.current, config)) {
-		prevConfigRef.current = config;
-		intlRef.current = createIntl(config, cacheRef.current);
-	}
-	invariantIntlContext(intlRef.current);
-	return /* @__PURE__ */ _jsx(Provider, {
-		value: intlRef.current,
-		children: props.children
-	});
-}
-IntlProviderImpl.displayName = "IntlProvider";
-const IntlProvider = IntlProviderImpl;
-export default IntlProvider;

package/src/components/relative.d.ts

@@ -1,10 +0,0 @@
-import * as React from "react";
-import { type 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/src/components/relative.js

@@ -1,120 +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 "@formatjs/intl";
-import { invariant } from "../utils.js";
-import useIntl from "./useIntl.js";
-import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
-const MINUTE = 60;
-const HOUR = 60 * 60;
-const DAY = 60 * 60 * 24;
-function selectUnit(seconds) {
-	const 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;
-	}
-}
-const INCREMENTABLE_UNITS = [
-	"second",
-	"minute",
-	"hour"
-];
-function canIncrement(unit = "second") {
-	return INCREMENTABLE_UNITS.indexOf(unit) > -1;
-}
-const SimpleFormattedRelativeTime = (props) => {
-	const { formatRelativeTime, textComponent: Text } = useIntl();
-	const { children, value, unit, ...otherProps } = props;
-	const formattedRelativeTime = formatRelativeTime(value || 0, unit, otherProps);
-	if (typeof children === "function") {
-		return children(formattedRelativeTime);
-	}
-	if (Text) {
-		return /* @__PURE__ */ _jsx(Text, { children: formattedRelativeTime });
-	}
-	return /* @__PURE__ */ _jsx(_Fragment, { children: formattedRelativeTime });
-};
-const FormattedRelativeTime = ({ value = 0, unit = "second", updateIntervalInSeconds, ...otherProps }) => {
-	invariant(!updateIntervalInSeconds || !!(updateIntervalInSeconds && canIncrement(unit)), "Cannot schedule update with unit longer than hour");
-	const [prevUnit, setPrevUnit] = React.useState();
-	const [prevValue, setPrevValue] = React.useState(0);
-	const [currentValueInSeconds, setCurrentValueInSeconds] = React.useState(0);
-	const updateTimer = React.useRef(undefined);
-	if (unit !== prevUnit || value !== prevValue) {
-		setPrevValue(value || 0);
-		setPrevUnit(unit);
-		setCurrentValueInSeconds(canIncrement(unit) ? valueToSeconds(value, unit) : 0);
-	}
-	React.useEffect(() => {
-		function clearUpdateTimer() {
-			clearTimeout(updateTimer.current);
-		}
-		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
-		const nextValueInSeconds = currentValueInSeconds - updateIntervalInSeconds;
-		const nextUnit = selectUnit(nextValueInSeconds);
-		// We've reached the max auto incrementable unit, don't schedule another update
-		if (nextUnit === "day") {
-			return clearUpdateTimer;
-		}
-		const unitDuration = getDurationInSeconds(nextUnit);
-		const remainder = nextValueInSeconds % unitDuration;
-		const prevInterestingValueInSeconds = nextValueInSeconds - remainder;
-		const nextInterestingValueInSeconds = prevInterestingValueInSeconds >= currentValueInSeconds ? prevInterestingValueInSeconds - unitDuration : prevInterestingValueInSeconds;
-		const delayInSeconds = Math.abs(nextInterestingValueInSeconds - currentValueInSeconds);
-		if (currentValueInSeconds !== nextInterestingValueInSeconds) {
-			updateTimer.current = setTimeout(() => setCurrentValueInSeconds(nextInterestingValueInSeconds), delayInSeconds * 1e3);
-		}
-		return clearUpdateTimer;
-	}, [
-		currentValueInSeconds,
-		updateIntervalInSeconds,
-		unit
-	]);
-	let currentValue = value || 0;
-	let currentUnit = unit;
-	if (canIncrement(unit) && typeof currentValueInSeconds === "number" && updateIntervalInSeconds) {
-		currentUnit = selectUnit(currentValueInSeconds);
-		const unitDuration = getDurationInSeconds(currentUnit);
-		currentValue = Math.round(currentValueInSeconds / unitDuration);
-	}
-	return /* @__PURE__ */ _jsx(SimpleFormattedRelativeTime, {
-		value: currentValue,
-		unit: currentUnit,
-		...otherProps
-	});
-};
-FormattedRelativeTime.displayName = "FormattedRelativeTime";
-export default FormattedRelativeTime;

package/src/components/useIntl.d.ts

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