@akanjs/devkit 0.0.89 → 0.0.90

package/src/getModelFileData.js

@@ -1,13 +1,45 @@
-import fs from "fs";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getModelFileData_exports = {};
+__export(getModelFileData_exports, {
+  getModelFileData: () => getModelFileData
+});
+module.exports = __toCommonJS(getModelFileData_exports);
+var import_fs = __toESM(require("fs"));
 const getModelFileData = (modulePath, modelName) => {
   const moduleType = modulePath.startsWith("apps") ? "app" : "lib";
   const moduleName = modulePath.split("/")[1];
   const constantFilePath = `${modulePath}/lib/${modelName}/${modelName}.constant.ts`;
   const unitFilePath = `${modulePath}/lib/${modelName}/${modelName}.Unit.tsx`;
   const viewFilePath = `${modulePath}/lib/${modelName}/${modelName}.View.tsx`;
-  const constantFileStr = fs.readFileSync(constantFilePath, "utf8");
-  const unitFileStr = fs.readFileSync(unitFilePath, "utf8");
-  const viewFileStr = fs.readFileSync(viewFilePath, "utf8");
+  const constantFileStr = import_fs.default.readFileSync(constantFilePath, "utf8");
+  const unitFileStr = import_fs.default.readFileSync(unitFilePath, "utf8");
+  const viewFileStr = import_fs.default.readFileSync(viewFilePath, "utf8");
   const constantFileLines = constantFileStr.split("\n");
   const importLibNames = constantFileLines.filter((line) => line.startsWith("import { cnst as ")).map((line) => line.split("cnst as ")[1].split(" ")[0]);
   const importLocalPaths = constantFileLines.filter((line) => line.startsWith("import { ") && line.includes('from "../')).map((line) => line.split("from ")[1].split('"')[1]);
@@ -28,6 +60,7 @@ const getModelFileData = (modulePath, modelName) => {
     viewFileStr
   };
 };
-export {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   getModelFileData
-};
+});

package/src/getModelFileData.mjs

@@ -0,0 +1,33 @@
+import fs from "fs";
+const getModelFileData = (modulePath, modelName) => {
+  const moduleType = modulePath.startsWith("apps") ? "app" : "lib";
+  const moduleName = modulePath.split("/")[1];
+  const constantFilePath = `${modulePath}/lib/${modelName}/${modelName}.constant.ts`;
+  const unitFilePath = `${modulePath}/lib/${modelName}/${modelName}.Unit.tsx`;
+  const viewFilePath = `${modulePath}/lib/${modelName}/${modelName}.View.tsx`;
+  const constantFileStr = fs.readFileSync(constantFilePath, "utf8");
+  const unitFileStr = fs.readFileSync(unitFilePath, "utf8");
+  const viewFileStr = fs.readFileSync(viewFilePath, "utf8");
+  const constantFileLines = constantFileStr.split("\n");
+  const importLibNames = constantFileLines.filter((line) => line.startsWith("import { cnst as ")).map((line) => line.split("cnst as ")[1].split(" ")[0]);
+  const importLocalPaths = constantFileLines.filter((line) => line.startsWith("import { ") && line.includes('from "../')).map((line) => line.split("from ")[1].split('"')[1]);
+  const importModelNames = importLocalPaths.map((path) => path.split("/")[1]).filter((name) => !name.startsWith("_"));
+  const hasImportScalar = !!importLocalPaths.map((path) => path.split("/")[1]).filter((name) => name.startsWith("_")).length;
+  return {
+    moduleType,
+    moduleName,
+    modelName,
+    constantFilePath,
+    unitFilePath,
+    viewFilePath,
+    importModelNames,
+    hasImportScalar,
+    importLibNames,
+    constantFileStr,
+    unitFileStr,
+    viewFileStr
+  };
+};
+export {
+  getModelFileData
+};

package/src/getRelatedCnsts.d.ts

