@embroider/core 2.1.1-unstable.21eae41 → 2.1.1-unstable.72d5a8e

package/src/module-resolver.js

@@ -1,4 +1,10 @@
 "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 };
 };
@@ -11,6 +17,10 @@ const debug_1 = __importDefault(require("debug"));
 const assert_never_1 = __importDefault(require("assert-never"));
 const resolve_1 = __importDefault(require("resolve"));
 const virtual_content_1 = require("./virtual-content");
+const typescript_memoize_1 = require("typescript-memoize");
+const describe_exports_1 = require("./describe-exports");
+const fs_1 = require("fs");
+const fs_extra_1 = require("fs-extra");
 const debug = (0, debug_1.default)('embroider:resolver');
 function logTransition(reason, before, after = before) {
     if (after.isVirtual) {
@@ -61,7 +71,9 @@ class Resolver {
             // why we need to know about it.
             return logTransition('early exit', request);
         }
+        request = this.handleFastbootCompat(request);
         request = this.handleGlobalsCompat(request);
+        request = this.handleLegacyAddons(request);
         request = this.handleRenaming(request);
         return this.preHandleExternal(request);
     }
@@ -83,9 +95,7 @@ class Resolver {
     }
     // synchronous alternative to resolve() above. Because our own internals are
     // all synchronous, you can use this if your defaultResolve function is
-    // synchronous. At present, we need this for the case where we are compiling
-    // non-strict templates and doing component resolutions inside the template
-    // compiler inside babel, which is a synchronous context.
+    // synchronous.
     resolveSync(request, defaultResolve) {
         let gen = this.internalResolve(request, defaultResolve);
         let out = gen.next();
@@ -161,15 +171,42 @@ class Resolver {
     owningPackage(fromFile) {
         return shared_internals_2.PackageCache.shared('embroider-stage3', this.options.appRoot).ownerOfFile(fromFile);
     }
-    originalPackage(fromFile) {
-        let originalFile = this.options.relocatedFiles[fromFile];
-        if (originalFile) {
-            let owning = shared_internals_2.PackageCache.shared('embroider-stage3', this.options.appRoot).ownerOfFile(originalFile);
-            if (owning && !owning.isV2Ember()) {
-                throw new Error(`bug: it should only be possible for a v2 ember package to own relocated files`);
+    logicalPackage(owningPackage, file) {
+        let logicalLocation = this.reverseSearchAppTree(owningPackage, file);
+        if (logicalLocation) {
+            let pkg = shared_internals_2.PackageCache.shared('embroider-stage3', this.options.appRoot).get(logicalLocation.owningEngine.root);
+            if (!pkg.isV2Ember()) {
+                throw new Error(`bug: all engines should be v2 addons by the time we see them here`);
+            }
+            return pkg;
+        }
+        return owningPackage;
+    }
+    handleFastbootCompat(request) {
+        var _a;
+        let match = (0, virtual_content_1.decodeFastbootSwitch)(request.fromFile);
+        if (!match) {
+            return request;
+        }
+        let section;
+        if (request.specifier === './browser') {
+            section = 'app-js';
+        }
+        else if (request.specifier === './fastboot') {
+            section = 'fastboot-js';
+        }
+        if (!section) {
+            return request;
+        }
+        let pkg = this.owningPackage(match.filename);
+        if (pkg) {
+            let rel = withoutJSExt((0, shared_internals_2.explicitRelative)(pkg.root, match.filename));
+            let entry = (_a = this.mergeMap.get(pkg.root)) === null || _a === void 0 ? void 0 : _a.get(rel);
+            if ((entry === null || entry === void 0 ? void 0 : entry.type) === 'both') {
+                return request.alias(entry[section].localPath).rehome((0, path_1.resolve)(entry[section].packageRoot, 'package.json'));
             }
-            return owning;
         }
+        return request;
     }
     handleGlobalsCompat(request) {
         let match = compatPattern.exec(request.specifier);
@@ -197,9 +234,7 @@ class Resolver {
     }
     resolveHelper(path, inEngine, request) {
         let target = this.parseGlobalPath(path, inEngine);
-        return request
-            .alias(`${target.packageName}/helpers/${target.memberName}`)
-            .rehome((0, path_1.resolve)(inEngine.root, 'package.json'));
+        return logTransition('resolveHelper', request, request.alias(`${target.packageName}/helpers/${target.memberName}`).rehome((0, path_1.resolve)(inEngine.root, 'package.json')));
     }
     resolveComponent(path, inEngine, request) {
         let target = this.parseGlobalPath(path, inEngine);
@@ -241,25 +276,25 @@ class Resolver {
         let helperCandidate = this.resolveHelper(path, inEngine, request);
         let helperMatch = this.nodeResolve(helperCandidate.specifier, helperCandidate.fromFile);
         if (helperMatch.type === 'real') {
-            return helperCandidate;
+            return logTransition('ambiguous case matched a helper', request, helperCandidate);
         }
         // unlike resolveHelper, resolveComponent already does pre-resolution in
         // order to deal with its own internal ambiguity around JS vs HBS vs
         // colocation.≥
         let componentMatch = this.resolveComponent(path, inEngine, request);
         if (componentMatch !== request) {
-            return componentMatch;
+            return logTransition('ambiguous case matched a cmoponent', request, componentMatch);
         }
         // this is the hard failure case -- we were supposed to find something and
         // didn't. Let the normal resolution process progress so the user gets a
         // normal build error.
-        return request;
+        return logTransition('ambiguous case failing', request);
     }
     resolveModifier(path, inEngine, request) {
         let target = this.parseGlobalPath(path, inEngine);
-        return request
+        return logTransition('resolveModifier', request, request
             .alias(`${target.packageName}/modifiers/${target.memberName}`)
-            .rehome((0, path_1.resolve)(inEngine.root, 'package.json'));
+            .rehome((0, path_1.resolve)(inEngine.root, 'package.json')));
     }
     *componentTemplateCandidates(inPackageName) {
         yield { prefix: '/templates/components/', suffix: '' };
@@ -295,6 +330,106 @@ class Resolver {
             return { packageName: inEngine.packageName, memberName: path, from: (0, path_1.resolve)(inEngine.root, 'pacakge.json') };
         }
     }
+    engineConfig(packageName) {
+        return this.options.engines.find(e => e.packageName === packageName);
+    }
+    // This is where we figure out how all the classic treeForApp merging bottoms
+    // out.
+    get mergeMap() {
+        let packageCache = shared_internals_2.PackageCache.shared('embroider-stage3', this.options.appRoot);
+        let result = new Map();
+        for (let engine of this.options.engines) {
+            let engineModules = new Map();
+            for (let addonConfig of engine.activeAddons) {
+                let addon = packageCache.get(addonConfig.root);
+                if (!addon.isV2Addon()) {
+                    continue;
+                }
+                let appJS = addon.meta['app-js'];
+                if (appJS) {
+                    for (let [inEngineName, inAddonName] of Object.entries(appJS)) {
+                        if (!inEngineName.startsWith('./')) {
+                            throw new Error(`addon ${addon.name} declares app-js in its package.json with the illegal name "${inEngineName}". It must start with "./" to make it clear that it's relative to the app`);
+                        }
+                        if (!inAddonName.startsWith('./')) {
+                            throw new Error(`addon ${addon.name} declares app-js in its package.json with the illegal name "${inAddonName}". It must start with "./" to make it clear that it's relative to the addon`);
+                        }
+                        inEngineName = withoutJSExt(inEngineName);
+                        let prevEntry = engineModules.get(inEngineName);
+                        switch (prevEntry === null || prevEntry === void 0 ? void 0 : prevEntry.type) {
+                            case undefined:
+                                engineModules.set(inEngineName, {
+                                    type: 'app-only',
+                                    'app-js': {
+                                        localPath: inAddonName,
+                                        packageRoot: addon.root,
+                                        fromPackageName: addon.name,
+                                    },
+                                });
+                                break;
+                            case 'app-only':
+                            case 'both':
+                                // first match wins, so this one is shadowed
+                                break;
+                            case 'fastboot-only':
+                                engineModules.set(inEngineName, {
+                                    type: 'both',
+                                    'app-js': {
+                                        localPath: inAddonName,
+                                        packageRoot: addon.root,
+                                        fromPackageName: addon.name,
+                                    },
+                                    'fastboot-js': prevEntry['fastboot-js'],
+                                });
+                                break;
+                        }
+                    }
+                }
+                let fastbootJS = addon.meta['fastboot-js'];
+                if (fastbootJS) {
+                    for (let [inEngineName, inAddonName] of Object.entries(fastbootJS)) {
+                        if (!inEngineName.startsWith('./')) {
+                            throw new Error(`addon ${addon.name} declares fastboot-js in its package.json with the illegal name "${inEngineName}". It must start with "./" to make it clear that it's relative to the app`);
+                        }
+                        if (!inAddonName.startsWith('./')) {
+                            throw new Error(`addon ${addon.name} declares fastboot-js in its package.json with the illegal name "${inAddonName}". It must start with "./" to make it clear that it's relative to the addon`);
+                        }
+                        inEngineName = withoutJSExt(inEngineName);
+                        let prevEntry = engineModules.get(inEngineName);
+                        switch (prevEntry === null || prevEntry === void 0 ? void 0 : prevEntry.type) {
+                            case undefined:
+                                engineModules.set(inEngineName, {
+                                    type: 'fastboot-only',
+                                    'fastboot-js': {
+                                        localPath: inAddonName,
+                                        packageRoot: addon.root,
+                                        fromPackageName: addon.name,
+                                    },
+                                });
+                                break;
+                            case 'fastboot-only':
+                            case 'both':
+                                // first match wins, so this one is shadowed
+                                break;
+                            case 'app-only':
+                                engineModules.set(inEngineName, {
+                                    type: 'both',
+                                    'fastboot-js': {
+                                        localPath: inAddonName,
+                                        packageRoot: addon.root,
+                                        fromPackageName: addon.name,
+                                    },
+                                    'app-js': prevEntry['app-js'],
+                                });
+                                break;
+                        }
+                    }
+                }
+            }
+            result.set(engine.root, engineModules);
+        }
+        return result;
+    }
     owningEngine(pkg) {
         if (pkg.root === this.options.appRoot) {
             // the app is always the first engine
@@ -306,6 +441,51 @@ class Resolver {
         }
         return owningEngine;
     }
+    handleLegacyAddons(request) {
+        let packageCache = shared_internals_2.PackageCache.shared('embroider-stage3', this.options.appRoot);
+        // first we handle output requests from moved packages
+        let pkg = this.owningPackage(request.fromFile);
+        if (!pkg) {
+            return request;
+        }
+        let originalRoot = this.legacyAddonsIndex.v2toV1.get(pkg.root);
+        if (originalRoot) {
+            request = logTransition('outbound from moved v1 addon', request, request.rehome((0, path_1.resolve)(originalRoot, 'package.json')));
+            pkg = packageCache.get(originalRoot);
+        }
+        // then we handle inbound requests to moved packages
+        let packageName = (0, shared_internals_1.packageName)(request.specifier);
+        if (packageName && packageName !== pkg.name) {
+            // non-relative, non-self request, so check if it aims at a rewritten addon
+            try {
+                let target = shared_internals_2.PackageCache.shared('embroider-stage3', this.options.appRoot).resolve(packageName, pkg);
+                if (target) {
+                    let movedRoot = this.legacyAddonsIndex.v1ToV2.get(target.root);
+                    if (movedRoot) {
+                        request = logTransition('inbound to moved v1 addon', request, this.resolveWithinPackage(request, packageCache.get(movedRoot)));
+                    }
+                }
+            }
+            catch (err) {
+                if (err.code !== 'MODULE_NOT_FOUND') {
+                    throw err;
+                }
+            }
+        }
+        return request;
+    }
+    get legacyAddonsIndex() {
+        let addonsDir = (0, path_1.resolve)(this.options.appRoot, 'node_modules', '.embroider', 'addons');
+        let indexFile = (0, path_1.resolve)(addonsDir, 'v1-addon-index.json');
+        if ((0, fs_1.existsSync)(indexFile)) {
+            let { v1Addons } = (0, fs_extra_1.readJSONSync)(indexFile);
+            return {
+                v1ToV2: new Map(Object.entries(v1Addons).map(([oldRoot, relativeNewRoot]) => [oldRoot, (0, path_1.resolve)(addonsDir, relativeNewRoot)])),
+                v2toV1: new Map(Object.entries(v1Addons).map(([oldRoot, relativeNewRoot]) => [(0, path_1.resolve)(addonsDir, relativeNewRoot), oldRoot])),
+            };
+        }
+        return { v1ToV2: new Map(), v2toV1: new Map() };
+    }
     handleRenaming(request) {
         if (request.isVirtual) {
             return request;
@@ -341,12 +521,6 @@ class Resolver {
             // correctly.
             return logTransition(`v1 self-import`, request, this.resolveWithinPackage(request, pkg));
         }
-        let originalPkg = this.originalPackage(request.fromFile);
-        if (originalPkg && pkg.meta['auto-upgraded'] && originalPkg.name === packageName) {
-            // A file that was relocated out of a package is importing that package's
-            // name, it should find its own original copy.
-            return logTransition(`self-import in app-js`, request, this.resolveWithinPackage(request, originalPkg));
-        }
         return request;
     }
     resolveWithinPackage(request, pkg) {
@@ -383,9 +557,14 @@ class Resolver {
                 let publicSpecifier = absoluteSpecifier.replace(pkg.root, pkg.name);
                 return external('beforeResolve', request, publicSpecifier);
             }
-            else {
-                return request;
+            // if the requesting file is in an addon's app-js, the relative request
+            // should really be understood as a request for a module in the containing
+            // engine
+            let logicalLocation = this.reverseSearchAppTree(pkg, request.fromFile);
+            if (logicalLocation) {
+                return logTransition('beforeResolve: relative import in app-js', request, request.rehome((0, path_1.resolve)(logicalLocation.owningEngine.root, logicalLocation.inAppName)));
             }
+            return request;
         }
         // absolute package imports can also be explicitly external based on their
         // full specifier name
@@ -411,9 +590,13 @@ class Resolver {
             let newHome = (0, path_1.resolve)(this.options.appRoot, 'package.json');
             return logTransition(`emberVirtualPeerDeps in v2 addon`, request, request.rehome(newHome));
         }
-        if (pkg.meta['auto-upgraded'] && !pkg.hasDependency('ember-auto-import')) {
+        // if this file is part of an addon's app-js, it's really the logical
+        // package to which it belongs (normally the app) that affects some policy
+        // choices about what it can import
+        let logicalPackage = this.logicalPackage(pkg, fromFile);
+        if (logicalPackage.meta['auto-upgraded'] && !logicalPackage.hasDependency('ember-auto-import')) {
             try {
-                let dep = shared_internals_2.PackageCache.shared('embroider-stage3', this.options.appRoot).resolve(packageName, pkg);
+                let dep = shared_internals_2.PackageCache.shared('embroider-stage3', this.options.appRoot).resolve(packageName, logicalPackage);
                 if (!dep.isEmberPackage()) {
                     // classic ember addons can only import non-ember dependencies if they
                     // have ember-auto-import.
@@ -428,20 +611,10 @@ class Resolver {
         }
         // assertions on what native v2 addons can import
         if (!pkg.meta['auto-upgraded']) {
-            let originalPkg = this.originalPackage(fromFile);
-            if (originalPkg) {
-                // this file has been moved into another package (presumably the app).
-                if (packageName !== pkg.name) {
-                    // the only thing that native v2 addons are allowed to import from
-                    // within the app tree is their own 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`);
-                }
-            }
-            else {
-                // this file has not been moved. The normal case.
-                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`);
-                }
+            if (!pkg.meta['auto-upgraded'] &&
+                !appImportInAppTree(pkg, logicalPackage, packageName) &&
+                !reliablyResolvable(pkg, packageName)) {
+                throw new Error(`${pkg.name} is trying to import from ${packageName} but that is not one of its explicit dependencies`);
             }
         }
         return request;
@@ -466,18 +639,27 @@ class Resolver {
         }
         let pkg = this.owningPackage(fromFile);
         if (!pkg || !pkg.isV2Ember()) {
-            return request;
+            return logTransition('fallbackResolve: not in an ember package', request);
         }
         let packageName = (0, shared_internals_1.packageName)(specifier);
         if (!packageName) {
-            // this is a relative import, we have nothing more to for it.
-            return request;
-        }
-        let originalPkg = this.originalPackage(fromFile);
-        if (originalPkg) {
-            // we didn't find it from the original package, so try from the relocated
-            // package
-            return logTransition(`relocation fallback`, request, request.rehome((0, path_1.resolve)(originalPkg.root, 'package.json')));
+            // this is a relative import
+            let withinEngine = this.engineConfig(pkg.name);
+            if (withinEngine) {
+                // it's a relative import inside an engine (which also means app), which
+                // means we may need to satisfy the request via app tree merging.
+                let appJSMatch = this.searchAppTree(request, withinEngine, (0, shared_internals_2.explicitRelative)(pkg.root, (0, path_1.resolve)((0, path_1.dirname)(fromFile), specifier)));
+                if (appJSMatch) {
+                    return logTransition('fallbackResolve: relative appJsMatch', request, appJSMatch);
+                }
+                else {
+                    return logTransition('fallbackResolve: relative appJs search failure', request);
+                }
+            }
+            else {
+                // nothing else to do for relative imports
+                return logTransition('fallbackResolve: relative failure', request);
+            }
         }
         // auto-upgraded packages can fall back to the set of known active addons
         //
@@ -486,6 +668,21 @@ class Resolver {
         if ((pkg.meta['auto-upgraded'] || packageName === pkg.name) && this.options.activeAddons[packageName]) {
             return logTransition(`activeAddons`, request, this.resolveWithinPackage(request, shared_internals_2.PackageCache.shared('embroider-stage3', this.options.appRoot).get(this.options.activeAddons[packageName])));
         }
+        let targetingEngine = this.engineConfig(packageName);
+        if (targetingEngine) {
+            let appJSMatch = this.searchAppTree(request, targetingEngine, specifier.replace(packageName, '.'));
+            if (appJSMatch) {
+                return logTransition('fallbackResolve: non-relative appJsMatch', request, appJSMatch);
+            }
+        }
+        let logicalLocation = this.reverseSearchAppTree(pkg, request.fromFile);
+        if (logicalLocation) {
+            // the requesting file is in an addon's appTree. We didn't succeed in
+            // resolving this (non-relative) request from inside the actual addon, so
+            // next try to resolve it from the corresponding logical location in the
+            // app.
+            return logTransition('fallbackResolve: retry from logical home of app-js file', request, request.rehome((0, path_1.resolve)(logicalLocation.owningEngine.root, logicalLocation.inAppName)));
+        }
         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
@@ -503,7 +700,29 @@ class Resolver {
         }
         // this is falling through with the original specifier which was
         // non-resolvable, which will presumably cause a static build error in stage3.
-        return request;
+        return logTransition('fallbackResolve final exit', request);
+    }
+    searchAppTree(request, engine, inEngineSpecifier) {
+        var _a;
+        inEngineSpecifier = withoutJSExt(inEngineSpecifier);
+        let entry = (_a = this.mergeMap.get(engine.root)) === null || _a === void 0 ? void 0 : _a.get(inEngineSpecifier);
+        switch (entry === null || entry === void 0 ? void 0 : entry.type) {
+            case undefined:
+                return undefined;
+            case 'app-only':
+                return request.alias(entry['app-js'].localPath).rehome((0, path_1.resolve)(entry['app-js'].packageRoot, 'package.json'));
+            case 'fastboot-only':
+                return request
+                    .alias(entry['fastboot-js'].localPath)
+                    .rehome((0, path_1.resolve)(entry['fastboot-js'].packageRoot, 'package.json'));
+            case 'both':
+                let foundAppJS = this.nodeResolve(entry['app-js'].localPath, (0, path_1.resolve)(entry['app-js'].packageRoot, 'package.json'));
+                if (foundAppJS.type !== 'real') {
+                    throw new Error(`${entry['app-js'].fromPackageName} declared ${inEngineSpecifier} in packageJSON.ember-addon.app-js, but that module does not exist`);
+                }
+                let { names } = (0, describe_exports_1.describeExports)((0, fs_1.readFileSync)(foundAppJS.filename, 'utf8'), {});
+                return request.virtualize((0, virtual_content_1.fastbootSwitch)(request.specifier, request.fromFile, names));
+        }
     }
     // check whether the given file with the given owningPackage is an addon's
     // appTree, and if so return the notional location within the app (or owning
@@ -512,12 +731,14 @@ class Resolver {
         // if the requesting file is in an addon's app-js, the request should
         // really be understood as a request for a module in the containing engine
         if (owningPackage.isV2Addon()) {
-            let appJS = owningPackage.meta['app-js'];
-            if (appJS) {
-                let fromPackageRelativePath = (0, shared_internals_2.explicitRelative)(owningPackage.root, fromFile);
-                for (let [inAppName, inAddonName] of Object.entries(appJS)) {
-                    if (inAddonName === fromPackageRelativePath) {
-                        return { owningEngine: this.owningEngine(owningPackage), inAppName };
+            let sections = [owningPackage.meta['app-js'], owningPackage.meta['fastboot-js']];
+            for (let section of sections) {
+                if (section) {
+                    let fromPackageRelativePath = (0, shared_internals_2.explicitRelative)(owningPackage.root, fromFile);
+                    for (let [inAppName, inAddonName] of Object.entries(section)) {
+                        if (inAddonName === fromPackageRelativePath) {
+                            return { owningEngine: this.owningEngine(owningPackage), inAppName };
+                        }
                     }
                 }
             }
@@ -561,6 +782,12 @@ class Resolver {
         return undefined;
     }
 }
+__decorate([
+    (0, typescript_memoize_1.Memoize)()
+], Resolver.prototype, "mergeMap", null);
+__decorate([
+    (0, typescript_memoize_1.Memoize)()
+], Resolver.prototype, "legacyAddonsIndex", null);
 exports.Resolver = Resolver;
 function isExplicitlyExternal(specifier, fromPkg) {
     return Boolean(fromPkg.isV2Addon() && fromPkg.meta['externals'] && fromPkg.meta['externals'].includes(specifier));
@@ -582,8 +809,19 @@ function reliablyResolvable(pkg, packageName) {
     }
     return false;
 }
+//
+function appImportInAppTree(inPackage, inLogicalPackage, importedPackageName) {
+    return inPackage !== inLogicalPackage && importedPackageName === inLogicalPackage.name;
+}
 function external(label, request, specifier) {
     let filename = (0, virtual_content_1.virtualExternalModule)(specifier);
     return logTransition(label, request, request.virtualize(filename));
 }
+// this is specifically for app-js handling, where only .js and .hbs are legal
+// extensiosn, and only .js is allowed to be an *implied* extension (.hbs must
+// be explicit). So when normalizing such paths, it's only a .js suffix that we
+// must remove.
+function withoutJSExt(filename) {
+    return filename.replace(/\.js$/, '');
+}
 //# sourceMappingURL=module-resolver.js.map