### Bunup Package with Multiple Entry Points and Formats

Source: https://bunup.dev/docs/guide/workspaces

This example shows a package ('main') configured with multiple build targets, including a main entry point with both ESM and CJS formats, and a separate CLI entry point with only ESM format.

```typescript
export default defineWorkspace([
	{
		name: "main",
		root: "packages/main",
		config: [
			{
				entry: "src/index.ts",
				name: "main",
				format: ["esm", "cjs"],
			},
			{
				entry: "src/cli.ts",
				name: "cli",
				format: ["esm"],
			},
		],
	},
]);
```

--------------------------------

### Bunup Path Resolution Example

Source: https://bunup.dev/docs/guide/workspaces

Illustrates how paths for `entry` and `outDir` in Bunup package configurations are resolved relative to the package's root directory. This ensures consistent path handling within each package.

```typescript
{
  name: "core",
  root: "packages/core",
  config: {
    entry: "src/index.ts",  // resolves to packages/core/src/index.ts
    outDir: "dist",         // outputs to packages/core/dist/
  },
}
```

--------------------------------

### Using Built-in Copy Plugin in Bunup

Source: https://bunup.dev/docs/guide/plugins

Shows an example of utilizing Bunup's built-in `copy` plugin to transfer files and directories to the build output directory. This is useful for including static assets.

```typescript
import { defineConfig } from "bunup";
import { copy } from "bunup/plugins";

export default defineConfig({
	entry: "src/index.ts",
	plugins: [copy(["README.md", "assets/**/*"])],
});
```

--------------------------------

### Using Bunup-Specific Plugins

Source: https://bunup.dev/docs/guide/plugins

Illustrates how to define and use custom Bunup plugins, which offer additional lifecycle hooks like `onBuildStart` and `onBuildDone` to interact with the build process.

```typescript
import { defineConfig, type BunupPlugin } from "bunup";

const myBunupPlugin: BunupPlugin = {
	name: "my-bunup-plugin",
	hooks: {
		onBuildStart(options) {
			// Called before build starts
		},
		onBuildDone(context) {
			// Called after build completes
		},
	},
};

export default defineConfig({
	entry: "src/index.ts",
	plugins: [myBunupPlugin],
});
```

--------------------------------

### Example package.json with Exports

Source: https://bunup.dev/docs/extra-options/exports

Illustrates the structure of a package.json file after Bunup has automatically generated the 'exports' field, including ESM/CJS formats and type declarations.

```json
{
	"name": "my-package",
	"version": "1.0.0",
	"type": "module",
	"files": [
		// [!code ++]
		"dist" // [!code ++]
	], // [!code ++]
	"module": "./dist/index.js", // [!code ++]
	"main": "./dist/index.cjs", // [!code ++]
	"types": "./dist/index.d.ts", // [!code ++]
	"exports": {
		// [!code ++]
		".": {
			// [!code ++]
			"import": {
				// [!code ++]
				"types": "./dist/index.d.ts", // [!code ++]
				"default": "./dist/index.js" // [!code ++]
			}, // [!code ++]
			"require": {
				// [!code ++]
				"types": "./dist/index.d.cts", // [!code ++]
				"default": "./dist/index.cjs" // [!code ++]
			} // [!code ++]
		} // [!code ++]
	} // [!code ++]
}
```

--------------------------------

### Enable Basic Minification (CLI & Config)

Source: https://bunup.dev/docs/guide/options

Activate all available minification options to reduce the size of your bundled output. This is a convenient way to apply comprehensive optimizations for production builds.

```sh
bunup --minify
```

```typescript
export default defineConfig({
	minify: true,
});
```

--------------------------------

### Install Bunup as a Dev Dependency

Source: https://bunup.dev/index

Installs Bunup as a development dependency in the project using the 'bun add' command. This makes Bunup available for build scripts within the project.

```shell
bun add --dev bunup
```

--------------------------------

### Basic Bunup Configuration

Source: https://bunup.dev/docs/guide/config-file

Sets up a basic `bunup.config.ts` file in the project root. This is the simplest way to centralize build settings. It requires importing `defineConfig` from 'bunup'.

```typescript
import { defineConfig } from "bunup";

export default defineConfig({
	// ...your configuration options go here
});
```

--------------------------------

### Install React Compiler Plugin

Source: https://bunup.dev/docs/recipes/react

Install the React Compiler plugin for Bunup using npm or yarn. This plugin optimizes React components automatically during the build process.

```bash
bun add --dev @bunup/plugin-react-compiler
```

--------------------------------

### Use Glob Patterns for Entry Points (CLI & Config)

Source: https://bunup.dev/docs/guide/typescript-declarations

Leverage glob patterns to match multiple files for declaration generation. This includes simple patterns like `src/**/*.ts` and exclusion patterns starting with `!`. Both CLI and `bunup.config.ts` support these patterns for flexible file selection.

