Repository: node
Issue: Support for Import Maps
Labels: feature request,esm,never-stale

I was hoping to start the conversation around getting [Import Map](https://github.com/WICG/import-maps) support into core.  I figured starting here with a proposal was better than starting right off with a PR.

## What Are Import Maps

> This proposal allows control over what URLs get fetched by JavaScript import statements and import() expressions. This allows "bare import specifiers", such as import moment from "moment", to work.

The proposal was mainly targeted at browsers where URL imports have many downsides without bare specifier support.  It enables a standardized map file format to be used when resolving import specifiers, giving developers more control of the behavior of import statements.

Here is an example of the format:

```json
{
  "imports": {
    "todayis": "node_modules/todayis/index.js"
  },
  "scopes": {
    "node_modules/todayis": {
      "english-days": "node_modules/english-days/index.json"
    }
  }
}
```

Proposal link: https://github.com/WICG/import-maps

## Why should they be supported in Node.js?

Currently we use the structure of the filesystem and a resolution algorithm to map import specifiers to files.  These files are typically installed by a package manager in a structure which the Node.js resolution algorithm knows how to resolve.  This has some drawbacks:

1. It is slow
2. It can lead to unexpectedly resolving modules
    - if you have a `node_modules` at your filesystem root for example
    - if your package manager has hoisted a transitive dep and you access it from the top level
3. Tools are required to implement copies of the Node.js resolution logic
4. Users and package managers jump through hoops to try and make the filesystem performant

If we had import maps we could circumvent most of this.  Package mangers can generate an import map, enabling perf improvements and simplicity in their implementations.  It increases startup performance of apps because they don't have to do as much filesystem access.

One interesting example of what import maps enables is filesystem structure independent workspaces (think yarn workspaces but without the requirement of the modules being under the same root directory).

## Implementation

As an example implementation I created this gist:

https://gist.github.com/wesleytodd/4399b2351c59438db19a8ffb1f3fcdca

To run it:

```
$ git clone git@gist.github.com:4399b2351c59438db19a8ffb1f3fcdca.git hello-today
$ cd hello-today
$ npm it
```

This uses an experimental loader which loads an `importmap.json` and falls back to the original filesystem lookup if it fails.  I am also pretty sure this very naive implementation is missing edge cases, but in these simple cases it appears to work.

Obviously for support in core we would not use a loader, but I think the rest would be similar. Open questions I have are:

**Where would node find the `importmap.json`?**

My first idea is at `node_modules/importmap.json`.  I think this would be expected behavior from users if their package managers started writing this file.

**How would users override the `importmap.json`?**

For this I think a reasonable approach would be a cli flag (`--importmap`) and a package.json (`"importmap": "./importmap.json"`) field.

**Do we want to wait for browsers to standardize import maps?**

https://github.com/nodejs/node/issues/49443

I think that this is a very valid concern.  Is there a way to help push that forward?  The benefits are pretty large in node IMO, and it would superseded all the work currently being done on yarn pnp and npm 8.  If we let those go forward but then this spec lands it might be even worse for shifting the community.

Could we release it as flagged & experimental until browsers standardize?  This would mean users could opt in, but as it changed we could follow along.

---

Thoughts? Next steps?