@embroider/core 2.0.1 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@embroider/core",
-  "version": "2.0.1",
+  "version": "2.1.0",
   "private": false,
   "description": "A build system for EmberJS applications.",
   "repository": {

package/src/babel-plugin-adjust-imports.d.ts

@@ -1,38 +1,17 @@
 import type { NodePath } from '@babel/traverse';
 import type * as Babel from '@babel/core';
 import type { types as t } from '@babel/core';
-import { Package, V2Package } from '@embroider/shared-internals';
+import { Options, Resolver } from './module-resolver';
 interface State {
-    adjustFile: AdjustFile;
+    resolver: Resolver;
     opts: Options | DeflatedOptions;
 }
+export { Options };
 export interface DeflatedOptions {
     adjustImportsOptionsPath: string;
     relocatedFilesPath: string;
 }
 declare type BabelTypes = typeof t;
-export interface Options {
-    renamePackages: {
-        [fromName: string]: string;
-    };
-    renameModules: {
-        [fromName: string]: string;
-    };
-    extraImports: {
-        absPath: string;
-        target: string;
-        runtimeName?: string;
-    }[];
-    externalsDir: string;
-    activeAddons: {
-        [packageName: string]: string;
-    };
-    relocatedFiles: {
-        [relativePath: string]: string;
-    };
-    resolvableExtensions: string[];
-    appRoot: string;
-}
 declare type DefineExpressionPath = NodePath<t.CallExpression> & {
     node: t.CallExpression & {
         arguments: [t.StringLiteral, t.ArrayExpression, Function];
@@ -50,13 +29,3 @@ export default function main(babel: typeof Babel): {
         CallExpression(path: NodePath<Babel.types.CallExpression>, state: State): void;
     };
 };
-declare class AdjustFile {
-    name: string;
-    readonly originalFile: string;
-    private packageCache;
-    constructor(name: string, relocatedFiles: Options['relocatedFiles'], appRoot: string);
-    get isRelocated(): boolean;
-    owningPackage(): Package | undefined;
-    relocatedIntoPackage(): V2Package | undefined;
-}
-export {};

package/src/babel-plugin-adjust-imports.js

@@ -1,20 +1,17 @@
 "use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isDefineExpression = exports.isDynamicImportExpression = exports.isImportSyncExpression = void 0;
-const shared_internals_1 = require("@embroider/shared-internals");
 const path_1 = require("path");
-const shared_internals_2 = require("@embroider/shared-internals");
-const typescript_memoize_1 = require("typescript-memoize");
-const js_handlebars_1 = require("./js-handlebars");
 const babel_import_util_1 = require("babel-import-util");
 const crypto_1 = require("crypto");
 const fs_extra_1 = require("fs-extra");
+const shared_internals_1 = require("@embroider/shared-internals");
+const js_handlebars_1 = require("./js-handlebars");
+const module_resolver_1 = require("./module-resolver");
+const assert_never_1 = __importDefault(require("assert-never"));
 function isImportSyncExpression(t, path) {
     if (!path ||
         !path.isCallExpression() ||
@@ -48,254 +45,6 @@ function isDefineExpression(t, path) {
         t.isFunction(args[2]));
 }
 exports.isDefineExpression = isDefineExpression;
-function adjustSpecifier(specifier, file, opts, isDynamic) {
-    if (specifier === '@embroider/macros') {
-        // the macros package is always handled directly within babel (not
-        // necessarily as a real resolvable package), so we should not mess with it.
-        // It might not get compiled away until *after* our plugin has run, which is
-        // why we need to know about it.
-        return specifier;
-    }
-    specifier = handleRenaming(specifier, file, opts);
-    specifier = handleExternal(specifier, file, opts, isDynamic);
-    return specifier;
-}
-function handleRenaming(specifier, sourceFile, opts) {
-    let packageName = (0, shared_internals_1.packageName)(specifier);
-    if (!packageName) {
-        return specifier;
-    }
-    for (let [candidate, replacement] of Object.entries(opts.renameModules)) {
-        if (candidate === specifier) {
-            return replacement;
-        }
-        for (let extension of opts.resolvableExtensions) {
-            if (candidate === specifier + '/index' + extension) {
-                return replacement;
-            }
-            if (candidate === specifier + extension) {
-                return replacement;
-            }
-        }
-    }
-    if (opts.renamePackages[packageName]) {
-        return specifier.replace(packageName, opts.renamePackages[packageName]);
-    }
-    let pkg = sourceFile.owningPackage();
-    if (!pkg || !pkg.isV2Ember()) {
-        return specifier;
-    }
-    if (pkg.meta['auto-upgraded'] && pkg.name === packageName) {
-        // we found a self-import, make it relative. Only auto-upgraded packages get
-        // this help, v2 packages are natively supposed to use relative imports for
-        // their own modules, and we want to push them all to do that correctly.
-        let fullPath = specifier.replace(packageName, pkg.root);
-        return (0, shared_internals_2.explicitRelative)((0, path_1.dirname)(sourceFile.name), fullPath);
-    }
-    let relocatedIntoPkg = sourceFile.relocatedIntoPackage();
-    if (relocatedIntoPkg && pkg.meta['auto-upgraded'] && relocatedIntoPkg.name === packageName) {
-        // a file that was relocated into a package does a self-import of that
-        // package's name. This can happen when an addon (like ember-cli-mirage)
-        // emits files from its own treeForApp that contain imports of the app's own
-        // fully qualified name.
-        let fullPath = specifier.replace(packageName, relocatedIntoPkg.root);
-        return (0, shared_internals_2.explicitRelative)((0, path_1.dirname)(sourceFile.name), fullPath);
-    }
-    return specifier;
-}
-function isExplicitlyExternal(specifier, fromPkg) {
-    return Boolean(fromPkg.isV2Addon() && fromPkg.meta['externals'] && fromPkg.meta['externals'].includes(specifier));
-}
-function isResolvable(packageName, fromPkg, appRoot) {
-    try {
-        let dep = shared_internals_2.PackageCache.shared('embroider-stage3', appRoot).resolve(packageName, fromPkg);
-        if (!dep.isEmberPackage() && fromPkg.meta['auto-upgraded'] && !fromPkg.hasDependency('ember-auto-import')) {
-            // classic ember addons can only import non-ember dependencies if they
-            // have ember-auto-import.
-            //
-            // whereas native v2 packages can always import any dependency
-            return false;
-        }
-        return dep;
-    }
-    catch (err) {
-        if (err.code !== 'MODULE_NOT_FOUND') {
-            throw err;
-        }
-        return false;
-    }
-}
-const dynamicMissingModule = (0, js_handlebars_1.compile)(`
-  throw new Error('Could not find module \`{{{js-string-escape moduleName}}}\`');
-`);
-const externalTemplate = (0, js_handlebars_1.compile)(`
-{{#if (eq runtimeName "require")}}
-const m = window.requirejs;
-{{else}}
-const m = window.require("{{{js-string-escape runtimeName}}}");
-{{/if}}
-{{!-
-  There are plenty of hand-written AMD defines floating around
-  that lack this, and they will break when other build systems
-  encounter them.
-
-  As far as I can tell, Ember's loader was already treating this
-  case as a module, so in theory we aren't breaking anything by
-  marking it as such when other packagers come looking.
-
-  todo: get review on this part.
--}}
-if (m.default && !m.__esModule) {
-  m.__esModule = true;
-}
-module.exports = m;
-`);
-function handleExternal(specifier, sourceFile, opts, isDynamic) {
-    let pkg = sourceFile.owningPackage();
-    if (!pkg || !pkg.isV2Ember()) {
-        return specifier;
-    }
-    let packageName = (0, shared_internals_1.packageName)(specifier);
-    if (!packageName) {
-        // This is a relative import. We don't automatically externalize those
-        // because it's rare, and by keeping them static we give better errors. But
-        // we do allow them to be explicitly externalized by the package author (or
-        // a compat adapter). In the metadata, they would be listed in
-        // package-relative form, so we need to convert this specifier to that.
-        let absoluteSpecifier = (0, path_1.resolve)((0, path_1.dirname)(sourceFile.name), specifier);
-        let packageRelativeSpecifier = (0, shared_internals_2.explicitRelative)(pkg.root, absoluteSpecifier);
-        if (isExplicitlyExternal(packageRelativeSpecifier, pkg)) {
-            let publicSpecifier = absoluteSpecifier.replace(pkg.root, pkg.name);
-            return makeExternal(publicSpecifier, sourceFile, opts);
-        }
-        else {
-            return specifier;
-        }
-    }
-    // absolute package imports can also be explicitly external based on their
-    // full specifier name
-    if (isExplicitlyExternal(specifier, pkg)) {
-        return makeExternal(specifier, sourceFile, opts);
-    }
-    if (!pkg.meta['auto-upgraded'] && shared_internals_1.emberVirtualPeerDeps.has(packageName)) {
-        // Native v2 addons are allowed to use the emberVirtualPeerDeps like
-        // `@glimmer/component`. And like all v2 addons, it's important that they
-        // see those dependencies after those dependencies have been converted to
-        // v2.
-        //
-        // But unlike auto-upgraded addons, native v2 addons are not necessarily
-        // copied out of their original place in node_modules. And from that
-        // original place they might accidentally resolve the emberVirtualPeerDeps
-        // that are present there in v1 format.
-        //
-        // So before we even check isResolvable, we adjust these imports to point at
-        // the app's copies instead.
-        if (shared_internals_1.emberVirtualPeerDeps.has(packageName)) {
-            if (!opts.activeAddons[packageName]) {
-                throw new Error(`${pkg.name} is trying to import the app's ${packageName} package, but it seems to be missing`);
-            }
-            return (0, shared_internals_2.explicitRelative)((0, path_1.dirname)(sourceFile.name), specifier.replace(packageName, opts.activeAddons[packageName]));
-        }
-    }
-    let relocatedPkg = sourceFile.relocatedIntoPackage();
-    if (relocatedPkg) {
-        // this file has been moved into another package (presumably the app).
-        // first try to resolve from the destination package
-        if (isResolvable(packageName, relocatedPkg, opts.appRoot)) {
-            // self-imports are legal in the app tree, even for v2 packages.
-            if (!pkg.meta['auto-upgraded'] && packageName !== pkg.name) {
-                throw new Error(`${pkg.name} is trying to import ${packageName} from within its app tree. This is unsafe, because ${pkg.name} can't control which dependencies are resolvable from the app`);
-            }
-            return specifier;
-        }
-        else {
-            // second try to resolve from the source package
-            let targetPkg = isResolvable(packageName, pkg, opts.appRoot);
-            if (targetPkg) {
-                // self-imports are legal in the app tree, even for v2 packages.
-                if (!pkg.meta['auto-upgraded'] && packageName !== pkg.name) {
-                    throw new Error(`${pkg.name} is trying to import ${packageName} from within its app tree. This is unsafe, because ${pkg.name} can't control which dependencies are resolvable from the app`);
-                }
-                // we found it, but we need to rewrite it because it's not really going to
-                // resolve from where its sitting
-                return (0, shared_internals_2.explicitRelative)((0, path_1.dirname)(sourceFile.name), specifier.replace(packageName, targetPkg.root));
-            }
-        }
-    }
-    else {
-        if (isResolvable(packageName, pkg, opts.appRoot)) {
-            if (!pkg.meta['auto-upgraded'] && !reliablyResolvable(pkg, packageName)) {
-                throw new Error(`${pkg.name} is trying to import from ${packageName} but that is not one of its explicit dependencies`);
-            }
-            return specifier;
-        }
-    }
-    // auto-upgraded packages can fall back to the set of known active addons
-    //
-    // v2 packages can fall back to the set of known active addons only to find
-    // themselves (which is needed due to app tree merging)
-    if ((pkg.meta['auto-upgraded'] || packageName === pkg.name) && opts.activeAddons[packageName]) {
-        return (0, shared_internals_2.explicitRelative)((0, path_1.dirname)(sourceFile.name), specifier.replace(packageName, opts.activeAddons[packageName]));
-    }
-    if (pkg.meta['auto-upgraded']) {
-        // auto-upgraded packages can fall back to attempting to find dependencies at
-        // runtime. Native v2 packages can only get this behavior in the
-        // isExplicitlyExternal case above because they need to explicitly ask for
-        // externals.
-        return makeExternal(specifier, sourceFile, opts);
-    }
-    else {
-        // native v2 packages don't automatically externalize *everything* the way
-        // auto-upgraded packages do, but they still externalize known and approved
-        // ember virtual packages (like @ember/component)
-        if (shared_internals_1.emberVirtualPackages.has(packageName)) {
-            return makeExternal(specifier, sourceFile, opts);
-        }
-    }
-    // non-resolvable imports in dynamic positions become runtime errors, not
-    // build-time errors, so we emit the runtime error module here before the
-    // stage3 packager has a chance to see the missing module. (Maybe some stage3
-    // packagers will have this behavior by default, because it would make sense,
-    // but webpack at least does not.)
-    if (isDynamic) {
-        return makeMissingModule(specifier, sourceFile, opts);
-    }
-    // this is falling through with the original specifier which was
-    // non-resolvable, which will presumably cause a static build error in stage3.
-    return specifier;
-}
-function makeMissingModule(specifier, sourceFile, opts) {
-    let target = (0, path_1.join)(opts.externalsDir, 'missing', specifier + '.js');
-    atomicWrite(target, dynamicMissingModule({
-        moduleName: specifier,
-    }));
-    return (0, shared_internals_2.explicitRelative)((0, path_1.dirname)(sourceFile.name), target.slice(0, -3));
-}
-function makeExternal(specifier, sourceFile, opts) {
-    let target = (0, path_1.join)(opts.externalsDir, specifier + '.js');
-    atomicWrite(target, externalTemplate({
-        runtimeName: specifier,
-    }));
-    return (0, shared_internals_2.explicitRelative)((0, path_1.dirname)(sourceFile.name), target.slice(0, -3));
-}
-function atomicWrite(path, content) {
-    if ((0, fs_extra_1.pathExistsSync)(path)) {
-        return;
-    }
-    let suffix = (0, crypto_1.randomBytes)(8).toString('hex');
-    (0, fs_extra_1.outputFileSync)(path + suffix, content);
-    try {
-        (0, fs_extra_1.renameSync)(path + suffix, path);
-    }
-    catch (err) {
-        // windows throws EPERM for concurrent access. For us it's not an error
-        // condition because the other thread is writing the exact same value we
-        // would have.
-        if (err.code !== 'EPERM') {
-            throw err;
-        }
-    }
-}
 function main(babel) {
     let t = babel.types;
     return {
@@ -303,7 +52,7 @@ function main(babel) {
             Program: {
                 enter(path, state) {
                     let opts = ensureOpts(state);
-                    state.adjustFile = new AdjustFile(path.hub.file.opts.filename, opts.relocatedFiles, opts.appRoot);
+                    state.resolver = new module_resolver_1.Resolver(path.hub.file.opts.filename, opts);
                     let adder = new babel_import_util_1.ImportUtil(t, path);
                     addExtraImports(adder, t, path, opts.extraImports);
                 },
@@ -318,24 +67,23 @@ function main(babel) {
             CallExpression(path, state) {
                 if (isImportSyncExpression(t, path) || isDynamicImportExpression(t, path)) {
                     const [source] = path.get('arguments');
-                    let opts = ensureOpts(state);
-                    let specifier = adjustSpecifier(source.node.value, state.adjustFile, opts, true);
-                    source.replaceWith(t.stringLiteral(specifier));
+                    resolve(source.node.value, true, state, newSpecifier => {
+                        source.replaceWith(t.stringLiteral(newSpecifier));
+                    });
                     return;
                 }
                 // Should/can we make this early exit when the first define was found?
                 if (!isDefineExpression(t, path)) {
                     return;
                 }
-                let pkg = state.adjustFile.owningPackage();
+                let pkg = state.resolver.owningPackage();
                 if (pkg && pkg.isV2Ember() && !pkg.meta['auto-upgraded']) {
-                    throw new Error(`The file ${state.adjustFile.originalFile} in package ${pkg.name} tried to use AMD define. Native V2 Ember addons are forbidden from using AMD define, they must use ECMA export only.`);
+                    throw new Error(`The file ${state.resolver.originalFilename} in package ${pkg.name} tried to use AMD define. Native V2 Ember addons are forbidden from using AMD define, they must use ECMA export only.`);
                 }
-                let opts = ensureOpts(state);
                 const dependencies = path.node.arguments[1];
                 const specifiers = dependencies.elements.slice();
                 specifiers.push(path.node.arguments[0]);
-                for (let source of specifiers) {
+                for (const source of specifiers) {
                     if (!source) {
                         continue;
                     }
@@ -346,10 +94,9 @@ function main(babel) {
                         // skip "special" AMD dependencies
                         continue;
                     }
-                    let specifier = adjustSpecifier(source.value, state.adjustFile, opts, false);
-                    if (specifier !== source.value) {
-                        source.value = specifier;
-                    }
+                    resolve(source.value, false, state, newSpecifier => {
+                        source.value = newSpecifier;
+                    });
                 }
             },
         },
@@ -357,15 +104,13 @@ function main(babel) {
 }
 exports.default = main;
 function rewriteTopLevelImport(path, state) {
-    let opts = ensureOpts(state);
     const { source } = path.node;
     if (source === null || source === undefined) {
         return;
     }
-    let specifier = adjustSpecifier(source.value, state.adjustFile, opts, false);
-    if (specifier !== source.value) {
-        source.value = specifier;
-    }
+    resolve(source.value, false, state, newSpecifier => {
+        source.value = newSpecifier;
+    });
 }
 main.baseDir = function () {
     return (0, path_1.join)(__dirname, '..');
@@ -389,37 +134,6 @@ function amdDefine(t, adder, path, target, runtimeName) {
         t.functionExpression(null, [], t.blockStatement([t.returnStatement(value)])),
     ]));
 }
-class AdjustFile {
-    constructor(name, relocatedFiles, appRoot) {
-        this.name = name;
-        this.packageCache = shared_internals_2.PackageCache.shared('embroider-stage3', appRoot);
-        if (!name) {
-            throw new Error(`bug: adjust-imports plugin was run without a filename`);
-        }
-        this.originalFile = relocatedFiles[name] || name;
-    }
-    get isRelocated() {
-        return this.originalFile !== this.name;
-    }
-    owningPackage() {
-        return this.packageCache.ownerOfFile(this.originalFile);
-    }
-    relocatedIntoPackage() {
-        if (this.isRelocated) {
-            let owning = this.packageCache.ownerOfFile(this.name);
-            if (owning && !owning.isV2Ember()) {
-                throw new Error(`bug: it should only be possible to get relocated into a v2 ember package here`);
-            }
-            return owning;
-        }
-    }
-}
-__decorate([
-    (0, typescript_memoize_1.Memoize)()
-], AdjustFile.prototype, "owningPackage", null);
-__decorate([
-    (0, typescript_memoize_1.Memoize)()
-], AdjustFile.prototype, "relocatedIntoPackage", null);
 function ensureOpts(state) {
     let { opts } = state;
     if ('adjustImportsOptionsPath' in opts) {
@@ -428,21 +142,83 @@ function ensureOpts(state) {
     }
     return opts;
 }
-// we don't want to allow things that resolve only by accident that are likely
-// to break in other setups. For example: import your dependencies'
-// dependencies, or importing your own name from within a monorepo (which will
-// work because of the symlinking) without setting up "exports" (which makes
-// your own name reliably resolvable)
-function reliablyResolvable(pkg, packageName) {
-    if (pkg.hasDependency(packageName)) {
-        return true;
+function makeExternal(specifier, sourceFile, opts) {
+    let target = (0, path_1.join)(opts.externalsDir, specifier + '.js');
+    atomicWrite(target, externalTemplate({
+        runtimeName: specifier,
+    }));
+    return (0, shared_internals_1.explicitRelative)((0, path_1.dirname)(sourceFile), target.slice(0, -3));
+}
+function atomicWrite(path, content) {
+    if ((0, fs_extra_1.pathExistsSync)(path)) {
+        return;
+    }
+    let suffix = (0, crypto_1.randomBytes)(8).toString('hex');
+    (0, fs_extra_1.outputFileSync)(path + suffix, content);
+    try {
+        (0, fs_extra_1.renameSync)(path + suffix, path);
     }
-    if (pkg.name === packageName && pkg.packageJSON.exports) {
-        return true;
+    catch (err) {
+        // windows throws EPERM for concurrent access. For us it's not an error
+        // condition because the other thread is writing the exact same value we
+        // would have.
+        if (err.code !== 'EPERM') {
+            throw err;
+        }
     }
-    if (shared_internals_1.emberVirtualPeerDeps.has(packageName)) {
-        return true;
+}
+function makeMissingModule(specifier, sourceFile, opts) {
+    let target = (0, path_1.join)(opts.externalsDir, 'missing', specifier + '.js');
+    atomicWrite(target, dynamicMissingModule({
+        moduleName: specifier,
+    }));
+    return (0, shared_internals_1.explicitRelative)((0, path_1.dirname)(sourceFile), target.slice(0, -3));
+}
+const dynamicMissingModule = (0, js_handlebars_1.compile)(`
+  throw new Error('Could not find module \`{{{js-string-escape moduleName}}}\`');
+`);
+const externalTemplate = (0, js_handlebars_1.compile)(`
+{{#if (eq runtimeName "require")}}
+const m = window.requirejs;
+{{else}}
+const m = window.require("{{{js-string-escape runtimeName}}}");
+{{/if}}
+{{!-
+  There are plenty of hand-written AMD defines floating around
+  that lack this, and they will break when other build systems
+  encounter them.
+
+  As far as I can tell, Ember's loader was already treating this
+  case as a module, so in theory we aren't breaking anything by
+  marking it as such when other packagers come looking.
+
+  todo: get review on this part.
+-}}
+if (m.default && !m.__esModule) {
+  m.__esModule = true;
+}
+module.exports = m;
+`);
+function resolve(specifier, isDynamic, state, setter) {
+    let resolution = state.resolver.resolve(specifier, isDynamic);
+    let newSpecifier;
+    switch (resolution.result) {
+        case 'continue':
+            return;
+        case 'external':
+            newSpecifier = makeExternal(resolution.specifier, state.resolver.filename, ensureOpts(state));
+            break;
+        case 'redirect-to':
+            newSpecifier = resolution.specifier;
+            break;
+        case 'runtime-failure':
+            newSpecifier = makeMissingModule(resolution.specifier, state.resolver.filename, ensureOpts(state));
+            break;
+        default:
+            throw (0, assert_never_1.default)(resolution);
+    }
+    if (newSpecifier) {
+        setter(newSpecifier);
     }
-    return false;
 }
 //# sourceMappingURL=babel-plugin-adjust-imports.js.map