@rosskevin I saw that

First of all, I think as expected the error from

const mockWithT: i18next.WithT = {
  t: (key: string) => key,
};

It should be

const mockWithT: i18next.WithT = {
  t: (key: string | string[]) => key,
};

But It still does not fix the error. And I actually don't know why

Agreed @VincentLanglet - I tried a variety of things - none of which worked. The specific error from what you mentioned is:

test/typescript/mock.test.ts:7:3 - error TS2322: Type '(key: string | string[]) => string | string[]' is not assignable to type '<TKeys extends string = string, TValues extends object = object, TResult extends string | object | (string | object)[] = string | object | (string | object)[]>(key: TKeys | TKeys[], options?: TranslationOptions<TValues> | undefined) => TResult'.
  Type 'string | string[]' is not assignable to type 'TResult'.
    Type 'string' is not assignable to type 'TResult'.

7   t: (key: string | string[]) => key,
    ~

  index.d.ts:479:5
    479     t<
            ~~
    480       TKeys extends string = string,
        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    ...
    488       options?: TranslationOptions<TValues>,
        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    489     ): TResult;
        ~~~~~~~~~~~~~~~
    The expected type comes from property 't' which is declared here on type 'WithT'

I normally parameterize the interface and use in the method. I haven't tried that because I don't see how that would make a difference but perhaps I should. @tkow - thoughts since you introduced this originally?

BTW - the diff is now cleaned up and much simpler.

@rosskevin I get no error this way

interface TFunction<
  TKeys extends string = string,
  TValues extends object = object,
  TResult extends string | object | Array<string | object> =
    | string
    | object
    | Array<string | object>
> {
  (key: TKeys | TKeys[], options?: TranslationOptions<TValues>): TResult;
}

interface WithT {
  t: TFunction;
}

const mockWithT: WithT = {
  t: (key: string | string[]) => key,
};

Given that @VincentLanglet - I think we need to make a type-breaking change and just update the TranslationFunction because your TFunction duplicates it with diff parameterized arg order. I'll make an attempt.

@rosskevin I Agree

Ok, I think I have cleaned it up, though the generics test fails here:

i18next.t<string, KeyList>('friend', { myVar: 'someValue' });
i18next.t<string, KeyList>(['friend', 'tree'], { myVar: 'someValue' });
i18next.t<string, KeyList, { myVar: 'someValue' }>('friend', { myVar: 'someValue' });
i18next.t<string, KeyList, { myVar: 'someValue' }>(['friend', 'tree'], { myVar: 'someValue' });

Expected 0 type arguments, but got 2.
Expected 0 type arguments, but got 2.
Expected 0 type arguments, but got 2.
Expected 0 type arguments, but got 2.

Thoughts? Please check the updated description for a summary. I am tempted to comment out this test until @tkow has time to take a look. I think it is an important improvement that I think others may be running into.

@rosskevin Indeed, this way we lose the ability to use t<A,B,C>(...)
@tkow or @Jessidhia will be better help than me

Since the PR of tkow introduced a regression, I understand you comment out theses tests, in order to fix it. We will search how to have a better t function after.

There is still a debate about the choice

No breaking change, but not classic

interface TFunction<
  TResult extends string | object | Array<string | object> =
    | string
    | object
    | Array<string | object>,
  TValues extends object = object,
  TKeys extends string = string
> {
  (key: TKeys | TKeys[], options?: TranslationOptions<TValues>): TResult;
}

Versus

Breaking change, but classic

interface TFunction<
  TKeys extends string = string,
  TValues extends object = object,
  TResult extends string | object | Array<string | object> =
    | string
    | object
    | Array<string | object>
> {
  (key: TKeys | TKeys[], options?: TranslationOptions<TValues>): TResult;
}

@VincentLanglet the goal has always been to support classic usage. I just added some to t.test to demonstrate expected/typical use:

// various returns <string> is the default
i18next.t('friend');
i18next.t<object>('friend');
i18next.t<string[]>('friend');
i18next.t<object[]>('friend');

This should be the simplest use I think.

The current push works for everything except the mock - back to square one but with an improved basis. I strangely have to duplicate TFunction inside WithT to retain parameterized type usage with i18next.t<>. So close...

@rosskevin When @tkow made his PR, it was intented to be used this way I think. But it's debatable

i18next.t('friend');
i18next.t<'friend'>('friend');

Anyway, the actual real problem is that we are not able to type correctly in order to having both generic type and the test for the mock working. We're doing something wrong... but hard to find what.

Duplication removed, change init test to rely on inference instead of explicit types for callbacks, still have the mock issue.

This works now without explicit types (unless you want the return type of object or string[]). For parameterized TKeys use, you now have to use the second arg, which makes sense because most won't do that.

If I can get a good solution to the mock test, I think this is good to go.

Added a workaround for the mock.test for the time being and filed an issue.

Coverage decreased (-0.3%) to 88.155% when pulling 921ae23 on rosskevin:ts-mock-withnamespaces into 5134e75 on i18next:master.

@jamuhl I need a release for this. This is a breaking typescript change (see description) - it primarily fixes a regression introduced but to do so had to change order of parameterized args. The best way to not silently cause a lot of confusion for TS users is to break it in very obvious way - change the name of the interfaces that were affected.

A major bump would make sense for TS users, but not for js users - your call on versioning. If you aren't worried, I would major bump it.

I will have a follow-up PR/release to react-i18next related to this.

@rosskevin published in i18next@14.0.0

I just updated my dependencies and apperently I am not able to do this anymore:

import { WithNamespaces, withNamespaces } from "react-i18next";

export interface IDurationProps extends WithNamespaces {
 /* other props */ 
}

const Duration: React.FC<IDurationProps> = ({ t }) => { 
   return <p>{t("my-key")}</p>
}

export default withNamespaces()(Duration);

My test:

describe("Duration", () => {
  const props: IDurationProps = {
    duration: 1800000,
    size: "medium",
    i18n: null,
    tReady: true,
    t: (key) => "h [hrs] mm [min]" // <-- Error: Compile Error!
  };

  /* omitted */

Type '"h [hrs] mm [min]"' is not assignable to type 'TResult'.ts(2322)
index.d.ts(473, 5): The expected type comes from the return type of this signature.