@reliverse/build 2.2.7

package/dist/impl/plugins/bundle-analyzer.js

@@ -0,0 +1,156 @@
+import { existsSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { logger } from "@reliverse/relinka";
+export const BundleAnalyzerPlugin = {
+  name: "bundle-analyzer",
+  setup: (buildConfig) => {
+    if (buildConfig?.verbose) {
+      logger.debug("Bundle analyzer plugin registered");
+    }
+  },
+  onBuildEnd: async (result) => {
+    if (!result.success || result.skipped) {
+      return;
+    }
+    try {
+      await analyzeBundle(result);
+    } catch (error) {
+      logger.warn(
+        `Failed to analyze bundle for ${result.package.name}: ${error}`
+      );
+    }
+  }
+};
+async function analyzeBundle(result) {
+  const pkg = result.package;
+  const outputDir = pkg.outputDir;
+  if (!existsSync(outputDir)) {
+    return;
+  }
+  const glob = new Bun.Glob("**/*");
+  const files = Array.from(glob.scanSync({ cwd: outputDir, onlyFiles: true }));
+  const analysis = {
+    package: pkg.name,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    files: [],
+    totals: {
+      totalSize: 0,
+      totalFiles: 0,
+      jsFiles: 0,
+      cssFiles: 0,
+      assetFiles: 0
+    },
+    recommendations: []
+  };
+  for (const file of files) {
+    const filePath = join(outputDir, file);
+    const stats = statSync(filePath);
+    const ext = file.split(".").pop()?.toLowerCase() || "";
+    const fileInfo = {
+      name: file,
+      size: stats.size,
+      type: getFileType(ext)
+    };
+    analysis.files.push(fileInfo);
+    analysis.totals.totalSize += stats.size;
+    analysis.totals.totalFiles++;
+    if (ext === "js" || ext === "mjs") {
+      analysis.totals.jsFiles++;
+    } else if (ext === "css") {
+      analysis.totals.cssFiles++;
+    } else {
+      analysis.totals.assetFiles++;
+    }
+  }
+  analysis.files.sort((a, b) => b.size - a.size);
+  generateRecommendations(analysis);
+  const reportPath = join(outputDir, "bundle-analysis.json");
+  writeFileSync(reportPath, JSON.stringify(analysis, null, 2));
+  logger.info(`\u{1F4CA} Bundle analysis for ${pkg.name}:`);
+  logger.info(`   Total size: ${formatBytes(analysis.totals.totalSize)}`);
+  logger.info(
+    `   Files: ${analysis.totals.totalFiles} (${analysis.totals.jsFiles} JS, ${analysis.totals.cssFiles} CSS, ${analysis.totals.assetFiles} assets)`
+  );
+  if (analysis.files.length > 0) {
+    const largestFile = analysis.files[0];
+    if (largestFile) {
+      logger.info(
+        `   Largest file: ${largestFile.name} (${formatBytes(largestFile.size)})`
+      );
+    }
+  }
+  if (analysis.recommendations.length > 0) {
+    logger.info(`   Recommendations:`);
+    for (const rec of analysis.recommendations) {
+      logger.info(`     \u2022 ${rec}`);
+    }
+  }
+  logger.info(`   Report saved to: ${reportPath}`);
+}
+function getFileType(ext) {
+  const typeMap = {
+    js: "JavaScript",
+    mjs: "JavaScript (ESM)",
+    css: "CSS",
+    png: "Image (PNG)",
+    jpg: "Image (JPEG)",
+    jpeg: "Image (JPEG)",
+    gif: "Image (GIF)",
+    svg: "Image (SVG)",
+    webp: "Image (WebP)",
+    woff: "Font (WOFF)",
+    woff2: "Font (WOFF2)",
+    ttf: "Font (TTF)",
+    eot: "Font (EOT)",
+    html: "HTML",
+    json: "JSON",
+    txt: "Text"
+  };
+  return typeMap[ext] || "Unknown";
+}
+function generateRecommendations(analysis) {
+  const { totals, files } = analysis;
+  if (totals.totalSize > 1024 * 1024) {
+    analysis.recommendations.push(
+      "Bundle size is large (>1MB). Consider code splitting or removing unused code."
+    );
+  }
+  const largeFiles = files.filter((f) => f.size > 500 * 1024);
+  if (largeFiles.length > 0) {
+    analysis.recommendations.push(
+      `Large files detected: ${largeFiles.map((f) => f.name).join(", ")}. Consider optimizing or splitting.`
+    );
+  }
+  if (totals.totalFiles > 50) {
+    analysis.recommendations.push(
+      "Many files in bundle. Consider consolidating or using code splitting."
+    );
+  }
+  if (totals.jsFiles > 0 && totals.cssFiles > 0) {
+    const jsSize = files.filter((f) => f.type.includes("JavaScript")).reduce((sum, f) => sum + f.size, 0);
+    const cssSize = files.filter((f) => f.type.includes("CSS")).reduce((sum, f) => sum + f.size, 0);
+    if (cssSize > jsSize) {
+      analysis.recommendations.push(
+        "CSS is larger than JavaScript. Consider CSS optimization or purging unused styles."
+      );
+    }
+  }
+  const fileTypes = /* @__PURE__ */ new Map();
+  files.forEach((f) => {
+    fileTypes.set(f.type, (fileTypes.get(f.type) || 0) + 1);
+  });
+  for (const [type, count] of fileTypes) {
+    if (count > 10) {
+      analysis.recommendations.push(
+        `Many ${type} files (${count}). Consider consolidating.`
+      );
+    }
+  }
+}
+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]}`;
+}

package/dist/impl/plugins/css-modules.d.ts

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

package/dist/impl/plugins/css-modules.js

@@ -0,0 +1,19 @@
+import { logger } from "@reliverse/relinka";
+export const CSSModulesPlugin = {
+  name: "css-modules",
+  setup: (buildConfig) => {
+    buildConfig.loader = {
+      ...buildConfig.loader,
+      ".module.css": "file",
+      ".module.less": "file",
+      ".module.styl": "file"
+    };
+    if (!buildConfig.define) {
+      buildConfig.define = {};
+    }
+    buildConfig.define.__CSS_MODULES__ = "true";
+    if (buildConfig.verbose) {
+      logger.debug("CSS modules plugin applied");
+    }
+  }
+};

package/dist/impl/plugins/index.d.ts

@@ -0,0 +1,21 @@
+import type { BunBuildConfig, DlerPlugin } from "../types.js";
+export declare class PluginRegistry {
+    private plugins;
+    register(plugin: DlerPlugin, verbose?: boolean): void;
+    getPlugin(name: string): DlerPlugin | undefined;
+    getAllPlugins(): DlerPlugin[];
+    hasPlugin(name: string): boolean;
+    clear(): void;
+}
+export declare const pluginRegistry: PluginRegistry;
+export { AssetOptimizationPlugin } from "./asset-optimization.js";
+export { BundleAnalyzerPlugin } from "./bundle-analyzer.js";
+export { CSSModulesPlugin } from "./css-modules.js";
+export { PerformancePlugin } from "./performance.js";
+export { ReactRefreshPlugin } from "./react-refresh.js";
+export { SVGAsReactPlugin } from "./svg-as-react.js";
+export { TypeScriptDeclarationsPlugin } from "./typescript-declarations.js";
+export { WorkerPlugin } from "./worker.js";
+export declare function createPlugin(name: string, setup: (build: BunBuildConfig) => void): DlerPlugin;
+export declare function loadPlugins(pluginNames: string[]): DlerPlugin[];
+export declare function applyPlugins(plugins: DlerPlugin[], buildConfig: BunBuildConfig): void;

package/dist/impl/plugins/index.js

@@ -0,0 +1,65 @@
+import { logger } from "@reliverse/relinka";
+export class PluginRegistry {
+  plugins = /* @__PURE__ */ new Map();
+  register(plugin, verbose) {
+    if (this.plugins.has(plugin.name)) {
+      logger.warn(`Plugin ${plugin.name} is already registered`);
+      return;
+    }
+    this.plugins.set(plugin.name, plugin);
+    if (verbose) {
+      logger.debug(`Registered plugin: ${plugin.name}`);
+    }
+  }
+  getPlugin(name) {
+    return this.plugins.get(name);
+  }
+  getAllPlugins() {
+    return Array.from(this.plugins.values());
+  }
+  hasPlugin(name) {
+    return this.plugins.has(name);
+  }
+  clear() {
+    this.plugins.clear();
+  }
+}
+export const pluginRegistry = new PluginRegistry();
+export { AssetOptimizationPlugin } from "./asset-optimization.js";
+export { BundleAnalyzerPlugin } from "./bundle-analyzer.js";
+export { CSSModulesPlugin } from "./css-modules.js";
+export { PerformancePlugin } from "./performance.js";
+export { ReactRefreshPlugin } from "./react-refresh.js";
+export { SVGAsReactPlugin } from "./svg-as-react.js";
+export { TypeScriptDeclarationsPlugin } from "./typescript-declarations.js";
+export { WorkerPlugin } from "./worker.js";
+export function createPlugin(name, setup) {
+  return {
+    name,
+    setup
+  };
+}
+export function loadPlugins(pluginNames) {
+  const plugins = [];
+  for (const name of pluginNames) {
+    const plugin = pluginRegistry.getPlugin(name);
+    if (plugin) {
+      plugins.push(plugin);
+    } else {
+      logger.warn(`Plugin ${name} not found in registry`);
+    }
+  }
+  return plugins;
+}
+export function applyPlugins(plugins, buildConfig) {
+  for (const plugin of plugins) {
+    try {
+      plugin.setup(buildConfig);
+      if (buildConfig.verbose) {
+        logger.debug(`Applied plugin: ${plugin.name}`);
+      }
+    } catch (error) {
+      logger.error(`Failed to apply plugin ${plugin.name}: ${error}`);
+    }
+  }
+}

package/dist/impl/plugins/performance.d.ts

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

package/dist/impl/plugins/performance.js

@@ -0,0 +1,62 @@
+import { logger } from "@reliverse/relinka";
+export const PerformancePlugin = {
+  name: "performance",
+  setup: (buildConfig) => {
+    if (buildConfig?.verbose) {
+      logger.debug("Performance monitoring plugin registered");
+    }
+  },
+  onBuildEnd: async (result) => {
+    if (!result.success || result.skipped) {
+      return;
+    }
+    try {
+      await checkPerformanceBudgets(result);
+    } catch (error) {
+      logger.warn(
+        `Failed to check performance budgets for ${result.package.name}: ${error}`
+      );
+    }
+  }
+};
+async function checkPerformanceBudgets(result) {
+  const pkg = result.package;
+  const budget = pkg.buildConfig?.performanceBudget;
+  if (!budget) {
+    return;
+  }
+  const bundleSize = result.bundleSize || 0;
+  const warnings = [];
+  if (budget.maxBundleSize && bundleSize > budget.maxBundleSize) {
+    warnings.push(
+      `Bundle size ${formatBytes(bundleSize)} exceeds limit of ${formatBytes(budget.maxBundleSize)}`
+    );
+  }
+  if (budget.maxChunkSize && bundleSize > budget.maxChunkSize) {
+    warnings.push(
+      `Chunk size ${formatBytes(bundleSize)} exceeds limit of ${formatBytes(budget.maxChunkSize)}`
+    );
+  }
+  if (budget.maxAssetSize && bundleSize > budget.maxAssetSize) {
+    warnings.push(
+      `Asset size ${formatBytes(bundleSize)} exceeds limit of ${formatBytes(budget.maxAssetSize)}`
+    );
+  }
+  if (warnings.length > 0) {
+    logger.warn(`\u26A0\uFE0F  Performance budget exceeded for ${pkg.name}:`);
+    for (const warning of warnings) {
+      logger.warn(`   ${warning}`);
+    }
+  } else {
+    logger.info(
+      `\u2705 Performance budget met for ${pkg.name} (${formatBytes(bundleSize)})`
+    );
+  }
+}
+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]}`;
+}

