@simplysm/sd-cli 12.11.8 → 12.11.10

package/src/ts-compiler/sd-dependency-cache.ts

@@ -1,138 +1,184 @@
 import { TNormPath } from "@simplysm/sd-core-node";
 
 export class SdDependencyCache {
-  #exportCache = new Map<
-    /* fileNPath: */ TNormPath,
-    /* exportSymbolSet: */ Set<string>
-  >();
-
-  #importCache = new Map<
-    /* fileNPath: */ TNormPath,
+  /**
+   * 각 파일이 export한 심볼 집합 (예: export const A → "A")
+   */
+  private _exportCache = new Map<TNormPath, Set<string>>();
+
+  /**
+   * import한 타겟과 그 심볼 정보
+   * - 값이 0이면 전체 import(import * 또는 리소스 import)
+   * - 값이 Set이면 선택적 심볼 import (예: import { A } ...)
+   */
+  private _importCache = new Map<TNormPath, Map<TNormPath, Set<string> | 0>>();
+
+  /**
+   * re-export한 타겟과 그 심볼 정보
+   * - export * from ...
+   * - export { A as B } from ...
+   * - 값이 0이면 전체 reexport(export * from ...)
+   */
+  private _reexportCache = new Map<
+    TNormPath,
     Map<
-      /* targetNPath: */ TNormPath,
-      /* targetSymbolSet: */ Set<string> | 0
+      TNormPath,
+      | {
+          importSymbol: string;
+          exportSymbol: string;
+        }[]
+      | 0
     >
   >();
 
-  #reexportCache = new Map<
-    /* fileNPath: */ TNormPath,
-    Map<
-      /* targetNPath: */ TNormPath,
-      /* targetSymbolInfos: */ {
-      importSymbol: string;
-      exportSymbol: string;
-    }[] | 0
-    >
-  >();
-
-  #revDepCache = new Map<
-    /* targetNPath: */ TNormPath,
-    Map<
-      /* fileNPath: */ TNormPath,
-      /* exportSymbolSet: */ Set<string> | 0 // fileNPath입장에선 import, targetNPath입장에선 export
-    >
-  >();
-
-  #collectedCache = new Set<TNormPath>();
+  /**
+   * 역의존 정보 (revDep)
+   * - 특정 파일이 어떤 파일에게 의존(참조)되는지
+   * - symbol 기반 추적
+   */
+  private _revDepCache = new Map<TNormPath, Map<TNormPath, Set<string> | 0>>();
+
+  /**
+   * 분석이 완료된 파일 경로
+   */
+  private _collectedCache = new Set<TNormPath>();
+
+  /**
+   * .d.ts 또는 .js가 입력되었을 때 쌍으로 존재하는 파일 경로를 반환
+   * 예: "/a.d.ts" → ["/a.d.ts", "/a.js"]
+   */
+  #getRelatedNPaths(nPath: TNormPath): TNormPath[] {
+    if (nPath.endsWith(".d.ts")) {
+      return [nPath, nPath.replace(/\.d\.ts$/, ".js") as TNormPath];
+    }
+    if (nPath.endsWith(".js")) {
+      return [nPath, nPath.replace(/\.js$/, ".d.ts") as TNormPath];
+    }
+    return [nPath];
+  }
 
+  /**
+   * 전체 추적된 파일 경로를 반환
+   */
   getFiles(): Set<TNormPath> {
-    return new Set<TNormPath>([
-      ...this.#collectedCache.keys(),
-      ...this.#revDepCache.keys(),
-    ]);
+    return new Set<TNormPath>([...this._collectedCache.keys(), ...this._revDepCache.keys()]);
   }
 
+  /**
+   * 분석이 완료된 파일로 표시
+   */
   addCollected(fileNPath: TNormPath) {
-    this.#collectedCache.add(fileNPath);
+    for (const path of this.#getRelatedNPaths(fileNPath)) {
+      this._collectedCache.add(path);
+    }
   }
 
   hasCollected(fileNPath: TNormPath) {
-    return this.#collectedCache.has(fileNPath);
+    return this._collectedCache.has(fileNPath);
   }
 
