bunup 0.8.52 → 0.8.53

package/dist/{chunk-mf58dgyw.js → chunk-4cgw2ywa.js}

@@ -1,6 +1,6 @@
 import {
   logger
-} from "./chunk-kk5yc8cy.js";
+} from "./chunk-cakmscpb.js";
 
 // src/cli/utils.ts
 import pc from "picocolors";

package/dist/{chunk-p2wczz52.d.ts → chunk-80rcmwcp.d.ts}

@@ -1,11 +1,4 @@
-type Resolve = boolean | (string | RegExp)[];
-type GenerateDtsOptions = {
-	preferredTsConfigPath?: string;
-	resolve?: Resolve;
-	cwd?: string;
-	splitting?: boolean;
-	minify?: boolean;
-};
+import { GenerateDtsOptions } from "typeroll";
 import { BunPlugin } from "bun";
 type PackageJson = {
 	/** The parsed content of the package.json file */

package/dist/{chunk-8dm3xyd7.js → chunk-c4xe90dt.js}

@@ -1,11 +1,11 @@
 // @bun
 import {
   displayBunupGradientArt
-} from "./chunk-mf58dgyw.js";
+} from "./chunk-4cgw2ywa.js";
 import {
   link,
   pathExistsSync
-} from "./chunk-kk5yc8cy.js";
+} from "./chunk-cakmscpb.js";
 
 // src/cli/new.ts
 import { renameSync } from "fs";

package/dist/{chunk-kk5yc8cy.js → chunk-cakmscpb.js}

