bunup 0.11.24 → 0.11.25

package/dist/cli/index.js

@@ -4,7 +4,7 @@ import {
   build,
   createBuildOptions,
   processLoadedConfigs
-} from "../shared/bunup-rqk1dnq1.js";
+} from "../shared/bunup-yaq8w9a4.js";
 import {
   BunupCLIError,
   BunupWatchError,
@@ -18,13 +18,13 @@ import {
   logger,
   parseErrorMessage,
   setSilent
-} from "../shared/bunup-a55nf4gz.js";
+} from "../shared/bunup-ed9pv5cz.js";
 
 // packages/bunup/src/cli/index.ts
 import { loadConfig } from "coffi";
 import pc3 from "picocolors";
 // packages/bunup/package.json
-var version = "0.11.24";
+var version = "0.11.25";
 
 // packages/bunup/src/watch.ts
 import path from "path";

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Arrayable, BuildContext, BuildMeta, BuildOptions, BuildOutput, BuildOutputFile, BunupPlugin, DefineConfigItem, DefineWorkspaceItem, WithOptional } from "./shared/bunup-ff28zhd9";
+import { Arrayable, BuildContext, BuildMeta, BuildOptions, BuildOutput, BuildOutputFile, BunupPlugin, DefineConfigItem, DefineWorkspaceItem, WithOptional } from "./shared/bunup-r5ahaj5s";
 declare function build(partialOptions: Partial<BuildOptions>, rootDir?: string): Promise<void>;
 declare function defineConfig(options: Arrayable<DefineConfigItem>): Arrayable<DefineConfigItem>;
 declare function defineWorkspace(options: WithOptional<DefineWorkspaceItem, "config">[], sharedOptions?: Partial<DefineConfigItem>): DefineWorkspaceItem[];

package/dist/index.js

