@tego/core 1.3.44

package/lib/helper.js

@@ -0,0 +1,193 @@
+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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 helper_exports = {};
+__export(helper_exports, {
+  createAppProxy: () => createAppProxy,
+  createI18n: () => createI18n,
+  createResourcer: () => createResourcer,
+  enablePerfHooks: () => enablePerfHooks,
+  getCommandFullName: () => getCommandFullName,
+  registerMiddlewares: () => registerMiddlewares,
+  tsxRerunning: () => tsxRerunning
+});
+module.exports = __toCommonJS(helper_exports);
+var import_node_crypto = require("node:crypto");
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = require("node:path");
+var import_node_perf_hooks = require("node:perf_hooks");
+var import_logger = require("@tachybase/logger");
+var import_resourcer = require("@tachybase/resourcer");
+var import_utils = require("@tachybase/utils");
+var import_cors = __toESM(require("@koa/cors"));
+var import_i18next = __toESM(require("i18next"));
+var import_koa_bodyparser = __toESM(require("koa-bodyparser"));
+var import_data_wrapping = require("./middlewares/data-wrapping");
+var import_db2resource = require("./middlewares/db2resource");
+var import_extract_client_ip = require("./middlewares/extract-client-ip");
+var import_i18n = require("./middlewares/i18n");
+function createI18n(options) {
+  const instance = import_i18next.default.createInstance();
+  instance.init({
+    lng: "en-US",
+    resources: {},
+    keySeparator: false,
+    nsSeparator: false,
+    ...options.i18n
+  });
+  return instance;
+}
+__name(createI18n, "createI18n");
+function createResourcer(options) {
+  return new import_resourcer.Resourcer({ ...options.resourcer });
+}
+__name(createResourcer, "createResourcer");
+function registerMiddlewares(app, options) {
+  var _a;
+  app.use(
+    async (ctx, next) => {
+      app.context.reqId = (0, import_node_crypto.randomUUID)();
+      await next();
+    },
+    { tag: "UUID" }
+  );
+  app.use((0, import_logger.requestLogger)(app.name, (_a = options.logger) == null ? void 0 : _a.request), { tag: "logger" });
+  app.use(
+    (0, import_cors.default)({
+      exposeHeaders: ["content-disposition"],
+      ...options.cors
+    }),
+    {
+      tag: "cors",
+      after: "bodyParser"
+    }
+  );
+  if (options.bodyParser !== false) {
+    const bodyLimit = "10mb";
+    app.use(
+      (0, import_koa_bodyparser.default)({
+        enableTypes: ["json", "form", "xml"],
+        jsonLimit: bodyLimit,
+        formLimit: bodyLimit,
+        textLimit: bodyLimit,
+        ...options.bodyParser
+      }),
+      {
+        tag: "bodyParser",
+        after: "logger"
+      }
+    );
+  }
+  app.use(
+    async (ctx, next) => {
+      ctx.getBearerToken = () => {
+        const token = ctx.get("Authorization").replace(/^Bearer\s+/gi, "");
+        return token || ctx.query.token;
+      };
+      await next();
+    },
+    { tag: "authorization" }
+  );
+  app.use(import_i18n.i18n, { tag: "i18n", after: "cors" });
+  if (options.dataWrapping !== false) {
+    app.use((0, import_data_wrapping.dataWrapping)(), { tag: "dataWrapping", after: "i18n" });
+  }
+  app.use(import_db2resource.db2resource, { tag: "db2resource", after: "dataWrapping" });
+  app.use(app.dataSourceManager.middleware(), { tag: "dataSource", after: "dataWrapping" });
+  app.use((0, import_extract_client_ip.extractClientIp)(), { tag: "extractClientIp", before: "cors" });
+}
+__name(registerMiddlewares, "registerMiddlewares");
+const createAppProxy = /* @__PURE__ */ __name((app) => {
+  return new Proxy(app, {
+    get(target, prop, ...args) {
+      if (typeof prop === "string" && ["on", "once", "addListener"].includes(prop)) {
+        return (eventName, listener) => {
+          listener["_reinitializable"] = true;
+          return target[prop](eventName, listener);
+        };
+      }
+      return Reflect.get(target, prop, ...args);
+    }
+  });
+}, "createAppProxy");
+const getCommandFullName = /* @__PURE__ */ __name((command) => {
+  const names = [];
+  names.push(command.name());
+  let parent = command == null ? void 0 : command.parent;
+  while (parent) {
+    if (!(parent == null ? void 0 : parent.parent)) {
+      break;
+    }
+    names.unshift(parent.name());
+    parent = parent.parent;
+  }
+  return names.join(".");
+}, "getCommandFullName");
+const tsxRerunning = /* @__PURE__ */ __name(async () => {
+  const file = (0, import_node_path.resolve)(process.cwd(), "storage/app.watch.ts");
+  await import_node_fs.default.promises.writeFile(file, `export const watchId = '${(0, import_utils.uid)()}';`, "utf-8");
+}, "tsxRerunning");
+const enablePerfHooks = /* @__PURE__ */ __name((app) => {
+  app.context.getPerfHistogram = (name) => {
+    if (!app.perfHistograms.has(name)) {
+      app.perfHistograms.set(name, (0, import_node_perf_hooks.createHistogram)());
+    }
+    return app.perfHistograms.get(name);
+  };
+  app.resourcer.define({
+    name: "perf",
+    actions: {
+      view: /* @__PURE__ */ __name(async (ctx, next) => {
+        const result = {};
+        const histograms = ctx.app.perfHistograms;
+        const sortedHistograms = [...histograms.entries()].sort(([i, a], [j, b]) => b.mean - a.mean);
+        sortedHistograms.forEach(([name, histogram]) => {
+          result[name] = histogram;
+        });
+        ctx.body = result;
+        await next();
+      }, "view"),
+      reset: /* @__PURE__ */ __name(async (ctx, next) => {
+        const histograms = ctx.app.perfHistograms;
+        histograms.forEach((histogram) => histogram.reset());
+        await next();
+      }, "reset")
+    }
+  });
+  app.acl.allow("perf", "*", "public");
+}, "enablePerfHooks");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAppProxy,
+  createI18n,
+  createResourcer,
+  enablePerfHooks,
+  getCommandFullName,
+  registerMiddlewares,
+  tsxRerunning
+});

