@chidchanun/bcp 0.1.0

package/packages/bundler/src/incremental-context.ts

@@ -0,0 +1,206 @@
+import * as esbuild from "esbuild";
+
+import {
+  performance,
+} from "node:perf_hooks";
+
+/**
+ * Configuration for a long-lived esbuild context.
+ *
+ * The context is intended for development builds where the same
+ * dependency graph is rebuilt multiple times.
+ */
+export interface IncrementalContextOptions
+  extends esbuild.BuildOptions {
+  /**
+   * Absolute application/project root used for path resolution.
+   */
+  projectRoot: string;
+}
+
+/**
+ * Small wrapper around esbuild.context().
+ *
+ * It keeps one esbuild context alive and exposes rebuild()/dispose()
+ * methods for a development server.
+ */
+export class IncrementalBuildContext {
+  private readonly projectRoot: string;
+
+  private readonly options: esbuild.BuildOptions;
+
+  private context: esbuild.BuildContext | null = null;
+
+  private lastResult:
+    esbuild.BuildResult | null = null;
+
+  /**
+   * Rebuild calls are serialized so two file-system events cannot
+   * mutate the same esbuild context concurrently.
+   */
+  private rebuildQueue:
+    Promise<esbuild.BuildResult> =
+      Promise.reject(
+        new Error("No rebuild has been scheduled yet.")
+      );
+
+  private constructor(
+    options: IncrementalContextOptions
+  ) {
+    const {
+      projectRoot,
+      ...buildOptions
+    } = options;
+
+    this.projectRoot = projectRoot;
+
+    this.options = {
+      ...buildOptions,
+
+      absWorkingDir:
+        projectRoot,
+
+      /**
+       * The module graph needs build metadata.
+       */
+      metafile: true,
+    };
+  }
+
+  /**
+   * Create and initialize a persistent esbuild context.
+   */
+  static async create(
+    options: IncrementalContextOptions
+  ): Promise<IncrementalBuildContext> {
+    const instance =
+      new IncrementalBuildContext(
+        options
+      );
+
+    await instance.initialize();
+
+    return instance;
+  }
+
+  /**
+   * Initializes the underlying esbuild context and performs the
+   * first build.
+   */
+  private async initialize(): Promise<esbuild.BuildResult> {
+    if (this.context) {
+      return this.rebuild();
+    }
+
+    const startedAt =
+      performance.now();
+
+    this.context =
+      await esbuild.context(
+        this.options
+      );
+
+    const result =
+      await this.rebuild();
+
+    const duration =
+      performance.now() -
+      startedAt;
+
+    console.log(
+      `[BCP] Initial incremental build: ${duration.toFixed(2)}ms`,
+    );
+
+    return result;
+  }
+
+  /**
+   * Incrementally rebuilds the same context.
+   *
+   * esbuild can reuse information from the previous build when the
+   * context is kept alive.
+   */
+  async rebuild(): Promise<esbuild.BuildResult> {
+    const previous =
+      this.rebuildQueue.catch(() =>
+        undefined,
+      );
+
+    const next =
+      previous.then(async () => {
+        if (!this.context) {
+          throw new Error(
+            "IncrementalBuildContext is not initialized.",
+          );
+        }
+
+        const startedAt =
+          performance.now();
+
+        const result =
+          await this.context.rebuild();
+
+        this.lastResult =
+          result;
+
+        if (
+          result.errors.length ===
+          0
+        ) {
+          const duration =
+            performance.now() -
+            startedAt;
+
+          console.log(
+            `[BCP] Incremental rebuild: ${duration.toFixed(2)}ms`,
+          );
+        }
+
+        return result;
+      });
+
+    this.rebuildQueue =
+      next;
+
+    return next;
+  }
+
+  /**
+   * Returns the latest successful/attempted build result.
+   */
+  getLastResult():
+    esbuild.BuildResult | null {
+    return this.lastResult;
+  }
+
+  /**
+   * Returns the project root used by the context.
+   */
+  getProjectRoot(): string {
+    return this.projectRoot;
+  }
+
+  /**
+   * Indicates whether the underlying esbuild context exists.
+   */
+  isInitialized(): boolean {
+    return this.context !== null;
+  }
+
+  /**
+   * Dispose the long-lived esbuild context.
+   */
+  async dispose(): Promise<void> {
+    if (!this.context) {
+      return;
+    }
+
+    const context =
+      this.context;
+
+    this.context = null;
+    this.lastResult = null;
+
+    await context.dispose();
+  }
+}