@tachybase/plugin-i18n-editor 0.23.8

package/dist/server/actions/localization.js

@@ -0,0 +1,225 @@
+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 localization_exports = {};
+__export(localization_exports, {
+  default: () => localization_default,
+  getResources: () => getResources,
+  getTextsFromDB: () => getTextsFromDB,
+  getTextsFromMenu: () => getTextsFromMenu,
+  getUISchemas: () => getUISchemas
+});
+module.exports = __toCommonJS(localization_exports);
+var import_database = require("@tachybase/database");
+var import_constans = require("../constans");
+var import_utils = require("../utils");
+const getResourcesInstance = async (ctx) => {
+  const plugin = ctx.app.getPlugin("localization-management");
+  return plugin.resources;
+};
+const getResources = async (ctx) => {
+  const resources = await ctx.app.localeManager.getCacheResources(ctx.get("X-Locale") || "en-US");
+  return { ...resources };
+};
+const getUISchemas = async (db) => {
+  const uiSchemas = await db.getModel("uiSchemas").findAll({
+    attributes: ["schema"],
+    where: {
+      [import_database.Op.or]: [
+        {
+          schema: {
+            title: {
+              [import_database.Op.ne]: null
+            }
+          }
+        },
+        {
+          schema: {
+            "x-component-props": {
+              title: {
+                [import_database.Op.ne]: null
+              }
+            }
+          }
+        },
+        {
+          schema: {
+            "x-decorator-props": {
+              title: {
+                [import_database.Op.ne]: null
+              }
+            }
+          }
+        },
+        {
+          schema: {
+            "x-data-templates": {
+              [import_database.Op.ne]: null
+            }
+          }
+        }
+      ]
+    }
+  });
+  return uiSchemas;
+};
+const getTextsFromUISchemas = async (db) => {
+  const result = {};
+  const schemas = await getUISchemas(db);
+  schemas.forEach((schema) => {
+    const texts = (0, import_utils.getTextsFromUISchema)(schema.schema);
+    texts.forEach((text) => result[text] = "");
+  });
+  return result;
+};
+const getTextsFromDB = async (db) => {
+  const result = {};
+  const collections = Array.from(db.collections.values());
+  for (const collection of collections) {
+    const fields = Array.from(collection.fields.values()).filter((field) => {
+      var _a;
+      return (_a = field.options) == null ? void 0 : _a.translation;
+    }).map((field) => field.name);
+    if (!fields.length) {
+      continue;
+    }
+    const repo = db.getRepository(collection.name);
+    const records = await repo.find({ fields });
+    records.forEach((record) => {
+      const texts = (0, import_utils.getTextsFromDBRecord)(fields, record);
+      texts.forEach((text) => result[text] = "");
+    });
+  }
+  return result;
+};
+const getSchemaUid = async (db, migrate = false) => {
+  if (migrate) {
+    const systemSettings = await db.getRepository("systemSettings").findOne();
+    const options = (systemSettings == null ? void 0 : systemSettings.options) || {};
+    const { adminSchemaUid, mobileSchemaUid } = options;
+    return { adminSchemaUid, mobileSchemaUid };
+  }
+  return { adminSchemaUid: "default-admin-menu", mobileSchemaUid: "default-admin-mobile" };
+};
+const getTextsFromMenu = async (db, migrate = false) => {
+  var _a, _b, _c, _d;
+  const result = {};
+  const { adminSchemaUid, mobileSchemaUid } = await getSchemaUid(db, migrate);
+  const repo = db.getRepository("uiSchemas");
+  if (adminSchemaUid) {
+    const schema = await repo.getProperties(adminSchemaUid);
+    const extractTitle = (schema2) => {
+      if (schema2 == null ? void 0 : schema2.properties) {
+        Object.values(schema2.properties).forEach((item) => {
+          if (item.title) {
+            result[item.title] = "";
+          }
+          extractTitle(item);
+        });
+      }
+    };
+    extractTitle(schema);
+  }
+  if (mobileSchemaUid) {
+    const schema = await repo.getProperties(mobileSchemaUid);
+    if ((_b = (_a = schema == null ? void 0 : schema["properties"]) == null ? void 0 : _a.tabBar) == null ? void 0 : _b.properties) {
+      Object.values((_d = (_c = schema["properties"]) == null ? void 0 : _c.tabBar) == null ? void 0 : _d.properties).forEach((item) => {
+        var _a2;
+        const title = (_a2 = item["x-component-props"]) == null ? void 0 : _a2.title;
+        if (title) {
+          result[title] = "";
+        }
+      });
+    }
+  }
+  return result;
+};
+const sync = async (ctx, next) => {
+  const startTime = Date.now();
+  ctx.logger.info("Start sync localization resources");
+  const resourcesInstance = await getResourcesInstance(ctx);
+  const locale = ctx.get("X-Locale") || "en-US";
+  const { type = [] } = ctx.action.params.values || {};
+  if (!type.length) {
+    ctx.throw(400, ctx.t("Please provide synchronization source."));
+  }
+  let resources = { client: {} };
+  if (type.includes("local")) {
+    resources = await getResources(ctx);
+  }
+  if (type.includes("menu")) {
+    const menuTexts = await getTextsFromMenu(ctx.db);
+    resources[import_constans.NAMESPACE_MENUS] = {
+      ...menuTexts
+    };
+  }
+  if (type.includes("db")) {
+    const dbTexts = await getTextsFromDB(ctx.db);
+    resources[import_constans.NAMESPACE_COLLECTIONS] = {
+      ...dbTexts
+    };
+  }
+  let textValues = [];
+  Object.entries(resources).forEach(([module2, resource]) => {
+    Object.keys(resource).forEach((text) => {
+      textValues.push({ module: `resources.${module2}`, text });
+    });
+  });
+  textValues = await resourcesInstance.filterExists(textValues);
+  await ctx.db.sequelize.transaction(async (t) => {
+    const newTexts = await ctx.db.getModel("localizationTexts").bulkCreate(textValues, {
+      transaction: t
+    });
+    const texts = await ctx.db.getModel("localizationTexts").findAll({
+      include: [{ association: "translations", where: { locale }, required: false }],
+      where: { "$translations.id$": null },
+      transaction: t
+    });
+    const translationValues = texts.filter((text) => {
+      var _a;
+      const module2 = text.module.replace("resources.", "");
+      return (_a = resources[module2]) == null ? void 0 : _a[text.text];
+    }).map((text) => {
+      var _a;
+      const module2 = text.module.replace("resources.", "");
+      return {
+        locale,
+        textId: text.id,
+        translation: (_a = resources[module2]) == null ? void 0 : _a[text.text]
+      };
+    });
+    await ctx.db.getModel("localizationTranslations").bulkCreate(translationValues, {
+      transaction: t
+    });
+    await resourcesInstance.updateCacheTexts(newTexts);
+  });
+  ctx.logger.info(`Sync localization resources done, ${Date.now() - startTime}ms`);
+  await next();
+};
+const publish = async (ctx, next) => {
+  const resources = await getResourcesInstance(ctx);
+  ctx.body = await resources.resetCache(ctx.get("X-Locale") || "en-US");
+  await next();
+};
+var localization_default = { publish, sync };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getResources,
+  getTextsFromDB,
+  getTextsFromMenu,
+  getUISchemas
+});