package/dist/impl/plugins/react-refresh.d.ts

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

package/dist/impl/plugins/react-refresh.js

@@ -0,0 +1,33 @@
+import { logger } from "@reliverse/relinka";
+export const ReactRefreshPlugin = {
+  name: "react-refresh",
+  setup: (buildConfig) => {
+    buildConfig.reactFastRefresh = true;
+    const refreshRuntime = `
+if (typeof window !== 'undefined' && process.env.NODE_ENV === 'development') {
+  const refreshRuntime = {
+    performReactRefresh: () => {
+      if (window.__REACT_DEVTOOLS_GLOBAL_HOOK__?.onCommitFiberRoot) {
+        window.__REACT_DEVTOOLS_GLOBAL_HOOK__.onCommitFiberRoot();
+      }
+    }
+  };
+  window.__REACT_REFRESH_RUNTIME__ = refreshRuntime;
+}`;
+    if (buildConfig.banner) {
+      buildConfig.banner = `${refreshRuntime}
+${buildConfig.banner}`;
+    } else {
+      buildConfig.banner = refreshRuntime;
+    }
+    if (!buildConfig.jsx) {
+      buildConfig.jsx = {
+        runtime: "automatic",
+        importSource: "react"
+      };
+    }
+    if (buildConfig.verbose) {
+      logger.debug("React Fast Refresh plugin applied");
+    }
+  }
+};

