@tachybase/plugin-i18n-editor 0.23.8

package/dist/server/migrations/20231206161851-fix-module.d.ts

@@ -0,0 +1,6 @@
+import { Migration } from '@tachybase/server';
+export default class FixModuleMigration extends Migration {
+    appVersion: string;
+    up(): Promise<void>;
+    down(): Promise<void>;
+}

package/dist/server/migrations/20231206161851-fix-module.js

@@ -0,0 +1,91 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fix_module_exports = {};
+__export(fix_module_exports, {
+  default: () => FixModuleMigration
+});
+module.exports = __toCommonJS(fix_module_exports);
+var import_database = require("@tachybase/database");
+var import_server = require("@tachybase/server");
+var import_localization = require("../actions/localization");
+var import_constans = require("../constans");
+class FixModuleMigration extends import_server.Migration {
+  appVersion = "<0.17.0-alpha.3";
+  async up() {
+    const result = await this.app.version.satisfies("<=0.17.0-alpha.4");
+    if (!result) {
+      return;
+    }
+    const resources = await this.app.localeManager.getCacheResources("zh-CN");
+    const menus = await (0, import_localization.getTextsFromMenu)(this.context.db, true);
+    const collections = await (0, import_localization.getTextsFromDB)(this.context.db);
+    const db = this.context.db;
+    await db.getCollection("localizationTexts").sync();
+    await db.sequelize.transaction(async (t) => {
+      const menuTexts = Object.keys(menus);
+      await db.getModel("localizationTexts").update(
+        {
+          module: `resources.${import_constans.NAMESPACE_MENUS}`
+        },
+        {
+          where: {
+            text: {
+              [import_database.Op.in]: menuTexts
+            }
+          },
+          transaction: t
+        }
+      );
+      const collectionTexts = Object.keys(collections);
+      await db.getModel("localizationTexts").update(
+        {
+          module: `resources.${import_constans.NAMESPACE_COLLECTIONS}`
+        },
+        {
+          where: {
+            text: {
+              [import_database.Op.in]: collectionTexts
+            }
+          },
+          transaction: t
+        }
+      );
+      for (const [module2, resource] of Object.entries(resources)) {
+        if (module2 === "client") {
+          continue;
+        }
+        const texts = Object.keys(resource);
+        await db.getModel("localizationTexts").update(
+          {
+            module: `resources.${module2}`
+          },
+          {
+            where: {
+              text: {
+                [import_database.Op.in]: texts
+              }
+            },
+            transaction: t
+          }
+        );
+      }
+    });
+  }
+  async down() {
+  }
+}

package/dist/server/plugin.d.ts

@@ -0,0 +1,15 @@
+import { ModuleUiSchema } from '@tachybase/module-ui-schema';
+import { InstallOptions, Plugin } from '@tachybase/server';
+import Resources from './resources';
+export declare class LocalizationManagementPlugin extends Plugin {
+    resources: Resources;
+    registerUISchemahook(plugin?: ModuleUiSchema): void;
+    afterAdd(): void;
+    beforeLoad(): void;
+    load(): Promise<void>;
+    install(options?: InstallOptions): Promise<void>;
+    afterEnable(): Promise<void>;
+    afterDisable(): Promise<void>;
+    remove(): Promise<void>;
+}
+export default LocalizationManagementPlugin;

package/dist/server/plugin.js

