@nocobase/portal-template-default 1.0.2 → 1.0.4

package/{registry/nocobase-i18n → src/providers/i18n}/runtime.ts

@@ -3,6 +3,7 @@ import { createInstance, type TOptions } from "i18next";
 import {
   getTranslationResources,
   registerTranslationResources,
+  setTranslationResolver,
   subscribeTranslationResources,
   type TranslationOptions,
 } from "@/lib/i18n";
@@ -14,15 +15,23 @@ import {
   getLocaleLabel,
   registerLocale,
   resolveSupportedLocale,
+  setEnabledLocales,
 } from "./locale-store";
-import enUS from "./locales/en-US";
-import zhCN from "./locales/zh-CN";
 
 export type LocaleResources = Record<
   string,
   Record<string, string | number | boolean>
 >;
 
+export type LocaleSystemSettings = {
+  appLang?: string | null;
+  enabledLanguages?: string[] | null;
+};
+
+type LocalePersistence = (locale: string) => void | Promise<void>;
+
+let localePersistence: LocalePersistence | undefined;
+
 export const i18n = createInstance();
 
 void i18n.init({
@@ -36,10 +45,6 @@ void i18n.init({
   interpolation: {
     escapeValue: false,
   },
-  resources: {
-    "en-US": enUS,
-    "zh-CN": zhCN,
-  },
 });
 
 function addLocaleResources(namespace: string, resources: LocaleResources) {
@@ -56,7 +61,6 @@ function addLocaleResources(namespace: string, resources: LocaleResources) {
 getTranslationResources().forEach(([namespace, resources]) =>
   addLocaleResources(namespace, resources)
 );
-
 subscribeTranslationResources(addLocaleResources);
 
 export function getCurrentLocale() {
@@ -94,18 +98,60 @@ export function applyDocumentLocale(locale = getCurrentLocale()) {
   document.documentElement.dir = direction;
 }
 
+function resolveSystemLocale(settings?: LocaleSystemSettings) {
+  const enabledLanguages = Array.isArray(settings?.enabledLanguages)
+    ? settings.enabledLanguages.filter(Boolean)
+    : [];
+  const storedLocale = nocobaseClient.getStoredLocale();
+
+  if (
+    storedLocale &&
+    (!enabledLanguages.length || enabledLanguages.includes(storedLocale))
+  ) {
+    return resolveSupportedLocale(storedLocale);
+  }
+
+  const defaultLocale =
+    settings?.appLang || enabledLanguages[0] || DEFAULT_LOCALE;
+  return resolveSupportedLocale(defaultLocale);
+}
+
+export async function applySystemLocale(settings?: LocaleSystemSettings) {
+  const enabledLanguages = Array.isArray(settings?.enabledLanguages)
+    ? settings.enabledLanguages.filter(Boolean)
+    : [];
+  if (enabledLanguages.length) setEnabledLocales(enabledLanguages);
+
+  const storedLocale = nocobaseClient.getStoredLocale();
+  if (
+    storedLocale &&
+    enabledLanguages.length &&
+    !enabledLanguages.includes(storedLocale)
+  ) {
+    nocobaseClient.setLocale(null);
+  }
+
+  const locale = resolveSystemLocale(settings);
+  nocobaseClient.setRuntimeLocale(locale);
+  await i18n.changeLanguage(locale);
+  applyDocumentLocale(locale);
+  return locale;
+}
+
+export function setLocalePersistence(persistence?: LocalePersistence) {
+  localePersistence = persistence;
+  return () => {
+    if (localePersistence === persistence) localePersistence = undefined;
+  };
+}
+
 export async function changeLocale(locale: string) {
   const nextLocale = resolveSupportedLocale(locale);
 
-  if (nocobaseClient.getToken()) {
-    try {
-      await nocobaseClient.action("users", "updateLang", {
-        method: "POST",
-        body: { appLang: nextLocale },
-      });
-    } catch (error) {
-      console.warn("Unable to persist the NocoBase language preference", error);
-    }
+  try {
+    await localePersistence?.(nextLocale);
+  } catch (error) {
+    console.warn("Unable to persist the language preference", error);
   }
 
   nocobaseClient.setLocale(nextLocale);
@@ -115,4 +161,5 @@ export async function changeLocale(locale: string) {
   if (typeof window !== "undefined") window.location.reload();
 }
 
+setTranslationResolver(translate);
 applyDocumentLocale();

package/src/providers/system-settings/context.ts

@@ -0,0 +1,26 @@
+import { createContext, useContext } from "react";
+
+export type SystemSettings = Record<string, unknown> & {
+  appLang?: string | null;
+  enabledLanguages?: string[] | null;
+};
+
+export type SystemSettingsContextValue = {
+  settings?: SystemSettings;
+  error?: Error;
+  loading: boolean;
+  refresh: () => Promise<SystemSettings | undefined>;
+};
+
+export const SystemSettingsContext =
+  createContext<SystemSettingsContextValue | null>(null);
+
+export function useSystemSettings() {
+  const value = useContext(SystemSettingsContext);
+  if (!value) {
+    throw new Error(
+      "useSystemSettings must be used inside SystemSettingsProvider"
+    );
+  }
+  return value;
+}

package/src/providers/system-settings/index.ts

@@ -0,0 +1,2 @@
+export * from "./context";
+export * from "./provider";

package/src/providers/system-settings/provider.tsx

@@ -0,0 +1,94 @@
+import {
+  useCallback,
+  useEffect,
+  useMemo,
+  useState,
+  type PropsWithChildren,
+} from "react";
+
+import { LoadingState } from "@/components/app-shell/loading-state";
+import { nocobaseClient } from "@/lib/nocobase/client";
+import { applySystemLocale } from "../i18n";
+import {
+  SystemSettingsContext,
+  type SystemSettings,
+  type SystemSettingsContextValue,
+} from "./context";
+
+let cachedSettings: SystemSettings | undefined;
+let settingsRequest: Promise<SystemSettings> | undefined;
+
+function requestSystemSettings(force = false) {
+  if (!force && cachedSettings) return Promise.resolve(cachedSettings);
+  if (!force && settingsRequest) return settingsRequest;
+
+  const request = nocobaseClient
+    .action<SystemSettings>("systemSettings", "get", {
+      method: "GET",
+      includeRole: false,
+      withAclMeta: false,
+    })
+    .then((settings) => {
+      cachedSettings = settings;
+      return settings;
+    });
+
+  settingsRequest = request;
+  const clearRequest = () => {
+    if (settingsRequest === request) settingsRequest = undefined;
+  };
+  void request.then(clearRequest, clearRequest);
+  return request;
+}
+
+export function SystemSettingsProvider({ children }: PropsWithChildren) {
+  const [settings, setSettings] = useState(cachedSettings);
+  const [error, setError] = useState<Error>();
+  const [ready, setReady] = useState(false);
+  const [loading, setLoading] = useState(true);
+
+  const load = useCallback(async (force = false) => {
+    setLoading(true);
+    try {
+      const nextSettings = await requestSystemSettings(force);
+      await applySystemLocale(nextSettings);
+      setSettings(nextSettings);
+      setError(undefined);
+      return nextSettings;
+    } catch (reason) {
+      const nextError =
+        reason instanceof Error
+          ? reason
+          : new Error("Unable to load system settings");
+      console.warn("Unable to load NocoBase system settings", reason);
+      setError(nextError);
+      await applySystemLocale();
+      return undefined;
+    } finally {
+      setLoading(false);
+      setReady(true);
+    }
+  }, []);
+
+  useEffect(() => {
+    void load();
+  }, [load]);
+
+  const value = useMemo<SystemSettingsContextValue>(
+    () => ({
+      settings,
+      error,
+      loading,
+      refresh: () => load(true),
+    }),
+    [error, load, loading, settings]
+  );
+
+  if (!ready) return <LoadingState className="min-h-svh" />;
+
+  return (
+    <SystemSettingsContext.Provider value={value}>
+      {children}
+    </SystemSettingsContext.Provider>
+  );
+}