bunup 0.8.42 → 0.8.44

package/dist/chunk-5s4mpe5d.js

@@ -0,0 +1,355 @@
+// @bun
+import {
+  loadPackageJson
+} from "./chunk-gh7z7s46.js";
+import {
+  displayBunupGradientArt
+} from "./chunk-a7j07gk7.js";
+import {
+  formatListWithAnd
+} from "./chunk-c1eyecm3.js";
+
+// src/cli/init.ts
+import fs from "fs";
+import path from "path";
+import {
+  confirm,
+  intro,
+  log,
+  multiselect,
+  outro,
+  select,
+  tasks,
+  text
+} from "@clack/prompts";
+import pc from "picocolors";
+import { exec } from "tinyexec";
+async function init() {
+  displayBunupGradientArt();
+  intro(pc.bgCyan(pc.black(" Initialize bunup in an existing project ")));
+  const { path: packageJsonPath } = await loadPackageJson();
+  if (!packageJsonPath) {
+    log.error("package.json not found");
+    process.exit(1);
+  }
+  const shouldSetupWorkspace = await promptForWorkspace();
+  if (shouldSetupWorkspace) {
+    await initializeWorkspace(packageJsonPath);
+  } else {
+    await initializeSinglePackage(packageJsonPath);
+  }
+  await tasks([
+    {
+      title: "Installing bunup",
+      task: async () => {
+        await installBunup();
+        return "Bunup installed";
+      }
+    }
+  ]);
+  showSuccessOutro(shouldSetupWorkspace);
+}
+async function promptForWorkspace() {
+  return await confirm({
+    message: "Do you want to setup a Bunup workspace? (for building multiple packages with one command)",
+    initialValue: false
+  });
+}
+async function initializeWorkspace(packageJsonPath) {
+  const workspacePackages = await collectWorkspacePackages();
+  const configMethod = await selectWorkspaceConfigurationMethod();
+  await generateWorkspaceConfiguration(configMethod, workspacePackages);
+  await handleWorkspaceBuildScripts(packageJsonPath);
+}
+async function initializeSinglePackage(packageJsonPath) {
+  const entryFiles = await collectEntryFiles();
+  const outputFormats = await selectOutputFormats();
+  const shouldGenerateDts = await promptForTypeScriptDeclarations(entryFiles);
+  const configMethod = await selectConfigurationMethod();
+  await generateConfiguration(configMethod, entryFiles, outputFormats, shouldGenerateDts, packageJsonPath);
+  await handleBuildScripts(packageJsonPath, entryFiles, outputFormats, shouldGenerateDts, configMethod);
+}
+async function collectWorkspacePackages() {
+  const packages = [];
+  while (true) {
+    const packageName = await text({
+      message: packages.length > 0 ? "Enter the next package name:" : "Enter the first package name:",
+      placeholder: "core",
+      validate: (value) => {
+        if (!value)
+          return "Package name is required";
+        if (packages.some((pkg) => pkg.name === value))
+          return "Package name already exists";
+      }
+    });
+    const packageRoot = await text({
+      message: `Enter the root directory for "${packageName}":`,
+      placeholder: `packages/${packageName}`,
+      defaultValue: `packages/${packageName}`,
+      validate: (value) => {
+        if (!value)
+          return "Package root is required";
+        if (!fs.existsSync(value))
+          return "Package root directory does not exist";
+        if (!fs.statSync(value).isDirectory())
+          return "Package root must be a directory";
+      }
+    });
+    const entryFiles = await collectEntryFilesForPackage(packageRoot, packageName);
+    const outputFormats = await selectOutputFormats();
+    const shouldGenerateDts = await promptForTypeScriptDeclarations(entryFiles);
+    packages.push({
+      name: packageName,
+      root: packageRoot,
+      entryFiles,
+      outputFormats,
+      shouldGenerateDts
+    });
+    const shouldAddMore = await confirm({
+      message: "Do you want to add another package?",
+      initialValue: true
+    });
+    if (!shouldAddMore)
+      break;
+  }
+  return packages;
+}
+async function collectEntryFilesForPackage(packageRoot, packageName) {
+  const entryFiles = [];
+  while (true) {
+    const entryFile = await text({
+      message: entryFiles.length > 0 ? `Where is the next entry file for "${packageName}"? (relative to ${packageRoot})` : `Where is the entry file for "${packageName}"? (relative to ${packageRoot})`,
+      placeholder: "src/index.ts",
+      defaultValue: "src/index.ts",
+      validate: (value) => {
+        if (!value)
+          return "Entry file is required";
+        const fullPath = path.join(packageRoot, value);
+        if (!fs.existsSync(fullPath))
+          return `Entry file does not exist at ${fullPath}`;
+        if (!fs.statSync(fullPath).isFile())
+          return "Entry file must be a file";
+        if (entryFiles.includes(value))
+          return "You have already added this entry file";
+      }
+    });
+    entryFiles.push(entryFile);
+    const shouldAddMore = await confirm({
+      message: "Do you want to add another entry file for this package?",
+      initialValue: false
+    });
+    if (!shouldAddMore)
+      break;
+  }
+  return entryFiles;
+}
+async function collectEntryFiles() {
+  const entryFiles = [];
+  while (true) {
+    const entryFile = await text({
+      message: entryFiles.length > 0 ? "Where is your next entry file?" : "Where is your entry file?",
+      placeholder: "src/index.ts",
+      defaultValue: "src/index.ts",
+      validate: (value) => {
+        if (!value)
+          return "Entry file is required";
+        if (!fs.existsSync(value))
+          return "Entry file does not exist";
+        if (!fs.statSync(value).isFile())
+          return "Entry file must be a file";
+        if (entryFiles.includes(value))
+          return "You have already added this entry file";
+      }
+    });
+    entryFiles.push(entryFile);
+    const shouldAddMore = await confirm({
+      message: "Do you want to add another entry file?",
+      initialValue: false
+    });
+    if (!shouldAddMore)
+      break;
+  }
+  return entryFiles;
+}
+async function selectOutputFormats() {
+  return await multiselect({
+    message: "Select the output formats",
+    options: [
+      { value: "esm", label: "ESM (.mjs)" },
+      { value: "cjs", label: "CommonJS (.cjs)" },
+      { value: "iife", label: "IIFE (.global.js)" }
+    ],
+    initialValues: ["esm", "cjs"]
+  });
+}
+async function promptForTypeScriptDeclarations(entryFiles) {
+  const hasTypeScriptFiles = entryFiles.some((file) => file.endsWith(".ts") || file.endsWith(".tsx"));
+  if (!hasTypeScriptFiles)
+    return false;
+  return await confirm({
+    message: "Generate TypeScript declarations?",
+    initialValue: true
+  });
+}
+async function selectWorkspaceConfigurationMethod() {
+  return await select({
+    message: "How would you like to configure your workspace?",
+    options: [
+      { value: "ts", label: "bunup.config.ts", hint: "Recommended" },
+      { value: "js", label: "bunup.config.js" }
+    ],
+    initialValue: "ts"
+  });
+}
+async function selectConfigurationMethod() {
+  return await select({
+    message: "How would you like to configure Bunup?",
+    options: [
+      { value: "ts", label: "bunup.config.ts", hint: "Recommended" },
+      { value: "js", label: "bunup.config.js" },
+      { value: "json", label: 'package.json "bunup" property' },
+      {
+        value: "none",
+        label: "No config file",
+        hint: "Configure via CLI only"
+      }
+    ],
+    initialValue: "ts"
+  });
+}
+async function generateWorkspaceConfiguration(configMethod, workspacePackages) {
+  const configContent = createWorkspaceConfigFileContent(workspacePackages);
+  await Bun.write(`bunup.config.${configMethod}`, configContent);
+}
+async function generateConfiguration(configMethod, entryFiles, outputFormats, shouldGenerateDts, packageJsonPath) {
+  if (configMethod === "none") {
+    log.info("If you need more control (such as adding plugins or customizing output), you can always create a config file later.");
+    return;
+  }
+  if (configMethod === "ts" || configMethod === "js") {
+    await Bun.write(`bunup.config.${configMethod}`, createConfigFileContent(entryFiles, outputFormats, shouldGenerateDts));
+  } else if (configMethod === "json") {
+    const { data: packageJsonConfig } = await loadPackageJson();
+    const updatedConfig = {
+      ...packageJsonConfig,
+      bunup: createPackageJsonConfig(entryFiles, outputFormats, shouldGenerateDts)
+    };
+    await Bun.write(packageJsonPath, JSON.stringify(updatedConfig, null, 2));
+  }
+}
+async function handleWorkspaceBuildScripts(packageJsonPath) {
+  const { data: packageJsonConfig } = await loadPackageJson();
+  const existingScripts = packageJsonConfig?.scripts ?? {};
+  const newScripts = createWorkspaceBuildScripts();
+  const conflictingScripts = Object.keys(newScripts).filter((script) => existingScripts[script]);
+  if (conflictingScripts.length > 0) {
+    const shouldOverride = await confirm({
+      message: `The ${formatListWithAnd(conflictingScripts)} ${conflictingScripts.length > 1 ? "scripts already exist" : "script already exists"} in package.json. Override ${conflictingScripts.length > 1 ? "them" : "it"}?`,
+      initialValue: true
+    });
+    if (!shouldOverride) {
+      log.info("Skipped adding build scripts to avoid conflicts.");
+      return;
+    }
+  }
+  const updatedConfig = {
+    ...packageJsonConfig,
+    scripts: { ...existingScripts, ...newScripts }
+  };
+  await Bun.write(packageJsonPath, JSON.stringify(updatedConfig, null, 2));
+}
+async function handleBuildScripts(packageJsonPath, entryFiles, outputFormats, shouldGenerateDts, configMethod) {
+  const { data: packageJsonConfig } = await loadPackageJson();
+  const existingScripts = packageJsonConfig?.scripts ?? {};
+  const newScripts = createBuildScripts(entryFiles, outputFormats, shouldGenerateDts, configMethod);
+  const conflictingScripts = Object.keys(newScripts).filter((script) => existingScripts[script]);
+  if (conflictingScripts.length > 0) {
+    const shouldOverride = await confirm({
+      message: `The ${formatListWithAnd(conflictingScripts)} ${conflictingScripts.length > 1 ? "scripts already exist" : "script already exists"} in package.json. Override ${conflictingScripts.length > 1 ? "them" : "it"}?`,
+      initialValue: true
+    });
+    if (!shouldOverride) {
+      log.info("Skipped adding build scripts to avoid conflicts.");
+      return;
+    }
+  }
+  const updatedConfig = {
+    ...packageJsonConfig,
+    scripts: { ...existingScripts, ...newScripts }
+  };
+  await Bun.write(packageJsonPath, JSON.stringify(updatedConfig, null, 2));
+}
+function createWorkspaceConfigFileContent(workspacePackages) {
+  const packagesConfig = workspacePackages.map((pkg) => {
+    return `  {
+    name: '${pkg.name}',
+    root: '${pkg.root}',
+    config: {
+      entry: [${pkg.entryFiles.map((file) => `'${file}'`).join(", ")}],
+      format: [${pkg.outputFormats.map((format) => `'${format}'`).join(", ")}],${pkg.shouldGenerateDts ? `
+      dts: true,` : ""}
+    },
+  }`;
+  }).join(`,
+`);
+  return `import { defineWorkspace } from 'bunup'
+
+export default defineWorkspace([
+${packagesConfig}
+])
+`;
+}
+function createConfigFileContent(entryFiles, outputFormats, shouldGenerateDts) {
+  return `import { defineConfig } from 'bunup'
+
+export default defineConfig({
+	entry: [${entryFiles.map((file) => `'${file}'`).join(", ")}],
+	format: [${outputFormats.map((format) => `'${format}'`).join(", ")}],${shouldGenerateDts ? `
+	dts: true,` : ""}
+})
+`;
+}
+function createPackageJsonConfig(entryFiles, outputFormats, shouldGenerateDts) {
+  return {
+    entry: entryFiles,
+    format: outputFormats,
+    ...shouldGenerateDts && { dts: true }
+  };
+}
+function createWorkspaceBuildScripts() {
+  return {
+    build: "bunup",
+    dev: "bunup --watch"
+  };
+}
+function createBuildScripts(entryFiles, outputFormats, shouldGenerateDts, configMethod) {
+  const cliOptions = configMethod === "none" ? ` ${entryFiles.join(" ")} --format ${outputFormats.join(",")}${shouldGenerateDts ? " --dts" : ""}` : "";
+  return {
+    build: `bunup${cliOptions}`,
+    dev: `bunup${cliOptions} --watch`
+  };
+}
+function showSuccessOutro(isWorkspace) {
+  const buildCommand = isWorkspace ? `${pc.cyan("bun run build")} - Build all packages in your workspace` : `${pc.cyan("bun run build")} - Build your library`;
+  const devCommand = isWorkspace ? `${pc.cyan("bun run dev")} - Start development mode (watches all packages)` : `${pc.cyan("bun run dev")} - Start development mode`;
+  const filterCommand = isWorkspace ? `${pc.cyan("bunup --filter core,utils")} - Build specific packages` : "";
+  outro(`
+   ${pc.green("\u2728 Bunup initialized successfully! \u2728")}
+
+   ${buildCommand}
+   ${devCommand}${isWorkspace ? `
+   ${filterCommand}` : ""}
+  
+   ${pc.dim("Learn more:")} ${pc.underline("https://bunup.dev/docs")}
+  
+   ${pc.yellow("Happy building!")} \uD83D\uDE80
+  `);
+}
+async function installBunup() {
+  await exec("bun add -d bunup", [], {
+    nodeOptions: { shell: true, stdio: "pipe" }
+  });
+}
+export {
+  init
+};

package/dist/chunk-6gvmfnmt.js

@@ -0,0 +1,45 @@
+import {
+  BunupPluginError
+} from "./chunk-c1eyecm3.js";
+
+// src/plugins/utils.ts
+import pc 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(`[${pc.cyan(name)}] is required for the ${pluginName} plugin. Please install it with: ${pc.blue(`bun add ${name} --dev`)}`);
+  }
+  return pkg;
+}
+
+export { filterBunupBunPlugins, filterBunupPlugins, runPluginBuildStartHooks, runPluginBuildDoneHooks, getPackageForPlugin };