package/dist/server/actions/localizationTexts.d.ts

@@ -0,0 +1,5 @@
+import { Context, Next } from '@tachybase/actions';
+declare const _default: {
+    list: (ctx: Context, next: Next) => Promise<void>;
+};
+export default _default;

package/dist/server/actions/localizationTexts.js

@@ -0,0 +1,130 @@
+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 localizationTexts_exports = {};
+__export(localizationTexts_exports, {
+  default: () => localizationTexts_default
+});
+module.exports = __toCommonJS(localizationTexts_exports);
+var import_actions = require("@tachybase/actions");
+var import_database = require("@tachybase/database");
+var import_constans = require("../constans");
+const appendTranslations = async (db, rows, locale) => {
+  const texts = rows || [];
+  const textIds = texts.map((text) => text.id);
+  const textMp = texts.reduce((memo, text) => {
+    memo[text.id] = text;
+    return memo;
+  }, {});
+  const repo = db.getRepository("localizationTranslations");
+  const translations = await repo.find({
+    filter: {
+      locale,
+      textId: textIds
+    }
+  });
+  translations.forEach((translation) => {
+    const text = textMp[translation.textId];
+    if (text) {
+      text.set("translation", translation.translation, { raw: true });
+      text.set("translationId", translation.id, { raw: true });
+      textMp[translation.textId] = text;
+    }
+  });
+  return Object.values(textMp);
+};
+const listText = async (db, params) => {
+  const { module: module2, keyword, hasTranslation, locale, options } = params;
+  if (module2) {
+    options["filter"] = { module: `resources.${module2}` };
+  }
+  if (keyword || !hasTranslation) {
+    options["include"] = [{ association: "translations", where: { locale }, required: false }];
+    if (!hasTranslation) {
+      if (keyword) {
+        options["filter"] = {
+          ...options["filter"],
+          text: {
+            $includes: keyword
+          }
+        };
+      }
+      options["where"] = {
+        "$translations.id$": null
+      };
+    } else {
+      options["where"] = {
+        [import_database.Op.or]: [
+          { text: { [import_database.Op.like]: `%${keyword}%` } },
+          { "$translations.translation$": { [import_database.Op.like]: `%${keyword}%` } }
+        ]
+      };
+    }
+  }
+  const [rows, count] = await db.getRepository("localizationTexts").findAndCount(options);
+  if (!hasTranslation) {
+    return [rows, count];
+  }
+  return [await appendTranslations(db, rows, locale), count];
+};
+const list = async (ctx, next) => {
+  const locale = ctx.get("X-Locale") || "en-US";
+  let { page = import_actions.DEFAULT_PAGE, pageSize = import_actions.DEFAULT_PER_PAGE, hasTranslation } = ctx.action.params;
+  page = parseInt(String(page));
+  pageSize = parseInt(String(pageSize));
+  hasTranslation = hasTranslation === "true" || hasTranslation === void 0;
+  const { keyword, module: module2 } = ctx.action.params;
+  const options = {
+    context: ctx,
+    offset: (page - 1) * pageSize,
+    limit: pageSize
+  };
+  const [rows, count] = await listText(ctx.db, { module: module2, keyword, hasTranslation, locale, options });
+  const cache = ctx.app.cache;
+  const pm = ctx.app.pm;
+  const plugins = await cache.wrap(`lm-plugins:${locale}`, () => pm.list({ locale }));
+  const modules = [
+    ...import_constans.EXTEND_MODULES,
+    ...plugins.map((plugin) => ({
+      value: plugin.alias || plugin.name,
+      label: plugin.displayName
+    }))
+  ];
+  for (const row of rows) {
+    const moduleName = row.get("module").replace("resources.", "");
+    const module3 = modules.find((module4) => module4.value === moduleName);
+    if (module3) {
+      row.set("moduleTitle", module3.label, { raw: true });
+    }
+  }
+  ctx.body = {
+    count,
+    rows,
+    page,
+    pageSize,
+    totalPage: Math.ceil(count / pageSize),
+    modules: [
+      ...import_constans.EXTEND_MODULES,
+      ...plugins.map((plugin) => ({
+        value: plugin.alias || plugin.name,
+        label: plugin.displayName
+      }))
+    ]
+  };
+  await next();
+};
+var localizationTexts_default = { list };