package/lib/helpers/application-version.d.ts

@@ -0,0 +1,10 @@
+import { Collection } from '@tachybase/database';
+import Application from '../application';
+export declare class ApplicationVersion {
+    protected app: Application;
+    protected collection: Collection;
+    constructor(app: Application);
+    get(): Promise<any>;
+    update(version?: string): Promise<void>;
+    satisfies(range: string): Promise<boolean>;
+}

package/lib/helpers/application-version.js

@@ -0,0 +1,77 @@
+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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 application_version_exports = {};
+__export(application_version_exports, {
+  ApplicationVersion: () => ApplicationVersion
+});
+module.exports = __toCommonJS(application_version_exports);
+var import_semver = __toESM(require("semver"));
+const _ApplicationVersion = class _ApplicationVersion {
+  constructor(app) {
+    this.app = app;
+    app.db.collection({
+      origin: "@tego/core",
+      name: "applicationVersion",
+      dataType: "meta",
+      timestamps: false,
+      dumpRules: "required",
+      fields: [{ name: "value", type: "string" }]
+    });
+    this.collection = this.app.db.getCollection("applicationVersion");
+  }
+  async get() {
+    const model = await this.collection.model.findOne();
+    if (!model) {
+      return null;
+    }
+    return model.get("value");
+  }
+  async update(version) {
+    await this.collection.model.destroy({
+      truncate: true
+    });
+    await this.collection.model.create({
+      value: version || this.app.getVersion()
+    });
+  }
+  async satisfies(range) {
+    const model = await this.collection.model.findOne();
+    const version = model == null ? void 0 : model.value;
+    if (!version) {
+      return true;
+    }
+    return import_semver.default.satisfies(version, range, { includePrerelease: true });
+  }
+};
+__name(_ApplicationVersion, "ApplicationVersion");
+let ApplicationVersion = _ApplicationVersion;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApplicationVersion
+});

package/lib/helpers/multiple-instance-manager.d.ts

@@ -0,0 +1,6 @@
+export declare class MultipleInstanceManager<Item> {
+    map: Map<string, Item>;
+    constructor();
+    get(key: string): Item;
+    set(key: string, value: Item): void;
+}

package/lib/helpers/multiple-instance-manager.js

