react-i18next 11.18.5 → 12.0.0

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+### 12.0.0
+
+- Update t function types to rely on types coming from i18next [1501](https://github.com/i18next/react-i18next/pull/1501)
+
+### 11.18.6
+
+- types: nsMode [1554](https://github.com/i18next/react-i18next/issues/1554)
+
 ### 11.18.5
 
 - support unescaping forward slash [1548](https://github.com/i18next/react-i18next/pull/1548)

package/{ts4.1/icu.macro.d.ts → icu.macro.d.ts}

@@ -1,6 +1,6 @@
 import React from 'react';
-import { Namespace, DefaultNamespace, TFuncKey, Trans } from '.';
-import { i18n } from 'i18next';
+import { Trans } from './';
+import { Namespace, DefaultNamespace, TFuncKey, i18n } from 'i18next';
 
 export { Trans };
 

package/index.d.ts

@@ -1,11 +1,18 @@
-import i18next, { ReactOptions, i18n, ThirdPartyModule, WithT, TFunction, Resource } from 'i18next';
+import i18next, {
+  ReactOptions,
+  i18n,
+  ThirdPartyModule,
+  Resource,
+  TFuncKey,
+  Namespace,
+  TypeOptions,
+  TFunction,
+  KeyPrefix,
+} from 'i18next';
 import * as React from 'react';
 
-type Omit<T, K> = Pick<T, Exclude<keyof T, K>>;
 type Subtract<T extends K, K> = Omit<T, keyof K>;
 
-export type Namespace = string | string[];
-
 export function setDefaults(options: ReactOptions): void;
 export function getDefaults(): ReactOptions;
 export function setI18n(instance: i18n): void;
@@ -20,7 +27,7 @@ export function getInitialProps(): {
 };
 
 export interface ReportNamespaces {
-  addUsedNamespaces(namespaces: Namespace[]): void;
+  addUsedNamespaces(namespaces: Namespace): void;
   getUsedNamespaces(): string[];
 }
 
@@ -30,43 +37,76 @@ declare module 'i18next' {
   }
 }
 
-export interface TransProps<E extends Element = HTMLDivElement>
-  extends React.HTMLProps<E>,
-    Partial<WithT> {
-  children?: React.ReactNode;
+type ObjectOrNever = TypeOptions['allowObjectInHTMLChildren'] extends true
+  ? Record<string, unknown>
+  : never;
+type ReactI18NextChild = React.ReactNode | ObjectOrNever;
+
+declare module 'react' {
+  interface HTMLAttributes<T> {
+    children?: ReactI18NextChild | Iterable<ReactI18NextChild>;
+  }
+}
+
+type DefaultNamespace = TypeOptions['defaultNS'];
+
+type TransChild = React.ReactNode | Record<string, unknown>;
+export type TransProps<
+  K extends TFuncKey<N, TKPrefix> extends infer A ? A : never,
+  N extends Namespace = DefaultNamespace,
+  TKPrefix = undefined,
+  E = React.HTMLProps<HTMLDivElement>
+> = E & {
+  children?: TransChild | TransChild[];
   components?: readonly React.ReactElement[] | { readonly [tagName: string]: React.ReactElement };
   count?: number;
   context?: string;
   defaults?: string;
   i18n?: i18n;
-  i18nKey?: string;
-  ns?: Namespace;
+  i18nKey?: K | K[];
+  ns?: N;
   parent?: string | React.ComponentType<any> | null; // used in React.createElement if not null
   tOptions?: {};
   values?: {};
   shouldUnescape?: boolean;
-  t?: TFunction;
-}
-export function Trans<E extends Element = HTMLDivElement>(props: TransProps<E>): React.ReactElement;
+  t?: TFunction<N, TKPrefix>;
+};
+
+export function Trans<
+  K extends TFuncKey<N, TKPrefix> extends infer A ? A : never,
+  N extends Namespace = DefaultNamespace,
+  TKPrefix extends KeyPrefix<N> = undefined,
+  E = React.HTMLProps<HTMLDivElement>
+>(props: TransProps<K, N, TKPrefix, E>): React.ReactElement;
 
 export function useSSR(initialI18nStore: Resource, initialLanguage: string): void;
 
-export interface UseTranslationOptions {
+export interface UseTranslationOptions<TKPrefix = undefined> {
   i18n?: i18n;
   useSuspense?: boolean;
-  keyPrefix?: string;
+  keyPrefix?: TKPrefix;
   bindI18n?: string | false;
+  nsMode?: 'fallback' | 'default';
   // other of these options might also work: https://github.com/i18next/i18next/blob/master/index.d.ts#L127
 }
-export type UseTranslationResponse = [TFunction, i18n, boolean] & {
-  t: TFunction;
+
+export type UseTranslationResponse<N extends Namespace, TKPrefix = undefined> = [
+  TFunction<N, TKPrefix>,
+  i18n,
+  boolean,
+] & {
+  t: TFunction<N, TKPrefix>;
   i18n: i18n;
   ready: boolean;
 };
-export function useTranslation(
-  ns?: Namespace,
-  options?: UseTranslationOptions,
-): UseTranslationResponse;
+
+export function useTranslation<
+  N extends Namespace = DefaultNamespace,
+  TKPrefix extends KeyPrefix<N> = undefined
+>(
+  ns?: N | Readonly<N>,
+  options?: UseTranslationOptions<TKPrefix>,
+): UseTranslationResponse<N, TKPrefix>;
 
 // Need to see usage to improve this
 export function withSSR(): <Props>(
@@ -83,7 +123,11 @@ export function withSSR(): <Props>(
   getInitialProps: (ctx: unknown) => Promise<any>;
 };
 
-export interface WithTranslation extends WithT {
+export interface WithTranslation<
+  N extends Namespace = DefaultNamespace,
+  TKPrefix extends KeyPrefix<N> = undefined
+> {
+  t: TFunction<N, TKPrefix>;
   i18n: i18n;
   tReady: boolean;
 }
@@ -93,20 +137,24 @@ export interface WithTranslationProps {
   useSuspense?: boolean;
 }
 
-export function withTranslation(
-  ns?: Namespace,
+export function withTranslation<
+  N extends Namespace = DefaultNamespace,
+  TKPrefix extends KeyPrefix<N> = undefined
+>(
+  ns?: N,
   options?: {
     withRef?: boolean;
+    keyPrefix?: TKPrefix;
   },
 ): <
-  C extends React.ComponentType<React.ComponentProps<C> & WithTranslationProps>,
+  C extends React.ComponentType<React.ComponentProps<any> & WithTranslationProps>,
   ResolvedProps = JSX.LibraryManagedAttributes<
     C,
     Subtract<React.ComponentProps<C>, WithTranslationProps>
   >
 >(
   component: C,
-) => React.ComponentType<Omit<ResolvedProps, keyof WithTranslation> & WithTranslationProps>;
+) => React.ComponentType<Omit<ResolvedProps, keyof WithTranslation<N>> & WithTranslationProps>;
 
 export interface I18nextProviderProps {
   children?: React.ReactNode;
@@ -117,18 +165,26 @@ export interface I18nextProviderProps {
 export const I18nextProvider: React.FunctionComponent<I18nextProviderProps>;
 export const I18nContext: React.Context<{ i18n: i18n }>;
 
-export interface TranslationProps {
+export interface TranslationProps<
+  N extends Namespace = DefaultNamespace,
+  TKPrefix extends KeyPrefix<N> = undefined
+> {
   children: (
-    t: TFunction,
+    t: TFunction<N, TKPrefix>,
     options: {
       i18n: i18n;
       lng: string;
     },
     ready: boolean,
   ) => React.ReactNode;
-  ns?: Namespace;
+  ns?: N;
   i18n?: i18n;
   useSuspense?: boolean;
+  keyPrefix?: TKPrefix;
+  nsMode?: 'fallback' | 'default';
 }
 
-export function Translation(props: TranslationProps): any;
+export function Translation<
+  N extends Namespace = DefaultNamespace,
+  TKPrefix extends KeyPrefix<N> = undefined
+>(props: TranslationProps<N, TKPrefix>): any;

package/package.json

@@ -1,16 +1,9 @@
 {
   "name": "react-i18next",
-  "version": "11.18.5",
+  "version": "12.0.0",
   "description": "Internationalization for react done right. Using the i18next i18n ecosystem.",
   "main": "dist/commonjs/index.js",
   "types": "./index.d.ts",
-  "typesVersions": {
-    ">=4.1": {
-      "*": [
-        "ts4.1/*"
-      ]
-    }
-  },
   "jsnext:main": "dist/es/index.js",
   "module": "dist/es/index.js",
   "keywords": [
@@ -67,7 +60,7 @@
     "eslint-plugin-react": "^7.16.0",
     "eslint-plugin-testing-library": "^3.10.1",
     "husky": "^3.0.3",
-    "i18next": "^21.0.0",
+    "i18next": "^22.0.1",
     "jest": "^24.8.0",
     "jest-cli": "^24.8.4",
     "lint-staged": "^8.1.3",

package/src/withTranslation.js

@@ -28,6 +28,7 @@ export function withTranslation(ns, options = {}) {
     I18nextWithTranslation.WrappedComponent = WrappedComponent;
 
     const forwardRef = (props, ref) =>
+      // eslint-disable-next-line prefer-object-spread
       createElement(I18nextWithTranslation, Object.assign({}, props, { forwardedRef: ref }));
 
     return options.withRef ? forwardRefReact(forwardRef) : I18nextWithTranslation;

package/ts4.1/index.d.ts

@@ -1,395 +0,0 @@
-import i18next, {
-  ReactOptions,
-  i18n,
-  ThirdPartyModule,
-  Resource,
-  TOptions,
-  StringMap,
-  TFunctionResult,
-} from 'i18next';
-import * as React from 'react';
-
-type Subtract<T extends K, K> = Omit<T, keyof K>;
-
-/**
- * Due to a limitation/bug on typescript 4.1 (https://github.com/microsoft/TypeScript/issues/41406), we added
- * "extends infer A ? A : never" in a few places to suppress the error "Type instantiation is excessively deep and possibly infinite."
- * on cases where users have more than 22 namespaces. Once the issue is fixed, we can remove all instances of the workaround used.
- *
- * Reference of the bug reported: https://github.com/i18next/react-i18next/issues/1222
- */
-
-/**
- * This interface can be augmented by users to add types to `react-i18next` default resources.
- *
- * @deprecated use the `resources` key of `CustomTypeOptions` instead
- */
-export interface Resources {}
-/**
- * This interface can be augmented by users to add types to `react-i18next`. It accepts a `defaultNS`, `resources`, `returnNull` and `returnEmptyString` properties.
- *
- * Usage:
- * ```ts
- * // react-i18next.d.ts
- * import 'react-i18next';
- * declare module 'react-i18next' {
- *   interface CustomTypeOptions {
- *     defaultNS: 'custom';
- *     returnNull: false;
- *     returnEmptyString: false;
- *     nsSeparator: ':';
- *     keySeparator: '.';
- *     jsonFormat: 'v4';
- *     allowObjectInHTMLChildren: false;
- *     resources: {
- *       custom: {
- *         foo: 'foo';
- *       };
- *     };
- *   }
- * }
- * ```
- */
-export interface CustomTypeOptions {}
-
-type MergeBy<T, K> = Omit<T, keyof K> & K;
-
-type TypeOptions = MergeBy<
-  {
-    returnNull: true;
-    returnEmptyString: true;
-    keySeparator: '.';
-    nsSeparator: ':';
-    defaultNS: 'translation';
-    jsonFormat: 'v4';
-    resources: Resources;
-    allowObjectInHTMLChildren: false;
-  },
-  CustomTypeOptions
->;
-
-type DefaultResources = TypeOptions['resources'];
-type DefaultNamespace<T = TypeOptions['defaultNS']> = T extends Fallback<string> ? T : string;
-
-type Fallback<F, T = keyof DefaultResources> = [T] extends [never] ? F : T;
-
-export type Namespace<F = Fallback<string>> = F | F[];
-
-export function setDefaults(options: ReactOptions): void;
-export function getDefaults(): ReactOptions;
-export function setI18n(instance: i18n): void;
-export function getI18n(): i18n;
-export const initReactI18next: ThirdPartyModule;
-export function composeInitialProps(ForComponent: any): (ctx: unknown) => Promise<any>;
-export function getInitialProps(): {
-  initialI18nStore: {
-    [ns: string]: {};
-  };
-  initialLanguage: string;
-};
-
-export interface ReportNamespaces {
-  addUsedNamespaces(namespaces: Namespace[]): void;
-  getUsedNamespaces(): string[];
-}
-
-declare module 'i18next' {
-  interface i18n {
-    reportNamespaces: ReportNamespaces;
-  }
-}
-
-type ObjectOrNever = TypeOptions['allowObjectInHTMLChildren'] extends true
-  ? Record<string, unknown>
-  : never;
-
-type ReactI18NextChild = React.ReactNode | ObjectOrNever;
-
-declare module 'react' {
-  interface HTMLAttributes<T> {
-    children?: ReactI18NextChild | Iterable<ReactI18NextChild>;
-  }
-}
-
-type PluralSuffix = 'zero' | 'one' | 'two' | 'few' | 'many' | 'other';
-
-type WithOrWithoutPlural<K> = TypeOptions['jsonFormat'] extends 'v4'
-  ? K extends `${infer B}_${PluralSuffix}`
-    ? B | K
-    : K
-  : K;
-
-// Normalize single namespace
-export type KeysWithSeparator<K1, K2, S extends string = TypeOptions['keySeparator']> = `${K1 &
-  string}${S}${K2 & string}`;
-type KeysWithSeparator2<K1, K2> = KeysWithSeparator<K1, Exclude<K2, keyof any[]>>;
-type Normalize2<T, K = keyof T> = K extends keyof T
-  ? T[K] extends Record<string, any>
-    ? T[K] extends readonly any[]
-      ?
-          | KeysWithSeparator2<K, WithOrWithoutPlural<keyof T[K]>>
-          | KeysWithSeparator2<K, Normalize2<T[K]>>
-      :
-          | KeysWithSeparator<K, WithOrWithoutPlural<keyof T[K]>>
-          | KeysWithSeparator<K, Normalize2<T[K]>>
-    : never
-  : never;
-type Normalize<T> = WithOrWithoutPlural<keyof T> | Normalize2<T>;
-
-// Normalize multiple namespaces
-type KeyWithNSSeparator<N, K, S extends string = TypeOptions['nsSeparator']> = `${N &
-  string}${S}${K & string}`;
-type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void
-  ? I
-  : never;
-type LastOf<T> = UnionToIntersection<T extends any ? () => T : never> extends () => infer R
-  ? R
-  : never;
-type NormalizeMulti<T, U extends keyof T, L = LastOf<U>> = L extends U
-  ? KeyWithNSSeparator<L, Normalize<T[L]>> | NormalizeMulti<T, Exclude<U, L>>
-  : never;
-
-interface CustomTypeParameters {
-  returnNull?: boolean;
-  returnEmptyString?: boolean;
-}
-
-type TypeOptionsFallback<TranslationValue, Option, MatchingValue> = Option extends false
-  ? TranslationValue extends MatchingValue
-    ? string
-    : TranslationValue
-  : TranslationValue;
-
-/**
- * Checks if user has enabled `returnEmptyString` and `returnNull` options to retrieve correct values.
- */
-export type NormalizeByTypeOptions<
-  TranslationValue,
-  Options extends CustomTypeParameters = TypeOptions,
-  R = TypeOptionsFallback<TranslationValue, Options['returnEmptyString'], ''>
-> = TypeOptionsFallback<R, Options['returnNull'], null>;
-
-type StringIfPlural<T> = TypeOptions['jsonFormat'] extends 'v4'
-  ? T extends `${string}_${PluralSuffix}`
-    ? string
-    : never
-  : never;
-
-type NormalizeReturn<
-  T,
-  V,
-  S extends string | false = TypeOptions['keySeparator']
-> = V extends keyof T
-  ? NormalizeByTypeOptions<T[V]>
-  : S extends false
-  ? V
-  : V extends `${infer K}${S}${infer R}`
-  ? K extends keyof T
-    ? NormalizeReturn<T[K], R>
-    : never
-  : StringIfPlural<keyof T>;
-
-type NormalizeMultiReturn<T, V> = V extends `${infer N}:${infer R}`
-  ? N extends keyof T
-    ? NormalizeReturn<T[N], R>
-    : never
-  : never;
-
-type NormalizeWithKeyPrefix<
-  T,
-  K,
-  S extends string = TypeOptions['keySeparator']
-> = K extends `${infer K1}${S}${infer K2}`
-  ? K1 extends keyof T
-    ? NormalizeWithKeyPrefix<T[K1], K2>
-    : never
-  : K extends keyof T
-  ? T[K] extends string
-    ? never
-    : Normalize<T[K]>
-  : never;
-
-type KeyPrefix<N extends Namespace> =
-  | (N extends keyof DefaultResources ? Normalize<DefaultResources[N]> : string)
-  | undefined;
-
-export type TFuncKey<
-  N extends Namespace = DefaultNamespace,
-  TKPrefix = undefined,
-  T = DefaultResources
-> = N extends (keyof T)[] | Readonly<(keyof T)[]>
-  ? NormalizeMulti<T, N[number]>
-  : N extends keyof T
-  ? TKPrefix extends undefined
-    ? Normalize<T[N]>
-    : NormalizeWithKeyPrefix<T[N], TKPrefix>
-  : string;
-
-export type TFuncReturn<
-  N,
-  TKeys,
-  TDefaultResult,
-  TKPrefix = undefined,
-  T = DefaultResources
-> = N extends (keyof T)[]
-  ? NormalizeMultiReturn<T, TKeys>
-  : N extends keyof T
-  ? TKPrefix extends undefined
-    ? NormalizeReturn<T[N], TKeys>
-    : NormalizeReturn<T[N], KeysWithSeparator<TKPrefix, TKeys>>
-  : Fallback<TDefaultResult>;
-
-export interface TFunction<N extends Namespace = DefaultNamespace, TKPrefix = undefined> {
-  <
-    TKeys extends TFuncKey<N, TKPrefix> | TemplateStringsArray extends infer A ? A : never,
-    TDefaultResult extends TFunctionResult | React.ReactNode = string,
-    TInterpolationMap extends object = StringMap
-  >(
-    key: TKeys | TKeys[],
-    options?: TOptions<TInterpolationMap> | string,
-  ): TFuncReturn<N, TKeys, TDefaultResult, TKPrefix>;
-  <
-    TKeys extends TFuncKey<N, TKPrefix> | TemplateStringsArray extends infer A ? A : never,
-    TDefaultResult extends TFunctionResult | React.ReactNode = string,
-    TInterpolationMap extends object = StringMap
-  >(
-    key: TKeys | TKeys[],
-    defaultValue?: string,
-    options?: TOptions<TInterpolationMap> | string,
-  ): TFuncReturn<N, TKeys, TDefaultResult, TKPrefix>;
-}
-
-type TransChild = React.ReactNode | Record<string, unknown>;
-export type TransProps<
-  K extends TFuncKey<N, TKPrefix> extends infer A ? A : never,
-  N extends Namespace = DefaultNamespace,
-  TKPrefix = undefined,
-  E = React.HTMLProps<HTMLDivElement>
-> = E & {
-  children?: TransChild | TransChild[];
-  components?: readonly React.ReactElement[] | { readonly [tagName: string]: React.ReactElement };
-  count?: number;
-  context?: string;
-  defaults?: string;
-  i18n?: i18n;
-  i18nKey?: K | K[];
-  ns?: N;
-  parent?: string | React.ComponentType<any> | null; // used in React.createElement if not null
-  tOptions?: {};
-  values?: {};
-  shouldUnescape?: boolean;
-  t?: TFunction<N, TKPrefix>;
-};
-
-export function Trans<
-  K extends TFuncKey<N, TKPrefix> extends infer A ? A : never,
-  N extends Namespace = DefaultNamespace,
-  TKPrefix extends KeyPrefix<N> = undefined,
-  E = React.HTMLProps<HTMLDivElement>
->(props: TransProps<K, N, TKPrefix, E>): React.ReactElement;
-
-export function useSSR(initialI18nStore: Resource, initialLanguage: string): void;
-
-export interface UseTranslationOptions<TKPrefix = undefined> {
-  i18n?: i18n;
-  useSuspense?: boolean;
-  keyPrefix?: TKPrefix;
-}
-
-export type UseTranslationResponse<N extends Namespace, TKPrefix = undefined> = [
-  TFunction<N, TKPrefix>,
-  i18n,
-  boolean,
-] & {
-  t: TFunction<N, TKPrefix>;
-  i18n: i18n;
-  ready: boolean;
-};
-
-export function useTranslation<
-  N extends Namespace = DefaultNamespace,
-  TKPrefix extends KeyPrefix<N> = undefined
->(
-  ns?: N | Readonly<N>,
-  options?: UseTranslationOptions<TKPrefix>,
-): UseTranslationResponse<N, TKPrefix>;
-
-// Need to see usage to improve this
-export function withSSR(): <Props>(
-  WrappedComponent: React.ComponentType<Props>,
-) => {
-  ({
-    initialI18nStore,
-    initialLanguage,
-    ...rest
-  }: {
-    initialI18nStore: Resource;
-    initialLanguage: string;
-  } & Props): React.FunctionComponentElement<Props>;
-  getInitialProps: (ctx: unknown) => Promise<any>;
-};
-
-export interface WithTranslation<
-  N extends Namespace = DefaultNamespace,
-  TKPrefix extends KeyPrefix<N> = undefined
-> {
-  t: TFunction<N, TKPrefix>;
-  i18n: i18n;
-  tReady: boolean;
-}
-
-export interface WithTranslationProps {
-  i18n?: i18n;
-  useSuspense?: boolean;
-}
-
-export function withTranslation<
-  N extends Namespace = DefaultNamespace,
-  TKPrefix extends KeyPrefix<N> = undefined
->(
-  ns?: N,
-  options?: {
-    withRef?: boolean;
-    keyPrefix?: TKPrefix;
-  },
-): <
-  C extends React.ComponentType<React.ComponentProps<any> & WithTranslationProps>,
-  ResolvedProps = JSX.LibraryManagedAttributes<
-    C,
-    Subtract<React.ComponentProps<C>, WithTranslationProps>
-  >
->(
-  component: C,
-) => React.ComponentType<Omit<ResolvedProps, keyof WithTranslation<N>> & WithTranslationProps>;
-
-export interface I18nextProviderProps {
-  children?: React.ReactNode;
-  i18n: i18n;
-  defaultNS?: string;
-}
-
-export const I18nextProvider: React.FunctionComponent<I18nextProviderProps>;
-export const I18nContext: React.Context<{ i18n: i18n }>;
-
-export interface TranslationProps<
-  N extends Namespace = DefaultNamespace,
-  TKPrefix extends KeyPrefix<N> = undefined
-> {
-  children: (
-    t: TFunction<N, TKPrefix>,
-    options: {
-      i18n: i18n;
-      lng: string;
-    },
-    ready: boolean,
-  ) => React.ReactNode;
-  ns?: N;
-  i18n?: i18n;
-  useSuspense?: boolean;
-  keyPrefix?: TKPrefix;
-}
-
-export function Translation<
-  N extends Namespace = DefaultNamespace,
-  TKPrefix extends KeyPrefix<N> = undefined
->(props: TranslationProps<N, TKPrefix>): any;