package/dist/server/collections/localization-texts.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@tachybase/database").CollectionOptions;
+export default _default;

package/dist/server/collections/localization-texts.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 localization_texts_exports = {};
+__export(localization_texts_exports, {
+  default: () => localization_texts_default
+});
+module.exports = __toCommonJS(localization_texts_exports);
+var import_database = require("@tachybase/database");
+var localization_texts_default = (0, import_database.defineCollection)({
+  dumpRules: {
+    group: "required"
+  },
+  name: "localizationTexts",
+  model: "LocalizationTextModel",
+  createdBy: true,
+  updatedBy: true,
+  logging: true,
+  shared: true,
+  fields: [
+    {
+      name: "id",
+      type: "bigInt",
+      autoIncrement: true,
+      primaryKey: true,
+      allowNull: false,
+      interface: "id"
+    },
+    {
+      interface: "input",
+      type: "string",
+      name: "module",
+      allowNull: false,
+      uiSchema: {
+        type: "string",
+        title: '{{t("Module")}}',
+        "x-component": "Select",
+        required: true
+      }
+    },
+    {
+      interface: "input",
+      type: "text",
+      name: "text",
+      allowNull: false,
+      uiSchema: {
+        type: "string",
+        title: '{{t("Text")}}',
+        "x-component": "Input",
+        required: true
+      }
+    },
+    {
+      name: "batch",
+      type: "string"
+    },
+    {
+      interface: "o2m",
+      type: "hasMany",
+      name: "translations",
+      target: "localizationTranslations",
+      sourceKey: "id",
+      foreignKey: "textId",
+      onDelete: "CASCADE"
+    }
+  ],
+  indexes: [
+    {
+      fields: ["batch"]
+    }
+  ]
+});

package/dist/server/collections/localization-translations.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@tachybase/database").CollectionOptions;
+export default _default;

package/dist/server/collections/localization-translations.js