@@ -0,0 +1,40 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 multiple_instance_manager_exports = {};
+__export(multiple_instance_manager_exports, {
+  MultipleInstanceManager: () => MultipleInstanceManager
+});
+module.exports = __toCommonJS(multiple_instance_manager_exports);
+const _MultipleInstanceManager = class _MultipleInstanceManager {
+  constructor() {
+    this.map = /* @__PURE__ */ new Map();
+  }
+  get(key) {
+    return this.map.get(key);
+  }
+  set(key, value) {
+    this.map.set(key, value);
+  }
+};
+__name(_MultipleInstanceManager, "MultipleInstanceManager");
+let MultipleInstanceManager = _MultipleInstanceManager;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MultipleInstanceManager
+});

package/lib/index.d.ts

@@ -0,0 +1,10 @@
+export * from './application';
+export { Application as default } from './application';
+export * as middlewares from './middlewares';
+export * from './migration';
+export * from './plugin';
+export * from './plugin-manager';
+export * from './gateway';
+export * from './app-supervisor';
+export * from './notice';
+export { AesEncryptor } from './aes-encryptor';

package/lib/index.js

@@ -0,0 +1,57 @@
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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 index_exports = {};
+__export(index_exports, {
+  AesEncryptor: () => import_aes_encryptor.AesEncryptor,
+  default: () => import_application.Application,
+  middlewares: () => middlewares
+});
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./application"), module.exports);
+var import_application = require("./application");
+var middlewares = __toESM(require("./middlewares"));
+__reExport(index_exports, require("./migration"), module.exports);
+__reExport(index_exports, require("./plugin"), module.exports);
+__reExport(index_exports, require("./plugin-manager"), module.exports);
+__reExport(index_exports, require("./gateway"), module.exports);
+__reExport(index_exports, require("./app-supervisor"), module.exports);
+__reExport(index_exports, require("./notice"), module.exports);
+var import_aes_encryptor = require("./aes-encryptor");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AesEncryptor,
+  middlewares,
+  ...require("./application"),
+  ...require("./migration"),
+  ...require("./plugin"),
+  ...require("./plugin-manager"),
+  ...require("./gateway"),
+  ...require("./app-supervisor"),
+  ...require("./notice")
+});

package/lib/locale/index.d.ts

@@ -0,0 +1 @@
+export * from './locale';

package/lib/locale/index.js

@@ -0,0 +1,21 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var locale_exports = {};
+module.exports = __toCommonJS(locale_exports);
+__reExport(locale_exports, require("./locale"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./locale")
+});

package/lib/locale/locale.d.ts

@@ -0,0 +1,22 @@
+import { Cache } from '@tachybase/cache';
+import Application from '../application';
+export declare class Locale {
+    app: Application;
+    cache: Cache;
+    defaultLang: string;
+    localeFn: Map<any, any>;
+    resourceCached: Map<any, any>;
+    i18nInstances: Map<any, any>;
+    constructor(app: Application);
+    load(): Promise<void>;
+    setLocaleFn(name: string, fn: (lang: string) => Promise<any>): void;
+    getETag(lang: string): Promise<any>;
+    get(lang: string): Promise<{
+        resources: any;
+    }>;
+    wrapCache(key: string, fn: () => any): Promise<any>;
+    loadResourcesByLang(lang: string): Promise<void>;
+    getCacheResources(lang: string): Promise<any>;
+    getResources(lang: string): {};
+    getI18nInstance(lang: string): Promise<any>;
+}

package/lib/locale/locale.js

