use-intl 2.22.1 → 2.22.2

package/src/core/createTranslatorImpl.tsx

@@ -1,87 +0,0 @@
-import AbstractIntlMessages from './AbstractIntlMessages';
-import {InitializedIntlConfig} from './IntlConfig';
-import IntlError, {IntlErrorCode} from './IntlError';
-import {RichTranslationValues, TranslationValue} from './TranslationValues';
-import createBaseTranslator, {getMessagesOrError} from './createBaseTranslator';
-import resolveNamespace from './resolveNamespace';
-import NestedKeyOf from './utils/NestedKeyOf';
-
-export type CoreRichTranslationValues = Record<
-  string,
-  TranslationValue | ((chunks: string) => string)
->;
-
-export type CreateTranslatorImplProps<Messages> = Omit<
-  InitializedIntlConfig,
-  'messages'
-> & {
-  namespace: string;
-  messages: Messages;
-};
-
-export default function createTranslatorImpl<
-  Messages extends AbstractIntlMessages,
-  NestedKey extends NestedKeyOf<Messages>
->(
-  {
-    getMessageFallback,
-    messages,
-    namespace,
-    onError,
-    ...rest
-  }: CreateTranslatorImplProps<Messages>,
-  namespacePrefix: string
-) {
-  // The `namespacePrefix` is part of the type system.
-  // See the comment in the function invocation.
-  messages = messages[namespacePrefix] as Messages;
-  namespace = resolveNamespace(namespace, namespacePrefix) as NestedKey;
-
-  const translator = createBaseTranslator<Messages, NestedKey>({
-    ...rest,
-    onError,
-    getMessageFallback,
-    messagesOrError: getMessagesOrError({
-      messages,
-      namespace,
-      onError
-    }) as Messages | IntlError
-  });
-
-  const originalRich = translator.rich;
-
-  function base(...args: Parameters<typeof translator>) {
-    return translator(...args);
-  }
-
-  // Augment `t.rich` to return plain strings
-  base.rich = (
-    key: Parameters<typeof originalRich>[0],
-    /** Key value pairs for values to interpolate into the message. */
-    values: CoreRichTranslationValues,
-    formats?: Parameters<typeof originalRich>[2]
-  ): string => {
-    // `chunks` is returned as a string when no React element
-    // is used, therefore it's safe to cast this type.
-    const result = originalRich(key, values as RichTranslationValues, formats);
-
-    // When only string chunks are provided to the parser, only strings should be returned here.
-    if (typeof result !== 'string') {
-      const error = new IntlError(
-        IntlErrorCode.FORMATTING_ERROR,
-        process.env.NODE_ENV !== 'production'
-          ? "`createTranslator` only accepts functions for rich text formatting that receive and return strings.\n\nE.g. t.rich('rich', {b: (chunks) => `<b>${chunks}</b>`})"
-          : undefined
-      );
-
-      onError(error);
-      return getMessageFallback({error, key, namespace});
-    }
-
-    return result;
-  };
-
-  base.raw = translator.raw;
-
-  return base;
-}

package/src/core/defaults.tsx

@@ -1,18 +0,0 @@
-import IntlError from './IntlError';
-
-/**
- * Contains defaults that are used for all entry points into the core.
- * See also `InitializedIntlConfiguration`.
- */
-
-export function defaultGetMessageFallback(props: {
-  error: IntlError;
-  key: string;
-  namespace?: string;
-}) {
-  return [props.namespace, props.key].filter((part) => part != null).join('.');
-}
-
-export function defaultOnError(error: IntlError) {
-  console.error(error);
-}

package/src/core/index.tsx

@@ -1,14 +0,0 @@
-export type {default as AbstractIntlMessages} from './AbstractIntlMessages';
-export type {
-  default as TranslationValues,
-  RichTranslationValues
-} from './TranslationValues';
-export type {default as Formats} from './Formats';
-export type {default as DateTimeFormatOptions} from './DateTimeFormatOptions';
-export type {default as NumberFormatOptions} from './NumberFormatOptions';
-export {default as IntlError, IntlErrorCode} from './IntlError';
-export {default as createTranslator} from './createTranslator';
-export {default as createFormatter} from './createFormatter';
-
-// TODO: Remove in next major version
-export {default as createIntl} from './createIntl';

