@reliverse/build 2.2.7

package/dist/impl/debug.js

@@ -0,0 +1,150 @@
+import { logger } from "@reliverse/relinka";
+export class DebugLogger {
+  enabled;
+  startTime = 0;
+  constructor(enabled = false) {
+    this.enabled = enabled;
+  }
+  start() {
+    this.startTime = Date.now();
+    if (this.enabled) {
+      logger.info("\u{1F41B} Debug mode enabled");
+    }
+  }
+  logConfigResolution(pkg, configSource, configPath) {
+    if (!this.enabled) return;
+    logger.info(`\u{1F4CB} Config resolution for ${pkg.name}:`);
+    logger.info(`   Source: ${configSource}`);
+    if (configPath) {
+      logger.info(`   Path: ${configPath}`);
+    }
+  }
+  logBuildOptions(options, pkg) {
+    if (!this.enabled) return;
+    logger.info(`\u2699\uFE0F  Build options for ${pkg.name}:`);
+    logger.info(`   Target: ${options.target || "bun"}`);
+    logger.info(`   Format: ${options.format || "esm"}`);
+    logger.info(`   Minify: ${options.minify ? "enabled" : "disabled"}`);
+    logger.info(`   Sourcemap: ${options.sourcemap || "none"}`);
+    logger.info(`   Splitting: ${options.splitting ? "enabled" : "disabled"}`);
+    if (options.jsx) {
+      logger.info(`   JSX Runtime: ${options.jsx.runtime || "automatic"}`);
+      if (options.jsx.importSource) {
+        logger.info(`   JSX Import Source: ${options.jsx.importSource}`);
+      }
+    }
+    if (options.external) {
+      const externals = Array.isArray(options.external) ? options.external : [options.external];
+      logger.info(`   External: ${externals.join(", ")}`);
+    }
+    if (options.define) {
+      logger.info(`   Define: ${JSON.stringify(options.define)}`);
+    }
+  }
+  logEntryPoints(pkg) {
+    if (!this.enabled) return;
+    logger.info(`\u{1F4C1} Entry points for ${pkg.name}:`);
+    for (const entryPoint of pkg.entryPoints) {
+      logger.info(`   \u2022 ${entryPoint}`);
+    }
+  }
+  logBuildStats(summary) {
+    if (!this.enabled) return;
+    const totalTime = Date.now() - this.startTime;
+    logger.info("\u{1F4CA} Build Statistics:");
+    logger.info(`   Total packages: ${summary.totalPackages}`);
+    logger.info(`   Successful: ${summary.successfulPackages}`);
+    logger.info(`   Failed: ${summary.failedPackages}`);
+    logger.info(`   Skipped: ${summary.skippedPackages}`);
+    logger.info(`   Cache hits: ${summary.cacheHits}`);
+    logger.info(`   Total build time: ${summary.totalBuildTime}ms`);
+    logger.info(
+      `   Total bundle size: ${formatBytes(summary.totalBundleSize)}`
+    );
+    logger.info(`   Process time: ${totalTime}ms`);
+    logger.info(
+      `   Average per package: ${Math.round(summary.totalBuildTime / summary.totalPackages)}ms`
+    );
+    if (summary.cacheHits > 0) {
+      const cacheHitRate = Math.round(
+        summary.cacheHits / summary.totalPackages * 100
+      );
+      logger.info(`   Cache hit rate: ${cacheHitRate}%`);
+    }
+  }
+  logPackageResult(result) {
+    if (!this.enabled) return;
+    logger.info(`\u{1F4E6} Build result for ${result.package.name}:`);
+    logger.info(`   Success: ${result.success ? "\u2705" : "\u274C"}`);
+    logger.info(`   Skipped: ${result.skipped ? "\u23ED\uFE0F" : "\u274C"}`);
+    logger.info(`   Build time: ${result.buildTime}ms`);
+    if (result.bundleSize) {
+      logger.info(`   Bundle size: ${formatBytes(result.bundleSize)}`);
+    }
+    if (result.cacheHit) {
+      logger.info(`   Cache hit: \u26A1`);
+    }
+    if (result.errors.length > 0) {
+      logger.info(`   Errors: ${result.errors.length}`);
+      for (const error of result.errors) {
+        logger.info(`     \u2022 ${error}`);
+      }
+    }
+    if (result.warnings.length > 0) {
+      logger.info(`   Warnings: ${result.warnings.length}`);
+      for (const warning of result.warnings) {
+        logger.info(`     \u2022 ${warning}`);
+      }
+    }
+  }
+  logDependencyGraph(pkg, dependencies) {
+    if (!this.enabled) return;
+    logger.info(`\u{1F517} Dependencies for ${pkg.name}:`);
+    for (const dep of dependencies) {
+      logger.info(`   \u2022 ${dep}`);
+    }
+  }
+  logCacheInfo(pkg, cacheHit, cacheKey) {
+    if (!this.enabled) return;
+    if (cacheHit) {
+      logger.info(`\u26A1 Cache hit for ${pkg.name}`);
+      if (cacheKey) {
+        logger.info(`   Key: ${cacheKey}`);
+      }
+    } else {
+      logger.info(`\u{1F504} Cache miss for ${pkg.name}`);
+    }
+  }
+  logFileWatching(pkg, watchedFiles) {
+    if (!this.enabled) return;
+    logger.info(`\u{1F440} Watching files for ${pkg.name}:`);
+    for (const file of watchedFiles) {
+      logger.info(`   \u2022 ${file}`);
+    }
+  }
+  logAssetProcessing(pkg, assets) {
+    if (!this.enabled) return;
+    logger.info(`\u{1F3A8} Asset processing for ${pkg.name}:`);
+    for (const asset of assets) {
+      logger.info(`   \u2022 ${asset}`);
+    }
+  }
+  logError(error, context) {
+    if (!this.enabled) return;
+    logger.error(`\u{1F41B} Debug error${context ? ` in ${context}` : ""}:`);
+    logger.error(`   Message: ${error.message}`);
+    if (error.stack) {
+      logger.error(`   Stack: ${error.stack}`);
+    }
+  }
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / k ** i).toFixed(1))} ${sizes[i]}`;
+}
+export function createDebugLogger(options) {
+  return new DebugLogger(options.debug || false);
+}

package/dist/impl/dependency-tracker.d.ts

@@ -0,0 +1,23 @@
+export interface DependencyInfo {
+    filePath: string;
+    hash: string;
+    dependencies: string[];
+    lastModified: number;
+}
+export interface DependencyGraph {
+    [filePath: string]: DependencyInfo;
+}
+export declare class DependencyTracker {
+    private graph;
+    private visitedFiles;
+    trackDependencies(entryPoints: string[]): Promise<DependencyGraph>;
+    private trackFile;
+    private extractDependencies;
+    private resolveImportPath;
+    getFileHash(filePath: string): string | null;
+    getDependencies(filePath: string): string[];
+    getAllDependencies(filePath: string): string[];
+    hasFileChanged(filePath: string): boolean;
+    hasAnyDependencyChanged(filePath: string): boolean;
+    getGraph(): DependencyGraph;
+}

package/dist/impl/dependency-tracker.js

@@ -0,0 +1,113 @@
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { logger } from "@reliverse/relinka";
+export class DependencyTracker {
+  graph = {};
+  visitedFiles = /* @__PURE__ */ new Set();
+  async trackDependencies(entryPoints) {
+    this.graph = {};
+    this.visitedFiles.clear();
+    for (const entryPoint of entryPoints) {
+      await this.trackFile(entryPoint);
+    }
+    return this.graph;
+  }
+  async trackFile(filePath) {
+    if (this.visitedFiles.has(filePath) || !existsSync(filePath)) {
+      return;
+    }
+    this.visitedFiles.add(filePath);
+    try {
+      const content = readFileSync(filePath, "utf-8");
+      const hash = createHash("sha256").update(content).digest("hex");
+      const stats = require("node:fs").statSync(filePath);
+      const dependencies = await this.extractDependencies(filePath, content);
+      this.graph[filePath] = {
+        filePath,
+        hash,
+        dependencies,
+        lastModified: stats.mtime.getTime()
+      };
+      for (const dep of dependencies) {
+        await this.trackFile(dep);
+      }
+    } catch (error) {
+      logger.warn(`Failed to track file ${filePath}: ${error}`);
+    }
+  }
+  async extractDependencies(filePath, content) {
+    const dependencies = [];
+    const dir = resolve(filePath, "..");
+    const importRegex = /(?:import\s+.*?\s+from\s+['"]([^'"]+)['"]|require\s*\(\s*['"]([^'"]+)['"]\s*\)|import\s*\(\s*['"]([^'"]+)['"]\s*\))/g;
+    let match;
+    match = importRegex.exec(content);
+    while (match !== null) {
+      const importPath = match[1] || match[2] || match[3];
+      if (importPath && typeof importPath === "string") {
+        const resolvedPath = this.resolveImportPath(importPath, dir);
+        if (resolvedPath && existsSync(resolvedPath)) {
+          dependencies.push(resolvedPath);
+        }
+      }
+      match = importRegex.exec(content);
+    }
+    return [...new Set(dependencies)];
+  }
+  resolveImportPath(importPath, fromDir) {
+    if (importPath.startsWith("./") || importPath.startsWith("../")) {
+      return resolve(fromDir, importPath);
+    }
+    if (importPath.startsWith("/")) {
+      return importPath;
+    }
+    if (!importPath.startsWith(".") && !importPath.startsWith("/")) {
+      return null;
+    }
+    return null;
+  }
+  getFileHash(filePath) {
+    return this.graph[filePath]?.hash || null;
+  }
+  getDependencies(filePath) {
+    return this.graph[filePath]?.dependencies || [];
+  }
+  getAllDependencies(filePath) {
+    const visited = /* @__PURE__ */ new Set();
+    const deps = [];
+    const collectDeps = (currentPath) => {
+      if (visited.has(currentPath)) return;
+      visited.add(currentPath);
+      const fileDeps = this.getDependencies(currentPath);
+      for (const dep of fileDeps) {
+        deps.push(dep);
+        collectDeps(dep);
+      }
+    };
+    collectDeps(filePath);
+    return deps;
+  }
+  hasFileChanged(filePath) {
+    if (!existsSync(filePath)) return true;
+    try {
+      const content = readFileSync(filePath, "utf-8");
+      const currentHash = createHash("sha256").update(content).digest("hex");
+      const cachedHash = this.getFileHash(filePath);
+      return currentHash !== cachedHash;
+    } catch {
+      return true;
+    }
+  }
+  hasAnyDependencyChanged(filePath) {
+    const deps = this.getAllDependencies(filePath);
+    for (const dep of deps) {
+      if (this.hasFileChanged(dep)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  getGraph() {
+    return { ...this.graph };
+  }
+}

package/dist/impl/dev-server.d.ts

@@ -0,0 +1,24 @@
+import type { BuildOptions, DevServerOptions, PackageInfo } from "./types.js";
+export declare class DevServer {
+    private server;
+    private config;
+    private packages;
+    private watchers;
+    private rebuildQueue;
+    constructor(packages: PackageInfo[], options: BuildOptions, devServerOptions?: DevServerOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private serveIndexHtml;
+    private serveStaticAsset;
+    private serveBuiltFile;
+    private serveFile;
+    private getContentType;
+    private generateFallbackHtml;
+    private startFileWatching;
+    private watchFile;
+    private watchDirectory;
+    private handleFileChange;
+    private handleHMRMessage;
+    private notifyClients;
+}
+export declare function startDevServer(packages: PackageInfo[], options: BuildOptions, devServerOptions?: DevServerOptions): Promise<DevServer>;

package/dist/impl/dev-server.js

@@ -0,0 +1,360 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { extname, join } from "node:path";
+import { relinka } from "@reliverse/relinka";
+import {
+  DEFAULT_DEBOUNCE_MS,
+  DEFAULT_DEV_SERVER_HOST,
+  DEFAULT_DEV_SERVER_PORT
+} from "./constants.js";
+import { RebuildQueueProcessor } from "./utils/rebuild-queue.js";
+export class DevServer {
+  server = null;
+  config;
+  packages;
+  watchers = /* @__PURE__ */ new Map();
+  rebuildQueue;
+  constructor(packages, options, devServerOptions) {
+    this.packages = packages;
+    this.config = {
+      port: devServerOptions?.port ?? DEFAULT_DEV_SERVER_PORT,
+      host: devServerOptions?.host ?? DEFAULT_DEV_SERVER_HOST,
+      hmr: devServerOptions?.hmr ?? true,
+      publicDir: options.publicAssets ?? "public"
+    };
+    this.rebuildQueue = new RebuildQueueProcessor(packages, {
+      debounceMs: DEFAULT_DEBOUNCE_MS,
+      buildOptions: { ...options },
+      onRebuildComplete: (result) => {
+        if (result.success) {
+          this.notifyClients("reload");
+        } else {
+          this.notifyClients("error", {
+            message: `Build failed: ${result.errors.join(", ")}`
+          });
+        }
+      }
+    });
+  }
+  async start() {
+    if (this.server) {
+      await relinka.warn("Dev server is already running");
+      return;
+    }
+    try {
+      this.server = Bun.serve({
+        port: this.config.port,
+        hostname: this.config.host,
+        fetch: async (request) => {
+          const url2 = new URL(request.url);
+          const pathname = url2.pathname;
+          const corsHeaders = {
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
+            "Access-Control-Allow-Headers": "Content-Type, Authorization"
+          };
+          if (request.method === "OPTIONS") {
+            return new Response(null, {
+              status: 200,
+              headers: corsHeaders
+            });
+          }
+          if (pathname === "/" || pathname === "/index.html") {
+            const response = await this.serveIndexHtml();
+            if (response) {
+              Object.entries(corsHeaders).forEach(([key, value]) => {
+                response.headers.set(key, value);
+              });
+            }
+            return response;
+          }
+          const assetResponse = await this.serveStaticAsset(pathname);
+          if (assetResponse) {
+            Object.entries(corsHeaders).forEach(([key, value]) => {
+              assetResponse.headers.set(key, value);
+            });
+            return assetResponse;
+          }
+          const builtResponse = await this.serveBuiltFile(pathname);
+          if (builtResponse) {
+            Object.entries(corsHeaders).forEach(([key, value]) => {
+              builtResponse.headers.set(key, value);
+            });
+            return builtResponse;
+          }
+          return new Response("Not Found", {
+            status: 404,
+            headers: corsHeaders
+          });
+        },
+        websocket: {
+          open: (ws) => {
+            if (this.config.hmr) {
+              ws.subscribe("hmr");
+            }
+          },
+          message: (ws, message) => {
+            if (this.config.hmr) {
+              this.handleHMRMessage(ws, message);
+            }
+          }
+        }
+      });
+      const url = `http://${this.config.host}:${this.config.port}`;
+      await relinka.success(`\u{1F680} Dev server running at ${url}`);
+      if (this.config.hmr) {
+        await this.startFileWatching();
+      }
+    } catch (error) {
+      await relinka.error(`Failed to start dev server: ${error}`);
+      throw error;
+    }
+  }
+  async stop() {
+    if (this.server) {
+      this.server.stop();
+      this.server = null;
+    }
+    for (const watcher of this.watchers.values()) {
+      watcher.close();
+    }
+    this.watchers.clear();
+    await relinka.info("Dev server stopped");
+  }
+  async serveIndexHtml() {
+    for (const pkg of this.packages) {
+      if (pkg.hasHtmlEntry) {
+        const htmlFiles = pkg.entryPoints.filter((ep) => ep.endsWith(".html"));
+        if (htmlFiles.length > 0) {
+          const htmlPath = htmlFiles[0];
+          if (htmlPath && existsSync(htmlPath)) {
+            const content = readFileSync(htmlPath, "utf-8");
+            return new Response(content, {
+              headers: { "Content-Type": "text/html" }
+            });
+          }
+        }
+      }
+    }
+    const html = this.generateFallbackHtml();
+    return new Response(html, {
+      headers: { "Content-Type": "text/html" }
+    });
+  }
+  async serveStaticAsset(pathname) {
+    const assetPath = pathname.slice(1);
+    for (const pkg of this.packages) {
+      if (pkg.hasPublicDir) {
+        const publicPath = join(pkg.path, "public", assetPath);
+        if (existsSync(publicPath)) {
+          return this.serveFile(publicPath);
+        }
+      }
+    }
+    return null;
+  }
+  async serveBuiltFile(pathname) {
+    const filePath = pathname.slice(1);
+    for (const pkg of this.packages) {
+      const builtPath = join(pkg.outputDir, filePath);
+      if (existsSync(builtPath)) {
+        return this.serveFile(builtPath);
+      }
+    }
+    return null;
+  }
+  async serveFile(filePath) {
+    try {
+      if (!existsSync(filePath)) {
+        return null;
+      }
+      const content = readFileSync(filePath);
+      const ext = extname(filePath);
+      const contentType = this.getContentType(ext);
+      return new Response(content, {
+        headers: { "Content-Type": contentType }
+      });
+    } catch (error) {
+      await relinka.error(`Error serving file ${filePath}: ${error}`);
+      return null;
+    }
+  }
+  getContentType(ext) {
+    const types = {
+      ".html": "text/html",
+      ".js": "application/javascript",
+      ".mjs": "application/javascript",
+      ".css": "text/css",
+      ".json": "application/json",
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".gif": "image/gif",
+      ".svg": "image/svg+xml",
+      ".webp": "image/webp",
+      ".ico": "image/x-icon",
+      ".woff": "font/woff",
+      ".woff2": "font/woff2",
+      ".ttf": "font/ttf",
+      ".eot": "application/vnd.ms-fontobject"
+    };
+    return types[ext] || "application/octet-stream";
+  }
+  generateFallbackHtml() {
+    const title = this.packages.length === 1 ? this.packages[0]?.name || "Frontend App" : "Frontend App";
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>${title}</title>
+    <style>
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            margin: 0;
+            padding: 2rem;
+            background: #f5f5f5;
+        }
+        .container {
+            max-width: 800px;
+            margin: 0 auto;
+            background: white;
+            padding: 2rem;
+            border-radius: 8px;
+            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+        }
+        h1 { color: #333; }
+        p { color: #666; line-height: 1.6; }
+        .status { 
+            background: #e8f5e8; 
+            color: #2d5a2d; 
+            padding: 1rem; 
+            border-radius: 4px; 
+            margin: 1rem 0;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>${title}</h1>
+        <div class="status">
+            \u2705 Dev server is running successfully!
+        </div>
+        <p>This is a fallback page. To customize this page:</p>
+        <ul>
+            <li>Add an <code>index.html</code> file to your project root</li>
+            <li>Or add HTML files to your <code>public/</code> directory</li>
+            <li>Or configure entry points in your <code>package.json</code></li>
+        </ul>
+        <p>Hot Module Replacement (HMR) is enabled for development.</p>
+    </div>
+    <script>
+        // Basic HMR client
+        if (typeof WebSocket !== 'undefined') {
+            const ws = new WebSocket('ws://${this.config.host}:${this.config.port}');
+            ws.onmessage = (event) => {
+                if (event.data === 'reload') {
+                    window.location.reload();
+                }
+            };
+        }
+    <\/script>
+</body>
+</html>`;
+  }
+  async startFileWatching() {
+    for (const pkg of this.packages) {
+      if (pkg.entryPoints.length === 0) continue;
+      const sourceFiles = pkg.entryPoints.filter((ep) => !ep.endsWith(".html"));
+      for (const file of sourceFiles) {
+        if (existsSync(file)) {
+          await this.watchFile(file, pkg);
+        }
+      }
+      const htmlFiles = pkg.entryPoints.filter((ep) => ep.endsWith(".html"));
+      for (const file of htmlFiles) {
+        if (existsSync(file)) {
+          await this.watchFile(file, pkg);
+        }
+      }
+      const srcDir = join(pkg.path, "src");
+      if (existsSync(srcDir) && statSync(srcDir).isDirectory()) {
+        await this.watchDirectory(srcDir, pkg);
+      }
+    }
+    await relinka.info("\u{1F440} File watching started for HMR");
+  }
+  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) {
+    void relinka.info(`\u{1F4DD} File changed: ${filePath}`);
+    this.rebuildQueue.add(pkg.name);
+  }
+  handleHMRMessage(ws, message) {
+    try {
+      const data = JSON.parse(message.toString());
+      switch (data.type) {
+        case "ping":
+          ws.send(JSON.stringify({ type: "pong" }));
+          break;
+        case "reload":
+          this.notifyClients("reload");
+          break;
+      }
+    } catch (_error) {
+    }
+  }
+  notifyClients(type, data) {
+    if (this.server?.publish) {
+      const message = JSON.stringify({ type, data, timestamp: Date.now() });
+      this.server.publish("hmr", message);
+    }
+  }
+}
+export async function startDevServer(packages, options, devServerOptions) {
+  const server = new DevServer(packages, options, devServerOptions);
+  await server.start();
+  return server;
+}

package/dist/impl/dts-generator.d.ts

@@ -0,0 +1,26 @@
+import type { DtsOptions } from "@reliverse/config/impl/build";
+import type { PackageInfo } from "./types.js";
+export interface DtsGeneratorOptions {
+    /** Package information */
+    package: PackageInfo;
+    /** DTS configuration options */
+    dtsOptions: DtsOptions;
+    /** Build format (esm, cjs, iife) */
+    format?: "esm" | "cjs" | "iife";
+    /** Output directory for built files */
+    outputDir: string;
+}
+export interface DtsGeneratorResult {
+    success: boolean;
+    outputDir?: string;
+    error?: string;
+    files?: string[];
+}
+/**
+ * Generate TypeScript declaration files using Rslib's recommended approach
+ */
+export declare function generateDeclarations(options: DtsGeneratorOptions): Promise<DtsGeneratorResult>;
+/**
+ * Generate declarations with experimental tsgo
+ */
+export declare function generateWithTsgo(pkg: PackageInfo, dtsOptions: DtsOptions, outputDir: string): Promise<DtsGeneratorResult>;