@simplysm/sd-cli 12.16.27 → 13.0.0-beta.12

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

@@ -1,241 +0,0 @@
-import { beforeEach, describe, expect, it } from "vitest";
-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";
-
-function createMockProgram(sources: Record<string, string>) {
-  const fileNames = Object.keys(sources);
-  const compilerHost = ts.createCompilerHost({});
-  compilerHost.readFile = (fileName: string) => sources[fileName] ?? "";
-  compilerHost.fileExists = (fileName: string) => fileName in sources;
-  compilerHost.getSourceFile = (fileName, languageVersion) => {
-    const sourceText = sources[fileName];
-    if (!sourceText) return undefined;
-    return ts.createSourceFile(fileName, sourceText, languageVersion);
-  };
-  const program = ts.createProgram(fileNames, {}, compilerHost);
-  return { program, compilerHost };
-}
-
-function norm(path: string): TNormPath {
-  return PathUtils.norm(path);
-}
-
-describe("DependencyAnalyzer", () => {
-  const scope = PathUtils.norm("/");
-  let depCache: SdDepCache;
-
-  beforeEach(() => {
-    depCache = new SdDepCache();
-  });
-
-  it("1레벨 의존성 추적", () => {
-    const files = {
-      "/a.ts": `export const A = 1;`,
-      "/b.ts": `import { A } from "./a";`,
-    };
-
-    const { program, compilerHost } = createMockProgram(files);
-    SdDepAnalyzer.analyze(program, compilerHost, [scope], depCache);
-
-    const result = depCache.getAffectedFileSet(new Set([norm("/a.ts")]));
-    expect(result).toEqual(new Set([norm("/a.ts"), norm("/b.ts")]));
-  });
-
-  it("2레벨 의존성 추적", () => {
-    const files = {
-      "/a.ts": `export const A = 1;`,
-      "/b.ts": `export * from "./a";`,
-      "/c.ts": `import { A } from "./b";`,
-    };
-
-    const { program, compilerHost } = createMockProgram(files);
-    SdDepAnalyzer.analyze(program, compilerHost, [scope], depCache);
-
-    {
-      const result = depCache.getAffectedFileSet(new Set([norm("/a.ts")]));
-      expect(result).toEqual(
-        new Set([
-          norm("/a.ts"),
-          norm("/b.ts"), // a파일이 사라지거나 하면 b가 오류를 뱉어야 하므로
-          norm("/c.ts"),
-        ]),
-      );
-    }
-
-    {
-      const result = depCache.getAffectedFileSet(new Set([norm("/b.ts")]));
-      expect(result).toEqual(new Set([norm("/b.ts"), norm("/c.ts")]));
-    }
-  });
-
-  it("2레벨 Rename 의존성 추적", () => {
-    const files = {
-      "/a.ts": `export const A = 1;`,
-      "/b.ts": `export { A as B } from "./a";`,
-      "/c.ts": `import { B } from "./b";`,
-    };
-
-    const { program, compilerHost } = createMockProgram(files);
-    SdDepAnalyzer.analyze(program, compilerHost, [scope], depCache);
-
-    {
-      const result = depCache.getAffectedFileSet(new Set([norm("/a.ts")]));
-      expect(result).toEqual(
-        new Set([
-          norm("/a.ts"),
-          norm("/b.ts"), // a파일이 사라지거나 하면 b가 오류를 뱉어야 하므로
-          norm("/c.ts"),
-        ]),
-      );
-    }
-
-    {
-      const result = depCache.getAffectedFileSet(new Set([norm("/b.ts")]));
-      expect(result).toEqual(new Set([norm("/b.ts"), norm("/c.ts")]));
-    }
-  });
-
-  it("2레벨 선택적 의존성 추적", () => {
-    const files = {
-      "/a.ts": `export const A = 1;`,
-      "/a_1.ts": `export const A_1 = 1;`,
-      "/b.ts": `export * from "./a"; export * from "./a_1";`,
-      "/c.ts": `import { A } from "./b";`,
-    };
-
-    const { program, compilerHost } = createMockProgram(files);
-    SdDepAnalyzer.analyze(program, compilerHost, [scope], depCache);
-
-    {
-      const result = depCache.getAffectedFileSet(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")]));
-      expect(result).toEqual(new Set([norm("/a_1.ts"), norm("/b.ts")]));
-    }
-  });
-
-  it("A.b.c와같은 간접 의존성 추적", () => {
-    const files = {
-      "/a.ts": `
-        import { B } from "./b";
-        export class A {
-          b: B = new B();
-        }
-      `,
-      "/b.ts": `
-        export class B {
-          c: string = "hello";
-        }
-      `,
-      "/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);
-
-    // B가 변경되면 A와 C 모두 영향 받는지 확인
-    const result = depCache.getAffectedFileSet(new Set([norm("/b.ts")]));
-    expect(result).toEqual(new Set([norm("/a.ts"), norm("/b.ts"), norm("/c.ts")]));
-  });
-
-  it("A['b'].c와같은 Element 간접 의존성 추적", () => {
-    const files = {
-      "/a.ts": `
-        import { B } from "./b";
-        export class A {
-          b: B = new B();
-        }
-      `,
-      "/b.ts": `
-        export class B {
-          c: string = "hello";
-        }
-      `,
-      "/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);
-
-    // B가 변경되면 A와 C 모두 영향 받는지 확인
-    const result = depCache.getAffectedFileSet(new Set([norm("/b.ts")]));
-    expect(result).toEqual(new Set([norm("/a.ts"), norm("/b.ts"), norm("/c.ts")]));
-  });
-
-  it("타입만 사용하는 경우에도 의존성으로 추적된다", () => {
-    const files = {
-      "/a.ts": `export interface IA { value: string; }`,
-      "/b.ts": `import { IA } from "./a"; const val: IA = { value: "hi" };`,
-    };
-
-    const { program, compilerHost } = createMockProgram(files);
-    SdDepAnalyzer.analyze(program, compilerHost, [scope], depCache);
-
-    const result = depCache.getAffectedFileSet(new Set([norm("/a.ts")]));
-    expect(result).toEqual(new Set([norm("/a.ts"), norm("/b.ts")]));
-  });
-
-  it("함수 반환 타입을 통한 간접 의존성도 추적된다", () => {
-    const files = {
-      "/a.ts": `export class A { value = 1; }`,
-      "/b.ts": `import { A } from "./a"; export function getA(): A { return new A(); }`,
-      "/c.ts": `import { getA } from "./b"; console.log(getA().value);`,
-    };
-
-    const { program, compilerHost } = createMockProgram(files);
-    SdDepAnalyzer.analyze(program, compilerHost, [scope], depCache);
-
-    const result = depCache.getAffectedFileSet(new Set([norm("/a.ts")]));
-    expect(result).toEqual(new Set([norm("/a.ts"), norm("/b.ts"), norm("/c.ts")]));
-  });
-
-  it("optional chaining으로 접근해도 의존성은 추적된다", () => {
-    const files = {
-      "/a.ts": `export class A { b?: { c: number }; }`,
-      "/b.ts": `import { A } from "./a"; const a = new A(); console.log(a.b?.c);`,
-    };
-
-    const { program, compilerHost } = createMockProgram(files);
-    SdDepAnalyzer.analyze(program, compilerHost, [scope], depCache);
-
-    const result = depCache.getAffectedFileSet(new Set([norm("/a.ts")]));
-    expect(result).toEqual(new Set([norm("/a.ts"), norm("/b.ts")]));
-  });
-
-  it("invalidates()는 영향 받은 모든 파일을 캐시에서 제거한다", () => {
-    const files = {
-      "/a.ts": `export const A = 1;`,
-      "/b.ts": `import { A } from "./a";`,
-      "/c.ts": `import { A } from "./a";`,
-    };
-
-    const { program, compilerHost } = createMockProgram(files);
-    SdDepAnalyzer.analyze(program, compilerHost, [scope], 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")]));
-  });
-});

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

@@ -1,153 +0,0 @@
-import "@simplysm/sd-core-common";
-import { PathUtils } from "@simplysm/sd-core-node";
-import { beforeEach, describe, expect, it } from "vitest";
-import { ISdAffectedFileTreeNode, SdDepCache } from "../../src/ts-compiler/SdDepCache";
-
-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;
-
-  beforeEach(() => {
-    depCache = new SdDepCache();
-  });
-
-  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]));
-    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]));
-    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]));
-    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]));
-    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는 영향 없음
-  });
-
-  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])); // 단순 역참조만 전파
-  });
-
-  it("reexport 후 재import된 경로의 역의존도 정확히 추적된다", () => {
-    depCache.addExport(a, "X");
-    depCache.addReexport(b, a, { importSymbol: "X", exportSymbol: "Y" });
-    depCache.addImport(c, b, "Y");
-
-    const result = depCache.getAffectedFileSet(new Set([a]));
-    expect(result).toEqual(new Set([a, b, c]));
-  });
-
-  it("invalidates()는 캐시에서 모든 관련 정보를 제거한다", () => {
-    depCache.addExport(a, "X");
-    depCache.addImport(b, a, "X");
-
-    depCache.invalidates(new Set([a]));
-
-    // 내부 캐시 확인
-    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]));
-  });
-
-  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]));
-  });
-});

package/tsconfig.json

@@ -1,8 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "lib": ["ES2021"],
-    "outDir": "./dist"
-  },
-  "exclude": ["dist", "node_modules", "tests"]
-}

package/tsconfig.test.json

@@ -1,8 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "lib": ["ES2021"],
-    "outDir": "./dist"
-  },
-  "exclude": ["dist", "node_modules"]
-}

package/vitest.config.js

@@ -1,15 +0,0 @@
-import { defineConfig } from "vitest/config";
-import tsconfigPaths from "vite-tsconfig-paths";
-
-export default defineConfig({
-  plugins: [
-    tsconfigPaths({
-      projects: ["../../tsconfig.base.json"],
-    }),
-  ],
-  test: {
-    globals: true,
-    environment: "node",
-    include: ["tests/**/*.spec.ts"],
-  },
-});