```sh
# Single glob pattern
bunup --dts.entry "src/public/**/*.ts"

# Multiple patterns (including exclusions)
bunup --dts.entry "src/public/**/*.ts,!src/public/dev/**/*"
```

```typescript
export default defineConfig({
	dts: {
		entry: ["src/public/**/*.ts", "!src/public/dev/**/*"],
	},
});
```

--------------------------------

### Create New Project with Bunup CLI

Source: https://bunup.dev/docs/scaffold-with-bunup

This command initiates the project creation process using the Bunup CLI. It prompts the user with questions to configure the new project, offering 'Minimal' and 'Full' setup variants.

```sh
bunx @bunup/cli@latest create
```

--------------------------------

### Configure Build Report

Source: https://bunup.dev/docs/guide/options

Configures the build report to display file sizes and compression statistics. Supports enabling reporting for different compression algorithms like brotli.

```sh
# Enable brotli compression reporting (gzip is enabled by default)
bunup --report.brotli
```

--------------------------------

### Enable tsgo for Faster Declaration Generation (CLI & Config)

Source: https://bunup.dev/docs/guide/typescript-declarations

This snippet shows how to enable tsgo, TypeScript's experimental native compiler, for faster declaration generation. It requires installing the `@typescript/native-preview` package and can be configured via CLI flags or the `bunup.config.ts` file. `tsgo` only works when `inferTypes` is enabled.

```sh
bun add --dev @typescript/native-preview
bunup --dts.infer-types --dts.tsgo
```

```typescript
export default defineConfig({
	dts: {
		inferTypes: true,
		tsgo: true,
	},
});
```

--------------------------------

### Multiple Bunup Configurations

Source: https://bunup.dev/docs/guide/config-file

Exports an array of configurations from `bunup.config.ts` to build for multiple environments or formats in a single run. Each configuration requires a `name` property.

```typescript
export default defineConfig([
	{
		entry: "src/index.ts",
		name: "node",
		format: "esm",
		target: "node",
	},
	{
		entry: "src/browser.ts",
		name: "browser",
		format: ["esm", "iife"],
		target: "browser",
		outDir: "dist/browser",
	},
]);
```

```typescript
export default defineConfig([
	{
		entry: "src/index.ts",
		name: "main",
		format: ["esm", "cjs"],
	},
	{
		entry: "src/cli.ts",
		name: "cli",
		format: ["esm"],
	},
	{
		entry: "src/browser.ts",
		name: "browser",
		format: ["esm", "iife"],
		outDir: "dist/browser",
	},
]);
```

--------------------------------

### Basic Copy Plugin Configuration

Source: https://bunup.dev/docs/builtin-plugins/copy

Demonstrates the basic setup of the copy plugin within a bunup.config.ts file. It shows how to import the plugin and include it in the defineConfig configuration to copy specified files and directories.

```typescript
import {
	defineConfig
} from "bunup";
import { copy } from "bunup/plugins";

export default defineConfig({
	plugins: [copy(["README.md", "assets/**/*"])],
});
```

--------------------------------

### Create a TypeScript Function

Source: https://bunup.dev/index

Defines a simple TypeScript function 'greet' that takes a name as a string and returns a greeting string. This serves as an example of a basic TypeScript module.

```typescript
export function greet(name: string): string {
	return `Hello, ${name}`;
}
```

--------------------------------

### Customizing Output Directory for Executable

Source: https://bunup.dev/docs/advanced/compile

Customize the output directory for compiled executables using the 'outDir' option. This example changes the default 'bin/' to 'dist/'.

```typescript
export default defineConfig({
	entry: "src/cli.ts",
	compile: true,
	outDir: "dist", // Output to dist/ instead of bin/
});
```

--------------------------------

### Install Tailwind CSS Plugin

Source: https://bunup.dev/docs/builtin-plugins/tailwindcss

Installs the official Bunup plugin for Tailwind CSS as a development dependency using npm or yarn.

```bash
bun add --dev @bunup/plugin-tailwindcss
```

--------------------------------

### TypeScript: Minified vs Original Declaration Example

Source: https://bunup.dev/docs/guide/typescript-declarations

Compares an original TypeScript declaration file with its minified version. Minification shortens type names and removes comments, significantly reducing file size while preserving the public API.

```typescript
// Original:
type DeepPartial<T> = { [P in keyof T]?: DeepPartial<T[P]> };
interface Response<T> {
	data: T;
	error?: string;
	meta?: Record<string, unknown>;
}
declare function fetchData<T>(url: string, options?: RequestInit): Promise<Response<T>>;
export { fetchData, Response, DeepPartial };

// Minified:
type e<T> = { [P in keyof T]?: e<T[P]> };
interface t<T> {
	data: T;
	error?: string;
	meta?: Record<string, unknown>;
}
declare function n<T>(url: string, options?: RequestInit): Promise<t<T>>;
export { n as fetchData, t as Response, e as DeepPartial };
```

--------------------------------

### Initial Publish for Monorepo Packages

Source: https://bunup.dev/docs/scaffold-with-bunup

