Skip to content
Python
7.5 KB
Raw Blame
import {
  type GuiLocale,
  isLanguagePreference,
  isLanguageSnapshot,
  type LanguagePreference,
  type LanguageSnapshot,
  normalizeLanguagePreference,
  plainCount,
  resolveGuiLocale,
  translate,
  translateCount,
} from "@one-memory/i18n";
import {
  createContext,
  type ReactNode,
  useContext,
  useEffect,
  useState,
  useSyncExternalStore,
} from "react";

export const LANGUAGE_STORAGE_KEY = "memhub.ui-language";
type LanguageError = "languageLoadError" | "languageSaveError" | null;
type State = LanguageSnapshot & { error: LanguageError };
/** Tells Core the display language (null = follow the system). */
export type ReportUiLanguage = (language: GuiLocale | null) => Promise<unknown>;
const initial: State = {
  preference: "system",
  locale: "zh-Hans",
  revision: 0,
  error: null,
};

function createLanguageStore(reportToCore?: ReportUiLanguage) {
  let state = initial;
  let revision = -1;
  let generation = 0;
  let writeRequest = 0;
  let bridge: Window["oneMemory"];
  const listeners = new Set<() => void>();
  const publish = (next: State) => {
    state = next;
    for (const listener of listeners) listener();
  };
  const accept = (snapshot: unknown) => {
    if (!isLanguageSnapshot(snapshot))
      throw new Error("Invalid language snapshot");
    if (snapshot.revision < revision) return;
    if (
      snapshot.revision === revision &&
      (snapshot.preference !== state.preference ||
        snapshot.locale !== state.locale)
    )
      return;
    revision = snapshot.revision;
    publish({ ...snapshot, error: null });
  };
  const readBrowser = () => {
    try {
      const stored = window.localStorage.getItem(LANGUAGE_STORAGE_KEY);
      const preference = normalizeLanguagePreference(stored) ?? "system";
      // An earlier build's code (zh-CN) is kept as today's (zh-Hans).
      if (stored !== null && stored !== preference && preference !== "system")
        window.localStorage.setItem(LANGUAGE_STORAGE_KEY, preference);
      publish({
        preference,
        locale: resolveGuiLocale(preference, navigator.language),
        revision: state.revision + 1,
        error: null,
      });
    } catch {
      publish({ ...state, error: "languageLoadError" });
    }
  };
  return {
    getSnapshot: () => state,
    subscribe(listener: () => void) {
      listeners.add(listener);
      return () => {
        listeners.delete(listener);
      };
    },
    start() {
      const current = ++generation;
      bridge = window.oneMemory;
      if (bridge) {
        let unsubscribe: (() => void) | undefined;
        const beforeRead = revision;
        try {
          if (
            !bridge.onLanguagePreferenceChanged ||
            !bridge.getLanguagePreference
          )
            throw new Error("Language bridge unavailable");
          unsubscribe = bridge.onLanguagePreferenceChanged((snapshot) => {
            if (generation !== current) return;
            try {
              accept(snapshot);
            } catch {
              publish({ ...state, error: "languageLoadError" });
            }
          });
          void bridge
            .getLanguagePreference()
            .then((snapshot) => {
              if (generation === current) accept(snapshot);
            })
            .catch(() => {
              if (generation === current && revision === beforeRead)
                publish({ ...state, error: "languageLoadError" });
            });
        } catch {
          publish({ ...state, error: "languageLoadError" });
        }
        return () => {
          generation++;
          unsubscribe?.();
        };
      }
      const storage = (event: StorageEvent) => {
        if (event.key !== null && event.key !== LANGUAGE_STORAGE_KEY) return;
        try {
          if (
            event.storageArea !== null &&
            event.storageArea !== window.localStorage
          )
            return;
          readBrowser();
        } catch {
          publish({ ...state, error: "languageLoadError" });
        }
      };
      const languageChange = () => {
        if (state.preference === "system")
          publish({
            ...state,
            locale: resolveGuiLocale("system", navigator.language),
          });
      };
      window.addEventListener("storage", storage);
      window.addEventListener("languagechange", languageChange);
      readBrowser();
      return () => {
        generation++;
        window.removeEventListener("storage", storage);
        window.removeEventListener("languagechange", languageChange);
      };
    },
    async setPreference(preference: LanguagePreference) {
      const current = generation;
      const request = ++writeRequest;
      try {
        if (!isLanguagePreference(preference))
          throw new Error("Invalid language preference");
        if (bridge) {
          if (!bridge.setLanguagePreference)
            throw new Error("Language bridge unavailable");
          const snapshot = await bridge.setLanguagePreference(preference);
          if (generation === current) accept(snapshot);
        } else {
          window.localStorage.setItem(LANGUAGE_STORAGE_KEY, preference);
          publish({
            preference,
            locale: resolveGuiLocale(preference, navigator.language),
            revision: state.revision + 1,
            error: null,
          });
          // Desktop tells Core from its main process; the browser UI does it
          // here. Best effort: the display language is already saved.
          void reportToCore?.(
            preference === "system" ? null : preference,
          ).catch(() => {});
        }
      } catch {
        if (generation === current && request === writeRequest)
          publish({ ...state, error: "languageSaveError" });
      }
    },
  };
}

type LanguageContextValue = State & {
  setPreference(preference: LanguagePreference): Promise<void>;
};
// Standalone components retain the historical Chinese UI without a provider.
const LanguageContext = createContext<LanguageContextValue>({
  ...initial,
  setPreference: async () => {},
});

export function LanguageProvider({
  children,
  reportToCore,
}: {
  children: ReactNode;
  reportToCore?: ReportUiLanguage;
}) {
  const [store] = useState(() => createLanguageStore(reportToCore));
  const state = useSyncExternalStore(
    store.subscribe,
    store.getSnapshot,
    store.getSnapshot,
  );
  useEffect(() => store.start(), [store]);
  useEffect(() => {
    document.documentElement.lang = state.locale;
  }, [state.locale]);
  return (
    <LanguageContext.Provider
      value={{ ...state, setPreference: store.setPreference }}
    >
      {children}
    </LanguageContext.Provider>
  );
}

export function useGuiLanguage() {
  const language = useContext(LanguageContext);
  return {
    ...language,
    t: (
      key: Parameters<typeof translate>[1],
      params?: Parameters<typeof translate>[2],
    ) => translate(language.locale, key, params),
    /** Count-aware `t`: picks the Spanish `.one` variant and groups digits. */
    tn: (
      key: Parameters<typeof translate>[1],
      count: number,
      params?: Parameters<typeof translate>[2],
    ) =>
      translateCount(language.locale, key, count, {
        ...params,
        count: new Intl.NumberFormat(language.locale).format(count),
      }),
    /** `tn` for copy whose Chinese has always shown the bare number. */
    tnPlain: (
      key: Parameters<typeof translate>[1],
      count: number,
      params?: Parameters<typeof translate>[2],
    ) =>
      translateCount(language.locale, key, count, {
        ...params,
        count: plainCount(language.locale, count),
      }),
  };
}