@akanjs/dictionary 0.0.102 → 0.0.103

package/index.js

@@ -1 +1,17 @@
-export * from "./src";
+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 dictionary_exports = {};
+module.exports = __toCommonJS(dictionary_exports);
+__reExport(dictionary_exports, require("./src"), module.exports);

package/index.mjs

@@ -0,0 +1 @@
+export * from "./src";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@akanjs/dictionary",
-  "version": "0.0.102",
-  "type": "module",
+  "version": "0.0.103",
+  "type": "commonjs",
   "publishConfig": {
     "access": "public"
   },
@@ -17,8 +17,8 @@
   "dependencies": {},
   "exports": {
     ".": {
-      "require": "./index.cjs",
-      "import": "./index.js"
+      "require": "./index.js",
+      "import": "./index.mjs"
     }
   },
   "esbuild": {

package/src/index.js

@@ -1 +1,17 @@
-export * from "./trans";
+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 src_exports = {};
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./trans"), module.exports);

package/src/index.mjs

@@ -0,0 +1 @@
+export * from "./trans";

package/src/trans.js

@@ -1,16 +1,34 @@
-import { capitalize, Logger, lowerlize } from "@akanjs/common";
-import {
-  getAllFilterModelRefs,
-  getAllFullModelRefs,
-  getAllScalarModelRefs,
-  getClassMeta,
-  getFieldMetaMap,
-  getFilterArgMetas,
-  getFilterMeta,
-  getFilterQueryMap,
-  getFilterSortMap
-} from "@akanjs/constant";
-import { getAllSignalRefs, getArgMetas, getGqlMetas, getSigMeta } from "@akanjs/signal";
+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 trans_exports = {};
+__export(trans_exports, {
+  baseTrans: () => baseTrans,
+  checkDictCoverage: () => checkDictCoverage,
+  getBaseSignalTrans: () => getBaseSignalTrans,
+  makeDictionary: () => makeDictionary,
+  makeTrans: () => makeTrans,
+  msg: () => msg,
+  rootDictionary: () => rootDictionary
+});
+module.exports = __toCommonJS(trans_exports);
+var import_common = require("@akanjs/common");
+var import_constant = require("@akanjs/constant");
+var import_signal = require("@akanjs/signal");
 const baseTrans = {
   id: ["Id", "\uC544\uC774\uB514"],
   "desc-id": ["Unique ID value", "\uC720\uB2C8\uD06C\uD55C \uC544\uC774\uB514\uAC12"],
@@ -36,7 +54,7 @@ const baseTrans = {
   "qargdesc-byStatuses-statuses": ["Statuses", "\uC0C1\uD0DC"]
 };
 const getBaseSignalTrans = (modelName) => {
-  const className = capitalize(modelName);
+  const className = (0, import_common.capitalize)(modelName);
   return {
     // * ==================== Endpoint ==================== * //
     [`api-light${className}`]: [`Get light version of ${modelName}`, `${modelName} \uACBD\uB7C9\uD654 \uBC84\uC804 \uC870\uD68C`],
@@ -85,7 +103,7 @@ const getBaseSignalTrans = (modelName) => {
 const checkModelDictCoverages = (modelName, dictionary, modelRefs, filterRefs) => {
   const enumKeyMap = /* @__PURE__ */ new Map();
   modelRefs.forEach((modelRef) => {
-    const fieldMetaMap = getFieldMetaMap(modelRef);
+    const fieldMetaMap = (0, import_constant.getFieldMetaMap)(modelRef);
     [...fieldMetaMap.values()].forEach((fieldMeta) => {
       if (!fieldMeta.enum)
         return;
@@ -95,12 +113,12 @@ const checkModelDictCoverages = (modelName, dictionary, modelRefs, filterRefs) =
         const modelDict = rootDictionary[modelName];
         const rootEnumDict = modelDict?.[`enum-${fieldMeta.key}-${value}`];
         if (!enumDict && !rootEnumDict) {
-          Logger.warn(`\u2620\uFE0F Missing enum translation: ${modelName}.enum-${fieldMeta.key}-${value}`);
+          import_common.Logger.warn(`\u2620\uFE0F Missing enum translation: ${modelName}.enum-${fieldMeta.key}-${value}`);
         }
         const enumDescDict = dictionary[`enumdesc-${fieldMeta.key}-${value}`];
         const rootEnumDescDict = modelDict?.[`enumdesc-${fieldMeta.key}-${value}`];
         if (!enumDescDict && !rootEnumDescDict) {
-          Logger.warn(`\u2620\uFE0F Missing enum description: ${modelName}.enumdesc-${fieldMeta.key}-${value}`);
+          import_common.Logger.warn(`\u2620\uFE0F Missing enum description: ${modelName}.enumdesc-${fieldMeta.key}-${value}`);
         }
       });
     });
@@ -109,19 +127,19 @@ const checkModelDictCoverages = (modelName, dictionary, modelRefs, filterRefs) =
     const [, fieldKey, ...values] = key.split("-");
     const value = values.join("-");
     if (!enumKeyMap.get(fieldKey)?.has(value)) {
-      Logger.error(
+      import_common.Logger.error(
         `\u{1F47B} Unused enum translation, need to delete: ${modelName}.enum-${fieldKey}-${value} & ${modelName}.enumdesc-${fieldKey}-${value}`
       );
     }
   });
   const fieldKeySet = /* @__PURE__ */ new Set([
-    ...modelRefs.map((modelRef) => [...getFieldMetaMap(modelRef).keys()]).flat(),
-    ...filterRefs.map((filterRef) => Object.keys(getFilterSortMap(filterRef))).flat()
+    ...modelRefs.map((modelRef) => [...(0, import_constant.getFieldMetaMap)(modelRef).keys()]).flat(),
+    ...filterRefs.map((filterRef) => Object.keys((0, import_constant.getFilterSortMap)(filterRef))).flat()
   ]);
   Object.keys(dictionary).filter((key) => key.startsWith("desc-")).forEach((key) => {
     const [, fieldKey] = key.split("-");
     if (!fieldKeySet.has(fieldKey))
-      Logger.error(
+      import_common.Logger.error(
         `\u{1F47B} Unused description translation, need to delete: ${modelName}.${fieldKey} & ${modelName}.desc-${fieldKey}`
       );
   });
@@ -129,18 +147,18 @@ const checkModelDictCoverages = (modelName, dictionary, modelRefs, filterRefs) =
 const checkSignalDictCoverages = (modelName, sigRefs, dictionary) => {
   const argKeyMap = /* @__PURE__ */ new Map();
   sigRefs.forEach((sigRef) => {
-    const gqlMetas = getGqlMetas(sigRef);
+    const gqlMetas = (0, import_signal.getGqlMetas)(sigRef);
     gqlMetas.filter((gqlMeta) => gqlMeta.type !== "Process").forEach((gqlMeta) => {
-      const [argMetas] = getArgMetas(sigRef, gqlMeta.key);
+      const [argMetas] = (0, import_signal.getArgMetas)(sigRef, gqlMeta.key);
       argKeyMap.set(gqlMeta.key, new Set(argMetas.map((argMeta) => argMeta.name)));
       argMetas.forEach((argMeta) => {
         const argDict = dictionary[`arg-${gqlMeta.key}-${argMeta.name}`];
         if (!argDict) {
-          Logger.warn(`\u2620\uFE0F Missing arg translation: ${modelName}.arg-${gqlMeta.key}-${argMeta.name}`);
+          import_common.Logger.warn(`\u2620\uFE0F Missing arg translation: ${modelName}.arg-${gqlMeta.key}-${argMeta.name}`);
         }
         const argDescDict = dictionary[`argdesc-${gqlMeta.key}-${argMeta.name}`];
         if (!argDescDict) {
-          Logger.warn(`\u2620\uFE0F Missing arg description: ${modelName}.argdesc-${gqlMeta.key}-${argMeta.name}`);
+          import_common.Logger.warn(`\u2620\uFE0F Missing arg description: ${modelName}.argdesc-${gqlMeta.key}-${argMeta.name}`);
         }
       });
     });
@@ -148,7 +166,7 @@ const checkSignalDictCoverages = (modelName, sigRefs, dictionary) => {
   Object.keys(dictionary).filter((key) => key.startsWith("arg-")).forEach((key) => {
     const [, gqlKey, argKey] = key.split("-");
     if (!argKeyMap.get(gqlKey)?.has(argKey))
-      Logger.error(
+      import_common.Logger.error(
         `\u{1F47B} Unused arg translation, need to delete: ${modelName}.arg-${gqlKey}-${argKey} & ${modelName}.argdesc-${gqlKey}-${argKey}`
       );
   });
@@ -156,85 +174,85 @@ const checkSignalDictCoverages = (modelName, sigRefs, dictionary) => {
 const checkFilterDictCoverages = (modelName, filterRefs, dictionary) => {
   const qargKeyMap = /* @__PURE__ */ new Map();
   filterRefs.forEach((filterRef) => {
-    const filterMetaMap = getFilterQueryMap(filterRef);
+    const filterMetaMap = (0, import_constant.getFilterQueryMap)(filterRef);
     filterMetaMap.forEach((filterMeta) => {
-      const filterArgMetas = getFilterArgMetas(filterRef, filterMeta.key);
+      const filterArgMetas = (0, import_constant.getFilterArgMetas)(filterRef, filterMeta.key);
       qargKeyMap.set(filterMeta.key, new Set(filterArgMetas.map((filterArgMeta) => filterArgMeta.name)));
       filterArgMetas.forEach((filterArgMeta) => {
         const qargDict = dictionary[`qarg-${filterMeta.key}-${filterArgMeta.name}`];
         if (!qargDict)
-          Logger.warn(`\u2620\uFE0F Missing qarg translation: ${modelName}.qarg-${filterMeta.key}-${filterArgMeta.name}`);
+          import_common.Logger.warn(`\u2620\uFE0F Missing qarg translation: ${modelName}.qarg-${filterMeta.key}-${filterArgMeta.name}`);
         const qargDescDict = dictionary[`qargdesc-${filterMeta.key}-${filterArgMeta.name}`];
         if (!qargDescDict)
-          Logger.warn(`\u2620\uFE0F Missing qarg description: ${modelName}.qargdesc-${filterMeta.key}-${filterArgMeta.name}`);
+          import_common.Logger.warn(`\u2620\uFE0F Missing qarg description: ${modelName}.qargdesc-${filterMeta.key}-${filterArgMeta.name}`);
       });
     });
   });
   Object.keys(dictionary).filter((key) => key.startsWith("qarg-")).forEach((key) => {
     const [, filterKey, filterArgKey] = key.split("-");
     if (!qargKeyMap.get(filterKey)?.has(filterArgKey))
-      Logger.error(
+      import_common.Logger.error(
         `\u{1F47B} Unused qarg translation, need to delete: ${modelName}.qarg-${filterKey}-${filterArgKey} & ${modelName}.qargdesc-${filterKey}-${filterArgKey}`
       );
   });
 };
 const checkDictCoverage = () => {
-  const fullModelRefEntries = getAllFullModelRefs().filter((modelRef) => {
-    const classMeta = getClassMeta(modelRef);
+  const fullModelRefEntries = (0, import_constant.getAllFullModelRefs)().filter((modelRef) => {
+    const classMeta = (0, import_constant.getClassMeta)(modelRef);
     return classMeta.type === "full" && classMeta.modelType === "data";
   }).map((modelRef) => {
-    const classMeta = getClassMeta(modelRef);
-    const modelName = lowerlize(classMeta.refName);
+    const classMeta = (0, import_constant.getClassMeta)(modelRef);
+    const modelName = (0, import_common.lowerlize)(classMeta.refName);
     return { modelName, modelRef };
   });
-  const scalarModelRefs = getAllScalarModelRefs();
-  const insightModelRefEntries = scalarModelRefs.filter((ref) => getClassMeta(ref).modelType === "insight").map((modelRef) => {
-    const classMeta = getClassMeta(modelRef);
+  const scalarModelRefs = (0, import_constant.getAllScalarModelRefs)();
+  const insightModelRefEntries = scalarModelRefs.filter((ref) => (0, import_constant.getClassMeta)(ref).modelType === "insight").map((modelRef) => {
+    const classMeta = (0, import_constant.getClassMeta)(modelRef);
     if (!classMeta.refName.endsWith("Insight"))
       throw new Error(`Invalid insight model name: ${classMeta.refName}`);
-    const modelName = lowerlize(classMeta.refName.slice(0, -7));
+    const modelName = (0, import_common.lowerlize)(classMeta.refName.slice(0, -7));
     return { modelName, modelRef };
   });
-  const pureScalarModelRefEntries = scalarModelRefs.filter((ref) => getClassMeta(ref).modelType === "data").map((modelRef) => {
-    const classMeta = getClassMeta(modelRef);
-    const modelName = lowerlize(classMeta.refName);
+  const pureScalarModelRefEntries = scalarModelRefs.filter((ref) => (0, import_constant.getClassMeta)(ref).modelType === "data").map((modelRef) => {
+    const classMeta = (0, import_constant.getClassMeta)(modelRef);
+    const modelName = (0, import_common.lowerlize)(classMeta.refName);
     return { modelName, modelRef };
   });
-  const filterModelRefEntries = getAllFilterModelRefs().map((filterModelRef) => {
-    const filterMeta = getFilterMeta(filterModelRef);
+  const filterModelRefEntries = (0, import_constant.getAllFilterModelRefs)().map((filterModelRef) => {
+    const filterMeta = (0, import_constant.getFilterMeta)(filterModelRef);
     if (!filterMeta.refName.endsWith("Filter"))
       throw new Error(`Invalid filter model name: ${filterMeta.refName}`);
-    const modelName = lowerlize(filterMeta.refName.slice(0, -6));
+    const modelName = (0, import_common.lowerlize)(filterMeta.refName.slice(0, -6));
     return { modelName, filterModelRef };
   });
-  const signalRefs = getAllSignalRefs();
+  const signalRefs = (0, import_signal.getAllSignalRefs)();
   const fullModelSignalRefEntries = signalRefs.filter((ref) => {
-    const sigMeta = getSigMeta(ref);
+    const sigMeta = (0, import_signal.getSigMeta)(ref);
     if (!sigMeta.returns)
       return false;
     const modelRef = sigMeta.returns();
-    const classMeta = getClassMeta(modelRef);
+    const classMeta = (0, import_constant.getClassMeta)(modelRef);
     return classMeta.type === "full";
   }).map((sigRef) => {
-    const sigMeta = getSigMeta(sigRef);
-    const modelName = lowerlize(sigMeta.refName);
+    const sigMeta = (0, import_signal.getSigMeta)(sigRef);
+    const modelName = (0, import_common.lowerlize)(sigMeta.refName);
     return { modelName, sigRef };
   });
   const scalarModelSignalRefEntries = signalRefs.filter((ref) => {
-    const sigMeta = getSigMeta(ref);
+    const sigMeta = (0, import_signal.getSigMeta)(ref);
     if (!sigMeta.returns)
       return false;
     const modelRef = sigMeta.returns();
-    const classMeta = getClassMeta(modelRef);
+    const classMeta = (0, import_constant.getClassMeta)(modelRef);
     return classMeta.type === "scalar";
   }).map((sigRef) => {
-    const sigMeta = getSigMeta(sigRef);
-    const modelName = lowerlize(sigMeta.refName);
+    const sigMeta = (0, import_signal.getSigMeta)(sigRef);
+    const modelName = (0, import_common.lowerlize)(sigMeta.refName);
     return { modelName, sigRef };
   });
-  const pureSignalRefEntries = signalRefs.filter((ref) => !getSigMeta(ref).returns).map((sigRef) => {
-    const sigMeta = getSigMeta(sigRef);
-    const modelName = lowerlize(sigMeta.refName);
+  const pureSignalRefEntries = signalRefs.filter((ref) => !(0, import_signal.getSigMeta)(ref).returns).map((sigRef) => {
+    const sigMeta = (0, import_signal.getSigMeta)(sigRef);
+    const modelName = (0, import_common.lowerlize)(sigMeta.refName);
     return { modelName, sigRef };
   });
   const modelDictExamMap = /* @__PURE__ */ new Map();
@@ -347,12 +365,3 @@ const makeTrans = (locale) => {
     msg
   };
 };
-export {
-  baseTrans,
-  checkDictCoverage,
-  getBaseSignalTrans,
-  makeDictionary,
-  makeTrans,
-  msg,
-  rootDictionary
-};

package/src/{trans.cjs → trans.mjs}

@@ -1,34 +1,16 @@
-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 trans_exports = {};
-__export(trans_exports, {
-  baseTrans: () => baseTrans,
-  checkDictCoverage: () => checkDictCoverage,
-  getBaseSignalTrans: () => getBaseSignalTrans,
-  makeDictionary: () => makeDictionary,
-  makeTrans: () => makeTrans,
-  msg: () => msg,
-  rootDictionary: () => rootDictionary
-});
-module.exports = __toCommonJS(trans_exports);
-var import_common = require("@akanjs/common");
-var import_constant = require("@akanjs/constant");
-var import_signal = require("@akanjs/signal");
+import { capitalize, Logger, lowerlize } from "@akanjs/common";
+import {
+  getAllFilterModelRefs,
+  getAllFullModelRefs,
+  getAllScalarModelRefs,
+  getClassMeta,
+  getFieldMetaMap,
+  getFilterArgMetas,
+  getFilterMeta,
+  getFilterQueryMap,
+  getFilterSortMap
+} from "@akanjs/constant";
+import { getAllSignalRefs, getArgMetas, getGqlMetas, getSigMeta } from "@akanjs/signal";
 const baseTrans = {
   id: ["Id", "\uC544\uC774\uB514"],
   "desc-id": ["Unique ID value", "\uC720\uB2C8\uD06C\uD55C \uC544\uC774\uB514\uAC12"],
@@ -54,7 +36,7 @@ const baseTrans = {
   "qargdesc-byStatuses-statuses": ["Statuses", "\uC0C1\uD0DC"]
 };
 const getBaseSignalTrans = (modelName) => {
-  const className = (0, import_common.capitalize)(modelName);
+  const className = capitalize(modelName);
   return {
     // * ==================== Endpoint ==================== * //
     [`api-light${className}`]: [`Get light version of ${modelName}`, `${modelName} \uACBD\uB7C9\uD654 \uBC84\uC804 \uC870\uD68C`],
@@ -103,7 +85,7 @@ const getBaseSignalTrans = (modelName) => {
 const checkModelDictCoverages = (modelName, dictionary, modelRefs, filterRefs) => {
   const enumKeyMap = /* @__PURE__ */ new Map();
   modelRefs.forEach((modelRef) => {
-    const fieldMetaMap = (0, import_constant.getFieldMetaMap)(modelRef);
+    const fieldMetaMap = getFieldMetaMap(modelRef);
     [...fieldMetaMap.values()].forEach((fieldMeta) => {
       if (!fieldMeta.enum)
         return;
@@ -113,12 +95,12 @@ const checkModelDictCoverages = (modelName, dictionary, modelRefs, filterRefs) =
         const modelDict = rootDictionary[modelName];
         const rootEnumDict = modelDict?.[`enum-${fieldMeta.key}-${value}`];
         if (!enumDict && !rootEnumDict) {
-          import_common.Logger.warn(`\u2620\uFE0F Missing enum translation: ${modelName}.enum-${fieldMeta.key}-${value}`);
+          Logger.warn(`\u2620\uFE0F Missing enum translation: ${modelName}.enum-${fieldMeta.key}-${value}`);
         }
         const enumDescDict = dictionary[`enumdesc-${fieldMeta.key}-${value}`];
         const rootEnumDescDict = modelDict?.[`enumdesc-${fieldMeta.key}-${value}`];
         if (!enumDescDict && !rootEnumDescDict) {
-          import_common.Logger.warn(`\u2620\uFE0F Missing enum description: ${modelName}.enumdesc-${fieldMeta.key}-${value}`);
+          Logger.warn(`\u2620\uFE0F Missing enum description: ${modelName}.enumdesc-${fieldMeta.key}-${value}`);
         }
       });
     });
@@ -127,19 +109,19 @@ const checkModelDictCoverages = (modelName, dictionary, modelRefs, filterRefs) =
     const [, fieldKey, ...values] = key.split("-");
     const value = values.join("-");
     if (!enumKeyMap.get(fieldKey)?.has(value)) {
-      import_common.Logger.error(
+      Logger.error(
         `\u{1F47B} Unused enum translation, need to delete: ${modelName}.enum-${fieldKey}-${value} & ${modelName}.enumdesc-${fieldKey}-${value}`
       );
     }
   });
   const fieldKeySet = /* @__PURE__ */ new Set([
-    ...modelRefs.map((modelRef) => [...(0, import_constant.getFieldMetaMap)(modelRef).keys()]).flat(),
-    ...filterRefs.map((filterRef) => Object.keys((0, import_constant.getFilterSortMap)(filterRef))).flat()
+    ...modelRefs.map((modelRef) => [...getFieldMetaMap(modelRef).keys()]).flat(),
+    ...filterRefs.map((filterRef) => Object.keys(getFilterSortMap(filterRef))).flat()
   ]);
   Object.keys(dictionary).filter((key) => key.startsWith("desc-")).forEach((key) => {
     const [, fieldKey] = key.split("-");
     if (!fieldKeySet.has(fieldKey))
-      import_common.Logger.error(
+      Logger.error(
         `\u{1F47B} Unused description translation, need to delete: ${modelName}.${fieldKey} & ${modelName}.desc-${fieldKey}`
       );
   });
@@ -147,18 +129,18 @@ const checkModelDictCoverages = (modelName, dictionary, modelRefs, filterRefs) =
 const checkSignalDictCoverages = (modelName, sigRefs, dictionary) => {
   const argKeyMap = /* @__PURE__ */ new Map();
   sigRefs.forEach((sigRef) => {
-    const gqlMetas = (0, import_signal.getGqlMetas)(sigRef);
+    const gqlMetas = getGqlMetas(sigRef);
     gqlMetas.filter((gqlMeta) => gqlMeta.type !== "Process").forEach((gqlMeta) => {
-      const [argMetas] = (0, import_signal.getArgMetas)(sigRef, gqlMeta.key);
+      const [argMetas] = getArgMetas(sigRef, gqlMeta.key);
       argKeyMap.set(gqlMeta.key, new Set(argMetas.map((argMeta) => argMeta.name)));
       argMetas.forEach((argMeta) => {
         const argDict = dictionary[`arg-${gqlMeta.key}-${argMeta.name}`];
         if (!argDict) {
-          import_common.Logger.warn(`\u2620\uFE0F Missing arg translation: ${modelName}.arg-${gqlMeta.key}-${argMeta.name}`);
+          Logger.warn(`\u2620\uFE0F Missing arg translation: ${modelName}.arg-${gqlMeta.key}-${argMeta.name}`);
         }
         const argDescDict = dictionary[`argdesc-${gqlMeta.key}-${argMeta.name}`];
         if (!argDescDict) {
-          import_common.Logger.warn(`\u2620\uFE0F Missing arg description: ${modelName}.argdesc-${gqlMeta.key}-${argMeta.name}`);
+          Logger.warn(`\u2620\uFE0F Missing arg description: ${modelName}.argdesc-${gqlMeta.key}-${argMeta.name}`);
         }
       });
     });
@@ -166,7 +148,7 @@ const checkSignalDictCoverages = (modelName, sigRefs, dictionary) => {
   Object.keys(dictionary).filter((key) => key.startsWith("arg-")).forEach((key) => {
     const [, gqlKey, argKey] = key.split("-");
     if (!argKeyMap.get(gqlKey)?.has(argKey))
-      import_common.Logger.error(
+      Logger.error(
         `\u{1F47B} Unused arg translation, need to delete: ${modelName}.arg-${gqlKey}-${argKey} & ${modelName}.argdesc-${gqlKey}-${argKey}`
       );
   });
@@ -174,85 +156,85 @@ const checkSignalDictCoverages = (modelName, sigRefs, dictionary) => {
 const checkFilterDictCoverages = (modelName, filterRefs, dictionary) => {
   const qargKeyMap = /* @__PURE__ */ new Map();
   filterRefs.forEach((filterRef) => {
-    const filterMetaMap = (0, import_constant.getFilterQueryMap)(filterRef);
+    const filterMetaMap = getFilterQueryMap(filterRef);
     filterMetaMap.forEach((filterMeta) => {
-      const filterArgMetas = (0, import_constant.getFilterArgMetas)(filterRef, filterMeta.key);
+      const filterArgMetas = getFilterArgMetas(filterRef, filterMeta.key);
       qargKeyMap.set(filterMeta.key, new Set(filterArgMetas.map((filterArgMeta) => filterArgMeta.name)));
       filterArgMetas.forEach((filterArgMeta) => {
         const qargDict = dictionary[`qarg-${filterMeta.key}-${filterArgMeta.name}`];
         if (!qargDict)
-          import_common.Logger.warn(`\u2620\uFE0F Missing qarg translation: ${modelName}.qarg-${filterMeta.key}-${filterArgMeta.name}`);
+          Logger.warn(`\u2620\uFE0F Missing qarg translation: ${modelName}.qarg-${filterMeta.key}-${filterArgMeta.name}`);
         const qargDescDict = dictionary[`qargdesc-${filterMeta.key}-${filterArgMeta.name}`];
         if (!qargDescDict)
-          import_common.Logger.warn(`\u2620\uFE0F Missing qarg description: ${modelName}.qargdesc-${filterMeta.key}-${filterArgMeta.name}`);
+          Logger.warn(`\u2620\uFE0F Missing qarg description: ${modelName}.qargdesc-${filterMeta.key}-${filterArgMeta.name}`);
       });
     });
   });
   Object.keys(dictionary).filter((key) => key.startsWith("qarg-")).forEach((key) => {
     const [, filterKey, filterArgKey] = key.split("-");
     if (!qargKeyMap.get(filterKey)?.has(filterArgKey))
-      import_common.Logger.error(
+      Logger.error(
         `\u{1F47B} Unused qarg translation, need to delete: ${modelName}.qarg-${filterKey}-${filterArgKey} & ${modelName}.qargdesc-${filterKey}-${filterArgKey}`
       );
   });
 };
 const checkDictCoverage = () => {
-  const fullModelRefEntries = (0, import_constant.getAllFullModelRefs)().filter((modelRef) => {
-    const classMeta = (0, import_constant.getClassMeta)(modelRef);
+  const fullModelRefEntries = getAllFullModelRefs().filter((modelRef) => {
+    const classMeta = getClassMeta(modelRef);
     return classMeta.type === "full" && classMeta.modelType === "data";
   }).map((modelRef) => {
-    const classMeta = (0, import_constant.getClassMeta)(modelRef);
-    const modelName = (0, import_common.lowerlize)(classMeta.refName);
+    const classMeta = getClassMeta(modelRef);
+    const modelName = lowerlize(classMeta.refName);
     return { modelName, modelRef };
   });
-  const scalarModelRefs = (0, import_constant.getAllScalarModelRefs)();
-  const insightModelRefEntries = scalarModelRefs.filter((ref) => (0, import_constant.getClassMeta)(ref).modelType === "insight").map((modelRef) => {
-    const classMeta = (0, import_constant.getClassMeta)(modelRef);
+  const scalarModelRefs = getAllScalarModelRefs();
+  const insightModelRefEntries = scalarModelRefs.filter((ref) => getClassMeta(ref).modelType === "insight").map((modelRef) => {
+    const classMeta = getClassMeta(modelRef);
     if (!classMeta.refName.endsWith("Insight"))
       throw new Error(`Invalid insight model name: ${classMeta.refName}`);
-    const modelName = (0, import_common.lowerlize)(classMeta.refName.slice(0, -7));
+    const modelName = lowerlize(classMeta.refName.slice(0, -7));
     return { modelName, modelRef };
   });
-  const pureScalarModelRefEntries = scalarModelRefs.filter((ref) => (0, import_constant.getClassMeta)(ref).modelType === "data").map((modelRef) => {
-    const classMeta = (0, import_constant.getClassMeta)(modelRef);
-    const modelName = (0, import_common.lowerlize)(classMeta.refName);
+  const pureScalarModelRefEntries = scalarModelRefs.filter((ref) => getClassMeta(ref).modelType === "data").map((modelRef) => {
+    const classMeta = getClassMeta(modelRef);
+    const modelName = lowerlize(classMeta.refName);
     return { modelName, modelRef };
   });
-  const filterModelRefEntries = (0, import_constant.getAllFilterModelRefs)().map((filterModelRef) => {
-    const filterMeta = (0, import_constant.getFilterMeta)(filterModelRef);
+  const filterModelRefEntries = getAllFilterModelRefs().map((filterModelRef) => {
+    const filterMeta = getFilterMeta(filterModelRef);
     if (!filterMeta.refName.endsWith("Filter"))
       throw new Error(`Invalid filter model name: ${filterMeta.refName}`);
-    const modelName = (0, import_common.lowerlize)(filterMeta.refName.slice(0, -6));
+    const modelName = lowerlize(filterMeta.refName.slice(0, -6));
     return { modelName, filterModelRef };
   });
-  const signalRefs = (0, import_signal.getAllSignalRefs)();
+  const signalRefs = getAllSignalRefs();
   const fullModelSignalRefEntries = signalRefs.filter((ref) => {
-    const sigMeta = (0, import_signal.getSigMeta)(ref);
+    const sigMeta = getSigMeta(ref);
     if (!sigMeta.returns)
       return false;
     const modelRef = sigMeta.returns();
-    const classMeta = (0, import_constant.getClassMeta)(modelRef);
+    const classMeta = getClassMeta(modelRef);
     return classMeta.type === "full";
   }).map((sigRef) => {
-    const sigMeta = (0, import_signal.getSigMeta)(sigRef);
-    const modelName = (0, import_common.lowerlize)(sigMeta.refName);
+    const sigMeta = getSigMeta(sigRef);
+    const modelName = lowerlize(sigMeta.refName);
     return { modelName, sigRef };
   });
   const scalarModelSignalRefEntries = signalRefs.filter((ref) => {
-    const sigMeta = (0, import_signal.getSigMeta)(ref);
+    const sigMeta = getSigMeta(ref);
     if (!sigMeta.returns)
       return false;
     const modelRef = sigMeta.returns();
-    const classMeta = (0, import_constant.getClassMeta)(modelRef);
+    const classMeta = getClassMeta(modelRef);
     return classMeta.type === "scalar";
   }).map((sigRef) => {
-    const sigMeta = (0, import_signal.getSigMeta)(sigRef);
-    const modelName = (0, import_common.lowerlize)(sigMeta.refName);
+    const sigMeta = getSigMeta(sigRef);
+    const modelName = lowerlize(sigMeta.refName);
     return { modelName, sigRef };
   });
-  const pureSignalRefEntries = signalRefs.filter((ref) => !(0, import_signal.getSigMeta)(ref).returns).map((sigRef) => {
-    const sigMeta = (0, import_signal.getSigMeta)(sigRef);
-    const modelName = (0, import_common.lowerlize)(sigMeta.refName);
+  const pureSignalRefEntries = signalRefs.filter((ref) => !getSigMeta(ref).returns).map((sigRef) => {
+    const sigMeta = getSigMeta(sigRef);
+    const modelName = lowerlize(sigMeta.refName);
     return { modelName, sigRef };
   });
   const modelDictExamMap = /* @__PURE__ */ new Map();
@@ -365,3 +347,12 @@ const makeTrans = (locale) => {
     msg
   };
 };
+export {
+  baseTrans,
+  checkDictCoverage,
+  getBaseSignalTrans,
+  makeDictionary,
+  makeTrans,
+  msg,
+  rootDictionary
+};

package/index.cjs

@@ -1,17 +0,0 @@
-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 dictionary_exports = {};
-module.exports = __toCommonJS(dictionary_exports);
-__reExport(dictionary_exports, require("./src"), module.exports);

package/src/index.cjs

@@ -1,17 +0,0 @@
-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 src_exports = {};
-module.exports = __toCommonJS(src_exports);
-__reExport(src_exports, require("./trans"), module.exports);