bunup 0.8.40 → 0.8.42

package/dist/plugins/index.d.ts

@@ -47,10 +47,4 @@ type InjectStylesPluginOptions = Pick<import("lightningcss").TransformOptions<im
 * @see https://bunup.dev/docs/plugins/inject-styles
 */
 declare function injectStyles(options?: InjectStylesPluginOptions): Plugin;
-/**
-* A plugin that logs a report of the bundle size.
-*
-* @deprecated This plugin is enabled by default. Bundle size reports are automatically logged without needing to use this plugin.
-*/
-declare function report(): BunupPlugin;
-export { shims, report, injectStyles, exports, copy };
+export { shims, injectStyles, exports, copy };

package/dist/plugins/index.js

@@ -1,12 +1,380 @@
 // @bun
-import {
-  BunupPluginError,
-  cleanPath,
-  formatFileSize,
-  isDirectoryPath,
-  logTable,
-  logger
-} from "../chunk-c1eyecm3.js";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/logger.ts
+import pc from "picocolors";
+function setSilent(value) {
+  silent = value ?? false;
+}
+
+class Logger {
+  static instance;
+  loggedOnceMessages = new Set;
+  constructor() {}
+  static getInstance() {
+    if (!Logger.instance) {
+      Logger.instance = new Logger;
+    }
+    return Logger.instance;
+  }
+  dispose() {
+    this.loggedOnceMessages.clear();
+  }
+  shouldLog(options) {
+    if (!options?.once) {
+      return true;
+    }
+    if (this.loggedOnceMessages.has(options.once)) {
+      return false;
+    }
+    this.loggedOnceMessages.add(options.once);
+    return true;
+  }
+  getIcon(type, tick) {
+    if (tick) {
+      return pc.green("\u2713");
+    }
+    const iconMap = {
+      info: pc.blue("i"),
+      warn: pc.yellow("!"),
+      error: pc.red("\u2715")
+    };
+    return iconMap[type];
+  }
+  formatIdentifier(identifier) {
+    return identifier ? `   ${pc.bgBlue(pc.black(` ${identifier} `))}` : "";
+  }
+  formatMessage(options) {
+    const {
+      message,
+      identifier,
+      muted = false,
+      tick = false,
+      type = "info"
+    } = options;
+    const icon = this.getIcon(type, tick);
+    const styledMessage = muted ? pc.dim(message) : type === "error" ? pc.red(message) : type === "warn" ? pc.yellow(message) : message;
+    const identifierPart = this.formatIdentifier(identifier);
+    return `${icon} ${styledMessage}${identifierPart}`;
+  }
+  output(message, options = {}, logFn = console.log) {
+    if (silent || !this.shouldLog(options)) {
+      return;
+    }
+    if (options.verticalSpace) {
+      logFn("");
+    }
+    logFn(message);
+    if (options.verticalSpace) {
+      logFn("");
+    }
+  }
+  info(message, options = {}) {
+    const formattedMessage = this.formatMessage({
+      ...options,
+      message,
+      type: "info"
+    });
+    this.output(formattedMessage, options);
+  }
+  warn(message, options = {}) {
+    const formattedMessage = this.formatMessage({
+      ...options,
+      message,
+      type: "warn"
+    });
+    this.output(formattedMessage, options);
+  }
+  error(message, options = {}) {
+    const formattedMessage = this.formatMessage({
+      ...options,
+      message,
+      type: "error"
+    });
+    this.output(formattedMessage, options);
+  }
+  success(message, options = {}) {
+    const formattedMessage = this.formatMessage({
+      ...options,
+      message,
+      tick: true
+    });
+    this.output(formattedMessage, options);
+  }
+  space() {
+    if (!silent) {
+      console.log("");
+    }
+  }
+}
+function logTable(columns, data, footer) {
+  if (silent)
+    return;
+  const widths = {};
+  for (const col of columns) {
+    const headerLength = col.header.length;
+    const dataLengths = data.map((row) => row[col.header]?.length || 0);
+    const footerLength = footer ? footer[col.header]?.length || 0 : 0;
+    widths[col.header] = Math.max(headerLength, ...dataLengths, footerLength);
+  }
+  const pad = (str, width, align) => {
+    return align === "left" ? str.padEnd(width) : str.padStart(width);
+  };
+  const headerRow = columns.map((col) => pad(col.header, widths[col.header], col.align)).join(pc.gray(" | "));
+  console.log(pc.gray(headerRow));
+  const separator = columns.map((col) => "-".repeat(widths[col.header])).join(" | ");
+  console.log(pc.gray(separator));
+  for (const row of data) {
+    const rowStr = columns.map((col) => {
+      const value = row[col.header] || "";
+      const padded = pad(value, widths[col.header], col.align);
+      return col.color ? col.color(padded) : padded;
+    }).join(pc.gray(" | "));
+    console.log(rowStr);
+  }
+  console.log(pc.gray(separator));
+  if (footer) {
+    const footerRow = columns.map((col) => {
+      const value = footer[col.header] || "";
+      const padded = pad(value, widths[col.header], col.align);
+      return padded;
+    }).join(pc.gray(" | "));
+    console.log(footerRow);
+  }
+}
+var silent = false, logger;
+var init_logger = __esm(() => {
+  logger = Logger.getInstance();
+});
+
+// src/errors.ts
+import pc2 from "picocolors";
+var BunupError, BunupBuildError, BunupDTSBuildError, BunupCLIError, BunupWatchError, BunupPluginError, parseErrorMessage = (error) => {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}, KNOWN_ERRORS, handleError = (error, context) => {
+  const errorMessage = parseErrorMessage(error);
+  const contextPrefix = context ? `[${context}] ` : "";
+  let errorType = "UNKNOWN ERROR";
+  if (error instanceof BunupBuildError) {
+    errorType = "BUILD ERROR";
+  } else if (error instanceof BunupDTSBuildError) {
+    errorType = "DTS ERROR";
+  } else if (error instanceof BunupCLIError) {
+    errorType = "CLI ERROR";
+  } else if (error instanceof BunupWatchError) {
+    errorType = "WATCH ERROR";
+  } else if (error instanceof BunupPluginError) {
+    errorType = "PLUGIN ERROR";
+  } else if (error instanceof BunupError) {
+    errorType = "BUNUP ERROR";
+  }
+  const knownError = KNOWN_ERRORS.find((error2) => error2.pattern.test(errorMessage) && (error2.errorType === errorType || !error2.errorType));
+  if (!knownError && errorType) {
+    console.error(`${pc2.red(errorType)} ${contextPrefix}${errorMessage}`);
+  }
+  if (knownError) {
+    console.log(`
+`);
+    knownError.logSolution(errorMessage);
+    console.log(`
+`);
+  } else {
+    console.error(pc2.dim(pc2.white("If you think this is a bug, please open an issue at: ") + pc2.cyan("https://github.com/arshad-yaseen/bunup/issues/new")));
+  }
+}, handleErrorAndExit = (error, context) => {
+  handleError(error, context);
+  process.exit(1);
+};
+var init_errors = __esm(() => {
+  init_logger();
+  BunupError = class BunupError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "BunupError";
+    }
+  };
+  BunupBuildError = class BunupBuildError extends BunupError {
+    constructor(message) {
+      super(message);
+      this.name = "BunupBuildError";
+    }
+  };
+  BunupDTSBuildError = class BunupDTSBuildError extends BunupError {
+    constructor(message) {
+      super(message);
+      this.name = "BunupDTSBuildError";
+    }
+  };
+  BunupCLIError = class BunupCLIError extends BunupError {
+    constructor(message) {
+      super(message);
+      this.name = "BunupCLIError";
+    }
+  };
+  BunupWatchError = class BunupWatchError extends BunupError {
+    constructor(message) {
+      super(message);
+      this.name = "BunupWatchError";
+    }
+  };
+  BunupPluginError = class BunupPluginError extends BunupError {
+    constructor(message) {
+      super(message);
+      this.name = "BunupPluginError";
+    }
+  };
+  KNOWN_ERRORS = [
+    {
+      pattern: /Could not resolve: "bun"/i,
+      errorType: "BUILD ERROR",
+      logSolution: () => {
+        logger.info(pc2.white("You're trying to build a project that uses Bun. ") + pc2.white("Please set the target option to ") + pc2.cyan("`bun`") + pc2.white(`.
+`) + pc2.white("Example: ") + pc2.green("`bunup --target bun`") + pc2.white(" or in config: ") + pc2.green("{ target: 'bun' }"));
+      }
+    }
+  ];
+});
+
+// src/utils.ts
+import fsSync from "fs";
+import fs from "fs/promises";
+import path, { normalize } from "path";
+function ensureArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+function getDefaultOutputExtension(format, packageType) {
+  switch (format) {
+    case "esm":
+      return isModulePackage(packageType) ? ".js" : ".mjs";
+    case "cjs":
+      return isModulePackage(packageType) ? ".cjs" : ".js";
+    case "iife":
+      return ".global.js";
+  }
+}
+function getDefaultDtsExtention(format, packageType) {
+  switch (format) {
+    case "esm":
+      return isModulePackage(packageType) ? ".d.ts" : ".d.mts";
+    case "cjs":
+      return isModulePackage(packageType) ? ".d.cts" : ".d.ts";
+    case "iife":
+      return ".global.d.ts";
+  }
+}
+function isModulePackage(packageType) {
+  return packageType === "module";
+}
+function formatTime(ms) {
+  return ms >= 1000 ? `${(ms / 1000).toFixed(2)}s` : `${Math.round(ms)}ms`;
+}
+function getPackageDeps(packageJson) {
+  if (!packageJson)
+    return [];
+  return Array.from(new Set([
+    ...Object.keys(packageJson.dependencies || {}),
+    ...Object.keys(packageJson.peerDependencies || {})
+  ]));
+}
+function formatFileSize(bytes) {
+  if (bytes === 0)
+    return "0 B";
+  const units = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  if (i === 0)
+    return `${bytes} ${units[i]}`;
+  return `${(bytes / 1024 ** i).toFixed(2)} ${units[i]}`;
+}
+function getShortFilePath(filePath, maxLength = 3) {
+  const fileParts = filePath.split("/");
+  const shortPath = fileParts.slice(-maxLength).join("/");
+  return shortPath;
+}
+async function cleanOutDir(rootDir, outDir) {
+  const outDirPath = path.join(rootDir, outDir);
+  try {
+    await fs.rm(outDirPath, { recursive: true, force: true });
+  } catch (error) {
+    throw new BunupBuildError(`Failed to clean output directory: ${error}`);
+  }
+  await fs.mkdir(outDirPath, { recursive: true });
+}
+function cleanPath(path2) {
+  let cleaned = normalize(path2).replace(/\\/g, "/");
+  cleaned = cleaned.replace(/^[a-zA-Z]:\//, "");
+  cleaned = cleaned.replace(/^\/+/, "");
+  cleaned = cleaned.replace(/\/+/g, "/");
+  return cleaned;
+}
+function isDirectoryPath(filePath) {
+  return path.extname(filePath) === "";
+}
+function pathExistsSync(filePath) {
+  try {
+    fsSync.accessSync(filePath);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+function formatListWithAnd(arr) {
+  return new Intl.ListFormat("en", {
+    style: "long",
+    type: "conjunction"
+  }).format(arr);
+}
+async function getFilesFromGlobs(patterns, cwd) {
+  const includePatterns = patterns.filter((p) => !p.startsWith("!"));
+  const excludePatterns = patterns.filter((p) => p.startsWith("!")).map((p) => p.slice(1));
+  const includedFiles = new Set;
+  for (const pattern of includePatterns) {
+    const glob = new Bun.Glob(pattern);
+    for await (const file of glob.scan(cwd)) {
+      includedFiles.add(file);
+    }
+  }
+  if (excludePatterns.length > 0) {
+    for (const pattern of excludePatterns) {
+      const glob = new Bun.Glob(pattern);
+      for await (const file of glob.scan(cwd)) {
+        includedFiles.delete(file);
+      }
+    }
+  }
+  return Array.from(includedFiles);
+}
+var init_utils = __esm(() => {
+  init_errors();
+});
 
 // src/constants/re.ts
 var JS_RE = /\.(js|jsx|cjs|mjs)$/;
@@ -71,7 +439,9 @@ const importMetaUrl = pathToFileURL(__filename).href;
   };
 }
 // src/plugins/exports.ts
-import path from "path";
+import path2 from "path";
+init_logger();
+init_utils();
 function exports(options = {}) {
   return {
     type: "bunup",
@@ -168,16 +538,17 @@ function formatToExportField(format, dts) {
   return dts ? "types" : format === "esm" ? "import" : "require";
 }
 function removeExtension(filePath) {
-  const basename = path.basename(filePath);
+  const basename = path2.basename(filePath);
   const firstDotIndex = basename.indexOf(".");
   if (firstDotIndex === -1) {
     return filePath;
   }
   const nameWithoutExtensions = basename.slice(0, firstDotIndex);
-  const directory = path.dirname(filePath);
-  return directory === "." ? nameWithoutExtensions : path.join(directory, nameWithoutExtensions);
+  const directory = path2.dirname(filePath);
+  return directory === "." ? nameWithoutExtensions : path2.join(directory, nameWithoutExtensions);
 }
 // src/plugins/copy.ts
+init_utils();
 import { join } from "path";
 import { basename } from "path";
 function copy(patterns, outPath) {
@@ -202,10 +573,12 @@ function copy(patterns, outPath) {
   };
 }
 // src/plugins/inject-styles.ts
-import path2 from "path";
+import path3 from "path";
+init_logger();
 
 // src/plugins/utils.ts
-import pc from "picocolors";
+init_errors();
+import pc3 from "picocolors";
 function filterBunupBunPlugins(plugins) {
   if (!plugins)
     return [];
@@ -239,7 +612,7 @@ async function getPackageForPlugin(name, pluginName) {
   try {
     pkg = await import(name);
   } catch {
-    throw new BunupPluginError(`[${pc.cyan(name)}] is required for the ${pluginName} plugin. Please install it with: ${pc.blue(`bun add ${name} --dev`)}`);
+    throw new BunupPluginError(`[${pc3.cyan(name)}] is required for the ${pluginName} plugin. Please install it with: ${pc3.blue(`bun add ${name} --dev`)}`);
   }
   return pkg;
 }
@@ -284,7 +657,7 @@ function injectStyles(options) {
           const source = await Bun.file(args.path).text();
           const { code, warnings } = lightningcss.transform({
             ...transformOptions,
-            filename: path2.basename(args.path),
+            filename: path3.basename(args.path),
             code: Buffer.from(source),
             minify: transformOptions.minify ?? (build.config.minify === true || typeof build.config.minify === "object" && build.config.minify.whitespace)
           });
@@ -302,66 +675,9 @@ function injectStyles(options) {
     }
   };
 }
-// src/plugins/internal/report.ts
-import pc2 from "picocolors";
-function report() {
-  return {
-    type: "bunup",
-    name: "report",
-    hooks: {
-      onBuildDone: async ({ options, output }) => {
-        if (options.watch)
-          return;
-        const files = await Promise.all(output.files.map(async (file) => {
-          const name = file.relativePathToRootDir;
-          const size = Bun.file(file.fullPath).size;
-          const gzipSize = Bun.gzipSync(new Uint8Array(await Bun.file(file.fullPath).arrayBuffer())).length;
-          const formattedGzipSize = formatFileSize(gzipSize);
-          return {
-            name,
-            size,
-            formattedSize: formatFileSize(size),
-            gzipSize,
-            formattedGzipSize
-          };
-        }));
-        const totalSize = files.reduce((sum, file) => sum + file.size, 0);
-        const formattedTotalSize = formatFileSize(totalSize);
-        const totalGzipSize = files.reduce((sum, file) => sum + (file.gzipSize || 0), 0);
-        const formattedTotalGzipSize = formatFileSize(totalGzipSize);
-        const columns = [
-          { header: "File", align: "left", color: pc2.blue },
-          { header: "Size", align: "right", color: pc2.green },
-          {
-            header: "Gzip",
-            align: "right",
-            color: pc2.magenta
-          }
-        ];
-        const data = files.map((file) => {
-          return {
-            File: file.name,
-            Size: file.formattedSize,
-            Gzip: file.formattedGzipSize
-          };
-        });
-        const footer = {
-          File: "Total",
-          Size: formattedTotalSize,
-          Gzip: formattedTotalGzipSize
-        };
-        logger.space();
-        logTable(columns, data, footer);
-        logger.space();
-      }
-    }
-  };
-}
 export {
   shims,
-  report,
   injectStyles,
   exports,
   copy
 };
-export { filterBunupBunPlugins, filterBunupPlugins, runPluginBuildStartHooks, runPluginBuildDoneHooks, report };