@nocobase/portal-template-default 1.0.12 → 1.0.14

package/src/extensions/nocobase-i18n/server-resources.ts

@@ -0,0 +1,166 @@
+import { nocobaseClient } from "@/lib/nocobase/client";
+import {
+  type LocaleSystemSettings,
+  applyDocumentLocale,
+  getCurrentLocale,
+  i18n,
+  registerLocale,
+  setEnabledLocales,
+} from "@/providers/i18n";
+
+type ServerLanguagePayload = {
+  lang?: string;
+  resources?: Record<string, Record<string, string>>;
+};
+
+const serverResourceNamespaces = new Set(["lm-collections"]);
+const loadedServerResourceNamespaces = new Set<string>();
+const namespaceLoadPromises = new Map<string, Promise<void>>();
+let cachedServerResources: ServerLanguagePayload["resources"] = {};
+let serverResourcesPromise: Promise<void> | undefined;
+let bootstrapStarted = false;
+let bootstrapComplete = false;
+
+function mergeNamespace(namespace: string, locale?: string) {
+  const resource = cachedServerResources?.[namespace];
+  if (!locale || !resource) return false;
+  i18n.addResourceBundle(locale, namespace, resource, true, false);
+  loadedServerResourceNamespaces.add(namespace);
+  return true;
+}
+
+async function requestServerResources(
+  namespaces: string[],
+  requestedLocale?: string
+) {
+  const payload = await nocobaseClient.action<ServerLanguagePayload>(
+    "app",
+    "getLang",
+    {
+      method: "GET",
+      query: {
+        ...(requestedLocale ? { locale: requestedLocale } : {}),
+        ...(namespaces.length ? { ns: namespaces.join(",") } : {}),
+      },
+      includeRole: false,
+      withAclMeta: false,
+    }
+  );
+
+  cachedServerResources = {
+    ...cachedServerResources,
+    ...payload.resources,
+  };
+  for (const namespace of namespaces) {
+    mergeNamespace(namespace, payload.lang);
+    loadedServerResourceNamespaces.add(namespace);
+  }
+
+  return payload;
+}
+
+async function ensureServerResourceNamespaces(namespaces: string[]) {
+  const pending: Promise<void>[] = [];
+  const missing: string[] = [];
+
+  for (const namespace of namespaces) {
+    if (loadedServerResourceNamespaces.has(namespace)) continue;
+    if (mergeNamespace(namespace, getCurrentLocale())) continue;
+    const existing = namespaceLoadPromises.get(namespace);
+    if (existing) pending.push(existing);
+    else missing.push(namespace);
+  }
+
+  if (missing.length) {
+    const request = requestServerResources(
+      missing,
+      nocobaseClient.getStoredLocale() ?? getCurrentLocale()
+    ).then(() => undefined);
+    for (const namespace of missing) {
+      namespaceLoadPromises.set(namespace, request);
+    }
+    const cleanup = () => {
+      for (const namespace of missing) {
+        if (namespaceLoadPromises.get(namespace) === request) {
+          namespaceLoadPromises.delete(namespace);
+        }
+      }
+    };
+    void request.then(cleanup, cleanup);
+    pending.push(request);
+  }
+
+  await Promise.all(pending);
+}
+
+export function registerServerResourceNamespace(namespace: string) {
+  if (!namespace) return;
+  serverResourceNamespaces.add(namespace);
+
+  if (
+    mergeNamespace(namespace, getCurrentLocale()) ||
+    !bootstrapStarted ||
+    !bootstrapComplete
+  ) {
+    return;
+  }
+
+  void ensureServerResourceNamespaces([namespace]).catch((error) => {
+    console.warn(
+      `Unable to load NocoBase locale namespace ${namespace}`,
+      error
+    );
+  });
+}
+
+export function getServerResourceNamespaces() {
+  return [...serverResourceNamespaces];
+}
+
+export function loadServerLocaleResources(settings?: LocaleSystemSettings) {
+  if (serverResourcesPromise) return serverResourcesPromise;
+
+  bootstrapStarted = true;
+  const requestedLocale = nocobaseClient.getStoredLocale();
+  const initialNamespaces = [...serverResourceNamespaces];
+  const configuredLocales = Array.isArray(settings?.enabledLanguages)
+    ? settings.enabledLanguages
+    : [];
+  if (configuredLocales.length) setEnabledLocales(configuredLocales);
+  const languagePromise = requestServerResources(
+    initialNamespaces,
+    requestedLocale
+  );
+
+  serverResourcesPromise = languagePromise
+    .then(async (payload) => {
+      const serverLocale = payload.lang;
+
+      if (!configuredLocales.length && serverLocale) {
+        setEnabledLocales([serverLocale]);
+      }
+
+      if (serverLocale) {
+        registerLocale({ locale: serverLocale, label: serverLocale });
+        nocobaseClient.setLocale(serverLocale);
+        await i18n.changeLanguage(serverLocale);
+        applyDocumentLocale(serverLocale);
+      }
+
+      bootstrapComplete = true;
+      const lateNamespaces = [...serverResourceNamespaces].filter(
+        (namespace) => !loadedServerResourceNamespaces.has(namespace)
+      );
+      if (lateNamespaces.length) {
+        await ensureServerResourceNamespaces(lateNamespaces);
+      }
+    })
+    .catch((error) => {
+      bootstrapComplete = true;
+      if (!configuredLocales.length) setEnabledLocales([getCurrentLocale()]);
+      serverResourcesPromise = undefined;
+      throw error;
+    });
+
+  return serverResourcesPromise;
+}

package/src/extensions/nocobase-i18n/tests/i18n-regression.mjs

@@ -0,0 +1,51 @@
+import assert from "node:assert/strict";
+import { createServer } from "vite";
+
+const server = await createServer({
+  appType: "custom",
+  logLevel: "silent",
+  server: { middlewareMode: true },
+});
+
+try {
+  await server.ssrLoadModule("/src/locales/index.ts");
+  const {
+    applySystemLocale,
+    getCurrentLocale,
+    i18n,
+    registerLocaleResources,
+    translate,
+  } = await server.ssrLoadModule("/src/providers/i18n/runtime.ts");
+  const { resolveTranslatableText } =
+    await server.ssrLoadModule("/src/lib/i18n.ts");
+
+  await i18n.changeLanguage("en-US");
+  assert.equal(translate("buttons.create", { ns: "starter" }, "Create"), "Create");
+
+  await i18n.changeLanguage("zh-CN");
+  assert.equal(translate("buttons.create", { ns: "starter" }, "Create"), "新建");
+  assert.equal(resolveTranslatableText('{{t("Admin")}}'), "管理员");
+  assert.equal(
+    resolveTranslatableText("Full permissions", { ns: "starter" }),
+    "全部权限"
+  );
+
+  registerLocaleResources("example-feature", {
+    "en-US": { title: "Example" },
+    "zh-CN": { title: "示例" },
+  });
+  assert.equal(
+    translate("title", { ns: "example-feature" }, "Example"),
+    "示例"
+  );
+
+  await applySystemLocale({
+    appLang: "en-US",
+    enabledLanguages: ["en-US", "zh-CN"],
+  });
+  assert.equal(getCurrentLocale(), "en-US");
+
+  console.log("NocoBase i18n regression tests passed");
+} finally {
+  await server.close();
+}