prepare-package 1.2.6 → 2.0.1

package/CLAUDE.md

@@ -0,0 +1,76 @@
+# prepare-package
+
+## Overview
+NPM build tool that prepares packages for distribution. Supports two modes: **copy** (file copy with version replacement) and **bundle** (esbuild multi-format builds).
+
+## Architecture
+
+### Two Modes via `preparePackage.type`
+- **`"copy"` (default)**: Copies `src/` to `dist/`, replaces `{version}` in the main file. Used by large projects that don't need bundling (e.g., UJM).
+- **`"bundle"`**: Uses esbuild to produce ESM (`index.mjs`), CJS (`index.js`), and/or IIFE (minified, for CDN `<script>` tags). Used by client-side libraries (e.g., chatsy).
+
+### Project Structure
+```
+src/
+  index.js    # Main entry: resolves config, branches copy vs bundle, safety checks, CDN purge
+  build.js    # Esbuild config generator, version plugin, build() and createWatchContexts()
+  watch.js    # Watch mode: chokidar for copy, esbuild contexts for bundle
+  cli.js      # Interactive CLI for project setup (npx pp / npx prepare-package)
+  logger.js   # Timestamped console logger with chalk colors
+dist/         # Copy-mode output of src/ (prepare-package builds itself with copy mode)
+```
+
+### CLI (`npx pp` / `npx prepare-package`)
+Interactive setup wizard that configures a project's `package.json`:
+1. Asks **copy** or **bundle** mode
+2. Asks source/output directories (defaults: `src`/`dist`)
+3. If bundle: asks formats, auto-derives `globalName` (TitleCase of package name) and `fileName` (`{name}.min.js`)
+4. Writes `preparePackage` config and `prepare`/`prepare:watch` scripts to `package.json`
+
+### How It Runs
+- **`prepare` script**: Runs on `npm install` and `npm publish` in the consumer's project
+- **`postinstall` script**: Runs when prepare-package itself is installed as a dependency. Skips bundle mode (esbuild may not be available yet during install)
+- **`prepare:watch` script**: Starts watch mode (chokidar for copy, esbuild `.watch()` for bundle)
+- **`bin` commands**: `prepare-package` and `pp` both point to `cli.js`
+
+### Consumer Configuration
+All config lives in `preparePackage` key in the consumer's `package.json`:
+
+```jsonc
+{
+  "preparePackage": {
+    "input": "src",           // Source directory
+    "output": "dist",         // Output directory
+    "type": "copy",           // "copy" (default) or "bundle"
+    "build": {                // Only used when type: "bundle"
+      "entry": "src/index.js",
+      "formats": ["esm", "cjs", "iife"],
+      "target": "es2020",
+      "platform": "neutral",
+      "external": [],
+      "sourcemap": false,
+      "iife": {
+        "globalName": "MyLib",      // Required for IIFE
+        "fileName": "my-lib.min.js" // Default: "{name}.min.js"
+      }
+    }
+  }
+}
+```
+
+### Publish Safety
+- Blocks publish if any local `file:` dependencies are found
+- Removes sensitive files (`.env`, `.DS_Store`, etc.) from the package
+- Purges jsDelivr CDN cache after publish
+
+### Key Details
+- esbuild is a direct dependency but only `require()`'d inside bundle code paths (lazy-loaded)
+- Bundle mode's version plugin replaces `{version}` in all `.js` files at build time
+- IIFE build auto-unwraps default export: `GlobalName=GlobalName.default||GlobalName.GlobalName||GlobalName;`
+- Copy mode's `{version}` replacement only applies to the main file
+- prepare-package builds itself using copy mode (it's both the tool and a consumer of itself)
+
+## Conventions
+- Self-hosting: prepare-package uses itself (copy mode) to build `src/` → `dist/`
+- No breaking changes to copy mode — existing consumers must keep working unchanged
+- Bundle mode is opt-in via `type: "bundle"`

package/README.md

@@ -24,48 +24,129 @@
   <strong>Prepare Package</strong> is a helpful NPM module that prepares your package before distribution.
 </p>
 
-## 📦 Install Prepare Package
-### Option 1: Install via npm
-Install with npm if you plan to use **Prepare Package** in a Node.js project.
+## Install
 ```shell
 npm install prepare-package --save-dev
 ```
 
-## 🦄 Features
-* Copy files from `src` to `dist`
-* Replace tags in your main file, `index.js`
-  * `{version}` => `package.version`
+## Quick Setup
+Run the interactive CLI to configure your project:
+```shell
+npx pp
+```
+
+This will walk you through selecting a build type (**copy** or **bundle**), configuring formats, and auto-deriving IIFE settings (global name from package name in TitleCase, filename as `{name}.min.js`). The CLI writes the `preparePackage` config and scripts directly to your `package.json`.
+
+You can also use the full name:
+```shell
+npx prepare-package
+```
+
+## Features
+* Two modes: **copy** (default) and **bundle** (esbuild)
+* Copy mode: copies `src/` to `dist/`, replaces `{version}` in main file
+* Bundle mode: builds ESM, CJS, and/or IIFE outputs via esbuild
+* Blocks `npm publish` when local `file:` dependencies are detected
+* Cleans up sensitive files (`.env`, `.DS_Store`, etc.) before publish
+* Purges jsDelivr CDN cache after publish
+* Watch mode for both copy and bundle types
+* Auto-adds `prepare` and `prepare:watch` scripts to consumer's `package.json`
+
+## Configuration
+
+All configuration lives in the `preparePackage` key in your `package.json`.
+
+### Copy Mode (default)
+
+Copies files from `input` to `output` and replaces `{version}` in the main file.
+
+```json
+{
+  "main": "dist/index.js",
+  "preparePackage": {
+    "input": "src",
+    "output": "dist"
+  }
+}
+```
+
+| Key | Default | Description |
+|-----|---------|-------------|
+| `type` | `"copy"` | Processing mode |
+| `input` | `"src"` | Source directory to copy from |
+| `output` | `"dist"` | Destination directory to copy to |
+| `replace` | `{}` | Additional replacements (reserved) |
+
+### Bundle Mode
+
+Uses esbuild to produce optimized builds in multiple module formats.
 
-## 📘 Example Setup
-After installing via npm, simply put this in your `package.json`
 ```json
-...
-"main": "dist/index.js",
-"scripts": {
-  "prepare": "node -e 'require(`prepare-package`)()'",
-  "prepare:watch": "nodemon -w ./src -e '*' --exec 'npm run prepare'"
-},
-"preparePackage": {
-  "input": "src",
-  "output": "dist",
-  "replace": {}
-},
-...
+{
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "preparePackage": {
+    "input": "src",
+    "output": "dist",
+    "type": "bundle",
+    "build": {
+      "formats": ["esm", "cjs", "iife"],
+      "iife": {
+        "globalName": "MyLib",
+        "fileName": "my-lib.min.js"
+      }
+    }
+  }
+}
 ```
-* `preparePackage` is not required but you can provide it to customize the process.
-* `preparePackage.input`: The dir to copy **from**.
-* `preparePackage.out`: The dir to copy **to**.
-* `main`: The file to copy and use as your main file. Tags like `{version}` are replaced in this file.
 
-## ⚡️ Usage
-### Run Prepare Package
+| Key | Default | Description |
+|-----|---------|-------------|
+| `type` | — | Must be `"bundle"` to enable this mode |
+| `build.entry` | `"{input}/index.js"` | Entry point for esbuild |
+| `build.formats` | `["esm", "cjs"]` | Output formats: `"esm"`, `"cjs"`, `"iife"` |
+| `build.target` | `"es2020"` | esbuild target for ESM/CJS builds |
+| `build.platform` | `"neutral"` | esbuild platform |
+| `build.external` | `[]` | Packages to exclude from bundle |
+| `build.sourcemap` | `false` | Generate source maps |
+| `build.iife.globalName` | — | **Required** when `"iife"` is in formats. The global variable name (e.g., `window.MyLib`) |
+| `build.iife.fileName` | `"{name}.min.js"` | Output filename for IIFE build |
+| `build.iife.target` | `"es2015"` | esbuild target for IIFE build |
+
+#### Output files
+| Format | File | Minified |
+|--------|------|----------|
+| ESM | `dist/index.mjs` | No |
+| CJS | `dist/index.js` | No |
+| IIFE | `dist/{fileName}` | Yes |
+
+#### Version replacement
+In bundle mode, all occurrences of `{version}` in `.js` source files are replaced with the version from `package.json` at build time via an esbuild plugin.
+
+#### IIFE global export
+The IIFE build automatically unwraps the default export so `window[globalName]` is the class/function directly, not a `{ default }` wrapper.
+
+## Usage
+
 ```shell
-# Run once
+# Build once
 npm run prepare
 
-# Run and watch for changes
+# Watch for changes
 npm run prepare:watch
+
+# These scripts are auto-added to your package.json:
+# "prepare": "node -e \"require('prepare-package')()\""
+# "prepare:watch": "node -e \"require('prepare-package/watch')()\""
 ```
 
-## 🗨️ Final Words
-If you are still having difficulty, we would love for you to post a question to [the Prepare Package issues page](https://github.com/itw-creative-works/prepare-package/issues). It is much easier to answer questions that include your code and relevant files! So if you can provide them, we'd be extremely grateful (and more likely to help you find the answer!)
+## Publish Safety
+
+When running via `npm publish`, prepare-package will:
+
+1. **Block local dependencies** — fails if any `file:`, `../`, `./`, `/`, or `~` dependency versions are found
+2. **Remove sensitive files** — deletes `.env`, `.env.local`, `.env.development`, `.env.production`, `firebase-debug.log`, `.DS_Store`, `Thumbs.db` from the package
+3. **Purge CDN cache** — purges the jsDelivr cache for your package after publish
+
+## Questions
+If you are still having difficulty, post a question to [the Prepare Package issues page](https://github.com/itw-creative-works/prepare-package/issues).

package/dist/build.js

@@ -0,0 +1,205 @@
+const path = require('path');
+const fs = require('fs');
+const logger = require('./logger');
+const { default: chalk } = require('chalk');
+
+/**
+ * Build using esbuild based on preparePackage config
+ *
+ * @param {object} options
+ * @param {string} options.cwd - Working directory
+ * @param {object} options.packageJSON - Consumer's package.json
+ * @param {object} options.config - preparePackage config
+ * @returns {Promise<void>}
+ */
+async function build(options) {
+  const esbuild = require('esbuild');
+
+  const { cwd, packageJSON, config } = options;
+  const buildConfig = config.build || {};
+  const version = packageJSON.version;
+  const inputPath = path.resolve(cwd, config.input || './src');
+  const outputPath = path.resolve(cwd, config.output || './dist');
+
+  // Resolve entry point
+  const entry = path.resolve(cwd, buildConfig.entry || path.join(config.input || './src', 'index.js'));
+
+  // Default formats
+  const formats = buildConfig.formats || ['esm', 'cjs'];
+
+  // Version replacement plugin
+  const versionPlugin = {
+    name: 'version-replace',
+    setup(build) {
+      build.onLoad({ filter: /\.js$/ }, async (args) => {
+        let contents = fs.readFileSync(args.path, 'utf8');
+        contents = contents.replace(/\{version\}/g, version);
+        return { contents, loader: 'js' };
+      });
+    },
+  };
+
+  // Shared options
+  const shared = {
+    entryPoints: [entry],
+    bundle: true,
+    sourcemap: buildConfig.sourcemap || false,
+    plugins: [versionPlugin],
+    external: buildConfig.external || [],
+  };
+
+  const target = buildConfig.target || 'es2020';
+  const platform = buildConfig.platform || 'neutral';
+  const builds = [];
+
+  // ESM
+  if (formats.includes('esm')) {
+    builds.push({
+      ...shared,
+      outfile: path.join(outputPath, 'index.mjs'),
+      format: 'esm',
+      platform,
+      minify: false,
+      target,
+    });
+  }
+
+  // CJS
+  if (formats.includes('cjs')) {
+    builds.push({
+      ...shared,
+      outfile: path.join(outputPath, 'index.js'),
+      format: 'cjs',
+      platform,
+      minify: false,
+      target,
+    });
+  }
+
+  // IIFE (UMD/CDN)
+  if (formats.includes('iife')) {
+    const iife = buildConfig.iife || {};
+    const globalName = iife.globalName;
+
+    if (!globalName) {
+      throw new Error('preparePackage.build.iife.globalName is required when using "iife" format');
+    }
+
+    const fileName = iife.fileName || `${packageJSON.name}.min.js`;
+
+    builds.push({
+      ...shared,
+      outfile: path.join(outputPath, fileName),
+      format: 'iife',
+      globalName,
+      minify: true,
+      target: iife.target || 'es2015',
+      // Unwrap default export so window[globalName] is the class directly
+      footer: { js: `${globalName}=${globalName}.default||${globalName}.${globalName}||${globalName};` },
+    });
+  }
+
+  // Build all formats
+  await Promise.all(builds.map(config => esbuild.build(config)));
+
+  const formatNames = formats.map(f => f.toUpperCase()).join(', ');
+  logger.log(chalk.green(`Built ${packageJSON.name} v${version} (${formatNames})`));
+}
+
+/**
+ * Create esbuild watch contexts for watch mode
+ *
+ * @param {object} options - Same as build()
+ * @returns {Promise<object[]>} Array of esbuild contexts
+ */
+async function createWatchContexts(options) {
+  const esbuild = require('esbuild');
+
+  const { cwd, packageJSON, config } = options;
+  const buildConfig = config.build || {};
+  const version = packageJSON.version;
+  const inputPath = path.resolve(cwd, config.input || './src');
+  const outputPath = path.resolve(cwd, config.output || './dist');
+
+  const entry = path.resolve(cwd, buildConfig.entry || path.join(config.input || './src', 'index.js'));
+  const formats = buildConfig.formats || ['esm', 'cjs'];
+
+  const versionPlugin = {
+    name: 'version-replace',
+    setup(build) {
+      build.onLoad({ filter: /\.js$/ }, async (args) => {
+        let contents = fs.readFileSync(args.path, 'utf8');
+        contents = contents.replace(/\{version\}/g, version);
+        return { contents, loader: 'js' };
+      });
+    },
+  };
+
+  const shared = {
+    entryPoints: [entry],
+    bundle: true,
+    sourcemap: buildConfig.sourcemap || false,
+    plugins: [versionPlugin],
+    external: buildConfig.external || [],
+  };
+
+  const target = buildConfig.target || 'es2020';
+  const platform = buildConfig.platform || 'neutral';
+  const builds = [];
+
+  if (formats.includes('esm')) {
+    builds.push({
+      ...shared,
+      outfile: path.join(outputPath, 'index.mjs'),
+      format: 'esm',
+      platform,
+      minify: false,
+      target,
+    });
+  }
+
+  if (formats.includes('cjs')) {
+    builds.push({
+      ...shared,
+      outfile: path.join(outputPath, 'index.js'),
+      format: 'cjs',
+      platform,
+      minify: false,
+      target,
+    });
+  }
+
+  if (formats.includes('iife')) {
+    const iife = buildConfig.iife || {};
+    const globalName = iife.globalName;
+
+    if (!globalName) {
+      throw new Error('preparePackage.build.iife.globalName is required when using "iife" format');
+    }
+
+    const fileName = iife.fileName || `${packageJSON.name}.min.js`;
+
+    builds.push({
+      ...shared,
+      outfile: path.join(outputPath, fileName),
+      format: 'iife',
+      globalName,
+      minify: true,
+      target: iife.target || 'es2015',
+      footer: { js: `${globalName}=${globalName}.default||${globalName}.${globalName}||${globalName};` },
+    });
+  }
+
+  const contexts = await Promise.all(
+    builds.map(config => esbuild.context(config)),
+  );
+
+  await Promise.all(contexts.map(ctx => ctx.watch()));
+
+  const formatNames = formats.map(f => f.toUpperCase()).join(', ');
+  logger.log(chalk.green(`Watching ${packageJSON.name} v${version} (${formatNames})...`));
+
+  return contexts;
+}
+
+module.exports = { build, createWatchContexts };

package/dist/cli.js

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const { default: chalk } = require('chalk');
+const logger = require('./logger');
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+function ask(question, defaultValue) {
+  const suffix = defaultValue ? ` (${chalk.cyan(defaultValue)})` : '';
+  return new Promise((resolve) => {
+    rl.question(`${question}${suffix}: `, (answer) => {
+      resolve(answer.trim() || defaultValue || '');
+    });
+  });
+}
+
+function askChoice(question, choices, defaultIndex) {
+  console.log(`\n${question}`);
+  choices.forEach((choice, i) => {
+    const marker = i === defaultIndex ? chalk.green('❯') : ' ';
+    console.log(`  ${marker} ${i + 1}) ${choice}`);
+  });
+
+  return new Promise((resolve) => {
+    rl.question(`Choice (${defaultIndex + 1}): `, (answer) => {
+      const index = parseInt(answer, 10) - 1;
+      resolve(choices[Number.isNaN(index) || index < 0 || index >= choices.length ? defaultIndex : index]);
+    });
+  });
+}
+
+function toTitleCase(name) {
+  return name
+    .replace(/[-_@/]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .split(' ')
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+    .join('');
+}
+
+async function init() {
+  const cwd = process.cwd();
+  const pkgPath = path.resolve(cwd, 'package.json');
+
+  if (!fs.existsSync(pkgPath)) {
+    logger.error('No package.json found in current directory. Run `npm init` first.');
+    process.exit(1);
+  }
+
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+
+  console.log(chalk.bold(`\n  prepare-package init\n`));
+  console.log(`  Setting up ${chalk.cyan(pkg.name || 'your package')}...\n`);
+
+  // Ask type
+  const type = await askChoice('Build type:', ['copy', 'bundle'], 0);
+
+  // Ask input/output
+  const input = await ask('Source directory', 'src');
+  const output = await ask('Output directory', 'dist');
+
+  // Build preparePackage config
+  const config = {
+    input,
+    output,
+    type,
+  };
+
+  // Bundle-specific config
+  if (type === 'bundle') {
+    const defaultGlobal = toTitleCase(pkg.name || 'MyLib');
+    const defaultFileName = `${(pkg.name || 'my-lib').replace(/@.*\//, '')}.min.js`;
+
+    const formatsRaw = await ask('Formats (comma-separated)', 'esm, cjs, iife');
+    const formats = formatsRaw.split(',').map(f => f.trim()).filter(Boolean);
+
+    config.build = { formats };
+
+    if (formats.includes('iife')) {
+      const globalName = await ask('IIFE global name', defaultGlobal);
+      const fileName = await ask('IIFE filename', defaultFileName);
+
+      config.build.iife = { globalName, fileName };
+    }
+  }
+
+  // Update package.json
+  pkg.preparePackage = config;
+  pkg.main = pkg.main || `./${output}/index.js`;
+
+  if (type === 'bundle') {
+    pkg.module = pkg.module || `./${output}/index.mjs`;
+    pkg.exports = pkg.exports || {
+      '.': {
+        import: `./${output}/index.mjs`,
+        require: `./${output}/index.js`,
+      },
+    };
+  }
+
+  // Add scripts
+  pkg.scripts = pkg.scripts || {};
+  pkg.scripts.prepare = `node -e "require('prepare-package')()"`;
+  pkg.scripts['prepare:watch'] = `node -e "require('prepare-package/watch')()"`;
+
+  // Write
+  fs.writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`);
+
+  console.log(`\n${chalk.green('Done!')} Updated package.json:\n`);
+  console.log(chalk.gray(JSON.stringify({ preparePackage: config }, null, 2)));
+  console.log(`\nRun ${chalk.cyan('npm run prepare')} to build.\n`);
+
+  rl.close();
+}
+
+init().catch((err) => {
+  logger.error(err.message);
+  rl.close();
+  process.exit(1);
+});

package/dist/index.js

@@ -1,7 +1,7 @@
 const jetpack = require('fs-jetpack');
 const fetch = require('wonderful-fetch');
 const path = require('path');
-const chalk = require('chalk');
+const { default: chalk } = require('chalk');
 const logger = require('./logger');
 
 // const argv = require('yargs').argv;
@@ -110,96 +110,111 @@ module.exports = async function (options) {
   theirPackageJSON.preparePackage.input = theirPackageJSON.preparePackage.input || './src';
   theirPackageJSON.preparePackage.output = theirPackageJSON.preparePackage.output || './dist';
   theirPackageJSON.preparePackage.replace = theirPackageJSON.preparePackage.replace || {};
+  theirPackageJSON.preparePackage.type = theirPackageJSON.preparePackage.type || 'copy';
 
   // Add script
   theirPackageJSON.scripts = theirPackageJSON.scripts || {};
-  // theirPackageJSON.scripts.prepare = theirPackageJSON.scripts.prepare
-  //   || 'node -e \'require(`prepare-package`)()\'';
-  // theirPackageJSON.scripts['prepare:watch'] = theirPackageJSON.scripts['prepare:watch']
-  //   || `nodemon -w ./src -e '*' --exec 'npm run prepare'`
   theirPackageJSON.scripts.prepare = `node -e \"require('prepare-package')()\"`;
   theirPackageJSON.scripts['prepare:watch'] = `node -e \"require('prepare-package/watch')()\"`
 
-  // Log the options
-  // console.log(chalk.blue(`[prepare-package]: Options purge=${options.purge}`));
-  // console.log(chalk.blue(`[prepare-package]: input=${theirPackageJSON.preparePackage.input}`));
-  // console.log(chalk.blue(`[prepare-package]: output=${theirPackageJSON.preparePackage.output}`));
-  // console.log(chalk.blue(`[prepare-package]: main=${theirPackageJSON.main}`));
+  // Resolve type
+  const type = theirPackageJSON.preparePackage.type;
+  const isBundleMode = type === 'bundle';
+
+  // Skip bundle mode during postinstall — esbuild bundling only runs via prepare/build scripts
+  if (isBundleMode && options.isPostInstall) {
+    return;
+  }
+
   if (!options.singleFile) {
-    logger.log(`Starting...${isPublishing ? ' (via npm publish)' : ''}`);
+    logger.log(`Starting (${type} mode)...${isPublishing ? ' (via npm publish)' : ''}`);
     logger.log({
+      type: type,
       purge: options.purge,
       input: theirPackageJSON.preparePackage.input,
       output: theirPackageJSON.preparePackage.output,
       main: theirPackageJSON.main,
-
-      // lifecycle: process.env.npm_lifecycle_event,
-      // command: process.env.npm_command,
       isPublishing: isPublishing,
     });
   }
 
-  // Set the paths relative to the cwd
-  const mainPath = path.resolve(options.cwd, theirPackageJSON.main);
-  const outputPath = path.resolve(options.cwd, theirPackageJSON.preparePackage.output);
-  const inputPath = path.resolve(options.cwd, theirPackageJSON.preparePackage.input);
-
-  // Check if paths exist
-  const mainPathExists = jetpack.exists(mainPath);
-  const outputPathExists = jetpack.exists(outputPath);
-  const inputPathExists = jetpack.exists(inputPath);
-
-  // Handle single file mode (for watch)
-  if (options.singleFile) {
-    const relativePath = path.relative(inputPath, options.singleFile);
-    const destPath = path.join(outputPath, relativePath);
-
-    // Copy single file
-    if (jetpack.exists(options.singleFile)) {
-      jetpack.copy(options.singleFile, destPath, { overwrite: true });
-      logger.log(`Updated: ${relativePath}`);
-    }
-  } else {
-    // Normal mode - full copy
-    // Remove the output folder if it exists (input must exist too)
-    if (outputPathExists && inputPathExists) {
-      jetpack.remove(outputPath);
-    }
+  // --- BUNDLE MODE ---
+  if (isBundleMode) {
+    const { build } = require('./build');
 
-    // Copy the input folder to the output folder if it exists
-    if (inputPathExists) {
-      jetpack.copy(inputPath, outputPath);
+    await build({
+      cwd: options.cwd,
+      packageJSON: theirPackageJSON,
+      config: theirPackageJSON.preparePackage,
+    });
+
+    // Write updated package.json (scripts, defaults)
+    if (isLivePreparation && theirPackageJSONExists) {
+      jetpack.write(
+        theirPackageJSONPath,
+        `${JSON.stringify(theirPackageJSON, null, 2)}\n`
+      );
     }
   }
 
-  // Only do this part on the actual package that is using THIS package because we dont't want to replace THIS {version}
-  if (isLivePreparation) {
-    // In single file mode, only process if it's the main file
+  // --- COPY MODE ---
+  else {
+    // Set the paths relative to the cwd
+    const mainPath = path.resolve(options.cwd, theirPackageJSON.main);
+    const outputPath = path.resolve(options.cwd, theirPackageJSON.preparePackage.output);
+    const inputPath = path.resolve(options.cwd, theirPackageJSON.preparePackage.input);
+
+    // Check if paths exist
+    const mainPathExists = jetpack.exists(mainPath);
+    const outputPathExists = jetpack.exists(outputPath);
+    const inputPathExists = jetpack.exists(inputPath);
+
+    // Handle single file mode (for watch)
     if (options.singleFile) {
-      const destPath = path.join(outputPath, path.relative(inputPath, options.singleFile));
-      if (destPath === mainPath && jetpack.exists(destPath)) {
-        jetpack.write(
-          destPath,
-          jetpack.read(destPath).replace(/{version}/igm, theirPackageJSON.version)
-        );
+      const relativePath = path.relative(inputPath, options.singleFile);
+      const destPath = path.join(outputPath, relativePath);
+
+      // Copy single file
+      if (jetpack.exists(options.singleFile)) {
+        jetpack.copy(options.singleFile, destPath, { overwrite: true });
+        logger.log(`Updated: ${relativePath}`);
       }
     } else {
-      // Normal mode - process main file and package.json
-      // Replace the main file
-      if (mainPathExists) {
-        jetpack.write(
-          mainPath,
-          jetpack.read(mainPath)
-            .replace(/{version}/igm, theirPackageJSON.version),
-        );
+      // Normal mode - full copy
+      if (outputPathExists && inputPathExists) {
+        jetpack.remove(outputPath);
       }
 
-      // Replace the package.json
-      if (theirPackageJSONExists) {
-        jetpack.write(
-          theirPackageJSONPath,
-          `${JSON.stringify(theirPackageJSON, null, 2)}\n`
-        );
+      if (inputPathExists) {
+        jetpack.copy(inputPath, outputPath);
+      }
+    }
+
+    // Only do this part on the actual package that is using THIS package
+    if (isLivePreparation) {
+      if (options.singleFile) {
+        const destPath = path.join(outputPath, path.relative(inputPath, options.singleFile));
+        if (destPath === mainPath && jetpack.exists(destPath)) {
+          jetpack.write(
+            destPath,
+            jetpack.read(destPath).replace(/{version}/igm, theirPackageJSON.version)
+          );
+        }
+      } else {
+        if (mainPathExists) {
+          jetpack.write(
+            mainPath,
+            jetpack.read(mainPath)
+              .replace(/{version}/igm, theirPackageJSON.version),
+          );
+        }
+
+        if (theirPackageJSONExists) {
+          jetpack.write(
+            theirPackageJSONPath,
+            `${JSON.stringify(theirPackageJSON, null, 2)}\n`
+          );
+        }
       }
     }
   }

package/dist/logger.js

@@ -1,4 +1,4 @@
-const chalk = require('chalk');
+const { default: chalk } = require('chalk');
 
 // Setup logger
 const logger = {};

package/dist/watch.js

@@ -6,25 +6,47 @@ const logger = require('./logger');
 
 module.exports = async function watch() {
   const cwd = process.cwd();
-  
+
   // Get package.json info
   const packageJSONPath = path.resolve(cwd, 'package.json');
   const packageJSONExists = jetpack.exists(packageJSONPath);
   const packageJSON = packageJSONExists ? require(packageJSONPath) : {};
-  
+
   // Set up paths
   packageJSON.preparePackage = packageJSON.preparePackage || {};
+  const type = packageJSON.preparePackage.type || 'copy';
   const inputPath = path.resolve(cwd, packageJSON.preparePackage.input || './src');
   const outputPath = path.resolve(cwd, packageJSON.preparePackage.output || './dist');
-  
+
+  // --- BUNDLE MODE: use esbuild's built-in watch ---
+  if (type === 'bundle') {
+    const { createWatchContexts } = require('./build');
+
+    const contexts = await createWatchContexts({
+      cwd,
+      packageJSON,
+      config: packageJSON.preparePackage,
+    });
+
+    // Handle process termination
+    process.on('SIGINT', async () => {
+      logger.log('Stopping watchers...');
+      await Promise.all(contexts.map(ctx => ctx.dispose()));
+      process.exit(0);
+    });
+
+    return;
+  }
+
+  // --- COPY MODE: use chokidar ---
   // Run initial prepare (full copy)
   logger.log('Running initial prepare...');
   await prepare({ purge: false });
   logger.log('Initial prepare complete!');
-  
+
   // Set up watcher
   logger.log('Watching for changes...');
-  
+
   const watcher = chokidar.watch(inputPath, {
     persistent: true,
     ignoreInitial: true,
@@ -33,12 +55,12 @@ module.exports = async function watch() {
       pollInterval: 100
     }
   });
-  
+
   // Helper function to process a single file
   const processSingleFile = async (filePath, eventType) => {
     const relativePath = path.relative(inputPath, filePath);
     const destPath = path.join(outputPath, relativePath);
-    
+
     try {
       if (eventType === 'unlink' || eventType === 'unlinkDir') {
         // Remove the file/directory from output
@@ -52,16 +74,16 @@ module.exports = async function watch() {
         logger.log(`Created dir: ${relativePath}`);
       } else if (eventType === 'add' || eventType === 'change') {
         // Use the main prepare function with singleFile option
-        await prepare({ 
+        await prepare({
           purge: false,
-          singleFile: filePath 
+          singleFile: filePath
         });
       }
     } catch (error) {
       logger.error(`Error processing ${relativePath}: ${error.message}`);
     }
   };
-  
+
   // Set up event handlers
   watcher
     .on('add', path => processSingleFile(path, 'add'))
@@ -71,11 +93,11 @@ module.exports = async function watch() {
     .on('unlinkDir', path => processSingleFile(path, 'unlinkDir'))
     .on('error', error => logger.error(`Watcher error: ${error}`))
     .on('ready', () => logger.log('Ready for changes!'));
-  
+
   // Handle process termination
   process.on('SIGINT', () => {
     logger.log('Stopping watcher...');
     watcher.close();
     process.exit(0);
   });
-}
+}

package/package.json

@@ -1,15 +1,19 @@
 {
   "name": "prepare-package",
-  "version": "1.2.6",
+  "version": "2.0.1",
   "description": "Prepare a Node.js package before being published",
   "main": "dist/index.js",
+  "bin": {
+    "prepare-package": "./dist/cli.js",
+    "pp": "./dist/cli.js"
+  },
   "exports": {
     ".": "./dist/index.js",
     "./watch": "./dist/watch.js"
   },
   "scripts": {
     "test": "./node_modules/mocha/bin/mocha test/ --recursive --timeout=10000",
-    "start": "node -e \"require('./src/index.js')()\"",
+    "start": "npm run prepare:watch",
     "prepare": "node -e \"require('./src/index.js')()\"",
     "prepare:watch": "node -e \"require('./src/watch.js')()\"",
     "postinstall": "node -e \"require('./dist/index.js')({cwd: process.env.INIT_CWD, isPostInstall: true})\""
@@ -39,12 +43,13 @@
     "replace": {}
   },
   "dependencies": {
-    "chalk": "^4.1.2",
-    "chokidar": "^4.0.3",
+    "chalk": "^5.6.2",
+    "chokidar": "^5.0.0",
+    "esbuild": "^0.27.4",
     "fs-jetpack": "^5.1.0",
     "wonderful-fetch": "^1.3.4"
   },
   "devDependencies": {
-    "mocha": "^8.4.0"
+    "mocha": "^11.7.5"
   }
 }