For monorepo setups, this command is used to perform the initial publish of individual packages. It requires navigating to the specific package directory before running the publish command with the '--access public' flag.

```sh
cd packages/my-first-package
bun publish --access public
```

--------------------------------

### Define Single Entry Point (CLI & Config)

Source: https://bunup.dev/docs/guide/options

Specify a single source file as the entry point for your Bunup build. This can be done directly via the CLI or within the bunup.config.ts file.

```sh
bunup src/index.ts
```

```typescript
export default defineConfig({
	entry: "src/index.ts",
});
```

--------------------------------

### Cross-Compiling to a Specific Target Platform

Source: https://bunup.dev/docs/advanced/compile

Compile your code for a specific target platform using the 'compile' option with a target string. This example targets Linux x64.

```typescript
export default defineConfig({
	entry: "src/cli.ts",
	compile: "bun-linux-x64", // Cross-compile for Linux
});
```

--------------------------------

### Import CSS in TypeScript

Source: https://bunup.dev/docs/guide/css

Demonstrates how to import CSS files directly into TypeScript for automatic bundling by Bunup. This is the simplest way to include styles in your project.

```typescript
import "./styles.css";
import { Button } from "./components/button";

export { Button };
```

--------------------------------

### Use Glob Patterns for Entry Points (CLI & Config)

Source: https://bunup.dev/docs/guide/options

Leverage glob patterns to dynamically include multiple files for bundling, with support for exclusions. This is configurable via the CLI or the bunup.config.ts file.

```sh
bunup 'src/**/*.ts' '!src/**/*.test.ts'
```

```typescript
export default defineConfig({
	entry: ["src/**/*.ts", "!src/**/*.test.ts", "!src/internal/**/*.ts"],
});
```

--------------------------------

### Basic CSS Stylesheet

Source: https://bunup.dev/docs/guide/css

A simple CSS file defining styles for a button element. Bunup will bundle this into the main CSS output.

```css
.button {
	background-color: #007bff;
	color: white;
	padding: 8px 16px;
	border: none;
	border-radius: 4px;
}
```

--------------------------------

### Using Native Bun Plugins with Bunup

Source: https://bunup.dev/docs/guide/plugins

Demonstrates how to incorporate native Bun plugins directly into your Bunup configuration. These plugins are passed to Bun's underlying bundler to modify its behavior.

```typescript
import { defineConfig } from "bunup";
import type { BunPlugin } from "bun";

const myBunPlugin: BunPlugin = {
	name: "my-plugin",
	setup(build) {
		// Bun plugin setup
	},
};

export default defineConfig({
	entry: "src/index.ts",
	plugins: [myBunPlugin],
});
```

--------------------------------

### Configure onSuccess Command Execution

Source: https://bunup.dev/docs/guide/options

Allows specifying a command to run after a successful build, with options for working directory, environment variables, timeout, and kill signal. This is useful for restarting servers or running post-build scripts. Available only in the configuration file.

```typescript
export default defineConfig({
	onSuccess: {
		cmd: "bun run ./scripts/server.ts",
		options: {
			cwd: "./app",
			env: { ...process.env, FOO: "bar" },
			timeout: 30000, // 30 seconds
			killSignal: "SIGKILL",
		},
	},
});
```

--------------------------------

### Add Banner and Footer to Bundles

Source: https://bunup.dev/docs/guide/options

Adds custom text to the beginning (banner) and end (footer) of generated bundle files. Useful for directives like 'use client' or license information.

```sh
bunup --banner 'use client' --footer '// built with love in SF'
```

```typescript
export default defineConfig({
	// Add text to the beginning of bundle files
	banner: '"use client";',
	// Add text to the end of bundle files
	footer: "// built with love in SF",
});
```

--------------------------------

### Bunup Package with Multiple Build Configurations

Source: https://bunup.dev/docs/guide/workspaces

Demonstrates configuring a single package ('web') with multiple, distinct build configurations. Each configuration requires a `name` property for identification and can specify different entry points, formats, and targets.

```typescript
export default defineWorkspace([
	{
		name: "web",
		root: "packages/web",
		config: [
			{
				entry: "src/index.ts",
				name: "node",
				format: "esm",
			target: "node",
			},
			{
				entry: "src/browser.ts",
				name: "browser",
				format: ["esm", "iife"],
			target: "browser",
			outDir: "dist/browser",
			},
		],
	},
]);
```

--------------------------------

### Compiled Scoped CSS Output

Source: https://bunup.dev/docs/builtin-plugins/tailwindcss

Example of the compiled CSS output in dist/index.css, showing scoped Tailwind CSS classes with the specified prefix (yuku).