@@ -1,8 +1,8 @@
 // @bun
 import {
   build
-} from "./shared/bunup-rqk1dnq1.js";
-import"./shared/bunup-a55nf4gz.js";
+} from "./shared/bunup-yaq8w9a4.js";
+import"./shared/bunup-ed9pv5cz.js";
 // packages/bunup/src/define.ts
 function defineConfig(options) {
   return options;

package/dist/plugins.d.ts

@@ -1,12 +1,27 @@
-import { BuildContext, BunupPlugin, MaybePromise } from "./shared/bunup-ff28zhd9";
-/**
-* A plugin that copies files and directories to the output directory.
-*
-* @param pattern - String or array of glob patterns to match files for copying. Patterns starting with '!' exclude matching files.
-* @param outPath - Optional output path. If not provided, uses the build output directory
-* @see https://bunup.dev/docs/plugins/copy
-*/
-declare function copy(pattern: string | string[], outPath?: string): BunupPlugin;
+import { BuildContext, BunupPlugin, MaybePromise } from "./shared/bunup-r5ahaj5s";
+type CopyOptions = {
+	/** Whether to follow symbolic links when copying files. */
+	followSymlinks?: boolean
+	/** Whether to exclude dotfiles (files starting with a dot) from being copied. */
+	excludeDotfiles?: boolean
+};
+declare function copy(pattern: string | string[]): BunupPlugin & CopyBuilder;
+declare class CopyBuilder {
+	private _patterns;
+	private _destination?;
+	private _options?;
+	constructor(pattern: string | string[]);
+	/**
+	* Sets the destination directory where files will be copied.
+	*/
+	to(destination: string): this;
+	/**
+	* Sets additional options for the copy operation.
+	*/
+	with(options: CopyOptions): this;
+	get name(): string;
+	get hooks(): BunupPlugin["hooks"];
+}
 type CustomExports = Record<string, string | Record<string, string | Record<string, string>>>;
 type Exclude = ((ctx: BuildContext) => string[] | undefined) | string[];
 interface ExportsPluginOptions {
@@ -35,6 +50,16 @@ interface ExportsPluginOptions {
 	* @see https://bunup.dev/docs/plugins/exports#includepackagejson
 	*/
 	includePackageJson?: boolean;
+	/**
+	* Whether to add a wildcard export that allows deep imports
+	*
+	* When true, adds "./*": "./*" to exports, making all files accessible
+	* When false (default), only explicit exports are accessible
+	*
+	* @default false
+	* @see https://bunup.dev/docs/plugins/exports#all
+	*/
+	all?: boolean;
 }
 /**
 * A plugin that generates the exports field in the package.json file automatically.
@@ -43,15 +68,44 @@ interface ExportsPluginOptions {
 */
 declare function exports(options?: ExportsPluginOptions): BunupPlugin;
 import { BunPlugin } from "bun";
-type InjectStylesPluginOptions = Pick<import("lightningcss").TransformOptions<import("lightningcss").CustomAtRules>, "targets" | "nonStandard" | "pseudoClasses" | "unusedSymbols" | "errorRecovery" | "visitor" | "customAtRules" | "include" | "exclude" | "drafts"> & {
+type InjectStylesPluginOptions = {
+	/**
+	* Custom function to inject CSS into the document head.
+	*
+	* By default, bunup uses its own `injectStyle` function that creates a `<style>`
+	* tag and appends it to the document head. You can provide your own injection
+	* logic to customize how styles are applied to the document.
+	*
+	* @param css - The processed CSS string (already JSON stringified)
+	* @param filePath - The original file path of the CSS file being processed
+	* @returns JavaScript code that will inject the styles when executed
+	*
+	* @example
+	* ```ts
+	* injectStyles({
+	*   inject: (css, filePath) => {
+	*     return `
+	*       const style = document.createElement('style');
+	*       style.setAttribute('data-source', '${filePath}');
+	*       style.textContent = ${css};
+	*       document.head.appendChild(style);
+	*     `;
+	*   }
+	* })
+	* ```
+	*
+	* The default injection handles cases like when `document` is undefined (e.g., server-side rendering) and compatibility with older browsers. Consider these when implementing custom injection logic.
+	*/
 	inject?: (css: string, filePath: string) => MaybePromise<string>
-	/** Whether to minify the CSS.
+	/**
+	* Whether to minify the styles being injected.
+	*
 	* @default true
 	*/
 	minify?: boolean
 };
 /**
-* A plugin that injects styles into the document head.
+* A plugin that injects styles into the document head at runtime instead of bundling them to the build output.
 *
 * @see https://bunup.dev/docs/plugins/inject-styles
 */

package/dist/plugins.js

@@ -7,32 +7,91 @@ import {
   detectFileFormatting,
   ensureArray,
   formatListWithAnd,
-  getPackageForPlugin,
-  isDirectoryPath,
   logger
-} from "./shared/bunup-a55nf4gz.js";
+} from "./shared/bunup-ed9pv5cz.js";
 
 // packages/bunup/src/plugins/built-in/copy.ts
-import { basename, join } from "path";
-function copy(pattern, outPath) {
-  return {
-    name: "copy",
-    hooks: {
-      onBuildDone: async ({ options, meta }) => {
-        const destinationPath = outPath || options.outDir;
-        for (const p of ensureArray(pattern)) {
-          const glob = new Bun.Glob(p);
-          for await (const filePath of glob.scan({
+import { basename, extname, join } from "path";
+function copy(pattern) {
+  return new CopyBuilder(pattern);
+}
+
+class CopyBuilder {
+  _patterns;
+  _destination;
+  _options;
+  constructor(pattern) {
+    this._patterns = ensureArray(pattern);
+  }
+  to(destination) {
+    this._destination = destination;
+    return this;
+  }
+  with(options) {
+    this._options = options;
+    return this;
+  }
+  get name() {
+    return "copy";
+  }
+  get hooks() {
+    return {
+      onBuildDone: async ({ options: buildOptions, meta }) => {
+        let destinationPath = "";
+        if (this._destination) {
+          if (this._destination.startsWith(buildOptions.outDir)) {
+            logger.warn("You don't need to include the output directory in the destination path for the copy plugin. Files are copied to the output directory by default.", {
+              verticalSpace: true
+            });
+            destinationPath = this._destination;
+          } else {
+            destinationPath = join(buildOptions.outDir, this._destination);
+          }
+        } else {
+          destinationPath = buildOptions.outDir;
+        }
+        for (const pattern of this._patterns) {
+          const glob = new Bun.Glob(pattern);
+          for await (const scannedPath of glob.scan({
             cwd: meta.rootDir,
-            dot: true
+            dot: !this._options?.excludeDotfiles,
+            onlyFiles: !isPatternFolder(pattern),
+            followSymlinks: this._options?.followSymlinks
           })) {
-            const sourceFile = Bun.file(join(meta.rootDir, filePath));
-            await Bun.write(isDirectoryPath(destinationPath) ? join(meta.rootDir, destinationPath, basename(filePath)) : join(meta.rootDir, destinationPath), sourceFile);
+            const sourcePath = join(meta.rootDir, scannedPath);
+            const destinationDir = resolveDestinationPath(destinationPath, scannedPath, meta.rootDir);
+            if (isPathDir(sourcePath)) {
+              await copyDirectory(sourcePath, destinationDir);
+            } else {
+              await copyFile(sourcePath, destinationDir);
+            }
           }
         }
       }
-    }
-  };
+    };
+  }
+}
+function resolveDestinationPath(destinationPath, scannedPath, rootDir) {
+  const fullDestinationPath = join(rootDir, destinationPath);
+  const isScannedPathDir = isPathDir(scannedPath);
+  const isDestinationDir = isPathDir(fullDestinationPath);
+  if (isDestinationDir && !isScannedPathDir) {
+    return join(fullDestinationPath, basename(scannedPath));
+  }
+  return fullDestinationPath;
+}
+function isPatternFolder(pattern) {
+  return !pattern.includes("/");
+}
+function isPathDir(filePath) {
+  return extname(filePath) === "";
+}
+async function copyDirectory(sourcePath, destinationPath) {
+  await Bun.$`cp -r ${sourcePath} ${destinationPath}`;
+}
+async function copyFile(sourcePath, destinationPath) {
+  const sourceFile = Bun.file(sourcePath);
+  await Bun.write(destinationPath, sourceFile);
 }
 // packages/bunup/src/plugins/built-in/exports.ts
 import path from "path";
@@ -55,7 +114,7 @@ async function processPackageJsonExports(ctx, options) {
     const { exportsField, entryPoints } = generateExportsFields(output.files, options.exclude, options.excludeCss, ctx);
     const updatedFiles = createUpdatedFilesArray(meta.packageJson.data, buildOptions.outDir);
     const mergedExports = mergeCustomExportsWithGenerated(exportsField, options.customExports, ctx);
-    const finalExports = addPackageJsonExport(mergedExports, options.includePackageJson);
+    const finalExports = addPackageJsonOrWildcardExport(mergedExports, options.includePackageJson, options.all);
     const newPackageJson = createUpdatedPackageJson(meta.packageJson.data, entryPoints, finalExports, updatedFiles);
     if (Bun.deepEquals(newPackageJson, meta.packageJson.data)) {
       return;
@@ -291,13 +350,14 @@ function getCssExportKey(pathRelativeToOutdir) {
     return `./${pathSegments.join("/")}.css`;
   }
 }
-function addPackageJsonExport(exports2, includePackageJson) {
-  if (includePackageJson === false) {
-    return exports2;
-  }
+function addPackageJsonOrWildcardExport(exports2, includePackageJson, all) {
   const finalExports = { ...exports2 };
-  if (!finalExports["./package.json"]) {
-    finalExports["./package.json"] = "./package.json";
+  if (all) {
+    finalExports["./*"] = "./*";
+  } else if (includePackageJson !== false) {
+    if (!finalExports["./package.json"]) {
+      finalExports["./package.json"] = "./package.json";
+    }
   }
   return finalExports;
 }
@@ -313,12 +373,22 @@ function exportFieldToEntryPoint(exportField) {
 }
 // packages/bunup/src/plugins/built-in/inject-styles.ts
 import path2 from "path";
+import { transform } from "lightningcss";
+
+// packages/bunup/src/constants/css.ts
+var DEFAULT_CSS_TARGETS = {
+  chrome: 87 << 16,
+  firefox: 78 << 16,
+  safari: 14 << 16,
+  edge: 88 << 16
+};
+
+// packages/bunup/src/plugins/built-in/inject-styles.ts
 function injectStyles(options) {
-  const { inject, ...transformOptions } = options ?? {};
+  const { inject, minify = true } = options ?? {};
   return {
     name: "bunup:inject-styles",
     async setup(build) {
-      const lightningcss = await getPackageForPlugin("lightningcss", "inject-styles");
       build.onResolve({ filter: /^__inject-style$/ }, () => {
         return {
           path: "__inject-style",
@@ -347,11 +417,11 @@ function injectStyles(options) {
       });
       build.onLoad({ filter: CSS_RE }, async (args) => {
         const source = await Bun.file(args.path).text();
-        const { code, warnings } = lightningcss.transform({
-          ...transformOptions,
+        const { code, warnings } = transform({
           filename: path2.basename(args.path),
           code: Buffer.from(source),
-          minify: transformOptions.minify ?? true
+          minify,
+          targets: DEFAULT_CSS_TARGETS
         });
         for (const warning of warnings) {
           logger.warn(warning.message);

package/dist/shared/{bunup-a55nf4gz.js → bunup-ed9pv5cz.js}

@@ -1,3 +1,4 @@
+// @bun
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
@@ -381,9 +382,6 @@ function cleanPath(path2) {
   cleaned = cleaned.replace(/\/+/g, "/");
   return cleaned;
 }
-function isDirectoryPath(filePath) {
-  return path.extname(filePath) === "";
-}
 function formatListWithAnd(arr) {
   return new Intl.ListFormat("en", {
     style: "long",
@@ -458,44 +456,4 @@ async function detectFileFormatting(filePath) {
   }
 }
 
-// packages/bunup/src/plugins/utils.ts
-import pc3 from "picocolors";
-function filterBunPlugins(plugins) {
-  if (!plugins)
-    return [];
-  return plugins.filter((p) => ("setup" in p));
-}
-function filterBunupPlugins(plugins) {
-  if (!plugins)
-    return [];
-  return plugins.filter((p) => ("hooks" in p));
-}
-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(`[${pc3.cyan(name)}] is required for the ${pluginName} plugin. Please install it with: ${pc3.blue(`bun add ${name} --dev`)}`);
-  }
-  return pkg;
-}
-
-export { __toESM, __require, silent, setSilent, logTable, logTime, logger, BunupBuildError, BunupDTSBuildError, BunupCLIError, BunupWatchError, parseErrorMessage, handleError, handleErrorAndExit, JS_TS_RE, JS_DTS_RE, CSS_RE, ensureArray, getDefaultJsOutputExtension, getDefaultDtsOutputExtention, getPackageDeps, formatFileSize, getShortFilePath, cleanOutDir, cleanPath, isDirectoryPath, formatListWithAnd, getFilesFromGlobs, isTypeScriptFile, isJavascriptFile, replaceExtension, detectFileFormatting, filterBunPlugins, filterBunupPlugins, runPluginBuildStartHooks, runPluginBuildDoneHooks, getPackageForPlugin };
+export { __toESM, __require, silent, setSilent, logTable, logTime, logger, BunupBuildError, BunupDTSBuildError, BunupCLIError, BunupWatchError, parseErrorMessage, handleError, handleErrorAndExit, JS_TS_RE, JS_DTS_RE, CSS_RE, ensureArray, getDefaultJsOutputExtension, getDefaultDtsOutputExtention, getPackageDeps, formatFileSize, getShortFilePath, cleanOutDir, cleanPath, formatListWithAnd, getFilesFromGlobs, isTypeScriptFile, isJavascriptFile, replaceExtension, detectFileFormatting };

package/dist/shared/{bunup-ff28zhd9.d.ts → bunup-r5ahaj5s.d.ts}

@@ -84,6 +84,14 @@ type Format = "esm" | "cjs" | "iife";
 type Target = "bun" | "node" | "browser";
 type External = (string | RegExp)[];
 type Env = "inline" | "disable" | `${string}*` | Record<string, string>;
+type CSSOptions = {
+	/**
+	* Generate TypeScript definitions for CSS modules.
+	*
+	* @see https://bunup.dev/docs/guide/css#css-modules-and-typescript
+	*/
+	typedModules?: boolean
+};
 type OnSuccess = ((options: Partial<BuildOptions>) => MaybePromise<void> | (() => void)) | string | {
 	/**
 	* The shell command to execute after a successful build
@@ -404,6 +412,10 @@ interface BuildOptions {
 	* ]
 	*/
 	plugins?: (BunupPlugin | BunPlugin)[];
+	/**
+	* Options for CSS handling in the build process.
+	*/
+	css?: CSSOptions;
 }
 type MaybePromise<T> = Promise<T> | T;
 type WithOptional<

package/dist/shared/{bunup-rqk1dnq1.js → bunup-yaq8w9a4.js}

@@ -1,11 +1,10 @@
+// @bun
 import {
   BunupBuildError,
   BunupDTSBuildError,
   cleanOutDir,
   cleanPath,
   ensureArray,
-  filterBunPlugins,
-  filterBunupPlugins,
   formatFileSize,
   getDefaultDtsOutputExtention,
   getDefaultJsOutputExtension,
@@ -18,11 +17,9 @@ import {
   logger,
   parseErrorMessage,
   replaceExtension,
-  runPluginBuildDoneHooks,
-  runPluginBuildStartHooks,
   setSilent,
   silent
-} from "./bunup-a55nf4gz.js";
+} from "./bunup-ed9pv5cz.js";
 
 // packages/bunup/src/loaders.ts
 import path from "path";
@@ -97,6 +94,47 @@ async function executeOnSuccess(onSuccess, options, signal) {
   }
 }
 
+// packages/bunup/src/plugins/internal/css-typed-modules.ts
+import { transform } from "lightningcss";
+function cssTypedModulesPlugin() {
+  return {
+    name: "bunup:css-typed-modules",
+    setup(build) {
+      build.onLoad({ filter: /\.module\.css$/ }, async (args) => {
+        const uc = new Set;
+        const source = await Bun.file(args.path).text();
+        transform({
+          filename: args.path,
+          code: Buffer.from(source),
+          visitor: {
+            Rule: {
+              style(rule) {
+                rule.value.selectors.forEach((selector) => {
+                  selector.forEach((component) => {
+                    if (component.type === "class") {
+                      uc.add(component.name);
+                    }
+                  });
+                });
+              }
+            }
+          }
+        });
+        const classes = Array.from(uc);
+        const destination = `${args.path}.d.ts`;
+        const dts = `// This file is automatically generated. Do not edit.
+declare const classes: {
+${classes.map((className) => `  readonly "${className}": string;`).join(`
+`)}
+};
+export default classes;
+`;
+        await Bun.write(destination, dts);
+      });
+    }
+  };
+}
+
 // packages/bunup/src/plugins/internal/report.ts
 import pc from "picocolors";
 function report() {
@@ -191,9 +229,15 @@ function createBuildOptions(partialOptions) {
     ...DEFAULT_OPTIONS,
     ...partialOptions
   };
+  const typedModulesEnabled = options.css?.typedModules !== false;
   return {
     ...options,
-    plugins: [...options.plugins ?? [], useClient(), report()]
+    plugins: [
+      ...options.plugins ?? [],
+      ...typedModulesEnabled ? [cssTypedModulesPlugin()] : [],
+      useClient(),
+      report()
+    ]
   };
 }
 function getResolvedMinify(options) {
@@ -252,7 +296,7 @@ function isExternal(path2, options, packageJson) {
 // packages/bunup/src/plugins/internal/external-option.ts
 function externalOptionPlugin(options, packageJson) {
   return {
-    name: "bunup:external-option-plugin",
+    name: "bunup:external-option",
     setup(build) {
       build.onResolve({ filter: /.*/ }, (args) => {
         const importPath = args.path;
@@ -268,6 +312,36 @@ function externalOptionPlugin(options, packageJson) {
   };
 }
 
+// packages/bunup/src/plugins/utils.ts
+function filterBunPlugins(plugins) {
+  if (!plugins)
+    return [];
+  return plugins.filter((p) => ("setup" in p));
+}
+function filterBunupPlugins(plugins) {
+  if (!plugins)
+    return [];
+  return plugins.filter((p) => ("hooks" in p));
+}
+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 });
+    }
+  }
+}
+
 // packages/bunup/src/build.ts
 var ac = null;
 async function build(partialOptions, rootDir = process.cwd()) {

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "bunup",
 	"description": "⚡ A blazing-fast build tool for your libraries built with Bun.",
-	"version": "0.11.24",
+	"version": "0.11.25",
 	"type": "module",
 	"files": [
 		"dist"
@@ -47,23 +47,20 @@
 		"bunup": "dist/cli/index.js"
 	},
 	"dependencies": {
+		"@bunup/dts": "0.11.25",
 		"chokidar": "^4.0.3",
 		"coffi": "^0.1.35",
+		"lightningcss": "^1.30.1",
 		"picocolors": "^1.1.1",
 		"tinyexec": "^1.0.1",
-		"tree-kill": "^1.2.2",
-		"@bunup/dts": "0.11.18"
+		"tree-kill": "^1.2.2"
 	},
 	"peerDependencies": {
-		"typescript": ">=4.5.0",
-		"lightningcss": ">=1.17.0"
+		"typescript": ">=4.5.0"
 	},
 	"peerDependenciesMeta": {
 		"typescript": {
 			"optional": true
-		},
-		"lightningcss": {
-			"optional": true
 		}
 	},
 	"devDependencies": {