99 lines
4.5 KiB
TypeScript
99 lines
4.5 KiB
TypeScript
// Catalog discovery: import src/i18n/locales/<tag>.ts and plugins/<id>/i18n/<tag>.ts, then
|
|
// check every one against its set's en-US baseline. The imperative shell over catalog.ts's pure
|
|
// rules — the same contract as plugin discovery: one boot-stopping Error listing every problem,
|
|
// so a half-translated deploy is caught at startup rather than as a stray English word in production.
|
|
//
|
|
// Installed locales are whatever the core folder holds; a plugin may translate fewer of them (its
|
|
// strings then render in en-US on that page) but never one the host does not have.
|
|
|
|
import { existsSync, readdirSync } from "node:fs";
|
|
import { dirname, join } from "node:path";
|
|
import { fileURLToPath, pathToFileURL } from "node:url";
|
|
import { checkCatalog, DEFAULT_LOCALE, isCatalog, type Catalog } from "./catalog.ts";
|
|
import { PLUGINS_DIR } from "../plugin-host/discovery.ts";
|
|
|
|
export const LOCALES_DIR = join(dirname(fileURLToPath(import.meta.url)), "locales");
|
|
|
|
// A catalog file is named for the full locale it holds — sv-SE.ts, never sv.ts. Anything else in
|
|
// the folder is a mistake worth stopping for.
|
|
const LOCALE_FILE = /^([a-z]{2,3}-[A-Z]{2})\.ts$/;
|
|
|
|
export interface LoadI18nOptions {
|
|
localesDir?: string;
|
|
pluginIds?: string[]; // discovered plugins; their i18n/ folders are loaded under their id
|
|
pluginsDir?: string;
|
|
}
|
|
|
|
export interface LoadedI18n {
|
|
available: string[]; // installed locales, sorted — the switcher's list, and "sv" resolution order
|
|
core: Map<string, Catalog>;
|
|
plugins: Map<string, Map<string, Catalog>>; // plugin id → locale → catalog
|
|
}
|
|
|
|
export async function loadI18n(options: LoadI18nOptions = {}): Promise<LoadedI18n> {
|
|
const localesDir = options.localesDir ?? LOCALES_DIR;
|
|
const pluginsDir = options.pluginsDir ?? PLUGINS_DIR;
|
|
const errors: string[] = [];
|
|
|
|
const core = await readSet(localesDir, "core", errors);
|
|
if (!core.has(DEFAULT_LOCALE)) errors.push(`core: no ${DEFAULT_LOCALE}.ts — it is the baseline every other locale is checked against`);
|
|
checkSet(core, "core", errors);
|
|
const available = [...core.keys()].sort();
|
|
|
|
const plugins = new Map<string, Map<string, Catalog>>();
|
|
for (const id of options.pluginIds ?? []) {
|
|
const dir = join(pluginsDir, id, "i18n");
|
|
if (!existsSync(dir)) continue;
|
|
const set = await readSet(dir, `plugins/${id}`, errors);
|
|
if (set.size === 0) continue;
|
|
if (!set.has(DEFAULT_LOCALE)) errors.push(`plugins/${id}: no ${DEFAULT_LOCALE}.ts — a plugin's own baseline`);
|
|
for (const locale of set.keys()) {
|
|
if (!available.includes(locale)) errors.push(`plugins/${id}: ${locale} is not installed — add src/i18n/locales/${locale}.ts first`);
|
|
}
|
|
checkSet(set, `plugins/${id}`, errors);
|
|
plugins.set(id, set);
|
|
}
|
|
|
|
if (errors.length) throw new Error(`Translation catalogs failed to load:\n${errors.map((e) => ` - ${e}`).join("\n")}`);
|
|
return { available, core, plugins };
|
|
}
|
|
|
|
// Import every catalog in one folder. A stray file, a failed import or a value that is not a
|
|
// catalog is collected as an error — never skipped, or the locale would just go quietly missing.
|
|
async function readSet(dir: string, label: string, errors: string[]): Promise<Map<string, Catalog>> {
|
|
const set = new Map<string, Catalog>();
|
|
if (!existsSync(dir)) return set;
|
|
|
|
for (const entry of readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
|
|
if (entry.isDirectory() || entry.name.startsWith(".")) continue;
|
|
const locale = LOCALE_FILE.exec(entry.name)?.[1];
|
|
if (locale === undefined) {
|
|
errors.push(`${label}: "${entry.name}" is not a locale catalog — name it <language>-<REGION>.ts (e.g. sv-SE.ts)`);
|
|
continue;
|
|
}
|
|
let mod: { default?: unknown };
|
|
try {
|
|
mod = (await import(pathToFileURL(join(dir, entry.name)).href)) as { default?: unknown };
|
|
} catch (err) {
|
|
errors.push(`${label}: ${entry.name} failed to import — ${err instanceof Error ? err.message : String(err)}`);
|
|
continue;
|
|
}
|
|
if (!isCatalog(mod.default)) {
|
|
errors.push(`${label}: ${entry.name} must default-export an object of strings (or plural forms)`);
|
|
continue;
|
|
}
|
|
set.set(locale, mod.default);
|
|
}
|
|
return set;
|
|
}
|
|
|
|
function checkSet(set: Map<string, Catalog>, label: string, errors: string[]): void {
|
|
const baseline = set.get(DEFAULT_LOCALE);
|
|
if (baseline === undefined) return; // already reported; nothing to compare against
|
|
for (const [locale, catalog] of set) {
|
|
for (const problem of checkCatalog({ baseline, baselineLocale: DEFAULT_LOCALE, catalog, locale })) {
|
|
errors.push(`${label} ${locale}: ${problem}`);
|
|
}
|
|
}
|
|
}
|