Skip to content
Python
4.0 KB
Raw Blame
import { randomUUID } from "node:crypto";
import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
import path from "node:path";
import {
  isLanguagePreference,
  type LanguagePreference,
  type LanguageSnapshot,
  normalizeLanguagePreference,
  resolveGuiLocale,
} from "@one-memory/i18n";

interface Storage {
  read(file: string): Promise<string>;
  save(file: string, content: string): Promise<void>;
}
const storage: Storage = {
  read: (file) => readFile(file, "utf8"),
  async save(file, content) {
    await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
    const temporary = `${file}.${randomUUID()}.tmp`;
    try {
      await writeFile(temporary, content, {
        encoding: "utf8",
        mode: 0o600,
        flag: "wx",
      });
      await rename(temporary, file);
    } finally {
      await rm(temporary, { force: true }).catch(() => {});
    }
  },
};

/** GUI-only preferences, scoped to the active Electron userData profile. */
export class LanguagePreferences {
  private queue: Promise<unknown> = Promise.resolve();
  private readonly listeners = new Set<(snapshot: LanguageSnapshot) => void>();
  private snapshot: LanguageSnapshot;

  private constructor(
    private readonly file: string,
    private readonly systemLanguage: string | undefined,
    private readonly io: Storage,
    preference: LanguagePreference,
  ) {
    this.snapshot = {
      preference,
      locale: resolveGuiLocale(preference, systemLanguage),
      revision: 0,
    };
  }

  static async open(
    userData: string,
    systemLanguage?: string,
    io: Storage = storage,
  ): Promise<LanguagePreferences> {
    const file = path.join(userData, "gui-language.json");
    let preference: LanguagePreference = "system";
    try {
      const data: unknown = JSON.parse(await io.read(file));
      // An earlier build's code (zh-CN) reads as today's (zh-Hans), so a
      // person keeps the language they chose; the next change writes it.
      const stored =
        data && typeof data === "object" && "preference" in data
          ? normalizeLanguagePreference(data.preference)
          : null;
      if (stored !== null) preference = stored;
    } catch {
      // Missing, unreadable or corrupt preferences never block startup or get rewritten.
    }
    return new LanguagePreferences(file, systemLanguage, io, preference);
  }

  read(): LanguageSnapshot {
    return { ...this.snapshot };
  }

  set(preference: LanguagePreference): Promise<LanguageSnapshot> {
    if (!isLanguagePreference(preference))
      return Promise.reject(Error("invalid_language_preference"));
    const operation = this.queue.then(async () => {
      if (preference === this.snapshot.preference) return this.read();
      try {
        await this.io.save(this.file, `${JSON.stringify({ preference })}\n`);
      } catch {
        throw Error("language_preference_save_failed");
      }
      this.snapshot = {
        preference,
        locale: resolveGuiLocale(preference, this.systemLanguage),
        revision: this.snapshot.revision + 1,
      };
      for (const listener of this.listeners) {
        try {
          listener(this.read());
        } catch {
          /* A closed consumer cannot undo a committed save. */
        }
      }
      return this.read();
    });
    this.queue = operation.catch(() => {});
    return operation;
  }

  subscribe(listener: (snapshot: LanguageSnapshot) => void): () => void {
    this.listeners.add(listener);
    return () => {
      this.listeners.delete(listener);
    };
  }

  async drain(): Promise<void> {
    await this.queue;
  }
}

/** Call only after Electron readiness: later preferred languages are not fallbacks. */
export function preferredSystemLanguage(app: {
  getPreferredSystemLanguages(): string[];
  getLocale(): string;
}): string | undefined {
  try {
    const primary = app.getPreferredSystemLanguages()[0];
    if (primary) return primary;
  } catch {
    /* Older/unavailable platform API: use Electron's locale. */
  }
  try {
    return app.getLocale() || undefined;
  } catch {
    return undefined;
  }
}