```css
@layer theme {
	:root,
	:host {
		--yuku-color-blue-500: oklch(62.3% 0.214 259.815);
		--yuku-color-blue-600: oklch(54.6% 0.245 262.881);
		--yuku-color-white: #fff;
		--yuku-spacing: 0.25rem;
		--yuku-radius-md: 0.375rem;
	}
}

@layer base, components;

@layer utilities {
	.yuku\:rounded-md {
		border-radius: var(--yuku-radius-md);
	}

	.yuku\:bg-blue-500 {
		background-color: var(--yuku-color-blue-500);
	}

	.yuku\:px-4 {
		padding-inline: calc(var(--yuku-spacing) * 4);
	}

	.yuku\:py-2 {
		padding-block: calc(var(--yuku-spacing) * 2);
	}

	.yuku\:text-white {
		color: var(--yuku-color-white);
	}

	@media (hover: hover) {
		.yuku\:hover\:bg-blue-600:hover {
			background-color: var(--yuku-color-blue-600);
		}
	}
}
```

--------------------------------

### Configuring Copy Plugin Options: excludeDotfiles

Source: https://bunup.dev/docs/builtin-plugins/copy

Demonstrates how to use the `excludeDotfiles` option with the copy plugin. When set to `true`, files starting with a dot (e.g., `.env`) will be excluded from the copy operation.

```typescript
copy("assets/**/*").with({
	excludeDotfiles: true,
});
```

--------------------------------

### Define Multiple Entry Points (CLI & Config)

Source: https://bunup.dev/docs/guide/options

Configure Bunup to bundle multiple source files. Supports specifying files directly on the CLI, using the --entry flag, or providing an array of paths in the configuration file.

```sh
bunup src/index.ts src/cli.ts
```

```sh
bunup --entry src/index.ts --entry src/cli.ts
# or using alias
bunup -e src/index.ts -e src/cli.ts
```

```typescript
export default defineConfig({
	entry: ["src/index.ts", "src/cli.ts"],
});
```

--------------------------------

### Handle Environment Variables (CLI & Config)

Source: https://bunup.dev/docs/guide/options

Manage how environment variables are handled in your bundled code. Options include inlining all variables, disabling inlining, inlining variables with a specific prefix, or explicitly defining variables.

```sh
# Inline all environment variables available at build time
FOO=bar API_KEY=secret bunup --env inline

# Disable all environment variable inlining
bunup --env disable

# Only inline environment variables with a specific prefix (e.g., PUBLIC_)
PUBLIC_URL=https://example.com bunup --env PUBLIC_*

# Explicitly provide specific environment variables
bunup --env.NODE_ENV="production" --env.API_URL="https://api.example.com"
```

```typescript
export default defineConfig({
	// Inline all available environment variables at build time
	env: "inline",

	// Or disable inlining entirely (keep process.env.FOO in the output)
	// env: "disable",

	// Or inline only variables that start with a specific prefix
	// env: "PUBLIC_*",

	// Or explicitly provide specific environment variables
	// These will replace both process.env.FOO and import.meta.env.FOO
	// env: {
	//   API_URL: "https://api.example.com",
	//   DEBUG: "false",
	// },
});
```

--------------------------------

### Configure Source Base Directory (CLI & Config)

Source: https://bunup.dev/docs/guide/options

Define the base directory for entry points to control the output file structure. This option helps preserve the source directory hierarchy in the build output, especially with multiple entry points.

```bash
bunup --source-base ./src
```

```typescript
export default defineConfig({
	sourceBase: "./src",
});
```

--------------------------------

### Define Post-build Operations in Bunup

Source: https://bunup.dev/docs/guide/options

Configure actions to run after a successful build using the 'onSuccess' option. Supports function callbacks for custom logic or simple shell commands.

```typescript
export default defineConfig({
	onSuccess: (options) => {
		console.log("Build completed!");

		const server = startDevServer();

		// Optional: return a cleanup function for watch mode
		return () => server.close();
	},
});
```

```sh
bunup --on-success "bun run ./scripts/server.ts"
```

```typescript
export default defineConfig({
	onSuccess: "bun run ./scripts/server.ts",
});
```

--------------------------------

### Basic Bunup Workspace with Two Packages

Source: https://bunup.dev/docs/guide/workspaces

A minimal Bunup workspace configuration defining two packages, 'core' and 'utils'. The 'core' package specifies custom build formats, while 'utils' utilizes default settings for its build.

```typescript
import {
	defineWorkspace
} from "bunup";

export default defineWorkspace([
	{
		name: "core",
		root: "packages/core",
		config: {
			// Bunup finds 'src/index.ts' by default
			// Or specify exactly which files to build
			// entry: ["src/index.ts", "src/plugins.ts"],
			format: ["esm", "cjs"],
		},
	},
	{
		name: "utils",
		root: "packages/utils",
		// Uses default entry points
		// Uses default format: esm
		// Generates .d.ts declaration files
	},
]);
```

--------------------------------

### Generated TypeScript Definitions for CSS Modules

Source: https://bunup.dev/docs/guide/css

Illustrates the TypeScript definition file automatically generated by Bunup for CSS Modules. This provides type safety and autocompletion for CSS class names.

