@simplysm/sd-cli 12.8.21 → 12.9.1

package/src/utils/sd-cli-performance-time.ts

@@ -1,18 +1,18 @@
 export class SdCliPerformanceTimer {
-  #startingMap = new Map<string, number>();
-  #resultMap = new Map<string, number>();
+  private _startingMap = new Map<string, number>();
+  private _resultMap = new Map<string, number>();
 
   constructor(private _name: string) {}
 
   start(name: string) {
-    this.#startingMap.set(name, new Date().getTime());
+    this._startingMap.set(name, new Date().getTime());
   }
 
   end(name: string) {
-    const val = this.#startingMap.get(name);
+    const val = this._startingMap.get(name);
     if (val == null) throw new Error();
-    this.#resultMap.set(name, new Date().getTime() - val);
-    this.#startingMap.delete(name);
+    this._resultMap.set(name, new Date().getTime() - val);
+    this._startingMap.delete(name);
   }
 
   run<R>(name: string, fn: () => R): R {
@@ -21,20 +21,20 @@ export class SdCliPerformanceTimer {
     if (res instanceof Promise) {
       return res.then((realRes) => {
         const duration = new Date().getTime() - startTime;
-        this.#resultMap.update(name, (v) => (v ?? 0) + duration);
+        this._resultMap.update(name, (v) => (v ?? 0) + duration);
         return realRes;
       }) as R;
     }
 
     const duration = new Date().getTime() - startTime;
-    this.#resultMap.update(name, (v) => (v ?? 0) + duration);
+    this._resultMap.update(name, (v) => (v ?? 0) + duration);
     return res;
   }
 
   toString() {
     return `${this._name} 성능 보고서
 ------------------------------------
-${Array.from(this.#resultMap.entries())
+${Array.from(this._resultMap.entries())
   .map((en) => `${en[0]}: ${en[1].toLocaleString()}ms`)
   .join("\n")}
 ------------------------------------`;

package/src/workers/style-bundler.worker.ts

@@ -0,0 +1,70 @@
+import { createSdWorker, SdLogger, SdLoggerSeverity, TNormPath } from "@simplysm/sd-core-node";
+import { TStyleBundlerWorkerType } from "../types/worker.types";
+import { EventEmitter } from "events";
+import {
+  ComponentStylesheetBundler,
+} from "@angular/build/src/tools/esbuild/angular/component-stylesheets";
+import { transformSupportedBrowsersToTargets } from "@angular/build/src/tools/esbuild/utils";
+import browserslist from "browserslist";
+
+Error.stackTraceLimit = Infinity;
+EventEmitter.defaultMaxListeners = 0;
+
+if (process.env["SD_DEBUG"] != null) {
+  SdLogger.setConfig({
+    console: {
+      level: SdLoggerSeverity.debug,
+    },
+  });
+}
+else {
+  SdLogger.setConfig({
+    dot: true,
+  });
+}
+
+let stylesheetBundler: ComponentStylesheetBundler;
+
+createSdWorker<TStyleBundlerWorkerType>({
+  prepare(rootPath: string, dev: boolean) {
+    //-- stylesheetBundler
+    stylesheetBundler = new ComponentStylesheetBundler(
+      {
+        workspaceRoot: rootPath,
+        optimization: !dev,
+        inlineFonts: true,
+        preserveSymlinks: false,
+        sourcemap: dev ? "inline" : false,
+        outputNames: { bundles: "[name]", media: "media/[name]" },
+        includePaths: [],
+        // sass:
+        externalDependencies: [],
+        target: transformSupportedBrowsersToTargets(browserslist(["Chrome > 78"])),
+        tailwindConfiguration: undefined,
+        postcssConfiguration: {
+          plugins: [["css-has-pseudo"]],
+        },
+        // publicPath:
+        cacheOptions: {
+          enabled: true,
+          path: ".cache/angular",
+          basePath: ".cache",
+        },
+      },
+      "scss",
+      dev,
+    );
+  },
+  async bundle(
+    data: string,
+    containingFile: TNormPath,
+    resourceFile: TNormPath | null = null,
+  ) {
+    return resourceFile != null
+      ? await stylesheetBundler!.bundleFile(resourceFile)
+      : await stylesheetBundler!.bundleInline(data, containingFile, "scss");
+  },
+  invalidate(fileNPathSet: Set<TNormPath>) {
+    stylesheetBundler.invalidate(fileNPathSet);
+  },
+});

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

@@ -0,0 +1,272 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import * as ts from "typescript";
+import { PathUtils, TNormPath } from "@simplysm/sd-core-node/src";
+import { SdDependencyCache } from "../../src/ts-compiler/sd-dependency-cache";
+import { SdDependencyAnalyzer } from "../../src/ts-compiler/sd-dependency-analyzer";
+
+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: SdDependencyCache;
+
+  beforeEach(() => {
+    depCache = new SdDependencyCache();
+  });
+
+  it("1레벨 의존성 추적", () => {
+    const files = {
+      "/a.ts": `export const A = 1;`,
+      "/b.ts": `import { A } from "./a";`,
+    };
+
+    const { program, compilerHost } = createMockProgram(files);
+    SdDependencyAnalyzer.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);
+    SdDependencyAnalyzer.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);
+    SdDependencyAnalyzer.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);
+    SdDependencyAnalyzer.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);
+    SdDependencyAnalyzer.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);
+    SdDependencyAnalyzer.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);
+    SdDependencyAnalyzer.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);
+    SdDependencyAnalyzer.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);
+    SdDependencyAnalyzer.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);
+    SdDependencyAnalyzer.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

