prepare-package 2.0.0 → 2.0.3

package/README.md

@@ -29,6 +29,19 @@
 npm install prepare-package --save-dev
 ```
 
+## 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

package/dist/build.js

@@ -1,7 +1,7 @@
 const path = require('path');
 const fs = require('fs');
 const logger = require('./logger');
-const chalk = require('chalk');
+const { default: chalk } = require('chalk');
 
 /**
  * Build using esbuild based on preparePackage config
@@ -34,7 +34,7 @@ async function build(options) {
       build.onLoad({ filter: /\.js$/ }, async (args) => {
         let contents = fs.readFileSync(args.path, 'utf8');
         contents = contents.replace(/\{version\}/g, version);
-        return { contents, loader: 'js' };
+        return { contents, loader: 'js', watchFiles: [args.path] };
       });
     },
   };
@@ -124,13 +124,39 @@ async function createWatchContexts(options) {
   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',
+  // In watch mode, replace {version} in output files AFTER build (onEnd)
+  // instead of intercepting file loading (onLoad), so esbuild's native
+  // file watcher can detect source changes.
+  let isFirstBuild = true;
+  let rebuildTimer = null;
+
+  const watchVersionPlugin = {
+    name: 'version-replace-watch',
     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' };
+      build.onEnd((result) => {
+        // Replace {version} in the output file
+        const outfile = build.initialOptions.outfile;
+        if (outfile && fs.existsSync(outfile)) {
+          const contents = fs.readFileSync(outfile, 'utf8');
+          if (contents.includes('{version}')) {
+            fs.writeFileSync(outfile, contents.replace(/\{version\}/g, version));
+          }
+        }
+
+        // Skip first build (the "Watching..." message covers it)
+        if (isFirstBuild) {
+          return;
+        }
+
+        // Debounce rebuild log across all format contexts
+        if (result.errors.length > 0) {
+          logger.error(chalk.red(`Build failed with ${result.errors.length} error(s)`));
+        } else if (!rebuildTimer) {
+          rebuildTimer = setTimeout(() => {
+            rebuildTimer = null;
+            logger.log(chalk.green(`Rebuilt ${packageJSON.name} v${version}`));
+          }, 50);
+        }
       });
     },
   };
@@ -139,7 +165,7 @@ async function createWatchContexts(options) {
     entryPoints: [entry],
     bundle: true,
     sourcemap: buildConfig.sourcemap || false,
-    plugins: [versionPlugin],
+    plugins: [watchVersionPlugin],
     external: buildConfig.external || [],
   };
 
@@ -195,6 +221,8 @@ async function createWatchContexts(options) {
   );
 
   await Promise.all(contexts.map(ctx => ctx.watch()));
+  // Delay flipping the flag so initial onEnd callbacks complete first
+  await new Promise(resolve => setTimeout(() => { isFirstBuild = false; resolve(); }, 100));
 
   const formatNames = formats.map(f => f.toUpperCase()).join(', ');
   logger.log(chalk.green(`Watching ${packageJSON.name} v${version} (${formatNames})...`));

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;

package/dist/logger.js

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

package/package.json

@@ -1,15 +1,22 @@
 {
   "name": "prepare-package",
-  "version": "2.0.0",
+  "version": "2.0.3",
   "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"
   },
+  "files": [
+    "dist"
+  ],
   "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,13 +46,13 @@
     "replace": {}
   },
   "dependencies": {
-    "chalk": "^4.1.2",
-    "chokidar": "^4.0.3",
-    "esbuild": "^0.27.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"
   }
 }

package/CHANGELOG.md

@@ -1,20 +0,0 @@
-# CHANGELOG
-
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
-
-## Changelog Categories
-
-- `BREAKING` for breaking changes.
-- `Added` for new features.
-- `Changed` for changes in existing functionality.
-- `Deprecated` for soon-to-be removed features.
-- `Removed` for now removed features.
-- `Fixed` for any bug fixes.
-- `Security` in case of vulnerabilities.
-
----
-## [1.0.0] - 2024-06-19
-### Added
-- Initial release of the project 🚀

package/CLAUDE.md

@@ -1,67 +0,0 @@
-# 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
-  logger.js   # Timestamped console logger with chalk colors
-dist/         # Copy-mode output of src/ (prepare-package builds itself with copy mode)
-```
-
-### 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)
-
-### 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"`