@@ -1,9 +1,53 @@
-export declare const getRelatedCnsts: (constantFilePath: string) => {
-    paths: Map<string, {
-        filePath: string;
-        isLibModule: boolean;
-        isImport: boolean;
-        isScalar: boolean;
-        libName?: string;
-    }> | null;
+import * as ts from "typescript";
+/**
+ * TypeScript 설정 파일을 읽고 파싱하는 함수
+ */
+export declare const parseTsConfig: (tsConfigPath?: string) => ts.ParsedCommandLine;
+/**
+ * 파일 내의 임포트를 기반으로 관련 파일을 수집하는 함수
+ */
+export declare const collectImportedFiles: (constantFilePath: string, parsedConfig: ts.ParsedCommandLine) => {
+    allFilesToAnalyze: Set<string>;
+    analyzedFiles: Set<string>;
+};
+/**
+ * export 선언을 기반으로 관련 파일을 수집하는 함수
+ */
+export declare const collectExportedFiles: (constantFilePath: string, parsedConfig: ts.ParsedCommandLine) => {
+    allFilesToAnalyze: Set<string>;
+    analyzedFiles: Set<string>;
 };
+/**
+ * TypeScript 프로그램 생성 함수
+ */
+export declare const createTsProgram: (filePaths: Set<string>, options: ts.CompilerOptions) => {
+    program: ts.Program;
+    checker: ts.TypeChecker;
+};
+/**
+ * 심볼 캐싱 및 조회 함수 생성기
+ */
+export declare const createSymbolCache: (checker: ts.TypeChecker) => (node: ts.Node) => ts.Symbol | undefined;
+/**
+ * 파일 속성 분석 함수
+ */
+export declare const analyzeProperties: (filesToAnalyze: Set<string>, program: ts.Program, checker: ts.TypeChecker) => Map<string, {
+    filePath: string;
+    isLibModule: boolean;
+    isImport: boolean;
+    isScalar: boolean;
+    source: string;
+    libName?: string;
+}>;
+/**
+ * 메인 함수: 상수 파일 관련 요소 분석
+ */
+export declare const getRelatedCnsts: (constantFilePath: string) => {
+    filePath: string;
+    isLibModule: boolean;
+    isImport: boolean;
+    isScalar: boolean;
+    source: string;
+    libName?: string;
+    key: string;
+}[];

package/src/getRelatedCnsts.js

@@ -1,23 +1,183 @@
-import fs from "fs";
-import ora from "ora";
-import * as ts from "typescript";
-const getRelatedCnsts = (constantFilePath) => {
-  const tsConfigPath = `./tsconfig.json`;
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getRelatedCnsts_exports = {};
+__export(getRelatedCnsts_exports, {
+  analyzeProperties: () => analyzeProperties,
+  collectExportedFiles: () => collectExportedFiles,
+  collectImportedFiles: () => collectImportedFiles,
+  createSymbolCache: () => createSymbolCache,
+  createTsProgram: () => createTsProgram,
+  getRelatedCnsts: () => getRelatedCnsts,
+  parseTsConfig: () => parseTsConfig
+});
+module.exports = __toCommonJS(getRelatedCnsts_exports);
+var fs = __toESM(require("fs"));
+var import_ora = __toESM(require("ora"));
+var ts = __toESM(require("typescript"));
+const parseTsConfig = (tsConfigPath = "./tsconfig.json") => {
   const configFile = ts.readConfigFile(tsConfigPath, (path) => {
     return ts.sys.readFile(path);
   });
-  const parsedConfig = ts.parseJsonConfigFileContent(
+  return ts.parseJsonConfigFileContent(
     configFile.config,
     ts.sys,
     fs.realpathSync(tsConfigPath).replace(/[^/\\]+$/, "")
   );
+};
+const collectImportedFiles = (constantFilePath, parsedConfig) => {
+  const allFilesToAnalyze = /* @__PURE__ */ new Set([constantFilePath]);
+  const analyzedFiles = /* @__PURE__ */ new Set();
+  const spinner = (0, import_ora.default)("Collecting related files...");
+  spinner.start();
+  function collectImported(filePath) {
+    if (analyzedFiles.has(filePath))
+      return;
+    analyzedFiles.add(filePath);
+    const tempProgram = ts.createProgram([filePath], parsedConfig.options);
+    const source = tempProgram.getSourceFile(filePath);
+    if (!source)
+      return;
+    function collectImports(node) {
+      if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
+        const importPath = node.moduleSpecifier.text;
+        if (importPath.startsWith(".")) {
+          const resolved = ts.resolveModuleName(importPath, filePath, parsedConfig.options, ts.sys).resolvedModule?.resolvedFileName;
+          if (resolved && !allFilesToAnalyze.has(resolved)) {
+            allFilesToAnalyze.add(resolved);
+            collectImported(resolved);
+          }
+        }
+      }
+      ts.forEachChild(node, collectImports);
+    }
+    collectImports(source);
+  }
+  collectImported(constantFilePath);
+  spinner.succeed(`Found ${allFilesToAnalyze.size} related files.`);
+  return {
+    allFilesToAnalyze,
+    analyzedFiles
+  };
+};
+const collectExportedFiles = (constantFilePath, parsedConfig) => {
+  const allFilesToAnalyze = /* @__PURE__ */ new Set([constantFilePath]);
+  const analyzedFiles = /* @__PURE__ */ new Set();
+  const spinner = (0, import_ora.default)("Collecting files from exports...");
+  spinner.start();
+  function collectExported(filePath) {
+    if (analyzedFiles.has(filePath))
+      return;
+    analyzedFiles.add(filePath);
+    const tempProgram = ts.createProgram([filePath], parsedConfig.options);
+    const source = tempProgram.getSourceFile(filePath);
+    if (!source)
+      return;
+    function collectExports(node) {
+      if (ts.isExportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier) && !node.exportClause) {
+        const exportPath = node.moduleSpecifier.text;
+        if (exportPath.startsWith(".")) {
+          const resolved = ts.resolveModuleName(exportPath, filePath, parsedConfig.options, ts.sys).resolvedModule?.resolvedFileName;
+          if (resolved && !allFilesToAnalyze.has(resolved)) {
+            allFilesToAnalyze.add(resolved);
+            collectExported(resolved);
+          }
+        }
+      } else if (ts.isExportDeclaration(node) && node.exportClause && ts.isNamedExports(node.exportClause) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
+        const exportPath = node.moduleSpecifier.text;
+        if (exportPath.startsWith(".")) {
+          const resolved = ts.resolveModuleName(exportPath, filePath, parsedConfig.options, ts.sys).resolvedModule?.resolvedFileName;
+          if (resolved && !allFilesToAnalyze.has(resolved)) {
+            allFilesToAnalyze.add(resolved);
+            collectExported(resolved);
+          }
+        }
+      } else if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
+        const importPath = node.moduleSpecifier.text;
+        if (importPath.startsWith(".")) {
+          const resolved = ts.resolveModuleName(importPath, filePath, parsedConfig.options, ts.sys).resolvedModule?.resolvedFileName;
+          if (resolved && !allFilesToAnalyze.has(resolved)) {
+            allFilesToAnalyze.add(resolved);
+            collectExported(resolved);
+          }
+        }
+      }
+      if ((ts.isVariableStatement(node) || ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node)) && node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) {
+      }
+      ts.forEachChild(node, collectExports);
+    }
+    collectExports(source);
+  }
+  collectExported(constantFilePath);
+  spinner.succeed(`Found ${allFilesToAnalyze.size} related files from exports.`);
+  return {
+    allFilesToAnalyze,
+    analyzedFiles
+  };
+};
+const createTsProgram = (filePaths, options) => {
+  const spinner = (0, import_ora.default)("Creating TypeScript program for all files...");
+  spinner.start();
+  const program = ts.createProgram(Array.from(filePaths), options);
+  const checker = program.getTypeChecker();
+  spinner.succeed("TypeScript program created.");
+  return {
+    program,
+    checker
+  };
+};
+const createSymbolCache = (checker) => {
+  const symbolCache = /* @__PURE__ */ new Map();
+  return (node) => {
+    const cacheKey = `${node.getSourceFile().fileName}:${node.pos}:${node.end}`;
+    if (!symbolCache.has(cacheKey)) {
+      symbolCache.set(cacheKey, checker.getSymbolAtLocation(node));
+    }
+    return symbolCache.get(cacheKey);
+  };
+};
+const analyzeProperties = (filesToAnalyze, program, checker) => {
   const propertyMap = /* @__PURE__ */ new Map();
-  function findPropertyOriginAll(filePath) {
-    const program = ts.createProgram([filePath], parsedConfig.options);
-    const checker = program.getTypeChecker();
+  const analyzedFiles = /* @__PURE__ */ new Set();
+  const sourceLineCache = /* @__PURE__ */ new Map();
+  const getCachedSymbol = createSymbolCache(checker);
+  const spinner = (0, import_ora.default)("Analyzing property relationships...");
+  spinner.start();
+  function analyzeFileProperties(filePath) {
+    if (analyzedFiles.has(filePath))
+      return;
+    analyzedFiles.add(filePath);
     const source = program.getSourceFile(filePath);
     if (!source)
-      return null;
+      return;
+    if (!sourceLineCache.has(filePath)) {
+      sourceLineCache.set(filePath, source.getFullText().split("\n"));
+    }
+    const sourceLines = sourceLineCache.get(filePath);
     function visit(node) {
       if (!source)
         return;
@@ -25,38 +185,38 @@ const getRelatedCnsts = (constantFilePath) => {
         const left = node.expression;
         const right = node.name;
         const { line } = ts.getLineAndCharacterOfPosition(source, node.getStart());
-        //!Field.Prop 거르기가 빡세네.
-        const sourceLines = source.getFullText().split("\n");
-        if (ts.isIdentifier(left) && sourceLines.length && (sourceLines[line].includes(`@Field.Prop(() => ${left.text}.${right.text}`) || sourceLines[line].includes(`base.Filter(${left.text}.${right.text},`))) {
-          const symbol = checker.getSymbolAtLocation(right);
+        if (ts.isIdentifier(left) && sourceLines && sourceLines.length > line && (sourceLines[line].includes(`@Field.Prop(() => ${left.text}.${right.text}`) || sourceLines[line].includes(`base.Filter(${left.text}.${right.text},`))) {
+          const symbol = getCachedSymbol(right);
           if (symbol?.declarations && symbol.declarations.length > 0) {
             const key = symbol.declarations[0].getSourceFile().fileName.split("/").pop()?.split(".")[0] ?? "";
             const property = propertyMap.get(key);
             const isScalar = symbol.declarations[0].getSourceFile().fileName.includes("_");
-            const filePath2 = symbol.declarations[0].getSourceFile().fileName.replace(`${ts.sys.getCurrentDirectory()}/`, "");
+            const symbolFilePath = symbol.declarations[0].getSourceFile().fileName.replace(`${ts.sys.getCurrentDirectory()}/`, "");
             if (property) {
               propertyMap.set(`${left.text}.${right.text}`, {
-                filePath: filePath2,
+                filePath: symbolFilePath,
                 isLibModule: true,
                 isImport: false,
                 libName: left.text,
+                source: fs.readFileSync(symbolFilePath, "utf-8"),
                 isScalar
               });
-            } else
+            } else {
               propertyMap.set(key, {
-                filePath: filePath2,
+                filePath: symbolFilePath,
                 isLibModule: true,
                 isImport: false,
                 libName: left.text,
-                isScalar
+                isScalar,
+                source: fs.readFileSync(symbolFilePath, "utf-8")
               });
-            findPropertyOriginAll(filePath2);
+            }
           }
         }
-      } else if (ts.isImportDeclaration(node)) {
-        const importPath = node.moduleSpecifier.getText().slice(1, -1);
+      } else if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
+        const importPath = node.moduleSpecifier.text;
         if (importPath.startsWith(".")) {
-          const resolved = ts.resolveModuleName(importPath, filePath, parsedConfig.options, ts.sys).resolvedModule?.resolvedFileName;
+          const resolved = ts.resolveModuleName(importPath, filePath, program.getCompilerOptions(), ts.sys).resolvedModule?.resolvedFileName;
           const moduleName = importPath.split("/").pop()?.split(".")[0] ?? "";
           const property = propertyMap.get(moduleName);
           const isScalar = importPath.includes("_");
@@ -65,45 +225,36 @@ const getRelatedCnsts = (constantFilePath) => {
               filePath: resolved,
               isLibModule: false,
               isImport: true,
-              isScalar
+              isScalar,
+              source: fs.readFileSync(resolved, "utf-8")
             });
-            findPropertyOriginAll(resolved);
           }
         }
       }
       ts.forEachChild(node, visit);
     }
     visit(source);