@@ -0,0 +1,144 @@
+import "@simplysm/sd-core-common";
+import { PathUtils } from "@simplysm/sd-core-node";
+import { beforeEach, describe, expect, it } from "vitest";
+import {
+  ISdAffectedFileTreeNode,
+  SdDependencyCache,
+} from "../../src/ts-compiler/sd-dependency-cache";
+
+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: SdDependencyCache;
+
+  beforeEach(() => {
+    depCache = new 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]));
+    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]));
+  });
+});

package/tsconfig.json

@@ -4,5 +4,5 @@
     "lib": ["ES2021"],
     "outDir": "./dist"
   },
-  "exclude": ["dist", "node_modules"]
+  "exclude": ["dist", "node_modules", "tests"]
 }

package/tsconfig.test.json

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

package/vitest.config.ts

@@ -0,0 +1,15 @@
+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"],
+  },
+});

package/dist/index.d.ts

@@ -1,34 +0,0 @@
-export * from "./entry/sd-cli-ai-command";
-export * from "./entry/sd-cli-cordova";
-export * from "./entry/sd-cli-electron";
-export * from "./entry/sd-cli-local-update";
-export * from "./entry/sd-cli-postinstall";
-export * from "./entry/sd-cli-project";
-export * from "./pkg-builders/client/sd-cli-ng-routes.file-generator";
-export * from "./pkg-builders/client/sd-client.build-runner";
-export * from "./pkg-builders/client/sd-ng.bundler-context";
-export * from "./pkg-builders/client/sd-ng.bundler";
-export * from "./pkg-builders/client/sd-ng.plugin-creator";
-export * from "./pkg-builders/lib/sd-cli-db-context.file-generator";
-export * from "./pkg-builders/lib/sd-cli-index.file-generator";
-export * from "./pkg-builders/lib/sd-js-lib.build-runner";
-export * from "./pkg-builders/lib/sd-ts-lib.build-runner";
-export * from "./pkg-builders/lib/sd-ts-lib.builder";
-export * from "./pkg-builders/sd-multi.build-runner";
-export * from "./pkg-builders/server/sd-server.build-runner";
-export * from "./pkg-builders/server/sd-server.bundler";
-export * from "./pkg-builders/server/sd-server.plugin-creator";
-import "./sd-cli";
-export * from "./ts-compiler/sd-ts-compiler";
-export * from "./ts-compiler/sd-ts-dependency-analyzer";
-export * from "./types/build-plugin.types";
-export * from "./types/build-runner.types";
-export * from "./types/build.types";
-export * from "./types/common-configs.types";
-export * from "./types/config.types";
-export * from "./types/ts-compiler.types";
-export * from "./types/worker.types";
-export * from "./utils/sd-cli-convert-message.utils";
-export * from "./utils/sd-cli-performance-time";
-import "./workers/build-runner.worker";
-import "./workers/server.worker";

