parcel 2.16.4 → 3.0.0-alpha.1

package/README.md

@@ -5,33 +5,34 @@
 </p>
 
 [![Backers on Open Collective](https://opencollective.com/parcel/backers/badge.svg)](#backers) [![Sponsors on Open Collective](https://opencollective.com/parcel/sponsors/badge.svg)](#sponsors)
-[![Build Status](https://dev.azure.com/devongovett/devongovett/_apis/build/status/parcel-bundler.parcel?branchName=v2)](https://dev.azure.com/devongovett/devongovett/_build/latest?definitionId=1)
 [![npm package](https://img.shields.io/npm/v/parcel.svg)](https://www.npmjs.com/package/parcel)
 [![npm package](https://img.shields.io/npm/dm/parcel.svg)](https://www.npmjs.com/package/parcel)
 [![Discord](https://img.shields.io/discord/894288336095690753)](https://discord.gg/XSCzqGRuvr)
 [![Twitter Follow](https://img.shields.io/twitter/follow/parceljs.svg?style=social)](https://twitter.com/parceljs)
 
-Parcel is a zero configuration build tool for the web. It combines a great out-of-the-box development experience with a scalable architecture that can take your project from just getting started to massive production application.
+**NOTE: This is Parcel v3 (currently in alpha).**
+
+Parcel is a batteries-included build tool for the web. It combines a great out-of-the-box development experience with a scalable architecture that can take your project from just getting started to massive production application.
 
 ## Features
 
-- 😍 **Zero config** – Parcel supports many languages and file types out of the box, from web technologies like HTML, CSS, and JavaScript, to assets like images, fonts, videos, and more. It has a built-in dev server with hot reloading, beautiful error diagnostics, and much more. No configuration needed!
-- ⚡️ **Lightning fast** – Parcel's JavaScript compiler is written in Rust for native performance. Your code is built in parallel using worker threads, utilizing all of the cores on your machine. Everything is cached, so you never build the same code twice. It's like using watch mode, but even when you restart Parcel!
+- 😍 **Batteries included** – Parcel supports many languages and file types out of the box, from web technologies like HTML, CSS, and JavaScript, to assets like images, fonts, videos, and more. It has a built-in dev server with hot reloading, beautiful error diagnostics, and much more. No configuration needed!
+- ⚡️ **Lightning fast** – Parcel is written in Rust for native performance, taking advantage of all of the cores on your machine. Extend it with native plugins written in Rust, Go, Swift, or any language that supports the C ABI.
 - 🚀 **Automatic production optimization** – Parcel optimizes your whole app for production automatically. This includes tree-shaking and minifying your JavaScript, CSS, and HTML, resizing and optimizing images, content hashing, automatic code splitting, and much more.
 - 🎯 **Ship for any target** – Parcel automatically transforms your code for your target environments. From modern and legacy browser support, to zero config JSX and TypeScript compilation, Parcel makes it easy to build for any target – or many!
-- 🌍 **Scalable** – Parcel requires zero configuration to get started. But as your application grows and your build requirements become more complex, it's possible to extend Parcel in just about every way. A simple configuration format and powerful plugin system that's designed from the ground up for performance means Parcel can support projects of any size.
+- 🌍 **Scalable** – Parcel requires zero configuration to get started. But as your application grows and your build requirements become more complex, it's possible to extend Parcel in just about every way. A simple configuration format and powerful native and JavaScript plugin system means Parcel can support projects of any size or complexity.
 
 ## Getting Started
 
 See the following guides in our documentation on how to get started with Parcel.
 
-* [Building a webapp with Parcel](https://parceljs.org/getting-started/webapp/)
-* [Building a library with Parcel](https://parceljs.org/getting-started/library/)
-* [Migrating from Parcel v1](https://parceljs.org/getting-started/migration/)
+* [Building a webapp with Parcel](https://v3.parceljs.org/getting-started/webapp/)
+* [Building a library with Parcel](https://v3.parceljs.org/getting-started/library/)
+* [Migrating from Parcel v2](https://v3.parceljs.org/getting-started/migration/)
 
 ## Documentation
 
-Read the docs at https://parceljs.org/docs/.
+Read the docs at https://v3.parceljs.org/docs/.
 
 ## Community
 

package/bin/parcel

@@ -0,0 +1,232 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Shipped as `bin/parcel` in the `parcel` package, and as `bin/parcel3` in
+ * `@parcel/parcel3`, which exists so Parcel 3 can be installed beside Parcel 2.
+ * Parcel itself is a native executable, published one
+ * platform package per target and pulled in through optionalDependencies, so all
+ * this file does is hand off to whichever one npm installed for this host.
+ *
+ * It also tries to take itself out of the loop. Starting Node costs ~30ms on
+ * every single invocation, which is a large tax on a tool whose whole
+ * point is being fast, so on the first run it rewrites the `node_modules/.bin`
+ * entry that launched it into a launcher that execs the binary without Node.
+ * See `launcher` for why that launcher looks the way it does.
+ *
+ * Install scripts would be the natural place for this, but npm and pnpm both
+ * block them by default now, so first run is the earliest moment available.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * The command, which is also the `node_modules/.bin` entry `optimize` rewrites.
+ * Taken from this file's own name, so both packages can ship it unchanged.
+ */
+const NAME = path.basename(__filename);
+
+/** Prefix of the platform packages, which both packages depend on. */
+const PLATFORM_PACKAGE = '@parcel/parcel3';
+
+const EXECUTABLE = process.platform === 'win32' ? 'parcel.exe' : 'parcel';
+
+/**
+ * The platform packages that could serve this host, best first.
+ *
+ * The names are derived rather than listed, matching what `matrix.mjs` builds
+ * from the target table: `process.platform` and `process.arch` are already the
+ * values npm's `os` and `cpu` fields use, so a new target needs no change here.
+ *
+ * On Linux the name also depends on the C library, and rather than detect it and
+ * trust the answer we try both: npm, pnpm and Bun all honour the `libc` field,
+ * so only the right one is installed and the wrong one simply fails to resolve.
+ * The musl check just decides which to try first, for the package managers that
+ * ignore `libc` and install both.
+ */
+function candidates() {
+  const base = `${PLATFORM_PACKAGE}-${process.platform}-${process.arch}`;
+  if (process.platform !== 'linux') return [base];
+  return isMusl() ? [`${base}-musl`, base] : [base, `${base}-musl`];
+}
+
+/**
+ * Whether this is a musl system. Biome and friends shell out to `ldd --version`
+ * for this; a directory listing costs a fraction of a process.
+ */
+function isMusl() {
+  try {
+    return fs.readdirSync('/lib').some(entry => entry.startsWith('ld-musl-'));
+  } catch {
+    return false;
+  }
+}
+
+function resolveBinary() {
+  for (const pkg of candidates()) {
+    try {
+      return require.resolve(`${pkg}/${EXECUTABLE}`);
+    } catch {}
+  }
+  return null;
+}
+
+const binPath = resolveBinary();
+if (binPath == null) {
+  // Both cases land here, and the message covers both: the package is missing
+  // either because this platform has no prebuilt binary, or because it was
+  // skipped at install time.
+  process.stderr.write(
+    `Parcel could not find the "${
+      candidates()[0]
+    }" package, which would hold the Parcel ` +
+      `binary for ${process.platform} ${process.arch}.\n\n` +
+      `Either Parcel publishes no binary for this platform, or the one it does publish was not ` +
+      `installed: it comes in through optionalDependencies, so --no-optional and --omit=optional ` +
+      `both skip it, as does copying node_modules here from a machine of a different platform. ` +
+      `Reinstalling on this machine fixes the second case.\n`,
+  );
+  process.exit(1);
+}
+
+optimize();
+run();
+
+/**
+ * Rewrite the `.bin` entry that launched us so it runs the binary directly.
+ *
+ * Only an entry that can be proven to refer to this file is ever touched, the
+ * write goes through a temp file and an atomic rename, and every failure leaves
+ * the entry alone - a slow Parcel is fine, a broken one is not.
+ */
+function optimize() {
+  // Windows generates .cmd and .ps1 shims with `node` baked in at install time,
+  // so replacing what they point at would only break them.
+  if (process.platform === 'win32' || process.env.PARCEL_NO_OPTIMIZE) return;
+
+  for (const entry of binEntries()) {
+    try {
+      const stat = fs.lstatSync(entry);
+      if (stat.isSymbolicLink()) {
+        // npm and Yarn: the .bin entry is a symlink to this file.
+        if (fs.realpathSync(entry) !== __filename) continue;
+      } else if (stat.isFile()) {
+        // pnpm: the .bin entry is a generated sh wrapper that runs `node <this>`.
+        if (!wrapsThisFile(fs.readFileSync(entry, 'utf8'))) continue;
+      } else {
+        continue;
+      }
+
+      replace(entry);
+    } catch {}
+  }
+}
+
+/**
+ * Whether a generated wrapper points at this file. Package managers write the
+ * path relative to their own layout, so the tail below the last `node_modules`
+ * is the longest part that is guaranteed to appear verbatim.
+ */
+function wrapsThisFile(contents) {
+  const tail = __filename.split(/node_modules[\\/]/).pop();
+  return contents.includes(tail) && contents.includes('node');
+}
+
+/** Every `.bin` entry that could have launched this file. */
+function* binEntries() {
+  // What the kernel was handed, before symlinks were resolved: npm and Yarn
+  // launch us through the .bin symlink itself.
+  const argv1 = process.argv[1];
+  if (argv1 && path.basename(path.dirname(argv1)) === '.bin') {
+    yield argv1;
+  }
+
+  // Otherwise walk up. `node_modules/.bin` covers a hoisted layout; pnpm keeps
+  // the package under `node_modules/.pnpm/...` and the bin beside the store
+  // rather than next to the package, so that one is checked separately.
+  let dir = path.dirname(__filename);
+  for (
+    let parent = path.dirname(dir);
+    parent !== dir;
+    parent = path.dirname(dir)
+  ) {
+    const base = path.basename(dir);
+    if (base === 'node_modules') yield path.join(dir, '.bin', NAME);
+    if (base === '.pnpm') yield path.join(parent, '.bin', NAME);
+    dir = parent;
+  }
+}
+
+/**
+ * The launcher gets read two different ways and has to work as both.
+ *
+ * Normally the kernel reads `#!/bin/sh` and sh execs the binary, which is the
+ * whole point: no Node anywhere. But an invocation that started just before the
+ * rename has already told Node to load this path as its entry module, and Node
+ * opens it ~30ms later - after the swap. Writing anything Node cannot parse, a
+ * symlink to the binary included, makes those invocations die trying to read a
+ * Mach-O or ELF file as JavaScript.
+ *
+ * So the rest of the file is also valid JavaScript. `":"` is the sh no-op and a
+ * bare string in JS; everything after `//` is an sh argument and a JS comment.
+ * A straggler falls through to the last line and runs the binary anyway, paying
+ * for Node one final time.
+ */
+function launcher(entry) {
+  // Relative to the launcher, so the tree stays movable: renaming the project or
+  // copying node_modules into an image keeps it working.
+  const rel = path.relative(path.dirname(entry), binPath);
+  if (/["$`\\\n]/.test(rel)) return null; // not safely quotable for sh
+
+  return (
+    '#!/bin/sh\n' +
+    `":" //# ; exec "\${0%/*}/${rel}" "$@"\n` +
+    `require("child_process").spawnSync(require("path").join(__dirname, ${JSON.stringify(
+      rel,
+    )}), ` +
+    `process.argv.slice(2), {stdio: "inherit"});\n`
+  );
+}
+
+/**
+ * Write beside the entry, then rename over it. A concurrent invocation sees
+ * either the old entry or the new one, never a half-written file.
+ */
+function replace(entry) {
+  const contents = launcher(entry);
+  if (contents == null) return;
+
+  const tmp = `${entry}.${process.pid}.tmp`;
+  try {
+    fs.writeFileSync(tmp, contents, {mode: 0o755});
+    fs.renameSync(tmp, entry);
+  } catch (err) {
+    try {
+      fs.unlinkSync(tmp);
+    } catch {}
+    throw err;
+  }
+}
+
+function run() {
+  const args = process.argv.slice(2);
+
+  // Replacing this process rather than forking one keeps signals, the exit code
+  // and terminal handling native. Node gained execve in 23.11 and never has it
+  // on Windows, hence the fallback.
+  if (typeof process.execve === 'function') {
+    process.execve(binPath, [binPath, ...args], process.env);
+  }
+
+  const result = require('child_process').spawnSync(binPath, args, {
+    stdio: 'inherit',
+  });
+  if (result.error) throw result.error;
+  // Signal death has no exit code of its own; 128 + signal is what a shell reports.
+  process.exit(
+    result.signal
+      ? 128 + require('os').constants.signals[result.signal]
+      : result.status,
+  );
+}

package/package.json

@@ -1,45 +1,31 @@
 {
   "name": "parcel",
-  "version": "2.16.4",
+  "version": "3.0.0-alpha.1",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "MIT",
-  "publishConfig": {
-    "access": "public"
-  },
-  "funding": {
-    "type": "opencollective",
-    "url": "https://opencollective.com/parcel"
-  },
   "repository": {
     "type": "git",
     "url": "https://github.com/parcel-bundler/parcel.git"
   },
-  "bin": "lib/bin.js",
-  "main": "lib/bin.js",
-  "source": "src/bin.js",
-  "engines": {
-    "node": ">= 16.0.0"
+  "bin": {
+    "parcel": "bin/parcel"
   },
-  "dependencies": {
-    "@parcel/config-default": "2.16.4",
-    "@parcel/core": "2.16.4",
-    "@parcel/diagnostic": "2.16.4",
-    "@parcel/events": "2.16.4",
-    "@parcel/feature-flags": "2.16.4",
-    "@parcel/fs": "2.16.4",
-    "@parcel/logger": "2.16.4",
-    "@parcel/package-manager": "2.16.4",
-    "@parcel/reporter-cli": "2.16.4",
-    "@parcel/reporter-dev-server": "2.16.4",
-    "@parcel/reporter-tracer": "2.16.4",
-    "@parcel/utils": "2.16.4",
-    "chalk": "^4.1.2",
-    "commander": "^12.1.0",
-    "get-port": "^4.2.0"
-  },
-  "devDependencies": {
-    "@babel/core": "^7.22.11",
-    "@parcel/babel-register": "2.16.4"
+  "files": [
+    "bin",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">= 18"
   },
-  "gitHead": "59484858a1a0bcbb71f74088956bb437a2db6505"
-}
+  "optionalDependencies": {
+    "@parcel/parcel3-darwin-arm64": "3.0.0-alpha.1",
+    "@parcel/parcel3-win32-arm64": "3.0.0-alpha.1",
+    "@parcel/parcel3-linux-arm64": "3.0.0-alpha.1",
+    "@parcel/parcel3-linux-arm64-musl": "3.0.0-alpha.1",
+    "@parcel/parcel3-darwin-x64": "3.0.0-alpha.1",
+    "@parcel/parcel3-win32-x64": "3.0.0-alpha.1",
+    "@parcel/parcel3-linux-x64": "3.0.0-alpha.1",
+    "@parcel/parcel3-linux-x64-musl": "3.0.0-alpha.1"
+  }
+}

package/lib/bin.js

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-require('./cli');