@embroider/compat 1.9.0 → 2.0.0

package/src/resolver.js

@@ -15,9 +15,9 @@ const core_1 = require("@embroider/core");
 const path_1 = require("path");
 const typescript_memoize_1 = require("typescript-memoize");
 const dasherize_component_name_1 = require("./dasherize-component-name");
-const resolver_transform_1 = require("./resolver-transform");
 const fs_extra_1 = require("fs-extra");
 const resolve_1 = __importDefault(require("resolve"));
+const semver_1 = __importDefault(require("semver"));
 // TODO: this depends on the ember version. And it's probably missing some
 // private-but-used values.
 const builtInHelpers = [
@@ -78,7 +78,6 @@ exports.rehydrate = rehydrate;
 class CompatResolver {
     constructor(params) {
         this.params = params;
-        this.dependencies = new Map();
         this.params.options = extractOptions(this.params.options);
         this._parallelBabel = {
             requireFile: __filename,
@@ -89,23 +88,6 @@ class CompatResolver {
             this.auditHandler = globalThis.embroider_audit;
         }
     }
-    enter(moduleName, contents) {
-        let rules = this.findComponentRules(moduleName);
-        let deps;
-        if (rules === null || rules === void 0 ? void 0 : rules.dependsOnComponents) {
-            deps = rules.dependsOnComponents.map(snippet => this.resolveComponentSnippet(snippet, rules, moduleName));
-        }
-        else {
-            deps = [];
-        }
-        this.dependencies.set(moduleName, deps);
-        this.currentContents = contents;
-    }
-    add(resolution, from) {
-        // this "!" is safe because we always `enter()` a module before hitting this
-        this.dependencies.get(from).push(resolution);
-        return resolution;
-    }
     findComponentRules(absPath) {
         let rules = this.rules.components.get(absPath);
         if (rules) {
@@ -140,9 +122,7 @@ class CompatResolver {
             : params.adjustImportsOptions;
     }
     get rules() {
-        if (!this.templateCompiler) {
-            throw new Error(`Bug: Resolver needs to get linked into a TemplateCompiler before it can understand packageRules`);
-        }
+        var _a;
         // keyed by their first resolved dependency's runtimeName.
         let components = new Map();
         // keyed by our own dasherized interpretation of the component's name.
@@ -157,7 +137,9 @@ class CompatResolver {
                         ignoredComponents.push(this.standardDasherize(snippet, rule));
                         continue;
                     }
-                    let resolvedDep = this.resolveComponentSnippet(snippet, rule).modules[0];
+                    let resolvedSnippet = this.resolveComponentSnippet(snippet, rule);
+                    // cast is OK here because a component must have one or the other
+                    let resolvedDep = ((_a = resolvedSnippet.hbsModule) !== null && _a !== void 0 ? _a : resolvedSnippet.jsModule);
                     let processedRules = (0, dependency_rules_1.preprocessComponentRule)(componentRules);
                     // we always register our rules on the component's own first resolved
                     // module, which must be a module in the app's module namespace.
@@ -197,9 +179,6 @@ class CompatResolver {
         return { components, ignoredComponents };
     }
     resolveComponentSnippet(snippet, rule, from = 'rule-snippet.hbs') {
-        if (!this.templateCompiler) {
-            throw new Error(`bug: tried to use resolveComponentSnippet without a templateCompiler`);
-        }
         let name = this.standardDasherize(snippet, rule);
         let found = this.tryComponent(name, from, false);
         if (found && found.type === 'component') {
@@ -208,73 +187,50 @@ class CompatResolver {
         throw new Error(`unable to locate component ${snippet} referred to in rule ${JSON.stringify(rule, null, 2)}`);
     }
     standardDasherize(snippet, rule) {
-        if (!this.templateCompiler) {
-            throw new Error(`bug: tried to use resolveComponentSnippet without a templateCompiler`);
-        }
-        let ast;
-        try {
-            ast = this.templateCompiler.parse('snippet.hbs', snippet);
-        }
-        catch (err) {
+        let name = (0, dasherize_component_name_1.snippetToDasherizedName)(snippet);
+        if (name == null) {
             throw new Error(`unable to parse component snippet "${snippet}" from rule ${JSON.stringify(rule, null, 2)}`);
         }
-        if ((ast.type === 'Program' || ast.type === 'Template') && ast.body.length > 0) {
-            let first = ast.body[0];
-            const isMustachePath = first.type === 'MustacheStatement' && first.path.type === 'PathExpression';
-            const isComponent = isMustachePath && first.path.original === 'component';
-            const hasStringParam = isComponent &&
-                Array.isArray(first.params) &&
-                first.params[0].type === 'StringLiteral';
-            if (isMustachePath && isComponent && hasStringParam) {
-                return first.params[0].value;
-            }
-            if (isMustachePath) {
-                return first.path.original;
-            }
-            if (first.type === 'ElementNode') {
-                return (0, dasherize_component_name_1.dasherize)(first.tag);
-            }
-        }
-        throw new Error(`cannot identify a component in rule snippet: "${snippet}"`);
+        return name;
     }
-    astTransformer(templateCompiler) {
-        this.templateCompiler = templateCompiler;
+    astTransformer() {
         if (this.staticComponentsEnabled || this.staticHelpersEnabled || this.staticModifiersEnabled) {
-            return (0, resolver_transform_1.makeResolverTransform)(this);
+            let opts = {
+                resolver: this,
+                // lexical invocation of helpers was not reliable before Ember 4.2 due to https://github.com/emberjs/ember.js/pull/19878
+                patchHelpersBug: semver_1.default.satisfies(this.params.emberVersion, '<4.2.0-beta.0', {
+                    includePrerelease: true,
+                }),
+            };
+            return [require.resolve('./resolver-transform'), opts];
         }
     }
-    dependenciesOf(moduleName) {
-        let flatDeps = new Map();
-        let deps = this.dependencies.get(moduleName);
-        if (deps) {
-            for (let dep of deps) {
-                if (dep.type === 'error') {
-                    if (!this.auditHandler && !this.params.options.allowUnsafeDynamicComponents) {
-                        let e = new Error(`${dep.message}: ${dep.detail} in ${humanReadableFile(this.params.root, moduleName)}`);
-                        e.isTemplateResolverError = true;
-                        e.loc = dep.loc;
-                        e.moduleName = moduleName;
-                        throw e;
-                    }
-                    if (this.auditHandler) {
-                        this.auditHandler({
-                            message: dep.message,
-                            filename: moduleName,
-                            detail: dep.detail,
-                            loc: dep.loc,
-                            source: this.currentContents,
-                        });
-                    }
-                }
-                else {
-                    for (let entry of dep.modules) {
-                        let { runtimeName } = entry;
-                        flatDeps.set(runtimeName, entry);
-                    }
-                }
-            }
+    humanReadableFile(file) {
+        if (!this.params.root.endsWith('/')) {
+            this.params.root += '/';
+        }
+        if (file.startsWith(this.params.root)) {
+            return file.slice(this.params.root.length);
+        }
+        return file;
+    }
+    reportError(dep, filename, source) {
+        if (!this.auditHandler && !this.params.options.allowUnsafeDynamicComponents) {
+            let e = new Error(`${dep.message}: ${dep.detail} in ${this.humanReadableFile(filename)}`);
+            e.isTemplateResolverError = true;
+            e.loc = dep.loc;
+            e.moduleName = filename;
+            throw e;
+        }
+        if (this.auditHandler) {
+            this.auditHandler({
+                message: dep.message,
+                filename,
+                detail: dep.detail,
+                loc: dep.loc,
+                source,
+            });
         }
-        return [...flatDeps.values()];
     }
     resolveImport(path, from) {
         let absPath;
@@ -353,13 +309,12 @@ class CompatResolver {
             if ((0, fs_extra_1.pathExistsSync)(absPath)) {
                 return {
                     type: 'helper',
-                    modules: [
-                        {
-                            runtimeName: this.absPathToRuntimeName(absPath, targetPackage),
-                            path: (0, core_1.explicitRelative)((0, path_1.dirname)(from), absPath),
-                            absPath,
-                        },
-                    ],
+                    module: {
+                        runtimeName: this.absPathToRuntimeName(absPath, targetPackage),
+                        path: (0, core_1.explicitRelative)((0, path_1.dirname)(from), absPath),
+                        absPath,
+                    },
+                    nameHint: path,
                 };
             }
         }
@@ -388,13 +343,12 @@ class CompatResolver {
             if ((0, fs_extra_1.pathExistsSync)(absPath)) {
                 return {
                     type: 'modifier',
-                    modules: [
-                        {
-                            runtimeName: this.absPathToRuntimeName(absPath, targetPackage),
-                            path: (0, core_1.explicitRelative)((0, path_1.dirname)(from), absPath),
-                            absPath,
-                        },
-                    ],
+                    module: {
+                        runtimeName: this.absPathToRuntimeName(absPath, targetPackage),
+                        path: (0, core_1.explicitRelative)((0, path_1.dirname)(from), absPath),
+                        absPath,
+                    },
+                    nameHint: path,
                 };
             }
         }
@@ -421,23 +375,19 @@ class CompatResolver {
         }
     }
     _tryComponent(path, from, withRuleLookup, targetPackage) {
-        // The order here is important! We always put our .hbs paths first here, so
-        // that if we have an hbs file of our own, that will be the first resolved
-        // dependency. The first resolved dependency is special because we use that
-        // as a key into the rules, and we want to be able to find our rules when
-        // checking from our own template (among other times).
         let extensions = ['.hbs', ...this.adjustImportsOptions.resolvableExtensions.filter((e) => e !== '.hbs')];
-        let componentModules = [];
+        let hbsModule;
+        let jsModule;
         // first, the various places our template might be
         for (let extension of extensions) {
             let absPath = (0, path_1.join)(targetPackage.root, 'templates', 'components', path) + extension;
             if ((0, fs_extra_1.pathExistsSync)(absPath)) {
-                componentModules.push(absPath);
+                hbsModule = absPath;
                 break;
             }
             absPath = (0, path_1.join)(targetPackage.root, 'components', path, 'template') + extension;
             if ((0, fs_extra_1.pathExistsSync)(absPath)) {
-                componentModules.push(absPath);
+                hbsModule = absPath;
                 break;
             }
             if (typeof this.params.podModulePrefix !== 'undefined' &&
@@ -446,7 +396,7 @@ class CompatResolver {
                 let podPrefix = this.params.podModulePrefix.replace(this.params.modulePrefix, '');
                 absPath = (0, path_1.join)(targetPackage.root, podPrefix, 'components', path, 'template') + extension;
                 if ((0, fs_extra_1.pathExistsSync)(absPath)) {
-                    componentModules.push(absPath);
+                    hbsModule = absPath;
                     break;
                 }
             }
@@ -458,17 +408,17 @@ class CompatResolver {
             }
             let absPath = (0, path_1.join)(targetPackage.root, 'components', path, 'index') + extension;
             if ((0, fs_extra_1.pathExistsSync)(absPath)) {
-                componentModules.push(absPath);
+                jsModule = absPath;
                 break;
             }
             absPath = (0, path_1.join)(targetPackage.root, 'components', path) + extension;
             if ((0, fs_extra_1.pathExistsSync)(absPath)) {
-                componentModules.push(absPath);
+                jsModule = absPath;
                 break;
             }
             absPath = (0, path_1.join)(targetPackage.root, 'components', path, 'component') + extension;
             if ((0, fs_extra_1.pathExistsSync)(absPath)) {
-                componentModules.push(absPath);
+                jsModule = absPath;
                 break;
             }
             if (typeof this.params.podModulePrefix !== 'undefined' &&
@@ -477,29 +427,42 @@ class CompatResolver {
                 let podPrefix = this.params.podModulePrefix.replace(this.params.modulePrefix, '');
                 absPath = (0, path_1.join)(targetPackage.root, podPrefix, 'components', path, 'component') + extension;
                 if ((0, fs_extra_1.pathExistsSync)(absPath)) {
-                    componentModules.push(absPath);
+                    jsModule = absPath;
                     break;
                 }
             }
         }
-        if (componentModules.length > 0) {
-            let componentRules;
-            if (withRuleLookup) {
-                componentRules = this.findComponentRules(componentModules[0]);
-            }
-            return {
-                type: 'component',
-                modules: componentModules.map(absPath => ({
-                    path: (0, core_1.explicitRelative)((0, path_1.dirname)(from), absPath),
-                    absPath,
-                    runtimeName: this.absPathToRuntimeName(absPath, targetPackage),
-                })),
-                yieldsComponents: componentRules ? componentRules.yieldsSafeComponents : [],
-                yieldsArguments: componentRules ? componentRules.yieldsArguments : [],
-                argumentsAreComponents: componentRules ? componentRules.argumentsAreComponents : [],
-            };
+        if (jsModule == null && hbsModule == null) {
+            return null;
         }
-        return null;
+        let componentRules;
+        if (withRuleLookup) {
+            // the order here is important. We follow the convention that any rules
+            // get attached to the hbsModule if it exists, and only get attached to
+            // the jsModule otherwise
+            componentRules = this.findComponentRules((hbsModule !== null && hbsModule !== void 0 ? hbsModule : jsModule));
+        }
+        return {
+            type: 'component',
+            jsModule: jsModule
+                ? {
+                    path: (0, core_1.explicitRelative)((0, path_1.dirname)(from), jsModule),
+                    absPath: jsModule,
+                    runtimeName: this.absPathToRuntimeName(jsModule, targetPackage),
+                }
+                : null,
+            hbsModule: hbsModule
+                ? {
+                    path: (0, core_1.explicitRelative)((0, path_1.dirname)(from), hbsModule),
+                    absPath: hbsModule,
+                    runtimeName: this.absPathToRuntimeName(hbsModule, targetPackage),
+                }
+                : null,
+            yieldsComponents: componentRules ? componentRules.yieldsSafeComponents : [],
+            yieldsArguments: componentRules ? componentRules.yieldsArguments : [],
+            argumentsAreComponents: componentRules ? componentRules.argumentsAreComponents : [],
+            nameHint: path,
+        };
     }
     resolveSubExpression(path, from, loc) {
         if (!this.staticHelpersEnabled) {
@@ -507,29 +470,29 @@ class CompatResolver {
         }
         let found = this.tryHelper(path, from);
         if (found) {
-            return this.add(found, from);
+            return found;
         }
         if (builtInHelpers.includes(path)) {
             return null;
         }
-        return this.add({
+        return {
             type: 'error',
             message: `Missing helper`,
             detail: path,
             loc,
-        }, from);
+        };
     }
     resolveMustache(path, hasArgs, from, loc) {
         if (this.staticHelpersEnabled) {
             let found = this.tryHelper(path, from);
             if (found) {
-                return this.add(found, from);
+                return found;
             }
         }
         if (this.staticComponentsEnabled) {
             let found = this.tryComponent(path, from);
             if (found) {
-                return this.add(found, from);
+                return found;
             }
         }
         if (hasArgs &&
@@ -537,12 +500,12 @@ class CompatResolver {
             this.staticHelpersEnabled &&
             !builtInHelpers.includes(path) &&
             !this.isIgnoredComponent(path)) {
-            return this.add({
+            return {
                 type: 'error',
                 message: `Missing component or helper`,
                 detail: path,
                 loc,
-            }, from);
+            };
         }
         else {
             return null;
@@ -554,17 +517,17 @@ class CompatResolver {
         }
         let found = this.tryModifier(path, from);
         if (found) {
-            return this.add(found, from);
+            return found;
         }
         if (builtInModifiers.includes(path)) {
             return null;
         }
-        return this.add({
+        return {
             type: 'error',
             message: `Missing modifier`,
             detail: path,
             loc,
-        }, from);
+        };
     }
     resolveElement(tagName, from, loc) {
         if (!this.staticComponentsEnabled) {
@@ -581,17 +544,18 @@ class CompatResolver {
         }
         let found = this.tryComponent(dName, from);
         if (found) {
-            return this.add(found, from);
+            found.nameHint = tagName;
+            return found;
         }
         if (this.isIgnoredComponent(dName)) {
             return null;
         }
-        return this.add({
+        return {
             type: 'error',
             message: `Missing component`,
             detail: tagName,
             loc,
-        }, from);
+        };
     }
     resolveComponentHelper(component, from, loc, impliedBecause) {
         if (!this.staticComponentsEnabled) {
@@ -605,38 +569,38 @@ class CompatResolver {
             message = `Unsafe dynamic component`;
         }
         if (component.type === 'other') {
-            return this.add({
+            return {
                 type: 'error',
                 message,
                 detail: `cannot statically analyze this expression`,
                 loc,
-            }, from);
+            };
         }
         if (component.type === 'path') {
             let ownComponentRules = this.findComponentRules(from);
             if (ownComponentRules && ownComponentRules.safeInteriorPaths.includes(component.path)) {
                 return null;
             }
-            return this.add({
+            return {
                 type: 'error',
                 message,
                 detail: component.path,
                 loc,
-            }, from);
+            };
         }
         if (builtInComponents.includes(component.path)) {
             return null;
         }
         let found = this.tryComponent(component.path, from);
         if (found) {
-            return this.add(found, from);
+            return found;
         }
-        return this.add({
+        return {
             type: 'error',
             message: `Missing component`,
             detail: component.path,
             loc,
-        }, from);
+        };
     }
     resolveDynamicHelper(helper, from, loc) {
         if (!this.staticHelpersEnabled) {
@@ -649,22 +613,22 @@ class CompatResolver {
             }
             let found = this.tryHelper(helperName, from);
             if (found) {
-                return this.add(found, from);
+                return found;
             }
-            return this.add({
+            return {
                 type: 'error',
                 message: `Missing helper`,
                 detail: helperName,
                 loc,
-            }, from);
+            };
         }
         else {
-            return this.add({
+            return {
                 type: 'error',
                 message: 'Unsafe dynamic helper',
                 detail: `cannot statically analyze this expression`,
                 loc,
-            }, from);
+            };
         }
     }
     resolveDynamicModifier(modifier, from, loc) {
@@ -678,22 +642,22 @@ class CompatResolver {
             }
             let found = this.tryModifier(modifierName, from);
             if (found) {
-                return this.add(found, from);
+                return found;
             }
-            return this.add({
+            return {
                 type: 'error',
                 message: `Missing modifier`,
                 detail: modifierName,
                 loc,
-            }, from);
+            };
         }
         else {
-            return this.add({
+            return {
                 type: 'error',
                 message: 'Unsafe dynamic modifier',
                 detail: `cannot statically analyze this expression`,
                 loc,
-            }, from);
+            };
         }
     }
 }
@@ -710,13 +674,4 @@ __decorate([
     (0, typescript_memoize_1.Memoize)()
 ], CompatResolver.prototype, "appPackage", null);
 exports.default = CompatResolver;
-function humanReadableFile(root, file) {
-    if (!root.endsWith('/')) {
-        root += '/';
-    }
-    if (file.startsWith(root)) {
-        return file.slice(root.length);
-    }
-    return file;
-}
 //# sourceMappingURL=resolver.js.map