package/src/core/resolveNamespace.tsx

@@ -1,12 +0,0 @@
-/**
- * For the strictly typed messages to work we have to wrap the namespace into
- * a mandatory prefix. See https://stackoverflow.com/a/71529575/343045
- */
-export default function resolveNamespace(
-  namespace: string,
-  namespacePrefix: string
-) {
-  return namespace === namespacePrefix
-    ? undefined
-    : namespace.slice((namespacePrefix + '.').length);
-}

package/src/core/utils/MessageKeys.tsx

@@ -1,9 +0,0 @@
-import NestedValueOf from './NestedValueOf';
-
-type MessageKeys<ObjectType, Keys extends string> = {
-  [Property in Keys]: NestedValueOf<ObjectType, Property> extends string
-    ? Property
-    : never;
-}[Keys];
-
-export default MessageKeys;

package/src/core/utils/NamespaceKeys.tsx

@@ -1,9 +0,0 @@
-import NestedValueOf from './NestedValueOf';
-
-type NamespaceKeys<ObjectType, Keys extends string> = {
-  [Property in Keys]: NestedValueOf<ObjectType, Property> extends string
-    ? never
-    : Property;
-}[Keys];
-
-export default NamespaceKeys;

package/src/core/utils/NestedKeyOf.tsx

@@ -1,9 +0,0 @@
-type NestedKeyOf<ObjectType> = ObjectType extends object
-  ? {
-      [Key in keyof ObjectType]:
-        | `${Key & string}`
-        | `${Key & string}.${NestedKeyOf<ObjectType[Key]>}`;
-    }[keyof ObjectType]
-  : never;
-
-export default NestedKeyOf;

package/src/core/utils/NestedValueOf.tsx

@@ -1,12 +0,0 @@
-type NestedValueOf<
-  ObjectType,
-  Property extends string
-> = Property extends `${infer Key}.${infer Rest}`
-  ? Key extends keyof ObjectType
-    ? NestedValueOf<ObjectType[Key], Rest>
-    : never
-  : Property extends keyof ObjectType
-  ? ObjectType[Property]
-  : never;
-
-export default NestedValueOf;

package/src/core/validateMessages.tsx

@@ -1,77 +0,0 @@
-import AbstractIntlMessages from './AbstractIntlMessages';
-import IntlError, {IntlErrorCode} from './IntlError';
-
-function validateMessagesSegment(
-  messages: AbstractIntlMessages,
-  invalidKeyLabels: Array<string>,
-  parentPath?: string
-) {
-  Object.entries(messages).forEach(([key, messageOrMessages]) => {
-    if (key.includes('.')) {
-      let keyLabel = key;
-      if (parentPath) keyLabel += ` (at ${parentPath})`;
-      invalidKeyLabels.push(keyLabel);
-    }
-
-    if (messageOrMessages != null && typeof messageOrMessages === 'object') {
-      validateMessagesSegment(
-        messageOrMessages,
-        invalidKeyLabels,
-        [parentPath, key].filter((part) => part != null).join('.')
-      );
-    }
-  });
-}
-
-export default function validateMessages(
-  messages: AbstractIntlMessages,
-  onError: (error: IntlError) => void
-) {
-  const invalidKeyLabels: Array<string> = [];
-  validateMessagesSegment(messages, invalidKeyLabels);
-
-  if (invalidKeyLabels.length > 0) {
-    onError(
-      new IntlError(
-        IntlErrorCode.INVALID_KEY,
-        process.env.NODE_ENV !== 'production'
-          ? `Namespace keys can not contain the character "." as this is used to express nesting. Please remove it or replace it with another character.
-
-Invalid ${
-              invalidKeyLabels.length === 1 ? 'key' : 'keys'
-            }: ${invalidKeyLabels.join(', ')}
-
-If you're migrating from a flat structure, you can convert your messages as follows:
-
-import {set} from "lodash";
-
-const input = {
-  "one.one": "1.1",
-  "one.two": "1.2",
-  "two.one.one": "2.1.1"
-};
-
-const output = Object.entries(input).reduce(
-  (acc, [key, value]) => set(acc, key, value),
-  {}
-);
-
-// Output:
-//
-// {
-//   "one": {
-//     "one": "1.1",
-//     "two": "1.2"
-//   },
-//   "two": {
-//     "one": {
-//       "one": "2.1.1"
-//     }
-//   }
-// }
-`
-          : undefined
-      )
-    );
-  }
-}

