tslint-folders/dist/tsfFoldersImportsBetweenPackagesRule.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Lint = require("tslint");
const ConfigFactory_1 = require("./config/ConfigFactory");
const GeneralRuleUtils_1 = require("./utils/GeneralRuleUtils");
const ImportRuleUtils_1 = require("./utils/ImportRuleUtils");
exports.IMPORTS_BETWEEN_PACKAGES_RULE_ID = "tsf-folders-imports-between-packages";
const DISALLOW_IMPORT_FROM_SELF_MESSAGE = "do not import a package from itself - use a relative path";
class Rule extends Lint.Rules.AbstractRule {
    apply(sourceFile) {
        const walker = new ImportsWalker(sourceFile, this.getOptions());
        this.applyWithWalker(walker);
        return walker.getFailures();
    }
}
exports.Rule = Rule;
class ImportsWalker extends Lint.RuleWalker {
    visitImportDeclaration(node) {
        this.validate(node, node.moduleSpecifier.getText());
    }
    visitImportEqualsDeclaration(node) {
        this.validate(node, node.moduleReference.getText());
        super.visitImportEqualsDeclaration(node);
    }
    validate(node, text) {
        // algorithm:
        /*
            - determine this files PackageFolder, PackageSubFolder
            - if ThirdParty then skip
            - determine the PackageFolder, PackageSubFolder of the import
            - if ThirdParty then skip
            - disallowImportFromSelf -> disallow if same
            - check if the import is allowed
            */
        const config = ConfigFactory_1.ConfigFactory.createForBetweenPackages(this.getOptions());
        const thisPackageLocation = ImportRuleUtils_1.ImportRuleUtils.determinePackageLocationFromPath(node.getSourceFile().fileName, exports.IMPORTS_BETWEEN_PACKAGES_RULE_ID, config, ImportRuleUtils_1.PathSource.SourceFilePath);
        if (ImportRuleUtils_1.ImportRuleUtils.isThisPackageThirdParty(thisPackageLocation, node)) {
            return;
        }
        if (!thisPackageLocation.packageFolder) {
            throw new Error("unexpected: this package is not ThirdParty, but has no packageFolder in its location");
        }
        const importPackageLocation = ImportRuleUtils_1.ImportRuleUtils.determinePackageLocationFromPath(text, exports.IMPORTS_BETWEEN_PACKAGES_RULE_ID, config, ImportRuleUtils_1.PathSource.ImportText, thisPackageLocation);
        ImportRuleUtils_1.ImportRuleUtils.logPackageAndImport(node, thisPackageLocation, importPackageLocation);
        const isImportRecognised = !ImportRuleUtils_1.ImportRuleUtils.isPackageThirdParty(importPackageLocation);
        if (isImportRecognised &&
            importPackageLocation.packageName === thisPackageLocation.packageName &&
            config.disallowImportFromSelf.enabled &&
            !ImportRuleUtils_1.ImportRuleUtils.shouldIgnoreFile(node, config.disallowImportFromSelf.ignorePaths)) {
            this.addFailureAtNode(node, GeneralRuleUtils_1.GeneralRuleUtils.buildFailureString(DISALLOW_IMPORT_FROM_SELF_MESSAGE, exports.IMPORTS_BETWEEN_PACKAGES_RULE_ID));
            return;
        }
        if (isImportRecognised &&
            config.checkImportsBetweenPackages.enabled &&
            !ImportRuleUtils_1.ImportRuleUtils.shouldIgnoreFile(node, config.checkImportsBetweenPackages.ignorePaths)) {
            if (!thisPackageLocation.packageFolder ||
                !importPackageLocation.packageFolder) {
                return;
            }
            if (importPackageLocation.packageFolder ===
                thisPackageLocation.packageFolder) {
                if (!config.checkImportsBetweenPackages.checkSubFoldersEnabled) {
                    return;
                }
                // TODO xxx extract fun?
                // check sub-folders
                if (thisPackageLocation.packageSubFolder &&
                    importPackageLocation.packageSubFolder &&
                    thisPackageLocation.packageSubFolder.importPath !==
                        importPackageLocation.packageSubFolder.importPath) {
                    if (thisPackageLocation.packageSubFolder.allowedToImport.some(allowed => allowed === "*")) {
                        return;
                    }
                    if (!thisPackageLocation.packageSubFolder.allowedToImport.some(allowed => {
                        return (importPackageLocation.packageSubFolder.importPath === allowed);
                    })) {
                        const failureMessage = `'${thisPackageLocation.packageName}' sub folder '${thisPackageLocation.packageSubFolder.importPath}' is not allowed to import from '${importPackageLocation.packageSubFolder.importPath}'`;
                        this.addFailureAtNodeWithMessage(node, failureMessage);
                    }
                }
            }
            else {
                const thisPackageFolder = thisPackageLocation.packageFolder;
                if (thisPackageFolder.allowedToImport.find(allowed => allowed === "*")) {
                    return;
                }
                if (!thisPackageFolder.allowedToImport.find(allowed => allowed === importPackageLocation.packageName)) {
                    const failureMessage = `'${thisPackageLocation.packageName}' is not allowed to import from '${importPackageLocation.packageName}'`;
                    this.addFailureAtNodeWithMessage(node, failureMessage);
                }
            }
        }
    }
    addFailureAtNodeWithMessage(node, failureMessage) {
        this.addFailureAtNode(node, GeneralRuleUtils_1.GeneralRuleUtils.buildFailureString(failureMessage, exports.IMPORTS_BETWEEN_PACKAGES_RULE_ID));
    }
}
//# sourceMappingURL=tsfFoldersImportsBetweenPackagesRule.js.map