package/dist/index.js

@@ -1,35 +0,0 @@
-export * from "./entry/sd-cli-ai-command";
-export * from "./entry/sd-cli-cordova";
-export * from "./entry/sd-cli-electron";
-export * from "./entry/sd-cli-local-update";
-export * from "./entry/sd-cli-postinstall";
-export * from "./entry/sd-cli-project";
-export * from "./pkg-builders/client/sd-cli-ng-routes.file-generator";
-export * from "./pkg-builders/client/sd-client.build-runner";
-export * from "./pkg-builders/client/sd-ng.bundler-context";
-export * from "./pkg-builders/client/sd-ng.bundler";
-export * from "./pkg-builders/client/sd-ng.plugin-creator";
-export * from "./pkg-builders/lib/sd-cli-db-context.file-generator";
-export * from "./pkg-builders/lib/sd-cli-index.file-generator";
-export * from "./pkg-builders/lib/sd-js-lib.build-runner";
-export * from "./pkg-builders/lib/sd-ts-lib.build-runner";
-export * from "./pkg-builders/lib/sd-ts-lib.builder";
-export * from "./pkg-builders/sd-multi.build-runner";
-export * from "./pkg-builders/server/sd-server.build-runner";
-export * from "./pkg-builders/server/sd-server.bundler";
-export * from "./pkg-builders/server/sd-server.plugin-creator";
-import "./sd-cli";
-export * from "./ts-compiler/sd-ts-compiler";
-export * from "./ts-compiler/sd-ts-dependency-analyzer";
-export * from "./types/build-plugin.types";
-export * from "./types/build-runner.types";
-export * from "./types/build.types";
-export * from "./types/common-configs.types";
-export * from "./types/config.types";
-export * from "./types/ts-compiler.types";
-export * from "./types/worker.types";
-export * from "./utils/sd-cli-convert-message.utils";
-export * from "./utils/sd-cli-performance-time";
-import "./workers/build-runner.worker";
-import "./workers/server.worker";
-//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,uDAAuD,CAAC;AACtE,cAAc,8CAA8C,CAAC;AAC7D,cAAc,6CAA6C,CAAC;AAC5D,cAAc,qCAAqC,CAAC;AACpD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,qDAAqD,CAAC;AACpE,cAAc,gDAAgD,CAAC;AAC/D,cAAc,2CAA2C,CAAC;AAC1D,cAAc,2CAA2C,CAAC;AAC1D,cAAc,sCAAsC,CAAC;AACrD,cAAc,sCAAsC,CAAC;AACrD,cAAc,8CAA8C,CAAC;AAC7D,cAAc,yCAAyC,CAAC;AACxD,cAAc,gDAAgD,CAAC;AAC/D,OAAO,UAAU,CAAC;AAClB,cAAc,8BAA8B,CAAC;AAC7C,cAAc,yCAAyC,CAAC;AACxD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,qBAAqB,CAAC;AACpC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sBAAsB,CAAC;AACrC,cAAc,sCAAsC,CAAC;AACrD,cAAc,iCAAiC,CAAC;AAChD,OAAO,+BAA+B,CAAC;AACvC,OAAO,yBAAyB,CAAC"}

package/dist/ts-compiler/sd-ts-dependency-analyzer.d.ts

@@ -1,10 +0,0 @@
-import * as ts from "typescript";
-import { TNormPath } from "@simplysm/sd-core-node";
-import { ISdBuildMessage } from "../types/build.types";
-export declare class SdTsDependencyAnalyzer {
-    static analyze(program: ts.Program, compilerHost: ts.CompilerHost, scopePaths: TNormPath[]): {
-        allDepMap: Map<TNormPath, Set<TNormPath>>;
-        sourceFileSet: Set<ts.SourceFile>;
-        messages: ISdBuildMessage[];
-    };
-}