bunup 0.8.4 → 0.8.6

package/dist/cli.js

@@ -259,7 +259,7 @@ var import_picocolors2, BunupError, BunupBuildError, BunupDTSBuildError, BunupCL
 }, KNOWN_ERRORS, handleError = (error, context) => {
   const errorMessage = parseErrorMessage(error);
   const contextPrefix = context ? `[${context}] ` : "";
-  let errorType = "";
+  let errorType = "UNKNOWN ERROR";
   if (error instanceof BunupBuildError) {
     errorType = "BUILD ERROR";
   } else if (error instanceof BunupDTSBuildError) {
@@ -411,378 +411,6 @@ var init_utils = __esm(() => {
   init_errors();
 });
 
-// src/loaders.ts
-import path2 from "path";
-import { loadConfig } from "coffi";
-async function processLoadedConfigs(config, cwd, filter) {
-  return Array.isArray(config) && "root" in config[0] ? config.filter((c) => filter ? filter.includes(c.name) : true).map((c) => ({
-    rootDir: path2.resolve(cwd, c.root),
-    options: addField(c.config, "name", c.name)
-  })) : [
-    {
-      rootDir: cwd,
-      options: config
-    }
-  ];
-}
-function addField(objectOrArray, field, value) {
-  return Array.isArray(objectOrArray) ? objectOrArray.map((o) => ({ ...o, [field]: value })) : { ...objectOrArray, [field]: value };
-}
-async function loadPackageJson(cwd) {
-  const { config, filepath } = await loadConfig({
-    name: "package",
-    cwd,
-    extensions: [".json"]
-  });
-  return {
-    data: config,
-    path: filepath
-  };
-}
-var init_loaders = () => {};
-
-// src/helpers/entry.ts
-function getProcessableEntries(entry) {
-  if (typeof entry === "string") {
-    return [
-      {
-        entry,
-        outputBasePath: getEntryOutputBasePath(entry)
-      }
-    ];
-  }
-  if (typeof entry === "object" && !Array.isArray(entry)) {
-    return Object.entries(entry).map(([name, path3]) => ({
-      entry: path3,
-      outputBasePath: name
-    }));
-  }
-  return entry.map((_entry) => ({
-    entry: _entry,
-    outputBasePath: getEntryOutputBasePath(_entry)
-  }));
-}
-function getEntryOutputBasePath(entry) {
-  const pathSegments = cleanPath(removeExtension(entry)).split("/");
-  return pathSegments.length > 1 ? pathSegments.slice(1).join("/") : pathSegments.join("/");
-}
-function getResolvedNaming(outputBasePath, extension) {
-  return {
-    entry: `[dir]/${outputBasePath}${extension}`,
-    chunk: `${outputBasePath}-[hash].[ext]`,
-    asset: `${outputBasePath}-[name]-[hash].[ext]`
-  };
-}
-var init_entry = __esm(() => {
-  init_utils();
-});
-
-// src/plugins/internal/use-client.ts
-function useClient() {
-  return {
-    type: "bunup",
-    name: "use-client",
-    hooks: {
-      onBuildDone: async ({ output }) => {
-        for (const file of output.files) {
-          let text = await Bun.file(file.fullPath).text();
-          const hasUseClient = text.split(`
-`).some((line) => line.trim().startsWith(`"use client";`));
-          if (hasUseClient) {
-            text = text.replaceAll(`"use client";`, "");
-            text = `"use client";
-${text}`;
-          }
-          await Bun.write(file.fullPath, text);
-        }
-      }
-    }
-  };
-}
-
-// src/options.ts
-function createBuildOptions(partialOptions) {
-  const options = {
-    ...DEFAULT_OPTIONS,
-    ...partialOptions
-  };
-  return {
-    ...options,
-    plugins: [...options.plugins ?? [], useClient()]
-  };
-}
-function getResolvedMinify(options) {
-  const { minify, minifyWhitespace, minifyIdentifiers, minifySyntax } = options;
-  const defaultValue = minify === true;
-  return {
-    whitespace: minifyWhitespace ?? defaultValue,
-    identifiers: minifyIdentifiers ?? defaultValue,
-    syntax: minifySyntax ?? defaultValue
-  };
-}
-function getResolvedBytecode(bytecode, format) {
-  return format === "cjs" ? bytecode : undefined;
-}
-function getResolvedSourcemap(sourcemap) {
-  if (sourcemap === true) {
-    return "inline";
-  }
-  return typeof sourcemap === "string" ? sourcemap : undefined;
-}
-function getResolvedDefine(define, env) {
-  return {
-    ...typeof env === "object" && Object.keys(env).reduce((acc, key) => {
-      const value = JSON.stringify(env[key]);
-      acc[`process.env.${key}`] = value;
-      acc[`import.meta.env.${key}`] = value;
-      return acc;
-    }, {}),
-    ...define
-  };
-}
-function getResolvedSplitting(splitting, format) {
-  return splitting === undefined ? format === "esm" : splitting;
-}
-function getResolvedEnv(env) {
-  return typeof env === "string" ? env : undefined;
-}
-var DEFAULT_OPTIONS;
-var init_options = __esm(() => {
-  DEFAULT_OPTIONS = {
-    entry: [],
-    format: ["cjs"],
-    outDir: "dist",
-    target: "node",
-    clean: true
-  };
-});
-
-// src/helpers/external.ts
-function getPackageDepsPatterns(packageJson) {
-  return getPackageDeps(packageJson).map((dep) => new RegExp(`^${dep}($|\\/|\\\\)`));
-}
-function matchesPattern(path3, pattern) {
-  return typeof pattern === "string" ? pattern === path3 : pattern.test(path3);
-}
-function isExternal(path3, options, packageJson) {
-  const packageDepsPatterns = getPackageDepsPatterns(packageJson);
-  const matchesExternalPattern = packageDepsPatterns.some((pattern) => pattern.test(path3)) || options.external?.some((pattern) => matchesPattern(path3, pattern));
-  const isExcludedFromExternal = options.noExternal?.some((pattern) => matchesPattern(path3, pattern));
-  return matchesExternalPattern && !isExcludedFromExternal;
-}
-var init_external = __esm(() => {
-  init_utils();
-});
-
-// src/plugins/internal/external-option.ts
-function externalOptionPlugin(options, packageJson) {
-  return {
-    name: "bunup:external-option-plugin",
-    setup(build) {
-      build.onResolve({ filter: /.*/ }, (args) => {
-        const importPath = args.path;
-        if (isExternal(importPath, options, packageJson)) {
-          return {
-            path: importPath,
-            external: true
-          };
-        }
-        return null;
-      });
-    }
-  };
-}
-var init_external_option = __esm(() => {
-  init_external();
-});
-
-// src/plugins/utils.ts
-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 });
-    }
-  }
-}
-
-// src/build.ts
-var exports_build = {};
-__export(exports_build, {
-  build: () => build
-});
-import path3 from "path";
-import { generateDts, logIsolatedDeclarationErrors } from "bun-dts";
-async function build(partialOptions, rootDir = process.cwd()) {
-  const buildOutput = {
-    files: []
-  };
-  const options = createBuildOptions(partialOptions);
-  if (!options.entry || options.entry.length === 0 || !options.outDir) {
-    throw new BunupBuildError("Nothing to build. Please make sure you have provided a proper bunup configuration or cli arguments.");
-  }
-  if (options.clean) {
-    cleanOutDir(rootDir, options.outDir);
-  }
-  setSilent(options.silent);
-  const packageJson = await loadPackageJson(rootDir);
-  if (packageJson.data && packageJson.path) {
-    logger.cli(`Using ${getShortFilePath(packageJson.path, 2)}`, {
-      muted: true,
-      identifier: options.name,
-      once: `${packageJson.path}:${options.name}`
-    });
-  }
-  const bunupPlugins = filterBunupPlugins(options.plugins);
-  await runPluginBuildStartHooks(bunupPlugins, options);
-  const processableEntries = getProcessableEntries(options.entry);
-  const packageType = packageJson.data?.type;
-  const plugins = [
-    externalOptionPlugin(options, packageJson.data),
-    ...filterBunupBunPlugins(options.plugins).map((p) => p.plugin)
-  ];
-  if (!options.dtsOnly) {
-    const buildPromises = options.format.flatMap((fmt) => processableEntries.map(async ({ entry, outputBasePath }) => {
-      const extension = options.outputExtension?.({
-        format: fmt,
-        packageType,
-        options,
-        entry
-      }).js ?? getDefaultJsOutputExtension(fmt, packageType);
-      const result = await Bun.build({
-        entrypoints: [`${rootDir}/${entry}`],
-        format: fmt,
-        naming: getResolvedNaming(outputBasePath, extension),
-        splitting: getResolvedSplitting(options.splitting, fmt),
-        bytecode: getResolvedBytecode(options.bytecode, fmt),
-        define: getResolvedDefine(options.define, options.env),
-        minify: getResolvedMinify(options),
-        outdir: `${rootDir}/${options.outDir}`,
-        target: options.target,
-        sourcemap: getResolvedSourcemap(options.sourcemap),
-        loader: options.loader,
-        drop: options.drop,
-        banner: options.banner,
-        footer: options.footer,
-        publicPath: options.publicPath,
-        env: getResolvedEnv(options.env),
-        plugins,
-        throw: false
-      });
-      for (const log of result.logs) {
-        if (log.level === "error") {
-          console.log(`
-`);
-          console.log(log);
-          console.log(`
-`);
-          throw new Error;
-        }
-        if (log.level === "warning")
-          logger.warn(log.message);
-        else if (log.level === "info")
-          logger.info(log.message);
-      }
-      for (const file of result.outputs) {
-        const relativePathToRootDir = getRelativePathToRootDir(file.path, rootDir);
-        if (file.kind === "entry-point") {
-          logger.progress(fmt.toUpperCase(), relativePathToRootDir, {
-            identifier: options.name
-          });
-        }
-        buildOutput.files.push({
-          fullPath: file.path,
-          relativePathToRootDir,
-          dts: false,
-          entry,
-          outputBasePath,
-          format: fmt
-        });
-      }
-    }));
-    await Promise.all(buildPromises);
-  }
-  if (options.dts === true || typeof options.dts === "object" || options.dtsOnly) {
-    const dtsResolve = typeof options.dts === "object" && "resolve" in options.dts ? options.dts.resolve : undefined;
-    const dtsEntry = typeof options.dts === "object" && "entry" in options.dts ? options.dts.entry : undefined;
-    const processableDtsEntries = dtsEntry ? getProcessableEntries(dtsEntry) : processableEntries;
-    const dtsPromises = processableDtsEntries.map(async ({ entry, outputBasePath }) => {
-      const result = await generateDts(entry, {
-        cwd: rootDir,
-        preferredTsConfigPath: options.preferredTsconfigPath,
-        resolve: dtsResolve
-      });
-      for (const fmt of options.format) {
-        const extension = options.outputExtension?.({
-          format: fmt,
-          packageType,
-          options,
-          entry
-        }).dts ?? getDefaultDtsOutputExtension(fmt, packageType);
-        const filePath = path3.join(rootDir, options.outDir, `${outputBasePath}${extension}`);
-        const relativePathToRootDir = getRelativePathToRootDir(filePath, rootDir);
-        buildOutput.files.push({
-          fullPath: filePath,
-          relativePathToRootDir,
-          dts: true,
-          entry,
-          outputBasePath,
-          format: fmt
-        });
-        if (result.errors.length > 0) {
-          logIsolatedDeclarationErrors(result.errors, {
-            warnInsteadOfError: options.watch,
-            shouldExit: true
-          });
-        }
-        await Bun.write(filePath, result.dts);
-        logger.progress("DTS", relativePathToRootDir, {
-          identifier: options.name
-        });
-      }
-    });
-    await Promise.all(dtsPromises);
-  }
-  await runPluginBuildDoneHooks(bunupPlugins, options, buildOutput, {
-    packageJson
-  });
-  if (options.onSuccess) {
-    await options.onSuccess(options);
-  }
-}
-function getRelativePathToRootDir(filePath, rootDir) {
-  return filePath.replace(`${rootDir}/`, "");
-}
-var init_build = __esm(() => {
-  init_errors();
-  init_entry();
-  init_loaders();
-  init_logger();
-  init_options();
-  init_external_option();
-  init_utils();
-});
-
 // src/cli/new.ts
 var exports_new = {};
 __export(exports_new, {
@@ -802,12 +430,12 @@ import {
 import { downloadTemplate } from "giget";
 import { replaceInFile } from "replace-in-file";
 async function newProject() {
-  intro(import_picocolors5.default.bgCyan(import_picocolors5.default.black(" Scaffold a new project with Bunup ")));
+  intro(import_picocolors6.default.bgCyan(import_picocolors6.default.black(" Scaffold a new project with Bunup ")));
   const selectedTemplateDir = await select({
     message: "Select a template",
     options: TEMPLATES.map((template2) => ({
       value: template2.dir,
-      label: import_picocolors5.default.blue(template2.name)
+      label: import_picocolors6.default.blue(template2.name)
     }))
   });
   const template = TEMPLATES.find((t) => t.dir === selectedTemplateDir);
@@ -893,23 +521,23 @@ async function newProject() {
     }
   ]);
   outro(`
-  ${import_picocolors5.default.green("\u2728 Project scaffolded successfully! \u2728")} 
+  ${import_picocolors6.default.green("\u2728 Project scaffolded successfully! \u2728")} 
 
-  ${import_picocolors5.default.bold("Ready to launch your awesome new project?")}
+  ${import_picocolors6.default.bold("Ready to launch your awesome new project?")}
   
-  ${import_picocolors5.default.cyan("cd")} ${projectName}
-  ${import_picocolors5.default.cyan("bun install")}
-  ${import_picocolors5.default.cyan("bun run dev")}
+  ${import_picocolors6.default.cyan("cd")} ${projectName}
+  ${import_picocolors6.default.cyan("bun install")}
+  ${import_picocolors6.default.cyan("bun run dev")}
   
-  ${import_picocolors5.default.yellow("Happy coding!")} \uD83D\uDE80
+  ${import_picocolors6.default.yellow("Happy coding!")} \uD83D\uDE80
   `);
 }
 function getProjectPath(projectName) {
   return path5.join(process.cwd(), projectName);
 }
-var import_picocolors5, TEMPLATE_OWNER = "arshad-yaseen", TEMPLATE_REPO = "bunup-new", GITHUB_USERNAME_PLACEHOLDER = "username", GITHUB_REPO_PLACEHOLDER = "repo-name", MONOREPO_FIRST_PACKAGE_NAME_PLACEHOLDER = "package-1", MONOREPO_PACKAGES_DIR = "packages", TEMPLATES;
+var import_picocolors6, TEMPLATE_OWNER = "arshad-yaseen", TEMPLATE_REPO = "bunup-new", GITHUB_USERNAME_PLACEHOLDER = "username", GITHUB_REPO_PLACEHOLDER = "repo-name", MONOREPO_FIRST_PACKAGE_NAME_PLACEHOLDER = "package-1", MONOREPO_PACKAGES_DIR = "packages", TEMPLATES;
 var init_new = __esm(() => {
-  import_picocolors5 = __toESM(require_picocolors(), 1);
+  import_picocolors6 = __toESM(require_picocolors(), 1);
   init_utils();
   TEMPLATES = [
     {
@@ -924,7 +552,7 @@ var init_new = __esm(() => {
 // src/cli/index.ts
 import { exec } from "tinyexec";
 // package.json
-var version = "0.8.4";
+var version = "0.8.6";
 
 // src/cli/index.ts
 init_errors();
@@ -1069,106 +697,460 @@ var optionConfigs = {
         if (entries[name]) {
           logger.warn(`Duplicate entry name '${name}' derived from '${value}'. Overwriting previous entry.`);
         }
-        entries[name] = value;
-      }
-      options.entry = entries;
+        entries[name] = value;
+      }
+      options.entry = entries;
+    }
+  },
+  resolveDts: {
+    flags: ["rd", "resolve-dts"],
+    handler: (value, options) => {
+      if (!options.dts)
+        options.dts = {};
+      if (typeof options.dts === "boolean")
+        options.dts = {};
+      if (typeof value === "string") {
+        if (value === "true" || value === "false") {
+          options.dts.resolve = value === "true";
+        } else {
+          options.dts.resolve = value.split(",");
+        }
+      } else {
+        options.dts.resolve = true;
+      }
+    }
+  },
+  help: { flags: ["h", "help"], handler: () => showHelp() },
+  version: { flags: ["v", "version"], handler: () => showVersion() }
+};
+var flagToHandler = {};
+for (const config of Object.values(optionConfigs)) {
+  for (const flag of config.flags) {
+    flagToHandler[flag] = config.handler;
+  }
+}
+function parseCliOptions(argv) {
+  const options = {};
+  for (let i = 0;i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith("--")) {
+      let key;
+      let value;
+      if (arg.includes("=")) {
+        const [keyPart, valuePart] = arg.slice(2).split("=", 2);
+        key = keyPart;
+        value = valuePart;
+      } else {
+        key = arg.slice(2);
+        const nextArg = argv[i + 1];
+        value = nextArg && !nextArg.startsWith("-") ? nextArg : true;
+        if (typeof value === "string")
+          i++;
+      }
+      if (key.includes(".")) {
+        const [mainOption, subPath] = key.split(".", 2);
+        const handler = flagToHandler[mainOption];
+        if (handler) {
+          handler(value, options, subPath);
+        } else {
+          throw new BunupCLIError(`Unknown option: --${key}`);
+        }
+      } else {
+        const handler = flagToHandler[key];
+        if (handler) {
+          handler(value, options);
+        } else {
+          throw new BunupCLIError(`Unknown option: --${key}`);
+        }
+      }
+    } else if (arg.startsWith("-")) {
+      const key = arg.slice(1);
+      const nextArg = argv[i + 1];
+      const value = nextArg && !nextArg.startsWith("-") ? nextArg : true;
+      if (typeof value === "string")
+        i++;
+      const handler = flagToHandler[key];
+      if (handler) {
+        handler(value, options);
+      } else {
+        throw new BunupCLIError(`Unknown option: -${key}`);
+      }
+    } else {
+      optionConfigs.entry.handler(arg, options, undefined);
+    }
+  }
+  return options;
+}
+
+// src/cli/index.ts
+var import_picocolors7 = __toESM(require_picocolors(), 1);
+import { loadConfig as loadConfig2 } from "coffi";
+
+// src/build.ts
+init_errors();
+import path3 from "path";
+import { generateDts, logIsolatedDeclarationErrors } from "bun-dts";
+
+// src/helpers/entry.ts
+init_utils();
+function getProcessableEntries(entry) {
+  if (typeof entry === "string") {
+    return [
+      {
+        entry,
+        outputBasePath: getEntryOutputBasePath(entry)
+      }
+    ];
+  }
+  if (typeof entry === "object" && !Array.isArray(entry)) {
+    return Object.entries(entry).map(([name, path2]) => ({
+      entry: path2,
+      outputBasePath: name
+    }));
+  }
+  return entry.map((_entry) => ({
+    entry: _entry,
+    outputBasePath: getEntryOutputBasePath(_entry)
+  }));
+}
+function getEntryOutputBasePath(entry) {
+  const pathSegments = cleanPath(removeExtension(entry)).split("/");
+  return pathSegments.length > 1 ? pathSegments.slice(1).join("/") : pathSegments.join("/");
+}
+function getResolvedNaming(outputBasePath, extension) {
+  return {
+    entry: `[dir]/${outputBasePath}${extension}`,
+    chunk: `${outputBasePath}-[hash].[ext]`,
+    asset: `${outputBasePath}-[name]-[hash].[ext]`
+  };
+}
+
+// src/loaders.ts
+import path2 from "path";
+import { loadConfig } from "coffi";
+async function processLoadedConfigs(config, cwd, filter) {
+  return Array.isArray(config) && "root" in config[0] ? config.filter((c) => filter ? filter.includes(c.name) : true).map((c) => ({
+    rootDir: path2.resolve(cwd, c.root),
+    options: addField(c.config, "name", c.name)
+  })) : [
+    {
+      rootDir: cwd,
+      options: config
+    }
+  ];
+}
+function addField(objectOrArray, field, value) {
+  return Array.isArray(objectOrArray) ? objectOrArray.map((o) => ({ ...o, [field]: value })) : { ...objectOrArray, [field]: value };
+}
+async function loadPackageJson(cwd) {
+  const { config, filepath } = await loadConfig({
+    name: "package",
+    cwd,
+    extensions: [".json"]
+  });
+  return {
+    data: config,
+    path: filepath
+  };
+}
+
+// src/build.ts
+init_logger();
+
+// src/plugins/internal/use-client.ts
+function useClient() {
+  return {
+    type: "bunup",
+    name: "use-client",
+    hooks: {
+      onBuildDone: async ({ output }) => {
+        for (const file of output.files) {
+          let text = await Bun.file(file.fullPath).text();
+          const hasUseClient = text.split(`
+`).some((line) => line.trim().startsWith(`"use client";`));
+          if (hasUseClient) {
+            text = text.replaceAll(`"use client";`, "");
+            text = `"use client";
+${text}`;
+          }
+          await Bun.write(file.fullPath, text);
+        }
+      }
+    }
+  };
+}
+
+// src/options.ts
+var DEFAULT_OPTIONS = {
+  entry: [],
+  format: ["cjs"],
+  outDir: "dist",
+  target: "node",
+  clean: true
+};
+function createBuildOptions(partialOptions) {
+  const options = {
+    ...DEFAULT_OPTIONS,
+    ...partialOptions
+  };
+  return {
+    ...options,
+    plugins: [...options.plugins ?? [], useClient()]
+  };
+}
+function getResolvedMinify(options) {
+  const { minify, minifyWhitespace, minifyIdentifiers, minifySyntax } = options;
+  const defaultValue = minify === true;
+  return {
+    whitespace: minifyWhitespace ?? defaultValue,
+    identifiers: minifyIdentifiers ?? defaultValue,
+    syntax: minifySyntax ?? defaultValue
+  };
+}
+function getResolvedBytecode(bytecode, format) {
+  return format === "cjs" ? bytecode : undefined;
+}
+function getResolvedSourcemap(sourcemap) {
+  if (sourcemap === true) {
+    return "inline";
+  }
+  return typeof sourcemap === "string" ? sourcemap : undefined;
+}
+function getResolvedDefine(define, env) {
+  return {
+    ...typeof env === "object" && Object.keys(env).reduce((acc, key) => {
+      const value = JSON.stringify(env[key]);
+      acc[`process.env.${key}`] = value;
+      acc[`import.meta.env.${key}`] = value;
+      return acc;
+    }, {}),
+    ...define
+  };
+}
+function getResolvedSplitting(splitting, format) {
+  return splitting === undefined ? format === "esm" : splitting;
+}
+function getResolvedEnv(env) {
+  return typeof env === "string" ? env : undefined;
+}
+
+// src/helpers/external.ts
+init_utils();
+function getPackageDepsPatterns(packageJson) {
+  return getPackageDeps(packageJson).map((dep) => new RegExp(`^${dep}($|\\/|\\\\)`));
+}
+function matchesPattern(path3, pattern) {
+  return typeof pattern === "string" ? pattern === path3 : pattern.test(path3);
+}
+function isExternal(path3, options, packageJson) {
+  const packageDepsPatterns = getPackageDepsPatterns(packageJson);
+  const matchesExternalPattern = packageDepsPatterns.some((pattern) => pattern.test(path3)) || options.external?.some((pattern) => matchesPattern(path3, pattern));
+  const isExcludedFromExternal = options.noExternal?.some((pattern) => matchesPattern(path3, pattern));
+  return matchesExternalPattern && !isExcludedFromExternal;
+}
+
+// src/plugins/internal/external-option.ts
+function externalOptionPlugin(options, packageJson) {
+  return {
+    name: "bunup:external-option-plugin",
+    setup(build) {
+      build.onResolve({ filter: /.*/ }, (args) => {
+        const importPath = args.path;
+        if (isExternal(importPath, options, packageJson)) {
+          return {
+            path: importPath,
+            external: true
+          };
+        }
+        return null;
+      });
     }
-  },
-  resolveDts: {
-    flags: ["rd", "resolve-dts"],
-    handler: (value, options) => {
-      if (!options.dts)
-        options.dts = {};
-      if (typeof options.dts === "boolean")
-        options.dts = {};
-      if (typeof value === "string") {
-        if (value === "true" || value === "false") {
-          options.dts.resolve = value === "true";
-        } else {
-          options.dts.resolve = value.split(",");
-        }
-      } else {
-        options.dts.resolve = true;
-      }
+  };
+}
+
+// src/plugins/utils.ts
+var import_picocolors4 = __toESM(require_picocolors(), 1);
+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);
     }
-  },
-  help: { flags: ["h", "help"], handler: () => showHelp() },
-  version: { flags: ["v", "version"], handler: () => showVersion() }
-};
-var flagToHandler = {};
-for (const config of Object.values(optionConfigs)) {
-  for (const flag of config.flags) {
-    flagToHandler[flag] = config.handler;
   }
 }