@@ -269,7 +269,81 @@ var handleErrorAndExit = (error, context) => {
 import fsSync from "fs";
 import fs from "fs/promises";
 import path, { normalize } from "path";
-import { isCI, isDevelopment } from "std-env";
+
+// node_modules/std-env/dist/index.mjs
+var r = Object.create(null);
+var i = (e) => globalThis.process?.env || import.meta.env || globalThis.Deno?.env.toObject() || globalThis.__env__ || (e ? r : globalThis);
+var o = new Proxy(r, { get(e, s) {
+  return i()[s] ?? r[s];
+}, has(e, s) {
+  const E = i();
+  return s in E || s in r;
+}, set(e, s, E) {
+  const B = i(true);
+  return B[s] = E, true;
+}, deleteProperty(e, s) {
+  if (!s)
+    return false;
+  const E = i(true);
+  return delete E[s], true;
+}, ownKeys() {
+  const e = i(true);
+  return Object.keys(e);
+} });
+var t = typeof process < "u" && process.env && "development" || "";
+var f = [["APPVEYOR"], ["AWS_AMPLIFY", "AWS_APP_ID", { ci: true }], ["AZURE_PIPELINES", "SYSTEM_TEAMFOUNDATIONCOLLECTIONURI"], ["AZURE_STATIC", "INPUT_AZURE_STATIC_WEB_APPS_API_TOKEN"], ["APPCIRCLE", "AC_APPCIRCLE"], ["BAMBOO", "bamboo_planKey"], ["BITBUCKET", "BITBUCKET_COMMIT"], ["BITRISE", "BITRISE_IO"], ["BUDDY", "BUDDY_WORKSPACE_ID"], ["BUILDKITE"], ["CIRCLE", "CIRCLECI"], ["CIRRUS", "CIRRUS_CI"], ["CLOUDFLARE_PAGES", "CF_PAGES", { ci: true }], ["CLOUDFLARE_WORKERS", "WORKERS_CI", { ci: true }], ["CODEBUILD", "CODEBUILD_BUILD_ARN"], ["CODEFRESH", "CF_BUILD_ID"], ["DRONE"], ["DRONE", "DRONE_BUILD_EVENT"], ["DSARI"], ["GITHUB_ACTIONS"], ["GITLAB", "GITLAB_CI"], ["GITLAB", "CI_MERGE_REQUEST_ID"], ["GOCD", "GO_PIPELINE_LABEL"], ["LAYERCI"], ["HUDSON", "HUDSON_URL"], ["JENKINS", "JENKINS_URL"], ["MAGNUM"], ["NETLIFY"], ["NETLIFY", "NETLIFY_LOCAL", { ci: false }], ["NEVERCODE"], ["RENDER"], ["SAIL", "SAILCI"], ["SEMAPHORE"], ["SCREWDRIVER"], ["SHIPPABLE"], ["SOLANO", "TDDIUM"], ["STRIDER"], ["TEAMCITY", "TEAMCITY_VERSION"], ["TRAVIS"], ["VERCEL", "NOW_BUILDER"], ["VERCEL", "VERCEL", { ci: false }], ["VERCEL", "VERCEL_ENV", { ci: false }], ["APPCENTER", "APPCENTER_BUILD_ID"], ["CODESANDBOX", "CODESANDBOX_SSE", { ci: false }], ["CODESANDBOX", "CODESANDBOX_HOST", { ci: false }], ["STACKBLITZ"], ["STORMKIT"], ["CLEAVR"], ["ZEABUR"], ["CODESPHERE", "CODESPHERE_APP_ID", { ci: true }], ["RAILWAY", "RAILWAY_PROJECT_ID"], ["RAILWAY", "RAILWAY_SERVICE_ID"], ["DENO-DEPLOY", "DENO_DEPLOYMENT_ID"], ["FIREBASE_APP_HOSTING", "FIREBASE_APP_HOSTING", { ci: true }]];
+function b() {
+  if (globalThis.process?.env)
+    for (const e of f) {
+      const s = e[1] || e[0];
+      if (globalThis.process?.env[s])
+        return { name: e[0].toLowerCase(), ...e[2] };
+    }
+  return globalThis.process?.env?.SHELL === "/bin/jsh" && globalThis.process?.versions?.webcontainer ? { name: "stackblitz", ci: false } : { name: "", ci: false };
+}
+var l = b();
+var p = l.name;
+function n(e) {
+  return e ? e !== "false" : false;
+}
+var I = globalThis.process?.platform || "";
+var T = n(o.CI) || l.ci !== false;
+var R = n(globalThis.process?.stdout && globalThis.process?.stdout.isTTY);
+var U = typeof window < "u";
+var d = n(o.DEBUG);
+var a = t === "test" || n(o.TEST);
+var v = n(o.MINIMAL) || T || a || !R;
+var A = /^win/i.test(I);
+var M = /^linux/i.test(I);
+var m = /^darwin/i.test(I);
+var Y = !n(o.NO_COLOR) && (n(o.FORCE_COLOR) || (R || A) && o.TERM !== "dumb" || T);
+var C = (globalThis.process?.versions?.node || "").replace(/^v/, "") || null;
+var V = Number(C?.split(".")[0]) || null;
+var W = globalThis.process || Object.create(null);
+var _ = { versions: {} };
+var y = new Proxy(W, { get(e, s) {
+  if (s === "env")
+    return o;
+  if (s in e)
+    return e[s];
+  if (s in _)
+    return _[s];
+} });
+var O = globalThis.process?.release?.name === "node";
+var c = !!globalThis.Bun || !!globalThis.process?.versions?.bun;
+var D = !!globalThis.Deno;
+var L = !!globalThis.fastly;
+var S = !!globalThis.Netlify;
+var u = !!globalThis.EdgeRuntime;
+var N = globalThis.navigator?.userAgent === "Cloudflare-Workers";
+var F = [[S, "netlify"], [u, "edge-light"], [N, "workerd"], [L, "fastly"], [D, "deno"], [c, "bun"], [O, "node"]];
+function G() {
+  const e = F.find((s) => s[0]);
+  if (e)
+    return { name: e[1] };
+}
+var P = G();
+var K = P?.name || "";
 
 // src/constants/re.ts
 var JS_RE = /\.(js|jsx|cjs|mjs)$/;
@@ -278,7 +352,6 @@ var DTS_RE = /\.(d\.(ts|mts|cts))$/;
 var JS_TS_RE = new RegExp(`${JS_RE.source}|${TS_RE.source}`);
 var JS_DTS_RE = new RegExp(`${JS_RE.source}|${DTS_RE.source}`);
 var CSS_RE = /\.(css)$/;
-var EXTENSION_REGEX = /\.(d\.(ts|cts|mts)|[cm]?[jt]s)$/;
 
 // src/utils.ts
 function ensureArray(value) {
@@ -304,13 +377,6 @@ function getDefaultDtsExtention(format, packageType) {
       return ".global.d.ts";
   }
 }
-function getDeclarationExtensionFromJsExtension(ext) {
-  if (ext === ".mjs")
-    return ".d.mts";
-  if (ext === ".cjs")
-    return ".d.cts";
-  return ".d.ts";
-}
 function isModulePackage(packageType) {
   return packageType === "module";
 }
@@ -329,10 +395,10 @@ 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]}`;
+  const i2 = Math.floor(Math.log(bytes) / Math.log(1024));
+  if (i2 === 0)
+    return `${bytes} ${units[i2]}`;
+  return `${(bytes / 1024 ** i2).toFixed(2)} ${units[i2]}`;
 }
 function getShortFilePath(filePath, maxLength = 3) {
   const fileParts = filePath.split("/");
@@ -373,8 +439,8 @@ function formatListWithAnd(arr) {
   }).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 includePatterns = patterns.filter((p2) => !p2.startsWith("!"));
+  const excludePatterns = patterns.filter((p2) => p2.startsWith("!")).map((p2) => p2.slice(1));
   const includedFiles = new Set;
   for (const pattern of includePatterns) {
     const glob = new Bun.Glob(pattern);
@@ -392,38 +458,5 @@ async function getFilesFromGlobs(patterns, cwd) {
   }
   return Array.from(includedFiles);
 }
-function isDev() {
-  return isDevelopment || !isCI;
-}
-function generateRandomString(length = 10) {
-  return Array.from({ length }, () => String.fromCharCode(97 + Math.floor(Math.random() * 26))).join("");
-}
-function isNullOrUndefined(value) {
-  return value === null || value === undefined;
-}
-function isTypeScriptFile(path2) {
-  if (!path2)
-    return false;
-  return TS_RE.test(path2);
-}
-function getExtension(filename) {
-  const match = filename.match(EXTENSION_REGEX);
-  if (!match)
-    return "";
-  const ext = match[0];
-  return ext;
-}
-function replaceExtension(filename, newExt) {
-  if (EXTENSION_REGEX.test(filename)) {
-    return filename.replace(EXTENSION_REGEX, newExt);
-  }
-  return filename + newExt;
-}
-function deleteExtension(filename) {
-  return filename.replace(EXTENSION_REGEX, "");
-}
-function returnPathIfExists(path2) {
-  return pathExistsSync(path2) ? path2 : null;
-}
 
-export { __toESM, __require, setSilent, logTable, link, logger, JS_RE, JS_TS_RE, JS_DTS_RE, CSS_RE, BunupBuildError, BunupDTSBuildError, BunupCLIError, BunupWatchError, BunupPluginError, parseErrorMessage, handleError, handleErrorAndExit, ensureArray, getDefaultOutputExtension, getDefaultDtsExtention, getDeclarationExtensionFromJsExtension, formatTime, getPackageDeps, formatFileSize, getShortFilePath, cleanOutDir, cleanPath, isDirectoryPath, pathExistsSync, formatListWithAnd, getFilesFromGlobs, isDev, generateRandomString, isNullOrUndefined, isTypeScriptFile, getExtension, replaceExtension, deleteExtension, returnPathIfExists };
+export { __toESM, __require, setSilent, logTable, link, logger, BunupBuildError, BunupDTSBuildError, BunupCLIError, BunupWatchError, BunupPluginError, parseErrorMessage, handleError, handleErrorAndExit, JS_TS_RE, JS_DTS_RE, CSS_RE, ensureArray, getDefaultOutputExtension, getDefaultDtsExtention, formatTime, getPackageDeps, formatFileSize, getShortFilePath, cleanOutDir, cleanPath, isDirectoryPath, pathExistsSync, formatListWithAnd, getFilesFromGlobs };

package/dist/chunk-g2khvv3w.js

@@ -0,0 +1,384 @@
+import {
+  filterBunupBunPlugins,
+  filterBunupPlugins,
+  runPluginBuildDoneHooks,
+  runPluginBuildStartHooks
+} from "./chunk-zpjpa5th.js";
+import {
+  loadPackageJson
+} from "./chunk-gh7z7s46.js";
+import {
+  BunupBuildError,
+  BunupDTSBuildError,
+  cleanOutDir,
+  cleanPath,
+  ensureArray,
+  formatFileSize,
+  getDefaultDtsExtention,
+  getDefaultOutputExtension,
+  getFilesFromGlobs,
+  getPackageDeps,
+  getShortFilePath,
+  link,
+  logTable,
+  logger,
+  parseErrorMessage,
+  setSilent
+} from "./chunk-cakmscpb.js";
+
+// src/build.ts
+import path from "path";
+import pc2 from "picocolors";
+import { generateDts, logIsolatedDeclarationErrors } from "typeroll";
+
+// src/plugins/internal/linter.ts
+var rules = [
+  {
+    check: (ctx) => {
+      const hasMinification = !!(ctx.options.minify || ctx.options.minifyWhitespace || ctx.options.minifyIdentifiers || ctx.options.minifySyntax);
+      return hasMinification && !ctx.options.sourcemap;
+    },
+    message: `You are using minification without source maps. Consider enabling source maps to help with debugging minified code. Learn more: ${link("https://bunup.dev/docs/guide/options#source-maps")}`,
+    logLevel: "recommended"
+  }
+];
+function linter() {
+  return {
+    type: "bunup",
+    name: "linter",
+    hooks: {
+      onBuildDone: (ctx) => {
+        let hasWarnings = false;
+        for (const rule of rules) {
+          if (rule.check(ctx)) {
+            if (!hasWarnings) {
+              logger.space();
+            }
+            logger[rule.logLevel ?? "warn"](rule.message);
+            hasWarnings = true;
+          }
+        }
+      }
+    }
+  };
+}
+
+// src/plugins/internal/report.ts
+import pc 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: pc.blue },
+          { header: "Size", align: "right", color: pc.green },
+          {
+            header: "Gzip",
+            align: "right",
+            color: pc.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
+var DEFAULT_OPTIONS = {
+  entry: ["src/index.ts"],
+  format: ["cjs"],
+  outDir: "dist",
+  target: "node",
+  clean: true
+};
+function createBuildOptions(partialOptions) {
+  const options = {
+    ...DEFAULT_OPTIONS,
+    ...partialOptions
+  };
+  return {
+    ...options,
+    plugins: [...options.plugins ?? [], useClient(), linter(), 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
+function getPackageDepsPatterns(packageJson) {
+  return getPackageDeps(packageJson).map((dep) => new RegExp(`^${dep}($|\\/|\\\\)`));
+}
+function matchesPattern(path, pattern) {
+  return typeof pattern === "string" ? pattern === path : pattern.test(path);
+}
+function isExternal(path, options, packageJson) {
+  const packageDepsPatterns = getPackageDepsPatterns(packageJson);
+  const matchesExternalPattern = packageDepsPatterns.some((pattern) => pattern.test(path)) || options.external?.some((pattern) => matchesPattern(path, pattern));
+  const isExcludedFromExternal = options.noExternal?.some((pattern) => matchesPattern(path, 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/build.ts
+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(`One or more of the entrypoints you provided do not exist. Please check that each entrypoint points to a valid file.`);
+  }
+  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);
+    }
+    let entrypointIndex = 0;
+    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(`${pc2.dim(`${options.outDir}/`)}${relativePathToOutputDir}`, {
+          identifier: options.name
+        });
+      }
+      buildOutput.files.push({
+        fullPath: file.path,
+        relativePathToRootDir,
+        relativePathToOutputDir,
+        dts: false,
+        format: fmt,
+        kind: file.kind,
+        entrypoint: file.kind === "entry-point" ? cleanPath(entrypoints[entrypointIndex]) : undefined
+      });
+      if (file.kind === "entry-point") {
+        entrypointIndex++;
+      }
+    }
+  });
+  await Promise.all(buildPromises);
+  if (options.dts) {
+    try {
+      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);
+      }
+      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(`${pc2.dim(`${options.outDir}/`)}${relativePathToOutputDir}`, {
+              identifier: options.name
+            });
+          }
+          const fullPath = path.join(rootDir, relativePathToRootDir);
+          await Bun.write(fullPath, file.dts);
+          buildOutput.files.push({
+            fullPath,
+            relativePathToRootDir,
+            relativePathToOutputDir,
+            dts: true,
+            format: fmt,
+            kind: file.kind,
+            entrypoint: file.entrypoint ? cleanPath(file.entrypoint) : undefined
+          });
+        }
+      }
+    } catch (error) {
+      throw new BunupDTSBuildError(parseErrorMessage(error));
+    } finally {
+      logger.space();
+    }
+  }
+  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 { createBuildOptions, build };

package/dist/{chunk-5v78yfze.js → chunk-gh7z7s46.js}

@@ -26,14 +26,5 @@ async function loadPackageJson(cwd = process.cwd()) {
     path: filepath
   };
 }
-async function loadTsConfig(cwd, preferredPath) {
-  const config = await loadConfig({
-    name: "tsconfig",
-    extensions: [".json"],
-    preferredPath,
-    cwd
-  });
-  return config;
-}
 
-export { processLoadedConfigs, loadPackageJson, loadTsConfig };
+export { processLoadedConfigs, loadPackageJson };

package/dist/{chunk-ga9j5qp4.js → chunk-p86qvgaa.js}

@@ -1,14 +1,14 @@
 // @bun
 import {
   loadPackageJson
-} from "./chunk-5v78yfze.js";
+} from "./chunk-gh7z7s46.js";
 import {
   displayBunupGradientArt
-} from "./chunk-mf58dgyw.js";
+} from "./chunk-4cgw2ywa.js";
 import {
   formatListWithAnd,
   link
-} from "./chunk-kk5yc8cy.js";
+} from "./chunk-cakmscpb.js";
 
 // src/cli/init.ts
 import fs from "fs";

package/dist/{chunk-cv4z06x8.js → chunk-zpjpa5th.js}

@@ -1,6 +1,6 @@
 import {
   BunupPluginError
-} from "./chunk-kk5yc8cy.js";
+} from "./chunk-cakmscpb.js";
 
 // src/plugins/utils.ts
 import pc from "picocolors";

package/dist/cli/index.js

@@ -3,11 +3,11 @@
 import {
   build,
   createBuildOptions
-} from "../chunk-v3nkk11v.js";
-import"../chunk-cv4z06x8.js";
+} from "../chunk-g2khvv3w.js";
+import"../chunk-zpjpa5th.js";
 import {
   processLoadedConfigs
-} from "../chunk-5v78yfze.js";
+} from "../chunk-gh7z7s46.js";
 import {
   BunupCLIError,
   BunupWatchError,
@@ -21,14 +21,14 @@ import {
   logger,
   parseErrorMessage,
   setSilent
-} from "../chunk-kk5yc8cy.js";
+} from "../chunk-cakmscpb.js";
 
 // src/cli/index.ts
 import { loadConfig } from "coffi";
 import pc3 from "picocolors";
 import { exec } from "tinyexec";
 // package.json
-var version = "0.8.52";
+var version = "0.8.53";
 
 // src/watch.ts
 import path from "path";
@@ -485,12 +485,12 @@ var parseCliOptions = (argv) => {
 async function main(args = Bun.argv.slice(2)) {
   const cliOptions = parseCliOptions(args);
   if (cliOptions.new) {
-    const { newProject } = await import("../chunk-8dm3xyd7.js");
+    const { newProject } = await import("../chunk-c4xe90dt.js");
     await newProject();
     return;
   }
   if (cliOptions.init) {
-    const { init } = await import("../chunk-ga9j5qp4.js");
+    const { init } = await import("../chunk-p86qvgaa.js");
     await init();
     return;
   }

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Arrayable, BuildOptions, DefineConfigItem, DefineWorkspaceItem, Plugin } from "./chunk-p2wczz52";
+import { Arrayable, BuildOptions, DefineConfigItem, DefineWorkspaceItem, Plugin } from "./chunk-80rcmwcp";
 declare function build(partialOptions: Partial<BuildOptions>, rootDir?: string): Promise<void>;
 declare function defineConfig(options: Arrayable<DefineConfigItem>): Arrayable<DefineConfigItem>;
 declare function defineWorkspace(options: DefineWorkspaceItem[]): DefineWorkspaceItem[];