@simplysm/sd-cli 12.13.21 → 12.13.23

package/src/ts-compiler/{sd-style-bundler.ts → SdStyleBundler.ts}

@@ -1,9 +1,9 @@
 import { PathUtils, TNormPath } from "@simplysm/sd-core-node";
-import { TStylesheetBundlingResult } from "../types/ts-compiler.types";
 import { ComponentStylesheetBundler } from "@angular/build/src/tools/esbuild/angular/component-stylesheets";
 import { transformSupportedBrowsersToTargets } from "@angular/build/src/tools/esbuild/utils";
 import browserslist from "browserslist";
-import { ScopePathSet } from "../pkg-builders/commons/scope-path";
+import { ScopePathSet } from "../pkg-builders/commons/ScopePathSet";
+import { TStylesheetBundlingResult } from "../types/build/TStylesheetBundlingResult";
 
 export class SdStyleBundler {
   #ngStyleBundler: ComponentStylesheetBundler;
@@ -14,7 +14,7 @@ export class SdStyleBundler {
   constructor(
     private readonly _pkgPath: TNormPath,
     private readonly _isDevMode: boolean,
-    private readonly _watchScopePathSet: ScopePathSet,
+    private readonly _scopePathSet: ScopePathSet,
   ) {
     this.#ngStyleBundler = new ComponentStylesheetBundler(
       {
@@ -68,8 +68,8 @@ export class SdStyleBundler {
 
       for (const referencedFile of result.referencedFiles ?? []) {
         if (
-          !this._watchScopePathSet.inScope(fileNPath) ||
-          !this._watchScopePathSet.inScope(PathUtils.norm(referencedFile))
+          !this._scopePathSet.inScope(fileNPath) ||
+          !this._scopePathSet.inScope(PathUtils.norm(referencedFile))
         )
           continue;
 

package/src/ts-compiler/{sd-ts-compiler.ts → SdTsCompiler.ts}

@@ -5,14 +5,15 @@ import { StringUtils } from "@simplysm/sd-core-common";
 import { NgtscProgram, OptimizeFor } from "@angular/compiler-cli";
 import { AngularCompilerHost } from "@angular/build/src/tools/angular/angular-host";
 import { replaceBootstrap } from "@angular/build/src/tools/angular/transformers/jit-bootstrap-transformer";
-import { SdCliPerformanceTimer } from "../utils/sd-cli-performance-time";
-import { SdCliConvertMessageUtils } from "../utils/sd-cli-convert-message.utils";
-import { ISdTsCompilerResult, SdTsCompilerOptions } from "../types/ts-compiler.types";
+import { SdCliPerformanceTimer } from "../utils/SdCliPerformanceTimer";
+import { SdCliConvertMessageUtils } from "../utils/SdCliConvertMessageUtils";
 import { createWorkerTransformer } from "@angular/build/src/tools/angular/transformers/web-worker-transformer";
-import { SdDependencyCache } from "./sd-dependency-cache";
-import { SdDependencyAnalyzer } from "./sd-dependency-analyzer";
+import { SdDepCache } from "./SdDepCache";
+import { SdDepAnalyzer } from "./SdDepAnalyzer";
 import { FlatESLint } from "eslint/use-at-your-own-risk";
-import { SdStyleBundler } from "./sd-style-bundler";
+import { SdStyleBundler } from "./SdStyleBundler";
+import { ISdTsCompilerOptions } from "../types/build/ISdTsCompilerOptions";
+import { ISdTsCompilerResult } from "../types/build/ISdTsCompilerResult";
 
 export class SdTsCompiler {
   #logger = SdLogger.get(["simplysm", "sd-cli", "SdTsCompiler"]);
@@ -26,7 +27,7 @@ export class SdTsCompiler {
 
   // 빌드정보 캐싱
   #cache = {
-    dep: new SdDependencyCache(),
+    dep: new SdDepCache(),
     type: new WeakMap<ts.Node, ts.Type | undefined>(),
     prop: new WeakMap<ts.Type, Map<string, ts.Symbol | undefined>>(),
     declFiles: new WeakMap<ts.Symbol, TNormPath[]>(),
@@ -43,7 +44,7 @@ export class SdTsCompiler {
 
   #perf!: SdCliPerformanceTimer;
 
-  constructor(private readonly _opt: SdTsCompilerOptions) {
+  constructor(private readonly _opt: ISdTsCompilerOptions) {
     this.#debug("초기화 중...");
 
     const tsconfigPath = path.resolve(this._opt.pkgPath, "tsconfig.json");
@@ -54,7 +55,7 @@ export class SdTsCompiler {
       this.#styleBundler = new SdStyleBundler(
         this._opt.pkgPath,
         this._opt.isDevMode,
-        this._opt.watchScopePathSet,
+        this._opt.scopePathSet,
       );
     }
   }
@@ -171,23 +172,6 @@ export class SdTsCompiler {
             context.resourceFile != null ? PathUtils.norm(context.resourceFile) : undefined,
           );
 
-          /*if (!styleBundleResult.cached && !StringUtils.isNullOrEmpty(styleBundleResult.contents)) {
-            const relPath = path.relative(
-              path.resolve(this._opt.pkgPath, "src"),
-              context.containingFile,
-            );
-            const outAbsPath = PathUtils.norm(
-              compilerOptions.outDir!,
-              relPath.replace(/\.ts$/, ".css"),
-            );
-            const cache = this.#emittedFilesCacheMap.getOrCreate(
-              PathUtils.norm(context.containingFile),
-              [],
-            );
-            cache.remove((item) => item.outAbsPath === outAbsPath);
-            cache.push({ outAbsPath, text: styleBundleResult.contents });
-          }*/
-
           return StringUtils.isNullOrEmpty(styleBundleResult.contents)
             ? null
             : { content: styleBundleResult.contents };
@@ -240,7 +224,7 @@ export class SdTsCompiler {
 
     const tsconfig = this.#parseTsConfig();
 
-    if (modifiedFileSet.size !== 0) {
+    if (modifiedFileSet.size !== 0 && this._opt.isWatchMode) {
       this.#debug(`캐시 무효화 및 초기화 중...`);
 
       // this._perf.run("캐시 무효화 및 초기화", () => {
@@ -313,17 +297,12 @@ export class SdTsCompiler {
       });
     }
 
-    if (!this._opt.isEmitOnly) {
+    if (!this._opt.isEmitOnly && this._opt.isWatchMode) {
       this.#debug(`새 의존성 분석 중...`);
 
       this.#perf.run("새 의존성 분석", () => {
         // SdTsDependencyAnalyzer를 통해 의존성 분석 및 SdDepCache 업데이트
-        SdDependencyAnalyzer.analyze(
-          this.#program!,
-          compilerHost,
-          this._opt.watchScopePathSet,
-          this.#cache,
-        );
+        SdDepAnalyzer.analyze(this.#program!, compilerHost, this._opt.scopePathSet, this.#cache);
       });
 
       this.#debug(`새 의존성 분석(Angular) 중...`);
@@ -331,9 +310,9 @@ export class SdTsCompiler {
       // Angular 리소스 의존성 추가
       if (this.#ngProgram) {
         this.#perf.run("새 의존성 분석(Angular)", () => {
-          SdDependencyAnalyzer.analyzeAngularResources(
+          SdDepAnalyzer.analyzeAngularResources(
             this.#ngProgram!,
-            this._opt.watchScopePathSet,
+            this._opt.scopePathSet,
             this.#cache.dep,
           );
         });
@@ -341,13 +320,11 @@ export class SdTsCompiler {
     }
 
     const allFiles = this.#program!.getSourceFiles().map((item) => PathUtils.norm(item.fileName));
-    const watchFileSet = new Set(
-      allFiles.filter((item) => this._opt.watchScopePathSet.inScope(item)),
-    );
+    const watchFileSet = new Set(allFiles.filter((item) => this._opt.scopePathSet.inScope(item)));
 
     let affectedFileSet: Set<TNormPath>;
     if (modifiedFileSet.size === 0) {
-      affectedFileSet = new Set(allFiles);
+      affectedFileSet = new Set(allFiles.filter((item) => this._opt.scopePathSet.inScope(item)));
     } else {
       const affectedFileMap = this.#cache.dep.getAffectedFileMap(modifiedFileSet);
       this.#debug("영향받은 파일:", affectedFileMap);
@@ -459,8 +436,6 @@ export class SdTsCompiler {
           continue;
         }
 
-        // this.#debug(`get diagnostics of file ${affectedFile}...`);
-
         this.#perf.run("개별 파일 진단 수집", () => {
           diagnostics.push(
             ...this.#program!.getSyntacticDiagnostics(affectedSourceFile),
@@ -507,8 +482,6 @@ export class SdTsCompiler {
               return relPath.replace(/\.ts$/, "").replaceAll("\\", "/") + ".js";
             }),
           );
-
-          // (transformers.before ??= []).push(this.#createExternalizeComponentStylesTransformer());
         }
 
         this.#debug(`파일 출력 중...`);
@@ -595,106 +568,6 @@ export class SdTsCompiler {
     };
   }
 
-  /*#createExternalizeComponentStylesTransformer() {
-    const f = ts.factory;
-
-    function upsertEnsureStyleHelper(sf: ts.SourceFile): ts.SourceFile {
-      const importTarget = "./" + path.basename(sf.fileName).replace(/\.ts$/, ".css");
-
-      // 이미 동일한 import가 있으면 스킵
-      if (
-        sf.statements.some(
-          (s) =>
-            ts.isImportDeclaration(s) &&
-            ts.isStringLiteral(s.moduleSpecifier) &&
-            s.moduleSpecifier.text === importTarget,
-        )
-      ) {
-        return sf;
-      }
-
-      const importDecl = f.createImportDeclaration(
-        undefined,
-        undefined,
-        f.createStringLiteral(importTarget),
-      );
-
-      return f.updateSourceFile(sf, [importDecl, ...sf.statements]);
-    }
-
-    const removeStyleProp = (node: ts.ClassDeclaration) => {
-      const allDecorators = ts.getDecorators(node);
-      if (!allDecorators || allDecorators.length === 0) return node;
-
-      const decoratorsUpdated = allDecorators.map((dec) => {
-        if (!ts.isCallExpression(dec.expression)) return dec;
-        const call = dec.expression;
-        if (!ts.isIdentifier(call.expression) || call.expression.text !== "Component") return dec;
-        if (call.arguments.length !== 1) return dec;
-        const arg = call.arguments[0];
-        if (!ts.isObjectLiteralExpression(arg)) return dec;
-
-        const filteredProps = arg.properties.filter((p) => {
-          if (!ts.isPropertyAssignment(p)) return true;
-          const name = p.name;
-          const key = ts.isIdentifier(name)
-            ? name.text
-            : ts.isStringLiteralLike(name)
-              ? name.text
-              : undefined;
-          return !(key === "styles" || key === "styleUrls");
-        });
-
-        const newArg = f.updateObjectLiteralExpression(arg, filteredProps);
-        const newCall = f.updateCallExpression(call, call.expression, call.typeArguments, [newArg]);
-        return f.updateDecorator(dec, newCall);
-      });
-
-      const existingModifiers = node.modifiers ?? [];
-      const modifiersWithoutOldDecos = existingModifiers.filter((m) => !ts.isDecorator(m));
-      const newModifiers: readonly ts.ModifierLike[] = [
-        ...decoratorsUpdated,
-        ...modifiersWithoutOldDecos,
-      ];
-
-      const newNode = f.updateClassDeclaration(
-        node,
-        newModifiers,
-        node.name,
-        node.typeParameters,
-        node.heritageClauses,
-        node.members,
-      );
-
-      return f.updateClassDeclaration(
-        newNode,
-        newNode.modifiers,
-        newNode.name,
-        newNode.typeParameters,
-        newNode.heritageClauses,
-        newNode.members,
-      );
-    };
-
-    return (ctx: ts.TransformationContext) => {
-      return (sf: ts.SourceFile) => {
-        const has = this.#styleBundler!.getResultCache().get(PathUtils.norm(sf.fileName));
-        if (!has) return sf;
-
-        const realSf = upsertEnsureStyleHelper(sf);
-
-        function visitor(node: ts.Node): ts.Node {
-          if (ts.isClassDeclaration(node) && Boolean(ts.getDecorators(node)?.length)) {
-            return removeStyleProp(node);
-          }
-          return ts.visitEachChild(node, visitor, ctx);
-        }
-
-        return ts.visitNode(realSf, visitor) as ts.SourceFile;
-      };
-    };
-  }*/
-
   #convertOutputToReal(filePath: string, distPath: string, text: string) {
     let realFilePath = PathUtils.norm(filePath);
     let realText = text;

package/src/types/{build.types.ts → build/ISdBuildMessage.ts}

@@ -1,11 +1,5 @@
 import { TNormPath } from "@simplysm/sd-core-node";
 
-export interface ISdBuildRunnerResult {
-  affectedFilePathSet: Set<TNormPath>;
-  buildMessages: ISdBuildMessage[];
-  emitFileSet: Set<TNormPath>;
-}
-
 export interface ISdBuildMessage {
   filePath: TNormPath | undefined;
   line: number | undefined;

package/src/types/build/ISdBuildResult.ts

@@ -0,0 +1,9 @@
+import { TNormPath } from "@simplysm/sd-core-node";
+import { ISdBuildMessage } from "./ISdBuildMessage";
+
+export interface ISdBuildResult {
+  buildMessages: ISdBuildMessage[];
+  watchFileSet: Set<TNormPath>;
+  affectedFileSet: Set<TNormPath>;
+  emitFileSet: Set<TNormPath>;
+}

package/src/types/build/ISdTsCompilerOptions.ts

@@ -0,0 +1,15 @@
+import { TNormPath } from "@simplysm/sd-core-node";
+import ts from "typescript";
+import { ScopePathSet } from "../../pkg-builders/commons/ScopePathSet";
+
+export interface ISdTsCompilerOptions {
+  pkgPath: TNormPath;
+  additionalOptions: ts.CompilerOptions;
+  isForBundle: boolean;
+  isWatchMode: boolean;
+  isDevMode: boolean;
+  isEmitOnly: boolean;
+  isNoEmit: boolean;
+  scopePathSet: ScopePathSet;
+  globalStyleFilePath?: TNormPath;
+}

package/src/types/build/ISdTsCompilerResult.ts

@@ -0,0 +1,12 @@
+import { ISdBuildMessage } from "./ISdBuildMessage";
+import { TNormPath } from "@simplysm/sd-core-node";
+import { TStylesheetBundlingResult } from "./TStylesheetBundlingResult";
+
+export interface ISdTsCompilerResult {
+  messages: ISdBuildMessage[];
+  stylesheetBundlingResultMap: Map<TNormPath, TStylesheetBundlingResult>;
+  emittedFilesCacheMap: Map<TNormPath, { outAbsPath?: TNormPath; text: string }[]>;
+  emitFileSet: Set<TNormPath>;
+  watchFileSet: Set<TNormPath>;
+  affectedFileSet: Set<TNormPath>;
+}

package/src/types/build/TStylesheetBundlingResult.ts

@@ -0,0 +1,15 @@
+import esbuild from "esbuild";
+
+export type TStylesheetBundlingResult =
+  | {
+      errors: esbuild.PartialMessage[];
+      warnings: esbuild.PartialMessage[];
+      contents?: string;
+    }
+  | {
+      errors: undefined;
+      warnings: esbuild.PartialMessage[];
+      metafile: esbuild.Metafile;
+      outputFiles: esbuild.OutputFile[];
+      contents: string;
+    };

package/src/types/{common-configs.types.ts → common-config/INpmConfig.ts}

@@ -22,9 +22,3 @@ export interface INpmConfig {
 
   scripts?: Record<string, string>;
 }
-
-export interface ITsConfig {
-  files?: string[];
-  compilerOptions: { lib: string[] };
-  angularCompilerOptions?: {};
-}

package/src/types/common-config/ITsConfig.ts

@@ -0,0 +1,5 @@
+export interface ITsConfig {
+  files?: string[];
+  compilerOptions: { lib: string[] };
+  angularCompilerOptions?: {};
+}

package/src/types/{config.types.ts → config/ISdProjectConfig.ts}

@@ -23,7 +23,6 @@ export interface ISdLibPackageConfig {
   publish?: "npm";
   polyfills?: string[];
   noGenIndex?: boolean;
-  noBuild?: boolean;
   dbContext?: string;
   forceProductionMode?: boolean;
 }

package/src/types/plugin/ISdCliNgPluginResultCache.ts

@@ -0,0 +1,9 @@
+import esbuild from "esbuild";
+import { TNormPath } from "@simplysm/sd-core-node";
+
+export interface ISdCliNgPluginResultCache {
+  watchFileSet?: Set<TNormPath>;
+  affectedFileSet?: Set<TNormPath>;
+  outputFiles?: esbuild.OutputFile[];
+  metafile?: esbuild.Metafile;
+}

package/src/types/{build-plugin.types.ts → plugin/ISdCliServerPluginResultCache.ts}

@@ -7,10 +7,3 @@ export interface ISdCliServerPluginResultCache {
   outputFiles?: esbuild.OutputFile[];
   metafile?: esbuild.Metafile;
 }
-
-export interface ISdCliNgPluginResultCache {
-  watchFileSet?: Set<TNormPath>;
-  affectedFileSet?: Set<TNormPath>;
-  outputFiles?: esbuild.OutputFile[];
-  metafile?: esbuild.Metafile;
-}

package/src/types/worker/ISdBuildRunnerWorkerType.ts

@@ -0,0 +1,24 @@
+import { ISdBuildResult } from "../build/ISdBuildResult";
+import { ISdWorkerType, TNormPath } from "@simplysm/sd-core-node";
+import { ISdProjectConfig } from "../config/ISdProjectConfig";
+
+export interface ISdBuildRunnerWorkerType extends ISdWorkerType {
+  methods: {
+    initialize: {
+      params: [ISdBuildRunnerInitializeRequest];
+      returnType: void;
+    };
+    rebuild: { params: [Set<TNormPath>?]; returnType: ISdBuildResult };
+  };
+}
+
+export interface ISdBuildRunnerInitializeRequest {
+  pkgPath: TNormPath;
+  projConf: ISdProjectConfig;
+
+  // watch
+  watch?: boolean;
+  emitOnly?: boolean;
+  noEmit?: boolean;
+  scopePathSet?: Set<TNormPath>;
+}

package/src/types/worker/IServerWorkerType.ts

@@ -0,0 +1,8 @@
+export interface IServerWorkerType {
+  methods: {
+    listen: { params: [string | number]; returnType: number };
+    setPathProxy: { params: [Record<string, string>]; returnType: void };
+    broadcastReload: { params: [string | undefined, Set<string>]; returnType: void };
+  };
+  events: {};
+}

package/src/utils/{sd-cli-convert-message.utils.ts → SdCliConvertMessageUtils.ts}

@@ -3,7 +3,7 @@ import os from "os";
 import path from "path";
 import { PartialMessage } from "esbuild";
 import { ESLint } from "eslint";
-import { ISdBuildMessage } from "../types/build.types";
+import { ISdBuildMessage } from "../types/build/ISdBuildMessage";
 import { PathUtils } from "@simplysm/sd-core-node";
 
 export class SdCliConvertMessageUtils {
@@ -23,7 +23,9 @@ export class SdCliConvertMessageUtils {
 
       const filePath = diag.file ? PathUtils.norm(path.resolve(diag.file.fileName)) : undefined;
       const position =
-        diag.file && diag.start !== undefined ? diag.file.getLineAndCharacterOfPosition(diag.start) : undefined;
+        diag.file && diag.start !== undefined
+          ? diag.file.getLineAndCharacterOfPosition(diag.start)
+          : undefined;
       const line = position ? position.line + 1 : undefined;
       const char = position ? position.character + 1 : undefined;
 
@@ -47,7 +49,8 @@ export class SdCliConvertMessageUtils {
     orgPath: string,
   ): ISdBuildMessage[] {
     const convertFn = (msg: PartialMessage, severity: "error" | "warning") => {
-      const filePath = msg.location?.file != null ? PathUtils.norm(orgPath, msg.location.file) : undefined;
+      const filePath =
+        msg.location?.file != null ? PathUtils.norm(orgPath, msg.location.file) : undefined;
       const line = msg.location?.line;
       const char = msg.location?.column;
       const code = msg.text!.slice(0, msg.text!.indexOf(":"));

package/src/{entry/utils → utils}/loadProjConfAsync.ts

@@ -1,12 +1,16 @@
 import { pathToFileURL } from "url";
 import path from "path";
-import { ISdProjectConfig } from "../../types/config.types";
+import { ISdProjectConfig } from "../types/config/ISdProjectConfig";
 
-export async function loadProjConfAsync(rootPath: string, dev: boolean, opt: {
-  config: string;
-  options?: string[];
-}) {
+export async function loadProjConfAsync(
+  rootPath: string,
+  dev: boolean,
+  opt: {
+    config: string;
+    options?: string[];
+  },
+) {
   const filePath = path.resolve(rootPath, opt.config);
   const imported = await import(pathToFileURL(filePath).href);
   return imported.default(dev, opt.options ?? []) as ISdProjectConfig;
-}
+}

package/src/workers/build-runner.worker.ts

@@ -1,13 +1,21 @@
-import { createSdWorker, FsUtils, SdLogger, SdLoggerSeverity } from "@simplysm/sd-core-node";
-import { ISdBuildMessage } from "../types/build.types";
-import path from "path";
-import { SdServerBuildRunner } from "../pkg-builders/server/sd-server.build-runner";
-import { SdClientBuildRunner } from "../pkg-builders/client/sd-client.build-runner";
-import { SdTsLibBuildRunner } from "../pkg-builders/lib/sd-ts-lib.build-runner";
-import { SdJsLibBuildRunner } from "../pkg-builders/lib/sd-js-lib.build-runner";
-import { TSdBuildRunnerWorkerType } from "../types/worker.types";
-import { ISdBuildRunnerWorkerRequest } from "../types/build-runner.types";
+import {
+  createSdWorker,
+  FsUtils,
+  SdLogger,
+  SdLoggerSeverity,
+  TNormPath,
+} from "@simplysm/sd-core-node";
 import { EventEmitter } from "events";
+import path from "path";
+import {
+  ISdBuildRunnerInitializeRequest,
+  ISdBuildRunnerWorkerType,
+} from "../types/worker/ISdBuildRunnerWorkerType";
+import { SdBuildRunnerBase } from "../pkg-builders/commons/SdBuildRunnerBase";
+import { SdServerBuildRunner } from "../pkg-builders/server/SdServerBuildRunner";
+import { SdClientBuildRunner } from "../pkg-builders/client/SdClientBuildRunner";
+import { SdTsLibBuildRunner } from "../pkg-builders/lib/SdTsLibBuildRunner";
+import { SdJsLibBuildRunner } from "../pkg-builders/lib/SdJsLibBuildRunner";
 
 Error.stackTraceLimit = Infinity;
 EventEmitter.defaultMaxListeners = 0;
@@ -24,8 +32,10 @@ if (process.env["SD_DEBUG"] != null) {
   });
 }
 
-const worker = createSdWorker<TSdBuildRunnerWorkerType>({
-  async run(req: ISdBuildRunnerWorkerRequest): Promise<ISdBuildMessage[] | void> {
+let buildRunner: SdBuildRunnerBase<any>;
+
+createSdWorker<ISdBuildRunnerWorkerType>({
+  initialize(req: ISdBuildRunnerInitializeRequest) {
     const pkgConf = req.projConf.packages[path.basename(req.pkgPath)]!;
 
     const buildRunnerType =
@@ -37,26 +47,17 @@ const worker = createSdWorker<TSdBuildRunnerWorkerType>({
             ? SdTsLibBuildRunner
             : SdJsLibBuildRunner;
 
-    const builder = new buildRunnerType(
-      req.projConf,
+    buildRunner = new buildRunnerType(
       req.pkgPath,
-      req.workspaces,
+      req.projConf,
+      req.watch ?? false,
+      req.watch ? !pkgConf.forceProductionMode : false,
       req.emitOnly,
       req.noEmit,
-    )
-      .on("change", () => {
-        worker.send("change");
-      })
-      .on("complete", (result) => {
-        worker.send("complete", result);
-      });
-
-    if (req.cmd === "build") {
-      const res = await builder.buildAsync();
-      return res.buildMessages;
-    } else {
-      await builder.watchAsync();
-      return;
-    }
+      req.scopePathSet,
+    );
+  },
+  async rebuild(modifiedFileSet?: Set<TNormPath>) {
+    return await buildRunner.rebuildAsync(modifiedFileSet);
   },
 });

package/src/workers/server.worker.ts

@@ -3,7 +3,7 @@ import { pathToFileURL } from "url";
 import type { SdServiceServer } from "@simplysm/sd-service-server";
 import { createSdWorker, SdLogger, SdLoggerSeverity } from "@simplysm/sd-core-node";
 import { EventEmitter } from "events";
-import { TServerWorkerType } from "../types/worker.types";
+import { IServerWorkerType } from "../types/worker/IServerWorkerType";
 
 Error.stackTraceLimit = Infinity;
 EventEmitter.defaultMaxListeners = 0;
@@ -22,10 +22,10 @@ if (process.env["SD_DEBUG"] != null) {
 
 let server: SdServiceServer;
 
-createSdWorker<TServerWorkerType>({
-  async listen(pkgInfo: { path: string } | { port: number }) {
-    if ("path" in pkgInfo) {
-      const mainFilePath = path.resolve(pkgInfo.path, "dist/main.js");
+createSdWorker<IServerWorkerType>({
+  async listen(pkgPathOrPort: string | number) {
+    if (typeof pkgPathOrPort === "string") {
+      const mainFilePath = path.resolve(pkgPathOrPort, "dist/main.js");
       const serverModule = await import(pathToFileURL(mainFilePath).href);
       const currServer = serverModule.default as SdServiceServer | undefined;
       if (currServer == null) {
@@ -38,14 +38,14 @@ createSdWorker<TServerWorkerType>({
       server = new SdServiceServer({
         rootPath: process.cwd(),
         services: [],
-        port: pkgInfo.port,
+        port: pkgPathOrPort,
       });
       await server.listenAsync();
     }
 
     return server.options.port;
   },
-  setPathProxy(pathProxy: Record<string, string | number>) {
+  setPathProxy(pathProxy: Record<string, string>) {
     server.pathProxy = pathProxy;
   },
   broadcastReload(clientName: string | undefined, changedFileSet: Set<string>) {