@@ -0,0 +1,84 @@
+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 localization_translations_exports = {};
+__export(localization_translations_exports, {
+  default: () => localization_translations_default
+});
+module.exports = __toCommonJS(localization_translations_exports);
+var import_database = require("@tachybase/database");
+var localization_translations_default = (0, import_database.defineCollection)({
+  namespace: "localization.localization",
+  dumpRules: {
+    group: "required"
+  },
+  name: "localizationTranslations",
+  model: "LocalizationTranslationModel",
+  createdBy: true,
+  updatedBy: true,
+  logging: true,
+  shared: true,
+  fields: [
+    {
+      name: "id",
+      type: "bigInt",
+      autoIncrement: true,
+      primaryKey: true,
+      allowNull: false,
+      interface: "id"
+    },
+    {
+      interface: "input",
+      type: "string",
+      name: "locale",
+      allowNull: false,
+      uiSchema: {
+        type: "string",
+        title: '{{t("Locale")}}',
+        "x-component": "Input",
+        required: true
+      }
+    },
+    {
+      interface: "input",
+      type: "text",
+      name: "translation",
+      allowNull: false,
+      defaultValue: "",
+      uiSchema: {
+        type: "string",
+        title: '{{t("Translation")}}',
+        "x-component": "Input",
+        required: true
+      }
+    },
+    {
+      interface: "m2o",
+      type: "belongsTo",
+      name: "text",
+      target: "localizationTexts",
+      targetKey: "id",
+      foreignKey: "textId"
+    }
+  ],
+  indexes: [
+    {
+      fields: ["locale", "textId"],
+      unique: true
+    }
+  ]
+});

package/dist/server/constans.d.ts

@@ -0,0 +1,8 @@
+export declare const CACHE_KEY = "localization:texts";
+export declare const NAMESPACE_PREFIX = "lm-";
+export declare const NAMESPACE_MENUS = "lm-menus";
+export declare const NAMESPACE_COLLECTIONS = "lm-collections";
+export declare const EXTEND_MODULES: {
+    value: string;
+    label: string;
+}[];

package/dist/server/constans.js

@@ -0,0 +1,48 @@
+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 constans_exports = {};
+__export(constans_exports, {
+  CACHE_KEY: () => CACHE_KEY,
+  EXTEND_MODULES: () => EXTEND_MODULES,
+  NAMESPACE_COLLECTIONS: () => NAMESPACE_COLLECTIONS,
+  NAMESPACE_MENUS: () => NAMESPACE_MENUS,
+  NAMESPACE_PREFIX: () => NAMESPACE_PREFIX
+});
+module.exports = __toCommonJS(constans_exports);
+const CACHE_KEY = "localization:texts";
+const NAMESPACE_PREFIX = "lm-";
+const NAMESPACE_MENUS = `${NAMESPACE_PREFIX}menus`;
+const NAMESPACE_COLLECTIONS = `${NAMESPACE_PREFIX}collections`;
+const EXTEND_MODULES = [
+  {
+    value: NAMESPACE_MENUS,
+    label: "Menu"
+  },
+  {
+    value: NAMESPACE_COLLECTIONS,
+    label: "Collections & Fields"
+  }
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CACHE_KEY,
+  EXTEND_MODULES,
+  NAMESPACE_COLLECTIONS,
+  NAMESPACE_MENUS,
+  NAMESPACE_PREFIX
+});

package/dist/server/index.d.ts

@@ -0,0 +1 @@
+export { default } from './plugin';

package/dist/server/index.js

@@ -0,0 +1,33 @@
+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 server_exports = {};
+__export(server_exports, {
+  default: () => import_plugin.default
+});
+module.exports = __toCommonJS(server_exports);
+var import_plugin = __toESM(require("./plugin"));

package/dist/server/migrations/20230706200900-roles-add-translation.d.ts

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

package/dist/server/migrations/20230706200900-roles-add-translation.js

@@ -0,0 +1,50 @@
+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 roles_add_translation_exports = {};
+__export(roles_add_translation_exports, {
+  default: () => AddTranslationToRoleTitleMigration
+});
+module.exports = __toCommonJS(roles_add_translation_exports);
+var import_server = require("@tachybase/server");
+class AddTranslationToRoleTitleMigration extends import_server.Migration {
+  appVersion = "<0.11.1-alpha.1";
+  async up() {
+    const repo = this.context.db.getRepository("fields");
+    const field = await repo.findOne({
+      where: {
+        collectionName: "roles",
+        name: "title"
+      }
+    });
+    if (field) {
+      await repo.update({
+        filter: {
+          key: field.key
+        },
+        values: {
+          options: {
+            ...field.options,
+            translation: true
+          }
+        }
+      });
+    }
+  }
+  async down() {
+  }
+}