@simplysm/sd-cli 13.0.99 → 14.0.1

package/src/builders/BaseBuilder.ts

@@ -1,218 +0,0 @@
-import { consola } from "consola";
-import { WorkerManager } from "../infra/WorkerManager";
-import type { BuildResult, ResultCollector } from "../infra/ResultCollector";
-import type { RebuildManager } from "../utils/rebuild-manager";
-import type { BuildEventData, ErrorEventData } from "../utils/worker-events";
-import { formatBuildMessages } from "../utils/output-utils";
-import type { IBuilder, PackageInfo } from "./types";
-
-const baseBuilderLogger = consola.withTag("sd:cli:build");
-
-/**
- * Abstract base class for Builder
- *
- * Provides common logic for all Builders and
- * defines abstract methods that subclasses must implement.
- */
-export abstract class BaseBuilder implements IBuilder {
-  protected readonly workerManager: WorkerManager;
-  protected readonly resultCollector: ResultCollector;
-  protected readonly rebuildManager: RebuildManager | undefined;
-  protected readonly packages: PackageInfo[];
-  protected readonly cwd: string;
-  protected isWatchMode = false;
-
-  /** Initial build Promise (per package) */
-  protected readonly initialBuildPromises = new Map<string, Promise<void>>();
-  /** Initial build resolver (per package) */
-  protected readonly buildResolvers = new Map<string, () => void>();
-
-  constructor(options: {
-    cwd: string;
-    packages: PackageInfo[];
-    resultCollector: ResultCollector;
-    rebuildManager?: RebuildManager;
-  }) {
-    this.cwd = options.cwd;
-    this.packages = options.packages;
-    this.resultCollector = options.resultCollector;
-    this.rebuildManager = options.rebuildManager;
-    this.workerManager = new WorkerManager();
-  }
-
-  /**
-   * Initialize Builder
-   */
-  initialize(): Promise<void> {
-    // Create initial build Promises
-    for (const pkg of this.packages) {
-      const key = this.getPackageKey(pkg);
-      this.initialBuildPromises.set(
-        key,
-        new Promise<void>((resolve) => {
-          this.buildResolvers.set(key, resolve);
-        }),
-      );
-    }
-
-    // Create Workers
-    this.createWorkers();
-
-    // Register event handlers
-    this.registerEventHandlers();
-
-    return Promise.resolve();
-  }
-
-  /**
-   * One-time build (production)
-   */
-  async build(): Promise<void> {
-    await Promise.all(this.packages.map((pkg) => this.buildPackage(pkg)));
-  }
-
-  /**
-   * Start watch mode
-   */
-  async startWatch(): Promise<void> {
-    this.isWatchMode = true;
-
-    // Start watching all packages (without await - run in background)
-    for (const pkg of this.packages) {
-      this.startWatchPackage(pkg);
-    }
-
-    // Wait until initial build is complete
-    await Promise.all(this.initialBuildPromises.values());
-  }
-
-  /**
-   * Shutdown Builder
-   */
-  async shutdown(): Promise<void> {
-    await this.workerManager.terminateAll();
-  }
-
-  /**
-   * Get initial build Promise map
-   */
-  getInitialBuildPromises(): Map<string, Promise<void>> {
-    return this.initialBuildPromises;
-  }
-
-  /**
-   * Generate package key (for result storage)
-   */
-  protected getPackageKey(pkg: PackageInfo): string {
-    return `${pkg.name}:${this.getBuilderType()}`;
-  }
-
-  /**
-   * Handle build completion
-   */
-  protected completeBuild(pkg: PackageInfo): void {
-    const key = this.getPackageKey(pkg);
-    const resolver = this.buildResolvers.get(key);
-    if (resolver != null) {
-      resolver();
-      this.buildResolvers.delete(key);
-    }
-  }
-
-  /**
-   * Register common Worker event handlers (buildStart, build, error)
-   *
-   * Provides common logic so LibraryBuilder and DtsBuilder can register
-   * event handlers with the same pattern without duplication.
-   *
-   * @param workerKey Worker identifier (e.g., "core-common:build")
-   * @param resultType BuildResult type field value
-   * @param listrTitle Title to display during rebuild
-   */
-  protected registerEventHandlersForWorker(
-    pkg: PackageInfo,
-    workerKey: string,
-    resultType: BuildResult["type"],
-    listrTitle: string,
-  ): void {
-    const worker = this.workerManager.get(workerKey)!;
-
-    // Track if this is initial build
-    let isInitialBuild = true;
-
-    // Build start (during rebuild)
-    worker.on("buildStart", () => {
-      if (!isInitialBuild && this.rebuildManager != null) {
-        const resolver = this.rebuildManager.registerBuild(workerKey, listrTitle);
-        this.buildResolvers.set(workerKey, resolver);
-      }
-    });
-
-    // Build complete
-    worker.on("build", (data) => {
-      const event = data as BuildEventData;
-
-      // Output warnings
-      if (event.warnings != null && event.warnings.length > 0) {
-        baseBuilderLogger.warn(formatBuildMessages(pkg.name, pkg.config.target, event.warnings));
-      }
-
-      const result: BuildResult = {
-        name: pkg.name,
-        target: pkg.config.target,
-        type: resultType,
-        status: event.success ? "success" : "error",
-        message: event.errors?.join("\n"),
-      };
-      this.resultCollector.add(result);
-
-      if (isInitialBuild) {
-        isInitialBuild = false;
-      }
-      this.completeBuild(pkg);
-    });
-
-    // Error
-    worker.on("error", (data) => {
-      const event = data as ErrorEventData;
-      const result: BuildResult = {
-        name: pkg.name,
-        target: pkg.config.target,
-        type: resultType,
-        status: "error",
-        message: event.message,
-      };
-      this.resultCollector.add(result);
-
-      if (isInitialBuild) {
-        isInitialBuild = false;
-      }
-      this.completeBuild(pkg);
-    });
-  }
-
-  /**
-   * Builder type (for result key generation)
-   */
-  protected abstract getBuilderType(): string;
-
-  /**
-   * Create Workers
-   */
-  protected abstract createWorkers(): void;
-
-  /**
-   * Register event handlers
-   */
-  protected abstract registerEventHandlers(): void;
-
-  /**
-   * Single package build (production)
-   */
-  protected abstract buildPackage(pkg: PackageInfo): Promise<void>;
-
-  /**
-   * Start watching single package
-   */
-  protected abstract startWatchPackage(pkg: PackageInfo): void;
-}

