Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

4.0 KB
Raw Blame
import type * as Schema from "effect/Schema";
import * as Predicate from "effect/Predicate";
import {
  createContext,
  useCallback,
  useContext,
  useEffect,
  useMemo,
  useSyncExternalStore,
  type ReactNode,
} from "react";
import {
  availableLanguages,
  catalogIdForLocale,
  createCatalogLoader,
  createTranslator,
  resolveLocale,
  type TranslationCatalog,
} from "@akeru/client-runtime/i18n";
import {
  ensureClientSettingsHydrated,
  useClientSettings,
  useUpdateClientSettings,
} from "./hooks/useSettings";

export { availableLanguages };

export function normalizeLanguagePreference(value: Schema.Json | undefined): string {
  return Predicate.isString(value) && availableLanguages.some(({ id }) => id === value)
    ? value
    : "system";
}

function subscribeDeviceLanguage(listener: () => void) {
  window.addEventListener("languagechange", listener);

  return () => window.removeEventListener("languagechange", listener);
}

function getDeviceLocale() {
  return resolveLocale("system", typeof navigator === "undefined" ? [] : navigator.languages);
}

export interface TestLanguageCatalog {
  readonly locale: string;
  readonly catalog: TranslationCatalog;
}

const fallbackTranslator = createTranslator("en");

const LanguageContext = createContext({
  ...fallbackTranslator,
  t: fallbackTranslator.translate,
  preference: "system",
  setPreference: async (_value: string): Promise<void> => {
    throw new Error("Language changes require LanguageProvider.");
  },
  /** The selected language's catalog failed to load, so English is showing. */
  catalogFailed: false,
  retryCatalog: () => {},
});

/** Catalog injection is supplied by tests, not by the language selector. */
export function LanguageProvider({
  children,
  testCatalog,
}: {
  children: ReactNode;
  testCatalog?: TestLanguageCatalog | undefined;
}) {
  const preference = normalizeLanguagePreference(
    useClientSettings((settings) => settings.language),
  );

  const updateClientSettings = useUpdateClientSettings();

  const deviceLocale = useSyncExternalStore(
    subscribeDeviceLanguage,
    getDeviceLocale,
    getDeviceLocale,
  );

  const locale = resolveLocale(preference, [deviceLocale]);
  const loader = useMemo(() => createCatalogLoader(), []);

  const catalogSnapshot = useSyncExternalStore(
    loader.subscribe,
    loader.getSnapshot,
    loader.getSnapshot,
  );

  const retryCatalog = useCallback(() => {
    if (testCatalog) return;
    void loader.selectLocale(preference, [deviceLocale]);
  }, [deviceLocale, loader, preference, testCatalog]);

  useEffect(() => retryCatalog(), [retryCatalog]);

  const catalogFailed =
    !testCatalog &&
    catalogSnapshot.status === "error" &&
    catalogIdForLocale(catalogSnapshot.selectedLocale) === catalogIdForLocale(locale);

  const translator = useMemo(() => {
    if (testCatalog) return createTranslator(testCatalog.locale, testCatalog.catalog);

    if (catalogIdForLocale(locale) === "en") return createTranslator(locale);

    if (
      catalogSnapshot.status === "ready" &&
      catalogIdForLocale(catalogSnapshot.selectedLocale) === catalogIdForLocale(locale)
    ) {
      return catalogSnapshot.translator;
    }

    return createTranslator(locale);
  }, [catalogSnapshot, locale, testCatalog]);

  const setPreference = useCallback(
    async (value: string) => {
      // Preserve disk preferences if the selector is used before initial hydration finishes.
      await ensureClientSettingsHydrated();
      updateClientSettings({ language: normalizeLanguagePreference(value) });
    },
    [updateClientSettings],
  );

  const value = useMemo(
    () => ({
      ...translator,
      t: translator.translate,
      preference,
      setPreference,
      catalogFailed,
      retryCatalog,
    }),
    [translator, preference, setPreference, catalogFailed, retryCatalog],
  );

  useEffect(() => {
    document.documentElement.lang = translator.locale;
  }, [translator.locale]);

  return <LanguageContext value={value}>{children}</LanguageContext>;
}

export function useI18n() {
  return useContext(LanguageContext);
}