update

packages/core/src/module-resolver.ts

@@ -194,6 +194,7 @@ export class Resolver {
       return this.external('early require', request, request.specifier);
     }
 
+    request = this.decodeEncodedRequest(request);
     request = this.handleFastbootSwitch(request);
     request = await this.handleGlobalsCompat(request);
     request = this.handleImplicitModules(request);
@@ -283,6 +284,22 @@ export class Resolver {
     return RewrittenPackageCache.shared('embroider', this.options.appRoot);
   }
 
+  generateEncodedRequest<R extends ModuleRequest>(request: R): R {
+    let prefix = '@embroider/encoded-request/';
+    let specifier = `${prefix}${request.fromFile}/-embroider-to-/${request.specifier}`;
+    return request.alias(specifier);
+  }
+
+  decodeEncodedRequest<R extends ModuleRequest>(request: R): R {
+    let prefix = '@embroider/encoded-request/';
+    if (request.specifier.startsWith(prefix)) {
+      let specifier = request.specifier.slice(prefix.length);
+      let [from, to] = specifier.split('/-embroider-to-/');
+      return request.alias(to).rehome(from);
+    }
+    return request;
+  }
+
   private logicalPackage(owningPackage: V2Package, file: string): V2Package {
     let logicalLocation = this.reverseSearchAppTree(owningPackage, file);
     if (logicalLocation) {
@@ -651,11 +668,14 @@ export class Resolver {
       );
 
       if (resolution.type === 'ignored') {
-        return logTransition(`resolving to ignored component`, request, request.resolveTo(resolution));
+        return logTransition(`resolving to ignored template`, request, request.resolveTo(resolution));
       }
 
       if (resolution.type === 'found') {
-        if (resolution.filename.includes('.vite/deps')) {
+        let pkg = this.packageCache.ownerOfFile(resolution.filename);
+        // if we resolve to something that is not from an addon then
+        // we resolved to an optimised dep
+        if (!pkg?.isV2Ember()) {
           return request.resolveTo(resolution);
         }
         hbsModule = resolution;

packages/vite/src/esbuild-request.ts

@@ -146,27 +146,39 @@ export class EsBuildModuleRequest implements ModuleRequest {
 
     requestStatus(request.specifier);
 
-    let result = await this.context.resolve(request.specifier, {
-      importer: request.fromFile,
-      resolveDir: dirname(request.fromFile),
-      kind: this.kind,
-      pluginData: {
-        embroider: {
-          enableCustomResolver: false,
-          meta: request.meta,
+    const extensions = ['', '.hbs'];
+    let lastResult: Resolution<OnResolveResult, OnResolveResult>;
+
+    for (const extension of extensions) {
+      let result = await this.context.resolve(request.specifier + extension, {
+        importer: request.fromFile,
+        resolveDir: dirname(request.fromFile),
+        kind: this.kind,
+        pluginData: {
+          embroider: {
+            enableCustomResolver: false,
+            meta: request.meta,
+          },
         },
-      },
-    });
+      });
 
-    let status = readStatus(request.specifier);
+      let status = '';
 
-    if (result.errors.length > 0 || status === 'not_found') {
-      return { type: 'not_found', err: result };
-    } else if (result.external) {
-      return { type: 'ignored', result };
-    } else {
-      return { type: 'found', filename: result.path, result, isVirtual: this.isVirtual };
+      if (!request.specifier.startsWith('.')) {
+        status = readStatus(request.specifier + extension)
+      }
+
+      console.log(`search extension ${extension} with ${request.specifier}: `, request.fromFile, result, status);
+
+      if (result.errors.length > 0 || status === 'not_found') {
+        lastResult = { type: 'not_found', err: result };
+      } else if (result.external) {
+        return { type: 'ignored', result };
+      } else {
+        return { type: 'found', filename: result.path, result, isVirtual: this.isVirtual };
+      }
     }
+    return lastResult!;
   }
 }
 

packages/vite/src/esbuild-resolver.ts

@@ -1,15 +1,11 @@
 import type { Plugin as EsBuildPlugin, OnLoadResult } from 'esbuild';
 import { transform } from '@babel/core';
-import { ResolverLoader, virtualContent, needsSyntheticComponentJS } from '@embroider/core';
+import { ResolverLoader, virtualContent } from '@embroider/core';
 import { readFileSync } from 'fs-extra';
 import { EsBuildModuleRequest } from './esbuild-request';
 import assertNever from 'assert-never';
 import { hbsToJS } from '@embroider/core';
 import { Preprocessor } from 'content-tag';
-import { RollupModuleRequest } from './request';
-
-const templateOnlyComponent =
-  `import templateOnly from '@ember/component/template-only';\n` + `export default templateOnly();\n`;
 
 export function esBuildResolver(): EsBuildPlugin {
   let resolverLoader = new ResolverLoader(process.cwd());
@@ -25,9 +21,7 @@ export function esBuildResolver(): EsBuildPlugin {
 
   function onLoad({ path, namespace }: { path: string; namespace: string }): OnLoadResult {
     let src: string;
-    if (namespace === 'embroider-template-only-component') {
-      src = templateOnlyComponent;
-    } else if (namespace === 'embroider-virtual') {
+    if (namespace === 'embroider-virtual') {
       src = virtualContent(path, resolverLoader.resolver).src;
     } else {
       src = readFileSync(path, 'utf8');
@@ -56,28 +50,16 @@ export function esBuildResolver(): EsBuildPlugin {
         switch (resolution.type) {
           case 'found':
             // if some addon imports app files we do not want to bundle it
-            const filename = resolution.filename.replace(/\\/g, '/');
-            const fromFile = importer.replace(/\\/, '/');
-            const isInNodeModules = filename.includes('/node_modules/') || filename.includes('@embroider/ext-es');
-            if (!isInNodeModules && fromFile !== '<stdin>') {
-              const isFromApp = !fromFile.includes('/node_modules/');
-              if (!isFromApp) {
-                if (resolution.isVirtual) {
-                  return {
-                    path: RollupModuleRequest.from(null, resolution.filename, request.fromFile, {})!.virtualize(
-                      resolution.filename
-                    ).specifier,
-                    external: true,
-                  };
-                }
-                if (resolution.result.namespace === 'file') {
-                  return {
-                    path: resolution.filename,
-                    external: true,
-                  };
-                }
-                return null;
-              }
+            // we only need to do this for addons in node modules, not in-repo addons
+            let pkgCache = resolverLoader.resolver.packageCache;
+            let fromPkg = pkgCache.ownerOfFile(request.fromFile);
+            let toPkg = pkgCache.ownerOfFile(resolution.filename);
+            if (toPkg?.isV2App() && !fromPkg?.isV2App()) {
+              let encoded = resolverLoader.resolver.generateEncodedRequest(request);
+              return {
+                path: encoded.specifier,
+                external: true,
+              };
             }
           case 'ignored':
             return resolution.result;
@@ -88,39 +70,7 @@ export function esBuildResolver(): EsBuildPlugin {
         }
       });
 
-      // template-only-component synthesis
-      build.onResolve({ filter: /./ }, async ({ path, importer, namespace, resolveDir, pluginData, kind }) => {
-        if (pluginData?.embroiderExtensionResolving) {
-          // reentrance
-          return null;
-        }
-
-        // vite resolver does not take part when optimizing deps
-        const extensions = ['', '.hbs'];
-        for (const extension of extensions) {
-          let result = await build.resolve(path + extension, {
-            namespace,
-            resolveDir,
-            importer,
-            kind,
-            // avoid reentrance
-            pluginData: { ...pluginData, embroiderExtensionResolving: true },
-          });
-          if (result.errors.length) continue;
-          if (result.errors.length === 0 && !result.external) {
-            let syntheticPath = needsSyntheticComponentJS(path, result.path, resolverLoader.resolver.packageCache);
-            if (syntheticPath) {
-              return { path: syntheticPath, namespace: 'embroider-template-only-component' };
-            }
-          }
-          return result;
-        }
-      });
-
-      // we need to handle everything from one of our three special namespaces:
-      build.onLoad({ namespace: 'embroider-template-only-component', filter: /./ }, onLoad);
       build.onLoad({ namespace: 'embroider-virtual', filter: /./ }, onLoad);
-      build.onLoad({ namespace: 'embroider-template-tag', filter: /./ }, onLoad);
 
       // we need to handle all hbs
       build.onLoad({ filter: /\.hbs$/ }, onLoad);

packages/webpack/src/ember-webpack.ts

@@ -554,7 +554,7 @@ const Webpack: PackagerConstructor<Options> = class Webpack implements Packager
             // write all the stats output to the console
             this.consoleWrite(
               stats.toString({
-                color: Boolean(supportsColor.stdout),
+                colors: Boolean(supportsColor.stdout),
               })
             );
 
@@ -564,7 +564,7 @@ const Webpack: PackagerConstructor<Options> = class Webpack implements Packager
           if (stats.hasWarnings() || process.env.VANILLA_VERBOSE) {
             this.consoleWrite(
               stats.toString({
-                color: Boolean(supportsColor.stdout),
+                colors: Boolean(supportsColor.stdout),
               })
             );
           }

tests/scenarios/helpers/command-watcher.ts

@@ -21,6 +21,7 @@ export default class CommandWatcher {
 
   constructor(private process: ExecaChildProcess) {
     process.all!.on('data', data => {
+      console.log(data.toString());
       const lines = data.toString().split(/\r?\n/);
       this.lines.push(...lines);
       this.currentWaiter?.();