prepare-package 1.1.13 → 1.2.0

package/dist/index.js

@@ -2,6 +2,7 @@ const jetpack = require('fs-jetpack');
 const fetch = require('wonderful-fetch');
 const path = require('path');
 const chalk = require('chalk');
+const logger = require('./logger');
 
 // const argv = require('yargs').argv;
 
@@ -39,13 +40,20 @@ module.exports = async function (options) {
   // 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'] = `nodemon -w ./src -e '*' --exec 'npm run prepare'`
+  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}`));
+  // 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}`));
+  logger.log(`Starting...`);
+  logger.log({
+    purge: options.purge,
+    input: theirPackageJSON.preparePackage.input,
+    output: theirPackageJSON.preparePackage.output,
+    main: theirPackageJSON.main,
+  });
 
   // Set the paths relative to the cwd
   const mainPath = path.resolve(options.cwd, theirPackageJSON.main);
@@ -103,11 +111,13 @@ module.exports = async function (options) {
     response: 'json',
     tries: 3,
   })
-  .then(result => {
-    console.log(chalk.green(`[prepare-package]: Purged ${theirPackageJSON.name}`));
+  .then((r) => {
+    // console.log(chalk.green(`[prepare-package]: Purged ${theirPackageJSON.name}`));
+    logger.log(chalk.green(`Purged ${theirPackageJSON.name}!`));
   })
-  .catch(e => {
-    console.log(chalk.red(`[prepare-package]: Failed to purge ${theirPackageJSON.name}`, e));
+  .catch((e) => {
+    // console.log(chalk.red(`[prepare-package]: Failed to purge ${theirPackageJSON.name}`, e));
+    logger.error(`Failed to purge ${theirPackageJSON.name}!`, e.stack);
   })
 }
 

package/dist/logger.js

@@ -0,0 +1,46 @@
+const chalk = require('chalk');
+
+// Setup logger
+const logger = {};
+
+// Loop through log, error, warn, and info and make methods that log to console with the name and time [xx:xx:xx] name: message
+['log', 'error', 'warn', 'info'].forEach((method) => {
+  logger[method] = function () {
+    // Get time
+    const time = new Date().toLocaleTimeString('en-US', {
+      hour12: false,
+      hour: '2-digit',
+      minute: '2-digit',
+      second: '2-digit'
+    });
+
+    // Determine color based on method
+    let color;
+    switch (method) {
+      case 'warn':
+        color = chalk.yellow;
+        break;
+      case 'error':
+        color = chalk.red;
+        break;
+      default:
+        color = (text) => text; // No color
+    }
+
+    // Convert arguments to array and prepend time and name
+    const args = [`[${chalk.magenta(time)}] '${chalk.cyan('prepare-package')}':`, ...Array.from(arguments).map(arg => {
+      return typeof arg === 'string'
+        ? color(arg)
+        : (
+            arg instanceof Error
+              ? color(arg.stack)
+              : arg
+          );
+    })];
+
+    // Log
+    console[method].apply(console, args);
+  };
+});
+
+module.exports = logger;

package/dist/watch.js

@@ -0,0 +1,90 @@
+const chokidar = require('chokidar');
+const jetpack = require('fs-jetpack');
+const path = require('path');
+const prepare = require('./index');
+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 inputPath = path.resolve(cwd, packageJSON.preparePackage.input || './src');
+  const outputPath = path.resolve(cwd, packageJSON.preparePackage.output || './dist');
+  const mainPath = path.resolve(cwd, packageJSON.main || './dist/index.js');
+  const isLivePreparation = packageJSON.name !== 'prepare-package';
+  
+  // 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,
+    awaitWriteFinish: {
+      stabilityThreshold: 100,
+      pollInterval: 100
+    }
+  });
+  
+  // Helper function to process a single file
+  const processSingleFile = (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
+        if (jetpack.exists(destPath)) {
+          jetpack.remove(destPath);
+          logger.log(`Removed: ${relativePath}`);
+        }
+      } else if (eventType === 'addDir') {
+        // Create directory in output
+        jetpack.dir(destPath);
+        logger.log(`Created dir: ${relativePath}`);
+      } else if (eventType === 'add' || eventType === 'change') {
+        // Copy the file to output
+        jetpack.copy(filePath, destPath, { overwrite: true });
+        
+        // Apply version replacement if it's the main file
+        if (isLivePreparation && destPath === mainPath) {
+          jetpack.write(
+            destPath,
+            jetpack.read(destPath).replace(/{version}/igm, packageJSON.version)
+          );
+        }
+        
+        logger.log(`Updated: ${relativePath}`);
+      }
+    } catch (error) {
+      logger.error(`Error processing ${relativePath}: ${error.message}`);
+    }
+  };
+  
+  // Set up event handlers
+  watcher
+    .on('add', path => processSingleFile(path, 'add'))
+    .on('change', path => processSingleFile(path, 'change'))
+    .on('addDir', path => processSingleFile(path, 'addDir'))
+    .on('unlink', path => processSingleFile(path, 'unlink'))
+    .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,13 +1,17 @@
 {
   "name": "prepare-package",
-  "version": "1.1.13",
+  "version": "1.2.0",
   "description": "Prepare a Node.js package before being published",
   "main": "dist/index.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')()\"",
     "prepare": "node -e \"require('./src/index.js')()\"",
-    "prepare:watch": "nodemon -w ./src -e '*' --exec 'npm run prepare'",
+    "prepare:watch": "node -e \"require('./src/watch.js')()\"",
     "postinstall": "node -e \"require('./dist/index.js')({cwd: process.env.INIT_CWD, isPostInstall: true})\""
   },
   "engines": {
@@ -36,8 +40,9 @@
   },
   "dependencies": {
     "chalk": "^4.1.2",
+    "chokidar": "^3.5.3",
     "fs-jetpack": "^4.3.1",
-    "wonderful-fetch": "^1.1.11"
+    "wonderful-fetch": "^1.3.2"
   },
   "devDependencies": {
     "mocha": "^8.4.0"