@@ -0,0 +1,162 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plugin_exports = {};
+__export(plugin_exports, {
+  LocalizationManagementPlugin: () => LocalizationManagementPlugin,
+  default: () => plugin_default
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_server = require("@tachybase/server");
+var import_deepmerge = __toESM(require("deepmerge"));
+var import_localization = __toESM(require("./actions/localization"));
+var import_localizationTexts = __toESM(require("./actions/localizationTexts"));
+var import_constans = require("./constans");
+var import_resources = __toESM(require("./resources"));
+var import_utils = require("./utils");
+class LocalizationManagementPlugin extends import_server.Plugin {
+  resources;
+  registerUISchemahook(plugin) {
+    const uiSchemaStoragePlugin = plugin || this.app.getPlugin("ui-schema");
+    if (!uiSchemaStoragePlugin) {
+      return;
+    }
+    uiSchemaStoragePlugin.serverHooks.register("onSelfSave", "extractTextToLocale", async ({ schemaInstance }) => {
+      var _a;
+      const module2 = `resources.${import_constans.NAMESPACE_MENUS}`;
+      const schema = schemaInstance.get("schema");
+      const title = (schema == null ? void 0 : schema.title) || ((_a = schema == null ? void 0 : schema["x-component-props"]) == null ? void 0 : _a.title);
+      if (!title) {
+        return;
+      }
+      const result = await this.resources.filterExists([{ text: title, module: module2 }]);
+      if (!result.length) {
+        return;
+      }
+      this.db.getRepository("localizationTexts").create({
+        values: {
+          module: module2,
+          text: title
+        }
+      }).then((res) => this.resources.updateCacheTexts([res])).catch((err) => {
+      });
+    });
+  }
+  afterAdd() {
+  }
+  beforeLoad() {
+  }
+  async load() {
+    this.app.resourcer.define({
+      name: "localizationTexts",
+      actions: import_localizationTexts.default
+    });
+    this.app.resourcer.define({
+      name: "localization",
+      actions: import_localization.default
+    });
+    this.app.acl.registerSnippet({
+      name: `pm.${this.name}.localization`,
+      actions: ["localization:*", "localizationTexts:*", "localizationTranslations:*"]
+    });
+    this.db.on("afterSave", async (instance, options) => {
+      const module2 = `resources.${import_constans.NAMESPACE_COLLECTIONS}`;
+      const model = instance.constructor;
+      const collection = model.collection;
+      if (!collection) {
+        return;
+      }
+      let texts = [];
+      const fields = Array.from(collection.fields.values()).filter((field) => {
+        var _a;
+        return ((_a = field.options) == null ? void 0 : _a.translation) && instance["_changed"].has(field.name);
+      }).map((field) => field.name);
+      if (!fields.length) {
+        return;
+      }
+      const textsFromDB = (0, import_utils.getTextsFromDBRecord)(fields, instance);
+      textsFromDB.forEach((text) => {
+        texts.push({ text, module: module2 });
+      });
+      texts = await this.resources.filterExists(texts, options == null ? void 0 : options.transaction);
+      this.db.getModel("localizationTexts").bulkCreate(
+        texts.map(({ text, module: module3 }) => ({
+          module: module3,
+          text
+        })),
+        {
+          transaction: options == null ? void 0 : options.transaction
+        }
+      ).then((newTexts) => this.resources.updateCacheTexts(newTexts, options == null ? void 0 : options.transaction)).catch((err) => {
+      });
+    });
+    const cache = await this.app.cacheManager.createCache({
+      name: "localization",
+      prefix: "localization",
+      store: "memory"
+    });
+    this.resources = new import_resources.default(this.db, cache);
+    this.registerUISchemahook();
+    this.app.resourcer.use(async (ctx, next) => {
+      await next();
+      const { resourceName, actionName } = ctx.action;
+      if (resourceName === "app" && actionName === "getLang") {
+        const custom = await this.resources.getResources(ctx.get("X-Locale") || "en-US");
+        const appLang = ctx.body;
+        const resources = { ...appLang.resources };
+        Object.keys(custom).forEach((key) => {
+          const module2 = key.replace("resources.", "");
+          const resource = appLang.resources[module2];
+          const customResource = custom[key];
+          resources[module2] = resource ? (0, import_deepmerge.default)(resource, customResource) : customResource;
+        });
+        ctx.body = {
+          ...appLang,
+          resources
+        };
+      }
+    });
+  }
+  async install(options) {
+  }
+  async afterEnable() {
+  }
+  async afterDisable() {
+    const uiSchemaStoragePlugin = this.app.getPlugin("ui-schema");
+    if (!uiSchemaStoragePlugin) {
+      return;
+    }
+    uiSchemaStoragePlugin.serverHooks.remove("onSelfSave", "extractTextToLocale");
+  }
+  async remove() {
+  }
+}
+var plugin_default = LocalizationManagementPlugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LocalizationManagementPlugin
+});

package/dist/server/resources.d.ts

@@ -0,0 +1,19 @@
+import { Cache } from '@tachybase/cache';
+import { Database, Transaction } from '@tachybase/database';
+export default class Resources {
+    cache: Cache;
+    db: Database;
+    constructor(db: Database, cache: Cache);
+    getTexts(transaction?: Transaction): Promise<any>;
+    getTranslations(locale: string): Promise<any>;
+    getResources(locale: string): Promise<{}>;
+    filterExists(texts: {
+        text: string;
+        module: string;
+    }[], transaction?: Transaction): Promise<{
+        text: string;
+        module: string;
+    }[]>;
+    updateCacheTexts(texts: any[], transaction?: Transaction): Promise<void>;
+    resetCache(locale: string): Promise<void>;
+}