```ts
declare const classes: {
	readonly primary: string;
	readonly secondary: string;
};

export default classes;
```

--------------------------------

### Configure Loader Options (CLI & Config)

Source: https://bunup.dev/docs/guide/options

Customize how different file types are loaded and processed by bunup. You can map file extensions to built-in loader names. This is useful for handling non-JavaScript assets.

```bash
bunup --loader.".css"=text --loader.".txt"=file
```

```typescript
export default defineConfig({
	loader: {
		".css": "text",
		".txt": "file",
	},
});
```

--------------------------------

### Custom Bunup Configuration Path via CLI

Source: https://bunup.dev/docs/guide/config-file

Specifies a custom path for the Bunup configuration file using the `--config` or `-c` CLI option. This allows for non-standard file names or locations.

```bash
bunup --config ./configs/custom.bunup.config.ts
# or using alias
bunup -c ./configs/custom.bunup.config.ts
```

--------------------------------

### Import and Use React Component Library

Source: https://bunup.dev/docs/recipes/react

Example of how a consumer application would import and use components from a published React component library. It shows importing styles and the Button component.

```tsx
import "my-component-library/styles.css";
import { Button } from "my-component-library";

function App() {
	return <Button>Click me</Button>;
}

```

--------------------------------

### Filtering Bunup Configurations via CLI

Source: https://bunup.dev/docs/guide/config-file

Uses the `--filter` CLI option to build only specific configurations by name when multiple configurations are defined in `bunup.config.ts`. This is useful for testing individual builds.

```bash
# Single
bunup --filter main

# Multiple
bunup --filter main,browser
```

--------------------------------

### Bundle All Dependencies (CLI & Config)

Source: https://bunup.dev/docs/guide/options

Force all project dependencies to be included directly within the bundle, overriding the default behavior. Configure this using the --packages bundle flag on the CLI or the packages option in bunup.config.ts.

```sh
bunup --packages bundle
```

```typescript
export default defineConfig({
	packages: "bundle",
});
```

--------------------------------

### Composing Styles from Another CSS Module

Source: https://bunup.dev/docs/guide/css

Shows how to compose styles from a different CSS module file using the `composes` property, specifying the relative path to the source file. This enables sharing styles across modules.

```css
.primary {
	composes: base from "../shared.module.css";
	background-color: #007bff;
	color: white;
}
```

--------------------------------

### Configure Separate CSS Entry Points

Source: https://bunup.dev/docs/guide/css

Configures Bunup to treat specific CSS files as entry points, generating separate CSS files in the build output instead of a single bundled file. This is useful for managing distinct style sets.

```typescript
import { defineConfig } from 'bunup';

export default defineConfig({
  entry: [
    'src/index.ts',
    'src/components/button.css'
    'src/components/alert.css'
  ],
});
```

--------------------------------

### Define Global Build-Time Constants

Source: https://bunup.dev/docs/guide/options

Allows defining global constants that are replaced during the build process. Useful for feature flags, version numbers, or environment-specific configurations. Values are treated as strings and should be quoted if necessary.

```sh
bunup --define.PACKAGE_VERSION='"1.0.0"' --define.DEBUG='false'
```

```typescript
export default defineConfig({
	define: {
		PACKAGE_VERSION: '"1.0.0"',
		DEBUG: "false",
	},
});
```

--------------------------------

### Define Workspace Configuration with Bunup

Source: https://bunup.dev/docs/guide/workspaces

This snippet demonstrates how to initialize a Bunup workspace configuration using the `defineWorkspace` function. It serves as the entry point for defining your monorepo's package structure and build settings.

```typescript
import {
	defineWorkspace
} from "bunup";

export default defineWorkspace([
	// Package configurations go here
]);
```

--------------------------------

### Bunup Development Workflow Commands

Source: https://bunup.dev/docs/scaffold-with-bunup

A set of commands to manage the development lifecycle of a Bunup-scaffolded project. These include starting the development server, running tests, linting, fixing code style issues, type checking, and building the production bundle.

```sh
bun run dev
bun run test
bun run lint
bun run lint:fix
bun run type-check
bun run build
```

--------------------------------

### Initial Publish for Single Package

Source: https://bunup.dev/docs/scaffold-with-bunup

For single-package projects, this command is used to perform the initial publish. It should be run from the root directory of the project with the '--access public' flag.

```sh
bun publish --access public
```

--------------------------------

### Configuring Copy Plugin Options: followSymlinks

Source: https://bunup.dev/docs/builtin-plugins/copy

Shows how to configure the `followSymlinks` option for the copy plugin. Setting this to `true` ensures that symbolic links are followed when copying files and directories.

```typescript
copy("assets/**/*").with({
	followSymlinks: true,
});
```

--------------------------------

### Using Glob Patterns for File Selection

Source: https://bunup.dev/docs/builtin-plugins/copy

Shows how to leverage glob patterns with the copy plugin to select files and directories based on flexible matching rules. This includes recursive copying and combining multiple patterns.

