@akanjs/dictionary 0.0.54 → 0.0.56

package/index.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/dictionary",
-  "version": "0.0.54",
+  "version": "0.0.56",
   "type": "commonjs",
   "publishConfig": {
     "access": "public"
@@ -14,5 +14,11 @@
   "engines": {
     "node": ">=22"
   },
-  "dependencies": {}
+  "dependencies": {},
+  "exports": {
+    ".": {
+      "require": "./index.js",
+      "import": "./index.mjs"
+    }
+  }
 }

package/src/index.mjs

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

package/src/trans.mjs

@@ -0,0 +1,358 @@
+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"],
+  createdAt: ["CreatedAt", "\uC0DD\uC131\uC77C"],
+  "desc-createdAt": ["Data created time", "\uB370\uC774\uD130 \uC0DD\uC131 \uC2DC\uAC01"],
+  updatedAt: ["UpdatedAt", "\uC218\uC815\uC77C"],
+  "desc-updatedAt": ["Data updated time", "\uB370\uC774\uD130 \uB9C8\uC9C0\uB9C9 \uC218\uC815 \uC2DC\uAC01"],
+  removedAt: ["RemovedAt", "\uC0AD\uC81C\uC77C"],
+  "desc-removedAt": ["Data removed time", "\uB370\uC774\uD130 \uC0AD\uC81C \uC2DC\uAC01"],
+  status: ["Status", "\uC0C1\uD0DC"],
+  "desc-status": ["Data status", "\uB370\uC774\uD130 \uC0C1\uD0DC"],
+  count: ["Count", "\uAC1C\uC218"],
+  "desc-count": ["Data count", "\uB370\uC774\uD130 \uAC1C\uC218"],
+  latest: ["latest", "\uCD5C\uC2E0\uC21C"],
+  "desc-latest": ["latest", "\uCD5C\uC2E0\uC21C"],
+  oldest: ["oldest", "\uC624\uB798\uB41C\uC21C"],
+  "desc-oldest": ["oldest", "\uC624\uB798\uB41C\uC21C"],
+  "qry-any": ["All", "\uC804\uCCB4"],
+  "qrydesc-any": ["All", "\uC804\uCCB4"],
+  "qry-byStatuses": ["By Statuses", "\uC0C1\uD0DC\uBCC4 \uC870\uD68C"],
+  "qrydesc-byStatuses": ["By Statuses", "\uC0C1\uD0DC\uBCC4 \uC870\uD68C"],
+  "qarg-byStatuses-statuses": ["Statuses", "\uC0C1\uD0DC"],
+  "qargdesc-byStatuses-statuses": ["Statuses", "\uC0C1\uD0DC"]
+};
+const getBaseSignalTrans = (modelName) => {
+  const className = capitalize(modelName);
+  return {
+    // * ==================== Endpoint ==================== * //
+    [`api-light${className}`]: [`Get light version of ${modelName}`, `${modelName} \uACBD\uB7C9\uD654 \uBC84\uC804 \uC870\uD68C`],
+    [`apidesc-light${className}`]: [`Get light version of ${modelName}`, `${modelName} \uACBD\uB7C9\uD654 \uBC84\uC804 \uC870\uD68C`],
+    [`arg-light${className}-${modelName}Id`]: [`Id of ${modelName}`, `${modelName} \uC544\uC774\uB514`],
+    [`argdesc-light${className}-${modelName}Id`]: [`Id of ${modelName}`, `${modelName} \uC544\uC774\uB514`],
+    [`api-${modelName}`]: [`Get ${modelName}`, `${modelName} \uC870\uD68C`],
+    [`apidesc-${modelName}`]: [`Get ${modelName}`, `${modelName} \uC870\uD68C`],
+    [`arg-${modelName}-${modelName}Id`]: [`Id of ${modelName}`, `${modelName} \uC544\uC774\uB514`],
+    [`argdesc-${modelName}-${modelName}Id`]: [`Id of ${modelName}`, `${modelName} \uC544\uC774\uB514`],
+    [`api-${modelName}List`]: [`Get ${modelName} list`, `${modelName} \uB9AC\uC2A4\uD2B8 \uC870\uD68C`],
+    [`apidesc-${modelName}List`]: [`Get ${modelName} list`, `${modelName} \uB9AC\uC2A4\uD2B8 \uC870\uD68C`],
+    [`arg-${modelName}List-query`]: [`Query of ${modelName}`, `${modelName} \uCFFC\uB9AC`],
+    [`argdesc-${modelName}List-query`]: [`Query of ${modelName}`, `${modelName} \uCFFC\uB9AC`],
+    [`arg-${modelName}List-skip`]: [`Skip of ${modelName}`, `${modelName} \uC2A4\uD0B5`],
+    [`argdesc-${modelName}List-skip`]: [`Skip of ${modelName}`, `${modelName} \uC2A4\uD0B5`],
+    [`arg-${modelName}List-limit`]: [`Limit of ${modelName}`, `${modelName} \uC81C\uD55C`],
+    [`argdesc-${modelName}List-limit`]: [`Limit of ${modelName}`, `${modelName} \uC81C\uD55C`],
+    [`arg-${modelName}List-sort`]: [`Sort of ${modelName}`, `${modelName} \uC815\uB82C`],
+    [`argdesc-${modelName}List-sort`]: [`Sort of ${modelName}`, `${modelName} \uC815\uB82C`],
+    [`api-${modelName}Insight`]: [`Get ${modelName} insight`, `${modelName} \uC778\uC0AC\uC774\uD2B8 \uC870\uD68C`],
+    [`apidesc-${modelName}Insight`]: [`Get ${modelName} insight`, `${modelName} \uC778\uC0AC\uC774\uD2B8 \uC870\uD68C`],
+    [`arg-${modelName}Insight-query`]: [`Query of ${modelName}`, `${modelName} \uCFFC\uB9AC`],
+    [`argdesc-${modelName}Insight-query`]: [`Query of ${modelName}`, `${modelName} \uCFFC\uB9AC`],
+    [`api-${modelName}Exists`]: [`Check ${modelName} exists`, `${modelName} \uC874\uC7AC \uC5EC\uBD80 \uD655\uC778`],
+    [`apidesc-${modelName}Exists`]: [`Check ${modelName} exists`, `${modelName} \uC874\uC7AC \uC5EC\uBD80 \uD655\uC778`],
+    [`arg-${modelName}Exists-query`]: [`Query of ${modelName}`, `${modelName} \uCFFC\uB9AC`],
+    [`argdesc-${modelName}Exists-query`]: [`Query of ${modelName}`, `${modelName} \uCFFC\uB9AC`],
+    [`api-create${className}`]: [`Create ${modelName}`, `${modelName} \uC0DD\uC131`],
+    [`apidesc-create${className}`]: [`Create ${modelName}`, `${modelName} \uC0DD\uC131`],
+    [`arg-create${className}-data`]: [`Data of ${modelName}`, `${modelName} \uB370\uC774\uD130`],
+    [`argdesc-create${className}-data`]: [`Data of ${modelName}`, `${modelName} \uB370\uC774\uD130`],
+    [`api-update${className}`]: [`Update ${modelName}`, `${modelName} \uC218\uC815`],
+    [`apidesc-update${className}`]: [`Update ${modelName}`, `${modelName} \uC218\uC815`],
+    [`arg-update${className}-${modelName}Id`]: [`Id of ${modelName}`, `${modelName} \uC544\uC774\uB514`],
+    [`argdesc-update${className}-${modelName}Id`]: [`Id of ${modelName}`, `${modelName} \uC544\uC774\uB514`],
+    [`arg-update${className}-data`]: [`Data of ${modelName}`, `${modelName} \uB370\uC774\uD130`],
+    [`argdesc-update${className}-data`]: [`Data of ${modelName}`, `${modelName} \uB370\uC774\uD130`],
+    [`api-remove${className}`]: [`Remove ${modelName}`, `${modelName} \uC0AD\uC81C`],
+    [`apidesc-remove${className}`]: [`Remove ${modelName}`, `${modelName} \uC0AD\uC81C`],
+    [`arg-remove${className}-${modelName}Id`]: [`Id of ${modelName}`, `${modelName} \uC544\uC774\uB514`],
+    [`argdesc-remove${className}-${modelName}Id`]: [`Id of ${modelName}`, `${modelName} \uC544\uC774\uB514`]
+    // * ==================== Endpoint ==================== * //
+  };
+};
+const checkModelDictCoverages = (modelName, dictionary, modelRefs, filterRefs) => {
+  const enumKeyMap = /* @__PURE__ */ new Map();
+  modelRefs.forEach((modelRef) => {
+    const fieldMetaMap = getFieldMetaMap(modelRef);
+    [...fieldMetaMap.values()].forEach((fieldMeta) => {
+      if (!fieldMeta.enum)
+        return;
+      enumKeyMap.set(fieldMeta.key, new Set(fieldMeta.enum.map((value) => value.toString())));
+      fieldMeta.enum.forEach((value) => {
+        const enumDict = dictionary[`enum-${fieldMeta.key}-${value}`];
+        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}`);
+        }
+        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}`);
+        }
+      });
+    });
+  });
+  Object.keys(dictionary).filter((key) => key.startsWith("enum-")).forEach((key) => {
+    const [, fieldKey, ...values] = key.split("-");
+    const value = values.join("-");
+    if (!enumKeyMap.get(fieldKey)?.has(value)) {
+      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()
+  ]);
+  Object.keys(dictionary).filter((key) => key.startsWith("desc-")).forEach((key) => {
+    const [, fieldKey] = key.split("-");
+    if (!fieldKeySet.has(fieldKey))
+      Logger.error(
+        `\u{1F47B} Unused description translation, need to delete: ${modelName}.${fieldKey} & ${modelName}.desc-${fieldKey}`
+      );
+  });
+};
+const checkSignalDictCoverages = (modelName, sigRefs, dictionary) => {
+  const argKeyMap = /* @__PURE__ */ new Map();
+  sigRefs.forEach((sigRef) => {
+    const gqlMetas = getGqlMetas(sigRef);
+    gqlMetas.filter((gqlMeta) => gqlMeta.type !== "Process").forEach((gqlMeta) => {
+      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) {
+          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}`);
+        }
+      });
+    });
+  });
+  Object.keys(dictionary).filter((key) => key.startsWith("arg-")).forEach((key) => {
+    const [, gqlKey, argKey] = key.split("-");
+    if (!argKeyMap.get(gqlKey)?.has(argKey))
+      Logger.error(
+        `\u{1F47B} Unused arg translation, need to delete: ${modelName}.arg-${gqlKey}-${argKey} & ${modelName}.argdesc-${gqlKey}-${argKey}`
+      );
+  });
+};
+const checkFilterDictCoverages = (modelName, filterRefs, dictionary) => {
+  const qargKeyMap = /* @__PURE__ */ new Map();
+  filterRefs.forEach((filterRef) => {
+    const filterMetaMap = getFilterQueryMap(filterRef);
+    filterMetaMap.forEach((filterMeta) => {
+      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)
+          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}`);
+      });
+    });
+  });
+  Object.keys(dictionary).filter((key) => key.startsWith("qarg-")).forEach((key) => {
+    const [, filterKey, filterArgKey] = key.split("-");
+    if (!qargKeyMap.get(filterKey)?.has(filterArgKey))
+      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);
+    return classMeta.type === "full" && classMeta.modelType === "data";
+  }).map((modelRef) => {
+    const classMeta = getClassMeta(modelRef);
+    const modelName = lowerlize(classMeta.refName);
+    return { modelName, 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 = 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);
+    return { modelName, modelRef };
+  });
+  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 = lowerlize(filterMeta.refName.slice(0, -6));
+    return { modelName, filterModelRef };
+  });
+  const signalRefs = getAllSignalRefs();
+  const fullModelSignalRefEntries = signalRefs.filter((ref) => {
+    const sigMeta = getSigMeta(ref);
+    if (!sigMeta.returns)
+      return false;
+    const modelRef = sigMeta.returns();
+    const classMeta = getClassMeta(modelRef);
+    return classMeta.type === "full";
+  }).map((sigRef) => {
+    const sigMeta = getSigMeta(sigRef);
+    const modelName = lowerlize(sigMeta.refName);
+    return { modelName, sigRef };
+  });
+  const scalarModelSignalRefEntries = signalRefs.filter((ref) => {
+    const sigMeta = getSigMeta(ref);
+    if (!sigMeta.returns)
+      return false;
+    const modelRef = sigMeta.returns();
+    const classMeta = getClassMeta(modelRef);
+    return classMeta.type === "scalar";
+  }).map((sigRef) => {
+    const sigMeta = getSigMeta(sigRef);
+    const modelName = 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);
+    return { modelName, sigRef };
+  });
+  const modelDictExamMap = /* @__PURE__ */ new Map();
+  const scalarDictExamMap = /* @__PURE__ */ new Map();
+  const signalDictExamMap = /* @__PURE__ */ new Map();
+  const getDefaultModelDict = () => ({ modelRefs: [], insightRefs: [], sigRefs: [], filterRefs: [] });
+  fullModelRefEntries.forEach(({ modelName, modelRef }) => {
+    const modelDictExam = modelDictExamMap.get(modelName) ?? getDefaultModelDict();
+    modelDictExam.modelRefs.push(modelRef);
+    modelDictExamMap.set(modelName, modelDictExam);
+  });
+  insightModelRefEntries.forEach(({ modelName, modelRef }) => {
+    const modelDictExam = modelDictExamMap.get(modelName) ?? getDefaultModelDict();
+    modelDictExam.insightRefs.push(modelRef);
+    modelDictExamMap.set(modelName, modelDictExam);
+  });
+  fullModelSignalRefEntries.forEach(({ modelName, sigRef }) => {
+    const modelDictExam = modelDictExamMap.get(modelName) ?? getDefaultModelDict();
+    modelDictExam.sigRefs.push(sigRef);
+    modelDictExamMap.set(modelName, modelDictExam);
+  });
+  filterModelRefEntries.forEach(({ modelName, filterModelRef }) => {
+    const modelDictExam = modelDictExamMap.get(modelName) ?? getDefaultModelDict();
+    modelDictExam.filterRefs.push(filterModelRef);
+    modelDictExamMap.set(modelName, modelDictExam);
+  });
+  const getDefaultScalarDict = () => ({ modelRefs: [], sigRefs: [] });
+  pureScalarModelRefEntries.forEach(({ modelName, modelRef }) => {
+    const scalarDictExam = scalarDictExamMap.get(modelName) ?? getDefaultScalarDict();
+    scalarDictExam.modelRefs.push(modelRef);
+    scalarDictExamMap.set(modelName, scalarDictExam);
+  });
+  scalarModelSignalRefEntries.forEach(({ modelName, sigRef }) => {
+    const scalarDictExam = scalarDictExamMap.get(modelName) ?? getDefaultScalarDict();
+    scalarDictExam.sigRefs.push(sigRef);
+    scalarDictExamMap.set(modelName, scalarDictExam);
+  });
+  const getDefaultSignalDict = () => ({ sigRefs: [] });
+  pureSignalRefEntries.forEach(({ modelName, sigRef }) => {
+    const signalDictExam = signalDictExamMap.get(modelName) ?? getDefaultSignalDict();
+    signalDictExam.sigRefs.push(sigRef);
+    signalDictExamMap.set(modelName, signalDictExam);
+  });
+  modelDictExamMap.forEach(({ modelRefs, insightRefs, sigRefs, filterRefs }, modelName) => {
+    const dictionary = rootDictionary[modelName];
+    if (!dictionary)
+      return;
+    checkModelDictCoverages(modelName, dictionary, [...modelRefs, ...insightRefs], filterRefs);
+    checkSignalDictCoverages(modelName, sigRefs, dictionary);
+    checkFilterDictCoverages(modelName, filterRefs, dictionary);
+  });
+  scalarDictExamMap.forEach(({ modelRefs, sigRefs }, modelName) => {
+    const dictionary = rootDictionary[modelName];
+    if (!dictionary)
+      return;
+    checkModelDictCoverages(modelName, dictionary, modelRefs, []);
+    checkSignalDictCoverages(modelName, sigRefs, dictionary);
+  });
+  signalDictExamMap.forEach(({ sigRefs }, modelName) => {
+    const dictionary = rootDictionary[modelName];
+    if (!dictionary)
+      return;
+    checkSignalDictCoverages(modelName, sigRefs, dictionary);
+  });
+};
+const rootDictionary = {};
+const makeDictionary = (rootDict, dict1, dict2, dict3, dict4, dict5) => {
+  const dicts = [dict1, dict2, dict3, dict4, dict5].filter((d) => !!d);
+  dicts.forEach((dict) => {
+    Object.entries(dict).forEach(([key, value]) => {
+      const rootValue = rootDict[key];
+      if (!rootValue)
+        Object.assign(rootDict, { [key]: value });
+      else
+        Object.assign(rootDict[key], value);
+    });
+  });
+  return rootDict;
+};
+const languages = ["ko", "en", "zhChs", "zhCht"];
+const msg = {
+  info: () => null,
+  success: () => null,
+  error: () => null,
+  warning: () => null,
+  loading: () => null
+};
+const makeTrans = (locale) => {
+  const revert = (key, data) => {
+    throw new Error(key);
+  };
+  class Revert extends Error {
+    constructor(key, data) {
+      super(key);
+    }
+  }
+  const translate = (lang, key, data) => {
+    const langIdx = languages.indexOf(lang);
+    const [modelName, msgKey] = key.split(".");
+    const model = locale[modelName];
+    const message = model[msgKey][langIdx];
+    if (!message)
+      throw new Error("Invalid message");
+    return message;
+  };
+  return {
+    revert,
+    Revert,
+    translate,
+    msg
+  };
+};
+export {
+  baseTrans,
+  checkDictCoverage,
+  getBaseSignalTrans,
+  makeDictionary,
+  makeTrans,
+  msg,
+  rootDictionary
+};