@akanjs/dictionary 0.9.56 → 0.9.58-canary.0

package/cjs/src/base.dictionary.js

@@ -20,49 +20,33 @@ __export(base_dictionary_exports, {
   baseDictionary: () => baseDictionary
 });
 module.exports = __toCommonJS(base_dictionary_exports);
-const baseDictionary = {
-  // * ==================== Endpoint ==================== * //
-  "api-publishPing": ["Publish Ping", "Publish Ping"],
-  "apidesc-publishPing": ["Publish Ping", "Publish Ping"],
-  "api-ping": ["Ping", "Ping"],
-  "apidesc-ping": ["Ping", "Ping"],
-  "api-pingBody": ["Ping Body", "Ping Body"],
-  "apidesc-pingBody": ["Ping Body", "Ping Body"],
-  "arg-pingBody-data": ["Body data", "\uBC14\uB514 \uB370\uC774\uD130"],
-  "argdesc-pingBody-data": ["Body data", "\uBC14\uB514 \uB370\uC774\uD130"],
-  "api-pingParam": ["Ping Param", "Ping Param"],
-  "apidesc-pingParam": ["Ping Param", "Ping Param"],
-  "arg-pingParam-id": ["ID", "\uC544\uC774\uB514"],
-  "argdesc-pingParam-id": ["ID", "\uC544\uC774\uB514"],
-  "api-pingQuery": ["Ping Query", "Ping Query"],
-  "apidesc-pingQuery": ["Ping Query", "Ping Query"],
-  "arg-pingQuery-id": ["ID", "\uC544\uC774\uB514"],
-  "argdesc-pingQuery-id": ["ID", "\uC544\uC774\uB514"],
-  "api-pingEvery": ["Ping Every", "Ping Every"],
-  "apidesc-pingEvery": ["Ping Every", "Ping Every"],
-  "api-pingUser": ["Ping User", "Ping User"],
-  "apidesc-pingUser": ["Ping User", "Ping User"],
-  "api-pingAdmin": ["Ping Admin", "Ping Admin"],
-  "apidesc-pingAdmin": ["Ping Admin", "Ping Admin"],
-  "api-cleanup": ["Cleanup", "Cleanup"],
-  "apidesc-cleanup": ["Cleanup", "Cleanup"],
-  "api-wsPing": ["Socket.io Ping", "Socket.io Ping"],
-  "apidesc-wsPing": ["Socket.io Ping", "Socket.io Ping"],
-  "arg-wsPing-data": ["Data", "\uB370\uC774\uD130"],
-  "argdesc-wsPing-data": ["Data", "\uB370\uC774\uD130"],
-  "api-pubsubPing": ["Pubsub Ping", "Pubsub Ping"],
-  "apidesc-pubsubPing": ["Pubsub Ping", "Pubsub Ping"],
-  "api-getDictionary": ["Get Dictionary", "Get Dictionary"],
-  "apidesc-getDictionary": ["Get Dictionary", "Get Dictionary"],
-  "arg-getDictionary-lang": ["Language", "\uC5B8\uC5B4"],
-  "argdesc-getDictionary-lang": ["Language", "\uC5B8\uC5B4"],
-  "api-getAllDictionary": ["Get All Dictionary", "Get All Dictionary"],
-  "apidesc-getAllDictionary": ["Get All Dictionary", "Get All Dictionary"],
-  "api-getSignals": ["Get Signals", "Get Signals"],
-  "apidesc-getSignals": ["Get Signals", "Get Signals"],
-  // * ==================== Endpoint ==================== * //
-  // * ==================== Etc ==================== * //
-  // new: ["New", "신규"],
+var import_dictInfo = require("./dictInfo");
+const baseDictionary = (0, import_dictInfo.serviceDictionary)(["en", "ko"]).endpoint((fn) => ({
+  publishPing: fn(["Publish Ping", "Publish Ping"]),
+  ping: fn(["Ping", "Ping"]),
+  pingBody: fn(["Ping Body", "Ping Body"]).arg((t) => ({
+    data: t(["Body data", "\uBC14\uB514 \uB370\uC774\uD130"])
+  })),
+  pingParam: fn(["Ping Param", "Ping Param"]).arg((t) => ({
+    id: t(["ID", "\uC544\uC774\uB514"])
+  })),
+  pingQuery: fn(["Ping Query", "Ping Query"]).arg((t) => ({
+    id: t(["ID", "\uC544\uC774\uB514"])
+  })),
+  pingEvery: fn(["Ping Every", "Ping Every"]),
+  pingUser: fn(["Ping User", "Ping User"]),
+  pingAdmin: fn(["Ping Admin", "Ping Admin"]),
+  getDictionary: fn(["Get Dictionary", "Get Dictionary"]).arg((t) => ({
+    lang: t(["Language", "\uC5B8\uC5B4"])
+  })),
+  getAllDictionary: fn(["Get All Dictionary", "Get All Dictionary"]),
+  cleanup: fn(["Cleanup", "Cleanup"]),
+  wsPing: fn(["Socket.io Ping", "Socket.io Ping"]).arg((t) => ({
+    data: t(["Data", "\uB370\uC774\uD130"])
+  })),
+  pubsubPing: fn(["Pubsub Ping", "Pubsub Ping"]),
+  getSignals: fn(["Get Signals", "Get Signals"])
+})).translate({
   somethingWrong: ["Something's wrong!", "\uBB38\uC81C\uAC00 \uC0DD\uACBC\uC5B4\uC694!"],
   connecting: ["Connecting...", "\uC5F0\uACB0 \uC911..."],
   connected: ["Connected!", "\uC5F0\uACB0\uB418\uC5C8\uC2B5\uB2C8\uB2E4!"],
@@ -122,5 +106,4 @@ const baseDictionary = {
   save: ["Save", "\uC800\uC7A5"],
   remove: ["Remove", "\uC0AD\uC81C"],
   view: ["View", "\uBCF4\uAE30"]
-  // * ==================== Etc ==================== * //
-};
+});

package/cjs/src/dictInfo.js

@@ -0,0 +1,484 @@
+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 dictInfo_exports = {};
+__export(dictInfo_exports, {
+  ModelDictInfo: () => ModelDictInfo,
+  ScalarDictInfo: () => ScalarDictInfo,
+  ServiceDictInfo: () => ServiceDictInfo,
+  modelDictionary: () => modelDictionary,
+  scalarDictionary: () => scalarDictionary,
+  serviceDictionary: () => serviceDictionary
+});
+module.exports = __toCommonJS(dictInfo_exports);
+var import_common = require("@akanjs/common");
+class FieldTranslation {
+  static translate = (trans) => new FieldTranslation(trans);
+  trans;
+  descTrans;
+  constructor(trans) {
+    this.trans = trans;
+  }
+  desc(descTrans) {
+    this.descTrans = descTrans;
+    return this;
+  }
+}
+class FunctionTranslation {
+  trans;
+  descTrans;
+  argTrans = {};
+  constructor(trans) {
+    this.trans = trans;
+  }
+  desc(descTrans) {
+    this.descTrans = descTrans;
+    return this;
+  }
+  arg(translate) {
+    Object.assign(this.argTrans, translate(FieldTranslation.translate));
+    return this;
+  }
+}
+const fn = (trans) => new FunctionTranslation(trans);
+class ModelDictInfo {
+  static baseModelDictionary = {
+    id: FieldTranslation.translate(["ID", "\uC544\uC774\uB514"]).desc(["Unique ID value", "\uC720\uB2C8\uD06C\uD55C \uC544\uC774\uB514\uAC12"]),
+    createdAt: FieldTranslation.translate(["CreatedAt", "\uC0DD\uC131\uC77C"]).desc(["Data created time", "\uB370\uC774\uD130 \uC0DD\uC131 \uC2DC\uAC01"]),
+    updatedAt: FieldTranslation.translate(["UpdatedAt", "\uC218\uC815\uC77C"]).desc([
+      "Data updated time",
+      "\uB370\uC774\uD130 \uB9C8\uC9C0\uB9C9 \uC218\uC815 \uC2DC\uAC01"
+    ]),
+    removedAt: FieldTranslation.translate(["RemovedAt", "\uC0AD\uC81C\uC77C"]).desc(["Data removed time", "\uB370\uC774\uD130 \uC0AD\uC81C \uC2DC\uAC01"])
+  };
+  static baseInsightDictionary = {
+    count: FieldTranslation.translate(["Count", "\uAC1C\uC218"]).desc(["Total number of items", "\uCD1D \uC544\uC774\uD15C \uAC1C\uC218"])
+  };
+  static baseQueryDictionary = {
+    any: fn(["Any", "\uC804\uCCB4"]).desc(["All", "\uC804\uCCB4"])
+  };
+  static baseSortDictionary = {
+    latest: FieldTranslation.translate(["Latest", "\uCD5C\uC2E0\uC21C"]).desc(["Latest", "\uCD5C\uC2E0\uC21C"]),
+    oldest: FieldTranslation.translate(["Oldest", "\uC624\uB798\uB41C\uC21C"]).desc(["Oldest", "\uC624\uB798\uB41C\uC21C"])
+  };
+  static getBaseSignalDictionary(refName) {
+    return {
+      [refName]: fn([`Get ${refName}`, `${refName} \uC870\uD68C`]).desc([`Get ${refName}`, `${refName} \uC870\uD68C`]).arg((t) => ({ [`${refName}Id`]: t(["Id", "\uC544\uC774\uB514"]).desc([`Id of ${refName}`, `${refName} \uC544\uC774\uB514`]) })),
+      [`light${refName}`]: fn([`Get light version of ${refName}`, `${refName} \uACBD\uB7C9\uD654 \uBC84\uC804 \uC870\uD68C`]).desc([`Get light version of ${refName}`, `${refName} \uACBD\uB7C9\uD654 \uBC84\uC804 \uC870\uD68C`]).arg((t) => ({ [`${refName}Id`]: t(["Id", "\uC544\uC774\uB514"]).desc([`Id of ${refName}`, `${refName} \uC544\uC774\uB514`]) })),
+      [`create${refName}`]: fn([`Create ${refName}`, `${refName} \uC0DD\uC131`]).desc([`Create ${refName}`, `${refName} \uC0DD\uC131`]).arg((t) => ({ data: t(["Data", "\uB370\uC774\uD130"]).desc([`Data of ${refName}`, `${refName} \uB370\uC774\uD130`]) })),
+      [`update${refName}`]: fn([`Update ${refName}`, `${refName} \uC218\uC815`]).desc([`Update ${refName}`, `${refName} \uC218\uC815`]).arg((t) => ({
+        [`${refName}Id`]: t(["Id", "\uC544\uC774\uB514"]).desc([`Id of ${refName}`, `${refName} \uC544\uC774\uB514`]),
+        data: t(["Data", "\uB370\uC774\uD130"]).desc([`Data of ${refName}`, `${refName} \uB370\uC774\uD130`])
+      })),
+      [`remove${refName}`]: fn([`Remove ${refName}`, `${refName} \uC0AD\uC81C`]).desc([`Remove ${refName}`, `${refName} \uC0AD\uC81C`]).arg((t) => ({ [`${refName}Id`]: t(["Id", "\uC544\uC774\uB514"]).desc([`Id of ${refName}`, `${refName} \uC544\uC774\uB514`]) }))
+    };
+  }
+  static baseSliceDictionary = {
+    [""]: fn(["Universal", "\uC720\uB2C8\uBC84\uC124"]).desc(["Universal Slice", "\uC720\uB2C8\uBC84\uC124 \uC2AC\uB77C\uC774\uC2A4"]).arg((t) => ({ query: t(["Query", "\uCFFC\uB9AC"]).desc(["Query Description", "\uCFFC\uB9AC \uC124\uBA85"]) }))
+  };
+  languages;
+  modelTranslation;
+  modelDictionary = {};
+  insightDictionary = {};
+  queryDictionary = {};
+  sortDictionary = {};
+  enumDictionary = {};
+  baseSignalDictionary = {};
+  sliceDictionary = {};
+  endpointDictionary = {};
+  errorDictionary = {};
+  etcDictionary = {};
+  constructor(languages) {
+    this.languages = languages;
+  }
+  of(translate) {
+    this.modelTranslation = translate(FieldTranslation.translate);
+    return this;
+  }
+  model(translate) {
+    Object.assign(
+      this.modelDictionary,
+      translate(FieldTranslation.translate),
+      ModelDictInfo.baseModelDictionary
+    );
+    return this;
+  }
+  insight(translate) {
+    Object.assign(
+      this.insightDictionary,
+      translate(FieldTranslation.translate),
+      ModelDictInfo.baseInsightDictionary
+    );
+    return this;
+  }
+  query(translate) {
+    Object.assign(this.queryDictionary, translate(fn), ModelDictInfo.baseQueryDictionary);
+    return this;
+  }
+  sort(translate) {
+    Object.assign(
+      this.sortDictionary,
+      translate(FieldTranslation.translate),
+      ModelDictInfo.baseSortDictionary
+    );
+    return this;
+  }
+  enum(enumName, translate) {
+    Object.assign(this.enumDictionary, { [enumName]: translate(FieldTranslation.translate) });
+    return this;
+  }
+  slice(translate) {
+    Object.assign(this.sliceDictionary, translate(fn), ModelDictInfo.baseSliceDictionary);
+    return this;
+  }
+  endpoint(translate) {
+    Object.assign(this.endpointDictionary, translate(fn));
+    return this;
+  }
+  error(errorDictionary) {
+    Object.assign(this.errorDictionary, errorDictionary);
+    return this;
+  }
+  translate(etcDictionary) {
+    Object.assign(this.etcDictionary, etcDictionary);
+    return this;
+  }
+  _applyBaseSignal(refName) {
+    Object.assign(this.baseSignalDictionary, ModelDictInfo.getBaseSignalDictionary(refName));
+    return this;
+  }
+  _registerToRoot(refName, rootDict) {
+    this.languages.forEach((language) => {
+      rootDict[language] ??= {};
+      rootDict[language][refName] ??= {};
+    });
+    if (this.modelTranslation) {
+      this.modelTranslation.trans.forEach((t, idx) => rootDict[this.languages[idx]][refName].modelName = { t });
+      this.modelTranslation.descTrans?.forEach((t, idx) => rootDict[this.languages[idx]][refName].modelDesc = { t });
+    }
+    this.#registerInsightToRoot(refName, rootDict);
+    this.#registerQueryToRoot(refName, rootDict);
+    this.#registerSortToRoot(refName, rootDict);
+    this.#registerEnumToRoot(rootDict);
+    this.#registerBaseSignalToRoot(refName, rootDict);
+    this.#registerSliceToRoot(refName, rootDict);
+    this.#registerEndpointToRoot(refName, rootDict);
+    this.#registerErrorToRoot(refName, rootDict);
+    this.#registerModelToRoot(refName, rootDict);
+    this.#registerEtcToRoot(refName, rootDict);
+  }
+  #registerModelToRoot(refName, rootDict) {
+    Object.entries(this.modelDictionary).forEach(([key, value]) => {
+      value.trans.forEach((t, idx) => rootDict[this.languages[idx]][refName][key] = { t });
+      value.descTrans?.forEach((t, idx) => rootDict[this.languages[idx]][refName][key].desc = { t });
+    });
+  }
+  #registerInsightToRoot(refName, rootDict) {
+    this.languages.forEach((language) => rootDict[language][refName].insight ??= {});
+    Object.entries(this.insightDictionary).forEach(([key, value]) => {
+      value.trans.forEach((t, idx) => rootDict[this.languages[idx]][refName].insight[key] = { t });
+      value.descTrans?.forEach((t, idx) => rootDict[this.languages[idx]][refName].insight[key].desc = { t });
+    });
+  }
+  #registerQueryToRoot(refName, rootDict) {
+    this.languages.forEach((language) => rootDict[language][refName].query ??= {});
+    Object.entries(this.queryDictionary).forEach(
+      ([key, value]) => {
+        value.trans.forEach((t, idx) => rootDict[this.languages[idx]][refName].query[key] = { t, arg: {} });
+        value.descTrans?.forEach((t, idx) => rootDict[this.languages[idx]][refName].query[key].desc = { t });
+        Object.entries(value.argTrans).forEach(
+          ([argKey, argTrans]) => {
+            argTrans.trans.forEach((t, idx) => rootDict[this.languages[idx]][refName].query[key].arg[argKey] = { t });
+            argTrans.descTrans?.forEach(
+              (t, idx) => rootDict[this.languages[idx]][refName].query[key].arg[argKey].desc = { t }
+            );
+          }
+        );
+      }
+    );
+  }
+  #registerSortToRoot(refName, rootDict) {
+    this.languages.forEach((language) => rootDict[language][refName].sort ??= {});
+    Object.entries(this.sortDictionary).forEach(([key, value]) => {
+      value.trans.forEach((t, idx) => rootDict[this.languages[idx]][refName].sort[key] = { t });
+      value.descTrans?.forEach((t, idx) => rootDict[this.languages[idx]][refName].sort[key].desc = { t });
+    });
+  }
+  #registerEnumToRoot(rootDict) {
+    Object.entries(this.enumDictionary).forEach(
+      ([refName, enumTrans]) => {
+        this.languages.forEach((language) => rootDict[language][refName] ??= {});
+        Object.entries(enumTrans).forEach(([enumKey, enumValue]) => {
+          enumValue.trans.forEach((t, idx) => rootDict[this.languages[idx]][refName][enumKey] = { t });
+          enumValue.descTrans?.forEach((t, idx) => rootDict[this.languages[idx]][refName][enumKey].desc = { t });
+        });
+      }
+    );
+  }
+  #registerBaseSignalToRoot(refName, rootDict) {
+    this.languages.forEach((language) => rootDict[language][refName].api ??= {});
+    Object.entries(this.baseSignalDictionary).forEach(
+      ([key, value]) => {
+        value.trans.forEach((t, idx) => rootDict[this.languages[idx]][refName].api[key] = { t, arg: {} });
+        value.descTrans?.forEach((t, idx) => rootDict[this.languages[idx]][refName].api[key].desc = { t });
+        Object.entries(value.argTrans).forEach(
+          ([argKey, argTrans]) => {
+            argTrans.trans.forEach((t, idx) => rootDict[this.languages[idx]][refName].api[key].arg[argKey] = { t });
+            argTrans.descTrans?.forEach(
+              (t, idx) => rootDict[this.languages[idx]][refName].api[key].arg[argKey].desc = { t }
+            );
+          }
+        );
+      }
+    );
+  }
+  #registerSliceToRoot(refName, rootDict) {
+    this.languages.forEach((language) => rootDict[language][refName].api ??= {});
+    Object.entries(this.sliceDictionary).forEach(
+      ([sliceKey, sliceTrans]) => {
+        const listKey = `${refName}List${(0, import_common.capitalize)(sliceKey)}`;
+        const insightKey = `${refName}Insight${(0, import_common.capitalize)(sliceKey)}`;
+        sliceTrans.trans.forEach(
+          (t, idx) => rootDict[this.languages[idx]][refName].api[listKey] = { t: `Slice List - ${t}`, arg: {} }
+        );
+        sliceTrans.descTrans?.forEach(
+          (t, idx) => rootDict[this.languages[idx]][refName].api[listKey].desc = { t: `Slice List - ${t}` }
+        );
+        sliceTrans.trans.forEach(
+          (t, idx) => rootDict[this.languages[idx]][refName].api[insightKey] = { t: `Slice Insight - ${t}`, arg: {} }
+        );
+        sliceTrans.descTrans?.forEach(
+          (t, idx) => rootDict[this.languages[idx]][refName].api[insightKey].desc = { t: `Slice Insight - ${t}` }
+        );
+        Object.entries(sliceTrans.argTrans).forEach(
+          ([argKey, argTrans]) => {
+            argTrans.trans.forEach(
+              (t, idx) => rootDict[this.languages[idx]][refName].api[listKey].arg[argKey] = { t }
+            );
+            argTrans.descTrans?.forEach(
+              (t, idx) => rootDict[this.languages[idx]][refName].api[listKey].arg[argKey].desc = { t }
+            );
+            ["skip", "limit", "sort"].forEach((argKey2) => {
+              argTrans.trans.forEach(
+                (t, idx) => rootDict[this.languages[idx]][refName].api[listKey].arg[argKey2] = { t: argKey2 }
+              );
+              argTrans.descTrans?.forEach(
+                (t, idx) => rootDict[this.languages[idx]][refName].api[listKey].arg[argKey2].desc = { t: argKey2 }
+              );
+            });
+            argTrans.trans.forEach(
+              (t, idx) => rootDict[this.languages[idx]][refName].api[insightKey].arg[argKey] = { t }
+            );
+            argTrans.descTrans?.forEach(
+              (t, idx) => rootDict[this.languages[idx]][refName].api[insightKey].arg[argKey].desc = { t }
+            );
+          }
+        );
+      }
+    );
+  }
+  #registerEndpointToRoot(refName, rootDict) {
+    this.languages.forEach((language) => rootDict[language][refName].api ??= {});
+    Object.entries(this.endpointDictionary).forEach(
+      ([key, value]) => {
+        value.trans.forEach((t, idx) => rootDict[this.languages[idx]][refName].api[key] = { t, arg: {} });
+        value.descTrans?.forEach((t, idx) => rootDict[this.languages[idx]][refName].api[key].desc = { t });
+        Object.entries(value.argTrans).forEach(
+          ([argKey, argTrans]) => {
+            argTrans.trans.forEach((t, idx) => rootDict[this.languages[idx]][refName].api[key].arg[argKey] = { t });
+            argTrans.descTrans?.forEach(
+              (t, idx) => rootDict[this.languages[idx]][refName].api[key].arg[argKey].desc = { t }
+            );
+          }
+        );
+      }
+    );
+  }
+  #registerErrorToRoot(refName, rootDict) {
+    this.languages.forEach((language) => rootDict[language][refName].error ??= {});
+    Object.entries(this.errorDictionary).forEach(([key, value]) => {
+      value.forEach((t, idx) => {
+        rootDict[this.languages[idx]][refName].error[key] ??= {};
+        rootDict[this.languages[idx]][refName].error[key].t = t;
+      });
+    });
+  }
+  #registerEtcToRoot(refName, rootDict) {
+    Object.entries(this.etcDictionary).forEach(([key, value]) => {
+      value.forEach((t, idx) => {
+        rootDict[this.languages[idx]][refName][key] ??= {};
+        rootDict[this.languages[idx]][refName][key].t = t;
+      });
+    });
+  }
+}
+const modelDictionary = (languages = ["en"], ...extendModelDicts) => {
+  const modelDictionary2 = extendModelDicts.at(0) ?? new ModelDictInfo(languages);
+  return modelDictionary2;
+};
+class ScalarDictInfo {
+  languages;
+  modelTranslation;
+  modelDictionary = {};
+  enumDictionary = {};
+  errorDictionary = {};
+  etcDictionary = {};
+  constructor(languages) {
+    this.languages = languages;
+  }
+  of(translate) {
+    this.modelTranslation = translate(FieldTranslation.translate);
+    return this;
+  }
+  model(translate) {
+    Object.assign(
+      this.modelDictionary,
+      translate(FieldTranslation.translate),
+      ModelDictInfo.baseModelDictionary
+    );
+    return this;
+  }
+  enum(enumName, translate) {
+    Object.assign(this.enumDictionary, { [enumName]: translate(FieldTranslation.translate) });
+    return this;
+  }
+  error(errorDictionary) {
+    Object.assign(this.errorDictionary, errorDictionary);
+    return this;
+  }
+  translate(etcDictionary) {
+    Object.assign(this.etcDictionary, etcDictionary);
+    return this;
+  }
+  _registerToRoot(refName, rootDict) {
+    this.languages.forEach((language) => {
+      rootDict[language] ??= {};
+      rootDict[language][refName] ??= {};
+    });
+    if (this.modelTranslation) {
+      this.modelTranslation.trans.forEach((t, idx) => rootDict[this.languages[idx]][refName].modelName = { t });
+      this.modelTranslation.descTrans?.forEach((t, idx) => rootDict[this.languages[idx]][refName].modelDesc = { t });
+    }
+    this.#registerEnumToRoot(rootDict);
+    this.#registerErrorToRoot(refName, rootDict);
+    this.#registerModelToRoot(refName, rootDict);
+    this.#registerEtcToRoot(refName, rootDict);
+  }
+  #registerModelToRoot(refName, rootDict) {
+    Object.entries(this.modelDictionary).forEach(([key, value]) => {
+      value.trans.forEach((t, idx) => rootDict[this.languages[idx]][refName][key] = { t });
+      value.descTrans?.forEach((t, idx) => rootDict[this.languages[idx]][refName][key].desc = { t });
+    });
+  }
+  #registerEnumToRoot(rootDict) {
+    Object.entries(this.enumDictionary).forEach(
+      ([refName, enumTrans]) => {
+        this.languages.forEach((language) => rootDict[language][refName] ??= {});
+        Object.entries(enumTrans).forEach(([enumKey, enumValue]) => {
+          enumValue.trans.forEach((t, idx) => rootDict[this.languages[idx]][refName][enumKey] = { t });
+          enumValue.descTrans?.forEach((t, idx) => rootDict[this.languages[idx]][refName][enumKey].desc = { t });
+        });
+      }
+    );
+  }
+  #registerErrorToRoot(refName, rootDict) {
+    this.languages.forEach((language) => rootDict[language][refName].error ??= {});
+    Object.entries(this.errorDictionary).forEach(([key, value]) => {
+      value.forEach((t, idx) => {
+        rootDict[this.languages[idx]][refName].error[key] ??= {};
+        rootDict[this.languages[idx]][refName].error[key].t = t;
+      });
+    });
+  }
+  #registerEtcToRoot(refName, rootDict) {
+    Object.entries(this.etcDictionary).forEach(([key, value]) => {
+      value.forEach((t, idx) => {
+        rootDict[this.languages[idx]][refName][key] ??= {};
+        rootDict[this.languages[idx]][refName][key].t = t;
+      });
+    });
+  }
+}
+const scalarDictionary = (languages = ["en"]) => new ScalarDictInfo(languages);
+class ServiceDictInfo {
+  languages;
+  endpointDictionary = {};
+  errorDictionary = {};
+  etcDictionary = {};
+  constructor(languages) {
+    this.languages = languages;
+  }
+  endpoint(translate) {
+    Object.assign(this.endpointDictionary, translate(fn));
+    return this;
+  }
+  error(errorDictionary) {
+    Object.assign(this.errorDictionary, errorDictionary);
+    return this;
+  }
+  translate(etcDictionary) {
+    Object.assign(this.etcDictionary, etcDictionary);
+    return this;
+  }
+  _toTranslation() {
+    return Object.assign({}, this.errorDictionary, this.etcDictionary);
+  }
+  _registerToRoot(refName, rootDict) {
+    this.languages.forEach((language) => {
+      rootDict[language] ??= {};
+      rootDict[language][refName] ??= {};
+    });
+    this.#registerEndpointToRoot(refName, rootDict);
+    this.#registerErrorToRoot(refName, rootDict);
+    this.#registerEtcToRoot(refName, rootDict);
+  }
+  #registerEndpointToRoot(refName, rootDict) {
+    this.languages.forEach((language) => rootDict[language][refName].api ??= {});
+    Object.entries(this.endpointDictionary).forEach(
+      ([key, value]) => {
+        value.trans.forEach((t, idx) => rootDict[this.languages[idx]][refName].api[key] = { t, arg: {} });
+        value.descTrans?.forEach((t, idx) => rootDict[this.languages[idx]][refName].api[key].desc = { t });
+        Object.entries(value.argTrans).forEach(
+          ([argKey, argTrans]) => {
+            argTrans.trans.forEach((t, idx) => rootDict[this.languages[idx]][refName].api[key].arg[argKey] = { t });
+            argTrans.descTrans?.forEach(
+              (t, idx) => rootDict[this.languages[idx]][refName].api[key].arg[argKey].desc = { t }
+            );
+          }
+        );
+      }
+    );
+  }
+  #registerErrorToRoot(refName, rootDict) {
+    this.languages.forEach((language) => rootDict[language][refName].error ??= {});
+    Object.entries(this.errorDictionary).forEach(([key, value]) => {
+      value.forEach((t, idx) => {
+        rootDict[this.languages[idx]][refName].error[key] ??= {};
+        rootDict[this.languages[idx]][refName].error[key].t = t;
+      });
+    });
+  }
+  #registerEtcToRoot(refName, rootDict) {
+    Object.entries(this.etcDictionary).forEach(([key, value]) => {
+      value.forEach((t, idx) => {
+        rootDict[this.languages[idx]][refName][key] ??= {};
+        rootDict[this.languages[idx]][refName][key].t = t;
+      });
+    });
+  }
+}
+const serviceDictionary = (languages = ["en"]) => new ServiceDictInfo(languages);