-    return propertyMap;
   }
-  function findPropertyOrigin(filePath, aliasName, libName) {
-    const program = ts.createProgram([filePath], parsedConfig.options);
-    const checker = program.getTypeChecker();
-    const source = program.getSourceFile(filePath);
-    const propertyMap2 = /* @__PURE__ */ new Map();
-    if (!source)
-      return null;
-    function visit(node) {
-      if (ts.isPropertyAccessExpression(node)) {
-        const left = node.expression;
-        const right = node.name;
-        if (ts.isIdentifier(left) && left.text === aliasName && right.text === libName) {
-          const symbol = checker.getSymbolAtLocation(right);
-          if (symbol?.declarations && symbol.declarations.length > 0) {
-            return symbol.declarations[0].getSourceFile().fileName;
-          }
-        }
-      }
-      return ts.forEachChild(node, visit) || null;
-    }
-    return visit(source);
+  for (const filePath of filesToAnalyze) {
+    analyzeFileProperties(filePath);
   }
-  const spinner = ora("Finding property origin...");
-  spinner.start();
-  const paths = findPropertyOriginAll(constantFilePath);
-  spinner.succeed("property origin found.");
-  return { paths };
+  spinner.succeed(`Analysis complete. Found ${propertyMap.size} properties.`);
+  return propertyMap;
 };
-export {
-  getRelatedCnsts
+const getRelatedCnsts = (constantFilePath) => {
+  const parsedConfig = parseTsConfig();
+  const { allFilesToAnalyze } = collectImportedFiles(constantFilePath, parsedConfig);
+  const { program, checker } = createTsProgram(allFilesToAnalyze, parsedConfig.options);
+  const propertyMap = analyzeProperties(allFilesToAnalyze, program, checker);
+  return Array.from(propertyMap.entries()).map(([key, value]) => ({ key, ...value }));
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  analyzeProperties,
+  collectExportedFiles,
+  collectImportedFiles,
+  createSymbolCache,
+  createTsProgram,
+  getRelatedCnsts,
+  parseTsConfig
+});