package/dist/impl/plugins/svg-as-react.d.ts

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

package/dist/impl/plugins/svg-as-react.js

@@ -0,0 +1,18 @@
+import { logger } from "@reliverse/relinka";
+export const SVGAsReactPlugin = {
+  name: "svg-as-react",
+  setup: (buildConfig) => {
+    buildConfig.loader = {
+      ...buildConfig.loader,
+      ".svg": "jsx"
+      // Use JSX loader for SVG files
+    };
+    if (!buildConfig.define) {
+      buildConfig.define = {};
+    }
+    buildConfig.define.__SVG_AS_REACT__ = "true";
+    if (buildConfig.verbose) {
+      logger.debug("SVG as React plugin applied");
+    }
+  }
+};

package/dist/impl/plugins/typescript-declarations.d.ts

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

package/dist/impl/plugins/typescript-declarations.js

@@ -0,0 +1,48 @@
+import { logger } from "@reliverse/relinka";
+import { generateDeclarations } from "../dts-generator.js";
+export const TypeScriptDeclarationsPlugin = {
+  name: "typescript-declarations",
+  setup: (buildConfig) => {
+    if (buildConfig?.verbose) {
+      logger.debug("TypeScript declarations plugin registered");
+    }
+  },
+  onBuildEnd: async (result, buildOptions) => {
+    if (!result.success || result.skipped) {
+      return;
+    }
+    const pkg = result.package;
+    if (pkg.isFrontendApp) {
+      return;
+    }
+    try {
+      await generateTypeDeclarations(pkg, buildOptions);
+    } catch (error) {
+      logger.warn(`\u26A0\uFE0F  Declaration generation failed for ${pkg.name}: ${error}`);
+    }
+  }
+};
+async function generateTypeDeclarations(pkg, buildOptions) {
+  const configDts = pkg.buildConfig?.dts;
+  const dtsConfig = typeof configDts === "boolean" ? { enable: configDts } : configDts || {};
+  const dtsOptions = {
+    enable: true,
+    // Already checked by plugin activation
+    ...dtsConfig,
+    // Config from dler.ts
+    // CLI overrides
+    ...buildOptions?.dtsProvider && { provider: buildOptions.dtsProvider }
+  };
+  const result = await generateDeclarations({
+    package: pkg,
+    dtsOptions,
+    format: pkg.buildConfig?.format || "esm",
+    outputDir: pkg.outputDir
+  });
+  if (!result.success) {
+    logger.warn(`\u26A0\uFE0F  Declaration generation failed for ${pkg.name}:`);
+    logger.warn(
+      result.error || "Unknown error occurred during declaration generation"
+    );
+  }
+}

