next-translate.d.ts (something similar to react-i18n typed useTranslation)

[TabaiAlaEddin]

import type common from 'locales/en/common.json';
import type settings from 'locales/en/settings.json';

type Subtract<T extends K, K> = Omit<T, keyof K>;

export interface Resources {
  common: typeof common;
  settings: typeof settings;
}

type Fallback<F, T = keyof Resources> = [T] extends [never] ? F : T;

export type Namespace<F = Fallback<string>> = F | F[];

type AppendKeys<K1, K2> = `${K1 & string}.${K2 & string}`;
type AppendKeys2<K1, K2> = `${K1 & string}.${Exclude<K2, keyof any[]> &
  string}`;
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]>>
    : never
  : never;
type Normalize<T> = keyof T | Normalize2<T>;

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 AppendNS<N, K> = `${N & string}:${K & string}`;
type NormalizeMulti<T, U extends keyof T, L = LastOf<U>> = L extends U
  ? AppendNS<L, Normalize<T[L]>> | NormalizeMulti<T, Exclude<U, L>>
  : never;

type NormalizeReturn<T, V> = V extends `${infer K}.${infer R}`
  ? K extends keyof T
    ? NormalizeReturn<T[K], R>
    : never
  : V extends keyof T
  ? T[V]
  : never;

type NormalizeMultiReturn<T, V> = V extends `${infer N}:${infer R}`
  ? N extends keyof T
    ? NormalizeReturn<T[N], R>
    : never
  : never;

export type TFuncKey<
  N extends Namespace = DefaultNamespace,
  T = Resources
> = N extends (keyof T)[]
  ? NormalizeMulti<T, N[number]>
  : N extends keyof T
  ? Normalize<T[N]>
  : string;

export type TFuncReturn<
  N,
  TKeys,
  TDefaultResult,
  T = Resources
> = N extends (keyof T)[]
  ? NormalizeMultiReturn<T, TKeys>
  : N extends keyof T
  ? NormalizeReturn<T[N], TKeys>
  : Fallback<TDefaultResult>;

export interface TFunction<N extends Namespace = DefaultNamespace> {
  <
    TKeys extends TFuncKey<N> | 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>;
  <
    TKeys extends TFuncKey<N> | 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>;
}

type UseTranslationResponse<N extends Namespace> = [TFunction<N>] & {
  t: TFunction<N>;
};

type DefaultNamespace<T = 'translation'> = T extends Fallback<string>
  ? T
  : string;

declare module 'next-translate/useTranslation' {
  export default function useTranslation<
    N extends Namespace = DefaultNamespace
  >(json: string): UseTranslationResponse<N>;
}