Refresh HiveGrid Cloud reference snapshot

This commit is contained in:
david committed 2026-08-03 15:31:14 +02:00
1 parent 5e99e14772
commit 7f88026f79
5955 files changed
+1177325 -188362

No files matched your search

@@ -0,0 +1,143 @@
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;