-function parseCliOptions(argv) {
-  const options = {};
-  for (let i = 0;i < argv.length; i++) {
-    const arg = argv[i];
-    if (arg.startsWith("--")) {
-      let key;
-      let value;
-      if (arg.includes("=")) {
-        const [keyPart, valuePart] = arg.slice(2).split("=", 2);
-        key = keyPart;
-        value = valuePart;
-      } else {
-        key = arg.slice(2);
-        const nextArg = argv[i + 1];
-        value = nextArg && !nextArg.startsWith("-") ? nextArg : true;
-        if (typeof value === "string")
-          i++;
-      }
-      if (key.includes(".")) {
-        const [mainOption, subPath] = key.split(".", 2);
-        const handler = flagToHandler[mainOption];
-        if (handler) {
-          handler(value, options, subPath);
-        } else {
-          throw new BunupCLIError(`Unknown option: --${key}`);
+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 });
+    }
+  }
+}
+
+// src/build.ts
+init_utils();
+async function build(partialOptions, rootDir = process.cwd()) {
+  const buildOutput = {
+    files: []
+  };
+  const options = createBuildOptions(partialOptions);
+  if (!options.entry || options.entry.length === 0 || !options.outDir) {
+    throw new BunupBuildError("Nothing to build. Please make sure you have provided a proper bunup configuration or cli arguments.");
+  }
+  if (options.clean) {
+    cleanOutDir(rootDir, options.outDir);
+  }
+  setSilent(options.silent);
+  const packageJson = await loadPackageJson(rootDir);
+  if (packageJson.data && packageJson.path) {
+    logger.cli(`Using ${getShortFilePath(packageJson.path, 2)}`, {
+      muted: true,
+      identifier: options.name,
+      once: `${packageJson.path}:${options.name}`
+    });
+  }
+  const bunupPlugins = filterBunupPlugins(options.plugins);
+  await runPluginBuildStartHooks(bunupPlugins, options);
+  const processableEntries = getProcessableEntries(options.entry);
+  const packageType = packageJson.data?.type;
+  const plugins = [
+    externalOptionPlugin(options, packageJson.data),
+    ...filterBunupBunPlugins(options.plugins).map((p) => p.plugin)
+  ];
+  if (!options.dtsOnly) {
+    const buildPromises = options.format.flatMap((fmt) => processableEntries.map(async ({ entry, outputBasePath }) => {
+      const extension = options.outputExtension?.({
+        format: fmt,
+        packageType,
+        options,
+        entry
+      }).js ?? getDefaultJsOutputExtension(fmt, packageType);
+      const result = await Bun.build({
+        entrypoints: [`${rootDir}/${entry}`],
+        format: fmt,
+        naming: getResolvedNaming(outputBasePath, extension),
+        splitting: getResolvedSplitting(options.splitting, fmt),
+        bytecode: getResolvedBytecode(options.bytecode, fmt),
+        define: getResolvedDefine(options.define, options.env),
+        minify: getResolvedMinify(options),
+        outdir: `${rootDir}/${options.outDir}`,
+        target: options.target,
+        sourcemap: getResolvedSourcemap(options.sourcemap),
+        loader: options.loader,
+        drop: options.drop,
+        banner: options.banner,
+        footer: options.footer,
+        publicPath: options.publicPath,
+        env: getResolvedEnv(options.env),
+        plugins,
+        throw: false
+      });
+      for (const log of result.logs) {
+        if (log.level === "error") {
+          console.log(`
+`);
+          console.log(log);
+          console.log(`
+`);
+          throw new Error;
         }
-      } else {
-        const handler = flagToHandler[key];
-        if (handler) {
-          handler(value, options);
-        } else {
-          throw new BunupCLIError(`Unknown option: --${key}`);
+        if (log.level === "warning")
+          logger.warn(log.message);
+        else if (log.level === "info")
+          logger.info(log.message);
+      }
+      for (const file of result.outputs) {
+        const relativePathToRootDir = getRelativePathToRootDir(file.path, rootDir);
+        if (file.kind === "entry-point") {
+          logger.progress(fmt.toUpperCase(), relativePathToRootDir, {
+            identifier: options.name
+          });
         }
+        buildOutput.files.push({
+          fullPath: file.path,
+          relativePathToRootDir,
+          dts: false,
+          entry,
+          outputBasePath,
+          format: fmt
+        });
       }
-    } else if (arg.startsWith("-")) {
-      const key = arg.slice(1);
-      const nextArg = argv[i + 1];
-      const value = nextArg && !nextArg.startsWith("-") ? nextArg : true;
-      if (typeof value === "string")
-        i++;
-      const handler = flagToHandler[key];
-      if (handler) {
-        handler(value, options);
-      } else {
-        throw new BunupCLIError(`Unknown option: -${key}`);
+    }));
+    await Promise.all(buildPromises);
+  }
+  if (options.dts === true || typeof options.dts === "object" || options.dtsOnly) {
+    const dtsResolve = typeof options.dts === "object" && "resolve" in options.dts ? options.dts.resolve : undefined;
+    const dtsEntry = typeof options.dts === "object" && "entry" in options.dts ? options.dts.entry : undefined;
+    const processableDtsEntries = dtsEntry ? getProcessableEntries(dtsEntry) : processableEntries;
+    const dtsPromises = processableDtsEntries.map(async ({ entry, outputBasePath }) => {
+      const result = await generateDts(entry, {
+        cwd: rootDir,
+        preferredTsConfigPath: options.preferredTsconfigPath,
+        resolve: dtsResolve
+      });
+      for (const fmt of options.format) {
+        const extension = options.outputExtension?.({
+          format: fmt,
+          packageType,
+          options,
+          entry
+        }).dts ?? getDefaultDtsOutputExtension(fmt, packageType);
+        const filePath = path3.join(rootDir, options.outDir, `${outputBasePath}${extension}`);
+        const relativePathToRootDir = getRelativePathToRootDir(filePath, rootDir);
+        buildOutput.files.push({
+          fullPath: filePath,
+          relativePathToRootDir,
+          dts: true,
+          entry,
+          outputBasePath,
+          format: fmt
+        });
+        if (result.errors.length > 0) {
+          logIsolatedDeclarationErrors(result.errors, {
+            warnInsteadOfError: options.watch,
+            shouldExit: true
+          });
+        }
+        await Bun.write(filePath, result.dts);
+        logger.progress("DTS", relativePathToRootDir, {
+          identifier: options.name
+        });
       }
-    } else {
-      optionConfigs.entry.handler(arg, options, undefined);
-    }
+    });
+    await Promise.all(dtsPromises);
+  }
+  await runPluginBuildDoneHooks(bunupPlugins, options, buildOutput, {
+    packageJson
+  });
+  if (options.onSuccess) {
+    await options.onSuccess(options);
   }
-  return options;
+}
+function getRelativePathToRootDir(filePath, rootDir) {
+  return filePath.replace(`${rootDir}/`, "");
 }
 
 // src/cli/index.ts
-var import_picocolors6 = __toESM(require_picocolors(), 1);
-init_loaders();
 init_utils();
-import { loadConfig as loadConfig2 } from "coffi";
 
 // src/watch.ts
-var import_picocolors4 = __toESM(require_picocolors(), 1);
-init_build();
+var import_picocolors5 = __toESM(require_picocolors(), 1);
+import path4 from "path";
 init_errors();
-init_entry();
 init_logger();
-init_options();
 init_utils();
-import path4 from "path";
 async function watch(partialOptions, rootDir) {
   const watchPaths = new Set;
   const options = createBuildOptions(partialOptions);
@@ -1186,9 +1168,7 @@ async function watch(partialOptions, rootDir) {
   }
   const chokidar = await import("chokidar");
   const watcher = chokidar.watch(Array.from(watchPaths), {
-    persistent: true,
     ignoreInitial: true,
-    atomic: true,
     ignorePermissionErrors: true,
     ignored: [
       /[\\/]\.git[\\/]/,
@@ -1198,14 +1178,15 @@ async function watch(partialOptions, rootDir) {
   });
   let isRebuilding = false;
   const triggerRebuild = async (initial = false) => {
-    if (isRebuilding)
+    if (isRebuilding) {
       return;
+    }
     isRebuilding = true;
     try {
       const start = performance.now();
       await build(options, rootDir);
       if (!initial) {
-        logger.cli(`\uD83D\uDCE6 Rebuild finished in ${import_picocolors4.default.green(formatTime(performance.now() - start))}`);
+        logger.cli(`\uD83D\uDCE6 Rebuild finished in ${import_picocolors5.default.green(formatTime(performance.now() - start))}`);
       }
     } catch (error) {
       handleError(error);
@@ -1255,7 +1236,6 @@ async function main(args = Bun.argv.slice(2)) {
   }
   const startTime = performance.now();
   logger.cli("Build started");
-  const { build: build2 } = await Promise.resolve().then(() => (init_build(), exports_build));
   await Promise.all(configsToProcess.flatMap(({ options, rootDir }) => {
     const optionsArray = ensureArray(options);
     return optionsArray.map(async (o) => {
@@ -1266,13 +1246,13 @@ async function main(args = Bun.argv.slice(2)) {
       if (partialOptions.watch) {
         await watch(partialOptions, rootDir);
       } else {
-        await build2(partialOptions, rootDir);
+        await build(partialOptions, rootDir);
       }
     });
   }));
   const buildTimeMs = performance.now() - startTime;
   const timeDisplay = formatTime(buildTimeMs);
-  logger.cli(`\u26A1\uFE0F Build completed in ${import_picocolors6.default.green(timeDisplay)}`);
+  logger.cli(`\u26A1\uFE0F Build completed in ${import_picocolors7.default.green(timeDisplay)}`);
   if (cliOptions.watch) {
     logger.cli("\uD83D\uDC40 Watching for file changes");
   }

package/dist/index.cjs

@@ -511,6 +511,7 @@ function externalOptionPlugin(options, packageJson) {
 }
 
 // src/plugins/utils.ts
+var import_picocolors3 = __toESM(require_picocolors());
 function filterBunupBunPlugins(plugins) {
   if (!plugins)
     return [];

package/dist/index.js

@@ -478,6 +478,7 @@ function externalOptionPlugin(options, packageJson) {
 }
 
 // src/plugins/utils.ts
+var import_picocolors3 = __toESM(require_picocolors(), 1);
 function filterBunupBunPlugins(plugins) {
   if (!plugins)
     return [];

package/dist/plugins.cjs

@@ -416,10 +416,7 @@ function exports2() {
           const existingExports = packageJson.exports || {};
           const mergedExports = { ...existingExports };
           for (const [key, value] of Object.entries(exportsField)) {
-            mergedExports[key] = {
-              ...mergedExports[key] || {},
-              ...value
-            };
+            mergedExports[key] = value;
           }
           const newPackageJson = {
             name: packageJson.name,
@@ -555,7 +552,20 @@ function report(options = {}) {
 }
 // src/plugins/built-in/css/inject-styles.ts
 var import_node_path2 = __toESM(require("path"));
-var import_lightningcss = require("lightningcss");
+
+// src/plugins/utils.ts
+var import_picocolors4 = __toESM(require_picocolors());
+async function getPackageForPlugin(name, pluginName) {
+  let pkg;
+  try {
+    pkg = await import(name);
+  } catch {
+    throw new Error(`[${import_picocolors4.default.cyan(name)}] is required for the ${pluginName} plugin. Please install it with: ${import_picocolors4.default.blue(`bun add ${name} --dev`)}`);
+  }
+  return pkg;
+}
+
+// src/plugins/built-in/css/inject-styles.ts
 function injectStyles(options) {
   const { inject, ...transformOptions } = options ?? {};
   return {
@@ -563,7 +573,8 @@ function injectStyles(options) {
     name: "inject-styles",
     plugin: {
       name: "bunup:inject-styles",
-      setup(build) {
+      async setup(build) {
+        const lightningcss = await getPackageForPlugin("lightningcss", "inject-styles");
         build.onResolve({ filter: /^__inject-style$/ }, () => {
           return {
             path: "__inject-style",
@@ -592,7 +603,7 @@ function injectStyles(options) {
         });
         build.onLoad({ filter: CSS_RE }, async (args) => {
           const source = await Bun.file(args.path).text();
-          const { code, warnings } = import_lightningcss.transform({
+          const { code, warnings } = lightningcss.transform({
             ...transformOptions,
             filename: import_node_path2.default.basename(args.path),
             code: Buffer.from(source),

package/dist/plugins.d.cts

@@ -401,8 +401,7 @@ type ReportPluginOptions = {
 * @param options - The options for the report plugin.
 */
 declare function report(options?: ReportPluginOptions): BunupPlugin;
-import { CustomAtRules, TransformOptions } from "lightningcss";
-type InjectStylesPluginOptions = Pick<TransformOptions<CustomAtRules>, "sourceMap" | "inputSourceMap" | "targets" | "nonStandard" | "minify" | "pseudoClasses" | "unusedSymbols" | "errorRecovery" | "visitor" | "customAtRules" | "include" | "exclude" | "drafts"> & {
+type InjectStylesPluginOptions = Pick<import("lightningcss").TransformOptions<import("lightningcss").CustomAtRules>, "sourceMap" | "inputSourceMap" | "targets" | "nonStandard" | "minify" | "pseudoClasses" | "unusedSymbols" | "errorRecovery" | "visitor" | "customAtRules" | "include" | "exclude" | "drafts"> & {
 	inject?: (css: string, filePath: string) => MaybePromise<string>
 };
 /**

package/dist/plugins.d.ts

@@ -401,8 +401,7 @@ type ReportPluginOptions = {
 * @param options - The options for the report plugin.
 */
 declare function report(options?: ReportPluginOptions): BunupPlugin;
-import { CustomAtRules, TransformOptions } from "lightningcss";
-type InjectStylesPluginOptions = Pick<TransformOptions<CustomAtRules>, "sourceMap" | "inputSourceMap" | "targets" | "nonStandard" | "minify" | "pseudoClasses" | "unusedSymbols" | "errorRecovery" | "visitor" | "customAtRules" | "include" | "exclude" | "drafts"> & {
+type InjectStylesPluginOptions = Pick<import("lightningcss").TransformOptions<import("lightningcss").CustomAtRules>, "sourceMap" | "inputSourceMap" | "targets" | "nonStandard" | "minify" | "pseudoClasses" | "unusedSymbols" | "errorRecovery" | "visitor" | "customAtRules" | "include" | "exclude" | "drafts"> & {
 	inject?: (css: string, filePath: string) => MaybePromise<string>
 };
 /**

package/dist/plugins.js

@@ -381,10 +381,7 @@ function exports() {
           const existingExports = packageJson.exports || {};
           const mergedExports = { ...existingExports };
           for (const [key, value] of Object.entries(exportsField)) {
-            mergedExports[key] = {
-              ...mergedExports[key] || {},
-              ...value
-            };
+            mergedExports[key] = value;
           }
           const newPackageJson = {
             name: packageJson.name,
@@ -520,9 +517,20 @@ function report(options = {}) {
 }
 // src/plugins/built-in/css/inject-styles.ts
 import path2 from "path";
-import {
-  transform
-} from "lightningcss";
+
+// src/plugins/utils.ts
+var import_picocolors4 = __toESM(require_picocolors(), 1);
+async function getPackageForPlugin(name, pluginName) {
+  let pkg;
+  try {
+    pkg = await import(name);
+  } catch {
+    throw new Error(`[${import_picocolors4.default.cyan(name)}] is required for the ${pluginName} plugin. Please install it with: ${import_picocolors4.default.blue(`bun add ${name} --dev`)}`);
+  }
+  return pkg;
+}
+
+// src/plugins/built-in/css/inject-styles.ts
 function injectStyles(options) {
   const { inject, ...transformOptions } = options ?? {};
   return {
@@ -530,7 +538,8 @@ function injectStyles(options) {
     name: "inject-styles",
     plugin: {
       name: "bunup:inject-styles",
-      setup(build) {
+      async setup(build) {
+        const lightningcss = await getPackageForPlugin("lightningcss", "inject-styles");
         build.onResolve({ filter: /^__inject-style$/ }, () => {
           return {
             path: "__inject-style",
@@ -559,7 +568,7 @@ function injectStyles(options) {
         });
         build.onLoad({ filter: CSS_RE }, async (args) => {
           const source = await Bun.file(args.path).text();
-          const { code, warnings } = transform({
+          const { code, warnings } = lightningcss.transform({
             ...transformOptions,
             filename: path2.basename(args.path),
             code: Buffer.from(source),

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "bunup",
     "description": "⚡ A blazing-fast build tool for your libraries built with Bun.",
-    "version": "0.8.4",
+    "version": "0.8.6",
     "type": "module",
     "files": [
         "dist",
@@ -49,7 +49,7 @@
         "@clack/prompts": "^0.10.1",
         "bun-dts": "^0.1.27",
         "chokidar": "^4.0.3",
-        "coffi": "^0.1.28",
+        "coffi": "^0.1.29",
         "giget": "^2.0.0",
         "package-manager-detector": "^1.2.0",
         "replace-in-file": "^8.3.0",
@@ -61,8 +61,7 @@
         "bumpp": "^10.1.0",
         "husky": "^9.1.7",
         "lint-staged": "^15.5.1",
-        "typescript": "^5.8.3",
-        "lightningcss": "^1.30.1"
+        "typescript": "^5.8.3"
     },
     "peerDependencies": {
         "typescript": ">=4.5.0",