iifeify 0.1.0 → 1.1.0

package/README.md

@@ -3,7 +3,7 @@
 Turn an npm package into one classic browser script.
 
 ```bash
-npx iifeify vanilla-jsoneditor@3.13.0 --entry standalone.js --global-name VanillaJsonEditor
+npx -y iifeify vanilla-jsoneditor@3.13.0 --entry standalone.js --global-name VanillaJsonEditor
 ```
 
 This writes `vanilla-jsoneditor.iife.js`. Loaded with a plain `<script>` tag, the file defines the global `VanillaJsonEditor`, which holds everything the package exports. The file starts with a license banner generated from the package's own metadata:
@@ -32,7 +32,7 @@ iifeify is for hosts that accept only classic scripts and cannot `import` anythi
 Run it directly with `npx`, no installation required:
 
 ```bash
-npx iifeify <package>
+npx -y iifeify <package>
 ```
 
 Or install it globally:
@@ -62,7 +62,18 @@ npx iifeify <package>[@version] [options]
 | `-h`, `--help` | Show the help | |
 | `-v`, `--version` | Show the version | |
 
-The exit code is 0 on success, 1 if the package cannot be converted and 2 for a wrong command line.
+While it runs, iifeify prints each step and how long it took on stderr, and the result on stdout:
+
+```text
+Installing vanilla-jsoneditor@3.13.0 with npm... done in 3.4s
+Bundling vanilla-jsoneditor 3.13.0 with esbuild... done in 555ms
+Wrote vanilla-jsoneditor.iife.js (1.21 MB)
+  package  vanilla-jsoneditor 3.13.0 - ISC
+  entry    standalone.js
+  global   VanillaJsonEditor
+```
+
+A step that fails ends with `failed`, followed by the reason. The exit code is 0 on success, 1 if the package cannot be converted and 2 for a wrong command line.
 
 ### How it works
 

package/bin/cli.js

