@nocobase/plugin-localization 1.0.0-alpha.1

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("@nocobase/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() {
+  }
+}

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

@@ -0,0 +1,6 @@
+import { Migration } from '@nocobase/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("@nocobase/database");
+var import_server = require("@nocobase/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/migrations/20240425224508-change-locale-module.d.ts

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

package/dist/server/migrations/20240425224508-change-locale-module.js

@@ -0,0 +1,42 @@
+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 change_locale_module_exports = {};
+__export(change_locale_module_exports, {
+  default: () => change_locale_module_default
+});
+module.exports = __toCommonJS(change_locale_module_exports);
+var import_server = require("@nocobase/server");
+class change_locale_module_default extends import_server.Migration {
+  on = "afterLoad";
+  // 'beforeLoad' or 'afterLoad'
+  appVersion = "<1.0.0-alpha.1";
+  async up() {
+    const repo = this.db.getRepository("localizationTexts");
+    if (!repo) {
+      return;
+    }
+    await repo.update({
+      filter: {
+        module: "resources.localization-management"
+      },
+      values: {
+        module: "resources.localization"
+      }
+    });
+  }
+}

package/dist/server/migrations/20240426123538-delete-pkg-name-ns.d.ts

@@ -0,0 +1,20 @@
+import { Migration } from '@nocobase/server';
+export default class extends Migration {
+    on: string;
+    appVersion: string;
+    namesMp: {
+        'auth-cas': string;
+        'auth-oidc': string;
+        'auth-saml': string;
+        'field-china-region': string;
+        'action-custom-request': string;
+        'action-export': string;
+        'field-formula': string;
+        'block-iframe': string;
+        'action-import': string;
+        localization: string;
+        'field-sequence': string;
+        'auth-sms': string;
+    };
+    up(): Promise<void>;
+}

package/dist/server/migrations/20240426123538-delete-pkg-name-ns.js

@@ -0,0 +1,73 @@
+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 delete_pkg_name_ns_exports = {};
+__export(delete_pkg_name_ns_exports, {
+  default: () => delete_pkg_name_ns_default
+});
+module.exports = __toCommonJS(delete_pkg_name_ns_exports);
+var import_server = require("@nocobase/server");
+class delete_pkg_name_ns_default extends import_server.Migration {
+  on = "afterLoad";
+  // 'beforeLoad' or 'afterLoad'
+  appVersion = "<1.0.0-alpha.1";
+  namesMp = {
+    "auth-cas": "cas",
+    "auth-oidc": "oidc",
+    "auth-saml": "saml",
+    "field-china-region": "china-region",
+    "action-custom-request": "custom-request",
+    "action-export": "export",
+    "field-formula": "formula-field",
+    "block-iframe": "iframe-block",
+    "action-import": "import",
+    localization: "localization-management",
+    "field-sequence": "sequence-field",
+    "auth-sms": "sms-auth"
+  };
+  async up() {
+    const resources = await this.app.localeManager.getCacheResources("en-US");
+    const modules = Object.keys(resources);
+    Object.entries(this.namesMp).forEach(([newName, oldName]) => {
+      if (!modules.includes(newName)) {
+        return;
+      }
+      modules.push(oldName, `${import_server.OFFICIAL_PLUGIN_PREFIX}${oldName}`);
+    });
+    const toBeDeleted = [];
+    modules.forEach((module2) => {
+      if (!module2.startsWith(import_server.OFFICIAL_PLUGIN_PREFIX)) {
+        return;
+      }
+      const name = module2.replace(import_server.OFFICIAL_PLUGIN_PREFIX, "");
+      if (!modules.includes(name)) {
+        return;
+      }
+      toBeDeleted.push(module2);
+    });
+    if (!toBeDeleted.length) {
+      return;
+    }
+    await this.db.getRepository("localizationTexts").destroy({
+      filter: {
+        module: {
+          $in: toBeDeleted.map((module2) => `resources.${module2}`)
+        }
+      }
+    });
+  }
+}

package/dist/server/plugin.d.ts

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

package/dist/server/plugin.js

@@ -0,0 +1,168 @@
+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, {
+  PluginLocalizationServer: () => PluginLocalizationServer,
+  default: () => plugin_default
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_server = require("@nocobase/server");
+var import_deepmerge = __toESM(require("deepmerge"));
+var import_path = require("path");
+var import_localization = __toESM(require("./actions/localization"));
+var import_localizationTexts = __toESM(require("./actions/localizationTexts"));
+var import_resources = __toESM(require("./resources"));
+var import_utils = require("./utils");
+var import_constans = require("./constans");
+class PluginLocalizationServer extends import_server.Plugin {
+  resources;
+  registerUISchemahook(plugin) {
+    const uiSchemaStoragePlugin = plugin || this.app.getPlugin("ui-schema-storage");
+    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() {
+    await this.importCollections((0, import_path.resolve)(__dirname, "collections"));
+    this.app.resource({
+      name: "localizationTexts",
+      actions: import_localizationTexts.default
+    });
+    this.app.resource({
+      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.resourceManager.use(async (ctx, next) => {
+      await next();
+      const { resourceName, actionName } = ctx.action.params;
+      if (resourceName === "app" && actionName === "getLang") {
+        const custom = await this.resources.getResources(ctx.body.lang || "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;
+          const pkgName = `${import_server.OFFICIAL_PLUGIN_PREFIX}${module2}`;
+          if (appLang.resources[pkgName]) {
+            resources[pkgName] = { ...resources[module2] };
+          }
+        });
+        ctx.body = {
+          ...appLang,
+          resources
+        };
+      }
+    });
+  }
+  async install(options) {
+  }
+  async afterEnable() {
+  }
+  async afterDisable() {
+    const uiSchemaStoragePlugin = this.app.getPlugin("ui-schema-storage");
+    if (!uiSchemaStoragePlugin) {
+      return;
+    }
+    uiSchemaStoragePlugin.serverHooks.remove("onSelfSave", "extractTextToLocale");
+  }
+  async remove() {
+  }
+}
+var plugin_default = PluginLocalizationServer;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginLocalizationServer
+});

package/dist/server/resources.d.ts

@@ -0,0 +1,19 @@
+import { Cache } from '@nocobase/cache';
+import { Database, Transaction } from '@nocobase/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,80 @@
+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");
+/* istanbul ignore next -- @preserve */
+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
+});