```typescript
// Copy all markdown files recursively
copy("**/*.md");

// Copy all files in assets directory
copy("assets/**/*");

// Copy with multiple patterns
copy([
	"assets/**/*", // All files in assets
	"docs/**/*.md", // Markdown files in docs
	"src/**/*.css", // CSS files in src
]);
```

--------------------------------

### Copying Files and Directories

Source: https://bunup.dev/docs/builtin-plugins/copy

Illustrates various ways to use the copy plugin for handling files and directories. This includes copying single files, multiple files, entire directories, and renaming them during the copy process.

```typescript
// Copy single file
copy("README.md");

// Copy multiple specific files
copy(["README.md", "LICENSE", "CHANGELOG.md"]);

// Copy and rename a file
copy("README.md").to("documentation.md");

// Copy entire directory as is (preserves structure)
copy("assets"); // → dist/assets/

// Copy and rename directory
copy("assets").to("static"); // → dist/static/

// Copy multiple directories
copy(["assets", "public", "docs"]);
```

--------------------------------

### Disable CSS Module Type Generation (CLI)

Source: https://bunup.dev/docs/guide/css

Disables the automatic generation of TypeScript definition files for CSS Modules using the Bunup CLI command.

```sh
bunup --no-css.typed-modules
```

--------------------------------

### Composing Styles within a CSS Module

Source: https://bunup.dev/docs/guide/css

Demonstrates how to reuse styles within the same CSS module using the `composes` property. This promotes DRY principles in CSS.

```css
.base {
	padding: 8px 16px;
	border: none;
	border-radius: 4px;
	cursor: pointer;
}

.primary {
	composes: base;
	background-color: #007bff;
	color: white;
}

.secondary {
	composes: base;
	background-color: transparent;
	color: #007bff;
	border: 1px solid #007bff;
}
```

--------------------------------

### Disable CSS Module Type Generation (Config)

Source: https://bunup.dev/docs/guide/css

Disables the automatic generation of TypeScript definition files for CSS Modules by setting `typedModules: false` in the `bunup.config.ts` file.

```typescript
import { defineConfig } from "bunup";

export default defineConfig({
	css: {
		typedModules: false,
	},
});
```

--------------------------------

### Consumer Importing Components with Injected CSS

Source: https://bunup.dev/docs/builtin-plugins/tailwindcss

Demonstrates how consumers import components when the CSS is injected at runtime. No explicit CSS import is required.

```javascript
import { Button } from "your-package";

<Button />;
```

--------------------------------

### Basic Bunup Build Programmatically (TypeScript)

Source: https://bunup.dev/docs/advanced/programmatic-usage

Demonstrates the fundamental usage of the `build` function from the 'bunup' library to create a build. It imports the function, calls it with an entry point, and logs the resulting files and build context. This function must be executed within the Bun runtime.

```typescript
import { build } from "bunup";

const result = await build({
	entry: "src/index.ts",
});

console.log("Built files:", result.files);
console.log("Build context:", result.build);
```

--------------------------------

### Enable Watch Mode with Bunup CLI

Source: https://bunup.dev/index

Starts Bunup in watch mode, which automatically rebuilds the project whenever changes are detected in the source files. This is ideal for development workflows.

```shell
bunx bunup --watch
```

--------------------------------

### Run Build Script from package.json

Source: https://bunup.dev/index

Executes the 'build' script defined in the project's 'package.json' file, which is configured to run 'bunup'. This is a standard way to trigger the build process.

```shell
bun run build
```

--------------------------------

### Enable Silent Build Mode

Source: https://bunup.dev/docs/guide/options

Disables logging output during the build process, providing minimal console feedback. Useful for CI/CD environments or when only build success/failure is needed.

```sh
bunup --silent
# or using alias
bunup -q
```

```typescript
export default defineConfig({
	silent: true,
});
```

--------------------------------

### Compiling Multiple Entrypoints to Executables

Source: https://bunup.dev/docs/advanced/compile

Compile multiple entry points into separate executables by using an array of build configurations. Each object in the array defines a distinct build, allowing for different compile settings per entry point.

```typescript
export default defineConfig([
	{
		name: "main",
		entry: "src/main.ts",
		compile: true,
	},
	{
		name: "cli",
		entry: "src/cli.ts",
		compile: {
			outfile: "my-cli",
		},
	},
]);
```

--------------------------------

### Control Output Directory Cleaning

Source: https://bunup.dev/docs/guide/options

Configure whether Bunup should clean the output directory before each build. By default, cleaning is enabled. This can be controlled via CLI flag or configuration.

```sh
bunup --no-clean
```

```typescript
export default defineConfig({
	clean: false,
});
```

--------------------------------

### Specify Custom Tsconfig Path in Bunup

Source: https://bunup.dev/docs/guide/options

Define a custom tsconfig file to be used for build path resolution and TypeScript declaration generation. Defaults to the nearest tsconfig.json.

```sh
bunup --preferred-tsconfig ./tsconfig.build.json
```

