bunup 0.8.47 → 0.8.49

package/dist/chunk-ffytsq4c.js

@@ -1,376 +0,0 @@
-import {
-  filterBunupBunPlugins,
-  filterBunupPlugins,
-  runPluginBuildDoneHooks,
-  runPluginBuildStartHooks
-} from "./chunk-snvybwa2.js";
-import {
-  loadPackageJson
-} from "./chunk-gh7z7s46.js";
-import {
-  BunupBuildError,
-  cleanOutDir,
-  cleanPath,
-  ensureArray,
-  formatFileSize,
-  getDefaultDtsExtention,
-  getDefaultOutputExtension,
-  getFilesFromGlobs,
-  getPackageDeps,
-  getShortFilePath,
-  link,
-  logTable,
-  logger,
-  setSilent
-} from "./chunk-a76fsvj7.js";
-
-// src/build.ts
-import path from "path";
-import { generateDts, logIsolatedDeclarationErrors } from "bun-dts";
-import pc2 from "picocolors";
-
-// 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("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);
-    }
-    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: entrypoints[entrypointIndex]
-      });
-      entrypointIndex++;
-    }
-  });
-  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(`${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
-        });
-      }
-    }
-  }
-  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 };