package/dist/impl/plugins/worker.d.ts

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

package/dist/impl/plugins/worker.js

@@ -0,0 +1,20 @@
+import { logger } from "@reliverse/relinka";
+export const WorkerPlugin = {
+  name: "worker",
+  setup: (buildConfig) => {
+    buildConfig.loader = {
+      ...buildConfig.loader,
+      ".worker.js": "js",
+      ".worker.ts": "ts",
+      ".worker.jsx": "jsx",
+      ".worker.tsx": "tsx"
+    };
+    if (!buildConfig.define) {
+      buildConfig.define = {};
+    }
+    buildConfig.define.__WORKER_SUPPORT__ = "true";
+    if (buildConfig.verbose) {
+      logger.debug("Worker plugin applied");
+    }
+  }
+};

package/dist/impl/presets.d.ts

@@ -0,0 +1,10 @@
+import type { BuildOptions } from "./types.js";
+export declare function applyProductionPreset(options: BuildOptions): BuildOptions;
+export declare function applyDevelopmentPreset(options: BuildOptions): BuildOptions;
+export declare function applyFrontendPreset(options: BuildOptions): BuildOptions;
+export declare function applyPresets(options: BuildOptions): BuildOptions;
+export declare function applyLibraryPreset(options: BuildOptions): BuildOptions;
+export declare function applyReactPreset(options: BuildOptions): BuildOptions;
+export declare function applyNodePreset(options: BuildOptions): BuildOptions;
+export declare function applyMonorepoPreset(options: BuildOptions): BuildOptions;
+export declare function getPresetDescription(preset: "production" | "development" | "library" | "react" | "node" | "monorepo"): string;