package/src/index.tsx

@@ -1,2 +0,0 @@
-export * from './core';
-export * from './react';

package/src/react/IntlContext.tsx

@@ -1,12 +0,0 @@
-import {createContext} from 'react';
-import {InitializedIntlConfig} from '../core/IntlConfig';
-import MessageFormatCache from '../core/MessageFormatCache';
-
-const IntlContext = createContext<
-  | (InitializedIntlConfig & {
-      messageFormatCache?: MessageFormatCache;
-    })
-  | undefined
->(undefined);
-
-export default IntlContext;

package/src/react/IntlProvider.tsx

@@ -1,23 +0,0 @@
-import React, {ReactNode, useState} from 'react';
-import IntlConfig from '../core/IntlConfig';
-import IntlContext from './IntlContext';
-import getInitializedConfig from './getInitializedConfig';
-
-type Props = IntlConfig & {
-  children: ReactNode;
-};
-
-export default function IntlProvider({children, ...props}: Props) {
-  const [messageFormatCache] = useState(() => new Map());
-
-  return (
-    <IntlContext.Provider
-      value={{
-        ...getInitializedConfig(props),
-        messageFormatCache
-      }}
-    >
-      {children}
-    </IntlContext.Provider>
-  );
-}

package/src/react/getInitializedConfig.tsx

@@ -1,29 +0,0 @@
-import IntlConfig from '../core/IntlConfig';
-import {defaultGetMessageFallback, defaultOnError} from '../core/defaults';
-import validateMessages from '../core/validateMessages';
-
-/**
- * Enhances the incoming props with defaults.
- */
-export default function getInitializedConfig<
-  // This is a generic to allow for stricter typing. E.g.
-  // the RSC integration always provides a `now` value.
-  Props extends Omit<IntlConfig, 'children'>
->({getMessageFallback, messages, onError, ...rest}: Props) {
-  const finalOnError = onError || defaultOnError;
-  const finalGetMessageFallback =
-    getMessageFallback || defaultGetMessageFallback;
-
-  if (process.env.NODE_ENV !== 'production') {
-    if (messages) {
-      validateMessages(messages, finalOnError);
-    }
-  }
-
-  return {
-    ...rest,
-    messages,
-    onError: finalOnError,
-    getMessageFallback: finalGetMessageFallback
-  };
-}

package/src/react/index.tsx

@@ -1,10 +0,0 @@
-export {default as IntlProvider} from './IntlProvider';
-export {default as useTranslations} from './useTranslations';
-export {default as useLocale} from './useLocale';
-export {default as useNow} from './useNow';
-export {default as useTimeZone} from './useTimeZone';
-export {default as useMessages} from './useMessages';
-export {default as useFormatter} from './useFormatter';
-
-// TODO: Remove in next major version
-export {default as useIntl} from './useIntl';

package/src/react/useFormatter.tsx

@@ -1,19 +0,0 @@
-import {useMemo} from 'react';
-import createFormatter from '../core/createFormatter';
-import useIntlContext from './useIntlContext';
-
-export default function useFormatter() {
-  const {formats, locale, now: globalNow, onError, timeZone} = useIntlContext();
-
-  return useMemo(
-    () =>
-      createFormatter({
-        formats,
-        locale,
-        now: globalNow,
-        onError,
-        timeZone
-      }),
-    [formats, globalNow, locale, onError, timeZone]
-  );
-}

package/src/react/useIntl.tsx

@@ -1,29 +0,0 @@
-import {useMemo} from 'react';
-import createIntl from '../core/createIntl';
-import useIntlContext from './useIntlContext';
-
-let hasWarned = false;
-
-/** @deprecated Switch to `useFormatter` instead. */
-export default function useIntl() {
-  const {formats, locale, now: globalNow, onError, timeZone} = useIntlContext();
-
-  if (!hasWarned) {
-    hasWarned = true;
-    console.warn(
-      '`useIntl()` is deprecated and will be removed in the next major version. Please switch to `useFormatter()`.'
-    );
-  }
-
-  return useMemo(
-    () =>
-      createIntl({
-        formats,
-        locale,
-        now: globalNow,
-        onError,
-        timeZone
-      }),
-    [formats, globalNow, locale, onError, timeZone]
-  );
-}

