@simplysm/sd-cli 7.0.49 → 7.0.54

package/src/builder/SdCliServerBuilder.ts

@@ -1,6 +1,6 @@
 import { INpmConfig, ISdCliPackageBuildResult, ISdCliServerPackageConfig } from "../commons";
 import { EventEmitter } from "events";
-import { FsUtil, Logger, PathUtil } from "@simplysm/sd-core/node";
+import { FsUtil, Logger, PathUtil } from "@simplysm/sd-core-node";
 import webpack from "webpack";
 import path from "path";
 import ts from "typescript";
@@ -9,7 +9,7 @@ import { ErrorInfo } from "ts-loader/dist/interfaces";
 import os from "os";
 import { ESLint } from "eslint";
 import TerserPlugin from "terser-webpack-plugin";
-import { ObjectUtil, StringUtil } from "@simplysm/sd-core/common";
+import { ObjectUtil, StringUtil } from "@simplysm/sd-core-common";
 import ESLintWebpackPlugin from "eslint-webpack-plugin";
 import CopyWebpackPlugin from "copy-webpack-plugin";
 import { LicenseWebpackPlugin } from "license-webpack-plugin";
@@ -46,8 +46,8 @@ export class SdCliServerBuilder extends EventEmitter {
     await FsUtil.removeAsync(this._parsedTsconfig.options.outDir!);
 
     // 빌드 준비
-    const extModuleNames = this._getExternalModuleNames();
-    const webpackConfig = this._getWebpackConfig(true, extModuleNames);
+    const extModules = this._getExternalModules();
+    const webpackConfig = this._getWebpackConfig(true, extModules.map((item) => item.name));
     const compiler = webpack(webpackConfig);
     await new Promise<void>((resolve, reject) => {
       compiler.hooks.watchRun.tapAsync(this.constructor.name, (args, callback) => {
@@ -80,8 +80,8 @@ export class SdCliServerBuilder extends EventEmitter {
 
     // 빌드
     this._logger.debug("Webpack 빌드 수행...");
-    const extModuleNames = this._getExternalModuleNames();
-    const webpackConfig = this._getWebpackConfig(false, extModuleNames);
+    const extModules = this._getExternalModules();
+    const webpackConfig = this._getWebpackConfig(false, extModules.map((item) => item.name));
     const compiler = webpack(webpackConfig);
     const buildResults = await new Promise<ISdCliPackageBuildResult[]>((resolve, reject) => {
       compiler.run((err, stats) => {
@@ -106,7 +106,7 @@ export class SdCliServerBuilder extends EventEmitter {
     await this._writeDistIisConfigFileAsync();
 
     // 배포용 package.json 파일 생성
-    await this._writeDistNpmConfigFileAsync(extModuleNames);
+    await this._writeDistNpmConfigFileAsync(extModules.filter((item) => item.exists).map((item) => item.name));
 
     // 마무리
     this._logger.debug("Webpack 빌드 완료");
@@ -204,10 +204,18 @@ export class SdCliServerBuilder extends EventEmitter {
     );
   }
 
+  private _getInternalModuleCachePaths(workspaceName: string): string[] {
+    return [
+      ...FsUtil.findAllParentChildDirPaths("node_modules/*/package.json", this._rootPath, this._workspaceRootPath),
+      ...FsUtil.findAllParentChildDirPaths(`node_modules/!(@simplysm|@${workspaceName})/*/package.json`, this._rootPath, this._workspaceRootPath),
+    ].map((p) => path.dirname(p));
+  }
+
   private _getWebpackConfig(watch: boolean, extModuleNames: string[]): webpack.Configuration {
-    const internalModuleCachePaths = watch
-      ? FsUtil.findAllParentChildDirPaths("node_modules/!(@simplysm)", this._rootPath, this._workspaceRootPath)
-      : undefined;
+    const workspaceNpmConfig = this._getNpmConfig(this._workspaceRootPath)!;
+    const workspaceName = workspaceNpmConfig.name;
+
+    const internalModuleCachePaths = watch ? this._getInternalModuleCachePaths(workspaceName) : undefined;
 
     const npmConfig = this._getNpmConfig(this._rootPath)!;
     const pkgKey = npmConfig.name.split("/").last()!;
@@ -246,7 +254,9 @@ export class SdCliServerBuilder extends EventEmitter {
         filename: "[name].mjs",
         chunkFilename: "[name].mjs",
         assetModuleFilename: "res/[name][ext][query]",
-        libraryTarget: "module"
+        library: {
+          type: "module"
+        }
       },
       watch: false,
       watchOptions: { poll: undefined, ignored: undefined },
@@ -281,7 +291,7 @@ export class SdCliServerBuilder extends EventEmitter {
         __dirname: true
       },
       optimization: {
-        minimizer: watch ? [
+        minimizer: watch ? [] : [
           new TerserPlugin({
             extractComments: false,
             terserOptions: {
@@ -298,7 +308,7 @@ export class SdCliServerBuilder extends EventEmitter {
               }
             }
           })
-        ] : [],
+        ],
         moduleIds: "deterministic",
         chunkIds: watch ? "named" : "deterministic",
         emitOnErrors: watch
@@ -314,12 +324,15 @@ export class SdCliServerBuilder extends EventEmitter {
           },
           ...watch ? [
             {
-              test: /\.m?js$/,
+              test: /\.[cm]?jsx?$/,
               enforce: "pre" as const,
               loader: "source-map-loader",
               options: {
                 filterSourceMappingUrl: (mapUri: string, resourcePath: string) => {
-                  return !resourcePath.includes("node_modules") || (/@simplysm[\\/]/).test(resourcePath);
+                  const workspaceRegex = new RegExp(`node_modules[\\\\/]@${workspaceName}[\\\\/]`);
+                  return !resourcePath.includes("node_modules")
+                    || (/node_modules[\\/]@simplysm[\\/]/).test(resourcePath)
+                    || workspaceRegex.test(resourcePath);
                 }
               }
             }
@@ -418,9 +431,9 @@ export class SdCliServerBuilder extends EventEmitter {
     };
   }
 
-  private _getExternalModuleNames(): string[] {
+  private _getExternalModules(): { name: string; exists: boolean }[] {
     const loadedModuleNames: string[] = [];
-    const resultSet = new Set<string>();
+    const results: { name: string; exists: boolean }[] = [];
 
     const fn = (currPath: string): void => {
       const npmConfig = this._getNpmConfig(currPath);
@@ -438,7 +451,7 @@ export class SdCliServerBuilder extends EventEmitter {
         }
 
         if (FsUtil.exists(path.resolve(modulePath, "binding.gyp"))) {
-          resultSet.add(moduleName);
+          results.push({ name: moduleName, exists: true });
         }
 
         fn(modulePath);
@@ -450,12 +463,12 @@ export class SdCliServerBuilder extends EventEmitter {
 
         const optModulePath = FsUtil.findAllParentChildDirPaths("node_modules/" + optModuleName, currPath, this._workspaceRootPath).first();
         if (StringUtil.isNullOrEmpty(optModulePath)) {
-          resultSet.add(optModuleName);
+          results.push({ name: optModuleName, exists: false });
           continue;
         }
 
         if (FsUtil.exists(path.resolve(optModulePath, "binding.gyp"))) {
-          resultSet.add(optModuleName);
+          results.push({ name: optModuleName, exists: true });
         }
 
         fn(optModulePath);
@@ -464,7 +477,7 @@ export class SdCliServerBuilder extends EventEmitter {
 
     fn(this._rootPath);
 
-    return Array.from(resultSet.values());
+    return results;
   }
 
   private _getNpmConfig(pkgPath: string): INpmConfig | undefined {

package/src/builder/SdCliTsLibBuilder.ts

@@ -1,7 +1,7 @@
 import { INpmConfig, ISdCliPackageBuildResult } from "../commons";
 import { EventEmitter } from "events";
 import ts from "typescript";
-import { FsUtil, Logger, PathUtil, SdFsWatcher } from "@simplysm/sd-core/node";
+import { FsUtil, Logger, PathUtil, SdFsWatcher } from "@simplysm/sd-core-node";
 import * as path from "path";
 import { createHash } from "crypto";
 import { SdCliBuildResultUtil } from "../utils/SdCliBuildResultUtil";

package/src/commons.ts

@@ -2,10 +2,8 @@ export interface INpmConfig {
   name: string;
   version: string;
   workspaces?: string[];
-  es2020?: string;
-  browser?: string;
-  module?: string;
   main?: string;
+  types?: string;
   exports?: Record<string, {
     types?: string;
   }>;
@@ -23,7 +21,10 @@ export interface ITsconfig {
     outDir?: string;
     baseUrl?: string;
     paths?: Record<string, string[]>;
+    declaration?: boolean;
   };
+  files?: string[];
+  angularCompilerOptions?: Record<string, any>;
 }
 
 export interface ISdCliPackageBuildResult {
@@ -44,6 +45,9 @@ export type TSdCliPackageConfig = ISdCliLibPackageConfig | ISdCliServerPackageCo
 
 export interface ISdCliLibPackageConfig {
   type: "library";
+  autoIndex?: {
+    polyfills?: string[];
+  };
   publish?: "npm";
 }
 
@@ -59,4 +63,5 @@ export interface ISdCliClientPackageConfig {
   type: "client";
   server: string;
   env?: Record<string, string>;
+  configs?: Record<string, any>;
 }

package/src/entry-points/SdCliIndexFileGenerator.ts

@@ -0,0 +1,79 @@
+import { ITsconfig } from "../commons";
+import * as path from "path";
+import { FsUtil, PathUtil } from "@simplysm/sd-core-node";
+import * as os from "os";
+import * as chokidar from "chokidar";
+
+export class SdCliIndexFileGenerator {
+  private readonly _indexFilePath = path.resolve(this.rootPath, "src/index.ts");
+  private _contentCache: string | undefined;
+
+  public constructor(public readonly rootPath: string,
+                     public readonly config: ISdAutoIndexConfig) {
+  }
+
+  public async watchAsync(): Promise<void> {
+    const watcher = chokidar.watch([path.resolve(this.rootPath, "src")], { persistent: true });
+    watcher.on("add", async (filePath) => {
+      if (filePath.endsWith(".ts")) {
+        await this.runAsync();
+      }
+    });
+    watcher.on("unlink", async (filePath) => {
+      if (filePath.endsWith(".ts")) {
+        await this.runAsync();
+      }
+    });
+
+    await this.runAsync();
+  }
+
+  public async runAsync(): Promise<void> {
+    const importTexts: string[] = [];
+
+    // 옵션의 polyfills 를 모두 import
+    if (this.config.polyfills) {
+      for (const polyfill of this.config.polyfills) {
+        importTexts.push(`import "${polyfill}";`);
+      }
+    }
+
+    // 내부 파일들 import
+    const filePaths = await this._getFilePathsAsync();
+    for (const filePath of filePaths) {
+      const requirePath = PathUtil.posix(path.relative(path.dirname(this._indexFilePath), filePath))
+        .replace(/\.ts$/, "")
+        .replace(/\/index$/, "");
+
+      const sourceTsFileContent = await FsUtil.readFileAsync(filePath);
+      if (sourceTsFileContent.split("\n").some((line) => line.startsWith("export "))) {
+        importTexts.push(`export * from "./${requirePath}";`);
+      }
+      else {
+        importTexts.push(`import "./${requirePath}";`);
+      }
+    }
+
+    const content = importTexts.join(os.EOL) + os.EOL;
+    const prevContent = this._contentCache ?? (FsUtil.exists(this._indexFilePath) ? FsUtil.readFile(this._indexFilePath) : undefined);
+    this._contentCache = content;
+    if (content !== prevContent) {
+      await FsUtil.writeFileAsync(this._indexFilePath, content);
+    }
+  }
+
+  private async _getFilePathsAsync(): Promise<string[]> {
+    const tsconfig: ITsconfig = await FsUtil.readJsonAsync(path.resolve(this.rootPath, "tsconfig.json"));
+    const entryFilePaths = tsconfig.files?.map((item) => path.resolve(this.rootPath, item)) ?? [];
+
+    return (await FsUtil.globAsync(path.resolve(this.rootPath, "src/**/*.ts"), { nodir: true }))
+      .filter((item) => (
+        !entryFilePaths.includes(item)
+        && item !== this._indexFilePath
+      ));
+  }
+}
+
+export interface ISdAutoIndexConfig {
+  polyfills?: string[];
+}

package/src/entry-points/SdCliLocalUpdate.ts

@@ -1,5 +1,5 @@
 import { SdCliConfigUtil } from "../utils/SdCliConfigUtil";
-import { FsUtil, Logger, PathUtil, SdFsWatcher } from "@simplysm/sd-core/node";
+import { FsUtil, Logger, PathUtil, SdFsWatcher } from "@simplysm/sd-core-node";
 import * as path from "path";
 
 export class SdCliLocalUpdate {
@@ -14,6 +14,7 @@ export class SdCliLocalUpdate {
     if (!conf.localUpdates) return;
 
     const updatePathInfos = await this._getUpdatePathInfosAsync(conf.localUpdates);
+    this._logger.debug("로컬 업데이트 구성", updatePathInfos);
 
     this._logger.log("로컬 라이브러리 업데이트 시작...");
     for (const updatePathInfo of updatePathInfos) {
@@ -36,6 +37,7 @@ export class SdCliLocalUpdate {
     if (!conf.localUpdates) return;
 
     const updatePathInfos = await this._getUpdatePathInfosAsync(conf.localUpdates);
+    this._logger.debug("로컬 업데이트 구성", updatePathInfos);
 
     const watchPaths = (await updatePathInfos.mapManyAsync(async (item) => await this._getWatchPathsAsync(item.source))).distinct();
 
@@ -73,7 +75,10 @@ export class SdCliLocalUpdate {
     const result: IUpdatePathInfo[] = [];
     for (const pkgGlobPath of Object.keys(record)) {
       // "node_modules'에서 로컬업데이트 설정에 맞는 패키지를 "glob"하여 대상 패키지경로 목록 가져오기
-      const targetPaths = await FsUtil.globAsync(path.resolve(this._rootPath, "node_modules", pkgGlobPath));
+      const targetPaths = [
+        ...await FsUtil.globAsync(path.resolve(this._rootPath, "node_modules", pkgGlobPath)),
+        ...await FsUtil.globAsync(path.resolve(this._rootPath, "packages", "*", "node_modules", pkgGlobPath))
+      ];
 
       result.push(
         ...targetPaths

package/src/entry-points/SdCliNpm.ts

@@ -1,4 +1,4 @@
-import { Logger, SdProcess } from "@simplysm/sd-core/node";
+import { Logger, SdProcess } from "@simplysm/sd-core-node";
 import { SdCliPrepare } from "./SdCliPrepare";
 
 export class SdCliNpm {

package/src/entry-points/SdCliPrepare.ts

@@ -1,4 +1,4 @@
-import { FsUtil, Logger } from "@simplysm/sd-core/node";
+import { FsUtil, Logger } from "@simplysm/sd-core-node";
 import { fileURLToPath } from "url";
 
 export class SdCliPrepare {

package/src/entry-points/SdCliWorkspace.ts

@@ -1,16 +1,17 @@
-import { FsUtil, Logger, SdProcess } from "@simplysm/sd-core/node";
+import { FsUtil, Logger, SdProcess } from "@simplysm/sd-core-node";
 import path from "path";
 import { INpmConfig, ISdCliConfig, ISdCliPackageBuildResult } from "../commons";
 import { SdCliPackage } from "../packages/SdCliPackage";
-import { Uuid, Wait } from "@simplysm/sd-core/common";
+import { Uuid, Wait } from "@simplysm/sd-core-common";
 import os from "os";
 import { SdCliBuildResultUtil } from "../utils/SdCliBuildResultUtil";
 import semver from "semver/preload";
 import { SdCliConfigUtil } from "../utils/SdCliConfigUtil";
-import { SdServiceServer } from "@simplysm/sd-service/server";
+import { SdServiceServer } from "@simplysm/sd-service-server";
 import { SdCliNpm } from "./SdCliNpm";
 import { SdCliLocalUpdate } from "./SdCliLocalUpdate";
 import { NextHandleFunction } from "connect";
+import { SdCliIndexFileGenerator } from "./SdCliIndexFileGenerator";
 
 export class SdCliWorkspace {
   private readonly _logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
@@ -35,6 +36,13 @@ export class SdCliWorkspace {
     this._logger.debug("패키지 목록 구성...");
     const pkgs = await this._getPackagesAsync(config);
 
+    this._logger.debug("패키지 인덱스 생성기 실행...");
+    await pkgs.parallelAsync(async (pkg) => {
+      if (pkg.config.type === "library" && pkg.config.autoIndex) {
+        await new SdCliIndexFileGenerator(pkg.rootPath, pkg.config.autoIndex).watchAsync();
+      }
+    });
+
     this._logger.debug("패키지 이벤트 설정...");
     let changeCount = 0;
     const totalResultMap = new Map<string, ISdCliPackageBuildResult[]>();
@@ -85,17 +93,23 @@ export class SdCliWorkspace {
     });
   }
 
+  private _isServerRestarting = false;
+
   private async _restartServerAsync(pkg: SdCliPackage): Promise<void> {
+    await Wait.until(() => !this._isServerRestarting);
+
+    this._isServerRestarting = true;
     const entryFileRelPath = pkg.main;
     if (entryFileRelPath === undefined) {
       this._logger.error(`서버패키지(${pkg.name})의 'package.json'에서 'main'필드를 찾을 수 없습니다.`);
+      this._isServerRestarting = false;
       return;
     }
     const entryFilePath = path.resolve(pkg.rootPath, entryFileRelPath);
 
     this._logger.log(`서버(${pkg.name}) 재시작...`);
     try {
-      const serverInfo = this._serverInfoMap.getOrCreate(pkg.name, { middlewares: [], clientInfos: [] });
+      const serverInfo = this._serverInfoMap.getOrCreate(path.basename(pkg.rootPath), { middlewares: [], clientInfos: [] });
       if (serverInfo.server) {
         await serverInfo.server.closeAsync();
         delete serverInfo.server;
@@ -104,6 +118,7 @@ export class SdCliWorkspace {
       serverInfo.server = (await import("file:///" + entryFilePath + "?update=" + Uuid.new().toString())).default as SdServiceServer | undefined;
       if (!serverInfo.server) {
         this._logger.error(`${entryFilePath}(0, 0): 'SdServiceServer'를 'export'해야 합니다.`);
+        this._isServerRestarting = false;
         return;
       }
       serverInfo.server.devMiddlewares = serverInfo.middlewares;
@@ -114,6 +129,8 @@ export class SdCliWorkspace {
     catch (err) {
       this._logger.error(`서버(${pkg.name}) 재시작중 오류 발생`, err);
     }
+
+    this._isServerRestarting = false;
   }
 
   public async buildAsync(opt: { confFileRelPath: string; optNames: string[] }): Promise<void> {
@@ -123,6 +140,13 @@ export class SdCliWorkspace {
     this._logger.debug("패키지 목록 구성...");
     const pkgs = await this._getPackagesAsync(config);
 
+    this._logger.debug("패키지 인덱스 생성기 실행...");
+    await pkgs.parallelAsync(async (pkg) => {
+      if (pkg.config.type === "library" && pkg.config.autoIndex) {
+        await new SdCliIndexFileGenerator(pkg.rootPath, pkg.config.autoIndex).runAsync();
+      }
+    });
+
     this._logger.debug("프로젝트 및 패키지 버전 설정...");
     await this._upgradeVersionAsync(pkgs);
 

package/src/packages/SdCliPackage.ts

@@ -1,8 +1,8 @@
 import { INpmConfig, ISdCliPackageBuildResult, ITsconfig, TSdCliPackageConfig } from "../commons";
 import path from "path";
-import { FsUtil, SdProcess } from "@simplysm/sd-core/node";
+import { FsUtil, SdProcess } from "@simplysm/sd-core-node";
 import { EventEmitter } from "events";
-import { ObjectUtil } from "@simplysm/sd-core/common";
+import { ObjectUtil } from "@simplysm/sd-core-common";
 import { SdCliTsLibBuilder } from "../builder/SdCliTsLibBuilder";
 import { SdCliJsLibBuilder } from "../builder/SdCliJsLibBuilder";
 import { SdCliServerBuilder } from "../builder/SdCliServerBuilder";
@@ -116,6 +116,8 @@ export class SdCliPackage extends EventEmitter {
     delete buildTsconfig.compilerOptions.baseUrl;
     delete buildTsconfig.compilerOptions.paths;
 
+    buildTsconfig.compilerOptions.declaration = Boolean(this._npmConfig.types);
+
     const buildTsconfigFilePath = path.resolve(this.rootPath, "tsconfig-build.json");
     await FsUtil.writeJsonAsync(buildTsconfigFilePath, buildTsconfig, { space: 2 });
   }

package/src/utils/SdCliConfigUtil.ts

@@ -1,6 +1,6 @@
 import { ISdCliConfig, TSdCliPackageConfig } from "../commons";
-import { FsUtil } from "@simplysm/sd-core/node";
-import { ObjectUtil } from "@simplysm/sd-core/common";
+import { FsUtil } from "@simplysm/sd-core-node";
+import { ObjectUtil } from "@simplysm/sd-core-common";
 import path from "path";
 
 export class SdCliConfigUtil {

package/tsconfig-build.json

@@ -4,6 +4,10 @@
     "lib": [
       "ES2020"
     ],
-    "outDir": "./dist"
-  }
+    "outDir": "./dist",
+    "declaration": false
+  },
+  "files": [
+    "./src/bin/sd-cli.ts"
+  ]
 }

package/tsconfig.json

@@ -7,12 +7,21 @@
     "outDir": "./dist",
     "baseUrl": ".",
     "paths": {
-      "@simplysm/sd-core/*": [
-        "../sd-core/src/*/index.ts"
+      "@simplysm/sd-core-common": [
+        "../sd-core-common/src/index.ts"
       ],
-      "@simplysm/sd-service/*": [
-        "../sd-service/src/*/index.ts"
+      "@simplysm/sd-core-node": [
+        "../sd-core-node/src/index.ts"
+      ],
+      "@simplysm/sd-service-common": [
+        "../sd-service-common/src/index.ts"
+      ],
+      "@simplysm/sd-service-server": [
+        "../sd-service-server/src/index.ts"
       ]
     }
-  }
+  },
+  "files": [
+    "./src/bin/sd-cli.ts"
+  ]
 }

package/dist/bin/sd-cli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node --experimental-specifier-resolution=node --experimental-import-meta-resolve
-export {};

package/dist/build-tool/SdCliCacheCompilerHost.d.ts

@@ -1,10 +0,0 @@
-import ts from "typescript";
-export declare class SdCliCacheCompilerHost {
-    static create(parsedTsconfig: ts.ParsedCommandLine, moduleResolutionCache: ts.ModuleResolutionCache, sourceFileCache: Map<string, IFileCache>, outputFileCache: Map<string, string>): ts.CompilerHost;
-}
-interface IFileCache {
-    exists?: boolean;
-    sourceFile?: ts.SourceFile;
-    content?: string;
-}
-export {};

package/dist/build-tool/SdCliNgCacheCompilerHost.d.ts

@@ -1,11 +0,0 @@
-import ts from "typescript";
-export declare class SdCliNgCacheCompilerHost {
-    static wrap(compilerHost: ts.CompilerHost, sourceFileCache: Map<string, IFileCache>): ts.CompilerHost;
-}
-interface IFileCache {
-    exists?: boolean;
-    sourceFile?: ts.SourceFile;
-    content?: string;
-    styleContent?: string;
-}
-export {};

package/dist/build-tool/SdCliPackageLinter.d.ts

@@ -1,8 +0,0 @@
-import { ISdCliPackageBuildResult } from "../commons";
-import ts from "typescript";
-export declare class SdCliPackageLinter {
-    private readonly _rootPath;
-    private readonly _lintResultCache;
-    constructor(_rootPath: string);
-    lintAsync(filePaths: string[], program?: ts.Program): Promise<ISdCliPackageBuildResult[]>;
-}

package/dist/builder/SdCliClientBuilder.d.ts

@@ -1,20 +0,0 @@
-/// <reference types="node" />
-import { ISdCliClientPackageConfig, ISdCliPackageBuildResult } from "../commons";
-import { EventEmitter } from "events";
-import { NextHandleFunction } from "connect";
-export declare class SdCliClientBuilder extends EventEmitter {
-    private readonly _rootPath;
-    private readonly _config;
-    private readonly _workspaceRootPath;
-    private readonly _logger;
-    private readonly _tsconfigFilePath;
-    private readonly _parsedTsconfig;
-    private readonly _npmConfigMap;
-    constructor(_rootPath: string, _config: ISdCliClientPackageConfig, _workspaceRootPath: string);
-    on(event: "change", listener: () => void): this;
-    on(event: "complete", listener: (results: ISdCliPackageBuildResult[]) => void): this;
-    watchAsync(): Promise<NextHandleFunction[]>;
-    buildAsync(): Promise<ISdCliPackageBuildResult[]>;
-    private _getWebpackConfig;
-    private _getNpmConfig;
-}

package/dist/builder/SdCliJsLibBuilder.d.ts

@@ -1,14 +0,0 @@
-/// <reference types="node" />
-import { ISdCliPackageBuildResult } from "../commons";
-import { EventEmitter } from "events";
-export declare class SdCliJsLibBuilder extends EventEmitter {
-    private readonly _rootPath;
-    private readonly _logger;
-    private readonly _linter;
-    constructor(_rootPath: string);
-    on(event: "change", listener: () => void): this;
-    on(event: "complete", listener: (results: ISdCliPackageBuildResult[]) => void): this;
-    watchAsync(): Promise<void>;
-    buildAsync(): Promise<ISdCliPackageBuildResult[]>;
-    private getRelatedPathsAsync;
-}

package/dist/builder/SdCliServerBuilder.d.ts

@@ -1,24 +0,0 @@
-/// <reference types="node" />
-import { ISdCliPackageBuildResult, ISdCliServerPackageConfig } from "../commons";
-import { EventEmitter } from "events";
-export declare class SdCliServerBuilder extends EventEmitter {
-    private readonly _rootPath;
-    private readonly _config;
-    private readonly _workspaceRootPath;
-    private readonly _logger;
-    private readonly _tsconfigFilePath;
-    private readonly _parsedTsconfig;
-    private readonly _npmConfigMap;
-    constructor(_rootPath: string, _config: ISdCliServerPackageConfig, _workspaceRootPath: string);
-    on(event: "change", listener: () => void): this;
-    on(event: "complete", listener: (results: ISdCliPackageBuildResult[]) => void): this;
-    watchAsync(): Promise<void>;
-    buildAsync(): Promise<ISdCliPackageBuildResult[]>;
-    private _writeDistConfigFileAsync;
-    private _writeDistPm2ConfigFileAsync;
-    private _writeDistIisConfigFileAsync;
-    private _writeDistNpmConfigFileAsync;
-    private _getWebpackConfig;
-    private _getExternalModuleNames;
-    private _getNpmConfig;
-}

package/dist/builder/SdCliTsLibBuilder.d.ts

@@ -1,29 +0,0 @@
-/// <reference types="node" />
-import { ISdCliPackageBuildResult } from "../commons";
-import { EventEmitter } from "events";
-export declare class SdCliTsLibBuilder extends EventEmitter {
-    private readonly _rootPath;
-    private readonly _logger;
-    private _moduleResolutionCache?;
-    private readonly _linter;
-    private readonly _fileCache;
-    private readonly _writeFileCache;
-    private _program?;
-    private _ngProgram?;
-    private _builder?;
-    private readonly _tsconfigFilePath;
-    private readonly _parsedTsconfig;
-    private readonly _npmConfig;
-    private readonly _isAngular;
-    constructor(_rootPath: string);
-    on(event: "change", listener: () => void): this;
-    on(event: "complete", listener: (results: ISdCliPackageBuildResult[]) => void): this;
-    watchAsync(): Promise<void>;
-    buildAsync(): Promise<ISdCliPackageBuildResult[]>;
-    private getAllRelatedPathsAsync;
-    private _runBuilderAsync;
-    private _createSdBuildPack;
-    private _createProgram;
-    private _configProgramSourceFileVersions;
-    private _createCacheCompilerHost;
-}