@reliverse/build 2.2.7

package/dist/impl/utils/go-build-handler.js

@@ -0,0 +1,83 @@
+import { relinka } from "@reliverse/relinka";
+import { buildGo } from "../go-build.js";
+export async function handleGoBuild(pkg, options, verbose) {
+  if (options.tsOnly) {
+    if (verbose) {
+      await relinka.info(
+        `\u23ED\uFE0F  ${pkg.name}: Skipping Go build (--ts-only flag set)`
+      );
+    }
+    return;
+  }
+  if (!pkg.hasGoFiles) {
+    if (verbose) {
+      await relinka.debug(`\u23ED\uFE0F  ${pkg.name}: No Go files detected`);
+    }
+    return;
+  }
+  const goConfig = options.go ?? pkg.buildConfig?.go;
+  if (goConfig?.enable === false) {
+    if (verbose) {
+      await relinka.info(`\u23ED\uFE0F  ${pkg.name}: Go build disabled in config`);
+    }
+    return;
+  }
+  try {
+    await relinka.info(`\u{1F528} ${pkg.name}: Building Go binaries...`);
+    const goResult = await buildGo(
+      pkg.path,
+      pkg.name,
+      goConfig ?? { enable: true }
+    );
+    if (!goResult.success) {
+      await relinka.warn(
+        `\u26A0\uFE0F  ${pkg.name}: Go build failed: ${goResult.errors.join(", ")}`
+      );
+    } else {
+      await relinka.success(`\u2705 ${pkg.name}: Go binaries built successfully`);
+    }
+  } catch (error) {
+    await relinka.warn(
+      `\u26A0\uFE0F  ${pkg.name}: Go build error: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+export async function handleGoOnlyBuild(pkg, options) {
+  if (!pkg.hasGoFiles) {
+    return {
+      success: true,
+      errors: []
+    };
+  }
+  const goConfig = options.go ?? pkg.buildConfig?.go;
+  if (goConfig?.enable === false) {
+    return {
+      success: true,
+      errors: []
+    };
+  }
+  try {
+    await relinka.info(`\u{1F528} ${pkg.name}: Building Go binaries...`);
+    const goResult = await buildGo(
+      pkg.path,
+      pkg.name,
+      goConfig ?? { enable: true }
+    );
+    if (!goResult.success) {
+      return {
+        success: false,
+        errors: goResult.errors
+      };
+    }
+    await relinka.success(`\u2705 ${pkg.name}: Go binaries built successfully`);
+    return {
+      success: true,
+      errors: []
+    };
+  } catch (error) {
+    return {
+      success: false,
+      errors: [error instanceof Error ? error.message : String(error)]
+    };
+  }
+}

package/dist/impl/utils/log-extraction.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Bun build log entry - matches the structure from Bun.build().logs
+ */
+interface BunLogEntry {
+    level: "error" | "warning" | "info" | "debug" | "verbose";
+    message: string;
+    position?: {
+        file: string;
+        line: number;
+        column: number;
+    } | null;
+}
+/**
+ * Extract error messages from Bun build logs
+ */
+export declare function extractErrors(logs: BunLogEntry[]): string[];
+/**
+ * Extract warning messages from Bun build logs
+ */
+export declare function extractWarnings(logs: BunLogEntry[]): string[];
+/**
+ * Format all log messages into a single string
+ */
+export declare function formatLogMessages(logs: BunLogEntry[]): string;
+export {};

package/dist/impl/utils/log-extraction.js

@@ -0,0 +1,24 @@
+export function extractErrors(logs) {
+  return logs.filter((log) => log.level === "error").map((log) => {
+    if (log.position) {
+      return `${log.message} (${log.position.file}:${log.position.line}:${log.position.column})`;
+    }
+    return log.message;
+  });
+}
+export function extractWarnings(logs) {
+  return logs.filter((log) => log.level === "warning").map((log) => {
+    if (log.position) {
+      return `${log.message} (${log.position.file}:${log.position.line}:${log.position.column})`;
+    }
+    return log.message;
+  });
+}
+export function formatLogMessages(logs) {
+  return logs.map((log) => {
+    if (log.position) {
+      return `${log.message} (${log.position.file}:${log.position.line}:${log.position.column})`;
+    }
+    return log.message;
+  }).join("\n");
+}

package/dist/impl/utils/package-filtering.d.ts

@@ -0,0 +1,5 @@
+import type { PackageInfo } from "../types.js";
+/**
+ * Filter packages based on private status and allowed patterns
+ */
+export declare function filterPrivatePackages(packages: PackageInfo[], allowPrivateBuild?: string | string[]): PackageInfo[];

package/dist/impl/utils/package-filtering.js

@@ -0,0 +1,22 @@
+function isPackageAllowed(pkgName, allowedPatterns) {
+  for (const pattern of allowedPatterns) {
+    if (pattern.includes("*")) {
+      const regexPattern = pattern.replace(/\*/g, ".*");
+      if (new RegExp(`^${regexPattern}$`).test(pkgName)) {
+        return true;
+      }
+    } else if (pkgName === pattern) {
+      return true;
+    }
+  }
+  return false;
+}
+export function filterPrivatePackages(packages, allowPrivateBuild) {
+  if (!allowPrivateBuild) {
+    return packages.filter((pkg) => pkg.private !== true);
+  }
+  const allowedPatterns = Array.isArray(allowPrivateBuild) ? allowPrivateBuild : [allowPrivateBuild];
+  return packages.filter(
+    (pkg) => pkg.private !== true || isPackageAllowed(pkg.name, allowedPatterns)
+  );
+}

package/dist/impl/utils/rebuild-queue.d.ts

@@ -0,0 +1,38 @@
+import type { BuildOptions, BuildResult, PackageInfo } from "../types.js";
+interface RebuildQueueOptions {
+    debounceMs?: number;
+    incremental?: boolean;
+    buildOptions?: BuildOptions;
+    onRebuildComplete?: (result: BuildResult) => void | Promise<void>;
+}
+/**
+ * Shared rebuild queue processor for watch mode and dev server
+ */
+export declare class RebuildQueueProcessor {
+    private rebuildQueue;
+    private rebuildTimeout;
+    private readonly options;
+    private readonly packages;
+    constructor(packages: PackageInfo[], options?: RebuildQueueOptions);
+    /**
+     * Add a package to the rebuild queue
+     */
+    add(packageName: string): void;
+    /**
+     * Clear the rebuild queue
+     */
+    clear(): void;
+    /**
+     * Schedule a rebuild with debouncing
+     */
+    private scheduleRebuild;
+    /**
+     * Process the rebuild queue
+     */
+    private processQueue;
+    /**
+     * Process rebuild queue with custom build options
+     */
+    processWithOptions(options: BuildOptions): Promise<void>;
+}
+export {};

package/dist/impl/utils/rebuild-queue.js

@@ -0,0 +1,110 @@
+import { relinka } from "@reliverse/relinka";
+import { DEFAULT_DEBOUNCE_MS } from "../constants.js";
+export class RebuildQueueProcessor {
+  rebuildQueue = /* @__PURE__ */ new Set();
+  rebuildTimeout = null;
+  options;
+  packages;
+  constructor(packages, options = {}) {
+    this.packages = packages;
+    this.options = {
+      debounceMs: options.debounceMs ?? DEFAULT_DEBOUNCE_MS,
+      incremental: options.incremental ?? false,
+      buildOptions: options.buildOptions,
+      onRebuildComplete: options.onRebuildComplete
+    };
+  }
+  /**
+   * Add a package to the rebuild queue
+   */
+  add(packageName) {
+    this.rebuildQueue.add(packageName);
+    this.scheduleRebuild();
+  }
+  /**
+   * Clear the rebuild queue
+   */
+  clear() {
+    this.rebuildQueue.clear();
+    if (this.rebuildTimeout) {
+      clearTimeout(this.rebuildTimeout);
+      this.rebuildTimeout = null;
+    }
+  }
+  /**
+   * Schedule a rebuild with debouncing
+   */
+  scheduleRebuild() {
+    if (this.rebuildTimeout) {
+      clearTimeout(this.rebuildTimeout);
+    }
+    this.rebuildTimeout = setTimeout(() => {
+      void this.processQueue();
+    }, this.options.debounceMs);
+  }
+  /**
+   * Process the rebuild queue
+   */
+  async processQueue() {
+    if (this.rebuildQueue.size === 0) return;
+    const packagesToRebuild = Array.from(this.rebuildQueue).map((name) => this.packages.find((pkg) => pkg.name === name)).filter((pkg) => pkg !== void 0);
+    this.rebuildQueue.clear();
+    const rebuildMessage = this.options.incremental ? `\u{1F504} Incrementally rebuilding ${packagesToRebuild.length} packages...` : `\u{1F504} Rebuilding ${packagesToRebuild.length} packages...`;
+    await relinka.info(rebuildMessage);
+    const { buildPackage } = await import("../../mod.js");
+    const buildOptions = this.options.buildOptions ?? {};
+    const buildPromises = packagesToRebuild.map(async (pkg) => {
+      try {
+        const result = await buildPackage(pkg, buildOptions);
+        if (result.success) {
+          await relinka.success(`\u2705 ${pkg.name}: Rebuilt successfully`);
+        } else {
+          await relinka.error(`\u274C ${pkg.name}: Rebuild failed`);
+          for (const error of result.errors) {
+            await relinka.error(`   ${error}`);
+          }
+        }
+        if (this.options.onRebuildComplete) {
+          await this.options.onRebuildComplete(result);
+        }
+        return result;
+      } catch (error) {
+        await relinka.error(
+          `\u274C ${pkg.name}: Rebuild error - ${error instanceof Error ? error.message : String(error)}`
+        );
+        return null;
+      }
+    });
+    await Promise.all(buildPromises);
+  }
+  /**
+   * Process rebuild queue with custom build options
+   */
+  async processWithOptions(options) {
+    if (this.rebuildQueue.size === 0) return;
+    const packagesToRebuild = Array.from(this.rebuildQueue).map((name) => this.packages.find((pkg) => pkg.name === name)).filter((pkg) => pkg !== void 0);
+    this.rebuildQueue.clear();
+    await relinka.info(`\u{1F504} Rebuilding ${packagesToRebuild.length} packages...`);
+    const { buildPackage } = await import("../../mod.js");
+    for (const pkg of packagesToRebuild) {
+      try {
+        const result = await buildPackage(pkg, options);
+        if (result.success) {
+          await relinka.success(`\u2705 ${pkg.name}: Rebuilt successfully`);
+        } else {
+          await relinka.error(`\u274C ${pkg.name}: Rebuild failed`);
+          for (const error of result.errors) {
+            await relinka.error(`   ${error}`);
+          }
+        }
+        if (this.options.onRebuildComplete) {
+          await this.options.onRebuildComplete(result);
+        }
+      } catch (error) {
+        await relinka.error(
+          `\u274C ${pkg.name}: Rebuild error - ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  }
+}

package/dist/impl/validation.d.ts

@@ -0,0 +1,9 @@
+import type { BuildOptions } from "./types.js";
+export interface ValidationError {
+    field: string;
+    message: string;
+    suggestion?: string;
+}
+export declare function validateBuildOptions(options: BuildOptions): ValidationError[];
+export declare function logValidationErrors(errors: ValidationError[]): void;
+export declare function validateAndExit(options: BuildOptions): void;

package/dist/impl/validation.js

@@ -0,0 +1,332 @@
+import { logger } from "@reliverse/relinka";
+export function validateBuildOptions(options) {
+  const errors = [];
+  if (options.bundler && !["bun", "mkdist"].includes(options.bundler)) {
+    errors.push({
+      field: "bundler",
+      message: 'Bundler must be "bun" or "mkdist"',
+      suggestion: 'Set --bundler to "bun" or "mkdist"'
+    });
+  }
+  if (options.bytecode) {
+    if (options.format !== "cjs") {
+      errors.push({
+        field: "bytecode",
+        message: 'Bytecode compilation requires format: "cjs"',
+        suggestion: "Set --format cjs or remove --bytecode"
+      });
+    }
+    if (options.target !== "bun") {
+      errors.push({
+        field: "bytecode",
+        message: 'Bytecode compilation requires target: "bun"',
+        suggestion: "Set --target bun or remove --bytecode"
+      });
+    }
+  }
+  if (options.jsx) {
+    if (options.jsx.runtime && !["automatic", "classic"].includes(options.jsx.runtime)) {
+      errors.push({
+        field: "jsx.runtime",
+        message: 'JSX runtime must be "automatic" or "classic"',
+        suggestion: 'Set --jsxRuntime to "automatic" or "classic"'
+      });
+    }
+    if (options.jsx.importSource && typeof options.jsx.importSource !== "string") {
+      errors.push({
+        field: "jsx.importSource",
+        message: "JSX import source must be a string",
+        suggestion: 'Set --jsxImportSource to a valid package name like "react"'
+      });
+    }
+  }
+  if (options.format === "iife") {
+    if (options.target !== "browser") {
+      errors.push({
+        field: "format",
+        message: 'IIFE format requires target: "browser"',
+        suggestion: "Set --target browser or use --format esm/cjs"
+      });
+    }
+    if (options.splitting) {
+      errors.push({
+        field: "splitting",
+        message: "Code splitting is not supported with IIFE format",
+        suggestion: "Set --splitting false or use --format esm/cjs"
+      });
+    }
+  }
+  if (options.format === "cjs") {
+    if (options.target === "browser") {
+      errors.push({
+        field: "format",
+        message: "CommonJS format is not recommended for browser targets",
+        suggestion: "Use --format esm for browser or --target node for CommonJS"
+      });
+    }
+    errors.push({
+      field: "format",
+      message: "CommonJS format is experimental in Bun",
+      suggestion: "Consider using --format esm for better compatibility"
+    });
+  }
+  if (options.format === "iife") {
+    errors.push({
+      field: "format",
+      message: "IIFE format is experimental in Bun",
+      suggestion: "Consider using --format esm for better compatibility"
+    });
+  }
+  if (options.production && options.dev) {
+    errors.push({
+      field: "production",
+      message: "Cannot use both --production and --dev flags",
+      suggestion: "Choose either --production or --dev"
+    });
+  }
+  if (options.watch && options.compile) {
+    errors.push({
+      field: "watch",
+      message: "Watch mode is not supported with --compile",
+      suggestion: "Remove --watch or --compile flag"
+    });
+  }
+  if (options.compile) {
+    if (options.target === "browser") {
+      errors.push({
+        field: "compile",
+        message: "Standalone executables cannot be built for browser target",
+        suggestion: "Use --target bun or --target node for executables"
+      });
+    }
+    if (options.html) {
+      errors.push({
+        field: "compile",
+        message: "HTML processing is not compatible with standalone executables",
+        suggestion: "Remove --html or --compile flag"
+      });
+    }
+    if (!options.bytecode && options.format === "cjs" && options.target === "bun") {
+      logger.info(
+        "\u{1F4A1} Consider using --bytecode with --compile for faster cold starts"
+      );
+    }
+  }
+  if (options.entryNaming && !isValidNamingPattern(options.entryNaming)) {
+    errors.push({
+      field: "entryNaming",
+      message: "Invalid entry naming pattern",
+      suggestion: "Use valid placeholders: [dir], [name], [ext], [hash]"
+    });
+  }
+  if (options.chunkNaming && !isValidNamingPattern(options.chunkNaming)) {
+    errors.push({
+      field: "chunkNaming",
+      message: "Invalid chunk naming pattern",
+      suggestion: "Use valid placeholders: [dir], [name], [ext], [hash]"
+    });
+  }
+  if (options.assetNaming && !isValidNamingPattern(options.assetNaming)) {
+    errors.push({
+      field: "assetNaming",
+      message: "Invalid asset naming pattern",
+      suggestion: "Use valid placeholders: [dir], [name], [ext], [hash]"
+    });
+  }
+  if (options.external && Array.isArray(options.external)) {
+    for (const ext of options.external) {
+      if (typeof ext !== "string" || ext.trim() === "") {
+        errors.push({
+          field: "external",
+          message: "External packages must be non-empty strings",
+          suggestion: "Remove empty strings from external array"
+        });
+        break;
+      }
+    }
+  }
+  if (options.drop && Array.isArray(options.drop)) {
+    for (const drop of options.drop) {
+      if (typeof drop !== "string" || drop.trim() === "") {
+        errors.push({
+          field: "drop",
+          message: "Drop patterns must be non-empty strings",
+          suggestion: "Remove empty strings from drop array"
+        });
+        break;
+      }
+    }
+  }
+  if (options.concurrency !== void 0) {
+    if (!Number.isInteger(options.concurrency) || options.concurrency < 1) {
+      errors.push({
+        field: "concurrency",
+        message: "Concurrency must be a positive integer",
+        suggestion: "Set --concurrency to a number >= 1"
+      });
+    }
+  }
+  if (options.devServer) {
+    if (options.target !== "browser") {
+      errors.push({
+        field: "devServer",
+        message: 'Dev server requires target: "browser"',
+        suggestion: "Set --target browser or remove --devServer"
+      });
+    }
+    if (options.compile) {
+      errors.push({
+        field: "devServer",
+        message: "Dev server is not supported with --compile",
+        suggestion: "Remove --compile or --devServer flag"
+      });
+    }
+  }
+  if (options.port !== void 0) {
+    if (!Number.isInteger(options.port) || options.port < 1 || options.port > 65535) {
+      errors.push({
+        field: "port",
+        message: "Port must be between 1 and 65535",
+        suggestion: "Set --port to a valid port number"
+      });
+    }
+  }
+  if (options.html && options.target === "node") {
+    errors.push({
+      field: "html",
+      message: 'HTML processing is not supported with target: "node"',
+      suggestion: "Use --target browser for HTML processing"
+    });
+  }
+  if (options.cssChunking && options.format === "iife") {
+    errors.push({
+      field: "cssChunking",
+      message: "CSS chunking is not supported with IIFE format",
+      suggestion: "Use --format esm or remove --cssChunking"
+    });
+  }
+  if (options.minify && typeof options.minify === "object") {
+    const minify = options.minify;
+    if (minify.whitespace !== void 0 && typeof minify.whitespace !== "boolean") {
+      errors.push({
+        field: "minify.whitespace",
+        message: "Minify whitespace option must be boolean",
+        suggestion: "Set --minifyWhitespace to true or false"
+      });
+    }
+    if (minify.syntax !== void 0 && typeof minify.syntax !== "boolean") {
+      errors.push({
+        field: "minify.syntax",
+        message: "Minify syntax option must be boolean",
+        suggestion: "Set --minifySyntax to true or false"
+      });
+    }
+    if (minify.identifiers !== void 0 && typeof minify.identifiers !== "boolean") {
+      errors.push({
+        field: "minify.identifiers",
+        message: "Minify identifiers option must be boolean",
+        suggestion: "Set --minifyIdentifiers to true or false"
+      });
+    }
+  }
+  if (options.loader && typeof options.loader === "object") {
+    const validLoaders = [
+      "js",
+      "jsx",
+      "ts",
+      "tsx",
+      "json",
+      "toml",
+      "file",
+      "napi",
+      "wasm",
+      "text"
+    ];
+    for (const [ext, loader] of Object.entries(options.loader)) {
+      if (typeof loader !== "string" || !validLoaders.includes(loader)) {
+        errors.push({
+          field: "loader",
+          message: `Invalid loader for extension .${ext}: ${loader}`,
+          suggestion: `Use one of: ${validLoaders.join(", ")}`
+        });
+      }
+    }
+  }
+  if (options.env && typeof options.env === "string") {
+    if (options.env !== "inline" && options.env !== "disable" && !options.env.endsWith("*")) {
+      errors.push({
+        field: "env",
+        message: 'env must be "inline", "disable", or a string ending with "*"',
+        suggestion: 'Use --env inline, --env disable, or --env "PUBLIC_*"'
+      });
+    }
+  }
+  if (options.conditions && Array.isArray(options.conditions)) {
+    for (const condition of options.conditions) {
+      if (typeof condition !== "string" || condition.trim() === "") {
+        errors.push({
+          field: "conditions",
+          message: "Conditions must be non-empty strings",
+          suggestion: "Remove empty strings from conditions array"
+        });
+        break;
+      }
+    }
+  }
+  if (options.naming) {
+    if (options.naming.chunk && !isValidNamingPattern(options.naming.chunk)) {
+      errors.push({
+        field: "naming.chunk",
+        message: "Invalid chunk naming pattern",
+        suggestion: "Use valid placeholders: [dir], [name], [ext], [hash]"
+      });
+    }
+    if (options.naming.entry && !isValidNamingPattern(options.naming.entry)) {
+      errors.push({
+        field: "naming.entry",
+        message: "Invalid entry naming pattern",
+        suggestion: "Use valid placeholders: [dir], [name], [ext], [hash]"
+      });
+    }
+    if (options.naming.asset && !isValidNamingPattern(options.naming.asset)) {
+      errors.push({
+        field: "naming.asset",
+        message: "Invalid asset naming pattern",
+        suggestion: "Use valid placeholders: [dir], [name], [ext], [hash]"
+      });
+    }
+  }
+  return errors;
+}
+function isValidNamingPattern(pattern) {
+  const validPlaceholders = /\[(dir|name|ext|hash)\]/g;
+  const matches = pattern.match(validPlaceholders);
+  if (!matches) {
+    return false;
+  }
+  const invalidChars = /[<>:"|?*]/;
+  if (invalidChars.test(pattern)) {
+    return false;
+  }
+  return true;
+}
+export function logValidationErrors(errors) {
+  if (errors.length === 0) return;
+  logger.error("\u274C Build configuration validation failed:");
+  logger.error("");
+  for (const error of errors) {
+    logger.error(`   \u2022 ${error.field}: ${error.message}`);
+    if (error.suggestion) {
+      logger.error(`     \u{1F4A1} ${error.suggestion}`);
+    }
+  }
+  logger.error("");
+  logger.error("Run with --help to see all available options.");
+}
+export function validateAndExit(options) {
+  const errors = validateBuildOptions(options);
+  if (errors.length > 0) {
+    logValidationErrors(errors);
+    process.exit(1);
+  }
+}

package/dist/impl/watch.d.ts

@@ -0,0 +1,21 @@
+import type { BuildOptions, PackageInfo } from "./types.js";
+export interface WatchOptions extends BuildOptions {
+    debounceMs?: number;
+    ignorePatterns?: string[];
+    incremental?: boolean;
+}
+export declare class FileWatcher {
+    private watchers;
+    private rebuildQueue;
+    private options;
+    private packages;
+    constructor(packages: PackageInfo[], options: WatchOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private watchPackage;
+    private watchFile;
+    private watchDirectory;
+    private handleFileChange;
+    private shouldIgnoreFile;
+}
+export declare function startWatchMode(packages: PackageInfo[], options: WatchOptions): Promise<void>;