@depup/react-intl 10.1.0-depup.0

package/server.d.ts

@@ -0,0 +1,10 @@
+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;

package/server.js

@@ -0,0 +1,10 @@
+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) {
+	return msgs;
+}
+export function defineMessage(msg) {
+	return msg;
+}

package/src/components/context.d.ts

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,56 @@
+/*
+* 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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,25 @@
+/*
+* 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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,57 @@
+/*
+* 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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,120 @@
+/*
+* 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

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

package/src/components/useIntl.js

@@ -0,0 +1,9 @@
+import * as React from "react";
+import "../types.js";
+import { invariantIntlContext } from "../utils.js";
+import { Context } from "./context.js";
+export default function useIntl() {
+	const intl = React.useContext(Context);
+	invariantIntlContext(intl);
+	return intl;
+}

package/src/types.d.ts

@@ -0,0 +1,14 @@
+import { type ResolvedIntlConfig as CoreResolvedIntlConfig, type Formatters, type IntlFormatters, type MessageDescriptor } from "@formatjs/intl";
+import { type FormatXMLElementFn, type Options as IntlMessageFormatOptions, type PrimitiveType } from "intl-messageformat";
+import * as React from "react";
+import type { DEFAULT_INTL_CONFIG } from "./utils.js";
+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/src/types.js

@@ -0,0 +1,8 @@
+/*
+* Copyright 2015, Yahoo Inc.
+* Copyrights licensed under the New BSD License.
+* See the accompanying LICENSE file for terms.
+*/
+import "@formatjs/intl";
+import "intl-messageformat";
+import * as React from "react";

package/src/utils.d.ts

@@ -0,0 +1,26 @@
+import { type FormatXMLElementFn } from "intl-messageformat";
+import * as React from "react";
+import { type ResolvedIntlConfig } from "./types.js";
+export declare function invariant(condition: boolean, message: string, Err?: any): asserts condition;
+export declare function invariantIntlContext(intl?: any): asserts intl;
+export type DefaultIntlConfig = Pick<ResolvedIntlConfig, "fallbackOnEmptyString" | "formats" | "messages" | "timeZone" | "textComponent" | "defaultLocale" | "defaultFormats" | "onError">;
+export declare const DEFAULT_INTL_CONFIG: DefaultIntlConfig;
+/**
+* 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.
+*
+*/
+export declare const toKeyedReactNodeArray: typeof React.Children.toArray;
+/**
+* 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
+*/
+export declare function assignUniqueKeysToParts(formatXMLElementFn: FormatXMLElementFn<React.ReactNode>): FormatXMLElementFn<React.ReactNode>;
+export declare function shallowEqual<T extends Record<string, unknown> = Record<string, unknown>>(objA?: T, objB?: T): boolean;

package/src/utils.js

@@ -0,0 +1,71 @@
+import "intl-messageformat";
+import * as React from "react";
+import "./types.js";
+import { DEFAULT_INTL_CONFIG as CORE_DEFAULT_INTL_CONFIG } from "@formatjs/intl";
+import { jsx as _jsx } from "react/jsx-runtime";
+export function invariant(condition, message, Err = Error) {
+	if (!condition) {
+		throw new Err(message);
+	}
+}
+export function invariantIntlContext(intl) {
+	invariant(intl, "[React Intl] Could not find required `intl` object. " + "<IntlProvider> needs to exist in the component ancestry.");
+}
+export const DEFAULT_INTL_CONFIG = {
+	...CORE_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.
+*
+*/
+export const toKeyedReactNodeArray = (children) => {
+	const childrenArray = React.Children.toArray(children);
+	return childrenArray.map((child, index) => {
+		// For React elements, wrap in a keyed Fragment
+		// This creates a new element with a key rather than trying to add one after creation
+		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
+*/
+export function assignUniqueKeysToParts(formatXMLElementFn) {
+	return function(parts) {
+		// eslint-disable-next-line prefer-rest-params
+		return formatXMLElementFn(toKeyedReactNodeArray(parts));
+	};
+}
+export function shallowEqual(objA, objB) {
+	if (objA === objB) {
+		return true;
+	}
+	if (!objA || !objB) {
+		return false;
+	}
+	var aKeys = Object.keys(objA);
+	var bKeys = Object.keys(objB);
+	var len = aKeys.length;
+	if (bKeys.length !== len) {
+		return false;
+	}
+	for (var i = 0; i < len; i++) {
+		var key = aKeys[i];
+		if (objA[key] !== objB[key] || !Object.prototype.hasOwnProperty.call(objB, key)) {
+			return false;
+		}
+	}
+	return true;
+}