package/dist/server/resources.js

@@ -0,0 +1,86 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var resources_exports = {};
+__export(resources_exports, {
+  default: () => Resources
+});
+module.exports = __toCommonJS(resources_exports);
+class Resources {
+  cache;
+  db;
+  constructor(db, cache) {
+    this.cache = cache;
+    this.db = db;
+  }
+  async getTexts(transaction) {
+    return await this.cache.wrap(`texts`, async () => {
+      return await this.db.getRepository("localizationTexts").find({
+        fields: ["id", "module", "text"],
+        raw: true,
+        transaction
+      });
+    });
+  }
+  async getTranslations(locale) {
+    return await this.cache.wrap(`translations:${locale}`, async () => {
+      return await this.db.getRepository("localizationTranslations").find({
+        fields: ["textId", "translation"],
+        filter: { locale },
+        raw: true
+      });
+    });
+  }
+  async getResources(locale) {
+    const [texts, translations] = await Promise.all([this.getTexts(), this.getTranslations(locale)]);
+    const resources = {};
+    const textsMap = texts.reduce((map, item) => {
+      map[item.id] = item;
+      return map;
+    }, {});
+    translations.forEach((item) => {
+      const text = textsMap[item.textId];
+      if (!text) {
+        return;
+      }
+      const module2 = text.module;
+      if (!resources[module2]) {
+        resources[module2] = {};
+      }
+      resources[module2][text.text] = item.translation;
+    });
+    return resources;
+  }
+  async filterExists(texts, transaction) {
+    const existTexts = await this.getTexts(transaction);
+    return texts.filter((text) => {
+      return !existTexts.find((item) => item.text === text.text && item.module === text.module);
+    });
+  }
+  async updateCacheTexts(texts, transaction) {
+    const newTexts = texts.map((text) => ({
+      id: text.id,
+      module: text.module,
+      text: text.text
+    }));
+    const existTexts = await this.getTexts(transaction);
+    await this.cache.set(`texts`, [...existTexts, ...newTexts]);
+  }
+  async resetCache(locale) {
+    await this.cache.del(`translations:${locale}`);
+  }
+}

package/dist/server/utils.d.ts

@@ -0,0 +1,3 @@
+export declare const compile: (title: string) => string;
+export declare const getTextsFromUISchema: (schema: any) => any[];
+export declare const getTextsFromDBRecord: (fields: string[], record: any) => any[];

package/dist/server/utils.js

