@embroider/compat 3.4.8-unstable.fad2387 → 3.4.8

package/src/compat-app-builder.js

@@ -34,6 +34,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CompatAppBuilder = void 0;
 const core_1 = require("@embroider/core");
+const walk_sync_1 = __importDefault(require("walk-sync"));
 const path_1 = require("path");
 const dependency_rules_1 = require("./dependency-rules");
 const flatMap_1 = __importDefault(require("lodash/flatMap"));
@@ -61,14 +62,13 @@ const sync_dir_1 = require("./sync-dir");
 // This exists during the actual broccoli build step. As opposed to CompatApp,
 // which also exists during pipeline-construction time.
 class CompatAppBuilder {
-    constructor(root, origAppPackage, appPackageWithMovedDeps, options, compatApp, configTree, contentForTree, synthVendor, synthStyles) {
+    constructor(root, origAppPackage, appPackageWithMovedDeps, options, compatApp, configTree, synthVendor, synthStyles) {
         this.root = root;
         this.origAppPackage = origAppPackage;
         this.appPackageWithMovedDeps = appPackageWithMovedDeps;
         this.options = options;
         this.compatApp = compatApp;
         this.configTree = configTree;
-        this.contentForTree = contentForTree;
         this.synthVendor = synthVendor;
         this.synthStyles = synthStyles;
         // for each relativePath, an Asset we have already emitted
@@ -83,6 +83,22 @@ class CompatAppBuilder {
     }
     extractAssets(treePaths) {
         let assets = [];
+        // Everything in our traditional public tree is an on-disk asset
+        if (treePaths.publicTree) {
+            walk_sync_1.default
+                .entries(treePaths.publicTree, {
+                directories: false,
+            })
+                .forEach(entry => {
+                assets.push({
+                    kind: 'on-disk',
+                    relativePath: entry.relativePath,
+                    sourcePath: entry.fullPath,
+                    mtime: entry.mtime,
+                    size: entry.size,
+                });
+            });
+        }
         // ember-cli traditionally outputs a dummy testem.js file to prevent
         // spurious errors when running tests under "ember s".
         if (this.compatApp.shouldBuildTests) {
@@ -161,7 +177,7 @@ class CompatAppBuilder {
         // For TS, we defer to ember-cli-babel, and the setting for
         // "enableTypescriptTransform" can be set with and without
         // ember-cli-typescript
-        return ['.wasm', '.mjs', '.js', '.json', '.ts', '.hbs', '.hbs.js', '.gjs', '.gts'];
+        return ['.wasm', '.mjs', '.js', '.json', '.ts', '.hbs', '.hbs.js'];
     }
     *emberEntrypoints(htmlTreePath) {
         let classicEntrypoints = [
@@ -217,6 +233,10 @@ class CompatAppBuilder {
     resolverConfig(engines) {
         let renamePackages = Object.assign({}, ...this.allActiveAddons.map(dep => dep.meta['renamed-packages']));
         let renameModules = Object.assign({}, ...this.allActiveAddons.map(dep => dep.meta['renamed-modules']));
+        let activeAddons = {};
+        for (let addon of this.allActiveAddons) {
+            activeAddons[addon.name] = addon.root;
+        }
         let options = {
             staticHelpers: this.options.staticHelpers,
             staticModifiers: this.options.staticModifiers,
@@ -225,6 +245,7 @@ class CompatAppBuilder {
         };
         let config = {
             // this part is the base ModuleResolverOptions as required by @embroider/core
+            activeAddons,
             renameModules,
             renamePackages,
             resolvableExtensions: this.resolvableExtensions(),
@@ -236,16 +257,14 @@ class CompatAppBuilder {
                 root: (0, fs_extra_1.realpathSync)(index === 0 ? this.root : appFiles.engine.package.root),
                 fastbootFiles: appFiles.fastbootFiles,
                 activeAddons: [...appFiles.engine.addons]
-                    .map(([addon, canResolveFromFile]) => ({
-                    name: addon.name,
-                    root: addon.root,
-                    canResolveFromFile,
+                    .map(a => ({
+                    name: a.name,
+                    root: a.root,
                 }))
                     // the traditional order is the order in which addons will run, such
                     // that the last one wins. Our resolver's order is the order to
                     // search, so first one wins.
                     .reverse(),
-                isLazy: appFiles.engine.package.isLazyEngine(),
             })),
             amdCompatibility: this.options.amdCompatibility,
             // this is the additional stufff that @embroider/compat adds on top to do
@@ -298,11 +317,35 @@ class CompatAppBuilder {
                 source: `loader.makeDefaultExport=false;`,
             });
         }
+        if (type === 'implicit-test-scripts') {
+            // this is the traditional test-support-suffix.js
+            result.push({
+                kind: 'in-memory',
+                relativePath: '_testing_suffix_.js',
+                source: `
+        var runningTests=true;
+        if (typeof Testem !== 'undefined' && (typeof QUnit !== 'undefined' || typeof Mocha !== 'undefined')) {
+          Testem.hookIntoTestFramework();
+        }`,
+            });
+            // whether or not anybody was actually using @embroider/macros
+            // explicitly as an addon, we ensure its test-support file is always
+            // present.
+            if (!result.find(s => s.kind === 'on-disk' && s.sourcePath.endsWith('embroider-macros-test-support.js'))) {
+                result.unshift({
+                    kind: 'on-disk',
+                    sourcePath: require.resolve('@embroider/macros/src/vendor/embroider-macros-test-support'),
+                    mtime: 0,
+                    size: 0,
+                    relativePath: 'embroider-macros-test-support.js',
+                });
+            }
+        }
         return result;
     }
     impliedAddonAssets(type, { engine }) {
         let result = [];
-        for (let addon of (0, sortBy_1.default)(Array.from(engine.addons.keys()), this.scriptPriority.bind(this))) {
+        for (let addon of (0, sortBy_1.default)(Array.from(engine.addons), this.scriptPriority.bind(this))) {
             let implicitScripts = addon.meta[type];
             if (implicitScripts) {
                 let styles = [];
@@ -325,7 +368,7 @@ class CompatAppBuilder {
         }
         return result;
     }
-    async babelConfig(resolverConfig) {
+    babelConfig(resolverConfig) {
         let babel = (0, cloneDeep_1.default)(this.compatApp.babelConfig());
         if (!babel.plugins) {
             babel.plugins = [];
@@ -335,10 +378,7 @@ class CompatAppBuilder {
         babel.plugins.push(require.resolve('@babel/plugin-syntax-dynamic-import'));
         // https://github.com/webpack/webpack/issues/12154
         babel.plugins.push(require.resolve('./rename-require-plugin'));
-        babel.plugins.push([
-            require.resolve('babel-plugin-ember-template-compilation'),
-            await this.etcOptions(resolverConfig),
-        ]);
+        babel.plugins.push([require.resolve('babel-plugin-ember-template-compilation'), this.etcOptions(resolverConfig)]);
         // this is @embroider/macros configured for full stage3 resolution
         babel.plugins.push(...this.compatApp.macrosConfig.babelPluginConfig());
         let colocationOptions = {
@@ -414,7 +454,7 @@ class CompatAppBuilder {
             }
         }
         html.insertStyleLink(html.styles, `assets/${this.origAppPackage.name}.css`);
-        const parentEngine = appFiles.find(e => e.engine.isApp);
+        const parentEngine = appFiles.find(e => !e.engine.parent);
         let vendorJS = this.implicitScriptsAsset(prepared, parentEngine, emberENV);
         if (vendorJS) {
             html.insertScriptTag(html.implicitScripts, vendorJS.relativePath);
@@ -427,17 +467,24 @@ class CompatAppBuilder {
                 html.insertScriptTag(html.implicitScripts, script, { tag: 'fastboot-script' });
             }
         }
-        // virtual vendor.css entrypoint
-        html.insertStyleLink(html.implicitStyles, '@embroider/core/vendor.css');
+        let implicitStyles = this.implicitStylesAsset(prepared, parentEngine);
+        if (implicitStyles) {
+            html.insertStyleLink(html.implicitStyles, implicitStyles.relativePath);
+        }
         if (!asset.fileAsset.includeTests) {
             return;
         }
         // Test-related assets happen below this point
         let testJS = this.testJSEntrypoint(appFiles, prepared);
         html.insertScriptTag(html.testJavascript, testJS.relativePath, { type: 'module' });
-        // virtual test-support.js
-        html.insertScriptTag(html.implicitTestScripts, '@embroider/core/test-support.js');
-        html.insertStyleLink(html.implicitTestStyles, '@embroider/core/test-support.css');
+        let implicitTestScriptsAsset = this.implicitTestScriptsAsset(prepared, parentEngine);
+        if (implicitTestScriptsAsset) {
+            html.insertScriptTag(html.implicitTestScripts, implicitTestScriptsAsset.relativePath);
+        }
+        let implicitTestStylesAsset = this.implicitTestStylesAsset(prepared, parentEngine);
+        if (implicitTestStylesAsset) {
+            html.insertStyleLink(html.implicitTestStyles, implicitTestStylesAsset.relativePath);
+        }
     }
     implicitScriptsAsset(prepared, application, emberENV) {
         let asset = prepared.get('assets/vendor.js');
@@ -450,6 +497,40 @@ class CompatAppBuilder {
         }
         return asset;
     }
+    implicitStylesAsset(prepared, application) {
+        let asset = prepared.get('assets/vendor.css');
+        if (!asset) {
+            let implicitStyles = this.impliedAssets('implicit-styles', application);
+            if (implicitStyles.length > 0) {
+                // we reverse because we want the synthetic vendor style at the top
+                asset = new ConcatenatedAsset('assets/vendor.css', implicitStyles.reverse(), this.resolvableExtensionsPattern);
+                prepared.set(asset.relativePath, asset);
+            }
+        }
+        return asset;
+    }
+    implicitTestScriptsAsset(prepared, application) {
+        let testSupportJS = prepared.get('assets/test-support.js');
+        if (!testSupportJS) {
+            let implicitTestScripts = this.impliedAssets('implicit-test-scripts', application);
+            if (implicitTestScripts.length > 0) {
+                testSupportJS = new ConcatenatedAsset('assets/test-support.js', implicitTestScripts, this.resolvableExtensionsPattern);
+                prepared.set(testSupportJS.relativePath, testSupportJS);
+            }
+        }
+        return testSupportJS;
+    }
+    implicitTestStylesAsset(prepared, application) {
+        let asset = prepared.get('assets/test-support.css');
+        if (!asset) {
+            let implicitTestStyles = this.impliedAssets('implicit-test-styles', application);
+            if (implicitTestStyles.length > 0) {
+                asset = new ConcatenatedAsset('assets/test-support.css', implicitTestStyles, this.resolvableExtensionsPattern);
+                prepared.set(asset.relativePath, asset);
+            }
+        }
+        return asset;
+    }
     // recurse to find all active addons that don't cross an engine boundary.
     // Inner engines themselves will be returned, but not those engines' children.
     // The output set's insertion order is the proper ember-cli compatible
@@ -459,31 +540,22 @@ class CompatAppBuilder {
             if (!child.isEngine()) {
                 this.findActiveAddons(child, engine, true);
             }
-            let canResolveFrom;
-            if (pkg === this.appPackageWithMovedDeps) {
-                // we want canResolveFrom to always be a rewritten package path, and our
-                // app's package is not rewritten yet here.
-                canResolveFrom = (0, path_1.resolve)(this.root, 'package.json');
-            }
-            else {
-                // whereas our addons are already moved
-                canResolveFrom = (0, path_1.resolve)(pkg.root, 'package.json');
-            }
-            engine.addons.set(child, canResolveFrom);
+            engine.addons.add(child);
         }
         // ensure addons are applied in the correct order, if set (via @embroider/compat/v1-addon)
         if (!isChild) {
-            engine.addons = new Map([...engine.addons].sort(([a], [b]) => {
+            engine.addons = new Set([...engine.addons].sort((a, b) => {
                 return (a.meta['order-index'] || 0) - (b.meta['order-index'] || 0);
             }));
         }
     }
-    partitionEngines() {
+    partitionEngines(appJSPath) {
         let queue = [
             {
                 package: this.appPackageWithMovedDeps,
-                addons: new Map(),
-                isApp: true,
+                addons: new Set(),
+                parent: undefined,
+                sourcePath: appJSPath,
                 modulePrefix: this.modulePrefix(),
                 appRelativePath: '.',
             },
@@ -496,13 +568,14 @@ class CompatAppBuilder {
                 break;
             }
             this.findActiveAddons(current.package, current);
-            for (let addon of current.addons.keys()) {
+            for (let addon of current.addons) {
                 if (addon.isEngine() && !seenEngines.has(addon)) {
                     seenEngines.add(addon);
                     queue.push({
                         package: addon,
-                        addons: new Map(),
-                        isApp: !current,
+                        addons: new Set(),
+                        parent: current,
+                        sourcePath: addon.root,
                         modulePrefix: addon.name,
                         appRelativePath: (0, core_1.explicitRelative)(this.root, addon.root),
                     });
@@ -528,8 +601,8 @@ class CompatAppBuilder {
     updateAppJS(appJSPath) {
         var _a;
         if (!this.engines) {
-            this.engines = this.partitionEngines().map(engine => {
-                if (engine.isApp) {
+            this.engines = this.partitionEngines(appJSPath).map(engine => {
+                if (engine.sourcePath === appJSPath) {
                     // this is the app. We have more to do for the app than for other
                     // engines.
                     let fastbootSync;
@@ -551,7 +624,7 @@ class CompatAppBuilder {
                     // their files, not doing any actual copying or building.
                     return {
                         engine,
-                        appSync: new sync_dir_1.SyncDir(engine.package.root, undefined),
+                        appSync: new sync_dir_1.SyncDir(engine.sourcePath, undefined),
                         // AFAIK, we've never supported a fastboot overlay directory in an
                         // engine. But if we do need that, it would go here.
                         fastbootSync: undefined,
@@ -691,6 +764,21 @@ class CompatAppBuilder {
     gatherAssets(inputPaths) {
         // first gather all the assets out of addons
         let assets = [];
+        for (let pkg of this.allActiveAddons) {
+            if (pkg.meta['public-assets']) {
+                for (let [filename, appRelativeURL] of Object.entries(pkg.meta['public-assets'] || {})) {
+                    let sourcePath = (0, path_1.resolve)(pkg.root, filename);
+                    let stats = (0, fs_extra_1.statSync)(sourcePath);
+                    assets.push({
+                        kind: 'on-disk',
+                        sourcePath,
+                        relativePath: appRelativeURL,
+                        mtime: stats.mtimeMs,
+                        size: stats.size,
+                    });
+                }
+            }
+        }
         if (this.activeFastboot) {
             const source = `
       (function(){
@@ -753,10 +841,8 @@ class CompatAppBuilder {
         (0, fs_extra_1.writeFileSync)((0, path_2.join)(this.root, 'package.json'), JSON.stringify(pkg, null, 2), 'utf8');
         let resolverConfig = this.resolverConfig(appFiles);
         this.addResolverConfig(resolverConfig);
-        this.addContentForConfig(this.contentForTree.readContents());
-        let babelConfig = await this.babelConfig(resolverConfig);
+        let babelConfig = this.babelConfig(resolverConfig);
         this.addBabelConfig(babelConfig);
-        (0, fs_extra_1.writeFileSync)((0, path_2.join)(this.root, 'macros-config.json'), JSON.stringify(this.compatApp.macrosConfig.babelPluginConfig()[0], null, 2));
     }
     combinePackageJSON(meta) {
         let pkgLayers = [this.origAppPackage.packageJSON];
@@ -769,7 +855,7 @@ class CompatAppBuilder {
         pkgLayers.push({ keywords: ['ember-addon'], 'ember-addon': meta });
         return combinePackageJSON(...pkgLayers);
     }
-    async etcOptions(resolverConfig) {
+    etcOptions(resolverConfig) {
         let transforms = this.compatApp.htmlbarsPlugins;
         let { plugins: macroPlugins, setConfig } = node_1.MacrosConfig.transforms();
         setConfig(this.compatApp.macrosConfig);
@@ -786,7 +872,7 @@ class CompatAppBuilder {
             transforms.push([require.resolve('./resolver-transform'), opts]);
         }
         let resolver = new core_1.Resolver(resolverConfig);
-        let resolution = await resolver.nodeResolve('ember-source/vendor/ember/ember-template-compiler', (0, path_1.resolve)(this.root, 'package.json'));
+        let resolution = resolver.nodeResolve('ember-source/vendor/ember/ember-template-compiler', (0, path_1.resolve)(this.root, 'package.json'));
         if (resolution.type !== 'real') {
             throw new Error(`bug: unable to resolve ember-template-compiler from ${this.root}`);
         }
@@ -823,11 +909,6 @@ class CompatAppBuilder {
     addResolverConfig(config) {
         (0, fs_extra_1.outputJSONSync)((0, path_2.join)((0, core_1.locateEmbroiderWorkingDir)(this.compatApp.root), 'resolver.json'), config, { spaces: 2 });
     }
-    addContentForConfig(contentForConfig) {
-        (0, fs_extra_1.outputJSONSync)((0, path_2.join)((0, core_1.locateEmbroiderWorkingDir)(this.compatApp.root), 'content-for.json'), contentForConfig, {
-            spaces: 2,
-        });
-    }
     shouldSplitRoute(routeName) {
         return (!this.options.splitAtRoutes ||
             this.options.splitAtRoutes.find(pattern => {
@@ -933,7 +1014,7 @@ class CompatAppBuilder {
         let styles = [];
         // only import styles from engines with a parent (this excludeds the parent application) as their styles
         // will be inserted via a direct <link> tag.
-        if (!appFiles.engine.isApp && appFiles.engine.package.isLazyEngine()) {
+        if (appFiles.engine.parent && appFiles.engine.package.isLazyEngine()) {
             let implicitStyles = this.impliedAssets('implicit-styles', appFiles);
             for (let style of implicitStyles) {
                 styles.push({
@@ -980,16 +1061,10 @@ class CompatAppBuilder {
         let [fastboot, nonFastboot] = (0, partition_1.default)(excludeDotFiles((0, flatten_1.default)(requiredAppFiles)), file => appFiles.isFastbootOnly.get(file));
         let amdModules = nonFastboot.map(file => this.importPaths(appFiles, file));
         let fastbootOnlyAmdModules = fastboot.map(file => this.importPaths(appFiles, file));
-        let params = {
-            amdModules,
-            fastbootOnlyAmdModules,
-            lazyRoutes,
-            lazyEngines,
-            eagerModules,
-            styles,
-            // this is a backward-compatibility feature: addons can force inclusion of modules.
-            defineModulesFrom: './-embroider-implicit-modules.js',
-        };
+        // this is a backward-compatibility feature: addons can force inclusion of
+        // modules.
+        eagerModules.push('./-embroider-implicit-modules.js');
+        let params = { amdModules, fastbootOnlyAmdModules, lazyRoutes, lazyEngines, eagerModules, styles };
         if (entryParams) {
             Object.assign(params, entryParams);
         }
@@ -1041,6 +1116,9 @@ class CompatAppBuilder {
             (0, core_1.explicitRelative)((0, path_2.dirname)(myName), this.topAppJSAsset(appFiles, prepared).relativePath),
         ];
         let amdModules = [];
+        // this is a backward-compatibility feature: addons can force inclusion of
+        // test support modules.
+        eagerModules.push('./-embroider-implicit-test-modules.js');
         for (let relativePath of engine.tests) {
             amdModules.push(this.importPaths(engine, relativePath));
         }
@@ -1048,8 +1126,6 @@ class CompatAppBuilder {
             amdModules,
             eagerModules,
             testSuffix: true,
-            // this is a backward-compatibility feature: addons can force inclusion of test support modules.
-            defineModulesFrom: './-embroider-implicit-test-modules.js',
         });
         asset = {
             kind: 'in-memory',
@@ -1121,15 +1197,6 @@ let d = w.define;
   }
 {{/if}}
 
-{{#if defineModulesFrom ~}}
-  import implicitModules from "{{js-string-escape defineModulesFrom}}";
-
-  for(const [name, module] of Object.entries(implicitModules)) {
-    d(name, function() { return module });
-  }
-{{/if}}
-
-
 {{#each eagerModules as |eagerModule| ~}}
   i("{{js-string-escape eagerModule}}");
 {{/each}}
@@ -1140,17 +1207,9 @@ let d = w.define;
 
 {{#if fastbootOnlyAmdModules}}
   if (macroCondition(getGlobalConfig().fastboot?.isRunning)) {
-    let fastbootModules = {};
-
     {{#each fastbootOnlyAmdModules as |amdModule| ~}}
-      fastbootModules["{{js-string-escape amdModule.runtime}}"] = import("{{js-string-escape amdModule.buildtime}}");
+      d("{{js-string-escape amdModule.runtime}}", function(){ return i("{{js-string-escape amdModule.buildtime}}");});
     {{/each}}
-
-    const resolvedValues = await Promise.all(Object.values(fastbootModules));
-
-    Object.keys(fastbootModules).forEach((k, i) => {
-      d(k, function(){ return resolvedValues[i];});
-    })
   }
 {{/if}}