144 lines
5.3 KiB
TypeScript
144 lines
5.3 KiB
TypeScript
export const defaultLocale = "de" as const;
|
|
export const supportedLocales = ["de", "en", "pl", "ru", "uk", "hu"] as const;
|
|
export type SupportedLocale = (typeof supportedLocales)[number];
|
|
|
|
// This registry advances with the atomic per-language catalog commits. A
|
|
// supported locale cannot be enabled until every namespace and QA artifact for
|
|
// that locale is present in the same commit.
|
|
export const catalogReadyLocales = ["de", "en", "pl", "ru", "uk", "hu"] as const satisfies readonly SupportedLocale[];
|
|
|
|
export const defaultEnabledLocales = ["de", "en"] as const satisfies readonly SupportedLocale[];
|
|
|
|
export const localeReleaseStages = {
|
|
de: "production",
|
|
en: "production",
|
|
pl: "review",
|
|
ru: "review",
|
|
uk: "review",
|
|
hu: "review",
|
|
} as const satisfies Record<SupportedLocale, "production" | "review">;
|
|
|
|
export type EnabledLocalesIssueCode = "empty-value" | "duplicate" | "unknown" | "missing-catalog" | "missing-default" | "review-only";
|
|
|
|
export type EnabledLocalesIssue = {
|
|
code: EnabledLocalesIssueCode;
|
|
value?: string;
|
|
};
|
|
|
|
export class EnabledLocalesConfigError extends Error {
|
|
readonly issues: readonly EnabledLocalesIssue[];
|
|
|
|
constructor(issues: readonly EnabledLocalesIssue[]) {
|
|
const details = issues.map((issue) => (issue.value ? `${issue.code}:${issue.value}` : issue.code)).join(", ");
|
|
super(`I18N_ENABLED_LOCALES is invalid (${details}). Use unique comma-separated locale codes from: ${supportedLocales.join(",")}.`);
|
|
this.name = "EnabledLocalesConfigError";
|
|
this.issues = [...issues];
|
|
}
|
|
}
|
|
|
|
export function isSupportedLocale(locale: string | undefined): locale is SupportedLocale {
|
|
return Boolean(locale && (supportedLocales as readonly string[]).includes(locale));
|
|
}
|
|
|
|
export function parseEnabledLocales(
|
|
value: string | undefined,
|
|
options: { allowReviewLocales?: boolean } = {}
|
|
): readonly SupportedLocale[] {
|
|
const configured = value === undefined ? [...defaultEnabledLocales] : value.split(",").map((part) => part.trim());
|
|
const issues: EnabledLocalesIssue[] = [];
|
|
const seen = new Set<string>();
|
|
|
|
for (const locale of configured) {
|
|
if (!locale) {
|
|
issues.push({ code: "empty-value" });
|
|
continue;
|
|
}
|
|
if (seen.has(locale)) {
|
|
issues.push({ code: "duplicate", value: locale });
|
|
continue;
|
|
}
|
|
seen.add(locale);
|
|
if (!isSupportedLocale(locale)) {
|
|
issues.push({ code: "unknown", value: locale });
|
|
continue;
|
|
}
|
|
if (!(catalogReadyLocales as readonly SupportedLocale[]).includes(locale)) {
|
|
issues.push({ code: "missing-catalog", value: locale });
|
|
continue;
|
|
}
|
|
if (localeReleaseStages[locale] === "review" && options.allowReviewLocales !== true) {
|
|
issues.push({ code: "review-only", value: locale });
|
|
}
|
|
}
|
|
|
|
if (!seen.has(defaultLocale)) {
|
|
issues.push({ code: "missing-default", value: defaultLocale });
|
|
}
|
|
if (issues.length > 0) {
|
|
throw new EnabledLocalesConfigError(issues);
|
|
}
|
|
|
|
return configured as SupportedLocale[];
|
|
}
|
|
|
|
export function normalizeLocaleCandidate(value: string | null | undefined): SupportedLocale | undefined {
|
|
const normalized = value?.trim().toLowerCase();
|
|
if (!normalized) return undefined;
|
|
const base = normalized.endsWith("-formal") ? normalized.slice(0, -"-formal".length) : normalized.split(/[-_]/u)[0];
|
|
return isSupportedLocale(base) ? base : undefined;
|
|
}
|
|
|
|
function parseAcceptLanguage(value: string | null | undefined): SupportedLocale[] {
|
|
if (!value) return [];
|
|
return value
|
|
.split(",")
|
|
.map((entry, index) => {
|
|
const [tag, ...parameters] = entry.trim().split(";");
|
|
const qualityParameter = parameters.map((parameter) => parameter.trim()).find((parameter) => parameter.startsWith("q="));
|
|
const parsedQuality = qualityParameter ? Number(qualityParameter.slice(2)) : 1;
|
|
return {
|
|
locale: tag === "*" ? undefined : normalizeLocaleCandidate(tag),
|
|
quality: Number.isFinite(parsedQuality) && parsedQuality >= 0 && parsedQuality <= 1 ? parsedQuality : 0,
|
|
index,
|
|
};
|
|
})
|
|
.filter((entry): entry is { locale: SupportedLocale; quality: number; index: number } => Boolean(entry.locale) && entry.quality > 0)
|
|
.sort((left, right) => right.quality - left.quality || left.index - right.index)
|
|
.map((entry) => entry.locale);
|
|
}
|
|
|
|
export type ResolveEnabledLocaleInput = {
|
|
enabledLocales: readonly SupportedLocale[];
|
|
userLocale?: string | null;
|
|
tenantLocale?: string | null;
|
|
cookieLocale?: string | null;
|
|
acceptLanguage?: string | null;
|
|
};
|
|
|
|
export function resolveEnabledLocale(input: ResolveEnabledLocaleInput): SupportedLocale {
|
|
const enabled = new Set<SupportedLocale>(input.enabledLocales);
|
|
const preferred = [
|
|
normalizeLocaleCandidate(input.userLocale),
|
|
normalizeLocaleCandidate(input.tenantLocale),
|
|
normalizeLocaleCandidate(input.cookieLocale),
|
|
...parseAcceptLanguage(input.acceptLanguage),
|
|
];
|
|
for (const locale of preferred) {
|
|
if (locale && enabled.has(locale)) return locale;
|
|
}
|
|
return defaultLocale;
|
|
}
|
|
|
|
export const formalLngs = supportedLocales.map((locale) => `${locale}-formal` as const);
|
|
export type FormalLocale = (typeof formalLngs)[number];
|
|
|
|
export const fallbackLng = {
|
|
"de-formal": ["de"],
|
|
"en-formal": ["en", "de"],
|
|
"pl-formal": ["pl", "de"],
|
|
"ru-formal": ["ru", "de"],
|
|
"uk-formal": ["uk", "de"],
|
|
"hu-formal": ["hu", "de"],
|
|
default: [defaultLocale],
|
|
} as const;
|