@simplysm/sd-cli 14.0.29 → 14.0.32

package/src/esbuild/esbuild-client-config.ts

@@ -0,0 +1,230 @@
+import path from "path";
+import fs from "fs";
+import esbuild from "esbuild";
+import browserslistToEsbuild from "browserslist-to-esbuild";
+import {
+  createCompilerPlugin,
+  SourceFileCache,
+  type CompilerPluginOptions,
+  type BundleStylesheetOptions,
+} from "@angular/build/private";
+import { createScssPlugin } from "./esbuild-scss-plugin";
+
+export interface CreateClientEsbuildOptions {
+  /** 패키지 디렉토리 경로 */
+  pkgDir: string;
+  /** 모노레포 루트 (workspaceRoot) */
+  cwd: string;
+  /** 빌드 모드 */
+  mode: "dev" | "build";
+  /** tsconfig 경로 (기본: pkgDir/tsconfig.json) */
+  tsconfig?: string;
+  /** 빌드 시 치환할 환경변수 */
+  env?: Record<string, string>;
+  /** 추가 esbuild 플러그인 (Feature 1.1b에서 사용) */
+  plugins?: esbuild.Plugin[];
+  /** HMR용 templateUpdates Map (Feature 2.2에서 사용) */
+  templateUpdates?: Map<string, string>;
+  /** watch 모드 빌드 완료 콜백 */
+  onEnd?: (result: esbuild.BuildResult) => void | Promise<void>;
+  /** PostCSS 플러그인 ([name, options] 튜플 배열) */
+  postcssPlugins?: [string, (object | string)?][];
+  /** PostCSS 설정 기준 경로 */
+  postcssConfigPath?: string;
+  /** 빌드 출력 경로 (기본: pkgDir/dist) */
+  outdir?: string;
+  /** browserslist 쿼리. 미설정 시 "es2022" 기본값 */
+  browserslist?: string | string[];
+  /** polyfills 경로 (pkgDir 기준 상대경로, 예: ["src/polyfills.ts"]). entryPoints에 추가됨 */
+  polyfills?: string[];
+  /** 레거시 모듈 지원 (코드 분할 비활성화 + import.meta 치환 + 잔여 import() 제거) */
+  legacyModule?: boolean;
+}
+
+export interface ClientEsbuildResult {
+  context: esbuild.BuildContext;
+  sourceFileCache: InstanceType<typeof SourceFileCache>;
+}
+
+export async function createClientEsbuildContext(
+  options: CreateClientEsbuildOptions,
+): Promise<ClientEsbuildResult> {
+  const isDev = options.mode === "dev";
+
+  // browserslist → esbuild target 변환
+  let esbuildTarget: string[] = ["es2022"];
+  if (options.browserslist != null) {
+    const queries = Array.isArray(options.browserslist)
+      ? options.browserslist
+      : [options.browserslist];
+    esbuildTarget = browserslistToEsbuild(queries);
+  }
+
+  // SourceFileCache 생성 (LMDB 디스크 캐시)
+  const cachePath = path.join(options.pkgDir, ".angular", "cache");
+  const sourceFileCache = new SourceFileCache(cachePath);
+
+  // CompilerPluginOptions
+  const pluginOptions: CompilerPluginOptions & { browserOnlyBuild?: boolean } = {
+    tsconfig: options.tsconfig ?? path.join(options.pkgDir, "tsconfig.json"),
+    sourcemap: isDev,
+    advancedOptimizations: !isDev,
+    thirdPartySourcemaps: isDev,
+    incremental: true,
+    sourceFileCache,
+    loadResultCache: sourceFileCache.loadResultCache,
+    templateUpdates: options.templateUpdates,
+    browserOnlyBuild: true,
+  };
+
+  // BundleStylesheetOptions
+  const styleOptions: BundleStylesheetOptions & { inlineStyleLanguage: string } = {
+    workspaceRoot: options.cwd,
+    optimization: !isDev,
+    inlineFonts: false,
+    sourcemap: isDev ? "linked" : false,
+    outputNames: { bundles: "[name]", media: "media/[name]" },
+    includePaths: [],
+    target: esbuildTarget,
+    cacheOptions: {
+      enabled: true,
+      path: cachePath,
+      basePath: cachePath,
+    },
+    postcssConfiguration:
+      options.postcssPlugins != null
+        ? {
+            config: { plugins: options.postcssPlugins },
+            configPath: options.postcssConfigPath ?? options.pkgDir,
+          }
+        : undefined,
+    inlineStyleLanguage: "scss",
+  };
+
+  const angularPlugin = createCompilerPlugin(pluginOptions, styleOptions);
+
+  // SCSS side-effect import 처리 플러그인
+  const scssPlugin = createScssPlugin({
+    loadPaths: [
+      path.join(options.pkgDir, "scss"),
+      path.join(options.cwd, "node_modules"),
+    ],
+  });
+
+  // define 주입
+  const define: Record<string, string> = {};
+
+  // Angular 플래그
+  if (!isDev) {
+    define["ngDevMode"] = "false";
+  }
+  define["ngJitMode"] = "false";
+  if (isDev && options.templateUpdates != null && options.legacyModule !== true) {
+    define["ngHmrMode"] = "true";
+  } else if (!isDev) {
+    define["ngHmrMode"] = "false";
+  }
+
+  // 커스텀 env
+  if (options.env != null) {
+    for (const [key, value] of Object.entries(options.env)) {
+      define[`import.meta.env.${key}`] = JSON.stringify(value);
+    }
+  }
+
+  // import.meta.hot 폴리필 banner (Angular HMR 런타임용)
+  // Angular의 compileHmrInitializer가 import.meta.hot.on('angular:component-update', ...)을 사용.
+  // Vite 없이 동작하도록 import.meta.hot을 폴리필하고, globalThis.__hmr_dispatch로 외부 트리거 제공.
+  const hmrBanner =
+    options.templateUpdates != null && options.legacyModule !== true
+      ? [
+          'if(typeof ngHmrMode!=="undefined"&&ngHmrMode){(function(){',
+          "var _l={};",
+          "import.meta.hot={on:function(e,c){if(!_l[e])_l[e]=[];_l[e].push(c);},off:function(e,c){var a=_l[e];if(a){var i=a.indexOf(c);if(i!==-1)a.splice(i,1);}}};",
+          "globalThis.__hmr_dispatch=function(e,d){var a=_l[e];if(a)for(var i=0;i<a.length;i++)a[i](d);};",
+          "})()}",
+        ].join("")
+      : undefined;
+
+  // esbuild context 생성
+  const context = await esbuild.context({
+    entryPoints: [
+      path.join(options.pkgDir, "src", "main.ts"),
+      ...(options.polyfills != null
+        ? options.polyfills.map((p) => path.join(options.pkgDir, p))
+        : []),
+    ],
+    target: esbuildTarget,
+    entryNames: isDev ? "[name]" : "[name]-[hash]",
+    chunkNames: isDev ? "[name]" : "[name]-[hash]",
+    assetNames: isDev ? "[name]" : "[name]-[hash]",
+    bundle: true,
+    splitting: options.legacyModule !== true,
+    format: "esm",
+    platform: "browser",
+    outdir: options.outdir ?? path.join(options.pkgDir, "dist"),
+    metafile: true,
+    write: true,
+    sourcemap: isDev ? "linked" : false,
+    logLevel: "silent",
+    tsconfig: options.tsconfig ?? path.join(options.pkgDir, "tsconfig.json"),
+    define,
+    banner: hmrBanner != null ? { js: hmrBanner } : undefined,
+    ...(options.legacyModule === true ? { supported: { "import-meta": false } } : {}),
+    plugins: [
+      ...(options.templateUpdates != null
+        ? [
+            {
+              name: "sd-hmr-reset",
+              setup(build: esbuild.PluginBuild) {
+                build.onStart(() => {
+                  options.templateUpdates!.clear();
+                });
+              },
+            },
+          ]
+        : []),
+      angularPlugin,
+      scssPlugin,
+      ...(options.plugins ?? []),
+      ...(options.legacyModule === true
+        ? [
+            {
+              name: "sd-legacy-strip-dynamic-import",
+              setup(build: esbuild.PluginBuild) {
+                build.onEnd(async (result) => {
+                  if (result.metafile == null) return;
+                  const jsFiles = Object.keys(result.metafile.outputs).filter((f) =>
+                    f.endsWith(".js"),
+                  );
+                  for (const file of jsFiles) {
+                    const code = await fs.promises.readFile(file, "utf-8");
+                    if (!code.includes("import(")) continue;
+                    const replaced = code.replace(
+                      /\bimport\s*\(/g,
+                      '(function(){return Promise.reject(new Error("Dynamic import not supported"))})(',
+                    );
+                    await fs.promises.writeFile(file, replaced);
+                  }
+                });
+              },
+            },
+          ]
+        : []),
+      ...(options.onEnd != null
+        ? [
+            {
+              name: "sd-on-end",
+              setup(build: esbuild.PluginBuild) {
+                build.onEnd((result) => {
+                  return options.onEnd!(result);
+                });
+              },
+            },
+          ]
+        : []),
+    ],
+  });
+
+  return { context, sourceFileCache };
+}

package/src/{utils → esbuild}/esbuild-config.ts

@@ -85,6 +85,7 @@ export function createServerEsbuildOptions(options: ServerEsbuildOptions): esbui
     outdir: path.join(options.pkgDir, "dist"),
     format: "esm",
     minify: options.dev !== true,
+    sourcemap: options.dev === true ? "linked" : undefined,
     platform: "node",
     target: "node20",
     bundle: true,

package/src/esbuild/esbuild-index-html.ts

@@ -0,0 +1,119 @@
+import type esbuild from "esbuild";
+import {
+  IndexHtmlGenerator,
+  type IndexHtmlTransform,
+} from "@angular/build/private";
+import path from "path";
+
+/** metafile.outputs에서 추출된 파일 정보 (IndexHtmlGenerator.FileInfo 호환) */
+export interface FileInfo {
+  file: string;
+  name?: string;
+  extension: string;
+}
+
+export interface GenerateIndexHtmlOptions {
+  /** src/index.html 경로 */
+  indexPath: string;
+  /** esbuild 빌드 결과 metafile */
+  metafile: esbuild.Metafile;
+  /** 출력 디렉토리 (dist/) */
+  outdir: string;
+  /** <base href> (기본: "/") */
+  baseHref?: string;
+  /** 빌드 모드 */
+  mode: "dev" | "build";
+  /** entryPoints의 이름 목록 (main, polyfills 등) */
+  entryNames: string[];
+  /** HTML 후처리 훅 (HMR 스크립트 주입용) */
+  postTransform?: IndexHtmlTransform;
+}
+
+export interface GenerateIndexHtmlResult {
+  content: string;
+  warnings: string[];
+  errors: string[];
+}
+
+/**
+ * esbuild metafile.outputs에서 JS/CSS 파일을 추출하여 FileInfo[] 로 변환한다.
+ */
+export function extractFilesFromMetafile(
+  metafile: esbuild.Metafile,
+  outdir: string,
+): FileInfo[] {
+  const files: FileInfo[] = [];
+  const normalizedOutdir = outdir.replace(/\\/g, "/");
+
+  // cssBundle → entry name 매핑 (JS entry의 cssBundle로 CSS에 name 전파)
+  const cssBundleToName = new Map<string, string>();
+  for (const output of Object.values(metafile.outputs)) {
+    if (output.entryPoint != null && output.cssBundle != null) {
+      const name = path.basename(output.entryPoint, path.extname(output.entryPoint));
+      cssBundleToName.set(output.cssBundle.replace(/\\/g, "/"), name);
+    }
+  }
+
+  for (const [outputPath, output] of Object.entries(metafile.outputs)) {
+    const normalizedPath = outputPath.replace(/\\/g, "/");
+    const ext = path.extname(normalizedPath);
+
+    if (ext !== ".js" && ext !== ".css") {
+      continue;
+    }
+
+    const relativePath = normalizedPath.startsWith(normalizedOutdir)
+      ? normalizedPath.slice(normalizedOutdir.length).replace(/^\//, "")
+      : path.relative(normalizedOutdir, normalizedPath).replace(/\\/g, "/");
+
+    const fileInfo: FileInfo = {
+      file: relativePath,
+      extension: ext,
+    };
+
+    if (output.entryPoint != null) {
+      fileInfo.name = path.basename(output.entryPoint, path.extname(output.entryPoint));
+    } else if (ext === ".css") {
+      const cssName = cssBundleToName.get(normalizedPath);
+      if (cssName != null) {
+        fileInfo.name = cssName;
+      }
+    }
+
+    files.push(fileInfo);
+  }
+
+  return files;
+}
+
+/**
+ * esbuild 빌드 결과를 기반으로 index.html을 생성한다.
+ * IndexHtmlGenerator(@angular/build/private)를 활용하여 script/link 태그를 자동 주입한다.
+ */
+export async function generateIndexHtml(
+  options: GenerateIndexHtmlOptions,
+): Promise<GenerateIndexHtmlResult> {
+  const files = extractFilesFromMetafile(options.metafile, options.outdir);
+
+  const entrypoints: [string, boolean][] = options.entryNames.map((name) => [name, true]);
+
+  const generator = new IndexHtmlGenerator({
+    indexPath: options.indexPath,
+    entrypoints,
+    sri: options.mode === "build",
+    postTransform: options.postTransform,
+  });
+
+  const result = await generator.process({
+    lang: undefined,
+    baseHref: options.baseHref,
+    outputPath: options.outdir,
+    files,
+  });
+
+  return {
+    content: result.csrContent,
+    warnings: result.warnings,
+    errors: result.errors,
+  };
+}

package/src/esbuild/esbuild-pwa.ts

@@ -0,0 +1,139 @@
+import type { IndexHtmlTransform } from "@angular/build/private";
+import type { SdPwaConfig } from "../sd-config.types.js";
+import { augmentAppWithServiceWorker } from "@angular/build/private";
+import { generatePwaIcons } from "../utils/generate-pwa-icons.js";
+import fs from "node:fs";
+import path from "path";
+
+export interface ApplyPwaOptions {
+  /** 패키지 디렉토리 경로 */
+  pkgDir: string;
+  /** 패키지 표시명 */
+  pkgName: string;
+  /** 모노레포 루트 (workspaceRoot) */
+  cwd: string;
+  /** 빌드 출력 디렉토리 (dist/) */
+  outdir: string;
+  /** base href (기본: "/") */
+  baseHref: string;
+  /** 빌드 모드 */
+  mode: "dev" | "build";
+  /** PWA 설정. false이면 비활성화 */
+  pwa?: false | SdPwaConfig;
+}
+
+export function createPwaHtmlTransform(): IndexHtmlTransform {
+  return (content: string) => {
+    const manifestLink = '<link rel="manifest" href="manifest.webmanifest">';
+    const registrationScript = `<script>${generateRegistrationScript()}</script>`;
+
+    content = content.replace("</head>", `${manifestLink}\n</head>`);
+    content = content.replace("</body>", `${registrationScript}\n</body>`);
+
+    return Promise.resolve(content);
+  };
+}
+
+export async function applyPwa(options: ApplyPwaOptions): Promise<void> {
+  if (options.mode !== "build") return;
+  if (options.pwa === false) return;
+
+  const pwaConfig = options.pwa ?? {};
+
+  // 1. Icons
+  let iconsField: Record<string, unknown> = {};
+  if (pwaConfig.manifest?.icons != null) {
+    iconsField = { icons: pwaConfig.manifest.icons };
+  } else {
+    const generated = await generatePwaIcons(options.pkgDir);
+    if (generated.length > 0) {
+      // Copy generated icons from public/icons/ to dist/icons/
+      const srcIconsDir = path.join(options.pkgDir, "public", "icons");
+      const dstIconsDir = path.join(options.outdir, "icons");
+      fs.mkdirSync(dstIconsDir, { recursive: true });
+      for (const icon of generated) {
+        const srcPath = path.join(srcIconsDir, path.basename(icon.src));
+        const dstPath = path.join(dstIconsDir, path.basename(icon.src));
+        fs.copyFileSync(srcPath, dstPath);
+      }
+      iconsField = { icons: generated };
+    }
+  }
+
+  // 2. Manifest
+  const manifest = {
+    name: pwaConfig.manifest?.name ?? options.pkgName,
+    short_name: pwaConfig.manifest?.short_name ?? options.pkgName,
+    display: pwaConfig.manifest?.display ?? "standalone",
+    theme_color: pwaConfig.manifest?.theme_color ?? "#ffffff",
+    background_color: pwaConfig.manifest?.background_color ?? "#ffffff",
+    start_url: ".",
+    scope: ".",
+    ...iconsField,
+  };
+
+  fs.writeFileSync(
+    path.join(options.outdir, "manifest.webmanifest"),
+    JSON.stringify(manifest, null, 2),
+  );
+
+  // 3. Ensure ngsw-config.json exists
+  const ngswConfigPath = path.join(options.pkgDir, "ngsw-config.json");
+  if (!fs.existsSync(ngswConfigPath)) {
+    const defaultConfig = {
+      $schema: "./node_modules/@angular/service-worker/config/schema.json",
+      index: "/index.html",
+      assetGroups: [
+        {
+          name: "app",
+          installMode: "prefetch",
+          resources: {
+            files: ["/*.html", "/*.css", "/*.js"],
+          },
+        },
+        {
+          name: "assets",
+          installMode: "lazy",
+          updateMode: "prefetch",
+          resources: {
+            files: ["/**/*.{png,jpg,svg,ico,woff2,webmanifest}"],
+          },
+        },
+      ],
+    };
+    fs.writeFileSync(ngswConfigPath, JSON.stringify(defaultConfig, null, 2) + "\n");
+  }
+
+  // 4. augmentAppWithServiceWorker
+  await augmentAppWithServiceWorker(
+    options.pkgDir,
+    options.cwd,
+    options.outdir,
+    options.baseHref,
+  );
+}
+
+function generateRegistrationScript(): string {
+  return `(function(){
+  if(!("serviceWorker" in navigator))return;
+  navigator.serviceWorker.register("ngsw-worker.js").then(function(reg){
+    if(reg.waiting){d(reg.waiting);return}
+    reg.addEventListener("updatefound",function(){
+      var w=reg.installing;
+      if(!w)return;
+      w.addEventListener("statechange",function(){
+        if(w.state==="installed"&&navigator.serviceWorker.controller)d(w);
+      });
+    });
+  });
+  var r=false;
+  navigator.serviceWorker.addEventListener("controllerchange",function(){
+    if(!r){r=true;window.location.reload()}
+  });
+  function d(w){
+    window.dispatchEvent(new CustomEvent("sd-pwa-update-ready",{
+      detail:{update:function(){w.postMessage({type:"SKIP_WAITING"})}}
+    }));
+  }
+})();`;
+}

package/src/esbuild/esbuild-scss-plugin.ts

@@ -0,0 +1,48 @@
+import type esbuild from "esbuild";
+import { fileURLToPath } from "url";
+import { compileScssFileAsync } from "../angular/scss-compiler";
+
+export interface CreateScssPluginOptions {
+  loadPaths: string[];
+}
+
+export function createScssPlugin(options: CreateScssPluginOptions): esbuild.Plugin {
+  return {
+    name: "sd-scss",
+    setup(build) {
+      build.onLoad({ filter: /\.scss$/ }, async (args) => {
+        try {
+          const result = await compileScssFileAsync(args.path, options.loadPaths);
+          return {
+            contents: result.css,
+            loader: "css" as const,
+            watchFiles: result.dependencies,
+          };
+        } catch (e: unknown) {
+          // sass.Exception은 span 프로퍼티로 위치 정보를 제공한다
+          const sassSpan = (e as any)?.span;
+          const location: esbuild.PartialMessage["location"] =
+            sassSpan != null
+              ? {
+                  file:
+                    sassSpan.url != null
+                      ? fileURLToPath(sassSpan.url)
+                      : args.path,
+                  line: sassSpan.start.line + 1, // sass: 0-based → esbuild: 1-based
+                  column: sassSpan.start.column,
+                }
+              : undefined;
+
+          return {
+            errors: [
+              {
+                text: (e as any)?.sassMessage ?? (e instanceof Error ? e.message : String(e)),
+                location,
+              },
+            ],
+          };
+        }
+      });
+    },
+  };
+}

package/src/orchestrators/BaseOrchestrator.ts

@@ -0,0 +1,118 @@
+import { consola, type ConsolaInstance } from "consola";
+import type { SdConfig } from "../sd-config.types";
+import { loadSdConfig } from "../utils/sd-config";
+import { getVersion } from "../utils/build-env";
+import { buildPathMapFromConfig, validateTargets } from "../utils/package-utils";
+import { watchReplaceDeps, type WatchReplaceDepResult } from "../deps/replace-deps/replace-deps";
+import { RebuildManager } from "../runtime/rebuild-manager";
+import { ResultCollector } from "../runtime/ResultCollector";
+import { SignalHandler } from "../runtime/SignalHandler";
+/**
+ * Orchestrator 공통 기반 클래스
+ *
+ * sd.config.ts 로드, pathMap 구축, 대상 검증, replaceDeps 감시,
+ * 런타임(SignalHandler, ResultCollector, RebuildManager) 초기화를 수행한다.
+ *
+ * 서브클래스(WatchOrchestrator, DevOrchestrator)가 OrchestratorLifecycle을 implements한다.
+ * BaseOrchestrator.initialize()는 params를 받으므로 인터페이스와 직접 호환되지 않으며,
+ * 서브클래스가 parameterless override를 제공한다.
+ */
+export abstract class BaseOrchestrator {
+  protected readonly _cwd: string;
+  protected readonly _logger: ConsolaInstance;
+
+  // 런타임
+  protected _resultCollector!: ResultCollector;
+  protected _signalHandler!: SignalHandler;
+  protected _rebuildManager!: RebuildManager;
+
+  // 공통 상태
+  protected _pathMap = new Map<string, string>();
+  protected _baseEnv!: { VER: string; DEV: string };
+  protected _replaceDeps: Record<string, string> | undefined;
+  protected _replaceDepWatcher: WatchReplaceDepResult | undefined;
+  protected _hasPackages = false;
+
+  constructor(logTag: string) {
+    this._cwd = process.cwd();
+    this._logger = consola.withTag(logTag);
+  }
+
+  async initialize(params: {
+    targets: string[];
+    options: string[];
+    dev: boolean;
+  }): Promise<void> {
+    this._logger.debug(`시작`, { targets: params.targets });
+
+    // 1. sd.config.ts 로드
+    let sdConfig: SdConfig;
+    try {
+      sdConfig = await loadSdConfig({
+        cwd: this._cwd,
+        dev: params.dev,
+        opt: params.options,
+      });
+      this._logger.debug("sd.config.ts 로드 완료");
+    } catch (err) {
+      this._logger.error(`sd.config.ts 로드 실패: ${err instanceof Error ? err.message : err}`);
+      process.exitCode = 1;
+      throw err;
+    }
+
+    // 2. pathMap 구축
+    this._pathMap = buildPathMapFromConfig(sdConfig.packages);
+
+    // 3. 대상 유효성 검사
+    validateTargets(params.targets, sdConfig.packages);
+
+    // 4. 환경변수 준비 (VER, DEV)
+    const version = await getVersion(this._cwd);
+    this._baseEnv = { VER: version, DEV: params.dev ? "true" : "false" };
+
+    // 5. replaceDeps 저장 + watch 시작
+    this._replaceDeps = sdConfig.replaceDeps;
+    if (sdConfig.replaceDeps != null) {
+      this._replaceDepWatcher = await watchReplaceDeps(this._cwd, sdConfig.replaceDeps);
+    }
+
+    // 6. 서브클래스 초기화 (패키지 분류, 엔진 생성 등)
+    await this._initializeMode(sdConfig, params.targets);
+
+    // 7. 패키지 유무 확인 후 런타임 초기화
+    if (!this._hasPackages) return;
+    this._signalHandler = new SignalHandler();
+    this._resultCollector = new ResultCollector();
+    this._rebuildManager = new RebuildManager(this._logger);
+
+    // 8. 런타임 의존 초기화 (엔진 생성 등)
+    await this._initializeEngines(sdConfig);
+  }
+
+  abstract start(): Promise<void>;
+
+  async awaitTermination(): Promise<void> {
+    if (!this._hasPackages) return;
+    await this._signalHandler.waitForTermination();
+  }
+
+  async shutdown(): Promise<void> {
+    // replaceDepWatcher는 항상 정리 (initialize 부분 실패 대응)
+    this._replaceDepWatcher?.dispose();
+    this._replaceDepWatcher = undefined;
+
+    if (!this._hasPackages) return;
+    process.stdout.write("⏳ 종료 중...\n");
+    await this._shutdownMode();
+    process.stdout.write("✔ 종료 완료\n");
+  }
+
+  protected abstract _initializeMode(
+    config: SdConfig,
+    targets: string[],
+  ): Promise<void> | void;
+
+  protected abstract _initializeEngines(config: SdConfig): Promise<void> | void;
+
+  protected abstract _shutdownMode(): Promise<void>;
+}