bunup 0.8.32 → 0.8.35

package/dist/chunk-0r7kktgh.js

@@ -0,0 +1,352 @@
+import {
+  BunupPluginError,
+  cleanPath,
+  formatFileSize,
+  isDirectoryPath,
+  logTable,
+  logger,
+  removeExtension
+} from "./chunk-8z361mhm.js";
+
+// 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/plugins/built-in/productivity/exports.ts
+function exports(options = {}) {
+  return {
+    type: "bunup",
+    name: "exports",
+    hooks: {
+      onBuildDone: async ({ output, options: buildOptions, 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,
+              buildOptions.outDir
+            ])
+          ] : [buildOptions.outDir];
+          const mergedExports = { ...exportsField };
+          if (options.extraExports) {
+            for (const [key, value] of Object.entries(options.extraExports)) {
+              if (typeof value === "string") {
+                mergedExports[key] = value;
+              } else {
+                const existingExport = mergedExports[key];
+                if (typeof existingExport === "object" && existingExport !== null) {
+                  mergedExports[key] = {
+                    ...existingExport,
+                    ...value
+                  };
+                } else {
+                  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 {
+          logger.error("Failed to update package.json");
+        }
+      }
+    }
+  };
+}
+function generateExportsFields(files) {
+  const exportsField = {};
+  const entryPoints = {};
+  const filteredFiles = filterFiles(files);
+  for (const file of filteredFiles) {
+    const exportType = formatToExportField(file.format, file.dts);
+    const relativePath = `./${cleanPath(file.relativePathToRootDir)}`;
+    const exportKey = getExportKey(cleanPath(file.relativePathToOutputDir));
+    exportsField[exportKey] = {
+      ...exportsField[exportKey],
+      [exportType]: relativePath
+    };
+  }
+  for (const field of Object.keys(exportsField["."] ?? {})) {
+    const entryPoint = exportFieldToEntryPoint(field);
+    entryPoints[entryPoint] = exportsField["."][field];
+  }
+  return { exportsField, entryPoints };
+}
+function filterFiles(files) {
+  return files.filter((file) => JS_DTS_RE.test(file.fullPath) && file.kind === "entry-point");
+}
+function getExportKey(relativePathToOutputDir) {
+  const pathSegments = cleanPath(removeExtension(relativePathToOutputDir)).split("/");
+  if (pathSegments.length === 1 && pathSegments[0].startsWith("index")) {
+    return ".";
+  }
+  return `./${pathSegments.filter((p) => !p.startsWith("index")).join("/")}`;
+}
+function exportFieldToEntryPoint(exportField) {
+  return exportField === "types" ? "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 path from "path";
+
+// src/plugins/utils.ts
+import pc from "picocolors";
+function filterBunupBunPlugins(plugins) {
+  if (!plugins)
+    return [];
+  return plugins.filter((p) => p.type === "bun");
+}
+function filterBunupPlugins(plugins) {
+  if (!plugins)
+    return [];
+  return plugins.filter((p) => p.type === "bunup");
+}
+async function runPluginBuildStartHooks(bunupPlugins, options) {
+  if (!bunupPlugins)
+    return;
+  for (const plugin of bunupPlugins) {
+    if (plugin.hooks.onBuildStart) {
+      await plugin.hooks.onBuildStart(options);
+    }
+  }
+}
+async function runPluginBuildDoneHooks(bunupPlugins, options, output, meta) {
+  if (!bunupPlugins)
+    return;
+  for (const plugin of bunupPlugins) {
+    if (plugin.hooks.onBuildDone) {
+      await plugin.hooks.onBuildDone({ options, output, meta });
+    }
+  }
+}
+async function getPackageForPlugin(name, pluginName) {
+  let pkg;
+  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`)}`);
+  }
+  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: path.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
+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, exports, filterBunupBunPlugins, filterBunupPlugins, runPluginBuildStartHooks, runPluginBuildDoneHooks, injectStyles, copy, report };