bunup 0.8.28 → 0.8.29

package/dist/plugins.js

@@ -1,610 +0,0 @@
-// @bun
-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 __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-
-// node_modules/picocolors/picocolors.js
-var require_picocolors = __commonJS((exports, module) => {
-  var p = process || {};
-  var argv = p.argv || [];
-  var env = p.env || {};
-  var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
-  var formatter = (open, close, replace = open) => (input) => {
-    let string = "" + input, index = string.indexOf(close, open.length);
-    return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
-  };
-  var replaceClose = (string, close, replace, index) => {
-    let result = "", cursor = 0;
-    do {
-      result += string.substring(cursor, index) + replace;
-      cursor = index + close.length;
-      index = string.indexOf(close, cursor);
-    } while (~index);
-    return result + string.substring(cursor);
-  };
-  var createColors = (enabled = isColorSupported) => {
-    let f = enabled ? formatter : () => String;
-    return {
-      isColorSupported: enabled,
-      reset: f("\x1B[0m", "\x1B[0m"),
-      bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
-      dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
-      italic: f("\x1B[3m", "\x1B[23m"),
-      underline: f("\x1B[4m", "\x1B[24m"),
-      inverse: f("\x1B[7m", "\x1B[27m"),
-      hidden: f("\x1B[8m", "\x1B[28m"),
-      strikethrough: f("\x1B[9m", "\x1B[29m"),
-      black: f("\x1B[30m", "\x1B[39m"),
-      red: f("\x1B[31m", "\x1B[39m"),
-      green: f("\x1B[32m", "\x1B[39m"),
-      yellow: f("\x1B[33m", "\x1B[39m"),
-      blue: f("\x1B[34m", "\x1B[39m"),
-      magenta: f("\x1B[35m", "\x1B[39m"),
-      cyan: f("\x1B[36m", "\x1B[39m"),
-      white: f("\x1B[37m", "\x1B[39m"),
-      gray: f("\x1B[90m", "\x1B[39m"),
-      bgBlack: f("\x1B[40m", "\x1B[49m"),
-      bgRed: f("\x1B[41m", "\x1B[49m"),
-      bgGreen: f("\x1B[42m", "\x1B[49m"),
-      bgYellow: f("\x1B[43m", "\x1B[49m"),
-      bgBlue: f("\x1B[44m", "\x1B[49m"),
-      bgMagenta: f("\x1B[45m", "\x1B[49m"),
-      bgCyan: f("\x1B[46m", "\x1B[49m"),
-      bgWhite: f("\x1B[47m", "\x1B[49m"),
-      blackBright: f("\x1B[90m", "\x1B[39m"),
-      redBright: f("\x1B[91m", "\x1B[39m"),
-      greenBright: f("\x1B[92m", "\x1B[39m"),
-      yellowBright: f("\x1B[93m", "\x1B[39m"),
-      blueBright: f("\x1B[94m", "\x1B[39m"),
-      magentaBright: f("\x1B[95m", "\x1B[39m"),
-      cyanBright: f("\x1B[96m", "\x1B[39m"),
-      whiteBright: f("\x1B[97m", "\x1B[39m"),
-      bgBlackBright: f("\x1B[100m", "\x1B[49m"),
-      bgRedBright: f("\x1B[101m", "\x1B[49m"),
-      bgGreenBright: f("\x1B[102m", "\x1B[49m"),
-      bgYellowBright: f("\x1B[103m", "\x1B[49m"),
-      bgBlueBright: f("\x1B[104m", "\x1B[49m"),
-      bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
-      bgCyanBright: f("\x1B[106m", "\x1B[49m"),
-      bgWhiteBright: f("\x1B[107m", "\x1B[49m")
-    };
-  };
-  module.exports = createColors();
-  module.exports.createColors = createColors;
-});
-
-// src/constants/re.ts
-var JS_RE = /\.(js|jsx|cjs|mjs)$/;
-var TS_RE = /\.(ts|tsx|mts|cts)$/;
-var DTS_RE = /\.(d\.(ts|mts|cts))$/;
-var JS_TS_RE = new RegExp(`${JS_RE.source}|${TS_RE.source}`);
-var JS_DTS_RE = new RegExp(`${JS_RE.source}|${DTS_RE.source}`);
-var CSS_RE = /\.(css)$/;
-
-// src/plugins/built-in/node/shims.ts
-function shims() {
-  return {
-    type: "bun",
-    name: "shims",
-    plugin: {
-      name: "bunup:shims",
-      setup(build) {
-        const isNodeCompatibleTarget = build.config.target === "node" || build.config.target === "bun";
-        const isEsm = build.config.format === "esm";
-        const isCjs = build.config.format === "cjs";
-        if (!isNodeCompatibleTarget || !isEsm && !isCjs) {
-          return;
-        }
-        build.config.define = {
-          ...build.config.define,
-          ...isCjs && {
-            "import.meta.url": "importMetaUrl"
-          }
-        };
-        build.onLoad({ filter: JS_TS_RE }, async ({ path }) => {
-          const content = await Bun.file(path).text();
-          let shimCode = "";
-          if (isEsm && (/\b__dirname\b/.test(content) || /\b__filename\b/.test(content))) {
-            shimCode = `import { fileURLToPath } from 'url';
-import { dirname } from 'path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-`;
-          }
-          if (isCjs && /\bimport\.meta\.url\b/.test(content)) {
-            shimCode = `import { pathToFileURL } from 'url';
-
-const importMetaUrl = pathToFileURL(__filename).href;
-
-`;
-          }
-          if (!shimCode)
-            return;
-          const lines = content.split(`
-`);
-          const firstLine = lines[0];
-          const restLines = lines.slice(1);
-          return {
-            contents: [firstLine, shimCode, ...restLines].join(`
-`)
-          };
-        });
-      }
-    }
-  };
-}
-// src/logger.ts
-var import_picocolors = __toESM(require_picocolors(), 1);
-var silent = false;
-class Logger {
-  static instance;
-  loggedOnceMessages = new Set;
-  MAX_LABEL_LENGTH = 3;
-  cliColor = import_picocolors.default.blue;
-  mutedColor = import_picocolors.default.dim;
-  infoColor = import_picocolors.default.cyan;
-  warnColor = import_picocolors.default.yellow;
-  errorColor = import_picocolors.default.red;
-  defaultColor = import_picocolors.default.white;
-  progressFgColorMap = {
-    ESM: import_picocolors.default.yellow,
-    CJS: import_picocolors.default.green,
-    IIFE: import_picocolors.default.magenta,
-    DTS: import_picocolors.default.blue
-  };
-  progressIdentifierBgColorMap = {
-    ESM: import_picocolors.default.bgYellow,
-    CJS: import_picocolors.default.bgGreen,
-    IIFE: import_picocolors.default.bgMagenta,
-    DTS: import_picocolors.default.bgBlue
-  };
-  labels = {
-    cli: "CLI",
-    info: "INFO",
-    warn: "WARN",
-    error: "ERROR"
-  };
-  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;
-  }
-  formatMessage({
-    fgColor,
-    bgColor,
-    label,
-    message,
-    identifier,
-    muted
-  }) {
-    const padding = " ".repeat(Math.max(0, this.MAX_LABEL_LENGTH - label.length));
-    const formattedMessage = muted ? this.mutedColor(message) : message;
-    const identifierPart = identifier ? `   ${bgColor(import_picocolors.default.black(` ${identifier} `))}` : "";
-    return `${fgColor(label)} ${padding}${formattedMessage}${identifierPart}`;
-  }
-  output(message, options = {}, logFn = console.log) {
-    if (silent || !this.shouldLog(options))
-      return;
-    if (options.verticalSpace)
-      logFn("");
-    logFn(message);
-    if (options.verticalSpace)
-      logFn("");
-  }
-  cli(message, options = {}) {
-    const formattedMessage = this.formatMessage({
-      fgColor: this.cliColor,
-      bgColor: import_picocolors.default.bgBlue,
-      label: this.labels.cli,
-      message,
-      identifier: options.identifier,
-      muted: options.muted
-    });
-    this.output(formattedMessage, options);
-  }
-  info(message, options = {}) {
-    const formattedMessage = this.formatMessage({
-      fgColor: this.infoColor,
-      bgColor: import_picocolors.default.bgCyan,
-      label: this.labels.info,
-      message,
-      identifier: options.identifier,
-      muted: options.muted
-    });
-    this.output(formattedMessage, options);
-  }
-  warn(message, options = {}) {
-    const formattedMessage = this.formatMessage({
-      fgColor: this.warnColor,
-      bgColor: import_picocolors.default.bgYellow,
-      label: this.labels.warn,
-      message,
-      identifier: options.identifier,
-      muted: options.muted
-    });
-    this.output(formattedMessage, options, console.warn);
-  }
-  error(message, options = {}) {
-    const formattedMessage = this.formatMessage({
-      fgColor: this.errorColor,
-      bgColor: import_picocolors.default.bgRed,
-      label: this.labels.error,
-      message,
-      identifier: options.identifier,
-      muted: options.muted
-    });
-    this.output(formattedMessage, options, console.error);
-  }
-  space() {
-    if (silent)
-      return;
-    console.log("");
-  }
-  getProgressFgColor(label) {
-    for (const [key, colorFn] of Object.entries(this.progressFgColorMap)) {
-      if (label.includes(key))
-        return colorFn;
-    }
-    return this.defaultColor;
-  }
-  getProgressBgColor(label) {
-    for (const [key, colorFn] of Object.entries(this.progressIdentifierBgColorMap)) {
-      if (label.includes(key))
-        return colorFn;
-    }
-    return import_picocolors.default.bgWhite;
-  }
-  progress(label, message, options = {}) {
-    const fgColor = this.getProgressFgColor(label);
-    const bgColor = this.getProgressBgColor(label);
-    const formattedMessage = this.formatMessage({
-      fgColor,
-      bgColor,
-      label,
-      message,
-      identifier: options.identifier,
-      muted: options.muted
-    });
-    this.output(formattedMessage, options);
-  }
-}
-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(import_picocolors.default.gray(" | "));
-  console.log(import_picocolors.default.gray(headerRow));
-  const separator = columns.map((col) => "-".repeat(widths[col.header])).join(" | ");
-  console.log(import_picocolors.default.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(import_picocolors.default.gray(" | "));
-    console.log(rowStr);
-  }
-  console.log(import_picocolors.default.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(import_picocolors.default.gray(" | "));
-    console.log(footerRow);
-  }
-}
-var logger = Logger.getInstance();
-
-// src/utils.ts
-import path, { normalize } from "path";
-
-// src/errors.ts
-var import_picocolors2 = __toESM(require_picocolors(), 1);
-class BunupError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "BunupError";
-  }
-}
-class BunupPluginError extends BunupError {
-  constructor(message) {
-    super(message);
-    this.name = "BunupPluginError";
-  }
-}
-
-// src/utils.ts
-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 makePortablePath(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) === "";
-}
-
-// src/plugins/built-in/productivity/exports.ts
-function exports() {
-  return {
-    type: "bunup",
-    name: "exports",
-    hooks: {
-      onBuildDone: async ({ output, options, meta }) => {
-        if (!meta.packageJson.path || !meta.packageJson.data) {
-          return;
-        }
-        try {
-          const { exportsField, entryPoints } = generateExportsFields(output.files);
-          const files = Array.isArray(meta.packageJson.data.files) ? [...new Set([...meta.packageJson.data.files, options.outDir])] : [options.outDir];
-          const existingExports = meta.packageJson.data.exports || {};
-          const mergedExports = { ...existingExports };
-          for (const [key, value] of Object.entries(exportsField)) {
-            mergedExports[key] = value;
-          }
-          const newPackageJson = {
-            name: meta.packageJson.data.name,
-            description: meta.packageJson.data.description,
-            version: meta.packageJson.data.version,
-            type: meta.packageJson.data.type,
-            private: meta.packageJson.data.private,
-            files,
-            ...entryPoints,
-            exports: mergedExports
-          };
-          for (const key in meta.packageJson.data) {
-            if (Object.prototype.hasOwnProperty.call(meta.packageJson.data, key) && !Object.prototype.hasOwnProperty.call(newPackageJson, key)) {
-              newPackageJson[key] = meta.packageJson.data[key];
-            }
-          }
-          await Bun.write(meta.packageJson.path, JSON.stringify(newPackageJson, null, 2));
-          logger.cli("Updated package.json with exports");
-        } catch (error) {
-          logger.error("Failed to update package.json");
-        }
-      }
-    }
-  };
-}
-function generateExportsFields(files) {
-  const exportsField = {};
-  const entryPoints = {};
-  for (const file of filterJsDtsFiles(files)) {
-    const exportType = formatToExportField(file.format, file.dts);
-    const relativePath = `./${makePortablePath(file.relativePathToRootDir)}`;
-    const exportKey = getExportKey(file.outputBasePath);
-    exportsField[exportKey] = {
-      ...exportsField[exportKey],
-      [exportType]: relativePath
-    };
-    for (const field of Object.keys(exportsField["."] ?? {})) {
-      entryPoints[exportFieldToEntryPoint(field, file.dts)] = exportsField["."][field];
-    }
-  }
-  return { exportsField, entryPoints };
-}
-function filterJsDtsFiles(files) {
-  return files.filter((file) => JS_DTS_RE.test(file.fullPath));
-}
-function getExportKey(outputBasePath) {
-  const pathSegments = outputBasePath.split("/");
-  if (pathSegments.length === 1 && pathSegments[0] === "index") {
-    return ".";
-  }
-  return `./${pathSegments.filter((p) => p !== "index").join("/")}`;
-}
-function exportFieldToEntryPoint(exportField, dts) {
-  return dts ? "types" : exportField === "require" ? "main" : "module";
-}
-function formatToExportField(format, dts) {
-  return dts ? "types" : format === "esm" ? "import" : "require";
-}
-// src/plugins/built-in/css/inject-styles.ts
-import path2 from "path";
-
-// src/plugins/utils.ts
-var import_picocolors3 = __toESM(require_picocolors(), 1);
-async function getPackageForPlugin(name, pluginName) {
-  let pkg;
-  try {
-    pkg = await import(name);
-  } catch {
-    throw new BunupPluginError(`[${import_picocolors3.default.cyan(name)}] is required for the ${pluginName} plugin. Please install it with: ${import_picocolors3.default.blue(`bun add ${name} --dev`)}`);
-  }
-  return pkg;
-}
-
-// src/plugins/built-in/css/inject-styles.ts
-function injectStyles(options) {
-  const { inject, ...transformOptions } = options ?? {};
-  return {
-    type: "bun",
-    name: "inject-styles",
-    plugin: {
-      name: "bunup:inject-styles",
-      async setup(build) {
-        const lightningcss = await getPackageForPlugin("lightningcss", "inject-styles");
-        build.onResolve({ filter: /^__inject-style$/ }, () => {
-          return {
-            path: "__inject-style",
-            namespace: "__inject-style"
-          };
-        });
-        build.onLoad({ filter: /^__inject-style$/, namespace: "__inject-style" }, () => {
-          return {
-            contents: `
-                      export default function injectStyle(css) {
-                        if (!css || typeof document === 'undefined') return
-                      
-                        const head = document.head || document.getElementsByTagName('head')[0]
-                        const style = document.createElement('style')
-                        head.appendChild(style)
-
-                        if (style.styleSheet) {
-                          style.styleSheet.cssText = css
-                        } else {
-                          style.appendChild(document.createTextNode(css))
-                        }
-                      }
-                      `,
-            loader: "js"
-          };
-        });
-        build.onLoad({ filter: CSS_RE }, async (args) => {
-          const source = await Bun.file(args.path).text();
-          const { code, warnings } = lightningcss.transform({
-            ...transformOptions,
-            filename: path2.basename(args.path),
-            code: Buffer.from(source),
-            minify: transformOptions.minify ?? (build.config.minify === true || typeof build.config.minify === "object" && build.config.minify.whitespace)
-          });
-          for (const warning of warnings) {
-            logger.warn(warning.message);
-          }
-          const stringifiedCode = JSON.stringify(code.toString());
-          const js = inject ? await inject(stringifiedCode, args.path) : `import injectStyle from '__inject-style';injectStyle(${stringifiedCode})`;
-          return {
-            contents: js,
-            loader: "js"
-          };
-        });
-      }
-    }
-  };
-}
-// src/plugins/built-in/productivity/copy.ts
-import { join } from "path";
-import { basename } from "path";
-function copy(patterns, outPath) {
-  return {
-    type: "bunup",
-    name: "copy",
-    hooks: {
-      onBuildDone: async ({ options, meta }) => {
-        const destinationPath = outPath || options.outDir;
-        for (const pattern of patterns) {
-          const glob = new Bun.Glob(pattern);
-          for await (const filePath of glob.scan({
-            cwd: meta.rootDir,
-            dot: true
-          })) {
-            const sourceFile = Bun.file(join(meta.rootDir, filePath));
-            await Bun.write(outPath && isDirectoryPath(outPath) ? join(destinationPath, basename(filePath)) : destinationPath, sourceFile);
-          }
-        }
-      }
-    }
-  };
-}
-// src/plugins/internal/report.ts
-var import_picocolors4 = __toESM(require_picocolors(), 1);
-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: import_picocolors4.default.blue },
-          { header: "Size", align: "right", color: import_picocolors4.default.green },
-          {
-            header: "Gzip",
-            align: "right",
-            color: import_picocolors4.default.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,
-  filterJsDtsFiles,
-  exports,
-  copy
-};