package/src/builders/DtsBuilder.ts

@@ -1,92 +0,0 @@
-import type * as DtsWorkerModule from "../workers/dts.worker";
-import type { BuildResult } from "../infra/ResultCollector";
-import { err as errNs } from "@simplysm/core-common";
-import type { TypecheckEnv } from "../utils/tsconfig";
-import { BaseBuilder } from "./BaseBuilder";
-import type { PackageInfo } from "./types";
-
-/**
- * Builder responsible for generating .d.ts files
- *
- * Handles TypeScript declaration file generation for library packages.
- * Supports both watch mode and production builds.
- */
-export class DtsBuilder extends BaseBuilder {
-  private readonly _workerPath: string;
-
-  constructor(options: ConstructorParameters<typeof BaseBuilder>[0]) {
-    super(options);
-    this._workerPath = import.meta.resolve("../workers/dts.worker");
-  }
-
-  protected getBuilderType(): string {
-    return "dts";
-  }
-
-  /**
-   * Determine TypecheckEnv from package target
-   */
-  private _getEnv(pkg: PackageInfo): TypecheckEnv {
-    const target = pkg.config.target;
-    if (target === "node") return "node";
-    return "browser"; // browser, neutral, client all use browser environment
-  }
-
-  protected createWorkers(): void {
-    for (const pkg of this.packages) {
-      this.workerManager.create<typeof DtsWorkerModule>(`${pkg.name}:dts`, this._workerPath);
-    }
-  }
-
-  protected registerEventHandlers(): void {
-    for (const pkg of this.packages) {
-      const workerKey = `${pkg.name}:dts`;
-      const listrTitle = `${pkg.name} (dts)`;
-      this.registerEventHandlersForWorker(pkg, workerKey, "dts", listrTitle);
-    }
-  }
-
-  protected async buildPackage(pkg: PackageInfo): Promise<void> {
-    const worker = this.workerManager.get<typeof DtsWorkerModule>(`${pkg.name}:dts`)!;
-
-    const buildPromise = new Promise<void>((resolve) => {
-      const originalResolver = this.buildResolvers.get(`${pkg.name}:dts`);
-      this.buildResolvers.set(`${pkg.name}:dts`, () => {
-        originalResolver?.();
-        resolve();
-      });
-    });
-
-    void worker.startWatch({
-      name: pkg.name,
-      cwd: this.cwd,
-      pkgDir: pkg.dir,
-      env: this._getEnv(pkg),
-    });
-
-    await buildPromise;
-  }
-
-  protected startWatchPackage(pkg: PackageInfo): void {
-    const worker = this.workerManager.get<typeof DtsWorkerModule>(`${pkg.name}:dts`)!;
-
-    worker
-      .startWatch({
-        name: pkg.name,
-        cwd: this.cwd,
-        pkgDir: pkg.dir,
-        env: this._getEnv(pkg),
-      })
-      .catch((err: unknown) => {
-        const result: BuildResult = {
-          name: pkg.name,
-          target: pkg.config.target,
-          type: "dts",
-          status: "error",
-          message: errNs.message(err),
-        };
-        this.resultCollector.add(result);
-        this.completeBuild(pkg);
-      });
-  }
-}

package/src/builders/LibraryBuilder.ts