package/src/react/useIntlContext.tsx

@@ -1,16 +0,0 @@
-import {useContext} from 'react';
-import IntlContext from './IntlContext';
-
-export default function useIntlContext() {
-  const context = useContext(IntlContext);
-
-  if (!context) {
-    throw new Error(
-      process.env.NODE_ENV !== 'production'
-        ? 'No intl context found. Have you configured the provider?'
-        : undefined
-    );
-  }
-
-  return context;
-}

package/src/react/useLocale.tsx

@@ -1,5 +0,0 @@
-import useIntlContext from './useIntlContext';
-
-export default function useLocale() {
-  return useIntlContext().locale;
-}

package/src/react/useMessages.tsx

@@ -1,5 +0,0 @@
-import useIntlContext from './useIntlContext';
-
-export default function useMessages() {
-  return useIntlContext().messages;
-}

package/src/react/useNow.tsx

@@ -1,49 +0,0 @@
-import {useState, useEffect} from 'react';
-import useIntlContext from './useIntlContext';
-
-type Options = {
-  updateInterval?: number;
-};
-
-function getNow() {
-  return new Date();
-}
-
-/**
- * Reading the current date via `new Date()` in components should be avoided, as
- * it causes components to be impure and can lead to flaky tests. Instead, this
- * hook can be used.
- *
- * By default, it returns the time when the component mounts. If `updateInterval`
- * is specified, the value will be updated based on the interval.
- *
- * You can however also return a static value from this hook, if you
- * configure the `now` parameter on the context provider. Note however,
- * that if `updateInterval` is configured in this case, the component
- * will initialize with the global value, but will afterwards update
- * continuously based on the interval.
- *
- * For unit tests, this can be mocked to a constant value. For end-to-end
- * testing, an environment parameter can be passed to the `now` parameter
- * of the provider to mock this to a static value.
- */
-export default function useNow(options?: Options) {
-  const updateInterval = options?.updateInterval;
-
-  const {now: globalNow} = useIntlContext();
-  const [now, setNow] = useState(globalNow || getNow());
-
-  useEffect(() => {
-    if (!updateInterval) return;
-
-    const intervalId = setInterval(() => {
-      setNow(getNow());
-    }, updateInterval);
-
-    return () => {
-      clearInterval(intervalId);
-    };
-  }, [globalNow, updateInterval]);
-
-  return now;
-}

package/src/react/useTimeZone.tsx

@@ -1,5 +0,0 @@
-import useIntlContext from './useIntlContext';
-
-export default function useTimeZone() {
-  return useIntlContext().timeZone;
-}

package/src/react/useTranslations.tsx

