@akanjs/dictionary 0.0.4

package/README.md

@@ -0,0 +1,11 @@
+# akan
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build akan` to build the library.
+
+## Running unit tests
+
+Run `nx test akan` to execute the unit tests via [Jest](https://jestjs.io).

package/index.d.ts

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

package/index.js

@@ -0,0 +1,21 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dictionary_exports = {};
+module.exports = __toCommonJS(dictionary_exports);
+__reExport(dictionary_exports, require("./src"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./src")
+});

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@akanjs/dictionary",
+  "version": "0.0.4",
+  "type": "commonjs",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/akan-team/akanjs.git",
+    "directory": "pkgs/@akanjs/dictionary"
+  },
+  "dependencies": {
+    "@urql/core": "5.1.0",
+    "bull": "4.16.5",
+    "dayjs": "1.11.13",
+    "express": "4.21.2",
+    "immer": "10.1.1",
+    "mongoose": "8.9.3",
+    "next": "15.1.3",
+    "pluralize": "8.0.0",
+    "react": "18.2.0",
+    "react-dom": "18.2.0",
+    "reflect-metadata": "0.2.2",
+    "socket.io": "4.8.1",
+    "socket.io-client": "4.8.1",
+    "tunnel-ssh": "5.2.0"
+  },
+  "main": "./index.js"
+}

package/src/index.d.ts

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

package/src/index.js

@@ -0,0 +1,21 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./trans"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./trans")
+});

package/src/trans.d.ts

@@ -0,0 +1,188 @@
+import { type BaseFilterKey, type GetActionObject, type GetStateObject } from "@akanjs/constant";
+import { DefaultSignal } from "@akanjs/signal";
+type TranslationSingle = readonly [string, string] | readonly [string, string, string, string];
+type TranslationWithParam = readonly [string, string, {
+    [key: string]: string | number;
+}];
+export type Translation = TranslationSingle | TranslationWithParam;
+export type Translate<Checker> = {
+    [K in keyof GetStateObject<Checker>]: Translation;
+} & {
+    [key: string]: Translation;
+} & {
+    modelName: Translation;
+};
+export type ExtendModelDictionary<Model, Insight = unknown, Filter = unknown> = {
+    [K in keyof Omit<GetStateObject<Model & Insight & Filter>, BaseFilterKey> as K extends string ? K | `desc-${K}` : never]: Translation;
+} & {
+    [K in keyof Omit<GetActionObject<Filter>, BaseFilterKey> as K extends string ? `qry-${K}` | `qrydesc-${K}` : never]: Translation;
+} & {
+    [key: string]: Translation;
+};
+export type ModelDictionary<Model, Insight = unknown, Filter = unknown> = {
+    [K in keyof GetStateObject<Model & Insight & Filter> as K extends string ? K | `desc-${K}` : never]: Translation;
+} & {
+    [K in keyof GetActionObject<Filter> as K extends string ? `qry-${K}` | `qrydesc-${K}` : never]: Translation;
+} & {
+    [key: string]: Translation;
+} & {
+    modelName: Translation;
+    modelDesc: Translation;
+};
+export type SummaryDictionary<Summary> = {
+    [K in keyof GetStateObject<Summary> as K extends string ? K | `desc-${K}` : never]: Translation;
+};
+export type SignalDictionary<Checker, Model = unknown> = {
+    [K in keyof GetActionObject<Checker> as K extends string ? K extends keyof Model ? never : Checker[K] extends (...args: any) => Promise<{
+        __Returns__: "Done";
+    }> ? never : `apidesc-${K}` | `api-${K}` : never]: Translation;
+} & {
+    [key: string]: Translation;
+};
+export type GetKeys<O> = O extends infer U ? (U extends object ? keyof U : never) : never;
+export type TransMessage<Locale extends Record<string, any>> = Locale extends infer U ? U extends object ? {
+    [K in keyof U]-?: `${K & string}${U[K] extends Record<string, any> ? `.${GetKeys<U[K]>}` : never}`;
+}[keyof U] : never : never;
+export declare const baseTrans: {
+    readonly id: readonly ["Id", "아이디"];
+    readonly "desc-id": readonly ["Unique ID value", "유니크한 아이디값"];
+    readonly createdAt: readonly ["CreatedAt", "생성일"];
+    readonly "desc-createdAt": readonly ["Data created time", "데이터 생성 시각"];
+    readonly updatedAt: readonly ["UpdatedAt", "수정일"];
+    readonly "desc-updatedAt": readonly ["Data updated time", "데이터 마지막 수정 시각"];
+    readonly removedAt: readonly ["RemovedAt", "삭제일"];
+    readonly "desc-removedAt": readonly ["Data removed time", "데이터 삭제 시각"];
+    readonly status: readonly ["Status", "상태"];
+    readonly "desc-status": readonly ["Data status", "데이터 상태"];
+    readonly count: readonly ["Count", "개수"];
+    readonly "desc-count": readonly ["Data count", "데이터 개수"];
+    readonly latest: readonly ["latest", "최신순"];
+    readonly "desc-latest": readonly ["latest", "최신순"];
+    readonly oldest: readonly ["oldest", "오래된순"];
+    readonly "desc-oldest": readonly ["oldest", "오래된순"];
+    readonly "qry-any": readonly ["All", "전체"];
+    readonly "qrydesc-any": readonly ["All", "전체"];
+    readonly "qry-byStatuses": readonly ["By Statuses", "상태별 조회"];
+    readonly "qrydesc-byStatuses": readonly ["By Statuses", "상태별 조회"];
+    readonly "qarg-byStatuses-statuses": readonly ["Statuses", "상태"];
+    readonly "qargdesc-byStatuses-statuses": readonly ["Statuses", "상태"];
+};
+type BaseSignalTrans<T extends string> = {
+    [K in keyof DefaultSignal<T, any, any, any, any, any> as K extends string ? `apidesc-${K}` | `api-${K}` : never]: Translation;
+};
+export declare const getBaseSignalTrans: <T extends string>(modelName: T) => BaseSignalTrans<T>;
+export declare const checkDictCoverage: () => void;
+type MergeDoubleDepths<T, U> = U extends undefined ? T : {
+    [K in keyof T | keyof U]: K extends keyof T ? K extends keyof U ? T[K] & U[K] : T[K] : K extends keyof U ? U[K] : never;
+};
+export declare const rootDictionary: {
+    [key: string]: {
+        [key: string]: Translation;
+    };
+};
+export declare const makeDictionary: <RootDict extends {
+    [key: string]: {
+        [key: string]: Translation;
+    };
+}, Dict1 extends {
+    [key: string]: {
+        [key: string]: Translation;
+    };
+}, Dict2 = unknown, Dict3 = unknown, Dict4 = unknown, Dict5 = unknown>(rootDict: RootDict, dict1: Dict1, dict2?: Dict2, dict3?: Dict3, dict4?: Dict4, dict5?: Dict5) => MergeDoubleDepths<MergeDoubleDepths<MergeDoubleDepths<MergeDoubleDepths<MergeDoubleDepths<RootDict, Dict1>, Dict2>, Dict3>, Dict4>, Dict5>;
+declare const languages: readonly ["ko", "en", "zhChs", "zhCht"];
+type Language = (typeof languages)[number];
+export declare const msg: {
+    info: (key: TransMessage<any>, option?: {
+        key?: string;
+        duration?: number;
+        data?: {
+            [key: string]: any;
+        };
+    }) => void;
+    success: (key: TransMessage<any>, option?: {
+        key?: string;
+        duration?: number;
+        data?: {
+            [key: string]: any;
+        };
+    }) => void;
+    error: (key: TransMessage<any>, option?: {
+        key?: string;
+        duration?: number;
+        data?: {
+            [key: string]: any;
+        };
+    }) => void;
+    warning: (key: TransMessage<any>, option?: {
+        key?: string;
+        duration?: number;
+        data?: {
+            [key: string]: any;
+        };
+    }) => void;
+    loading: (key: TransMessage<any>, option?: {
+        key?: string;
+        duration?: number;
+        data?: {
+            [key: string]: any;
+        };
+    }) => void;
+};
+export declare const makeTrans: <Locale extends {
+    [key: string]: {
+        [key: string]: Translation;
+    };
+}>(locale: Locale) => {
+    revert: (key: TransMessage<Locale>, data?: any) => never;
+    Revert: {
+        new (key: TransMessage<Locale>, data?: any): {
+            name: string;
+            message: string;
+            stack?: string;
+        };
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+        stackTraceLimit: number;
+    };
+    translate: (lang: Language, key: TransMessage<Locale>, data?: any) => string | {
+        [key: string]: string | number;
+    };
+    msg: {
+        info: (key: TransMessage<Locale>, option?: {
+            key?: string;
+            duration?: number;
+            data?: {
+                [key: string]: any;
+            };
+        }) => void;
+        success: (key: TransMessage<Locale>, option?: {
+            key?: string;
+            duration?: number;
+            data?: {
+                [key: string]: any;
+            };
+        }) => void;
+        error: (key: TransMessage<Locale>, option?: {
+            key?: string;
+            duration?: number;
+            data?: {
+                [key: string]: any;
+            };
+        }) => void;
+        warning: (key: TransMessage<Locale>, option?: {
+            key?: string;
+            duration?: number;
+            data?: {
+                [key: string]: any;
+            };
+        }) => void;
+        loading: (key: TransMessage<Locale>, option?: {
+            key?: string;
+            duration?: number;
+            data?: {
+                [key: string]: any;
+            };
+        }) => void;
+    };
+};
+export {};

package/src/trans.js

@@ -0,0 +1,377 @@
+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"],
+  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 = (0, import_common.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 = (0, import_constant.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) {
+          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) {
+          import_common.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)) {
+      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) => [...(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))
+      import_common.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 = (0, import_signal.getGqlMetas)(sigRef);
+    gqlMetas.filter((gqlMeta) => gqlMeta.type !== "Process").forEach((gqlMeta) => {
+      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) {
+          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) {
+          import_common.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))
+      import_common.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 = (0, import_constant.getFilterQueryMap)(filterRef);
+    filterMetaMap.forEach((filterMeta) => {
+      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)
+          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)
+          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))
+      import_common.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);
+    return classMeta.type === "full" && classMeta.modelType === "data";
+  }).map((modelRef) => {
+    const classMeta = (0, import_constant.getClassMeta)(modelRef);
+    const modelName = (0, import_common.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);
+    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));
+    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);
+    return { modelName, modelRef };
+  });
+  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 = (0, import_common.lowerlize)(filterMeta.refName.slice(0, -6));
+    return { modelName, filterModelRef };
+  });
+  const signalRefs = (0, import_signal.getAllSignalRefs)();
+  const fullModelSignalRefEntries = signalRefs.filter((ref) => {
+    const sigMeta = (0, import_signal.getSigMeta)(ref);
+    if (!sigMeta.returns)
+      return false;
+    const modelRef = sigMeta.returns();
+    const classMeta = (0, import_constant.getClassMeta)(modelRef);
+    return classMeta.type === "full";
+  }).map((sigRef) => {
+    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 = (0, import_signal.getSigMeta)(ref);
+    if (!sigMeta.returns)
+      return false;
+    const modelRef = sigMeta.returns();
+    const classMeta = (0, import_constant.getClassMeta)(modelRef);
+    return classMeta.type === "scalar";
+  }).map((sigRef) => {
+    const sigMeta = (0, import_signal.getSigMeta)(sigRef);
+    const modelName = (0, import_common.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);
+    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
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  baseTrans,
+  checkDictCoverage,
+  getBaseSignalTrans,
+  makeDictionary,
+  makeTrans,
+  msg,
+  rootDictionary
+});