@@ -0,0 +1,166 @@
+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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 locale_exports = {};
+__export(locale_exports, {
+  Locale: () => Locale
+});
+module.exports = __toCommonJS(locale_exports);
+var import_node_crypto = require("node:crypto");
+var import_lodash = __toESM(require("lodash"));
+var import_resource = require("./resource");
+const _Locale = class _Locale {
+  constructor(app) {
+    this.defaultLang = "en-US";
+    this.localeFn = /* @__PURE__ */ new Map();
+    this.resourceCached = /* @__PURE__ */ new Map();
+    this.i18nInstances = /* @__PURE__ */ new Map();
+    this.app = app;
+    this.app.on("afterLoad", async () => {
+      this.app.logger.debug("load locale resource", { submodule: "locale", method: "onAfterLoad" });
+      this.app.setMaintainingMessage("load locale resource");
+      await this.load();
+      this.app.logger.debug("locale resource loaded", { submodule: "locale", method: "onAfterLoad" });
+      this.app.setMaintainingMessage("locale resource loaded");
+    });
+  }
+  async load() {
+    this.cache = await this.app.cacheManager.createCache({
+      name: "locale",
+      prefix: "locale",
+      store: "memory"
+    });
+    await this.get(this.defaultLang);
+  }
+  setLocaleFn(name, fn) {
+    this.localeFn.set(name, fn);
+  }
+  async getETag(lang) {
+    if (process.env.APP_ENV !== "production" && !process.env.FORCE_LOCALE_CACHE) {
+      await this.cache.del(`eTag:${lang}`);
+    }
+    return await this.wrapCache(`eTag:${lang}`, async () => {
+      return (0, import_node_crypto.randomUUID)();
+    });
+  }
+  async get(lang) {
+    const defaults = {
+      resources: await this.getCacheResources(lang)
+    };
+    for (const [name, fn] of this.localeFn) {
+      const result = await this.wrapCache(`${name}:${lang}`, async () => {
+        this.cache.del(`eTag:${lang}`);
+        return await fn(lang);
+      });
+      if (result) {
+        defaults[name] = result;
+      }
+    }
+    return defaults;
+  }
+  async wrapCache(key, fn) {
+    return await this.cache.wrapWithCondition(key, fn, {
+      isCacheable: /* @__PURE__ */ __name((val) => !import_lodash.default.isEmpty(val), "isCacheable")
+    });
+  }
+  async loadResourcesByLang(lang) {
+    if (!this.cache) {
+      return;
+    }
+    if (!this.resourceCached.has(lang)) {
+      await this.getCacheResources(lang);
+    }
+  }
+  async getCacheResources(lang) {
+    this.resourceCached.set(lang, true);
+    if (process.env.APP_ENV !== "production" && !process.env.FORCE_LOCALE_CACHE) {
+      await this.cache.del(`resources:${lang}`);
+    }
+    return await this.wrapCache(`resources:${lang}`, () => this.getResources(lang));
+  }
+  getResources(lang) {
+    var _a;
+    const resources = {};
+    const names = this.app.pm.getAliases();
+    if (process.env.APP_ENV !== "production") {
+      const keys = Object.keys(require.cache);
+      const regex = new RegExp(`((plugin|module)-[a-zA-Z0-9\\-]+|client)/(dist|lib|src)/locale/${lang}`);
+      const matched = keys.filter((path) => regex.test(path));
+      if (matched.length > 0) {
+        this.app.logger.debug("clear locale resource cache", { submodule: "locale", matched });
+      }
+      matched.forEach((key) => delete require.cache[key]);
+    }
+    for (const name of names) {
+      try {
+        const p = this.app.pm.get(name);
+        if (!p) {
+          continue;
+        }
+        const packageName = (_a = p.options) == null ? void 0 : _a.packageName;
+        if (!packageName) {
+          continue;
+        }
+        const res = (0, import_resource.getResource)(packageName, lang);
+        if (res) {
+          resources[packageName] = { ...res };
+          if (packageName.includes("@tachybase/plugin-")) {
+            resources[packageName.substring("@tachybase/plugin-".length)] = { ...res };
+          }
+          if (packageName.includes("@tachybase/module-")) {
+            resources[packageName.substring("@tachybase/module-".length)] = { ...res };
+          }
+        }
+      } catch (err) {
+      }
+    }
+    resources["core"] = resources["web"];
+    resources["client"] = resources["web"];
+    Object.keys(resources).forEach((name) => {
+      this.app.i18n.addResources(lang, name, resources[name]);
+    });
+    return resources;
+  }
+  async getI18nInstance(lang) {
+    if (lang === "*" || !lang) {
+      return this.app.i18n.cloneInstance({ initImmediate: false });
+    }
+    let instance = this.i18nInstances.get(lang);
+    if (!instance) {
+      instance = this.app.i18n.cloneInstance({ initImmediate: false });
+      this.i18nInstances.set(lang, instance);
+    }
+    return instance;
+  }
+};
+__name(_Locale, "Locale");
+let Locale = _Locale;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Locale
+});

package/lib/locale/resource.d.ts

@@ -0,0 +1 @@
+export declare const getResource: (packageName: string, lang: string, isPlugin?: boolean) => any;