@reliverse/build 2.2.7

package/dist/impl/go-build.js

@@ -0,0 +1,350 @@
+import { existsSync } from "node:fs";
+import { mkdir, readdir, rename, stat } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { logger } from "@reliverse/relinka";
+import { lookpath } from "lookpath";
+const DEFAULT_TARGETS = [
+  ["windows", "amd64", "dll", "win32"],
+  ["linux", "amd64", "so", "linux"],
+  ["linux", "arm64", "so", "linux"],
+  ["darwin", "amd64", "dylib", "darwin"],
+  ["darwin", "arm64", "dylib", "darwin"]
+];
+async function checkDockerAvailable() {
+  const dockerPath = await lookpath("docker");
+  if (!dockerPath) {
+    return {
+      available: false,
+      reason: "Docker is not installed or not in PATH"
+    };
+  }
+  try {
+    const proc = Bun.spawnSync(["docker", "version"], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    if (proc.exitCode !== 0) {
+      const stderr = proc.stderr?.toString() || "";
+      if (stderr.includes("Cannot connect to the Docker daemon") || stderr.includes("Is the docker daemon running") || stderr.includes("dockerDesktopLinuxEngine") || stderr.includes("The system cannot find the file specified")) {
+        return {
+          available: false,
+          reason: "Docker daemon is not running"
+        };
+      }
+      return {
+        available: false,
+        reason: `Docker check failed: ${stderr.trim()}`
+      };
+    }
+    return { available: true };
+  } catch (error) {
+    return {
+      available: false,
+      reason: `Error checking Docker: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function findGoFiles(dir, goFiles = []) {
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === "node_modules" || entry.name === "release" || entry.name === "dist" || entry.name === ".git") {
+          continue;
+        }
+        await findGoFiles(fullPath, goFiles);
+      } else if (entry.isFile() && entry.name.endsWith(".go")) {
+        goFiles.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return goFiles;
+}
+function getExpectedBinaryName(target, outputName) {
+  const [goos, goarch] = target.split("/");
+  let platformName = goos;
+  let suffix = "";
+  if (goos === "windows") {
+    platformName = "win32";
+    suffix = ".dll";
+  } else if (goos === "linux") {
+    platformName = "linux";
+    suffix = ".so";
+  } else if (goos === "darwin") {
+    platformName = "darwin";
+    suffix = ".dylib";
+  }
+  return `${outputName}-${platformName}-${goarch}${suffix}`;
+}
+async function shouldRebuildGo(packagePath, targets, outputDir, outputName) {
+  const releasePath = path.join(packagePath, outputDir);
+  if (!existsSync(releasePath)) {
+    return { rebuild: true, reason: "Release directory does not exist" };
+  }
+  try {
+    const goFiles = await findGoFiles(packagePath);
+    goFiles.push(path.join(packagePath, "go.mod"));
+    const goSumPath = path.join(packagePath, "go.sum");
+    if (existsSync(goSumPath)) {
+      goFiles.push(goSumPath);
+    }
+    let newestGoFileTime = 0;
+    for (const goFile of goFiles) {
+      if (existsSync(goFile)) {
+        const stats = await stat(goFile);
+        if (stats.mtimeMs > newestGoFileTime) {
+          newestGoFileTime = stats.mtimeMs;
+        }
+      }
+    }
+    const missingBinaries = [];
+    const outdatedBinaries = [];
+    for (const target of targets) {
+      const expectedBinary = getExpectedBinaryName(target, outputName);
+      let binaryPath = path.join(releasePath, expectedBinary);
+      if (target.startsWith("windows/") && !existsSync(binaryPath)) {
+        const windowsBinary = expectedBinary.replace("win32", "windows");
+        const windowsPath = path.join(releasePath, windowsBinary);
+        if (existsSync(windowsPath)) {
+          binaryPath = windowsPath;
+        } else {
+          const windows4Binary = expectedBinary.replace("win32", "windows-4.0");
+          const windows4Path = path.join(releasePath, windows4Binary);
+          if (existsSync(windows4Path)) {
+            binaryPath = windows4Path;
+          }
+        }
+      }
+      if (!existsSync(binaryPath)) {
+        missingBinaries.push(target);
+        continue;
+      }
+      const binaryStats = await stat(binaryPath);
+      if (binaryStats.mtimeMs < newestGoFileTime) {
+        outdatedBinaries.push(target);
+      }
+    }
+    if (missingBinaries.length > 0) {
+      return {
+        rebuild: true,
+        reason: `Missing Go binaries for: ${missingBinaries.join(", ")}`
+      };
+    }
+    if (outdatedBinaries.length > 0) {
+      return {
+        rebuild: true,
+        reason: `Outdated Go binaries for: ${outdatedBinaries.join(", ")}`
+      };
+    }
+    return { rebuild: false, reason: "All Go binaries are up-to-date" };
+  } catch (error) {
+    return {
+      rebuild: true,
+      reason: `Error checking Go binaries: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function buildGoTarget(packagePath, goos, goarch, suffix, platformName, outputName, outputDir, buildMode, ldflags, mainFile) {
+  const outputFileName = `${outputName}-${platformName}-${goarch}.${suffix}`;
+  const outputPath = path.join(packagePath, outputDir, outputFileName);
+  const releasePath = path.join(packagePath, outputDir);
+  if (!existsSync(releasePath)) {
+    await mkdir(releasePath, { recursive: true });
+  }
+  logger.info(`Building for ${goos}/${goarch}...`);
+  const env = {
+    ...process.env,
+    GOOS: goos,
+    GOARCH: goarch,
+    CGO_ENABLED: "1"
+  };
+  const proc = Bun.spawnSync(
+    [
+      "go",
+      "build",
+      `-buildmode=${buildMode}`,
+      `-ldflags=${ldflags}`,
+      "-o",
+      outputPath,
+      mainFile
+    ],
+    {
+      env,
+      cwd: packagePath
+    }
+  );
+  if (proc.exitCode !== 0) {
+    logger.error(`Failed to build for ${goos}/${goarch}`);
+    if (proc.stderr) {
+      logger.error(proc.stderr.toString());
+    }
+    return false;
+  }
+  logger.success(`\u2713 Built ${outputFileName}`);
+  return true;
+}
+async function buildWithXgo(packagePath, config, outputName) {
+  const xgoBase = path.join(os.homedir(), "go/bin/xgo");
+  const XGO = os.platform() === "win32" ? `${xgoBase}.exe` : xgoBase;
+  let targets;
+  if (config.targets) {
+    targets = Array.isArray(config.targets) ? config.targets.join(",") : config.targets;
+  } else {
+    targets = "linux/arm64,linux/amd64,darwin/arm64,darwin/amd64,windows/amd64";
+  }
+  const outputDir = config.outputDir ?? "release";
+  const releasePath = path.join(packagePath, outputDir);
+  const targetsArray = targets.split(",").map((t) => t.trim());
+  const rebuildCheck = await shouldRebuildGo(
+    packagePath,
+    targetsArray,
+    outputDir,
+    outputName
+  );
+  if (!rebuildCheck.rebuild) {
+    logger.info(`\u2713 ${rebuildCheck.reason}, skipping rebuild`);
+    return { success: true, errors: [] };
+  }
+  if (rebuildCheck.reason) {
+    logger.info(`Rebuilding: ${rebuildCheck.reason}`);
+  }
+  if (!existsSync(XGO)) {
+    const error = `xgo not found at ${XGO}. Please install: go install github.com/crazy-max/xgo@latest`;
+    logger.error(`Error: ${error}`);
+    return { success: false, errors: [error] };
+  }
+  const dockerCheck = await checkDockerAvailable();
+  if (!dockerCheck.available) {
+    logger.warn(
+      `\u26A0\uFE0F  Skipping Go build: Docker is not installed or not running. Install Docker Desktop and ensure it's running to build Go binaries.`
+    );
+    return { success: true, errors: [] };
+  }
+  logger.info("Compiling native binaries with xgo...");
+  const buildMode = config.buildMode ?? "c-shared";
+  const ldflags = config.ldflags ?? "-s -w";
+  const goVersion = config.goVersion ?? "1.20.3";
+  if (!existsSync(releasePath)) {
+    await mkdir(releasePath, { recursive: true });
+  }
+  const outPath = `${outputDir}/${outputName}`;
+  const proc = Bun.spawnSync(
+    [
+      XGO,
+      "-go",
+      goVersion,
+      "-out",
+      outPath,
+      `--targets=${targets}`,
+      `-ldflags=${ldflags}`,
+      `-buildmode=${buildMode}`,
+      "."
+    ],
+    {
+      cwd: packagePath
+    }
+  );
+  if (proc.stdout) {
+    logger.info(proc.stdout.toString());
+  }
+  if (proc.exitCode !== 0) {
+    const error = "xgo compilation failed";
+    logger.error(error);
+    if (proc.stderr) {
+      const stderr = proc.stderr.toString();
+      logger.error(stderr);
+      return { success: false, errors: [error, stderr] };
+    }
+    return { success: false, errors: [error] };
+  }
+  if (existsSync(releasePath)) {
+    const binaries = await readdir(releasePath);
+    const windowsBinaries = binaries.filter(
+      (binary) => binary.includes("windows") && !binary.includes("win32")
+    );
+    await Promise.all(
+      windowsBinaries.map((binary) => {
+        const binaryPath = path.join(releasePath, binary);
+        const newPath = binaryPath.replace(/windows(-4\.0)?/g, "win32");
+        return rename(binaryPath, newPath);
+      })
+    );
+  }
+  return { success: true, errors: [] };
+}
+async function buildWithNative(packagePath, config, outputName) {
+  logger.info("Compiling native binaries with native Go build...");
+  const outputDir = config.outputDir ?? "release";
+  const buildMode = config.buildMode ?? "c-shared";
+  const ldflags = config.ldflags ?? "-s -w";
+  const mainFile = config.mainFile ?? "main.go";
+  const currentPlatform = os.platform();
+  let targetsToBuild = [...DEFAULT_TARGETS];
+  if (currentPlatform === "win32") {
+    targetsToBuild = targetsToBuild.filter(([goos]) => goos === "windows");
+    logger.info(
+      "Building only for Windows (CGO cross-compilation from Windows requires special setup)"
+    );
+  }
+  if (config.targets) {
+    const targetSet = new Set(
+      Array.isArray(config.targets) ? config.targets : [config.targets]
+    );
+    targetsToBuild = targetsToBuild.filter(
+      ([goos, goarch]) => targetSet.has(`${goos}/${goarch}`)
+    );
+  }
+  const results = await Promise.all(
+    targetsToBuild.map(
+      ([goos, goarch, suffix, platformName]) => buildGoTarget(
+        packagePath,
+        goos,
+        goarch,
+        suffix,
+        platformName,
+        outputName,
+        outputDir,
+        buildMode,
+        ldflags,
+        mainFile
+      ).catch((err) => {
+        logger.error(
+          `Error building ${goos}/${goarch}: ${err instanceof Error ? err.message : String(err)}`
+        );
+        return false;
+      })
+    )
+  );
+  const successCount = results.filter((r) => r === true).length;
+  const failCount = results.filter((r) => r === false).length;
+  logger.info(
+    `
+Build complete: ${successCount} succeeded, ${failCount} failed`
+  );
+  if (successCount === 0) {
+    const error = "No targets built successfully";
+    logger.error(error);
+    return { success: false, errors: [error] };
+  }
+  return { success: true, errors: [] };
+}
+export async function buildGo(packagePath, packageName, config) {
+  if (config?.enable === false) {
+    return { success: true, errors: [] };
+  }
+  const effectiveConfig = config ?? { enable: true };
+  const outputName = effectiveConfig.outputName ?? packageName.replace(/^@[^/]+\//, "").replace(/[^a-zA-Z0-9-]/g, "-");
+  const provider = effectiveConfig.provider ?? "xgo";
+  if (provider !== "xgo" && provider !== "native") {
+    const error = `Invalid provider "${provider}". Must be "xgo" or "native".`;
+    logger.error(`Error: ${error}`);
+    return { success: false, errors: [error] };
+  }
+  if (provider === "xgo") {
+    return buildWithXgo(packagePath, effectiveConfig, outputName);
+  }
+  return buildWithNative(packagePath, effectiveConfig, outputName);
+}

package/dist/impl/html-processor.d.ts

@@ -0,0 +1,21 @@
+import type { PackageInfo } from "./types.js";
+export interface HTMLProcessorOptions {
+    minify?: boolean;
+    injectAssets?: boolean;
+    publicPath?: string;
+}
+export declare class HTMLProcessor {
+    private options;
+    constructor(options?: HTMLProcessorOptions);
+    processHTML(pkg: PackageInfo, outputDir: string): Promise<void>;
+    private processHTMLFile;
+    private processScriptTags;
+    private processLinkTags;
+    private injectBuiltAssets;
+    private findBuiltAsset;
+    private findBuiltFiles;
+    private getRelativePath;
+    private getRelativePathFromOutput;
+    private minifyHTML;
+}
+export declare function processHTMLForPackage(pkg: PackageInfo, outputDir: string, options?: HTMLProcessorOptions): Promise<void>;

package/dist/impl/html-processor.js

@@ -0,0 +1,167 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { logger } from "@reliverse/relinka";
+export class HTMLProcessor {
+  options;
+  constructor(options = {}) {
+    this.options = {
+      minify: false,
+      injectAssets: true,
+      publicPath: "/",
+      ...options
+    };
+  }
+  async processHTML(pkg, outputDir) {
+    const htmlFiles = pkg.entryPoints.filter((ep) => ep.endsWith(".html"));
+    if (htmlFiles.length === 0) {
+      return;
+    }
+    for (const htmlFile of htmlFiles) {
+      await this.processHTMLFile(htmlFile, outputDir);
+    }
+  }
+  async processHTMLFile(htmlPath, outputDir) {
+    try {
+      const content = readFileSync(htmlPath, "utf-8");
+      let processedContent = content;
+      processedContent = await this.processScriptTags(
+        processedContent,
+        htmlPath,
+        outputDir
+      );
+      processedContent = await this.processLinkTags(
+        processedContent,
+        htmlPath,
+        outputDir
+      );
+      if (this.options.injectAssets) {
+        processedContent = await this.injectBuiltAssets(
+          processedContent,
+          outputDir
+        );
+      }
+      if (this.options.minify) {
+        processedContent = this.minifyHTML(processedContent);
+      }
+      const outputFileName = basename(htmlPath);
+      const outputPath = join(outputDir, outputFileName);
+      writeFileSync(outputPath, processedContent, "utf-8");
+      logger.info(`\u{1F4C4} Processed HTML: ${htmlPath} \u2192 ${outputPath}`);
+    } catch (error) {
+      logger.error(`Failed to process HTML file ${htmlPath}: ${error}`);
+    }
+  }
+  async processScriptTags(content, htmlPath, outputDir) {
+    const scriptRegex = /<script[^>]*src=["']([^"']+)["'][^>]*><\/script>/g;
+    return content.replace(scriptRegex, (match, src) => {
+      if (src.startsWith("./") || src.startsWith("../") || src.startsWith("/")) {
+        const scriptPath = resolve(dirname(htmlPath), src);
+        const builtScriptPath = this.findBuiltAsset(scriptPath, outputDir, [
+          ".js",
+          ".mjs"
+        ]);
+        if (builtScriptPath) {
+          const relativePath = this.getRelativePath(htmlPath, builtScriptPath);
+          return match.replace(src, relativePath);
+        }
+      }
+      return match;
+    });
+  }
+  async processLinkTags(content, htmlPath, outputDir) {
+    const linkRegex = /<link[^>]*href=["']([^"']+)["'][^>]*>/g;
+    return content.replace(linkRegex, (match, href) => {
+      if (href.startsWith("./") || href.startsWith("../") || href.startsWith("/")) {
+        const cssPath = resolve(dirname(htmlPath), href);
+        const builtCssPath = this.findBuiltAsset(cssPath, outputDir, [".css"]);
+        if (builtCssPath) {
+          const relativePath = this.getRelativePath(htmlPath, builtCssPath);
+          return match.replace(href, relativePath);
+        }
+      }
+      return match;
+    });
+  }
+  async injectBuiltAssets(content, outputDir) {
+    const jsFiles = this.findBuiltFiles(outputDir, [".js", ".mjs"]);
+    const cssFiles = this.findBuiltFiles(outputDir, [".css"]);
+    let injectedContent = content;
+    if (cssFiles.length > 0) {
+      const cssLinks = cssFiles.map((cssFile) => {
+        const relativePath = this.getRelativePathFromOutput(
+          cssFile,
+          outputDir
+        );
+        return `    <link rel="stylesheet" href="${relativePath}">`;
+      }).join("\n");
+      injectedContent = injectedContent.replace(
+        /<\/head>/i,
+        `${cssLinks}
+  </head>`
+      );
+    }
+    if (jsFiles.length > 0) {
+      const jsScripts = jsFiles.map((jsFile) => {
+        const relativePath = this.getRelativePathFromOutput(
+          jsFile,
+          outputDir
+        );
+        return `    <script src="${relativePath}"><\/script>`;
+      }).join("\n");
+      injectedContent = injectedContent.replace(
+        /<\/body>/i,
+        `${jsScripts}
+  </body>`
+      );
+    }
+    return injectedContent;
+  }
+  findBuiltAsset(originalPath, outputDir, extensions) {
+    const baseName = basename(
+      originalPath,
+      extensions.find((ext) => originalPath.endsWith(ext)) || ""
+    );
+    for (const ext of extensions) {
+      const possiblePath = join(outputDir, `${baseName}${ext}`);
+      if (existsSync(possiblePath)) {
+        return possiblePath;
+      }
+    }
+    return null;
+  }
+  findBuiltFiles(outputDir, extensions) {
+    const files = [];
+    try {
+      const { readdirSync, statSync } = require("node:fs");
+      const items = readdirSync(outputDir);
+      for (const item of items) {
+        const itemPath = join(outputDir, item);
+        const stats = statSync(itemPath);
+        if (stats.isFile()) {
+          const ext = extensions.find((e) => item.endsWith(e));
+          if (ext) {
+            files.push(itemPath);
+          }
+        }
+      }
+    } catch (_error) {
+    }
+    return files;
+  }
+  getRelativePath(fromPath, toPath) {
+    const fromDir = dirname(fromPath);
+    const relativePath = require("node:path").relative(fromDir, toPath);
+    return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+  }
+  getRelativePathFromOutput(filePath, outputDir) {
+    const relativePath = require("node:path").relative(outputDir, filePath);
+    return this.options.publicPath + relativePath.replace(/\\/g, "/");
+  }
+  minifyHTML(content) {
+    return content.replace(/\s+/g, " ").replace(/>\s+</g, "><").replace(/\s+>/g, ">").replace(/>\s+/g, ">").trim();
+  }
+}
+export async function processHTMLForPackage(pkg, outputDir, options = {}) {
+  const processor = new HTMLProcessor(options);
+  await processor.processHTML(pkg, outputDir);
+}

package/dist/impl/plugins/asset-optimization.d.ts

@@ -0,0 +1,2 @@
+import type { DlerPlugin } from "../types.js";
+export declare const AssetOptimizationPlugin: DlerPlugin;

package/dist/impl/plugins/asset-optimization.js

@@ -0,0 +1,114 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { extname, join } from "node:path";
+import { logger } from "@reliverse/relinka";
+export const AssetOptimizationPlugin = {
+  name: "asset-optimization",
+  setup: (buildConfig) => {
+    buildConfig.loader = {
+      ...buildConfig.loader,
+      ".png": "file",
+      ".jpg": "file",
+      ".jpeg": "file",
+      ".gif": "file",
+      ".svg": "file",
+      ".webp": "file",
+      ".ico": "file",
+      ".woff": "file",
+      ".woff2": "file",
+      ".ttf": "file",
+      ".eot": "file"
+    };
+    if (buildConfig.verbose) {
+      logger.debug("Asset optimization plugin applied");
+    }
+  },
+  onBuildEnd: async (result) => {
+    if (!result.success || result.skipped) {
+      return;
+    }
+    const pkg = result.package;
+    if (!pkg.isFrontendApp) {
+      return;
+    }
+    try {
+      await optimizeAssets(pkg);
+    } catch (error) {
+      logger.warn(`Failed to optimize assets for ${pkg.name}: ${error}`);
+    }
+  }
+};
+async function optimizeAssets(pkg) {
+  const outputDir = pkg.outputDir;
+  if (!existsSync(outputDir)) {
+    return;
+  }
+  const assetExtensions = [
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".svg",
+    ".webp",
+    ".ico",
+    ".woff",
+    ".woff2",
+    ".ttf",
+    ".eot"
+  ];
+  const assetFiles = [];
+  const glob = new Bun.Glob("**/*");
+  const files = Array.from(glob.scanSync({ cwd: outputDir, onlyFiles: true }));
+  for (const file of files) {
+    const ext = extname(file);
+    if (assetExtensions.includes(ext)) {
+      assetFiles.push(join(outputDir, file));
+    }
+  }
+  if (assetFiles.length === 0) {
+    return;
+  }
+  logger.info(`\u{1F5BC}\uFE0F  Optimizing ${assetFiles.length} assets for ${pkg.name}`);
+  for (const assetFile of assetFiles) {
+    try {
+      await optimizeAsset(assetFile);
+    } catch (error) {
+      logger.warn(`Failed to optimize asset ${assetFile}: ${error}`);
+    }
+  }
+}
+async function optimizeAsset(assetPath) {
+  const ext = extname(assetPath).toLowerCase();
+  switch (ext) {
+    case ".svg":
+      await optimizeSVG(assetPath);
+      break;
+    case ".png":
+    case ".jpg":
+    case ".jpeg":
+    case ".gif":
+    case ".webp":
+      await optimizeImage(assetPath);
+      break;
+    case ".woff":
+    case ".woff2":
+    case ".ttf":
+    case ".eot":
+      await optimizeFont(assetPath);
+      break;
+    default:
+      break;
+  }
+}
+async function optimizeSVG(svgPath) {
+  const content = readFileSync(svgPath, "utf-8");
+  let optimized = content.replace(/\s+/g, " ").replace(/>\s+</g, "><").replace(/\s+>/g, ">").replace(/>\s+/g, ">").trim();
+  optimized = optimized.replace(/<!--[\s\S]*?-->/g, "");
+  optimized = optimized.replace(/\s+(xmlns:xlink|xlink:href)="[^"]*"/g, "");
+  if (optimized !== content) {
+    writeFileSync(svgPath, optimized, "utf-8");
+  }
+}
+async function optimizeImage(_imagePath) {
+}
+async function optimizeFont(_fontPath) {
+}

package/dist/impl/plugins/bundle-analyzer.d.ts

@@ -0,0 +1,2 @@
+import type { DlerPlugin } from "../types.js";
+export declare const BundleAnalyzerPlugin: DlerPlugin;