-  // export const ...
-  // export function/class/interface A ...
+  /**
+   * export한 심볼 등록
+   * 예: export const A → "A"
+   */
   addExport(fileNPath: TNormPath, exportSymbol: string) {
-    const exportSymbolSet = this.#exportCache.getOrCreate(fileNPath, new Set());
-    exportSymbolSet.add(exportSymbol);
+    for (const path of this.#getRelatedNPaths(fileNPath)) {
+      const exportSymbolSet = this._exportCache.getOrCreate(path, new Set());
+      exportSymbolSet.add(exportSymbol);
+    }
   }
 
-  // import * from "..."
-  // import ... from "..."
-  // import(...)
-  // require(...)
+  /**
+   * import 구문 등록
+   * - import * from ... → symbol = 0
+   * - import { A } from ... → symbol = "A"
+   */
   addImport(fileNPath: TNormPath, targetNPath: TNormPath, targetSymbol: string | 0) {
-    const importTargetMap = this.#importCache.getOrCreate(fileNPath, new Map());
-    if (targetSymbol === 0) {
-      importTargetMap.set(targetNPath, 0);
-      this.#addRevDep(targetNPath, fileNPath, 0);
-    }
-    else {
-      const importTargetSymbolSet = importTargetMap.getOrCreate(targetNPath, new Set());
-      if (importTargetSymbolSet === 0) {
-        return;
+    for (const filePath of this.#getRelatedNPaths(fileNPath)) {
+      for (const targetPath of this.#getRelatedNPaths(targetNPath)) {
+        const importTargetMap = this._importCache.getOrCreate(filePath, new Map());
+
+        if (targetSymbol === 0) {
+          importTargetMap.set(targetPath, 0);
+          this.#addRevDep(targetPath, filePath, 0);
+        } else {
+          const importTargetSymbolSet = importTargetMap.getOrCreate(targetPath, new Set());
+          if (importTargetSymbolSet === 0) return;
+
+          importTargetSymbolSet.add(targetSymbol);
+          this.#addRevDep(targetPath, filePath, targetSymbol);
+        }
       }
-
-      importTargetSymbolSet.add(targetSymbol);
-      this.#addRevDep(targetNPath, fileNPath, targetSymbol);
     }
   }
 
-  // export * from '...'
-  // export { A as B } from '...'
-  //
-  // exoprt/import에 자동등록하진 않음.
-  // 차후 계산시 모든 캐시가 사용되므로,
-  // 이 클래스를 사용하는 곳에서는 따로따로 입력하면됨
+  /**
+   * export * or export { A as B } from ... 구문 등록
+   * ※ export/import에 자동 등록되지 않으므로 외부에서 명시적으로 따로 입력해야 함
+   */
   addReexport(
     fileNPath: TNormPath,
     targetNPath: TNormPath,
-    targetSymbolInfo: { importSymbol: string, exportSymbol: string } | 0,
+    targetSymbolInfo:
+      | {
+          importSymbol: string;
+          exportSymbol: string;
+        }
+      | 0,
   ) {
-    const reexportTargetMap = this.#reexportCache.getOrCreate(fileNPath, new Map());
-    if (targetSymbolInfo === 0) {
-      reexportTargetMap.set(targetNPath, 0);
-      this.#addRevDep(targetNPath, fileNPath, 0);
-    }
-    else {
-      const reexportTargetSymbolInfos = reexportTargetMap.getOrCreate(targetNPath, []);
-      if (reexportTargetSymbolInfos === 0) {
-        return;
-      }
-
-      if (
-        !reexportTargetSymbolInfos.some(item =>
-          item.importSymbol === targetSymbolInfo.importSymbol &&
-          item.exportSymbol === targetSymbolInfo.exportSymbol,
-        )
-      ) {
-        reexportTargetSymbolInfos.push(targetSymbolInfo);
-        this.#addRevDep(targetNPath, fileNPath, targetSymbolInfo.importSymbol);
+    for (const filePath of this.#getRelatedNPaths(fileNPath)) {
+      for (const targetPath of this.#getRelatedNPaths(targetNPath)) {
+        const reexportTargetMap = this._reexportCache.getOrCreate(filePath, new Map());
+
+        if (targetSymbolInfo === 0) {
+          reexportTargetMap.set(targetPath, 0);
+          this.#addRevDep(targetPath, filePath, 0);
+        } else {
+          const reexportTargetSymbolInfos = reexportTargetMap.getOrCreate(targetPath, []);
+          if (reexportTargetSymbolInfos === 0) return;
+
+          if (
+            !reexportTargetSymbolInfos.some(
+              (item) =>
+                item.importSymbol === targetSymbolInfo.importSymbol &&
+                item.exportSymbol === targetSymbolInfo.exportSymbol,
+            )
+          ) {
+            reexportTargetSymbolInfos.push(targetSymbolInfo);
+            this.#addRevDep(targetPath, filePath, targetSymbolInfo.importSymbol);
+          }
+        }
       }
     }
   }
 
+  /**
+   * 역의존 관계 등록 (revDep)
+   */
   #addRevDep(targetNPath: TNormPath, fileNPath: TNormPath, exportSymbol: string | 0) {
-    const revDepInfoMap = this.#revDepCache.getOrCreate(targetNPath, new Map());
-    if (exportSymbol === 0) {
-      revDepInfoMap.set(fileNPath, exportSymbol);
-    }
-    else {
-      const exportSymbolSet = revDepInfoMap.getOrCreate(fileNPath, new Set());
-      if (exportSymbolSet === 0) {
-        return;
+    for (const targetPath of this.#getRelatedNPaths(targetNPath)) {
+      for (const filePath of this.#getRelatedNPaths(fileNPath)) {
+        const revDepInfoMap = this._revDepCache.getOrCreate(targetPath, new Map());
+        if (exportSymbol === 0) {
+          revDepInfoMap.set(filePath, 0);
+        } else {
+          const exportSymbolSet = revDepInfoMap.getOrCreate(filePath, new Set());
+          if (exportSymbolSet === 0) return;
+
+          exportSymbolSet.add(exportSymbol);
+        }
       }
-
-      exportSymbolSet.add(exportSymbol);
     }
   }
 
+  /**
+   * 변경된 파일 경로 집합으로부터 영향을 받는 전체 파일 집합을 계산
+   */
   getAffectedFileSet(modifiedNPathSet: Set<TNormPath>): Set<TNormPath> {
     const visited = new Set<string>();
+    const result = new Set<TNormPath>();
 
-    const result = new Set<TNormPath>(modifiedNPathSet);
-
-    const queue: { fileNPath: TNormPath, exportSymbol: string | undefined }[] = [];
+    const queue: { fileNPath: TNormPath; exportSymbol: string | undefined }[] = [];
 
     const enqueue = (fileNPath: TNormPath, exportSymbol: string | undefined) => {
       const key = `${fileNPath}#${exportSymbol}`;
@@ -143,45 +189,37 @@ export class SdDependencyCache {
     };
 
     for (const modifiedNPath of modifiedNPathSet) {
-      const exportSymbols = this.#getExportSymbols(modifiedNPath);
-      if (exportSymbols.size === 0) {
-        enqueue(modifiedNPath, undefined);
-      }
-      else {
-        for (const symbol of exportSymbols) {
-          enqueue(modifiedNPath, symbol);
+      for (const path of this.#getRelatedNPaths(modifiedNPath)) {
+        result.add(path);
+        const exportSymbols = this.#getExportSymbols(path);
+        if (exportSymbols.size === 0) {
+          enqueue(path, undefined);
+        } else {
+          for (const symbol of exportSymbols) {
+            enqueue(path, symbol);
+          }
         }
       }
     }
 
     while (queue.length > 0) {
       const curr = queue.shift()!;
-
-      /*const key = curr.fileNPath + "#" + curr.exportSymbol;
-      if (visited.has(key)) continue;
-      visited.add(key);*/
-
-      const revDepInfoMap = this.#revDepCache.get(curr.fileNPath);
+      const revDepInfoMap = this._revDepCache.get(curr.fileNPath);
       if (!revDepInfoMap) continue;
 
       for (const [revDepFileNPath, revDepInfo] of revDepInfoMap) {
         if (curr.exportSymbol != null) {
-          // curr의 export를 토대로 revDep이 사용하고 있는지 체크
-          // curr.exportSymbol 와 revDev의 importSymbol은 같다
           const hasImportSymbol = revDepInfo === 0 || revDepInfo.has(curr.exportSymbol);
           if (hasImportSymbol) {
             result.add(revDepFileNPath);
-
-            // 하위 Deps를 queue에 넣기전 export명칭 변환 (이름을 변경한 reexport일 경우 필요)
             const exportSymbol = this.#convertImportSymbolToExportSymbol(
               revDepFileNPath,
               curr.fileNPath,
-              curr.exportSymbol, // revdep의 importSymbol
+              curr.exportSymbol,
             );
             enqueue(revDepFileNPath, exportSymbol);
           }
-        }
-        else { // Resource
+        } else {
           result.add(revDepFileNPath);
         }
       }
@@ -190,61 +228,64 @@ export class SdDependencyCache {
     return result;
   }
 
+  /**
+   * 주어진 파일들 및 그 영향 범위에 해당하는 모든 캐시를 무효화
+   */
   invalidates(fileNPathSet: Set<TNormPath>) {
     const affectedFiles = this.getAffectedFileSet(fileNPathSet);
 
     for (const fileNPath of affectedFiles) {
-      this.#exportCache.delete(fileNPath);
-      this.#importCache.delete(fileNPath);
-      this.#reexportCache.delete(fileNPath);
-      this.#collectedCache.delete(fileNPath);
-      this.#revDepCache.delete(fileNPath); // ← 자기 자신이 key인 경우도 정리
+      this._exportCache.delete(fileNPath);
+      this._importCache.delete(fileNPath);
+      this._reexportCache.delete(fileNPath);
+      this._collectedCache.delete(fileNPath);
+      this._revDepCache.delete(fileNPath); // 자신이 key인 경우
     }
 
-    // _revDepCache는 역방향으로 순회
-    for (const [targetNPath, infoMap] of this.#revDepCache) {
+    for (const [targetNPath, infoMap] of this._revDepCache) {
       for (const fileNPath of affectedFiles) {
         infoMap.delete(fileNPath);
       }
-
       if (infoMap.size === 0) {
-        this.#revDepCache.delete(targetNPath);
+        this._revDepCache.delete(targetNPath);
       }
     }
   }
 
+  /**
+   * reexport된 경우 importSymbol → exportSymbol로 변환
+   */
   #convertImportSymbolToExportSymbol(
     fileNPath: TNormPath,
     targetNPath: TNormPath,
     importSymbol: string,
   ) {
-    const symbolInfos = this.#reexportCache.get(fileNPath)?.get(targetNPath);
+    const symbolInfos = this._reexportCache.get(fileNPath)?.get(targetNPath);
     if (symbolInfos != null && symbolInfos !== 0 && symbolInfos.length > 0) {
-      const symbolInfo = symbolInfos.single(item => item.importSymbol === importSymbol);
-      if (symbolInfo) {
-        return symbolInfo.exportSymbol;
-      }
+      const symbolInfo = symbolInfos.single((item) => item.importSymbol === importSymbol);
+      if (symbolInfo) return symbolInfo.exportSymbol;
     }
-
     return importSymbol;
   }
 
+  /**
+   * 해당 파일에서 export된 모든 심볼 (직접 + 재export 포함)
+   */
   #getExportSymbols(fileNPath: TNormPath): Set<string> {
     const result = new Set<string>();
 
-    const set = this.#exportCache.get(fileNPath);
-    if (set) {
-      result.adds(...set);
-    }
-
-    const map = this.#reexportCache.get(fileNPath);
-    if (map) {
-      for (const [key, val] of map) {
-        if (val === 0) {
-          result.adds(...this.#getExportSymbols(key));
-        }
-        else {
-          result.adds(...val.map(item => item.exportSymbol));
+    for (const path of this.#getRelatedNPaths(fileNPath)) {
+      const set = this._exportCache.get(path);
+      if (set) result.adds(...set);
+
+      const map = this._reexportCache.get(path);
+      if (map) {
+        for (const [key, val] of map) {
+          if (val === 0) {
+            result.adds(...this.#getExportSymbols(key));
+          } else {
+            result.adds(...val.map(item => item.exportSymbol));
+          }
         }
       }
     }
@@ -252,32 +293,30 @@ export class SdDependencyCache {
     return result;
   }
 
-  // ---
-
+  /**
+   * 변경된 파일로부터 영향을 받는 전체 트리를 반환
+   * - 의존 관계를 시각화 및 구조적으로 추적할 수 있도록 트리 형태로 구성
+   */
   getAffectedFileTree(modifiedNPathSet: Set<TNormPath>): ISdAffectedFileTreeNode[] {
-    const visited = new Set<string>(); // 순환 방지용: file#symbol
-    const nodeMap = new Map<string, ISdAffectedFileTreeNode>(); // 중복 노드 캐시
+    const visited = new Set<string>();
+    const nodeMap = new Map<string, ISdAffectedFileTreeNode>();
 
     const buildTree = (
       fileNPath: TNormPath,
-      exportSymbol: string | undefined
+      exportSymbol: string | undefined,
     ): ISdAffectedFileTreeNode => {
       const key = `${fileNPath}#${exportSymbol ?? "*"}`;
-
-      // 동일 노드가 이미 만들어졌다면 재사용
       if (nodeMap.has(key)) return nodeMap.get(key)!;
 
-      // 방문 기록
       visited.add(key);
 
-      // 노드 생성 및 캐싱
       const node: ISdAffectedFileTreeNode = {
         fileNPath,
-        children: []
+        children: [],
       };
       nodeMap.set(key, node);
 
-      const revDepInfoMap = this.#revDepCache.get(fileNPath);
+      const revDepInfoMap = this._revDepCache.get(fileNPath);
       if (!revDepInfoMap) return node;
 
       for (const [revDepFileNPath, revDepInfo] of revDepInfoMap.entries()) {
@@ -285,16 +324,13 @@ export class SdDependencyCache {
           exportSymbol == null || revDepInfo === 0 || revDepInfo.has(exportSymbol);
         if (!hasImportSymbol) continue;
 
-        const nextExportSymbol = exportSymbol != null
-          ? this.#convertImportSymbolToExportSymbol(
-            revDepFileNPath,
-            fileNPath,
-            exportSymbol
-          )
-          : undefined;
+        const nextExportSymbol =
+          exportSymbol != null
+            ? this.#convertImportSymbolToExportSymbol(revDepFileNPath, fileNPath, exportSymbol)
+            : undefined;
 
         const childKey = `${revDepFileNPath}#${nextExportSymbol ?? "*"}`;
-        if (visited.has(childKey)) continue; // 순환 방지
+        if (visited.has(childKey)) continue;
 
         const childNode = buildTree(revDepFileNPath, nextExportSymbol);
         node.children.push(childNode);
@@ -306,15 +342,16 @@ export class SdDependencyCache {
     const result: ISdAffectedFileTreeNode[] = [];
 
     for (const modifiedNPath of modifiedNPathSet) {
-      const exportSymbols = this.#getExportSymbols(modifiedNPath);
-      if (exportSymbols.size === 0) {
-        const rootNode = buildTree(modifiedNPath, undefined);
-        result.push(rootNode);
-      } else {
-        for (const symbol of exportSymbols) {
-          const rootNode = buildTree(modifiedNPath, symbol);
-          result.push(rootNode);
-        }
+      for (const path of this.#getRelatedNPaths(modifiedNPath)) {
+        result.push(buildTree(path, undefined)); // root는 symbol상관없이
+        /*const exportSymbols = this.#getExportSymbols(path);
+        if (exportSymbols.size === 0) {
+          result.push(buildTree(path, undefined));
+        } else {
+          for (const symbol of exportSymbols) {
+            result.push(buildTree(path, symbol));
+          }
+        }*/
       }
     }
 
@@ -325,4 +362,4 @@ export class SdDependencyCache {
 export interface ISdAffectedFileTreeNode {
   fileNPath: TNormPath;
   children: ISdAffectedFileTreeNode[];
-}
+}

package/tests/deps/sd-dependency-cache.spec.ts

@@ -141,4 +141,16 @@ describe("SdDependencyCache", () => {
 
     console.log(printTree(trees[0]));
   });
+
+  it("d.ts를 입력하면 js도 함께 영향을 받는다", () => {
+    const dts = PathUtils.norm("/mod.d.ts");
+    const js = PathUtils.norm("/mod.js");
+    const consumer = PathUtils.norm("/consumer.ts");
+
+    depCache.addExport(dts, "Foo");
+    depCache.addImport(consumer, js, "Foo"); // js 경로로 import
+
+    const result = depCache.getAffectedFileSet(new Set([dts]));
+    expect(result).toEqual(new Set([dts, js, consumer]));
+  });
 });