@@ -24,7 +24,7 @@ cli.command('<package>', 'Turn an npm package into one classic browser script th
     .example('  $ iifeify ms')
     .example('  $ iifeify vanilla-jsoneditor@3.13.0 --entry standalone.js --global-name VanillaJsonEditor')
     .action(async (spec, options) => {
-        report(await convert({
+        const result = await convert({
             spec: String(spec),
             entry: text(options.entry),
             globalName: text(options.globalName),
@@ -32,11 +32,43 @@ cli.command('<package>', 'Turn an npm package into one classic browser script th
             minify: options.minify,
             target: text(options.target)?.split(','),
             notices: options.notices,
-        }));
+            onStep: step => startStep(step.name === 'install'
+                ? `Installing ${step.spec} with npm`
+                : `Bundling ${step.label} with esbuild`),
+        });
+        endStep('done');
+        report(result);
     });
 cli.help();
 cli.version(version);
 
+// While a conversion runs, each step gets a line on stderr, like the warnings: what is being done,
+// then how long it took, or that it failed. stdout gets the result only.
+/** @type {number | undefined} */
+let stepStartedAt;
+
+/** @param {string} description */
+function startStep(description) {
+    endStep('done');
+    process.stderr.write(`${description}... `);
+    stepStartedAt = performance.now();
+}
+
+/** @param {'done' | 'failed'} outcome */
+function endStep(outcome) {
+    if (stepStartedAt === undefined) {
+        return;
+    }
+    const ms = performance.now() - stepStartedAt;
+    stepStartedAt = undefined;
+    if (outcome === 'failed') {
+        process.stderr.write('failed\n\n'); // the error follows after a blank line
+        return;
+    }
+    const took = ms < 1000 ? `${Math.round(ms)}ms` : `${(ms / 1000).toFixed(1)}s`;
+    process.stderr.write(`done in ${took}\n`);
+}
+
 /** @param {Awaited<ReturnType<typeof convert>>} result */
 function report({ files, bytes, packages, entry, globalName, warnings, hint }) {
     const [root, ...dependencies] = packages;
@@ -79,6 +111,7 @@ try {
     cli.parse(process.argv, { run: false });
     await cli.runMatchedCommand();
 } catch (error) {
+    endStep('failed');
     // cac does not export the class of the errors it throws for a wrong command line.
     if (error instanceof UsageError || error.name === 'CACError') {
         console.error(`${error.message}\nRun "iifeify --help" for the options.`);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "iifeify",
-    "version": "0.1.0",
+    "version": "1.1.0",
     "description": "Turn any browser-compatible npm package into a single classic script (an IIFE that defines one global), with a generated license banner.",
     "license": "MIT",
     "author": "Florian Noever",

package/src/convert.js

@@ -7,6 +7,12 @@ import { bundle, checkOptions } from './bundle.js';
 import { installPackage, parseSpec } from './install.js';
 import { bundledPackages } from './packages.js';
 
+/**
+ * @typedef {{ name: 'install', spec: string } | { name: 'bundle', label: string }} Step
+ *     a step of a conversion: npm installs the package as the user named it, or esbuild bundles
+ *     the installed package, labelled with its name and version such as "ms 2.1.3"
+ */
+
 /**
  * Installs an npm package into a temporary folder and writes it as one classic browser script.
  *
@@ -18,10 +24,11 @@ import { bundledPackages } from './packages.js';
  * @param {boolean} [options.minify]
  * @param {string[]} [options.target]      esbuild targets such as ["es2020"]
  * @param {boolean} [options.notices]      also write the full license texts next to the script
+ * @param {(step: Step) => void} [options.onStep]  called as each step starts, to report progress
  * @returns {Promise<{ files: { js: string, css?: string, notices?: string }, bytes: number,
  *     packages: object[], entry: string, globalName: string, warnings: string[], hint?: string }>}
  */
-export async function convert({ spec, entry, globalName: requestedGlobalName, outfile, minify = true, target, notices = false }) {
+export async function convert({ spec, entry, globalName: requestedGlobalName, outfile, minify = true, target, notices = false, onStep }) {
     const wanted = parseSpec(spec);
     await checkOptions({ globalName: requestedGlobalName, target });
 
@@ -29,10 +36,12 @@ export async function convert({ spec, entry, globalName: requestedGlobalName, ou
     // reports files by their real paths.
     const workDir = realpathSync.native(mkdtempSync(join(tmpdir(), 'iifeify-')));
     try {
-        const { dir, manifest } = installPackage(wanted, workDir);
+        onStep?.({ name: 'install', spec });
+        const { dir, manifest } = await installPackage(wanted, workDir);
         const globalName = requestedGlobalName ?? defaultGlobalName(manifest.name);
 
         const label = `${manifest.name} ${manifest.version}`;
+        onStep?.({ name: 'bundle', label });
         const built = await bundle({ workDir, name: wanted.name, dir, label, entry, globalName, minify, target });
         const packages = bundledPackages(built.inputs, dir);
         const banner = renderBanner(packages);

package/src/install.js

@@ -1,9 +1,13 @@
-import { execSync } from 'node:child_process';
+import { exec } from 'node:child_process';
 import { readFileSync, realpathSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { promisify } from 'node:util';
 
 import { ConversionError, UsageError } from './errors.js';
 
+// Asynchronous, so that the caller can report progress while npm works.
+const run = promisify(exec);
+
 // npm's rule for package names, including old names with capital letters.
 const PACKAGE_NAME = /^(@[a-z0-9~-][a-z0-9._~-]*\/)?[a-z0-9~-][a-z0-9._~-]*$/i;
 
@@ -29,9 +33,9 @@ export function parseSpec(spec) {
 /**
  * Installs the package and its dependencies into workDir/node_modules.
  *
- * @returns {{ dir: string, manifest: object }} the package's folder and its package.json
+ * @returns {Promise<{ dir: string, manifest: object }>} the package's folder and its package.json
  */
-export function installPackage({ name, range }, workDir) {
+export async function installPackage({ name, range }, workDir) {
     // A package.json of our own makes workDir the project root. Without one, npm installs into the
     // nearest parent folder that has a package.json, and the temp folder lies inside the user
     // profile. It also keeps the range off the command line: on Windows npm starts through cmd.exe,
@@ -39,7 +43,7 @@ export function installPackage({ name, range }, workDir) {
     writeFileSync(join(workDir, 'package.json'), JSON.stringify({ private: true, dependencies: { [name]: range } }));
 
     try {
-        execSync(INSTALL, { cwd: workDir, stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf8', windowsHide: true });
+        await run(INSTALL, { cwd: workDir, encoding: 'utf8', windowsHide: true, maxBuffer: 64 * 1024 * 1024 });
     } catch (error) {
         const output = String(error.stderr ?? '').trim() || error.message;
         throw new ConversionError(`Could not install ${name}@${range}.\n\n${output}`);