@akanjs/dictionary 0.9.55 → 0.9.57

package/esm/src/dictInfo.js

@@ -0,0 +1,465 @@
+import { capitalize } from "@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${capitalize(sliceKey)}`;
+        const insightKey = `${refName}Insight${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);
+export {
+  ModelDictInfo,
+  ScalarDictInfo,
+  ServiceDictInfo,
+  modelDictionary,
+  scalarDictionary,
+  serviceDictionary
+};

package/esm/src/dictionary.js

@@ -1,11 +1,12 @@
 import { baseDictionary } from "./base.dictionary";
+import { registerServiceTrans } from "./locale";
 import { makeTrans } from "./trans";
-const dictionary = {
-  base: baseDictionary
-};
-const { Revert, translate, msg, getDictionary, getAllDictionary } = makeTrans(dictionary);
+const dictionary = { base: registerServiceTrans(baseDictionary) };
+const { Revert, translate, msg, getDictionary, getAllDictionary, __Dict_Key__, __Error_Key__ } = makeTrans(dictionary);
 export {
   Revert,
+  __Dict_Key__,
+  __Error_Key__,
   dictionary,
   getAllDictionary,
   getDictionary,

package/esm/src/index.js

@@ -1,8 +1,20 @@
 export * from "./trans";
-import { Revert, translate, dictionary, getDictionary, getAllDictionary } from "./dictionary";
+import {
+  Revert,
+  translate,
+  dictionary,
+  getDictionary,
+  getAllDictionary,
+  __Dict_Key__,
+  __Error_Key__
+} from "./dictionary";
 export * from "./serverTranslator";
+export * from "./dictInfo";
+export * from "./locale";
 export {
   Revert,
+  __Dict_Key__,
+  __Error_Key__,
   dictionary,
   getAllDictionary,
   getDictionary,

package/esm/src/locale.js

@@ -0,0 +1,14 @@
+const registerModelTrans = (modelDict) => {
+  return { dict: modelDict };
+};
+const registerScalarTrans = (scalarDict) => {
+  return { dict: scalarDict };
+};
+const registerServiceTrans = (serviceDict) => {
+  return { dict: serviceDict };
+};
+export {
+  registerModelTrans,
+  registerScalarTrans,
+  registerServiceTrans
+};

package/esm/src/serverTranslator.js

@@ -1,5 +1,5 @@
 import { baseClientEnv } from "@akanjs/base";
-import { Logger } from "@akanjs/common";
+import { Logger, pathGet } from "@akanjs/common";
 class ServerTranslator {
   static #langTransMap = /* @__PURE__ */ new Map();
   async init(lang) {
@@ -28,10 +28,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 pathGet(dictKey, dictionary, ".", { t: dictKey }).t;
       }
     };
     ServerTranslator.#langTransMap.set(lang, trans);