@@ -0,0 +1,79 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  compile: () => compile,
+  getTextsFromDBRecord: () => getTextsFromDBRecord,
+  getTextsFromUISchema: () => getTextsFromUISchema
+});
+module.exports = __toCommonJS(utils_exports);
+const compile = (title) => (title || "").replace(/{{\s*t\(["|'|`](.*)["|'|`]\)\s*}}/g, "$1");
+const getTextsFromUISchema = (schema) => {
+  var _a, _b, _c, _d;
+  const texts = [];
+  const title = compile(schema.title);
+  const componentPropsTitle = compile((_a = schema["x-component-props"]) == null ? void 0 : _a.title);
+  const decoratorPropsTitle = compile((_b = schema["x-decorator-props"]) == null ? void 0 : _b.title);
+  if (title) {
+    texts.push(title);
+  }
+  if (componentPropsTitle) {
+    texts.push(componentPropsTitle);
+  }
+  if (decoratorPropsTitle) {
+    texts.push(decoratorPropsTitle);
+  }
+  if ((_d = (_c = schema["x-data-templates"]) == null ? void 0 : _c.items) == null ? void 0 : _d.length) {
+    schema["x-data-templates"].items.forEach((item) => {
+      const title2 = compile(item.title);
+      if (title2) {
+        texts.push(title2);
+      }
+    });
+  }
+  return texts;
+};
+const getTextsFromDBRecord = (fields, record) => {
+  const texts = [];
+  fields.forEach((field) => {
+    var _a, _b;
+    const value = record[field];
+    if (typeof value === "string") {
+      texts.push(compile(value));
+    }
+    if (typeof value === "object") {
+      if ((_a = value == null ? void 0 : value.uiSchema) == null ? void 0 : _a.title) {
+        texts.push(compile(value.uiSchema.title));
+      }
+      if ((_b = value == null ? void 0 : value.uiSchema) == null ? void 0 : _b.enum) {
+        value.uiSchema.enum.forEach((item) => {
+          if (item == null ? void 0 : item.label) {
+            texts.push(compile(item.label));
+          }
+        });
+      }
+    }
+  });
+  return texts;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compile,
+  getTextsFromDBRecord,
+  getTextsFromUISchema
+});

package/dist/swagger/index.json

@@ -0,0 +1,156 @@
+{
+  "info": {
+    "title": "TachyBase API - Localization management plugin"
+  },
+  "openapi": "3.0.2",
+  "paths": {
+    "/localization:sync": {
+      "post": {
+        "tags": ["localization"],
+        "description": "Synchronize localization resources",
+        "parameters": [
+          {
+            "name": "X-Locale",
+            "in": "header",
+            "defalut": "en-US",
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "type": {
+                    "type": "array",
+                    "items": {
+                      "type": "string",
+                      "enum": ["local", "menu", "db"]
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "OK"
+          }
+        }
+      }
+    },
+    "/localization:publish": {
+      "post": {
+        "tags": ["localization"],
+        "description": "Publish localization resources (Reset cache)",
+        "parameters": [
+          {
+            "name": "X-Locale",
+            "in": "header",
+            "defalut": "en-US",
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "OK"
+          }
+        }
+      }
+    },
+    "/localizationTexts:list": {
+      "get": {
+        "tags": ["localizationTexts"],
+        "description": "Retrive localization texts with translations",
+        "parameters": [
+          {
+            "name": "X-Locale",
+            "in": "header",
+            "defalut": "en-US",
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "name": "keyword",
+            "in": "query",
+            "description": "Search keyword",
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "name": "hasTranslation",
+            "in": "query",
+            "description": "true - list all, false - list only untranslated",
+            "schema": {
+              "type": "boolean"
+            },
+            "defalut": true
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "OK"
+          }
+        }
+      }
+    },
+    "/localizationTranslations:updateOrCreate": {
+      "post": {
+        "tags": ["localizationTranslations"],
+        "description": "Update or create localization translations",
+        "parameters": [
+          {
+            "name": "textId",
+            "in": "query",
+            "schema": {
+              "type": "integer"
+            },
+            "required": true
+          },
+          {
+            "name": "locale",
+            "in": "query",
+            "schema": {
+              "type": "string"
+            },
+            "required": true
+          }
+        ],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "textId": {
+                    "type": "integer"
+                  },
+                  "locale": {
+                    "type": "string"
+                  },
+                  "translation": {
+                    "type": "string"
+                  }
+                }
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "OK"
+          }
+        }
+      }
+    }
+  },
+  "tags": []
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@tachybase/plugin-i18n-editor",
+  "displayName": "Localization",
+  "version": "0.23.8",
+  "description": "Allows to manage localization resources of the application.",
+  "keywords": [
+    "System management"
+  ],
+  "license": "Apache-2.0",
+  "main": "dist/server/index.js",
+  "devDependencies": {
+    "@ant-design/icons": "^5.5.2",
+    "ahooks": "^3.8.4",
+    "antd": "5.22.5",
+    "deepmerge": "^4.3.1",
+    "react-i18next": "^15.2.0",
+    "@tachybase/schema": "0.23.8"
+  },
+  "peerDependencies": {
+    "@tachybase/actions": "0.23.8",
+    "@tachybase/client": "0.23.8",
+    "@tachybase/server": "0.23.8",
+    "@tachybase/test": "0.23.8",
+    "@tachybase/cache": "0.23.8",
+    "@tachybase/database": "0.23.8",
+    "@tachybase/module-ui-schema": "0.23.8",
+    "@tachybase/module-web": "0.23.8"
+  },
+  "description.zh-CN": "支持管理应用程序的本地化资源。",
+  "displayName.zh-CN": "本地化",
+  "scripts": {
+    "build": "tachybase-build --no-dts @tachybase/plugin-i18n-editor"
+  }
+}

package/server.d.ts

@@ -0,0 +1,3 @@
+// @ts-nocheck
+export * from './dist/server';
+export { default } from './dist/server';