@reliverse/build 2.2.7

package/dist/impl/watch.js

@@ -0,0 +1,144 @@
+import { existsSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { relinka } from "@reliverse/relinka";
+import { DEFAULT_DEBOUNCE_MS, DEFAULT_IGNORE_PATTERNS } from "./constants.js";
+import { RebuildQueueProcessor } from "./utils/rebuild-queue.js";
+export class FileWatcher {
+  watchers = /* @__PURE__ */ new Map();
+  rebuildQueue;
+  options;
+  packages;
+  constructor(packages, options) {
+    this.packages = packages;
+    this.options = {
+      debounceMs: options.debounceMs ?? DEFAULT_DEBOUNCE_MS,
+      ignorePatterns: options.ignorePatterns ?? [...DEFAULT_IGNORE_PATTERNS],
+      incremental: options.incremental ?? true,
+      ...options
+    };
+    this.rebuildQueue = new RebuildQueueProcessor(packages, {
+      debounceMs: this.options.debounceMs,
+      incremental: this.options.incremental,
+      buildOptions: this.options
+    });
+  }
+  async start() {
+    await relinka.info(
+      `\u{1F440} Starting file watcher for ${this.packages.length} packages...`
+    );
+    for (const pkg of this.packages) {
+      if (pkg.entryPoints.length === 0) continue;
+      await this.watchPackage(pkg);
+    }
+    await relinka.success("\u2705 File watching started");
+  }
+  async stop() {
+    for (const [path, watcher] of this.watchers) {
+      try {
+        watcher.close();
+      } catch (error) {
+        await relinka.warn(
+          `Failed to close watcher for ${path}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    this.watchers.clear();
+    this.rebuildQueue.clear();
+    await relinka.info("File watching stopped");
+  }
+  async watchPackage(pkg) {
+    for (const entryPoint of pkg.entryPoints) {
+      if (existsSync(entryPoint)) {
+        await this.watchFile(entryPoint, pkg);
+      }
+    }
+    const srcDir = join(pkg.path, "src");
+    if (existsSync(srcDir) && statSync(srcDir).isDirectory()) {
+      await this.watchDirectory(srcDir, pkg);
+    }
+    const packageJsonPath = join(pkg.path, "package.json");
+    if (existsSync(packageJsonPath)) {
+      await this.watchFile(packageJsonPath, pkg);
+    }
+    const tsconfigPath = join(pkg.path, "tsconfig.json");
+    if (existsSync(tsconfigPath)) {
+      await this.watchFile(tsconfigPath, pkg);
+    }
+  }
+  async watchFile(filePath, pkg) {
+    if (this.watchers.has(filePath)) return;
+    try {
+      const { watch } = await import("node:fs");
+      const watcher = watch(filePath, (eventType) => {
+        if (eventType === "change") {
+          this.handleFileChange(filePath, pkg);
+        }
+      });
+      watcher.on("error", (error) => {
+        void relinka.warn(
+          `File watcher error for ${filePath}: ${error.message}`
+        );
+        this.watchers.delete(filePath);
+      });
+      this.watchers.set(filePath, watcher);
+    } catch (error) {
+      void relinka.warn(`Failed to watch file ${filePath}: ${error}`);
+    }
+  }
+  async watchDirectory(dirPath, pkg) {
+    if (this.watchers.has(dirPath)) return;
+    try {
+      const { watch } = await import("node:fs");
+      const watcher = watch(
+        dirPath,
+        { recursive: true },
+        (eventType, filename) => {
+          if (eventType === "change" && filename) {
+            const fullPath = join(dirPath, filename);
+            this.handleFileChange(fullPath, pkg);
+          }
+        }
+      );
+      watcher.on("error", (error) => {
+        void relinka.warn(
+          `Directory watcher error for ${dirPath}: ${error.message}`
+        );
+        this.watchers.delete(dirPath);
+      });
+      this.watchers.set(dirPath, watcher);
+    } catch (error) {
+      void relinka.warn(`Failed to watch directory ${dirPath}: ${error}`);
+    }
+  }
+  handleFileChange(filePath, pkg) {
+    if (this.shouldIgnoreFile(filePath)) {
+      return;
+    }
+    void relinka.info(`\u{1F4DD} File changed: ${filePath}`);
+    this.rebuildQueue.add(pkg.name);
+  }
+  shouldIgnoreFile(filePath) {
+    if (!this.options.ignorePatterns) return false;
+    for (const pattern of this.options.ignorePatterns) {
+      const regexPattern = pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/\./g, "\\.");
+      const regex = new RegExp(`^${regexPattern}$`);
+      if (regex.test(filePath) || regex.test(filePath.replace(/\\/g, "/"))) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
+export async function startWatchMode(packages, options) {
+  const watcher = new FileWatcher(packages, options);
+  const shutdown = async () => {
+    await relinka.info("\n\u{1F6D1} Shutting down watch mode...");
+    await watcher.stop();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  await watcher.start();
+  return new Promise(() => {
+  });
+}

package/dist/mod.d.ts

@@ -0,0 +1,17 @@
+import { BuildCache } from "./impl/cache.js";
+import type { BuildOptions, BuildResult, BuildSummary, PackageInfo } from "./impl/types.js";
+export type { GoBuildOptions } from "@reliverse/config/impl/build";
+export type { PackageKind, RegistryType, } from "@reliverse/config/impl/publish";
+export type { PreparePackageJsonOptions } from "@reliverse/typerso";
+export { addBinFieldToPackageJson, extractPackageName, parseBinArgument, preparePackageJsonForPublishing, transformExportsForBuild, } from "@reliverse/typerso";
+export type { DtsGeneratorOptions, DtsGeneratorResult, } from "./impl/dts-generator.js";
+export { generateDeclarations } from "./impl/dts-generator.js";
+export { buildGo } from "./impl/go-build.js";
+export { applyPresets } from "./impl/presets.js";
+export type { MkdistDtsOptions } from "./impl/providers/mkdist-dts.js";
+export type { TSConfigValidationOptions, TSConfigValidationResult, } from "./impl/tsconfig-validator.js";
+export { logValidationResults, validateAllTSConfigs, validateTSConfig, } from "./impl/tsconfig-validator.js";
+export type { BuildOptions } from "./impl/types.js";
+export { validateAndExit } from "./impl/validation.js";
+export declare const buildPackage: (pkg: PackageInfo, options?: BuildOptions, cache?: BuildCache) => Promise<BuildResult>;
+export declare const runBuildOnAllPackages: (ignore?: string | string[], cwd?: string, options?: BuildOptions) => Promise<BuildSummary>;