```typescript
export default defineConfig({
	entry: "src/index.ts",
	preferredTsconfig: "./tsconfig.build.json",
});
```

--------------------------------

### Configure JSX Transform in Bunup

Source: https://bunup.dev/docs/guide/options

Customize JSX transformation behavior, including runtime mode, import source, factory/fragment names, side effects, and development mode.

```sh
# Set JSX runtime mode to automatic
bunup --jsx.runtime automatic

# Configure import source for JSX
bunup --jsx.import-source preact

# Configure JSX factory and fragment
bunup --jsx.factory h --jsx.fragment Fragment

# Enable JSX side effects
bunup --jsx.side-effects

# Enable JSX development mode
bunup --jsx.development
```

```typescript
export default defineConfig({
	jsx: {
		runtime: "automatic", // or 'classic'
		importSource: "preact",
		factory: "h",
		fragment: "Fragment",
		sideEffects: false,
		development: false,
	},
});
```

--------------------------------

### Configure Environment Variables with Bunup

Source: https://bunup.dev/docs/guide/options

Control how environment variables are inlined during the build process. Options include 'inline', 'disable', 'PREFIX_*', or a key-value object for direct replacement.

```sh
# Inline all environment variables
bunup --env inline

# Disable environment variable replacement
bunup --env disable

# Inline variables with a specific prefix
bunup --env PUBLIC_*

# Inline specific key-value pairs
bunup --env "{ MY_VAR: 'my_value', ANOTHER_VAR: 'another_value' }"
```

--------------------------------

### Create a Bundle Size Reporter Plugin (TypeScript)

Source: https://bunup.dev/docs/advanced/plugin-development

A Bunup plugin that reports the sizes of generated entry-point files after a build is complete. It can optionally enforce a maximum bundle size, throwing an error if exceeded. Dependencies include Bun API for file access.

```typescript
export function bundleSizeReporter(maxSize?: number): BunupPlugin {
	return {
		name: "bundle-size-reporter",
		hooks: {
			onBuildDone: async ({ files }) => {
				const sizes = await Promise.all(
					files
						.filter((f) => f.kind === "entry-point")
						.map(async (file) => {
							const buffer = await Bun.file(file.fullPath).arrayBuffer();
							return {
								path: file.pathRelativeToOutdir,
								size: buffer.byteLength,
								format: file.format,
						};
						}),
				);

				console.log("\n📦 Bundle Sizes:");
				for (const { path, size, format } of sizes) {
					const sizeKB = (size / 1024).toFixed(2);
					console.log(`  ${path} (${format}): ${sizeKB} KB`);

					if (maxSize && size > maxSize) {
						throw new Error(`Bundle ${path} exceeds maximum size of ${maxSize} bytes`);
					}
				}
			},
		},
	};
}

```

--------------------------------

### Run Bunup in Watch Mode

Source: https://bunup.dev/docs/guide/workspaces

Executes Bunup in watch mode, rebuilding only changed packages within specified workspaces. This is useful for development workflows where incremental updates are desired.

```bash
bunx bunup --filter core,utils --watch
```

--------------------------------

### Export CSS for Package Consumers

Source: https://bunup.dev/docs/guide/css

Configures the `package.json` to export a specific CSS file, allowing users of the package to import the styles directly. This is crucial for distributing styles with libraries.

```json
{
	"exports": {
		".": {
			"import": "./dist/index.js",
			"types": "./dist/index.d.ts"
		},
		"./styles.css": "./dist/index.css" // [!code ++]
	}
}
```

--------------------------------

### Control Dead Code Elimination Annotations

Source: https://bunup.dev/docs/guide/options

Configure how dead code elimination (DCE) annotations like `@__PURE__` and `sideEffects` are handled. Options include ignoring them or forcing their emission.

```sh
# Ignore @__PURE__ annotations and sideEffects
bunup --ignore-dce-annotations

# Force emit @__PURE__ annotations even with minification
bunup --emit-dce-annotations
```

```typescript
export default defineConfig({
	ignoreDCEAnnotations: true,
	// or
	emitDCEAnnotations: true,
});
```

--------------------------------

### Basic Compilation to Executable

Source: https://bunup.dev/docs/advanced/compile

This configuration enables the creation of a standalone executable for the current platform. The compiled output will be placed in the 'bin/' directory by default.

```typescript
export default defineConfig({
	entry: "src/cli.ts",
	compile: true, // Create executable for current platform
});
```

--------------------------------

### Build Specific Packages with Bunup Filter

Source: https://bunup.dev/docs/guide/workspaces

Command to build only specific packages within the Bunup workspace using the `--filter` option. This allows for targeted builds, improving efficiency.

```shell
bunx bunup --filter core,utils
```

--------------------------------

### Configure Granular Minification (CLI & Config)

Source: https://bunup.dev/docs/guide/options

Control specific minification aspects like whitespace, identifiers, and syntax. This allows for fine-tuning optimizations based on your project's needs. Individual options take precedence over the general `--minify` flag.

