@embroider/compat 2.0.2 → 2.1.1-unstable.00ec2e7

package/src/resolver.js

@@ -1,677 +0,0 @@
-"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 };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rehydrate = void 0;
-const dependency_rules_1 = require("./dependency-rules");
-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 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 = [
-    '-get-dynamic-var',
-    '-in-element',
-    'in-element',
-    '-with-dynamic-vars',
-    'action',
-    'array',
-    'component',
-    'concat',
-    'debugger',
-    'each',
-    'each-in',
-    'fn',
-    'get',
-    'has-block',
-    'has-block-params',
-    'hasBlock',
-    'hasBlockParams',
-    'hash',
-    'helper',
-    'if',
-    'input',
-    'let',
-    'link-to',
-    'loc',
-    'log',
-    'modifier',
-    'mount',
-    'mut',
-    'on',
-    'outlet',
-    'partial',
-    'query-params',
-    'readonly',
-    'textarea',
-    'unbound',
-    'unique-id',
-    'unless',
-    'with',
-    'yield',
-];
-const builtInComponents = ['input', 'link-to', 'textarea'];
-const builtInModifiers = ['action', 'on'];
-function extractOptions(options) {
-    return {
-        staticHelpers: options.staticHelpers,
-        staticModifiers: options.staticModifiers,
-        staticComponents: options.staticComponents,
-        allowUnsafeDynamicComponents: options.allowUnsafeDynamicComponents,
-    };
-}
-function rehydrate(params) {
-    return new CompatResolver(params);
-}
-exports.rehydrate = rehydrate;
-class CompatResolver {
-    constructor(params) {
-        this.params = params;
-        this.params.options = extractOptions(this.params.options);
-        this._parallelBabel = {
-            requireFile: __filename,
-            buildUsing: 'rehydrate',
-            params,
-        };
-        if (globalThis.embroider_audit) {
-            this.auditHandler = globalThis.embroider_audit;
-        }
-    }
-    findComponentRules(absPath) {
-        let rules = this.rules.components.get(absPath);
-        if (rules) {
-            return rules;
-        }
-        // co-located templates aren't visible to the resolver, because they never
-        // get resolved from a template (they are always handled directly by the
-        // corresponding JS module, which the resolver *does* see). This means their
-        // paths won't ever be in `this.rules.components`. But we do want them to
-        // "inherit" the rules that are attached to their corresonding JS module.
-        if (absPath.endsWith('.hbs')) {
-            let stem = absPath.slice(0, -4);
-            for (let ext of this.adjustImportsOptions.resolvableExtensions) {
-                if (ext !== '.hbs') {
-                    let rules = this.rules.components.get(stem + ext);
-                    if (rules) {
-                        return rules;
-                    }
-                }
-            }
-        }
-        return undefined;
-    }
-    isIgnoredComponent(dasherizedName) {
-        return this.rules.ignoredComponents.includes(dasherizedName);
-    }
-    get adjustImportsOptions() {
-        const { params } = this;
-        return 'adjustImportsOptionsPath' in params
-            ? // eslint-disable-next-line @typescript-eslint/no-require-imports
-                require(params.adjustImportsOptionsPath)
-            : params.adjustImportsOptions;
-    }
-    get rules() {
-        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.
-        let ignoredComponents = [];
-        // we're not responsible for filtering out rules for inactive packages here,
-        // that is done before getting to us. So we should assume these are all in
-        // force.
-        for (let rule of this.params.activePackageRules) {
-            if (rule.components) {
-                for (let [snippet, componentRules] of Object.entries(rule.components)) {
-                    if (componentRules.safeToIgnore) {
-                        ignoredComponents.push(this.standardDasherize(snippet, rule));
-                        continue;
-                    }
-                    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.
-                    components.set(resolvedDep.absPath, processedRules);
-                    // if there's a custom layout, we also need to register our rules on
-                    // those templates.
-                    if (componentRules.layout) {
-                        if (componentRules.layout.appPath) {
-                            components.set((0, path_1.join)(this.params.root, componentRules.layout.appPath), processedRules);
-                        }
-                        else if (componentRules.layout.addonPath) {
-                            for (let root of rule.roots) {
-                                components.set((0, path_1.join)(root, componentRules.layout.addonPath), processedRules);
-                            }
-                        }
-                        else {
-                            throw new Error(`layout property in component rule must contain either appPath or addonPath: ${JSON.stringify(rule, null, 2)}`);
-                        }
-                    }
-                }
-            }
-            if (rule.appTemplates) {
-                for (let [path, templateRules] of Object.entries(rule.appTemplates)) {
-                    let processedRules = (0, dependency_rules_1.preprocessComponentRule)(templateRules);
-                    components.set((0, path_1.join)(this.params.root, path), processedRules);
-                }
-            }
-            if (rule.addonTemplates) {
-                for (let [path, templateRules] of Object.entries(rule.addonTemplates)) {
-                    let processedRules = (0, dependency_rules_1.preprocessComponentRule)(templateRules);
-                    for (let root of rule.roots) {
-                        components.set((0, path_1.join)(root, path), processedRules);
-                    }
-                }
-            }
-        }
-        return { components, ignoredComponents };
-    }
-    resolveComponentSnippet(snippet, rule, from = 'rule-snippet.hbs') {
-        let name = this.standardDasherize(snippet, rule);
-        let found = this.tryComponent(name, from, false);
-        if (found && found.type === 'component') {
-            return found;
-        }
-        throw new Error(`unable to locate component ${snippet} referred to in rule ${JSON.stringify(rule, null, 2)}`);
-    }
-    standardDasherize(snippet, rule) {
-        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)}`);
-        }
-        return name;
-    }
-    astTransformer() {
-        if (this.staticComponentsEnabled || this.staticHelpersEnabled || this.staticModifiersEnabled) {
-            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];
-        }
-    }
-    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,
-            });
-        }
-    }
-    resolveImport(path, from) {
-        let absPath;
-        try {
-            absPath = resolve_1.default.sync(path, {
-                basedir: (0, path_1.dirname)(from),
-                extensions: this.adjustImportsOptions.resolvableExtensions,
-            });
-        }
-        catch (err) {
-            return;
-        }
-        if (absPath) {
-            let runtimeName = this.absPathToRuntimeName(absPath);
-            if (runtimeName) {
-                return { runtimeName, absPath };
-            }
-        }
-    }
-    get resolvableExtensionsPattern() {
-        return (0, core_1.extensionsPattern)(this.adjustImportsOptions.resolvableExtensions);
-    }
-    absPathToRuntimePath(absPath, owningPackage) {
-        let pkg = owningPackage || core_1.PackageCache.shared('embroider-stage3', this.params.root).ownerOfFile(absPath);
-        if (pkg) {
-            let packageRuntimeName = pkg.name;
-            for (let [runtimeName, realName] of Object.entries(this.adjustImportsOptions.renamePackages)) {
-                if (realName === packageRuntimeName) {
-                    packageRuntimeName = runtimeName;
-                    break;
-                }
-            }
-            return (0, path_1.join)(packageRuntimeName, (0, path_1.relative)(pkg.root, absPath)).split(path_1.sep).join('/');
-        }
-        else if (absPath.startsWith(this.params.root)) {
-            return (0, path_1.join)(this.params.modulePrefix, (0, path_1.relative)(this.params.root, absPath)).split(path_1.sep).join('/');
-        }
-        else {
-            throw new Error(`bug: can't figure out the runtime name for ${absPath}`);
-        }
-    }
-    absPathToRuntimeName(absPath, owningPackage) {
-        return this.absPathToRuntimePath(absPath, owningPackage)
-            .replace(this.resolvableExtensionsPattern, '')
-            .replace(/\/index$/, '');
-    }
-    get staticComponentsEnabled() {
-        return this.params.options.staticComponents || Boolean(this.auditHandler);
-    }
-    get staticHelpersEnabled() {
-        return this.params.options.staticHelpers || Boolean(this.auditHandler);
-    }
-    get staticModifiersEnabled() {
-        return this.params.options.staticModifiers || Boolean(this.auditHandler);
-    }
-    tryHelper(path, from) {
-        let parts = path.split('@');
-        if (parts.length > 1 && parts[0].length > 0) {
-            let cache = core_1.PackageCache.shared('embroider-stage3', this.params.root);
-            let packageName = parts[0];
-            let renamed = this.adjustImportsOptions.renamePackages[packageName];
-            if (renamed) {
-                packageName = renamed;
-            }
-            let owner = cache.ownerOfFile(from);
-            let targetPackage = owner.name === packageName ? owner : cache.resolve(packageName, owner);
-            return this._tryHelper(parts[1], from, targetPackage);
-        }
-        else {
-            return this._tryHelper(path, from, this.appPackage);
-        }
-    }
-    _tryHelper(path, from, targetPackage) {
-        for (let extension of this.adjustImportsOptions.resolvableExtensions) {
-            let absPath = (0, path_1.join)(targetPackage.root, 'helpers', path) + extension;
-            if ((0, fs_extra_1.pathExistsSync)(absPath)) {
-                return {
-                    type: 'helper',
-                    module: {
-                        runtimeName: this.absPathToRuntimeName(absPath, targetPackage),
-                        path: (0, core_1.explicitRelative)((0, path_1.dirname)(from), absPath),
-                        absPath,
-                    },
-                    nameHint: path,
-                };
-            }
-        }
-        return null;
-    }
-    tryModifier(path, from) {
-        let parts = path.split('@');
-        if (parts.length > 1 && parts[0].length > 0) {
-            let cache = core_1.PackageCache.shared('embroider-stage3', this.params.root);
-            let packageName = parts[0];
-            let renamed = this.adjustImportsOptions.renamePackages[packageName];
-            if (renamed) {
-                packageName = renamed;
-            }
-            let owner = cache.ownerOfFile(from);
-            let targetPackage = owner.name === packageName ? owner : cache.resolve(packageName, owner);
-            return this._tryModifier(parts[1], from, targetPackage);
-        }
-        else {
-            return this._tryModifier(path, from, this.appPackage);
-        }
-    }
-    _tryModifier(path, from, targetPackage) {
-        for (let extension of this.adjustImportsOptions.resolvableExtensions) {
-            let absPath = (0, path_1.join)(targetPackage.root, 'modifiers', path) + extension;
-            if ((0, fs_extra_1.pathExistsSync)(absPath)) {
-                return {
-                    type: 'modifier',
-                    module: {
-                        runtimeName: this.absPathToRuntimeName(absPath, targetPackage),
-                        path: (0, core_1.explicitRelative)((0, path_1.dirname)(from), absPath),
-                        absPath,
-                    },
-                    nameHint: path,
-                };
-            }
-        }
-        return null;
-    }
-    get appPackage() {
-        return { root: this.params.root, name: this.params.modulePrefix };
-    }
-    tryComponent(path, from, withRuleLookup = true) {
-        let parts = path.split('@');
-        if (parts.length > 1 && parts[0].length > 0) {
-            let cache = core_1.PackageCache.shared('embroider-stage3', this.params.root);
-            let packageName = parts[0];
-            let renamed = this.adjustImportsOptions.renamePackages[packageName];
-            if (renamed) {
-                packageName = renamed;
-            }
-            let owner = cache.ownerOfFile(from);
-            let targetPackage = owner.name === packageName ? owner : cache.resolve(packageName, owner);
-            return this._tryComponent(parts[1], from, withRuleLookup, targetPackage);
-        }
-        else {
-            return this._tryComponent(path, from, withRuleLookup, this.appPackage);
-        }
-    }
-    _tryComponent(path, from, withRuleLookup, targetPackage) {
-        let extensions = ['.hbs', ...this.adjustImportsOptions.resolvableExtensions.filter((e) => e !== '.hbs')];
-        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)) {
-                hbsModule = absPath;
-                break;
-            }
-            absPath = (0, path_1.join)(targetPackage.root, 'components', path, 'template') + extension;
-            if ((0, fs_extra_1.pathExistsSync)(absPath)) {
-                hbsModule = absPath;
-                break;
-            }
-            if (typeof this.params.podModulePrefix !== 'undefined' &&
-                this.params.podModulePrefix !== '' &&
-                targetPackage === this.appPackage) {
-                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)) {
-                    hbsModule = absPath;
-                    break;
-                }
-            }
-        }
-        // then the various places our javascript might be
-        for (let extension of extensions) {
-            if (extension === '.hbs') {
-                continue;
-            }
-            let absPath = (0, path_1.join)(targetPackage.root, 'components', path, 'index') + extension;
-            if ((0, fs_extra_1.pathExistsSync)(absPath)) {
-                jsModule = absPath;
-                break;
-            }
-            absPath = (0, path_1.join)(targetPackage.root, 'components', path) + extension;
-            if ((0, fs_extra_1.pathExistsSync)(absPath)) {
-                jsModule = absPath;
-                break;
-            }
-            absPath = (0, path_1.join)(targetPackage.root, 'components', path, 'component') + extension;
-            if ((0, fs_extra_1.pathExistsSync)(absPath)) {
-                jsModule = absPath;
-                break;
-            }
-            if (typeof this.params.podModulePrefix !== 'undefined' &&
-                this.params.podModulePrefix !== '' &&
-                targetPackage === this.appPackage) {
-                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)) {
-                    jsModule = absPath;
-                    break;
-                }
-            }
-        }
-        if (jsModule == null && hbsModule == 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) {
-            return null;
-        }
-        let found = this.tryHelper(path, from);
-        if (found) {
-            return found;
-        }
-        if (builtInHelpers.includes(path)) {
-            return null;
-        }
-        return {
-            type: 'error',
-            message: `Missing helper`,
-            detail: path,
-            loc,
-        };
-    }
-    resolveMustache(path, hasArgs, from, loc) {
-        if (this.staticHelpersEnabled) {
-            let found = this.tryHelper(path, from);
-            if (found) {
-                return found;
-            }
-        }
-        if (this.staticComponentsEnabled) {
-            let found = this.tryComponent(path, from);
-            if (found) {
-                return found;
-            }
-        }
-        if (hasArgs &&
-            this.staticComponentsEnabled &&
-            this.staticHelpersEnabled &&
-            !builtInHelpers.includes(path) &&
-            !this.isIgnoredComponent(path)) {
-            return {
-                type: 'error',
-                message: `Missing component or helper`,
-                detail: path,
-                loc,
-            };
-        }
-        else {
-            return null;
-        }
-    }
-    resolveElementModifierStatement(path, from, loc) {
-        if (!this.staticModifiersEnabled) {
-            return null;
-        }
-        let found = this.tryModifier(path, from);
-        if (found) {
-            return found;
-        }
-        if (builtInModifiers.includes(path)) {
-            return null;
-        }
-        return {
-            type: 'error',
-            message: `Missing modifier`,
-            detail: path,
-            loc,
-        };
-    }
-    resolveElement(tagName, from, loc) {
-        if (!this.staticComponentsEnabled) {
-            return null;
-        }
-        if (tagName[0] === tagName[0].toLowerCase()) {
-            // starts with lower case, so this can't be a component we need to
-            // globally resolve
-            return null;
-        }
-        let dName = (0, dasherize_component_name_1.dasherize)(tagName);
-        if (builtInComponents.includes(dName)) {
-            return null;
-        }
-        let found = this.tryComponent(dName, from);
-        if (found) {
-            found.nameHint = tagName;
-            return found;
-        }
-        if (this.isIgnoredComponent(dName)) {
-            return null;
-        }
-        return {
-            type: 'error',
-            message: `Missing component`,
-            detail: tagName,
-            loc,
-        };
-    }
-    resolveComponentHelper(component, from, loc, impliedBecause) {
-        if (!this.staticComponentsEnabled) {
-            return null;
-        }
-        let message;
-        if (impliedBecause) {
-            message = `argument "${impliedBecause.argumentName}" to component "${impliedBecause.componentName}" is treated as a component, but the value you're passing is dynamic`;
-        }
-        else {
-            message = `Unsafe dynamic component`;
-        }
-        if (component.type === 'other') {
-            return {
-                type: 'error',
-                message,
-                detail: `cannot statically analyze this expression`,
-                loc,
-            };
-        }
-        if (component.type === 'path') {
-            let ownComponentRules = this.findComponentRules(from);
-            if (ownComponentRules && ownComponentRules.safeInteriorPaths.includes(component.path)) {
-                return null;
-            }
-            return {
-                type: 'error',
-                message,
-                detail: component.path,
-                loc,
-            };
-        }
-        if (builtInComponents.includes(component.path)) {
-            return null;
-        }
-        let found = this.tryComponent(component.path, from);
-        if (found) {
-            return found;
-        }
-        return {
-            type: 'error',
-            message: `Missing component`,
-            detail: component.path,
-            loc,
-        };
-    }
-    resolveDynamicHelper(helper, from, loc) {
-        if (!this.staticHelpersEnabled) {
-            return null;
-        }
-        if (helper.type === 'literal') {
-            let helperName = helper.path;
-            if (builtInHelpers.includes(helperName)) {
-                return null;
-            }
-            let found = this.tryHelper(helperName, from);
-            if (found) {
-                return found;
-            }
-            return {
-                type: 'error',
-                message: `Missing helper`,
-                detail: helperName,
-                loc,
-            };
-        }
-        else {
-            return {
-                type: 'error',
-                message: 'Unsafe dynamic helper',
-                detail: `cannot statically analyze this expression`,
-                loc,
-            };
-        }
-    }
-    resolveDynamicModifier(modifier, from, loc) {
-        if (!this.staticModifiersEnabled) {
-            return null;
-        }
-        if (modifier.type === 'literal') {
-            let modifierName = modifier.path;
-            if (builtInModifiers.includes(modifierName)) {
-                return null;
-            }
-            let found = this.tryModifier(modifierName, from);
-            if (found) {
-                return found;
-            }
-            return {
-                type: 'error',
-                message: `Missing modifier`,
-                detail: modifierName,
-                loc,
-            };
-        }
-        else {
-            return {
-                type: 'error',
-                message: 'Unsafe dynamic modifier',
-                detail: `cannot statically analyze this expression`,
-                loc,
-            };
-        }
-    }
-}
-__decorate([
-    (0, typescript_memoize_1.Memoize)()
-], CompatResolver.prototype, "adjustImportsOptions", null);
-__decorate([
-    (0, typescript_memoize_1.Memoize)()
-], CompatResolver.prototype, "rules", null);
-__decorate([
-    (0, typescript_memoize_1.Memoize)()
-], CompatResolver.prototype, "resolvableExtensionsPattern", null);
-__decorate([
-    (0, typescript_memoize_1.Memoize)()
-], CompatResolver.prototype, "appPackage", null);
-exports.default = CompatResolver;
-//# sourceMappingURL=resolver.js.map