@@ -1,103 +0,0 @@
-import {ReactElement, ReactNodeArray} from 'react';
-import Formats from '../core/Formats';
-import TranslationValues, {
-  RichTranslationValues
-} from '../core/TranslationValues';
-import MessageKeys from '../core/utils/MessageKeys';
-import NamespaceKeys from '../core/utils/NamespaceKeys';
-import NestedKeyOf from '../core/utils/NestedKeyOf';
-import NestedValueOf from '../core/utils/NestedValueOf';
-import useIntlContext from './useIntlContext';
-import useTranslationsImpl from './useTranslationsImpl';
-
-/**
- * Translates messages from the given namespace by using the ICU syntax.
- * See https://formatjs.io/docs/core-concepts/icu-syntax.
- *
- * If no namespace is provided, all available messages are returned.
- * The namespace can also indicate nesting by using a dot
- * (e.g. `namespace.Component`).
- */
-export default function useTranslations<
-  NestedKey extends NamespaceKeys<
-    IntlMessages,
-    NestedKeyOf<IntlMessages>
-  > = never
->(
-  namespace?: NestedKey
-): // Explicitly defining the return type is necessary as TypeScript would get it wrong
-{
-  // Default invocation
-  <
-    TargetKey extends MessageKeys<
-      NestedValueOf<
-        {'!': IntlMessages},
-        [NestedKey] extends [never] ? '!' : `!.${NestedKey}`
-      >,
-      NestedKeyOf<
-        NestedValueOf<
-          {'!': IntlMessages},
-          [NestedKey] extends [never] ? '!' : `!.${NestedKey}`
-        >
-      >
-    >
-  >(
-    key: TargetKey,
-    values?: TranslationValues,
-    formats?: Partial<Formats>
-  ): string;
-
-  // `rich`
-  rich<
-    TargetKey extends MessageKeys<
-      NestedValueOf<
-        {'!': IntlMessages},
-        [NestedKey] extends [never] ? '!' : `!.${NestedKey}`
-      >,
-      NestedKeyOf<
-        NestedValueOf<
-          {'!': IntlMessages},
-          [NestedKey] extends [never] ? '!' : `!.${NestedKey}`
-        >
-      >
-    >
-  >(
-    key: TargetKey,
-    values?: RichTranslationValues,
-    formats?: Partial<Formats>
-  ): string | ReactElement | ReactNodeArray;
-
-  // `raw`
-  raw<
-    TargetKey extends MessageKeys<
-      NestedValueOf<
-        {'!': IntlMessages},
-        [NestedKey] extends [never] ? '!' : `!.${NestedKey}`
-      >,
-      NestedKeyOf<
-        NestedValueOf<
-          {'!': IntlMessages},
-          [NestedKey] extends [never] ? '!' : `!.${NestedKey}`
-        >
-      >
-    >
-  >(
-    key: TargetKey
-  ): any;
-} {
-  const context = useIntlContext();
-  const messages = context.messages as IntlMessages;
-
-  // We have to wrap the actual hook so the type inference for the optional
-  // namespace works correctly. See https://stackoverflow.com/a/71529575/343045
-  // The prefix ("!") is arbitrary.
-  return useTranslationsImpl<
-    {'!': IntlMessages},
-    [NestedKey] extends [never] ? '!' : `!.${NestedKey}`
-  >(
-    {'!': messages},
-    // @ts-expect-error
-    namespace ? `!.${namespace}` : '!',
-    '!'
-  );
-}

package/src/react/useTranslationsImpl.tsx

@@ -1,61 +0,0 @@
-import {useMemo} from 'react';
-import AbstractIntlMessages from '../core/AbstractIntlMessages';
-import createBaseTranslator, {
-  getMessagesOrError
-} from '../core/createBaseTranslator';
-import resolveNamespace from '../core/resolveNamespace';
-import NestedKeyOf from '../core/utils/NestedKeyOf';
-import useIntlContext from './useIntlContext';
-
-export default function useTranslationsImpl<
-  Messages extends AbstractIntlMessages,
-  NestedKey extends NestedKeyOf<Messages>
->(allMessages: Messages, namespace: NestedKey, namespacePrefix: string) {
-  const {
-    defaultTranslationValues,
-    formats: globalFormats,
-    getMessageFallback,
-    locale,
-    messageFormatCache,
-    onError,
-    timeZone
-  } = useIntlContext();
-
-  // The `namespacePrefix` is part of the type system.
-  // See the comment in the hook invocation.
-  allMessages = allMessages[namespacePrefix] as Messages;
-  namespace = resolveNamespace(namespace, namespacePrefix) as NestedKey;
-
-  const messagesOrError = useMemo(
-    () => getMessagesOrError({messages: allMessages, namespace, onError}),
-    [allMessages, namespace, onError]
-  );
-
-  const translate = useMemo(
-    () =>
-      createBaseTranslator({
-        messageFormatCache,
-        getMessageFallback,
-        messagesOrError,
-        defaultTranslationValues,
-        namespace,
-        onError,
-        formats: globalFormats,
-        locale,
-        timeZone
-      }),
-    [
-      messageFormatCache,
-      getMessageFallback,
-      messagesOrError,
-      defaultTranslationValues,
-      namespace,
-      onError,
-      globalFormats,
-      locale,
-      timeZone
-    ]
-  );
-
-  return translate;
-}