bunup 0.8.41 → 0.8.42

package/dist/index.js

@@ -1,10 +1,410 @@
 // @bun
-import {
-  build
-} from "./chunk-5ng6vk19.js";
-import"./plugins/index.js";
-import"./chunk-gh7z7s46.js";
-import"./chunk-c1eyecm3.js";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/logger.ts
+import pc from "picocolors";
+function setSilent(value) {
+  silent = value ?? false;
+}
+
+class Logger {
+  static instance;
+  loggedOnceMessages = new Set;
+  constructor() {}
+  static getInstance() {
+    if (!Logger.instance) {
+      Logger.instance = new Logger;
+    }
+    return Logger.instance;
+  }
+  dispose() {
+    this.loggedOnceMessages.clear();
+  }
+  shouldLog(options) {
+    if (!options?.once) {
+      return true;
+    }
+    if (this.loggedOnceMessages.has(options.once)) {
+      return false;
+    }
+    this.loggedOnceMessages.add(options.once);
+    return true;
+  }
+  getIcon(type, tick) {
+    if (tick) {
+      return pc.green("\u2713");
+    }
+    const iconMap = {
+      info: pc.blue("i"),
+      warn: pc.yellow("!"),
+      error: pc.red("\u2715")
+    };
+    return iconMap[type];
+  }
+  formatIdentifier(identifier) {
+    return identifier ? `   ${pc.bgBlue(pc.black(` ${identifier} `))}` : "";
+  }
+  formatMessage(options) {
+    const {
+      message,
+      identifier,
+      muted = false,
+      tick = false,
+      type = "info"
+    } = options;
+    const icon = this.getIcon(type, tick);
+    const styledMessage = muted ? pc.dim(message) : type === "error" ? pc.red(message) : type === "warn" ? pc.yellow(message) : message;
+    const identifierPart = this.formatIdentifier(identifier);
+    return `${icon} ${styledMessage}${identifierPart}`;
+  }
+  output(message, options = {}, logFn = console.log) {
+    if (silent || !this.shouldLog(options)) {
+      return;
+    }
+    if (options.verticalSpace) {
+      logFn("");
+    }
+    logFn(message);
+    if (options.verticalSpace) {
+      logFn("");
+    }
+  }
+  info(message, options = {}) {
+    const formattedMessage = this.formatMessage({
+      ...options,
+      message,
+      type: "info"
+    });
+    this.output(formattedMessage, options);
+  }
+  warn(message, options = {}) {
+    const formattedMessage = this.formatMessage({
+      ...options,
+      message,
+      type: "warn"
+    });
+    this.output(formattedMessage, options);
+  }
+  error(message, options = {}) {
+    const formattedMessage = this.formatMessage({
+      ...options,
+      message,
+      type: "error"
+    });
+    this.output(formattedMessage, options);
+  }
+  success(message, options = {}) {
+    const formattedMessage = this.formatMessage({
+      ...options,
+      message,
+      tick: true
+    });
+    this.output(formattedMessage, options);
+  }
+  space() {
+    if (!silent) {
+      console.log("");
+    }
+  }
+}
+function logTable(columns, data, footer) {
+  if (silent)
+    return;
+  const widths = {};
+  for (const col of columns) {
+    const headerLength = col.header.length;
+    const dataLengths = data.map((row) => row[col.header]?.length || 0);
+    const footerLength = footer ? footer[col.header]?.length || 0 : 0;
+    widths[col.header] = Math.max(headerLength, ...dataLengths, footerLength);
+  }
+  const pad = (str, width, align) => {
+    return align === "left" ? str.padEnd(width) : str.padStart(width);
+  };
+  const headerRow = columns.map((col) => pad(col.header, widths[col.header], col.align)).join(pc.gray(" | "));
+  console.log(pc.gray(headerRow));
+  const separator = columns.map((col) => "-".repeat(widths[col.header])).join(" | ");
+  console.log(pc.gray(separator));
+  for (const row of data) {
+    const rowStr = columns.map((col) => {
+      const value = row[col.header] || "";
+      const padded = pad(value, widths[col.header], col.align);
+      return col.color ? col.color(padded) : padded;
+    }).join(pc.gray(" | "));
+    console.log(rowStr);
+  }
+  console.log(pc.gray(separator));
+  if (footer) {
+    const footerRow = columns.map((col) => {
+      const value = footer[col.header] || "";
+      const padded = pad(value, widths[col.header], col.align);
+      return padded;
+    }).join(pc.gray(" | "));
+    console.log(footerRow);
+  }
+}
+var silent = false, logger;
+var init_logger = __esm(() => {
+  logger = Logger.getInstance();
+});
+
+// src/errors.ts
+import pc2 from "picocolors";
+var BunupError, BunupBuildError, BunupDTSBuildError, BunupCLIError, BunupWatchError, BunupPluginError, parseErrorMessage = (error) => {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}, KNOWN_ERRORS, handleError = (error, context) => {
+  const errorMessage = parseErrorMessage(error);
+  const contextPrefix = context ? `[${context}] ` : "";
+  let errorType = "UNKNOWN ERROR";
+  if (error instanceof BunupBuildError) {
+    errorType = "BUILD ERROR";
+  } else if (error instanceof BunupDTSBuildError) {
+    errorType = "DTS ERROR";
+  } else if (error instanceof BunupCLIError) {
+    errorType = "CLI ERROR";
+  } else if (error instanceof BunupWatchError) {
+    errorType = "WATCH ERROR";
+  } else if (error instanceof BunupPluginError) {
+    errorType = "PLUGIN ERROR";
+  } else if (error instanceof BunupError) {
+    errorType = "BUNUP ERROR";
+  }
+  const knownError = KNOWN_ERRORS.find((error2) => error2.pattern.test(errorMessage) && (error2.errorType === errorType || !error2.errorType));
+  if (!knownError && errorType) {
+    console.error(`${pc2.red(errorType)} ${contextPrefix}${errorMessage}`);
+  }
+  if (knownError) {
+    console.log(`
+`);
+    knownError.logSolution(errorMessage);
+    console.log(`
+`);
+  } else {
+    console.error(pc2.dim(pc2.white("If you think this is a bug, please open an issue at: ") + pc2.cyan("https://github.com/arshad-yaseen/bunup/issues/new")));
+  }
+}, handleErrorAndExit = (error, context) => {
+  handleError(error, context);
+  process.exit(1);
+};
+var init_errors = __esm(() => {
+  init_logger();
+  BunupError = class BunupError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "BunupError";
+    }
+  };
+  BunupBuildError = class BunupBuildError extends BunupError {
+    constructor(message) {
+      super(message);
+      this.name = "BunupBuildError";
+    }
+  };
+  BunupDTSBuildError = class BunupDTSBuildError extends BunupError {
+    constructor(message) {
+      super(message);
+      this.name = "BunupDTSBuildError";
+    }
+  };
+  BunupCLIError = class BunupCLIError extends BunupError {
+    constructor(message) {
+      super(message);
+      this.name = "BunupCLIError";
+    }
+  };
+  BunupWatchError = class BunupWatchError extends BunupError {
+    constructor(message) {
+      super(message);
+      this.name = "BunupWatchError";
+    }
+  };
+  BunupPluginError = class BunupPluginError extends BunupError {
+    constructor(message) {
+      super(message);
+      this.name = "BunupPluginError";
+    }
+  };
+  KNOWN_ERRORS = [
+    {
+      pattern: /Could not resolve: "bun"/i,
+      errorType: "BUILD ERROR",
+      logSolution: () => {
+        logger.info(pc2.white("You're trying to build a project that uses Bun. ") + pc2.white("Please set the target option to ") + pc2.cyan("`bun`") + pc2.white(`.
+`) + pc2.white("Example: ") + pc2.green("`bunup --target bun`") + pc2.white(" or in config: ") + pc2.green("{ target: 'bun' }"));
+      }
+    }
+  ];
+});
+
+// src/loaders.ts
+import path 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: path.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 = process.cwd()) {
+  const { config, filepath } = await loadConfig({
+    name: "package",
+    cwd,
+    extensions: [".json"]
+  });
+  return {
+    data: config,
+    path: filepath
+  };
+}
+var init_loaders = () => {};
+
+// src/utils.ts
+import fsSync from "fs";
+import fs from "fs/promises";
+import path2, { normalize } from "path";
+function ensureArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+function getDefaultOutputExtension(format, packageType) {
+  switch (format) {
+    case "esm":
+      return isModulePackage(packageType) ? ".js" : ".mjs";
+    case "cjs":
+      return isModulePackage(packageType) ? ".cjs" : ".js";
+    case "iife":
+      return ".global.js";
+  }
+}
+function getDefaultDtsExtention(format, packageType) {
+  switch (format) {
+    case "esm":
+      return isModulePackage(packageType) ? ".d.ts" : ".d.mts";
+    case "cjs":
+      return isModulePackage(packageType) ? ".d.cts" : ".d.ts";
+    case "iife":
+      return ".global.d.ts";
+  }
+}
+function isModulePackage(packageType) {
+  return packageType === "module";
+}
+function formatTime(ms) {
+  return ms >= 1000 ? `${(ms / 1000).toFixed(2)}s` : `${Math.round(ms)}ms`;
+}
+function getPackageDeps(packageJson) {
+  if (!packageJson)
+    return [];
+  return Array.from(new Set([
+    ...Object.keys(packageJson.dependencies || {}),
+    ...Object.keys(packageJson.peerDependencies || {})
+  ]));
+}
+function formatFileSize(bytes) {
+  if (bytes === 0)
+    return "0 B";
+  const units = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  if (i === 0)
+    return `${bytes} ${units[i]}`;
+  return `${(bytes / 1024 ** i).toFixed(2)} ${units[i]}`;
+}
+function getShortFilePath(filePath, maxLength = 3) {
+  const fileParts = filePath.split("/");
+  const shortPath = fileParts.slice(-maxLength).join("/");
+  return shortPath;
+}
+async function cleanOutDir(rootDir, outDir) {
+  const outDirPath = path2.join(rootDir, outDir);
+  try {
+    await fs.rm(outDirPath, { recursive: true, force: true });
+  } catch (error) {
+    throw new BunupBuildError(`Failed to clean output directory: ${error}`);
+  }
+  await fs.mkdir(outDirPath, { recursive: true });
+}
+function cleanPath(path3) {
+  let cleaned = normalize(path3).replace(/\\/g, "/");
+  cleaned = cleaned.replace(/^[a-zA-Z]:\//, "");
+  cleaned = cleaned.replace(/^\/+/, "");
+  cleaned = cleaned.replace(/\/+/g, "/");
+  return cleaned;
+}
+function isDirectoryPath(filePath) {
+  return path2.extname(filePath) === "";
+}
+function pathExistsSync(filePath) {
+  try {
+    fsSync.accessSync(filePath);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+function formatListWithAnd(arr) {
+  return new Intl.ListFormat("en", {
+    style: "long",
+    type: "conjunction"
+  }).format(arr);
+}
+async function getFilesFromGlobs(patterns, cwd) {
+  const includePatterns = patterns.filter((p) => !p.startsWith("!"));
+  const excludePatterns = patterns.filter((p) => p.startsWith("!")).map((p) => p.slice(1));
+  const includedFiles = new Set;
+  for (const pattern of includePatterns) {
+    const glob = new Bun.Glob(pattern);
+    for await (const file of glob.scan(cwd)) {
+      includedFiles.add(file);
+    }
+  }
+  if (excludePatterns.length > 0) {
+    for (const pattern of excludePatterns) {
+      const glob = new Bun.Glob(pattern);
+      for await (const file of glob.scan(cwd)) {
+        includedFiles.delete(file);
+      }
+    }
+  }
+  return Array.from(includedFiles);
+}
+var init_utils = __esm(() => {
+  init_errors();
+});
 
 // src/define.ts
 function defineConfig(options) {
@@ -13,6 +413,372 @@ function defineConfig(options) {
 function defineWorkspace(options) {
   return options;
 }
+// src/build.ts
+init_errors();
+init_loaders();
+init_logger();
+import path3 from "path";
+import { generateDts, logIsolatedDeclarationErrors } from "bun-dts";
+import pc5 from "picocolors";
+
+// src/plugins/internal/report.ts
+init_logger();
+init_logger();
+init_utils();
+import pc3 from "picocolors";
+function report() {
+  return {
+    type: "bunup",
+    name: "report",
+    hooks: {
+      onBuildDone: async ({ options, output }) => {
+        if (options.watch)
+          return;
+        const files = await Promise.all(output.files.map(async (file) => {
+          const name = file.relativePathToRootDir;
+          const size = Bun.file(file.fullPath).size;
+          const gzipSize = Bun.gzipSync(new Uint8Array(await Bun.file(file.fullPath).arrayBuffer())).length;
+          const formattedGzipSize = formatFileSize(gzipSize);
+          return {
+            name,
+            size,
+            formattedSize: formatFileSize(size),
+            gzipSize,
+            formattedGzipSize
+          };
+        }));
+        const totalSize = files.reduce((sum, file) => sum + file.size, 0);
+        const formattedTotalSize = formatFileSize(totalSize);
+        const totalGzipSize = files.reduce((sum, file) => sum + (file.gzipSize || 0), 0);
+        const formattedTotalGzipSize = formatFileSize(totalGzipSize);
+        const columns = [
+          { header: "File", align: "left", color: pc3.blue },
+          { header: "Size", align: "right", color: pc3.green },
+          {
+            header: "Gzip",
+            align: "right",
+            color: pc3.magenta
+          }
+        ];
+        const data = files.map((file) => {
+          return {
+            File: file.name,
+            Size: file.formattedSize,
+            Gzip: file.formattedGzipSize
+          };
+        });
+        const footer = {
+          File: "Total",
+          Size: formattedTotalSize,
+          Gzip: formattedTotalGzipSize
+        };
+        logger.space();
+        logTable(columns, data, footer);
+        logger.space();
+      }
+    }
+  };
+}
+
+// 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
+init_utils();
+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?.filter((p) => p.name !== "report") ?? [],
+      useClient(),
+      report()
+    ]
+  };
+}
+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 getResolvedDtsSplitting(splitting) {
+  return splitting ?? true;
+}
+var DEFAULT_ENTRY_NAMING = "[dir]/[name].[ext]";
+function getResolvedNaming(fmt, packageType) {
+  const replaceExt = (pattern) => pattern.replace(".[ext]", getDefaultOutputExtension(fmt, packageType));
+  return replaceExt(DEFAULT_ENTRY_NAMING);
+}
+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;
+      });
+    }
+  };
+}
+
+// src/plugins/utils.ts
+init_errors();
+import pc4 from "picocolors";
+function filterBunupBunPlugins(plugins) {
+  if (!plugins)
+    return [];
+  return plugins.filter((p) => p.type === "bun");
+}
+function filterBunupPlugins(plugins) {
+  if (!plugins)
+    return [];
+  return plugins.filter((p) => p.type === "bunup");
+}
+async function runPluginBuildStartHooks(bunupPlugins, options) {
+  if (!bunupPlugins)
+    return;
+  for (const plugin of bunupPlugins) {
+    if (plugin.hooks.onBuildStart) {
+      await plugin.hooks.onBuildStart(options);
+    }
+  }
+}
+async function runPluginBuildDoneHooks(bunupPlugins, options, output, meta) {
+  if (!bunupPlugins)
+    return;
+  for (const plugin of bunupPlugins) {
+    if (plugin.hooks.onBuildDone) {
+      await plugin.hooks.onBuildDone({ options, output, meta });
+    }
+  }
+}
+async function getPackageForPlugin(name, pluginName) {
+  let pkg;
+  try {
+    pkg = await import(name);
+  } catch {
+    throw new BunupPluginError(`[${pc4.cyan(name)}] is required for the ${pluginName} plugin. Please install it with: ${pc4.blue(`bun add ${name} --dev`)}`);
+  }
+  return pkg;
+}
+
+// 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.info(`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 packageType = packageJson.data?.type;
+  const plugins = [
+    externalOptionPlugin(options, packageJson.data),
+    ...filterBunupBunPlugins(options.plugins).map((p) => p.plugin)
+  ];
+  const entrypoints = await getFilesFromGlobs(ensureArray(options.entry), rootDir);
+  if (!entrypoints.length) {
+    throw new BunupBuildError("The entrypoints you provided do not exist. Please make sure the entrypoints point to valid files.");
+  }
+  const buildPromises = options.format.flatMap(async (fmt) => {
+    const result = await Bun.build({
+      entrypoints: entrypoints.map((file) => `${rootDir}/${file}`),
+      format: fmt,
+      naming: getResolvedNaming(fmt, packageType),
+      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),
+      ignoreDCEAnnotations: options.ignoreDCEAnnotations,
+      emitDCEAnnotations: options.emitDCEAnnotations,
+      throw: false,
+      plugins
+    });
+    for (const log of result.logs) {
+      if (log.level === "error") {
+        throw new BunupBuildError(log.message);
+      }
+      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);
+      const relativePathToOutputDir = getRelativePathToOutputDir(relativePathToRootDir, options.outDir);
+      if (file.kind === "entry-point") {
+        logger.success(`${pc5.dim(options.outDir)}/${relativePathToOutputDir}`, {
+          identifier: options.name
+        });
+      }
+      buildOutput.files.push({
+        fullPath: file.path,
+        relativePathToRootDir,
+        relativePathToOutputDir,
+        dts: false,
+        format: fmt,
+        kind: file.kind
+      });
+    }
+  });
+  await Promise.all(buildPromises);
+  if (options.dts) {
+    const { entry, splitting, ...dtsOptions } = typeof options.dts === "object" ? options.dts : {};
+    const dtsResult = await generateDts(ensureArray(entry ?? entrypoints), {
+      cwd: rootDir,
+      preferredTsConfigPath: options.preferredTsconfigPath,
+      splitting: getResolvedDtsSplitting(splitting),
+      ...dtsOptions
+    });
+    if (dtsResult.errors.length) {
+      logIsolatedDeclarationErrors(dtsResult.errors, {
+        shouldExit: true
+      });
+    }
+    for (const fmt of options.format) {
+      for (const file of dtsResult.files) {
+        const dtsExtension = getDefaultDtsExtention(fmt, packageType);
+        const relativePathToOutputDir = cleanPath(`${file.pathInfo.outputPathWithoutExtension}${dtsExtension}`);
+        const relativePathToRootDir = cleanPath(`${options.outDir}/${relativePathToOutputDir}`);
+        if (file.kind === "entry-point") {
+          logger.success(`${pc5.dim(options.outDir)}/${relativePathToOutputDir}`, {
+            identifier: options.name
+          });
+        }
+        const fullPath = path3.join(rootDir, relativePathToRootDir);
+        await Bun.write(fullPath, file.dts);
+        buildOutput.files.push({
+          fullPath,
+          relativePathToRootDir,
+          relativePathToOutputDir,
+          dts: true,
+          format: fmt,
+          kind: file.kind
+        });
+      }
+    }
+  }
+  await runPluginBuildDoneHooks(bunupPlugins, options, buildOutput, {
+    packageJson,
+    rootDir
+  });
+  if (options.onSuccess) {
+    await options.onSuccess(options);
+  }
+}
+function getRelativePathToRootDir(filePath, rootDir) {
+  return cleanPath(filePath).replace(`${cleanPath(rootDir)}/`, "");
+}
+function getRelativePathToOutputDir(relativePathToRootDir, outDir) {
+  return cleanPath(relativePathToRootDir).replace(`${cleanPath(outDir)}/`, "");
+}
 export {
   defineWorkspace,
   defineConfig,