```sh
# Single option - minify whitespace only
bunup --minify-whitespace

# Multiple options - minify whitespace and syntax, but not identifiers
bunup --minify-whitespace --minify-syntax
```

```typescript
export default defineConfig({
	// Configure individual options
	minifyWhitespace: true,
	minifyIdentifiers: false,
	minifySyntax: true,
});
```

--------------------------------

### Bunup Workspace with Shared Options

Source: https://bunup.dev/docs/guide/workspaces

This configuration illustrates how to apply shared build options across multiple packages in a Bunup workspace. Individual package configurations can override these shared options.

```typescript
export default defineWorkspace(
	[
		{
			name: "core",
			root: "packages/core",
			config: {
				format: ["esm"], // overrides shared format
			},
		},
		{
			name: "utils",
			root: "packages/utils",
			// config is optional, shared options apply
		},
	],
	{
		// Shared options
		format: ["esm", "cjs"],
		exports: true,
	},
);
```

--------------------------------

### Specify Custom Entry Points for Bunup

Source: https://bunup.dev/index

Builds the project using Bunup, explicitly specifying the entry point files to be processed. This overrides the default entry point detection mechanism.

```shell
bunx bunup src/index.ts src/plugins.ts
```

--------------------------------

### Specify Package.json Export Conditions

Source: https://bunup.dev/docs/guide/options

Allows defining custom conditions for resolving imports based on package.json's 'exports' field. This controls which conditional exports are used during module resolution.

```sh
# Single condition
bunup --conditions development

# Multiple conditions
bunup --conditions development,node
```

```typescript
export default defineConfig({
	conditions: ["development", "node"],
});
```

--------------------------------

### Configure Entry Points and Source Base Directory (CLI & Config)

Source: https://bunup.dev/docs/extra-options/exports

Define entry points for bundling using glob patterns and control the base directory for source files. Setting 'sourceBase' removes the specified directory from the generated export keys, simplifying the public API structure. Supports CLI and configuration file.

```bash
bunup 'src/**/*.ts' --source-base ./src
```

```typescript
export default defineConfig({
	entry: ["src/**/*.ts"],
	sourceBase: "./src",
});
```

--------------------------------

### Set Target Environment (CLI & Config)

Source: https://bunup.dev/docs/guide/options

Specify the target environment for your Bunup bundle. This optimizes the output for different runtimes like Node.js, browsers, or the Bun runtime itself. The default is 'node'.

```sh
bunup --target browser
# or using alias
bunup -t browser
```

```typescript
export default defineConfig({
	target: "browser",
});
```

--------------------------------

### Build and Sync Package Exports

Source: https://bunup.dev/index

Builds the TypeScript project and automatically generates and synchronizes package export configurations. This simplifies managing entry points for published packages.

```shell
bunx bunup --exports
```

--------------------------------

### Bunup Release Command

Source: https://bunup.dev/docs/scaffold-with-bunup

This command initiates the package release process. It prompts for a new version, updates the package.json, creates a Git tag, and pushes changes to GitHub. A GitHub Actions workflow then handles building, generating release notes, and publishing to npm.

```sh
bun run release
```

--------------------------------

### Define Build Metadata Type (TypeScript)

Source: https://bunup.dev/docs/advanced/plugin-development

Defines the structure for build metadata used within Bunup plugins. It includes the parsed package.json content and the project's root directory.

```typescript
type BuildMeta = {
	packageJson: PackageJson;
	rootDir: string;
};

```

--------------------------------

### CSS Modules for Scoped Styles

Source: https://bunup.dev/docs/guide/css

Defines scoped CSS styles using CSS Modules by appending `.module.css` to the filename. This prevents class name collisions by generating unique class names.

```css
.primary {
	background-color: #007bff;
	color: white;
	padding: 8px 16px;
	border: none;
	border-radius: 4px;
}
```

--------------------------------

### Bunup Build with Plugins Programmatically (TypeScript)

Source: https://bunup.dev/docs/advanced/programmatic-usage

Demonstrates how to integrate plugins into a Bunup build when using the library programmatically. It shows the usage of the `tailwindcss` and `copy` plugins within the `plugins` array of the build options. This requires the 'bunup' library and relevant plugins, and must be run in the Bun runtime.

```typescript
import { build } from "bunup";
import { copy } from "bunup/plugins";
import { tailwindcss } from "@bunup/plugin-tailwindcss";

await build({
	entry: "src/index.ts",
	plugins: [
		tailwindcss({
			minify: true,
		}),
		copy(["README.md", "assets/**/*"]),
	],
});
```

--------------------------------

### Build TypeScript Project with Multiple Formats

Source: https://bunup.dev/index

Builds the current TypeScript project using the Bunup CLI, generating output in both ECMAScript Module (ESM) and CommonJS (CJS) formats. This is useful for broader compatibility.

```shell
bunx bunup --format esm,cjs
```