@reliverse/build 2.2.9 → 2.3.2

package/dist/impl/cache.js

@@ -124,7 +124,7 @@ export class BuildCache {
       }
       this.hits++;
       return entry;
-    } catch (_error) {
+    } catch {
       this.misses++;
       return null;
     }
@@ -145,7 +145,7 @@ export class BuildCache {
       };
       const cacheFilePath = this.getCacheFilePath(key);
       writeFileSync(cacheFilePath, JSON.stringify(entry, null, 2));
-    } catch (_error) {
+    } catch {
     }
   }
   delete(key) {
@@ -158,7 +158,7 @@ export class BuildCache {
         const fs = require("node:fs");
         fs.unlinkSync(cacheFilePath);
       }
-    } catch (_error) {
+    } catch {
     }
   }
   clear() {
@@ -176,7 +176,7 @@ export class BuildCache {
           }
         }
       }
-    } catch (_error) {
+    } catch {
     }
   }
   getStats() {
@@ -202,7 +202,7 @@ export class BuildCache {
         misses: this.misses,
         size: totalSize
       };
-    } catch (_error) {
+    } catch {
       return { hits: this.hits, misses: this.misses, size: 0 };
     }
   }

package/dist/impl/constants.d.ts

@@ -25,11 +25,11 @@ export declare const FRONTEND_HTML_PATTERNS: readonly ["index.html", "public/ind
 /**
  * Common JavaScript/TypeScript entry point patterns
  */
-export declare const JS_ENTRY_PATTERNS: readonly ["src/main.ts", "src/main.js", "src/index.ts", "src/index.js", "main.ts", "main.js", "index.ts", "index.js"];
+export declare const JS_ENTRY_PATTERNS: readonly ["src/main.ts", "src/main.js", "src/mod.ts", "src/index.js", "main.ts", "main.js", "index.ts", "index.js"];
 /**
  * Common library entry point patterns
  */
-export declare const LIBRARY_ENTRY_PATTERNS: readonly ["src/index.ts", "src/mod.ts", "index.ts", "src/index.js", "src/mod.js", "index.js"];
+export declare const LIBRARY_ENTRY_PATTERNS: readonly ["src/mod.ts", "src/mod.ts", "index.ts", "src/index.js", "src/mod.js", "index.js"];
 /**
  * Common Go project directories
  */

package/dist/impl/constants.js

@@ -13,7 +13,7 @@ export const FRONTEND_HTML_PATTERNS = [
 export const JS_ENTRY_PATTERNS = [
   "src/main.ts",
   "src/main.js",
-  "src/index.ts",
+  "src/mod.ts",
   "src/index.js",
   "main.ts",
   "main.js",
@@ -21,7 +21,7 @@ export const JS_ENTRY_PATTERNS = [
   "index.js"
 ];
 export const LIBRARY_ENTRY_PATTERNS = [
-  "src/index.ts",
+  "src/mod.ts",
   "src/mod.ts",
   "index.ts",
   "src/index.js",

package/dist/impl/dev-server.js

@@ -343,7 +343,7 @@ export class DevServer {
           this.notifyClients("reload");
           break;
       }
-    } catch (_error) {
+    } catch {
     }
   }
   notifyClients(type, data) {

package/dist/impl/html-processor.js

@@ -144,7 +144,7 @@ export class HTMLProcessor {
           }
         }
       }
-    } catch (_error) {
+    } catch {
     }
     return files;
   }

package/dist/impl/types.d.ts

