@simplysm/sd-cli 12.16.37 → 12.16.39

package/dist/pkg-builders/client/SdNgBundler.js

@@ -22,6 +22,7 @@ import { createSdNgPlugin } from "./createSdNgPlugin";
 import { SdCliPerformanceTimer } from "../../utils/SdCliPerformanceTimer";
 import nodeModule from "module";
 import { SdWorkerPathPlugin } from "../commons/SdWorkerPathPlugin";
+import { SdPolyfillPlugin } from "./SdPolyfillPlugin";
 export class SdNgBundler {
     constructor(_opt, _conf) {
         this._opt = _opt;
@@ -370,7 +371,7 @@ export class SdNgBundler {
             mainFields: ["es2020", "es2015", "browser", "module", "main"],
             entryNames: "[dir]/[name]",
             entryPoints: {
-                "sd-polyfills": path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../../lib/chrome61-polyfills.js"),
+                "sd-polyfills": "virtual:sd-polyfills",
                 main: this._mainFilePath,
                 ...(FsUtils.exists(path.resolve(this._opt.pkgPath, "src/polyfills.ts"))
                     ? {
@@ -433,6 +434,7 @@ export class SdNgBundler {
                 }),
             plugins: [
                 createSourcemapIgnorelistPlugin(),
+                SdPolyfillPlugin(["Chrome >= 61"]),
                 createSdNgPlugin(this._opt, this._modifiedFileSet, this._ngResultCache),
                 ...(this._conf.builderType === "electron"
                     ? []

package/dist/pkg-builders/client/SdPolyfillPlugin.d.ts

@@ -0,0 +1,2 @@
+import { Plugin } from "esbuild";
+export declare function SdPolyfillPlugin(browserslistQuery: string[]): Plugin;

package/dist/pkg-builders/client/SdPolyfillPlugin.js

@@ -0,0 +1,61 @@
+import compat from "core-js-compat";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import path from "path";
+const _require = createRequire(import.meta.url);
+const _resolveDir = path.dirname(fileURLToPath(import.meta.url));
+const SD_POLYFILL_NS = "sd-polyfill";
+const SD_POLYFILL_FILTER = /^virtual:sd-polyfills$/;
+export function SdPolyfillPlugin(browserslistQuery) {
+    return {
+        name: "sd-polyfill-plugin",
+        setup(build) {
+            build.onResolve({ filter: SD_POLYFILL_FILTER }, () => ({
+                path: "sd-polyfills",
+                namespace: SD_POLYFILL_NS,
+            }));
+            build.onLoad({ filter: /.*/, namespace: SD_POLYFILL_NS }, () => {
+                const { list } = compat({
+                    targets: browserslistQuery,
+                });
+                const lines = [];
+                // core-js 모듈 (bare specifier + resolveDir로 소비 프로젝트의 node_modules 의존 제거)
+                for (const mod of list) {
+                    try {
+                        _require.resolve(`core-js/modules/${mod}.js`);
+                        lines.push(`import "core-js/modules/${mod}.js";`);
+                    }
+                    catch {
+                        // 모듈이 존재하지 않으면 skip (WeakRef 등 polyfill 불가 항목)
+                    }
+                }
+                // AbortController (Chrome 66+)
+                try {
+                    _require.resolve("abortcontroller-polyfill/dist/abortcontroller-polyfill-only");
+                    lines.push(`import "abortcontroller-polyfill/dist/abortcontroller-polyfill-only";`);
+                }
+                catch {
+                    // skip
+                }
+                // ResizeObserver (Chrome 64+)
+                try {
+                    _require.resolve("resize-observer-polyfill");
+                    lines.push(`import RO from "resize-observer-polyfill";`);
+                    lines.push(`if (typeof window !== "undefined" && !("ResizeObserver" in window)) { window.ResizeObserver = RO; }`);
+                }
+                catch {
+                    // skip
+                }
+                // TransformStream / ReadableStream / WritableStream (Chrome 67+)
+                try {
+                    _require.resolve("web-streams-polyfill/polyfill");
+                    lines.push(`import "web-streams-polyfill/polyfill";`);
+                }
+                catch {
+                    // skip
+                }
+                return { contents: lines.join("\n"), loader: "js", resolveDir: _resolveDir };
+            });
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simplysm/sd-cli",
-  "version": "12.16.37",
+  "version": "12.16.39",
   "description": "심플리즘 패키지 - CLI",
   "author": "김석래",
   "repository": {
@@ -17,14 +17,15 @@
     "@angular/compiler-cli": "^20.3.18",
     "@anthropic-ai/sdk": "^0.78.0",
     "@electron/rebuild": "^4.0.3",
-    "@simplysm/sd-core-common": "12.16.37",
-    "@simplysm/sd-core-node": "12.16.37",
-    "@simplysm/sd-service-server": "12.16.37",
-    "@simplysm/sd-storage": "12.16.37",
+    "@simplysm/sd-core-common": "12.16.39",
+    "@simplysm/sd-core-node": "12.16.39",
+    "@simplysm/sd-service-server": "12.16.39",
+    "@simplysm/sd-storage": "12.16.39",
     "abortcontroller-polyfill": "^1.7.8",
     "browserslist": "^4.28.1",
     "cordova": "^13.0.0",
     "core-js": "^3.49.0",
+    "core-js-compat": "^3.49.0",
     "electron": "^33.4.11",
     "electron-builder": "^25.1.8",
     "esbuild": "0.25.9",
@@ -41,6 +42,7 @@
     "ts-morph": "^27.0.2",
     "tslib": "^2.8.1",
     "typescript": "~5.8.3",
+    "web-streams-polyfill": "^4.2.0",
     "yargs": "^18.0.0"
   },
   "devDependencies": {

package/src/pkg-builders/client/SdNgBundler.ts

@@ -41,6 +41,7 @@ import { INpmConfig } from "../../types/common-config/INpmConfig";
 import { ISdBuildResult } from "../../types/build/ISdBuildResult";
 import { ISdTsCompilerOptions } from "../../types/build/ISdTsCompilerOptions";
 import { SdWorkerPathPlugin } from "../commons/SdWorkerPathPlugin";
+import { SdPolyfillPlugin } from "./SdPolyfillPlugin";
 
 export class SdNgBundler {
   private readonly _logger = SdLogger.get(["simplysm", "sd-cli", "SdNgBundler"]);
@@ -488,10 +489,7 @@ export class SdNgBundler {
       mainFields: ["es2020", "es2015", "browser", "module", "main"],
       entryNames: "[dir]/[name]",
       entryPoints: {
-        "sd-polyfills": path.resolve(
-          path.dirname(fileURLToPath(import.meta.url)),
-          "../../../lib/chrome61-polyfills.js",
-        ),
+        "sd-polyfills": "virtual:sd-polyfills",
         main: this._mainFilePath,
         ...(FsUtils.exists(path.resolve(this._opt.pkgPath, "src/polyfills.ts"))
           ? {
@@ -561,6 +559,7 @@ export class SdNgBundler {
           }),
       plugins: [
         createSourcemapIgnorelistPlugin(),
+        SdPolyfillPlugin(["Chrome >= 61"]),
         createSdNgPlugin(this._opt, this._modifiedFileSet, this._ngResultCache),
         ...(this._conf.builderType === "electron"
           ? []

package/src/pkg-builders/client/SdPolyfillPlugin.ts

@@ -0,0 +1,70 @@
+import { Plugin, PluginBuild } from "esbuild";
+import compat from "core-js-compat";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import path from "path";
+
+const _require = createRequire(import.meta.url);
+const _resolveDir = path.dirname(fileURLToPath(import.meta.url));
+
+const SD_POLYFILL_NS = "sd-polyfill";
+const SD_POLYFILL_FILTER = /^virtual:sd-polyfills$/;
+
+export function SdPolyfillPlugin(browserslistQuery: string[]): Plugin {
+  return {
+    name: "sd-polyfill-plugin",
+    setup(build: PluginBuild) {
+      build.onResolve({ filter: SD_POLYFILL_FILTER }, () => ({
+        path: "sd-polyfills",
+        namespace: SD_POLYFILL_NS,
+      }));
+
+      build.onLoad({ filter: /.*/, namespace: SD_POLYFILL_NS }, () => {
+        const { list } = compat({
+          targets: browserslistQuery,
+        });
+
+        const lines: string[] = [];
+
+        // core-js 모듈 (bare specifier + resolveDir로 소비 프로젝트의 node_modules 의존 제거)
+        for (const mod of list) {
+          try {
+            _require.resolve(`core-js/modules/${mod}.js`);
+            lines.push(`import "core-js/modules/${mod}.js";`);
+          } catch {
+            // 모듈이 존재하지 않으면 skip (WeakRef 등 polyfill 불가 항목)
+          }
+        }
+
+        // AbortController (Chrome 66+)
+        try {
+          _require.resolve("abortcontroller-polyfill/dist/abortcontroller-polyfill-only");
+          lines.push(`import "abortcontroller-polyfill/dist/abortcontroller-polyfill-only";`);
+        } catch {
+          // skip
+        }
+
+        // ResizeObserver (Chrome 64+)
+        try {
+          _require.resolve("resize-observer-polyfill");
+          lines.push(`import RO from "resize-observer-polyfill";`);
+          lines.push(
+            `if (typeof window !== "undefined" && !("ResizeObserver" in window)) { window.ResizeObserver = RO; }`,
+          );
+        } catch {
+          // skip
+        }
+
+        // TransformStream / ReadableStream / WritableStream (Chrome 67+)
+        try {
+          _require.resolve("web-streams-polyfill/polyfill");
+          lines.push(`import "web-streams-polyfill/polyfill";`);
+        } catch {
+          // skip
+        }
+
+        return { contents: lines.join("\n"), loader: "js", resolveDir: _resolveDir };
+      });
+    },
+  };
+}

package/tests/client/sd-polyfill-plugin.spec.ts

@@ -0,0 +1,87 @@
+import { describe, expect, it } from "vitest";
+import { SdPolyfillPlugin } from "../../src/pkg-builders/client/SdPolyfillPlugin";
+
+function captureOnLoad(browserslistQuery: string[]) {
+  const plugin = SdPolyfillPlugin(browserslistQuery);
+
+  let onLoadHandler: (() => { contents: string; loader: string; resolveDir?: string }) | undefined;
+  const mockBuild = {
+    onResolve: () => {},
+    onLoad: (_opts: unknown, handler: () => { contents: string; loader: string; resolveDir?: string }) => {
+      onLoadHandler = handler;
+    },
+  };
+
+  plugin.setup(mockBuild as never);
+  return onLoadHandler!();
+}
+
+describe("SdPolyfillPlugin", () => {
+  describe("가상 polyfill 모듈의 import가 OS 무관하게 resolve되어야 한다", () => {
+    it("모든 import가 bare specifier이다 (절대 경로 없음)", () => {
+      const result = captureOnLoad(["Chrome >= 61"]);
+      const importLines = result.contents.split("\n").filter((l) => l.startsWith("import"));
+
+      expect(importLines.length).toBeGreaterThan(0);
+      for (const line of importLines) {
+        expect(line).not.toMatch(/["'][A-Z]:\//i); // Windows 드라이브 문자 금지
+        expect(line).not.toMatch(/["']\//); // Unix 절대 경로 금지
+      }
+      // core-js bare specifier 사용
+      expect(result.contents).toContain('import "core-js/modules/');
+    });
+
+    it("abortcontroller-polyfill import에 절대 경로가 포함되지 않는다", () => {
+      const result = captureOnLoad(["Chrome >= 61"]);
+
+      expect(result.contents).toContain("abortcontroller-polyfill");
+      // 절대 경로가 아닌 bare specifier
+      const abortLines = result.contents.split("\n").filter((l) => l.includes("abortcontroller"));
+      for (const line of abortLines) {
+        expect(line).not.toMatch(/[A-Z]:\//i);
+      }
+    });
+
+    it("resize-observer-polyfill import에 절대 경로가 포함되지 않는다", () => {
+      const result = captureOnLoad(["Chrome >= 61"]);
+
+      expect(result.contents).toContain("resize-observer-polyfill");
+      const roLines = result.contents.split("\n").filter((l) => l.includes("resize-observer"));
+      for (const line of roLines) {
+        expect(line).not.toMatch(/[A-Z]:\//i);
+      }
+    });
+
+    it("web-streams-polyfill import에 절대 경로가 포함되지 않는다", () => {
+      const result = captureOnLoad(["Chrome >= 61"]);
+
+      expect(result.contents).toContain("web-streams-polyfill");
+      const wsLines = result.contents.split("\n").filter((l) => l.includes("web-streams-polyfill"));
+      for (const line of wsLines) {
+        expect(line).not.toMatch(/[A-Z]:\//i);
+      }
+    });
+
+    it("resolveDir이 설정되어야 한다", () => {
+      const result = captureOnLoad(["Chrome >= 61"]);
+
+      expect(result.resolveDir).toBeDefined();
+      expect(typeof result.resolveDir).toBe("string");
+      expect(result.resolveDir!.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe("core-js-compat 기반 동적 polyfill 목록이 유지되어야 한다", () => {
+    it("browserslistQuery에 따라 core-js 모듈이 포함된다", () => {
+      const result = captureOnLoad(["Chrome >= 61"]);
+
+      // Chrome 61에서 지원하지 않는 ES feature가 포함되어야 함
+      expect(result.contents).toContain("core-js/modules/");
+    });
+
+    it("존재하지 않는 모듈은 skip되고 에러 없이 완료된다", () => {
+      // core-js-compat이 반환하는 모듈 중 실제 존재하지 않는 것이 있어도 에러 없이 완료
+      expect(() => captureOnLoad(["Chrome >= 61"])).not.toThrow();
+    });
+  });
+});

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

@@ -3,6 +3,7 @@ import * as ts from "typescript";
 import { PathUtils, TNormPath } from "@simplysm/sd-core-node";
 import { SdDepCache } from "../../src/ts-compiler/SdDepCache";
 import { SdDepAnalyzer } from "../../src/ts-compiler/SdDepAnalyzer";
+import { ScopePathSet } from "../../src/ts-compiler/ScopePathSet";
 
 function createMockProgram(sources: Record<string, string>) {
   const fileNames = Object.keys(sources);
@@ -14,6 +15,11 @@ function createMockProgram(sources: Record<string, string>) {
     if (!sourceText) return undefined;
     return ts.createSourceFile(fileName, sourceText, languageVersion);
   };
+  const moduleResolutionCache = ts.createModuleResolutionCache(
+    compilerHost.getCurrentDirectory(),
+    (x) => x,
+  );
+  compilerHost.getModuleResolutionCache = () => moduleResolutionCache;
   const program = ts.createProgram(fileNames, {}, compilerHost);
   return { program, compilerHost };
 }
@@ -22,8 +28,27 @@ function norm(path: string): TNormPath {
   return PathUtils.norm(path);
 }
 
+function getAffectedFileSet(depCache: SdDepCache, modifiedSet: Set<TNormPath>): Set<TNormPath> {
+  const map = depCache.getAffectedFileMap(modifiedSet);
+  const result = new Set<TNormPath>();
+  for (const set of map.values()) {
+    for (const p of set) result.add(p);
+  }
+  return result;
+}
+
+function createCache(dep: SdDepCache) {
+  return {
+    dep,
+    type: new WeakMap<ts.Node, ts.Type | undefined>(),
+    prop: new WeakMap<ts.Type, Map<string, ts.Symbol | undefined>>(),
+    declFiles: new WeakMap<ts.Symbol, TNormPath[]>(),
+    ngOrg: new Map<TNormPath, ts.SourceFile>(),
+  };
+}
+
 describe("DependencyAnalyzer", () => {
-  const scope = PathUtils.norm("/");
+  const scopePathSet = new ScopePathSet([PathUtils.norm("/")]);
   let depCache: SdDepCache;
 
   beforeEach(() => {
@@ -37,9 +62,9 @@ describe("DependencyAnalyzer", () => {
     };
 
     const { program, compilerHost } = createMockProgram(files);
-    SdDepAnalyzer.analyze(program, compilerHost, [scope], depCache);
+    SdDepAnalyzer.analyze(program, compilerHost, scopePathSet, createCache(depCache));
 
-    const result = depCache.getAffectedFileSet(new Set([norm("/a.ts")]));
+    const result = getAffectedFileSet(depCache, new Set([norm("/a.ts")]));
     expect(result).toEqual(new Set([norm("/a.ts"), norm("/b.ts")]));
   });
 
@@ -51,21 +76,17 @@ describe("DependencyAnalyzer", () => {
     };
 
     const { program, compilerHost } = createMockProgram(files);
-    SdDepAnalyzer.analyze(program, compilerHost, [scope], depCache);
+    SdDepAnalyzer.analyze(program, compilerHost, scopePathSet, createCache(depCache));
 
     {
-      const result = depCache.getAffectedFileSet(new Set([norm("/a.ts")]));
+      const result = getAffectedFileSet(depCache, new Set([norm("/a.ts")]));
       expect(result).toEqual(
-        new Set([
-          norm("/a.ts"),
-          norm("/b.ts"), // a파일이 사라지거나 하면 b가 오류를 뱉어야 하므로
-          norm("/c.ts"),
-        ]),
+        new Set([norm("/a.ts"), norm("/b.ts"), norm("/c.ts")]),
       );
     }
 
     {
-      const result = depCache.getAffectedFileSet(new Set([norm("/b.ts")]));
+      const result = getAffectedFileSet(depCache, new Set([norm("/b.ts")]));
       expect(result).toEqual(new Set([norm("/b.ts"), norm("/c.ts")]));
     }
   });
@@ -78,21 +99,17 @@ describe("DependencyAnalyzer", () => {
     };
 
     const { program, compilerHost } = createMockProgram(files);
-    SdDepAnalyzer.analyze(program, compilerHost, [scope], depCache);
+    SdDepAnalyzer.analyze(program, compilerHost, scopePathSet, createCache(depCache));
 
     {
-      const result = depCache.getAffectedFileSet(new Set([norm("/a.ts")]));
+      const result = getAffectedFileSet(depCache, new Set([norm("/a.ts")]));
       expect(result).toEqual(
-        new Set([
-          norm("/a.ts"),
-          norm("/b.ts"), // a파일이 사라지거나 하면 b가 오류를 뱉어야 하므로
-          norm("/c.ts"),
-        ]),
+        new Set([norm("/a.ts"), norm("/b.ts"), norm("/c.ts")]),
       );
     }
 
     {
-      const result = depCache.getAffectedFileSet(new Set([norm("/b.ts")]));
+      const result = getAffectedFileSet(depCache, new Set([norm("/b.ts")]));
       expect(result).toEqual(new Set([norm("/b.ts"), norm("/c.ts")]));
     }
   });
@@ -106,15 +123,15 @@ describe("DependencyAnalyzer", () => {
     };
 
     const { program, compilerHost } = createMockProgram(files);
-    SdDepAnalyzer.analyze(program, compilerHost, [scope], depCache);
+    SdDepAnalyzer.analyze(program, compilerHost, scopePathSet, createCache(depCache));
 
     {
-      const result = depCache.getAffectedFileSet(new Set([norm("/a.ts")]));
+      const result = getAffectedFileSet(depCache, new Set([norm("/a.ts")]));
       expect(result).toEqual(new Set([norm("/a.ts"), norm("/b.ts"), norm("/c.ts")]));
     }
 
     {
-      const result = depCache.getAffectedFileSet(new Set([norm("/a_1.ts")]));
+      const result = getAffectedFileSet(depCache, new Set([norm("/a_1.ts")]));
       expect(result).toEqual(new Set([norm("/a_1.ts"), norm("/b.ts")]));
     }
   });
@@ -134,19 +151,17 @@ describe("DependencyAnalyzer", () => {
       `,
       "/c.ts": `
         import { A } from "./a";
-        
+
         function doSomething() {
-          // A.b.c 속성 접근을 통해 B에 간접 의존
           console.log(new A().b.c);
         }
       `,
     };
 
     const { program, compilerHost } = createMockProgram(files);
-    SdDepAnalyzer.analyze(program, compilerHost, [scope], depCache);
+    SdDepAnalyzer.analyze(program, compilerHost, scopePathSet, createCache(depCache));
 
-    // B가 변경되면 A와 C 모두 영향 받는지 확인
-    const result = depCache.getAffectedFileSet(new Set([norm("/b.ts")]));
+    const result = getAffectedFileSet(depCache, new Set([norm("/b.ts")]));
     expect(result).toEqual(new Set([norm("/a.ts"), norm("/b.ts"), norm("/c.ts")]));
   });
 
@@ -165,19 +180,17 @@ describe("DependencyAnalyzer", () => {
       `,
       "/c.ts": `
         import { A } from "./a";
-        
+
         function doSomething() {
-          // A['b'].c 속성 접근을 통해 B에 간접 의존
           console.log(new A()['b'].c);
         }
       `,
     };
 
     const { program, compilerHost } = createMockProgram(files);
-    SdDepAnalyzer.analyze(program, compilerHost, [scope], depCache);
+    SdDepAnalyzer.analyze(program, compilerHost, scopePathSet, createCache(depCache));
 
-    // B가 변경되면 A와 C 모두 영향 받는지 확인
-    const result = depCache.getAffectedFileSet(new Set([norm("/b.ts")]));
+    const result = getAffectedFileSet(depCache, new Set([norm("/b.ts")]));
     expect(result).toEqual(new Set([norm("/a.ts"), norm("/b.ts"), norm("/c.ts")]));
   });
 
@@ -188,9 +201,9 @@ describe("DependencyAnalyzer", () => {
     };
 
     const { program, compilerHost } = createMockProgram(files);
-    SdDepAnalyzer.analyze(program, compilerHost, [scope], depCache);
+    SdDepAnalyzer.analyze(program, compilerHost, scopePathSet, createCache(depCache));
 
-    const result = depCache.getAffectedFileSet(new Set([norm("/a.ts")]));
+    const result = getAffectedFileSet(depCache, new Set([norm("/a.ts")]));
     expect(result).toEqual(new Set([norm("/a.ts"), norm("/b.ts")]));
   });
 
@@ -202,9 +215,9 @@ describe("DependencyAnalyzer", () => {
     };
 
     const { program, compilerHost } = createMockProgram(files);
-    SdDepAnalyzer.analyze(program, compilerHost, [scope], depCache);
+    SdDepAnalyzer.analyze(program, compilerHost, scopePathSet, createCache(depCache));
 
-    const result = depCache.getAffectedFileSet(new Set([norm("/a.ts")]));
+    const result = getAffectedFileSet(depCache, new Set([norm("/a.ts")]));
     expect(result).toEqual(new Set([norm("/a.ts"), norm("/b.ts"), norm("/c.ts")]));
   });
 
@@ -215,13 +228,13 @@ describe("DependencyAnalyzer", () => {
     };
 
     const { program, compilerHost } = createMockProgram(files);
-    SdDepAnalyzer.analyze(program, compilerHost, [scope], depCache);
+    SdDepAnalyzer.analyze(program, compilerHost, scopePathSet, createCache(depCache));
 
-    const result = depCache.getAffectedFileSet(new Set([norm("/a.ts")]));
+    const result = getAffectedFileSet(depCache, new Set([norm("/a.ts")]));
     expect(result).toEqual(new Set([norm("/a.ts"), norm("/b.ts")]));
   });
 
-  it("invalidates()는 영향 받은 모든 파일을 캐시에서 제거한다", () => {
+  it("invalidates()는 해당 파일의 자체 분석 데이터를 제거한다", () => {
     const files = {
       "/a.ts": `export const A = 1;`,
       "/b.ts": `import { A } from "./a";`,
@@ -229,13 +242,12 @@ describe("DependencyAnalyzer", () => {
     };
 
     const { program, compilerHost } = createMockProgram(files);
-    SdDepAnalyzer.analyze(program, compilerHost, [scope], depCache);
+    SdDepAnalyzer.analyze(program, compilerHost, scopePathSet, createCache(depCache));
 
-    // invalidate 처리
     depCache.invalidates(new Set([norm("/a.ts")]));
 
-    const affected = depCache.getAffectedFileSet(new Set([norm("/a.ts")]));
-    // 분석 안된 상태이므로, a만 남아야 함
-    expect(affected).toEqual(new Set([norm("/a.ts")]));
+    // a의 자체 분석 데이터가 제거됨 (재분석 필요 상태)
+    expect(depCache["_exportCache"].has(norm("/a.ts"))).toBe(false);
+    expect(depCache["_collectedCache"].has(norm("/a.ts"))).toBe(false);
   });
 });

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

@@ -1,14 +1,22 @@
 import "@simplysm/sd-core-common";
-import { PathUtils } from "@simplysm/sd-core-node";
+import { PathUtils, TNormPath } from "@simplysm/sd-core-node";
 import { beforeEach, describe, expect, it } from "vitest";
-import { ISdAffectedFileTreeNode, SdDepCache } from "../../src/ts-compiler/SdDepCache";
+import { SdDepCache } from "../../src/ts-compiler/SdDepCache";
+
+function getAffectedFileSet(depCache: SdDepCache, modifiedSet: Set<TNormPath>): Set<TNormPath> {
+  const map = depCache.getAffectedFileMap(modifiedSet);
+  const result = new Set<TNormPath>();
+  for (const set of map.values()) {
+    for (const p of set) result.add(p);
+  }
+  return result;
+}
 
 describe("SdDependencyCache", () => {
   const a = PathUtils.norm("/a.ts");
   const b = PathUtils.norm("/b.ts");
   const c = PathUtils.norm("/c.ts");
   const html = PathUtils.norm("/comp.html");
-  // const style = PathUtils.norm("/style.scss");
 
   let depCache: SdDepCache;
 
@@ -17,75 +25,55 @@ describe("SdDependencyCache", () => {
   });
 
   it("export * from 구문으로 재export된 심볼이 정확히 전파된다", () => {
-    // a.ts → export const A
     depCache.addExport(a, "A");
-
-    // b.ts → export * from './a.ts'
     depCache.addReexport(b, a, 0);
-
-    // c.ts → import { A } from './b.ts'
     depCache.addImport(c, b, "A");
 
-    const result = depCache.getAffectedFileSet(new Set([a]));
+    const result = getAffectedFileSet(depCache, new Set([a]));
     expect(result).toEqual(new Set([a, b, c]));
   });
 
   it("export { A as B } from 구문으로 이름이 바뀐 심볼도 추적된다", () => {
-    // a.ts → export const A
     depCache.addExport(a, "A");
-
-    // b.ts → export { A as B } from './a.ts'
     depCache.addReexport(b, a, {
       importSymbol: "A",
       exportSymbol: "B",
     });
-
-    // c.ts → import { B } from './b.ts'
     depCache.addImport(c, b, "B");
 
-    const result = depCache.getAffectedFileSet(new Set([a]));
+    const result = getAffectedFileSet(depCache, new Set([a]));
     expect(result).toEqual(new Set([a, b, c]));
   });
 
   it("import { X } 구문은 정확히 사용한 심볼만 추적한다", () => {
-    // b.ts → export const Foo
     depCache.addExport(b, "Foo");
-
-    // a.ts → import { Foo } from './b.ts'
     depCache.addImport(a, b, "Foo");
 
-    const result = depCache.getAffectedFileSet(new Set([b]));
+    const result = getAffectedFileSet(depCache, new Set([b]));
     expect(result).toEqual(new Set([b, a]));
   });
 
   it("import * (namespace import)은 모든 export의 영향을 받는다", () => {
-    // b.ts → export const Bar
     depCache.addExport(b, "Bar");
-
-    // a.ts → import * as B from './b.ts'
     depCache.addImport(a, b, 0);
 
-    const result = depCache.getAffectedFileSet(new Set([b]));
+    const result = getAffectedFileSet(depCache, new Set([b]));
     expect(result).toEqual(new Set([b, a]));
   });
 
   it("심볼이 일치하지 않으면 영향이 전파되지 않는다", () => {
-    // b.ts → export const Foo
     depCache.addExport(b, "Foo");
-
-    // a.ts → import { NotFoo } from './b.ts'
     depCache.addImport(a, b, "NotFoo");
 
-    const result = depCache.getAffectedFileSet(new Set([b]));
-    expect(result).toEqual(new Set([b])); // a.ts는 영향 없음
+    const result = getAffectedFileSet(depCache, new Set([b]));
+    expect(result).toEqual(new Set([b]));
   });
 
   it("리소스 의존은 역의존만 추적되고 심볼 전파는 없다", () => {
-    // a.ts → templateUrl: "comp.html"
     depCache.addImport(a, html, 0);
 
-    const result = depCache.getAffectedFileSet(new Set([html]));
-    expect(result).toEqual(new Set([html, a])); // 단순 역참조만 전파
+    const result = getAffectedFileSet(depCache, new Set([html]));
+    expect(result).toEqual(new Set([html, a]));
   });
 
   it("reexport 후 재import된 경로의 역의존도 정확히 추적된다", () => {
@@ -93,50 +81,20 @@ describe("SdDependencyCache", () => {
     depCache.addReexport(b, a, { importSymbol: "X", exportSymbol: "Y" });
     depCache.addImport(c, b, "Y");
 
-    const result = depCache.getAffectedFileSet(new Set([a]));
+    const result = getAffectedFileSet(depCache, new Set([a]));
     expect(result).toEqual(new Set([a, b, c]));
   });
 
-  it("invalidates()는 캐시에서 모든 관련 정보를 제거한다", () => {
+  it("invalidates()는 해당 파일의 자체 분석 데이터를 제거한다", () => {
     depCache.addExport(a, "X");
     depCache.addImport(b, a, "X");
 
     depCache.invalidates(new Set([a]));
 
-    // 내부 캐시 확인
+    // a의 자체 export/import/collected 캐시가 제거됨
     expect(depCache["_exportCache"].has(a)).toBe(false);
-    expect(depCache["#revDepCache"].get(a)?.has(b)).toBeFalsy(); // unefined
-  });
-
-  it("getAffectedFileTree()는 영향도를 트리 형태로 표현한다", () => {
-    // a.ts → export A
-    depCache.addExport(a, "A");
-
-    // b.ts → export { A as B } from './a.ts'
-    depCache.addReexport(b, a, {
-      importSymbol: "A",
-      exportSymbol: "B",
-    });
-
-    // c.ts → import { B } from './b.ts'
-    depCache.addImport(c, b, "B");
-
-    const trees = depCache.getAffectedFileTree(new Set([a]));
-
-    expect(trees.length).toBeGreaterThan(0);
-    const aNode = trees.find((t) => t.fileNPath === a)!;
-    expect(aNode.children.some((c1) => c1.fileNPath === b)).toBeTruthy();
-    const bNode = aNode.children.find((c1) => c1.fileNPath === b)!;
-    expect(bNode.children.some((c2) => c2.fileNPath === c)).toBeTruthy();
-
-    const printTree = (node: ISdAffectedFileTreeNode, indent = "") => {
-      console.log(indent + node.fileNPath);
-      for (const child of node.children) {
-        printTree(child, indent + "  ");
-      }
-    };
-
-    console.log(printTree(trees[0]));
+    expect(depCache["_importCache"].has(a)).toBe(false);
+    expect(depCache["_collectedCache"].has(a)).toBe(false);
   });
 
   it("d.ts를 입력하면 js도 함께 영향을 받는다", () => {
@@ -145,9 +103,9 @@ describe("SdDependencyCache", () => {
     const consumer = PathUtils.norm("/consumer.ts");
 
     depCache.addExport(dts, "Foo");
-    depCache.addImport(consumer, js, "Foo"); // js 경로로 import
+    depCache.addImport(consumer, js, "Foo");
 
-    const result = depCache.getAffectedFileSet(new Set([dts]));
+    const result = getAffectedFileSet(depCache, new Set([dts]));
     expect(result).toEqual(new Set([dts, js, consumer]));
   });
 });

package/lib/chrome61-polyfills.js

@@ -1,46 +0,0 @@
-// =============================================================
-// Chrome 61+ Polyfills
-// core-js는 feature detection 기반 — 이미 지원하는 기능은 skip
-// sd-cli가 Angular 클라이언트 빌드 시 자동 주입
-// =============================================================
-
-// -- ES2018 --
-import "core-js/actual/promise/finally";
-
-// -- ES2019 --
-import "core-js/actual/array/flat";
-import "core-js/actual/array/flat-map";
-import "core-js/actual/object/from-entries";
-import "core-js/actual/string/trim-start";
-import "core-js/actual/string/trim-end";
-
-// -- ES2020 --
-import "core-js/actual/global-this";
-import "core-js/actual/string/match-all";
-import "core-js/actual/promise/all-settled";
-
-// -- ES2021 --
-import "core-js/actual/promise/any";
-import "core-js/actual/aggregate-error";
-import "core-js/actual/string/replace-all";
-import "core-js/actual/weak-ref";
-import "core-js/actual/finalization-registry";
-
-// -- ES2022 --
-import "core-js/actual/array/at";
-import "core-js/actual/string/at";
-import "core-js/actual/object/has-own";
-import "core-js/actual/error/cause";
-
-// -- Web APIs --
-import "core-js/actual/queue-microtask";
-import "core-js/actual/structured-clone";
-
-// -- AbortController (Chrome 66+) --
-import "abortcontroller-polyfill/dist/abortcontroller-polyfill-only";
-
-// -- ResizeObserver (Chrome 64+) --
-import ResizeObserver from "resize-observer-polyfill";
-if (typeof window !== "undefined" && !("ResizeObserver" in window)) {
-  window.ResizeObserver = ResizeObserver;
-}