react-i18next 11.12.0 → 11.14.2

package/CHANGELOG.md

@@ -1,3 +1,21 @@
+### 11.14.2
+
+- Add type-safe support to deep keyPrefix [1403](https://github.com/i18next/react-i18next/pull/1403)
+
+### 11.14.1
+
+- Rollback [1402](https://github.com/i18next/react-i18next/pull/1402): Remove generics from Trans component to suppress warning issue [1400](https://github.com/i18next/react-i18next/pull/1400)
+
+### 11.14.0
+
+- Remove generics from Trans component to suppress warning issue [1400](https://github.com/i18next/react-i18next/pull/1400)
+- Add type support to plurals [1399](https://github.com/i18next/react-i18next/pull/1399)
+
+### 11.13.0
+
+- feat(types): add type-safe support to keyPrefix option [1390](https://github.com/i18next/react-i18next/pull/1390)
+- feat(types): allow key separator augmentation [1367](https://github.com/i18next/react-i18next/pull/1367)
+
 ### 11.12.0
 
 - feature: add key prefix support to useTranslation hook [1371](https://github.com/i18next/react-i18next/pull/1371)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-i18next",
-  "version": "11.12.0",
+  "version": "11.14.2",
   "description": "Internationalization for react done right. Using the i18next i18n ecosystem.",
   "main": "dist/commonjs/index.js",
   "types": "./index.d.ts",
@@ -67,7 +67,7 @@
     "eslint-plugin-react": "^7.16.0",
     "eslint-plugin-testing-library": "^3.10.1",
     "husky": "^3.0.3",
-    "i18next": "^20.6.1",
+    "i18next": "^21.0.0",
     "jest": "^24.8.0",
     "jest-cli": "^24.8.4",
     "lint-staged": "^8.1.3",

package/ts4.1/index.d.ts

@@ -35,8 +35,10 @@ export interface Resources {}
  * declare module 'react-i18next' {
  *   interface CustomTypeOptions {
  *     defaultNS: 'custom';
- *     returnNull: false,
- *     returnEmptyString: false,
+ *     returnNull: false;
+ *     returnEmptyString: false;
+ *     keySeparator: '.';
+ *     jsonFormat: 'v4';
  *     resources: {
  *       custom: {
  *         foo: 'foo';
@@ -54,7 +56,9 @@ type TypeOptions = MergeBy<
   {
     returnNull: true;
     returnEmptyString: true;
+    keySeparator: '.';
     defaultNS: 'translation';
+    jsonFormat: 'v4';
     resources: Resources;
   },
   CustomTypeOptions
@@ -91,17 +95,28 @@ declare module 'i18next' {
   }
 }
 
+type WithOrWithoutPlural<K> = TypeOptions['jsonFormat'] extends 'v4'
+  ? K extends `${infer B}_${'zero' | 'one' | 'two' | 'few' | 'many' | 'other'}`
+    ? B | K
+    : K
+  : K;
+
 // Normalize single namespace
-type AppendKeys<K1, K2> = `${K1 & string}.${K2 & string}`;
-type AppendKeys2<K1, K2> = `${K1 & string}.${Exclude<K2, keyof any[]> & string}`;
+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[]
-      ? AppendKeys2<K, keyof T[K]> | AppendKeys2<K, Normalize2<T[K]>>
-      : AppendKeys<K, keyof T[K]> | AppendKeys<K, Normalize2<T[K]>>
+      ?
+          | 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> = keyof T | Normalize2<T>;
+type Normalize<T> = WithOrWithoutPlural<keyof T> | Normalize2<T>;
 
 // Normalize multiple namespaces
 type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void
@@ -135,12 +150,18 @@ export type NormalizeByTypeOptions<
   R = TypeOptionsFallback<TranslationValue, Options['returnEmptyString'], ''>
 > = TypeOptionsFallback<R, Options['returnNull'], null>;
 
-type NormalizeReturn<T, V> = V extends `${infer K}.${infer R}`
+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
-  : V extends keyof T
-  ? NormalizeByTypeOptions<T[V]>
   : never;
 
 type NormalizeMultiReturn<T, V> = V extends `${infer N}:${infer R}`
@@ -149,43 +170,74 @@ type NormalizeMultiReturn<T, V> = V extends `${infer N}:${infer R}`
     : never
   : never;
 
-export type TFuncKey<N extends Namespace = DefaultNamespace, T = DefaultResources> = N extends
-  | (keyof T)[]
-  | Readonly<(keyof T)[]>
+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]> | undefined
+  : 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
-  ? Normalize<T[N]>
+  ? TKPrefix extends undefined
+    ? Normalize<T[N]>
+    : NormalizeWithKeyPrefix<T[N], TKPrefix>
   : string;
 
-export type TFuncReturn<N, TKeys, TDefaultResult, T = DefaultResources> = N extends (keyof T)[]
+export type TFuncReturn<
+  N,
+  TKeys,
+  TDefaultResult,
+  TKPrefix = undefined,
+  T = DefaultResources
+> = N extends (keyof T)[]
   ? NormalizeMultiReturn<T, TKeys>
   : N extends keyof T
-  ? NormalizeReturn<T[N], TKeys>
+  ? TKPrefix extends undefined
+    ? NormalizeReturn<T[N], TKeys>
+    : NormalizeReturn<T[N], KeysWithSeparator<TKPrefix, TKeys>>
   : Fallback<TDefaultResult>;
 
-export interface TFunction<N extends Namespace = DefaultNamespace> {
+export interface TFunction<N extends Namespace = DefaultNamespace, TKPrefix = undefined> {
   <
-    TKeys extends TFuncKey<N> | TemplateStringsArray extends infer A ? A : never,
+    TKeys extends TFuncKey<N, TKPrefix> | TemplateStringsArray extends infer A ? A : never,
     TDefaultResult extends TFunctionResult = string,
     TInterpolationMap extends object = StringMap
   >(
     key: TKeys | TKeys[],
     options?: TOptions<TInterpolationMap> | string,
-  ): TFuncReturn<N, TKeys, TDefaultResult>;
+  ): TFuncReturn<N, TKeys, TDefaultResult, TKPrefix>;
   <
-    TKeys extends TFuncKey<N> | TemplateStringsArray extends infer A ? A : never,
+    TKeys extends TFuncKey<N, TKPrefix> | TemplateStringsArray extends infer A ? A : never,
     TDefaultResult extends TFunctionResult = string,
     TInterpolationMap extends object = StringMap
   >(
     key: TKeys | TKeys[],
     defaultValue?: string,
     options?: TOptions<TInterpolationMap> | string,
-  ): TFuncReturn<N, TKeys, TDefaultResult>;
+  ): TFuncReturn<N, TKeys, TDefaultResult, TKPrefix>;
 }
 
 export interface TransProps<
-  K extends TFuncKey<N> extends infer A ? A : never,
+  K extends TFuncKey<N, TKPrefix> extends infer A ? A : never,
   N extends Namespace = DefaultNamespace,
+  TKPrefix = undefined,
   E extends Element = HTMLDivElement
 > extends React.HTMLProps<E> {
   children?: React.ReactNode;
@@ -198,32 +250,41 @@ export interface TransProps<
   parent?: string | React.ComponentType<any> | null; // used in React.createElement if not null
   tOptions?: {};
   values?: {};
-  t?: TFunction<N>;
+  t?: TFunction<N, TKPrefix>;
 }
+
 export function Trans<
-  K extends TFuncKey<N> extends infer A ? A : never,
+  K extends TFuncKey<N, TKPrefix> extends infer A ? A : never,
   N extends Namespace = DefaultNamespace,
+  TKPrefix extends KeyPrefix<N> = undefined,
   E extends Element = HTMLDivElement
->(props: TransProps<K, N, E>): React.ReactElement;
+>(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;
 }
 
-type UseTranslationResponse<N extends Namespace> = [TFunction<N>, i18n, boolean] & {
-  t: TFunction<N>;
+type UseTranslationResponse<N extends Namespace, TKPrefix> = [
+  TFunction<N, TKPrefix>,
+  i18n,
+  boolean,
+] & {
+  t: TFunction<N, TKPrefix>;
   i18n: i18n;
   ready: boolean;
 };
 
-export function useTranslation<N extends Namespace = DefaultNamespace>(
+export function useTranslation<
+  N extends Namespace = DefaultNamespace,
+  TKPrefix extends KeyPrefix<N> = undefined
+>(
   ns?: N | Readonly<N>,
-  options?: UseTranslationOptions,
-): UseTranslationResponse<N>;
+  options?: UseTranslationOptions<TKPrefix>,
+): UseTranslationResponse<N, TKPrefix>;
 
 // Need to see usage to improve this
 export function withSSR(): <Props>(