@embroider/core 4.1.3 → 4.2.0

package/dist/src/module-resolver.js

@@ -388,6 +388,8 @@ class Resolver {
                 return this.resolveModifier(rest, engine, request);
             case 'ambiguous':
                 return this.resolveHelperOrComponent(rest, engine, request);
+            case 'compat-modules':
+                return request;
             default:
                 throw new Error(`bug: unexepected @embroider/virtual specifier: ${request.specifier}`);
         }
@@ -733,7 +735,7 @@ class Resolver {
         }
         if (pkg.name === packageName) {
             // we found a self-import
-            if ((_a = pkg.meta) === null || _a === void 0 ? void 0 : _a['auto-upgraded']) {
+            if (((_a = pkg.meta) === null || _a === void 0 ? void 0 : _a['auto-upgraded']) && !pkg.isEngine()) {
                 // auto-upgraded packages always get automatically adjusted. They never
                 // supported fancy package.json exports features so this direct mapping
                 // to the root is always right.
@@ -745,6 +747,15 @@ class Resolver {
                     // auto-upgraded addons get special support for self-resolving here.
                     return logTransition(`v1 addon self-import`, request, request.rehome(addonConfig.canResolveFromFile));
                 }
+                else if (owningEngine.root === pkg.root) {
+                    for (let engineConfig of this.options.engines) {
+                        for (let activeAddon of engineConfig.activeAddons) {
+                            if (activeAddon.root === pkg.root) {
+                                return logTransition(`v1 engine self-import`, request, request.rehome(activeAddon.canResolveFromFile));
+                            }
+                        }
+                    }
+                }
                 else {
                     // auto-upgraded apps will necessarily have packageJSON.exports
                     // because we insert them, so for that support we can fall through to
@@ -901,10 +912,16 @@ class Resolver {
             // here.
             return request;
         }
+        let abortFallback = (() => {
+            const unmodified = request;
+            // Whenever fallbackResolve gives up, it should return the original
+            // unmodifiedRequest so that we communicate clearly that no further
+            // fallbacks should be attempted. Internally, we track a modifiedRequest
+            // that has been adjusted to compensate for rehoming.
+            return (desc) => logTransition(desc, unmodified);
+        })();
+        request = this.restoreRehomedRequest(request);
         let pkg = this.packageCache.ownerOfFile(request.fromFile);
-        if (pkg) {
-            ({ pkg, request } = this.restoreRehomedRequest(pkg, request));
-        }
         if (!(pkg === null || pkg === void 0 ? void 0 : pkg.isV2Ember())) {
             // this request is coming from a file that appears to be owned by no ember
             // package. We offer one fallback behavior for such files. They're allowed
@@ -918,12 +935,12 @@ class Resolver {
             if (packageName === this.options.modulePrefix) {
                 return logTransition(`fallbackResolver: ${description} resolved app namespace`, request, request.rehome(this.packageCache.maybeMoved(this.packageCache.get(this.options.appRoot)).root));
             }
-            return logTransition(`fallbackResolver: ${description}`, request);
+            return abortFallback(`fallbackResolver: ${description}`);
         }
         let packageName = (0, shared_internals_1.packageName)(request.specifier);
         if (!packageName) {
             // this is a relative import
-            return this.relativeFallbackResolve(pkg, request);
+            return this.relativeFallbackResolve(pkg, request, abortFallback);
         }
         if (pkg.needsLooseResolving()) {
             let activeAddon = this.maybeFallbackToActiveAddon(request, packageName);
@@ -954,44 +971,39 @@ 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 logTransition('fallbackResolve final exit', request);
+        return abortFallback('fallbackResolve final exit');
     }
-    restoreRehomedRequest(pkg, request) {
+    restoreRehomedRequest(request) {
         var _a;
         // meta.originalFromFile gets set when we want to try to rehome a request
         // but then come back to the original location here in the fallback when the
         // rehomed request fails
-        let movedPkg = this.packageCache.maybeMoved(pkg);
-        if (movedPkg !== pkg) {
-            let originalFromFile = (_a = request.meta) === null || _a === void 0 ? void 0 : _a.originalFromFile;
-            if (typeof originalFromFile !== 'string') {
-                throw new Error(`bug: embroider resolver's meta is not propagating`);
-            }
-            request = request.rehome(originalFromFile);
-            pkg = movedPkg;
+        let originalFromFile = (_a = request.meta) === null || _a === void 0 ? void 0 : _a.originalFromFile;
+        if (typeof originalFromFile === 'string') {
+            return request.rehome(originalFromFile);
         }
-        return { pkg, request };
+        return request;
     }
-    async relativeFallbackResolve(pkg, request) {
+    async relativeFallbackResolve(pkg, request, abortFallback) {
         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 logicalName = engineRelativeName(pkg, (0, path_1.resolve)((0, path_1.dirname)(request.fromFile), request.specifier));
             if (!logicalName) {
-                return logTransition('fallbackResolve: relative failure because this file is not externally accessible', request);
+                return abortFallback('fallbackResolve: relative failure because this file is not externally accessible');
             }
             let appJSMatch = await this.searchAppTree(request, withinEngine, logicalName);
             if (appJSMatch) {
                 return logTransition('fallbackResolve: relative appJsMatch', request, appJSMatch);
             }
             else {
-                return logTransition('fallbackResolve: relative appJs search failure', request);
+                return abortFallback('fallbackResolve: relative appJs search failure');
             }
         }
         else {
             // nothing else to do for relative imports
-            return logTransition('fallbackResolve: relative failure', request);
+            return abortFallback('fallbackResolve: relative failure');
         }
     }
     maybeFallbackToActiveAddon(request, requestedPackageName) {