@nocobase/plugin-localization 2.1.0-alpha.4 → 2.1.0-alpha.40

package/dist/server/plugin.js

@@ -42,17 +42,29 @@ __export(plugin_exports, {
 module.exports = __toCommonJS(plugin_exports);
 var import_server = require("@nocobase/server");
 var import_localization = __toESM(require("./actions/localization"));
+var import_aiTranslate = __toESM(require("./actions/aiTranslate"));
 var import_localizationTexts = __toESM(require("./actions/localizationTexts"));
 var import_resources = __toESM(require("./resources"));
 var import_utils = require("./utils");
 var import_constants = require("./constants");
-var import_source_manager = require("./source-manager");
 var import_utils2 = require("@nocobase/utils");
+var import_localization_ai_translate = require("./tasks/localization-ai-translate");
 var import_package = __toESM(require("../../package.json"));
 class PluginLocalizationServer extends import_server.Plugin {
   resources;
-  sourceManager = new import_source_manager.SourceManager();
+  aiTranslateTaskRegistered = false;
+  localeSourceTextHookKeys = /* @__PURE__ */ new Set();
+  normalizeResourceModule(module2) {
+    const prefix = "resources.";
+    const namespace = module2.startsWith(prefix) ? module2.slice(prefix.length) : module2;
+    const normalizedNamespace = namespace.startsWith(import_server.OFFICIAL_PLUGIN_PREFIX) ? namespace.replace(import_server.OFFICIAL_PLUGIN_PREFIX, "") : namespace;
+    return `${prefix}${normalizedNamespace}`;
+  }
   addNewTexts = async (texts, options) => {
+    texts = texts.map(({ text, module: module2 }) => ({
+      text,
+      module: this.normalizeResourceModule(module2)
+    }));
     texts = await this.resources.filterExists(texts, options == null ? void 0 : options.transaction);
     await this.db.getModel("localizationTexts").bulkCreate(
       texts.map(({ text, module: module2 }) => ({
@@ -88,23 +100,44 @@ class PluginLocalizationServer extends import_server.Plugin {
     });
   };
   afterAdd() {
-    this.app.on("afterLoad", () => this.sourceManager.handleTextsSaved(this.db, this.addNewTexts));
+    this.app.on("afterLoad", () => this.handleLocaleSourceTextsSaved());
+    this.app.on("afterLoad", () => this.registerAITranslateTaskType());
   }
   beforeLoad() {
   }
+  registerAITranslateTaskType() {
+    if (this.aiTranslateTaskRegistered) {
+      return;
+    }
+    try {
+      const taskManager = this.app.container.get("AsyncTaskManager");
+      taskManager.registerTaskType(import_localization_ai_translate.LocalizationAITranslateTask);
+      this.aiTranslateTaskRegistered = true;
+    } catch (error) {
+      this.log.warn("AsyncTaskManager is not available, skip localization AI translate task registration.");
+    }
+  }
   async load() {
+    this.registerAITranslateTaskType();
     this.app.resourceManager.define({
       name: "localizationTexts",
       actions: import_localizationTexts.default
     });
     this.app.resourceManager.define({
       name: "localization",
-      actions: import_localization.default
+      actions: {
+        ...import_localization.default,
+        ...import_aiTranslate.default
+      }
     });
     this.app.acl.registerSnippet({
       name: `pm.${this.name}.localization`,
       actions: ["localization:*", "localizationTexts:*", "localizationTranslations:*"]
     });
+    this.app.acl.registerSnippet({
+      name: "ui.localization",
+      actions: ["localizationTexts:missing"]
+    });
     this.app.localeManager.registerResourceStorer("plugin-localization", {
       getResources: (lang) => this.resources.getResources(lang),
       reset: () => this.resources.reset()
@@ -115,24 +148,22 @@ class PluginLocalizationServer extends import_server.Plugin {
       store: "memory"
     });
     this.resources = new import_resources.default(this.db, cache);
-    this.sourceManager.registerSource("local", {
+    this.app.localeManager.registerSource("local", {
       title: (0, import_utils2.tval)("System & Plugins", { ns: import_package.default.name }),
       sync: async (ctx) => {
-        const resources = await ctx.app.localeManager.getCacheResources(ctx.get("X-Locale") || "en-US");
+        const resources = await ctx.app.localeManager.getBuiltInResources(ctx.get("X-Locale") || "en-US");
         const result = {};
         Object.entries(resources).forEach(([module2, resource]) => {
-          if (module2.startsWith(import_server.OFFICIAL_PLUGIN_PREFIX)) {
-            const name = module2.replace(import_server.OFFICIAL_PLUGIN_PREFIX, "");
-            if (resources[name]) {
-              return;
-            }
-          }
-          result[module2] = resource;
+          const name = module2.startsWith(import_server.OFFICIAL_PLUGIN_PREFIX) ? module2.replace(import_server.OFFICIAL_PLUGIN_PREFIX, "") : module2;
+          result[name] = {
+            ...result[name] || {},
+            ...resource
+          };
         });
         return result;
       }
     });
-    this.sourceManager.registerSource("db", {
+    this.app.localeManager.registerSource("db", {
       title: (0, import_utils2.tval)("Collections & Fields", { ns: import_package.default.name }),
       namespace: import_constants.NAMESPACE_COLLECTIONS,
       sync: async (ctx) => {
@@ -181,6 +212,37 @@ class PluginLocalizationServer extends import_server.Plugin {
       await this.addNewTexts(texts, options);
     });
   }
+  handleLocaleSourceTextsSaved() {
+    for (const [sourceName, source] of this.app.localeManager.sources.getEntities()) {
+      if (!source.collections) {
+        continue;
+      }
+      for (const [index, collectionOptions] of source.collections.entries()) {
+        const hookKey = `${sourceName}:${index}:${collectionOptions.collection}`;
+        if (this.localeSourceTextHookKeys.has(hookKey)) {
+          continue;
+        }
+        this.localeSourceTextHookKeys.add(hookKey);
+        this.db.on(`${collectionOptions.collection}.afterSave`, async (instance, options) => {
+          let texts = [];
+          if (collectionOptions.getTexts) {
+            texts = await collectionOptions.getTexts(instance, options);
+          } else {
+            const fields = collectionOptions.fields || [];
+            const changedFields = fields.filter((field) => instance["_changed"].has(field));
+            if (!changedFields.length) {
+              return;
+            }
+            texts = changedFields.map((field) => instance.get(field)).filter(Boolean).map((text) => ({ text, module: `resources.${source.namespace}` }));
+          }
+          if (!(texts == null ? void 0 : texts.length)) {
+            return;
+          }
+          await this.addNewTexts(texts, options);
+        });
+      }
+    }
+  }
   async handleSyncMessage(message) {
     switch (message.type) {
       case "updateCacheTexts":

package/dist/server/tasks/localization-ai-translate.d.ts

@@ -0,0 +1,48 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { TaskType } from '@nocobase/plugin-async-task-manager';
+import type { LocalizationTextRecord } from '../translation-scope';
+export declare const LOCALIZATION_AI_TRANSLATE_TASK_TYPE = "localization:ai-translate";
+export declare const pickBuiltInResourceReference: (row: LocalizationTextRecord, references: Map<string, Map<string, string>>, locales: ReferenceLocaleConfig) => {
+    locale: string;
+    translation: string;
+} | {
+    locale?: undefined;
+    translation?: undefined;
+};
+type ReferenceLocaleConfig = {
+    primary?: string;
+    fallback?: string;
+};
+export type TranslationReferenceLocales = {
+    builtIn?: ReferenceLocaleConfig;
+    custom?: ReferenceLocaleConfig;
+};
+export declare class LocalizationAITranslateTask extends TaskType {
+    static type: string;
+    execute(): Promise<{
+        translated: number;
+        total: number;
+    }>;
+    private countTexts;
+    private getLocaleReferences;
+    private getReferenceMaps;
+    private getBuiltInReferenceMaps;
+    private pickDbReference;
+    private getSystemDefaultLocale;
+    private resolveReferenceLocales;
+    private buildTranslationItems;
+    private translateItem;
+    private translateText;
+    private getEmployeeSystemPrompt;
+    private buildProviderContext;
+    private getLanguageName;
+    private extractTextContent;
+}
+export {};