package/dist/impl/presets.js

@@ -0,0 +1,196 @@
+export function applyProductionPreset(options) {
+  const result = {
+    ...options,
+    production: true,
+    minify: true,
+    sourcemap: "none",
+    env: "inline",
+    splitting: !options.compile,
+    // Disable splitting for executables
+    dev: false,
+    watch: false,
+    verbose: false
+  };
+  if (options.compile && options.target === "bun" && options.format === "cjs") {
+    result.bytecode = true;
+  }
+  return result;
+}
+export function applyDevelopmentPreset(options) {
+  return {
+    ...options,
+    dev: true,
+    minify: false,
+    sourcemap: "inline",
+    env: "disable",
+    splitting: true,
+    watch: true,
+    // Override user settings for development
+    production: false,
+    bytecode: false,
+    compile: false
+  };
+}
+export function applyFrontendPreset(options) {
+  return {
+    ...options,
+    target: "browser",
+    format: "esm",
+    splitting: true,
+    html: true,
+    cssChunking: true,
+    minify: options.production ?? false,
+    sourcemap: options.production ? "linked" : "inline",
+    // Frontend-specific defaults
+    publicAssets: "public",
+    // Override conflicting options
+    bytecode: false
+    // Bytecode not supported for browser target
+  };
+}
+export function applyPresets(options) {
+  let result = { ...options };
+  if (options.production) {
+    result = applyProductionPreset(result);
+  }
+  if (options.dev) {
+    result = applyDevelopmentPreset(result);
+  }
+  if (options.html || options.target === "browser") {
+    result = applyFrontendPreset(result);
+  }
+  if (typeof result.minify === "boolean") {
+    result.minify = {
+      whitespace: result.minify,
+      syntax: result.minify,
+      identifiers: result.minify
+    };
+  } else if (result.minifyWhitespace !== void 0 || result.minifySyntax !== void 0 || result.minifyIdentifiers !== void 0) {
+    result.minify = {
+      whitespace: result.minifyWhitespace ?? true,
+      syntax: result.minifySyntax ?? true,
+      identifiers: result.minifyIdentifiers ?? true
+    };
+  }
+  if (result.entryNaming || result.chunkNaming || result.assetNaming) {
+    result.naming = {
+      entry: result.entryNaming,
+      chunk: result.chunkNaming,
+      asset: result.assetNaming
+    };
+  }
+  if (result.external && typeof result.external === "string") {
+    result.external = [result.external];
+  }
+  if (result.drop && typeof result.drop === "string") {
+    result.drop = [result.drop];
+  }
+  if (result.conditions) {
+    if (typeof result.conditions === "string") {
+      result.conditions = [result.conditions];
+    } else if (!Array.isArray(result.conditions)) {
+      result.conditions = [];
+    }
+  }
+  const resultWithJSX = result;
+  if (resultWithJSX.jsxRuntime || resultWithJSX.jsxImportSource) {
+    result.jsx = {
+      runtime: resultWithJSX.jsxRuntime || "automatic",
+      importSource: resultWithJSX.jsxImportSource
+    };
+  }
+  if (result.experimental && typeof result.experimental === "string") {
+    result.experimental = result.experimental.split(",").map((f) => f.trim());
+  }
+  return result;
+}
+export function applyLibraryPreset(options) {
+  return {
+    ...options,
+    target: "bun",
+    format: "esm",
+    splitting: false,
+    minify: false,
+    sourcemap: "linked",
+    // Library-specific defaults
+    packages: "external",
+    // Enhanced library features
+    generateTypes: true,
+    typeCheck: true,
+    sideEffects: false,
+    // Override conflicting options
+    html: false,
+    cssChunking: false,
+    devServer: false
+  };
+}
+export function applyReactPreset(options) {
+  return {
+    ...options,
+    target: "browser",
+    format: "esm",
+    splitting: true,
+    html: true,
+    cssChunking: true,
+    jsx: {
+      runtime: "automatic",
+      importSource: "react"
+    },
+    // React-specific defaults
+    minify: options.production ?? false,
+    sourcemap: options.production ? "linked" : "inline",
+    // Enhanced React features
+    reactFastRefresh: !options.production,
+    svgAsReact: true,
+    cssModules: true,
+    // Override conflicting options
+    bytecode: false
+  };
+}
+export function applyNodePreset(options) {
+  return {
+    ...options,
+    target: "node",
+    format: "esm",
+    splitting: false,
+    minify: options.production ?? false,
+    sourcemap: options.production ? "none" : "inline",
+    // Node.js-specific defaults
+    packages: "bundle",
+    // Override conflicting options
+    html: false,
+    cssChunking: false,
+    devServer: false
+  };
+}
+export function applyMonorepoPreset(options) {
+  return {
+    ...options,
+    // Monorepo-specific defaults
+    concurrency: 8,
+    stopOnError: false,
+    cache: true,
+    // Optimize for multiple packages
+    minify: options.production ?? false,
+    sourcemap: options.production ? "linked" : "inline",
+    splitting: true
+  };
+}
+export function getPresetDescription(preset) {
+  switch (preset) {
+    case "production":
+      return "Optimized for production: minify=true, sourcemap=none, env=inline, splitting=true";
+    case "development":
+      return "Optimized for development: minify=false, sourcemap=inline, env=disable, watch=true";
+    case "library":
+      return "Optimized for libraries: target=bun, format=esm, splitting=false, packages=external";
+    case "react":
+      return "Optimized for React apps: target=browser, format=esm, jsx=automatic, html=true";
+    case "node":
+      return "Optimized for Node.js: target=node, format=esm, splitting=false, packages=bundle";
+    case "monorepo":
+      return "Optimized for monorepos: concurrency=8, cache=true, stopOnError=false";
+    default:
+      return "";
+  }
+}

package/dist/impl/providers/mkdist/loader.d.ts

@@ -0,0 +1,4 @@
+import type { CreateLoaderOptions, LoadFile } from "../../types.js";
+export declare function createLoader(loaderOptions?: CreateLoaderOptions): {
+    loadFile: LoadFile;
+};