@simplysm/sd-cli 10.0.4 → 10.0.21

package/src/builders/SdCliTsLibBuilder.ts

@@ -1,265 +1,96 @@
-import ts from "typescript";
-import { FsUtil, Logger, PathUtil, SdFsWatcher } from "@simplysm/sd-core-node";
+import { FsUtil, Logger, SdFsWatcher } from "@simplysm/sd-core-node";
 import path from "path";
-import { ISdCliPackageBuildResult } from "../commons";
-import { SdCliBuildResultUtil } from "../utils/SdCliBuildResultUtil";
+import { ISdCliBuilderResult } from "../commons";
 import { EventEmitter } from "events";
-import { ESLint } from "eslint";
 import { FunctionQueue } from "@simplysm/sd-core-common";
+import { SdTsIncrementalBuilder } from "../SdTsIncrementalBuilder";
+import { SdLinter } from "../SdLinter";
 
 export class SdCliTsLibBuilder extends EventEmitter {
   private readonly _logger = Logger.get(["simplysm", "sd-cli", "SdCliTsLibBuilder"]);
-  private readonly _pkgName: string;
-  private readonly _writeFileCache = new Map<string, string>();
 
   public constructor(private readonly _pkgPath: string) {
     super();
-    this._pkgName = path.basename(_pkgPath);
   }
 
   public override on(event: "change", listener: () => void): this;
-  public override on(event: "complete", listener: (result: { affectedFilePaths: string[]; buildResults: ISdCliPackageBuildResult[] }) => void): this;
+  public override on(event: "complete", listener: (result: ISdCliBuilderResult) => void): this;
   public override on(event: string | symbol, listener: (...args: any[]) => void): this {
     super.on(event, listener);
     return this;
   }
 
-  public async buildAsync(): Promise<ISdCliPackageBuildResult[]> {
+  public async buildAsync(): Promise<ISdCliBuilderResult> {
     this._debug("빌드 준비...");
-
-    const srcGlobPath = path.resolve(this._pkgPath, "src/**/*.ts");
-
-    const parsedTsConfig = ts.parseJsonConfigFileContent(
-      await FsUtil.readJsonAsync(path.resolve(this._pkgPath, "tsconfig.json")),
-      ts.sys,
-      this._pkgPath,
-      {
-        outDir: path.resolve(this._pkgPath, "dist"),
-        incremental: true,
-        tsBuildInfoFile: path.resolve(this._pkgPath, ".cache/tsbuildinfo.json"),
-      }
-    );
-
-    const host = ts.createIncrementalCompilerHost(parsedTsConfig.options, ts.sys);
+    const sdTsProgram = await SdTsIncrementalBuilder.createAsync(this._pkgPath, true);
 
     this._debug("dist 초기화...");
     await FsUtil.removeAsync(path.resolve(this._pkgPath, "dist"));
 
-    this._debug("빌드...");
-    const srcFilePaths = await FsUtil.globAsync(srcGlobPath);
-    const emitResult = this._emitIncrementalProgram({
-      rootNames: srcFilePaths,
-      options: parsedTsConfig.options,
-      host: host
-    });
+    this._debug("BUILD...");
+    const buildResult = await sdTsProgram.buildAsync();
+
 
     this._debug("LINT...");
-    const lintResults = await this._lintAsync(emitResult.program.getProgram(), srcFilePaths);
+    const lintResults = await SdLinter.lintAsync(buildResult.affectedFilePaths, sdTsProgram.builderProgram!.getProgram());
 
     this._debug(`빌드 완료`);
-    return [...emitResult.buildResults, ...lintResults];
+    return {
+      affectedFilePaths: buildResult.affectedFilePaths,
+      buildResults: [...buildResult.results, ...lintResults]
+    };
   }
 
   public async watchAsync(): Promise<void> {
-    this.emit("change");
     this._debug("빌드 준비...");
-
-    const srcGlobPath = path.resolve(this._pkgPath, "src/**/*.ts");
-
-    const parsedTsConfig = ts.parseJsonConfigFileContent(
-      await FsUtil.readJsonAsync(path.resolve(this._pkgPath, "tsconfig.json")),
-      ts.sys,
-      this._pkgPath,
-      {
-        outDir: path.resolve(this._pkgPath, "dist"),
-        incremental: true,
-        tsBuildInfoFile: path.resolve(this._pkgPath, ".cache/tsbuildinfo.json"),
-      }
-    );
-
-    const host = ts.createIncrementalCompilerHost(parsedTsConfig.options, ts.sys);
+    const sdTsProgram = await SdTsIncrementalBuilder.createAsync(this._pkgPath, true);
 
     this._debug("dist 초기화...");
     await FsUtil.removeAsync(path.resolve(this._pkgPath, "dist"));
 
-    this._debug("빌드...");
-    const srcFilePaths = await FsUtil.globAsync(srcGlobPath);
-    const emitResult = this._emitIncrementalProgram({
-      rootNames: srcFilePaths,
-      options: parsedTsConfig.options,
-      host: host
-    });
+    this.emit("change");
+
+    this._debug("BUILD...");
+    const buildResult = await sdTsProgram.buildAsync();
 
     this._debug("LINT...");
-    const lintResults = await this._lintAsync(emitResult.program.getProgram(), srcFilePaths);
+    const lintResults = await SdLinter.lintAsync(buildResult.affectedFilePaths, sdTsProgram.builderProgram!.getProgram());
 
     this._debug(`빌드 완료`);
     this.emit("complete", {
-      affectedFilePaths: srcFilePaths,
-      buildResults: [...emitResult.buildResults, ...lintResults]
+      affectedFilePaths: buildResult.affectedFilePaths,
+      buildResults: [...buildResult.results, ...lintResults]
     });
 
+    this._debug("WATCH...");
     const fnQ = new FunctionQueue();
     SdFsWatcher
       .watch([
-        ...emitResult.program.getSourceFiles().map((item) => item.fileName),
-        srcGlobPath
+        ...sdTsProgram.builderProgram!.getSourceFiles().map((item) => item.fileName),
+        path.resolve(this._pkgPath, "src/**/*.{ts,tsx}")
       ])
       .onChange({
         delay: 100
       }, () => {
         fnQ.runLast(async () => {
           this.emit("change");
-          this._debug(`빌드...`);
 
-          const watchSrcFilePaths = await FsUtil.globAsync(srcGlobPath);
-          const watchResult = this._emitIncrementalProgram({
-            rootNames: await FsUtil.globAsync(srcGlobPath),
-            options: parsedTsConfig.options,
-            host: host
-          });
-          const watchAffectedSrcFilePaths = watchResult.affectedFileNames.map((item) => path.resolve(item)).filter((item) => watchSrcFilePaths.includes(item));
+          this._debug(`BUILD...`);
+          const watchBuildResult = await sdTsProgram.buildAsync();
 
-          this._debug("LINT...");
-          const watchLintResults = await this._lintAsync(watchResult.program.getProgram(), watchAffectedSrcFilePaths);
+          this._debug(`LINT...`);
+          const watchLintResults = await SdLinter.lintAsync(watchBuildResult.affectedFilePaths, sdTsProgram.builderProgram!.getProgram());
 
           this._debug(`빌드 완료`);
           this.emit("complete", {
-            affectedFilePaths: watchAffectedSrcFilePaths,
-            buildResults: [...watchResult.buildResults, ...watchLintResults]
+            affectedFilePaths: watchBuildResult.affectedFilePaths,
+            buildResults: [...watchBuildResult.results, ...watchLintResults]
           });
         });
       });
   }
 
-  private _emitIncrementalProgram(opt: {
-    rootNames: string[];
-    options: ts.CompilerOptions;
-    host: ts.CompilerHost;
-  }): {
-    program: ts.SemanticDiagnosticsBuilderProgram;
-    buildResults: ISdCliPackageBuildResult[];
-    affectedFileNames: string[];
-  } {
-    const program = ts.createIncrementalProgram({
-      rootNames: opt.rootNames,
-      options: opt.options,
-      host: opt.host,
-      createProgram: ts.createSemanticDiagnosticsBuilderProgram
-    });
-
-    const diagnostics: ts.Diagnostic[] = [];
-    const affectedFileNames: string[] = [];
-
-    diagnostics.push(
-      ...program.getOptionsDiagnostics(),
-      ...program.getGlobalDiagnostics(),
-    );
-
-    while (true) {
-      const semanticResult = program.getSemanticDiagnosticsOfNextAffectedFile(undefined, (sourceFile) => {
-        return !opt.rootNames.includes(path.resolve(sourceFile.fileName));
-      });
-      if (!semanticResult) break;
-      diagnostics.push(...semanticResult.result);
-
-      /*const result = program.emitNextAffectedFile((filePath, data, writeByteOrderMark) => {
-        if (this._writeFileCache.get(filePath) !== data) {
-          ts.sys.writeFile(filePath, data, writeByteOrderMark);
-        }
-        this._writeFileCache.set(filePath, data);
-      });
-      if (!result) break;*/
-
-      if ("fileName" in semanticResult.affected) {
-        const emitResult = program.emit(program.getSourceFile(semanticResult.affected.fileName), (filePath, data, writeByteOrderMark) => {
-          let realFilePath = filePath;
-          if (PathUtil.isChildPath(realFilePath, path.resolve(this._pkgPath, "dist", this._pkgName, "src"))) {
-            realFilePath = path.resolve(this._pkgPath, "dist", path.relative(path.resolve(this._pkgPath, "dist", this._pkgName, "src"), realFilePath));
-          }
-
-          if (this._writeFileCache.get(realFilePath) !== data) {
-            ts.sys.writeFile(realFilePath, data, writeByteOrderMark);
-          }
-          this._writeFileCache.set(realFilePath, data);
-        });
-        diagnostics.push(...emitResult.diagnostics);
-
-        affectedFileNames.push(semanticResult.affected.fileName);
-        diagnostics.push(...program.getSyntacticDiagnostics(semanticResult.affected));
-      }
-    }
-
-    const buildResults = diagnostics.map((item) => SdCliBuildResultUtil.convertFromTsDiag(item));
-
-    return {
-      program,
-      buildResults,
-      affectedFileNames
-    };
-  }
-
-  /*private readonly _linter = new ESLint({
-    overrideConfig: {
-      overrides: [
-        {
-          files: ["*.ts"],
-          parserOptions: {
-            tsconfigRootDir: this._pkgPath,
-            project: "tsconfig.json"
-          },
-          settings: {
-            "import/resolver": {
-              "typescript": {
-                project: path.resolve(this._pkgPath, "tsconfig.json")
-              }
-            }
-          }
-        }
-      ]
-    }
-  });*/
-
-  private async _lintAsync(program: ts.Program, srcFilePaths: string[]): Promise<ISdCliPackageBuildResult[]> {
-    const linter = new ESLint({
-      overrideConfig: {
-        overrides: [
-          {
-            files: ["*.ts"],
-            parserOptions: {
-              programs: [program],
-              tsconfigRootDir: null,
-              project: null,
-              // tsconfigRootDir: this._pkgPath,
-              // project: "tsconfig.json"
-            },
-            settings: {
-              "import/resolver": {
-                "typescript": {
-                  programs: [program],
-                  project: null,
-                  // project: path.resolve(this._pkgPath, "tsconfig.json"),
-                }
-              }
-            }
-          }
-        ]
-      }
-    });
-
-    const lintResults = await linter.lintFiles(srcFilePaths);
-
-    return lintResults.mapMany((lintResult) => lintResult.messages.map((msg) => ({
-      filePath: lintResult.filePath,
-      line: msg.line,
-      char: msg.column,
-      code: msg.ruleId ?? undefined,
-      severity: msg.severity === 1 ? "warning" as const : "error" as const,
-      message: msg.message
-    })));
-  }
-
   private _debug(msg: string): void {
-    this._logger.debug(`[${this._pkgName}] ${msg}`);
+    this._logger.debug(`[${path.basename(this._pkgPath)}] ${msg}`);
   }
 }

package/src/commons.ts

@@ -10,6 +10,24 @@ export interface INpmConfig {
   peerDependenciesMeta?: Record<string, { optional?: boolean }>;
 }
 
+export interface ISdCliBuildClusterReqMessage {
+  cmd: "watch" | "build";
+  pkgPath: string;
+  pkgConf: TSdCliPackageConfig
+}
+
+export interface ISdCliBuildClusterResMessage {
+  req: ISdCliBuildClusterReqMessage;
+  type: "change" | "complete" | "ready";
+  result?: ISdCliBuilderResult;
+}
+
+export interface ISdCliBuilderResult {
+  port?: number;
+  affectedFilePaths: string[];
+  buildResults: ISdCliPackageBuildResult[];
+}
+
 export interface ISdCliPackageBuildResult {
   filePath: string | undefined;
   line: number | undefined;
@@ -23,9 +41,21 @@ export interface ISdCliConfig {
   packages: Record<string, TSdCliPackageConfig | undefined>;
 }
 
-export type TSdCliPackageConfig = ISdCliLibPackageConfig;
+export type TSdCliPackageConfig = ISdCliLibPackageConfig | ISdCliServerPackageConfig | ISdCliClientPackageConfig;
 
 export interface ISdCliLibPackageConfig {
   type: "library";
-  publish: "npm";
+  publish?: "npm";
+}
+
+export interface ISdCliServerPackageConfig {
+  type: "server";
+  externals?: string[];
+  publish?: any;
+}
+
+export interface ISdCliClientPackageConfig {
+  type: "client";
+  server?: string;
+  publish?: any;
 }

package/src/entry/SdCliProject.ts

@@ -1,7 +1,13 @@
 import path from "path";
 import { FsUtil, Logger, SdProcess } from "@simplysm/sd-core-node";
 import { SdCliConfigUtil } from "../utils/SdCliConfigUtil";
-import { INpmConfig, ISdCliPackageBuildResult, TSdCliPackageConfig } from "../commons";
+import {
+  INpmConfig,
+  ISdCliBuildClusterReqMessage,
+  ISdCliBuildClusterResMessage,
+  ISdCliPackageBuildResult,
+  TSdCliPackageConfig
+} from "../commons";
 import cp from "child_process";
 import { fileURLToPath } from "url";
 import { SdCliBuildResultUtil } from "../utils/SdCliBuildResultUtil";
@@ -36,7 +42,18 @@ export class SdCliProject {
     logger.debug("빌드 프로세스 이벤트 준비...");
     const resultCache = new Map<string, ISdCliPackageBuildResult[]>();
     let busyCount = 0;
-    cluster.on("message", (message: any) => {
+    const serverInfoMap = new Map<string, {
+      // server
+      pkgPath?: string; // persist
+      worker?: cp.ChildProcess; // persist
+      port?: number;
+      hasChanges: boolean;
+
+      //client
+      pathProxy: Record<string, number | undefined>; // persist
+      changeFilePaths: string[];
+    }>();
+    cluster.on("message", (message: ISdCliBuildClusterResMessage) => {
       if (message.type === "change") {
         if (busyCount === 0) {
           logger.log("빌드를 시작합니다...");
@@ -44,18 +61,74 @@ export class SdCliProject {
         busyCount++;
       }
       else if (message.type === "complete") {
-        for (const affectedFilePath of message.result.affectedFilePaths) {
+        for (const affectedFilePath of message.result!.affectedFilePaths) {
           resultCache.delete(affectedFilePath);
         }
 
-        for (const buildResult of message.result.buildResults) {
+        for (const buildResult of message.result!.buildResults) {
           const cacheItem = resultCache.getOrCreate(buildResult.filePath ?? "none", []);
           cacheItem.push(buildResult);
         }
 
-        setTimeout(() => {
+        if (message.req.pkgConf.type === "server") {
+          const pkgName = path.basename(message.req.pkgPath);
+          const serverInfo = serverInfoMap.getOrCreate(pkgName, {
+            hasChanges: false,
+            pathProxy: {},
+            changeFilePaths: []
+          });
+          serverInfo.pkgPath = message.req.pkgPath;
+          serverInfo.hasChanges = true;
+        }
+
+        if (message.req.pkgConf.type === "client" && message.req.pkgConf.server !== undefined) {
+          const pkgName = path.basename(message.req.pkgPath);
+          const serverInfo = serverInfoMap.getOrCreate(message.req.pkgConf.server, {
+            hasChanges: false,
+            pathProxy: {},
+            changeFilePaths: []
+          });
+          serverInfo.pathProxy[pkgName] = message.result!.port;
+          serverInfo.changeFilePaths.push(...message.result!.affectedFilePaths);
+        }
+
+        setTimeout(async () => {
           busyCount--;
           if (busyCount === 0) {
+            for (const serverPkgName of serverInfoMap.keys()) {
+              const serverInfo = serverInfoMap.get(serverPkgName)!;
+              if (serverInfo.pkgPath !== undefined && serverInfo.hasChanges) {
+                logger.debug("서버 재시작...");
+                try {
+                  const restartServerResult = await this._restartServerAsync(serverInfo.pkgPath, serverInfo.worker);
+                  serverInfo.worker = restartServerResult.worker;
+                  serverInfo.port = restartServerResult.port;
+                  serverInfo.hasChanges = false;
+                }
+                catch (err) {
+                  logger.error(err);
+                }
+              }
+
+              if (serverInfo.worker) {
+                logger.debug("클라이언트 설정...");
+                serverInfo.worker.send({
+                  type: "setPathProxy",
+                  pathProxy: serverInfo.pathProxy
+                });
+              }
+            }
+
+            const clientPaths: string[] = [];
+            for (const serverInfo of serverInfoMap.values()) {
+              for (const proxyPath of Object.keys(serverInfo.pathProxy)) {
+                clientPaths.push(`http://localhost:${serverInfo.port}/${proxyPath}/`);
+              }
+            }
+            if (clientPaths.length > 0) {
+              logger.info("클라이언트 개발 서버 접속 주소\n" + clientPaths.join("\n"));
+            }
+
             const buildResults = Array.from(resultCache.values()).mapMany();
             this._logging(buildResults, logger);
           }
@@ -68,7 +141,7 @@ export class SdCliProject {
     logger.log("빌드를 시작합니다...");
 
     await pkgPaths.parallelAsync(async (pkgPath) => {
-      await this._runCommandAsync(cluster, "watch", pkgPath);
+      await this._runCommandAsync(cluster, "watch", pkgPath, projConf.packages[path.basename(pkgPath)]!);
     });
 
     busyCount--;
@@ -108,7 +181,7 @@ export class SdCliProject {
     logger.debug("빌드 프로세스 명령 전달...");
     const results = (
       await pkgPaths.parallelAsync(async (pkgPath) => {
-        return await this._runCommandAsync(cluster, "build", pkgPath);
+        return await this._runCommandAsync(cluster, "build", pkgPath, projConf.packages[path.basename(pkgPath)]!);
       })
     ).mapMany();
 
@@ -165,7 +238,7 @@ export class SdCliProject {
       logger.debug("빌드 프로세스 명령 전달...");
       const results = (
         await pkgPaths.parallelAsync(async (pkgPath) => {
-          return await this._runCommandAsync(cluster, "build", pkgPath);
+          return await this._runCommandAsync(cluster, "build", pkgPath, projConf.packages[path.basename(pkgPath)]!);
         })
       ).mapMany();
 
@@ -325,27 +398,70 @@ export class SdCliProject {
     });
   }
 
-  private static async _runCommandAsync(cluster: cp.ChildProcess, cmd: "watch", pkgPath: string): Promise<void>;
-  private static async _runCommandAsync(cluster: cp.ChildProcess, cmd: "build", pkgPath: string): Promise<ISdCliPackageBuildResult[]>;
-  private static async _runCommandAsync(cluster: cp.ChildProcess, cmd: "watch" | "build", pkgPath: string): Promise<ISdCliPackageBuildResult[] | void> {
-    await new Promise<ISdCliPackageBuildResult[] | void>((resolve) => {
-      const cb = (message): void => {
-        if (cmd === "watch" && message.type === "ready" && message.cmd === cmd && message.pkgPath === pkgPath) {
+  private static async _runCommandAsync(cluster: cp.ChildProcess, cmd: "watch", pkgPath: string, pkgConf: TSdCliPackageConfig): Promise<void>;
+  private static async _runCommandAsync(cluster: cp.ChildProcess, cmd: "build", pkgPath: string, pkgConf: TSdCliPackageConfig): Promise<ISdCliPackageBuildResult[]>;
+  private static async _runCommandAsync(cluster: cp.ChildProcess, cmd: "watch" | "build", pkgPath: string, pkgConf: TSdCliPackageConfig): Promise<ISdCliPackageBuildResult[] | void> {
+    return await new Promise<ISdCliPackageBuildResult[] | void>((resolve) => {
+      const cb = (message: ISdCliBuildClusterResMessage): void => {
+        if (cmd === "watch" && message.type === "ready" && message.req.cmd === cmd && message.req.pkgPath === pkgPath) {
           cluster.off("message", cb);
           resolve();
         }
-        else if (cmd === "build" && message.type === "complete" && message.cmd === cmd && message.pkgPath === pkgPath) {
+        else if (cmd === "build" && message.type === "complete" && message.req.cmd === cmd && message.req.pkgPath === pkgPath) {
           cluster.off("message", cb);
-          resolve(message.result);
+          resolve(message.result?.buildResults);
         }
       };
       cluster.on("message", cb);
 
-      cluster.send({ cmd, pkgPath });
+      cluster.send({ cmd, pkgPath, pkgConf } as ISdCliBuildClusterReqMessage);
     });
   }
 
   private static _closeCluster(cluster: cp.ChildProcess): void {
     cluster.kill("SIGKILL");
   }
+
+  private static async _restartServerAsync(pkgPath: string, prevServerProcess?: cp.ChildProcess): Promise<{ worker: cp.ChildProcess, port: number }> {
+    const logger = Logger.get(["simplysm", "sd-cli", "SdCliProject", "_restartServerAsync"]);
+
+    if (prevServerProcess) {
+      prevServerProcess.kill("SIGKILL");
+    }
+
+    return await new Promise<{ worker: cp.ChildProcess, port: number }>(async (resolve, reject) => {
+      const worker = cp.fork(
+        fileURLToPath(await import.meta.resolve!("../server-worker")),
+        [pkgPath],
+        {
+          stdio: ["pipe", "pipe", "pipe", "ipc"],
+          env: process.env
+        }
+      );
+
+      worker.stdout!.pipe(process.stdout);
+      worker.stderr!.pipe(process.stderr);
+
+      worker.on("exit", (code) => {
+        if (code != null && code !== 0) {
+          const err = new Error(`오류와 함께 닫힘 (${code})`);
+          logger.error(err);
+          reject(err);
+          return;
+        }
+      });
+
+      worker.on("error", (err) => {
+        logger.error(err);
+        reject(err);
+      });
+
+      worker.on("message", (message: any) => {
+        if ("port" in message) {
+          logger.debug("서버가 시작되었습니다.");
+          resolve({ worker, port: message.port });
+        }
+      });
+    });
+  }
 }

package/src/sd-cli.ts

@@ -4,6 +4,7 @@ import { SdCliProject } from "./entry/SdCliProject";
 import { Logger, LoggerSeverity } from "@simplysm/sd-core-node";
 import { EventEmitter } from "events";
 
+Error.stackTraceLimit = Infinity;
 EventEmitter.defaultMaxListeners = 0;
 
 const argv = (

package/src/server-worker.ts

@@ -0,0 +1,45 @@
+import { EventEmitter } from "events";
+import { Logger, LoggerSeverity } from "@simplysm/sd-core-node";
+import path from "path";
+import { pathToFileURL } from "url";
+import { SdServiceServer } from "@simplysm/sd-service-server";
+
+Error.stackTraceLimit = Infinity;
+EventEmitter.defaultMaxListeners = 0;
+
+if (Boolean(process.env["SD_DEBUG"])) {
+  Logger.setConfig({
+    console: {
+      level: LoggerSeverity.debug
+    }
+  });
+}
+else {
+  Logger.setConfig({
+    dot: true
+  });
+}
+
+const logger = Logger.get(["simplysm", "sd-cli", "server-worker"]);
+
+const pkgPath = process.argv[2];
+
+const mainFilePath = path.resolve(pkgPath, "dist/main.mjs");
+
+const serverModule = await import(pathToFileURL(mainFilePath).href);
+
+const server = serverModule.default as SdServiceServer | undefined;
+if (server === undefined) {
+  logger.error(`${mainFilePath}(0, 0): 'SdServiceServer'를 'export'해야 합니다.`);
+  process.exit();
+}
+
+server.on("ready", () => {
+  process.send!({ port: server.options.port });
+});
+
+process.on("message", (message: any) => {
+  if (message.type === "setPathProxy") {
+    server.pathProxy = message.pathProxy;
+  }
+});

package/tsconfig.json

@@ -4,15 +4,6 @@
     "lib": [
       "ES2021"
     ],
-    "outDir": "./dist",
-    "baseUrl": ".",
-    "paths": {
-      "@simplysm/sd-core-common": [
-        "../sd-core-common/src/index.ts"
-      ],
-      "@simplysm/sd-core-node": [
-        "../sd-core-node/src/index.ts"
-      ]
-    }
+    "outDir": "./dist"
   }
 }