packages/js/src/ui/context/LocalizationContext.tsx - next - githubmirror/novu

packages/js/src/ui/context/LocalizationContext.tsx
104 строки3 KB
Dima Grossman
fix(js): localize de-DE sub-minute inbox timestamps fixes NV-8169 (#11765)
05 июл 2026, 12:32
05 июл 2026, 12:3200f1787
import { Accessor, createContext, createMemo, ParentProps, useContext } from 'solid-js';
import {
  defaultInboxLocalization,
  defaultLocalization,
  defaultSubscriptionLocalization,
  dynamicLocalization,
} from '../config/defaultLocalization';
import { normalizeIntlLocale } from '../helpers/normalizeIntlLocale';

export type InboxLocalizationKey = keyof typeof defaultInboxLocalization;
export type SubscriptionLocalizationKey = keyof typeof defaultSubscriptionLocalization;
export type AllLocalizationKey = InboxLocalizationKey | SubscriptionLocalizationKey;

export type StringLocalizationKey = {
  [K in AllLocalizationKey]: (typeof defaultLocalization)[K] extends string ? K : never;
}[AllLocalizationKey];

export type AllLocalization = {
  [K in AllLocalizationKey]?: (typeof defaultLocalization)[K] extends (...args: infer P) => any
    ? ((...args: P) => ReturnType<(typeof defaultLocalization)[K]>) | string
    : string;
} & {
  dynamic?: Record<string, string>;
};
export type InboxLocalization = {
  [K in InboxLocalizationKey]?: (typeof defaultInboxLocalization)[K] extends (...args: infer P) => any
    ? ((...args: P) => ReturnType<(typeof defaultInboxLocalization)[K]>) | string
    : string;
} & {
  dynamic?: Record<string, string>;
};
export type SubscriptionLocalization = {
  [K in SubscriptionLocalizationKey]?: (typeof defaultSubscriptionLocalization)[K] extends (...args: infer P) => any
    ? ((...args: P) => ReturnType<(typeof defaultSubscriptionLocalization)[K]>) | string
    : string;
} & {
  dynamic?: Record<string, string>;
};

type TranslateFunctionArg<K extends AllLocalizationKey> = K extends keyof typeof defaultLocalization
  ? (typeof defaultLocalization)[K] extends (arg: infer A) => any
    ? A
    : undefined
  : undefined;

type TranslateFunction = <K extends AllLocalizationKey>(
  key: K,
  ...args: TranslateFunctionArg<K> extends undefined
    ? [undefined?] // No arguments needed if TranslateFunctionArg<K> is undefined
    : [TranslateFunctionArg<K>] // A single argument is required if TranslateFunctionArg<K> is defined
) => string;

type LocalizationContextType = {
  t: TranslateFunction;
  locale: Accessor<string>;
};

const LocalizationContext = createContext<LocalizationContextType | undefined>(undefined);

type LocalizationProviderProps = ParentProps & { localization?: AllLocalization };

export const LocalizationProvider = (props: LocalizationProviderProps) => {
  const localization = createMemo<Record<string, string | Function>>(() => {
    const { dynamic, ...localizationObject } = props.localization || {};

    return {
      ...defaultLocalization,
      ...dynamicLocalization(),
      ...(dynamic || {}),
      ...localizationObject,
    };
  });

  const t: LocalizationContextType['t'] = (key, ...args) => {
    const value = localization()[key];
    if (typeof value === 'function') {
      return value(args[0]);
    }

    return value as string;
  };

  const locale = createMemo(() => normalizeIntlLocale(localization().locale as string));

  return (
    <LocalizationContext.Provider
      value={{
        t,
        locale,
      }}
    >
      {props.children}
    </LocalizationContext.Provider>
  );
};

export function useLocalization() {
  const context = useContext(LocalizationContext);
  if (!context) {
    throw new Error('useLocalization must be used within an LocalizationProvider');
  }

  return context;
}