package/cjs/src/dictionary.js

@@ -18,6 +18,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var dictionary_exports = {};
 __export(dictionary_exports, {
   Revert: () => Revert,
+  __Dict_Key__: () => __Dict_Key__,
+  __Error_Key__: () => __Error_Key__,
   dictionary: () => dictionary,
   getAllDictionary: () => getAllDictionary,
   getDictionary: () => getDictionary,
@@ -26,8 +28,7 @@ __export(dictionary_exports, {
 });
 module.exports = __toCommonJS(dictionary_exports);
 var import_base = require("./base.dictionary");
+var import_locale = require("./locale");
 var import_trans = require("./trans");
-const dictionary = {
-  base: import_base.baseDictionary
-};
-const { Revert, translate, msg, getDictionary, getAllDictionary } = (0, import_trans.makeTrans)(dictionary);
+const dictionary = { base: (0, import_locale.registerServiceTrans)(import_base.baseDictionary) };
+const { Revert, translate, msg, getDictionary, getAllDictionary, __Dict_Key__, __Error_Key__ } = (0, import_trans.makeTrans)(dictionary);

package/cjs/src/index.js

@@ -19,6 +19,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   Revert: () => import_dictionary.Revert,
+  __Dict_Key__: () => import_dictionary.__Dict_Key__,
+  __Error_Key__: () => import_dictionary.__Error_Key__,
   dictionary: () => import_dictionary.dictionary,
   getAllDictionary: () => import_dictionary.getAllDictionary,
   getDictionary: () => import_dictionary.getDictionary,
@@ -28,3 +30,5 @@ module.exports = __toCommonJS(src_exports);
 __reExport(src_exports, require("./trans"), module.exports);
 var import_dictionary = require("./dictionary");
 __reExport(src_exports, require("./serverTranslator"), module.exports);
+__reExport(src_exports, require("./dictInfo"), module.exports);
+__reExport(src_exports, require("./locale"), module.exports);

package/cjs/src/locale.js

@@ -0,0 +1,33 @@
+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 locale_exports = {};
+__export(locale_exports, {
+  registerModelTrans: () => registerModelTrans,
+  registerScalarTrans: () => registerScalarTrans,
+  registerServiceTrans: () => registerServiceTrans
+});
+module.exports = __toCommonJS(locale_exports);
+const registerModelTrans = (modelDict) => {
+  return { dict: modelDict };
+};
+const registerScalarTrans = (scalarDict) => {
+  return { dict: scalarDict };
+};
+const registerServiceTrans = (serviceDict) => {
+  return { dict: serviceDict };
+};

package/cjs/src/serverTranslator.js

@@ -51,10 +51,7 @@ class ServerTranslator {
     const trans = {
       dictionary,
       translate: (dictKey) => {
-        const keyParts = dictKey.split(".");
-        const model = keyParts[0];
-        const key = keyParts.slice(1).join(".");
-        return dictionary[model]?.[key] ?? dictKey;
+        return (0, import_common.pathGet)(dictKey, dictionary, ".", { t: dictKey }).t;
       }
     };
     ServerTranslator.#langTransMap.set(lang, trans);