@@ -1,110 +0,0 @@
-import type * as LibraryWorkerModule from "../workers/library.worker";
-import type { BuildResult } from "../infra/ResultCollector";
-import { err as errNs } from "@simplysm/core-common";
-import { BaseBuilder } from "./BaseBuilder";
-import type { BuildPackageInfo } from "./types";
-
-/**
- * Builder responsible for Library package builds
- *
- * Handles esbuild compilation for node/browser/neutral target packages.
- * Supports both watch mode and production builds.
- */
-export class LibraryBuilder extends BaseBuilder {
-  private readonly _workerPath: string;
-
-  constructor(options: ConstructorParameters<typeof BaseBuilder>[0]) {
-    super(options);
-    this._workerPath = import.meta.resolve("../workers/library.worker");
-  }
-
-  protected getBuilderType(): string {
-    return "build";
-  }
-
-  protected createWorkers(): void {
-    for (const pkg of this.packages) {
-      this.workerManager.create<typeof LibraryWorkerModule>(`${pkg.name}:build`, this._workerPath);
-    }
-  }
-
-  protected registerEventHandlers(): void {
-    for (const pkg of this.packages) {
-      const workerKey = `${pkg.name}:build`;
-      const listrTitle = `${pkg.name} (${pkg.config.target})`;
-      this.registerEventHandlersForWorker(pkg, workerKey, "build", listrTitle);
-    }
-  }
-
-  protected async buildPackage(pkg: BuildPackageInfo): Promise<void> {
-    const worker = this.workerManager.get<typeof LibraryWorkerModule>(`${pkg.name}:build`)!;
-
-    // Create build completion Promise
-    const buildPromise = new Promise<void>((resolve) => {
-      const originalResolver = this.buildResolvers.get(`${pkg.name}:build`);
-      this.buildResolvers.set(`${pkg.name}:build`, () => {
-        originalResolver?.();
-        resolve();
-      });
-    });
-
-    // Start build (without await - completion detected via events)
-    void worker.startWatch({
-      name: pkg.name,
-      config: pkg.config,
-      cwd: this.cwd,
-      pkgDir: pkg.dir,
-    });
-
-    await buildPromise;
-  }
-
-  protected startWatchPackage(pkg: BuildPackageInfo): void {
-    const worker = this.workerManager.get<typeof LibraryWorkerModule>(`${pkg.name}:build`)!;
-
-    worker
-      .startWatch({
-        name: pkg.name,
-        config: pkg.config,
-        cwd: this.cwd,
-        pkgDir: pkg.dir,
-      })
-      .catch((err: unknown) => {
-        const result: BuildResult = {
-          name: pkg.name,
-          target: pkg.config.target,
-          type: "build",
-          status: "error",
-          message: errNs.message(err),
-        };
-        this.resultCollector.add(result);
-        this.completeBuild(pkg);
-      });
-  }
-
-  /**
-   * Graceful shutdown (esbuild context dispose)
-   */
-  override async shutdown(): Promise<void> {
-    const shutdownTimeout = 3000;
-
-    // Call stopWatch method on each Worker, then terminate
-    await Promise.all(
-      this.workerManager.ids.map(async (id) => {
-        const worker = this.workerManager.get<typeof LibraryWorkerModule>(id);
-        if (worker != null) {
-          try {
-            await Promise.race([
-              worker.stopWatch(),
-              new Promise<void>((resolve) => setTimeout(resolve, shutdownTimeout)),
-            ]);
-          } catch {
-            // Continue even if stopWatch fails
-          }
-        }
-      }),
-    );
-
-    await super.shutdown();
-  }
-}

package/src/builders/types.ts

@@ -1,60 +0,0 @@
-import type { SdBuildPackageConfig, SdPackageConfig } from "../sd-config.types";
-import type { ResultCollector } from "../infra/ResultCollector";
-import type { RebuildManager } from "../utils/rebuild-manager";
-
-/**
- * Package information
- */
-export interface PackageInfo {
-  name: string;
-  dir: string;
-  config: SdPackageConfig;
-}
-
-/**
- * PackageInfo narrowed for build packages (node/browser/neutral)
- */
-export type BuildPackageInfo = PackageInfo & { config: SdBuildPackageConfig };
-
-/**
- * Common Builder options
- */
-export interface BuilderOptions {
-  cwd: string;
-  packages: PackageInfo[];
-  resultCollector: ResultCollector;
-  rebuildManager?: RebuildManager;
-}
-
-/**
- * Builder interface
- *
- * Common interface that all Builders must implement
- */
-export interface IBuilder {
-  /**
-   * Initialize Builder (create Workers, register event handlers)
-   */
-  initialize(): Promise<void>;
-
-  /**
-   * One-time build (for production builds)
-   */
-  build(): Promise<void>;
-
-  /**
-   * Start watch mode
-   * Promise resolves when initial build is complete
-   */
-  startWatch(): Promise<void>;
-
-  /**
-   * Shutdown Builder (clean up Workers)
-   */
-  shutdown(): Promise<void>;
-
-  /**
-   * Get initial build Promise map (for Listr tasks)
-   */
-  getInitialBuildPromises(): Map<string, Promise<void>>;
-}