@@ -57,6 +57,7 @@ export interface BuildOptions {
     watch?: boolean;
     bundler?: "bun" | "mkdist";
     target?: "browser" | "bun" | "node";
+    targets?: string | string[];
     format?: "esm" | "cjs" | "iife";
     minify?: boolean | MinifyOptions;
     minifyWhitespace?: boolean;
@@ -142,6 +143,11 @@ export interface BuildOptions {
     filter?: string | string[];
     goOnly?: boolean;
     tsOnly?: boolean;
+    compress?: boolean;
+    entry?: string | string[];
+    outdir?: string;
+    outfile?: string;
+    runtime?: "bun" | "node";
 }
 export interface CacheEntry {
     hash: string;

package/dist/mod.d.ts

@@ -1,7 +1,7 @@
 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 { 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";

package/dist/mod.js

@@ -48,7 +48,7 @@ import {
   SVGAsReactPlugin,
   TypeScriptDeclarationsPlugin,
   WorkerPlugin
-} from "./impl/plugins/index.js";
+} from "./impl/plugins/mod.js";
 import { validateTSConfig } from "./impl/tsconfig-validator.js";
 import { validateBuildConfig } from "./impl/type-guards.js";
 import {
@@ -402,57 +402,94 @@ const compileToExecutable = async (pkg, _outputs, options) => {
     await relinka.warn(`\u26A0\uFE0F  ${pkg.name}: No entry point found for compilation`);
     return;
   }
-  const executableName = entryPoint.split("/").pop()?.split("\\").pop()?.replace(/\.(ts|js|mjs|cjs)$/, "") || "app";
-  const executablePath = join(
-    pkg.outputDir,
-    executableName + (process.platform === "win32" ? ".exe" : "")
-  );
-  if (!existsSync(pkg.outputDir)) {
-    mkdirSync(pkg.outputDir, { recursive: true });
+  let targets = [];
+  if (options.targets) {
+    const targetsInput = Array.isArray(options.targets) ? options.targets : [options.targets];
+    for (const target of targetsInput) {
+      if (target === "all") {
+        targets.push("darwin-arm64", "darwin-x64", "linux-arm64", "linux-x64", "windows-x64");
+      } else if (target === "native") {
+        const platform = process.platform === "darwin" ? "darwin" : process.platform === "win32" ? "windows" : "linux";
+        const arch = process.arch === "arm64" ? "arm64" : "x64";
+        targets.push(`${platform}-${arch}`);
+      } else {
+        targets.push(target);
+      }
+    }
+    targets = [...new Set(targets)];
+  } else {
+    const platform = process.platform === "darwin" ? "darwin" : process.platform === "win32" ? "windows" : "linux";
+    const arch = process.arch === "arm64" ? "arm64" : "x64";
+    targets = [`${platform}-${arch}`];
   }
-  await relinka.info(
-    `\u{1F528} Compiling ${pkg.name} to executable: ${executablePath}`
-  );
-  try {
-    const buildConfig = {
-      entrypoints: [entryPoint],
-      outfile: executablePath,
-      compile: true,
-      target: options.target || "bun",
-      format: options.format || "cjs"
-    };
-    if (process.platform === "win32") {
-      if (options.windowsHideConsole)
-        buildConfig.windowsHideConsole = options.windowsHideConsole;
-      if (options.windowsIcon) buildConfig.windowsIcon = options.windowsIcon;
-      if (options.windowsTitle) buildConfig.windowsTitle = options.windowsTitle;
-      if (options.windowsPublisher)
-        buildConfig.windowsPublisher = options.windowsPublisher;
-      if (options.windowsVersion)
-        buildConfig.windowsVersion = options.windowsVersion;
-      if (options.windowsDescription)
-        buildConfig.windowsDescription = options.windowsDescription;
-      if (options.windowsCopyright)
-        buildConfig.windowsCopyright = options.windowsCopyright;
-    }
-    const { $ } = await import("bun");
+  const isMultiTarget = targets.length > 1;
+  const { $ } = await import("bun");
+  for (const platform of targets) {
+    const shouldCreateSubdir = isMultiTarget;
+    const targetDir = shouldCreateSubdir ? join(pkg.outputDir, platform) : pkg.outputDir;
+    if (!existsSync(targetDir)) {
+      mkdirSync(targetDir, { recursive: true });
+    }
+    const ext = entryPoint.split(".").pop() || "";
+    const nameWithoutExt = ext ? entryPoint.slice(0, -ext.length - 1) : entryPoint;
+    const baseName = nameWithoutExt.split("/").pop()?.split("\\").pop() || "app";
+    const isWindows = platform.includes("windows");
+    const executableName = isWindows ? `${baseName}.exe` : baseName;
+    const executablePath = join(targetDir, executableName);
+    await relinka.info(
+      `\u{1F528} Compiling ${pkg.name} for ${platform}: ${executablePath}`
+    );
     try {
-      const cmd = $`bun build ${entryPoint} --outfile ${executablePath} --compile --target ${buildConfig.target || "bun"}`;
-      await cmd.cwd(pkg.path).quiet();
+      const compileArgs = [
+        "build",
+        entryPoint,
+        "--compile",
+        "--outfile",
+        executablePath,
+        "--target",
+        `bun-${platform}`
+        // Bun requires the bun- prefix
+      ];
+      if (options.minify ?? true) {
+        compileArgs.push("--minify");
+      }
+      if (options.sourcemap ?? false) {
+        compileArgs.push("--sourcemap");
+      }
+      if (options.bytecode) {
+        compileArgs.push("--bytecode");
+      }
+      if (options.external) {
+        const externals = Array.isArray(options.external) ? options.external : [options.external];
+        for (const ext2 of externals) {
+          compileArgs.push("--external", ext2);
+        }
+      }
+      const result = await $`bun ${compileArgs}`.cwd(pkg.path).quiet();
+      if (result.exitCode !== 0) {
+        throw new Error(`Compilation failed for ${platform}`);
+      }
+      if (!existsSync(executablePath)) {
+        throw new Error(`Executable was not created at ${executablePath}`);
+      }
+      const stats = statSync(executablePath);
+      await relinka.success(
+        `\u2705 ${pkg.name} (${platform}): Executable created (${formatBytes(stats.size)})`
+      );
     } catch (error) {
-      await relinka.error(`\u274C Bun CLI compilation failed: ${error}`);
+      await relinka.error(`\u274C ${pkg.name} (${platform}): Compilation failed - ${error}`);
       throw error;
     }
-    if (!existsSync(executablePath)) {
-      throw new Error(`Executable was not created at ${executablePath}`);
+  }
+  if (options.compress && isMultiTarget) {
+    await relinka.info(`\u{1F4E6} Compressing builds for ${pkg.name}...`);
+    for (const platform of targets) {
+      const platformDir = join(pkg.outputDir, platform);
+      if (existsSync(platformDir)) {
+        await $`cd ${pkg.outputDir} && tar -czf ${platform}.tar.gz ${platform}`.quiet();
+        await $`rm -rf ${platformDir}`.quiet();
+      }
     }
-    const stats = statSync(executablePath);
-    await relinka.success(
-      `\u2705 ${pkg.name}: Executable created (${formatBytes(stats.size)})`
-    );
-  } catch (error) {
-    await relinka.error(`\u274C ${pkg.name}: Compilation failed - ${error}`);
-    throw error;
   }
 };
 const buildWithMkdist = async (pkg, options, _bunBuildConfig) => {
@@ -758,7 +795,11 @@ export const buildPackage = async (pkg, options = {}, cache) => {
   }
   debugLogger.logConfigResolution(pkg, pkg.buildConfig ? "dler" : "default");
   debugLogger.logBuildOptions(mergedOptions, pkg);
-  debugLogger.logEntryPoints(pkg);
+  const entryPoints = mergedOptions.entry ? (Array.isArray(mergedOptions.entry) ? mergedOptions.entry : [mergedOptions.entry]).map(
+    (ep) => resolve(pkg.path, ep)
+  ) : pkg.entryPoints;
+  const outputDir = mergedOptions.outdir ? resolve(pkg.path, mergedOptions.outdir) : pkg.outputDir;
+  debugLogger.logEntryPoints({ ...pkg, entryPoints });
   const startTime = Date.now();
   try {
     const validation = validateBuildConfig(mergedOptions);
@@ -768,8 +809,8 @@ export const buildPackage = async (pkg, options = {}, cache) => {
       );
     }
     const buildConfig = {
-      entrypoints: pkg.entryPoints,
-      outdir: pkg.outputDir,
+      entrypoints: entryPoints,
+      outdir: outputDir,
       target: validTarget,
       format: validFormat,
       sourcemap: validSourcemap,
@@ -1022,7 +1063,12 @@ export const buildPackage = async (pkg, options = {}, cache) => {
       });
     }
     if (mergedOptions.compile && result.success && result.outputs) {
-      await compileToExecutable(pkg, result.outputs, mergedOptions);
+      const modifiedPkg = {
+        ...pkg,
+        entryPoints,
+        outputDir
+      };
+      await compileToExecutable(modifiedPkg, result.outputs, mergedOptions);
     }
     if (result.success) {
       try {

package/package.json

@@ -1,9 +1,14 @@
 {
   "name": "@reliverse/build",
+  "version": "2.3.2",
+  "private": false,
   "description": "Build utils for Reliverse ecosystem",
+  "license": "MIT",
   "author": "reliverse",
-  "version": "2.2.9",
-  "private": false,
+  "files": [
+    "dist",
+    "package.json"
+  ],
   "type": "module",
   "exports": {
     ".": {
@@ -11,13 +16,16 @@
       "default": "./dist/mod.js"
     }
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "dependencies": {
-    "@reliverse/config": "2.2.9",
-    "@reliverse/helpers": "2.2.13",
-    "@reliverse/relinka": "2.2.9",
-    "@reliverse/mapkit": "2.2.9",
-    "@reliverse/matcha": "2.2.9",
-    "@reliverse/typerso": "2.2.9",
+    "@reliverse/config": "2.3.2",
+    "@reliverse/helpers": "2.3.2",
+    "@reliverse/mapkit": "2.3.2",
+    "@reliverse/matcha": "2.3.2",
+    "@reliverse/relinka": "2.3.2",
+    "@reliverse/typerso": "2.3.2",
     "autoprefixer": "^10.4.23",
     "c12": "^3.3.3",
     "cssnano": "^7.1.2",
@@ -30,13 +38,5 @@
     "pkg-types": "^2.3.0",
     "semver": "^7.7.3",
     "tinyglobby": "^0.2.15"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "files": [
-    "dist",
-    "package.json"
-  ],
-  "license": "MIT"
+  }
 }