eslint-plugin-boundaries 5.0.1 → 5.0.2

package/README.md

@@ -171,7 +171,7 @@ Read the [docs of the `boundaries/entry-point` rule](docs/rules/entry-point.md)
 
 ### Global settings
 
-#### __`boundaries/element-types`__
+#### __`boundaries/elements`__
 
 Define patterns to recognize each file in the project as one of this element types. All rules need this setting to be configured properly to work. The plugin tries to identify each file being analyzed or `import` statement in rules as one of the defined element types. The assigned element type will be that with the first matching pattern, in the same order that elements are defined in the array, so you __should sort them from the most accurate patterns to the less ones__. Properties of each `element`:
 
@@ -619,7 +619,7 @@ MIT, see [LICENSE](./LICENSE) for details.
 
 [coveralls-image]: https://coveralls.io/repos/github/javierbrea/eslint-plugin-boundaries/badge.svg
 [coveralls-url]: https://coveralls.io/github/javierbrea/eslint-plugin-boundaries
-[build-image]: https://github.com/javierbrea/eslint-plugin-boundaries/workflows/build/badge.svg?branch=master
+[build-image]: https://github.com/javierbrea/eslint-plugin-boundaries/workflows/build/badge.svg
 [build-url]: https://github.com/javierbrea/eslint-plugin-boundaries/actions?query=workflow%3Abuild+branch%3Amaster
 [last-commit-image]: https://img.shields.io/github/last-commit/javierbrea/eslint-plugin-boundaries.svg
 [last-commit-url]: https://github.com/javierbrea/eslint-plugin-boundaries/commits

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-boundaries",
-  "version": "5.0.1",
+  "version": "5.0.2",
   "description": "Eslint plugin checking architecture boundaries between elements",
   "keywords": [
     "eslint",
@@ -20,43 +20,26 @@
     "resolver-legacy-alias"
   ],
   "main": "index.js",
-  "scripts": {
-    "eslint": "eslint",
-    "lint": "eslint .",
-    "lint-staged": "lint-staged",
-    "test": "jest",
-    "test:unit": "cross-env ESLINT_PLUGIN_BOUNDARIES_DEBUG=1 npm run test",
-    "prepare": "is-ci || husky install"
-  },
   "peerDependencies": {
     "eslint": ">=6.0.0"
   },
   "dependencies": {
     "chalk": "4.1.2",
     "eslint-import-resolver-node": "0.3.9",
-    "eslint-module-utils": "2.12.0",
+    "eslint-module-utils": "2.12.1",
     "micromatch": "4.0.8"
   },
-  "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "8.13.0",
-    "@typescript-eslint/parser": "8.13.0",
-    "cross-env": "7.0.3",
-    "eslint": "9.14.0",
-    "eslint-config-prettier": "9.1.0",
-    "eslint-plugin-local-rules": "3.0.2",
-    "eslint-plugin-prettier": "5.2.1",
-    "husky": "9.1.6",
-    "is-ci": "3.0.1",
-    "jest": "29.7.0",
-    "lint-staged": "15.2.10",
-    "prettier": "3.3.3"
-  },
-  "lint-staged": {
-    "**/*.js": "eslint",
-    "**/*.ts": "eslint",
-    "**/*.mjs": "eslint"
-  },
   "engines": {
     "node": ">=18.18"
+  },
+  "scripts": {
+    "eslint": "eslint",
+    "build": "cross-env node ./scripts/copy-readme.js",
+    "check:all": "echo 'All checks passed'",
+    "check:spell": "cspell --quiet .",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "test": "jest",
+    "test:unit": "cross-env ESLINT_PLUGIN_BOUNDARIES_DEBUG=1 pnpm run test"
   }
-}
+}

package/resolver-legacy-alias/index.js

@@ -1,7 +1,9 @@
 const resolve = require("resolve");
 
 const getUsedAlias = (relativeFilePath, config) => {
-  return Object.keys(config).find((alias) => relativeFilePath.indexOf(alias) === 0);
+  return Object.keys(config).find(
+    (alias) => relativeFilePath.indexOf(alias) === 0,
+  );
 };
 
 const replaceAliases = (filePath, config) => {

package/src/constants/settings.js

@@ -50,9 +50,15 @@ module.exports = {
     ],
     import: [
       // Note: detects "import x from 'source'"
-      { selector: "ImportDeclaration:not([importKind=type]) > Literal", kind: "value" },
+      {
+        selector: "ImportDeclaration:not([importKind=type]) > Literal",
+        kind: "value",
+      },
       // Note: detects "import type x from 'source'"
-      { selector: "ImportDeclaration[importKind=type] > Literal", kind: "type" },
+      {
+        selector: "ImportDeclaration[importKind=type] > Literal",
+        kind: "type",
+      },
     ],
     "dynamic-import": [
       // Note: detects "import('source')"
@@ -60,13 +66,25 @@ module.exports = {
     ],
     export: [
       // Note: detects "export * from 'source'";
-      { selector: "ExportAllDeclaration:not([exportKind=type]) > Literal", kind: "value" },
+      {
+        selector: "ExportAllDeclaration:not([exportKind=type]) > Literal",
+        kind: "value",
+      },
       // Note: detects "export type * from 'source'";
-      { selector: "ExportAllDeclaration[exportKind=type] > Literal", kind: "type" },
+      {
+        selector: "ExportAllDeclaration[exportKind=type] > Literal",
+        kind: "type",
+      },
       // Note: detects "export { x } from 'source'";
-      { selector: "ExportNamedDeclaration:not([exportKind=type]) > Literal", kind: "value" },
+      {
+        selector: "ExportNamedDeclaration:not([exportKind=type]) > Literal",
+        kind: "value",
+      },
       // Note: detects "export type { x } from 'source'";
-      { selector: "ExportNamedDeclaration[exportKind=type] > Literal", kind: "type" },
+      {
+        selector: "ExportNamedDeclaration[exportKind=type] > Literal",
+        kind: "type",
+      },
     ],
   },
 };

package/src/core/dependencyInfo.js

@@ -25,7 +25,9 @@ function isBrother(elementA, elementB) {
 }
 
 function isDescendant(elementA, elementB) {
-  return !!elementA.parents.find((parent) => parent.elementPath === elementB.elementPath);
+  return elementA.parents.some(
+    (parent) => parent.elementPath === elementB.elementPath,
+  );
 }
 
 function isChild(elementA, elementB) {
@@ -37,7 +39,12 @@ function isInternal(elementA, elementB) {
 }
 
 function dependencyRelationship(dependency, element) {
-  if (!dependency.isLocal || dependency.isIgnored || !element.type || !dependency.type) {
+  if (
+    !dependency.isLocal ||
+    dependency.isIgnored ||
+    !element.type ||
+    !dependency.type
+  ) {
     return null;
   }
   if (isInternal(dependency, element)) {

package/src/core/elementsInfo.js

@@ -113,15 +113,25 @@ function elementTypeAndParents(path, settings) {
     .split("/")
     .reverse()
     .reduce(
-      ({ accumulator, lastSegmentMatching }, elementPathSegment, segmentIndex, elementPaths) => {
+      (
+        { accumulator, lastSegmentMatching },
+        elementPathSegment,
+        segmentIndex,
+        elementPaths,
+      ) => {
         accumulator.unshift(elementPathSegment);
         let elementFound = false;
         getElements(settings).forEach((element) => {
-          const typeOfMatch = VALID_MODES.includes(element.mode) ? element.mode : VALID_MODES[0];
-          const elementPatterns = isArray(element.pattern) ? element.pattern : [element.pattern];
+          const typeOfMatch = VALID_MODES.includes(element.mode)
+            ? element.mode
+            : VALID_MODES[0];
+          const elementPatterns = isArray(element.pattern)
+            ? element.pattern
+            : [element.pattern];
           elementPatterns.forEach((elementPattern) => {
             if (!elementFound) {
-              const useFullPathMatch = typeOfMatch === VALID_MODES[2] && !elementResult.type;
+              const useFullPathMatch =
+                typeOfMatch === VALID_MODES[2] && !elementResult.type;
               const pattern =
                 typeOfMatch === VALID_MODES[0] && !elementResult.type
                   ? `${elementPattern}/**/*`
@@ -145,10 +155,16 @@ function elementTypeAndParents(path, settings) {
               if (capture && basePatternCapture) {
                 elementFound = true;
                 lastSegmentMatching = segmentIndex + 1;
-                let capturedValues = elementCaptureValues(capture, element.capture);
+                let capturedValues = elementCaptureValues(
+                  capture,
+                  element.capture,
+                );
                 if (element.basePattern) {
                   capturedValues = {
-                    ...elementCaptureValues(basePatternCapture, element.baseCapture),
+                    ...elementCaptureValues(
+                      basePatternCapture,
+                      element.baseCapture,
+                    ),
                     ...capturedValues,
                   };
                 }
@@ -194,7 +210,10 @@ function replacePathSlashes(absolutePath) {
 
 function projectPath(absolutePath, rootPath) {
   if (absolutePath) {
-    return replacePathSlashes(absolutePath).replace(`${replacePathSlashes(rootPath)}/`, "");
+    return replacePathSlashes(absolutePath).replace(
+      `${replacePathSlashes(rootPath)}/`,
+      "",
+    );
   }
 }
 
@@ -203,9 +222,15 @@ function externalModulePath(source, baseModuleValue) {
 }
 
 function importInfo(source, context) {
-  const path = projectPath(resolve(source, context), getRootPath(context.settings));
+  const path = projectPath(
+    resolve(source, context),
+    getRootPath(context.settings),
+  );
   const isExternalModule = isExternal(source, path);
-  const resultCache = importsCache.load(isExternalModule ? source : path, context.settings);
+  const resultCache = importsCache.load(
+    isExternalModule ? source : path,
+    context.settings,
+  );
   let elementCache;
   let result;
   let elementResult;
@@ -216,7 +241,9 @@ function importInfo(source, context) {
     elementCache = elementsCache.load(path, context.settings);
     const baseModuleValue = isExternalModule ? baseModule(source) : null;
     const isBuiltInModule = isBuiltIn(source, path);
-    const pathToUse = isExternalModule ? externalModulePath(source, baseModuleValue) : path;
+    const pathToUse = isExternalModule
+      ? externalModulePath(source, baseModuleValue)
+      : path;
     if (elementCache) {
       elementResult = elementCache;
     } else {
@@ -245,7 +272,10 @@ function importInfo(source, context) {
 }
 
 function fileInfo(context) {
-  const path = projectPath(context.getFilename(), getRootPath(context.settings));
+  const path = projectPath(
+    context.getFilename(),
+    getRootPath(context.settings),
+  );
   const resultCache = filesCache.load(path, context.settings);
   let elementCache;
   let result;

package/src/helpers/debug.js

@@ -7,6 +7,7 @@ const warns = [];
 const debuggedFiles = [];
 
 function trace(message, color) {
+  // eslint-disable-next-line no-console
   console.log(chalk[color](`[${PLUGIN_NAME}]: ${message}`));
 }
 
@@ -34,7 +35,7 @@ function debugFileInfo(fileInfo) {
     } else {
       warn(`'${fileInfoKey}' is of unknown type`);
     }
-    console.log(JSON.stringify(fileInfo, null, 2));
+    trace(`\n${JSON.stringify(fileInfo, null, 2)}`, "gray");
   }
 }
 

package/src/helpers/messages.js

@@ -1,4 +1,8 @@
-const { isString, isArray, replaceObjectValuesInTemplates } = require("./utils");
+const {
+  isString,
+  isArray,
+  replaceObjectValuesInTemplates,
+} = require("./utils");
 const { micromatchPatternReplacingObjectsValues } = require("./rules");
 
 function quote(str) {
@@ -9,7 +13,7 @@ function typeMessage(elementMatcher) {
   return `elements of type ${quote(elementMatcher)}`;
 }
 
-function propertiesConcater(properties, index) {
+function propertiesConcatenator(properties, index) {
   if (properties.length > 1 && index === properties.length - 1) {
     return " and";
   }
@@ -28,27 +32,33 @@ function micromatchPatternMessage(micromatchPatterns, elementCapturedValues) {
     if (micromatchPatternsWithValues.length === 1) {
       return quote(micromatchPatternsWithValues[0]);
     }
-    return micromatchPatternsWithValues.reduce((message, micromatchPattern, index) => {
-      if (index === 0) {
-        return quote(micromatchPattern);
-      }
-      if (index === micromatchPatternsWithValues.length - 1) {
-        return `${message} or ${quote(micromatchPattern)}`;
-      }
-      return `${message}, ${quote(micromatchPattern)}`;
-    }, "");
+    return micromatchPatternsWithValues.reduce(
+      (message, micromatchPattern, index) => {
+        if (index === 0) {
+          return quote(micromatchPattern);
+        }
+        if (index === micromatchPatternsWithValues.length - 1) {
+          return `${message} or ${quote(micromatchPattern)}`;
+        }
+        return `${message}, ${quote(micromatchPattern)}`;
+      },
+      "",
+    );
   }
   return quote(micromatchPatternsWithValues);
 }
 
-function capturedValuesMatcherMessage(capturedValuesPattern, elementCapturedValues) {
+function capturedValuesMatcherMessage(
+  capturedValuesPattern,
+  elementCapturedValues,
+) {
   const capturedValuesPatternKeys = Object.keys(capturedValuesPattern);
   return capturedValuesPatternKeys
     .map((key) => {
       return [key, capturedValuesPattern[key]];
     })
     .reduce((message, propertyNameAndMatcher, index) => {
-      return `${message}${propertiesConcater(capturedValuesPatternKeys, index)} ${
+      return `${message}${propertiesConcatenator(capturedValuesPatternKeys, index)} ${
         propertyNameAndMatcher[0]
       } ${micromatchPatternMessage(propertyNameAndMatcher[1], elementCapturedValues)}`;
     }, "");
@@ -91,7 +101,11 @@ function elementPropertiesToReplaceInTemplate(element) {
 
 function customErrorMessage(message, file, dependency, report = {}) {
   let replacedMessage = replaceObjectValuesInTemplates(
-    replaceObjectValuesInTemplates(message, elementPropertiesToReplaceInTemplate(file), "file"),
+    replaceObjectValuesInTemplates(
+      message,
+      elementPropertiesToReplaceInTemplate(file),
+      "file",
+    ),
     elementPropertiesToReplaceInTemplate(dependency),
     "dependency",
   );
@@ -141,7 +155,7 @@ function elementCapturedValuesMessage(capturedValues) {
       return [key, capturedValues[key]];
     })
     .reduce((message, propertyNameAndValue, index) => {
-      return `${message}${propertiesConcater(capturedValuesKeys, index)} ${
+      return `${message}${propertiesConcatenator(capturedValuesKeys, index)} ${
         propertyNameAndValue[0]
       } ${quote(propertyNameAndValue[1])}`;
     }, "");

package/src/helpers/rules.js

@@ -32,13 +32,20 @@ function micromatchPatternReplacingObjectsValues(pattern, object) {
   let patternToReplace = pattern;
   // Backward compatibility
   if (object.from) {
-    patternToReplace = replaceObjectValuesInTemplates(patternToReplace, object.from);
+    patternToReplace = replaceObjectValuesInTemplates(
+      patternToReplace,
+      object.from,
+    );
   }
   return Object.keys(object).reduce((replacedPattern, namespace) => {
     if (!object[namespace]) {
       return replacedPattern;
     }
-    return replaceObjectValuesInTemplates(replacedPattern, object[namespace], namespace);
+    return replaceObjectValuesInTemplates(
+      replacedPattern,
+      object[namespace],
+      namespace,
+    );
   }, patternToReplace);
 }
 
@@ -62,7 +69,13 @@ function rulesMainKey(key) {
   return key || FROM;
 }
 
-function ruleMatch(ruleMatchers, targetElement, isMatch, fromElement, importKind) {
+function ruleMatch(
+  ruleMatchers,
+  targetElement,
+  isMatch,
+  fromElement,
+  importKind,
+) {
   let match = { result: false, report: null };
   const matchers = !isArray(ruleMatchers) ? [ruleMatchers] : ruleMatchers;
   matchers.forEach((matcher) => {
@@ -105,11 +118,18 @@ function isMatchElementKey(
 ) {
   const isMatch = micromatch.isMatch(
     elementInfo[elementKey],
-    micromatchPatternReplacingObjectsValues(matcher, elementsToCompareCapturedValues),
+    micromatchPatternReplacingObjectsValues(
+      matcher,
+      elementsToCompareCapturedValues,
+    ),
   );
   if (isMatch && options) {
     return {
-      result: isObjectMatch(options, elementInfo.capturedValues, elementsToCompareCapturedValues),
+      result: isObjectMatch(
+        options,
+        elementInfo.capturedValues,
+        elementsToCompareCapturedValues,
+      ),
     };
   }
   return {
@@ -134,7 +154,13 @@ function isMatchElementType(
   if (!isMatchImportKind(elementInfo, importKind)) {
     return { result: false };
   }
-  return isMatchElementKey(elementInfo, matcher, options, "type", elementsToCompareCapturedValues);
+  return isMatchElementKey(
+    elementInfo,
+    matcher,
+    options,
+    "type",
+    elementsToCompareCapturedValues,
+  );
 }
 
 function getElementRules(targetElement, options, mainKey, fromElement) {
@@ -150,7 +176,12 @@ function getElementRules(targetElement, options, mainKey, fromElement) {
       };
     })
     .filter((rule) => {
-      return ruleMatch(rule[key], targetElement, isMatchElementType, fromElement).result;
+      return ruleMatch(
+        rule[key],
+        targetElement,
+        isMatchElementType,
+        fromElement,
+      ).result;
     });
 }
 
@@ -181,7 +212,13 @@ function elementRulesAllowDependency({
   ).reduce(
     (allowed, rule) => {
       if (rule.disallow) {
-        const match = ruleMatch(rule.disallow, dependency, isMatch, element, rule.importKind);
+        const match = ruleMatch(
+          rule.disallow,
+          dependency,
+          isMatch,
+          element,
+          rule.importKind,
+        );
         if (match.result) {
           return [
             false,
@@ -197,7 +234,13 @@ function elementRulesAllowDependency({
         }
       }
       if (rule.allow) {
-        const match = ruleMatch(rule.allow, dependency, isMatch, element, rule.importKind);
+        const match = ruleMatch(
+          rule.allow,
+          dependency,
+          isMatch,
+          element,
+          rule.importKind,
+        );
         if (match.result) {
           return [true, match.report];
         }

package/src/helpers/utils.js

@@ -25,10 +25,20 @@ function replaceObjectValuesInTemplates(strings, object, namespace) {
     // If template is an array, replace key by value in all patterns
     if (isArray(result)) {
       return result.map((resultEntry) => {
-        return replaceObjectValueInTemplate(resultEntry, objectKey, object[objectKey], namespace);
+        return replaceObjectValueInTemplate(
+          resultEntry,
+          objectKey,
+          object[objectKey],
+          namespace,
+        );
       });
     }
-    return replaceObjectValueInTemplate(result, objectKey, object[objectKey], namespace);
+    return replaceObjectValueInTemplate(
+      result,
+      objectKey,
+      object[objectKey],
+      namespace,
+    );
   }, strings);
 }
 

package/src/helpers/validations.js

@@ -110,15 +110,24 @@ function rulesOptionsSchema(options = {}) {
 }
 
 function isValidElementTypesMatcher(matcher, settings) {
-  const mathcherToCheck = isArray(matcher) ? matcher[0] : matcher;
-  return !matcher || micromatch.some(getElementsTypeNames(settings), mathcherToCheck);
+  const matcherToCheck = isArray(matcher) ? matcher[0] : matcher;
+  return (
+    !matcher || micromatch.some(getElementsTypeNames(settings), matcherToCheck)
+  );
 }
 
 function validateElementTypesMatcher(elementsMatcher, settings) {
-  const [matcher] = isArray(elementsMatcher) ? elementsMatcher : [elementsMatcher];
-  if (!invalidMatchers.includes(matcher) && !isValidElementTypesMatcher(matcher, settings)) {
+  const [matcher] = isArray(elementsMatcher)
+    ? elementsMatcher
+    : [elementsMatcher];
+  if (
+    !invalidMatchers.includes(matcher) &&
+    !isValidElementTypesMatcher(matcher, settings)
+  ) {
     invalidMatchers.push(matcher);
-    warnOnce(`Option '${matcher}' does not match any element type from '${ELEMENTS}' setting`);
+    warnOnce(
+      `Option '${matcher}' does not match any element type from '${ELEMENTS}' setting`,
+    );
   }
 }
 
@@ -147,13 +156,18 @@ function validateElements(elements) {
             )}. Default value "${VALID_MODES[0]}" will be used instead`,
           );
         }
-        if (!element.pattern || !(isString(element.pattern) || isArray(element.pattern))) {
+        if (
+          !element.pattern ||
+          !(isString(element.pattern) || isArray(element.pattern))
+        ) {
           warnOnce(
             `Please provide a valid pattern to type ${element.type} in '${ELEMENTS}' setting`,
           );
         }
         if (element.capture && !isArray(element.capture)) {
-          warnOnce(`Invalid capture property of type ${element.type} in '${ELEMENTS}' setting`);
+          warnOnce(
+            `Invalid capture property of type ${element.type} in '${ELEMENTS}' setting`,
+          );
         }
       });
     }
@@ -178,7 +192,10 @@ function validateDependencyNodes(dependencyNodes) {
   }
 
   dependencyNodes.forEach((dependencyNode) => {
-    if (!isString(dependencyNode) || !defaultNodesNames.includes(dependencyNode)) {
+    if (
+      !isString(dependencyNode) ||
+      !defaultNodesNames.includes(dependencyNode)
+    ) {
       warnOnce(invalidFormatMessage);
     }
   });
@@ -204,7 +221,8 @@ function validateAdditionalDependencyNodes(additionalDependencyNodes) {
     const isValidObject =
       isObject(dependencyNode) &&
       isString(dependencyNode.selector) &&
-      (!dependencyNode.kind || VALID_DEPENDENCY_NODE_KINDS.includes(dependencyNode.kind));
+      (!dependencyNode.kind ||
+        VALID_DEPENDENCY_NODE_KINDS.includes(dependencyNode.kind));
 
     if (!isValidObject) {
       warnOnce(invalidFormatMessage);
@@ -222,7 +240,9 @@ function deprecateAlias(aliases) {
 
 function deprecateTypes(types) {
   if (types) {
-    warnOnce(`'${TYPES}' setting is deprecated. Please use '${ELEMENTS}' instead`);
+    warnOnce(
+      `'${TYPES}' setting is deprecated. Please use '${ELEMENTS}' instead`,
+    );
   }
 }
 

package/src/rules/element-types.js

@@ -3,7 +3,10 @@ const { RULE_ELEMENT_TYPES } = require("../constants/settings");
 const dependencyRule = require("../rules-factories/dependency-rule");
 
 const { rulesOptionsSchema } = require("../helpers/validations");
-const { isMatchElementType, elementRulesAllowDependency } = require("../helpers/rules");
+const {
+  isMatchElementType,
+  elementRulesAllowDependency,
+} = require("../helpers/rules");
 const {
   customErrorMessage,
   ruleElementMessage,
@@ -49,8 +52,17 @@ module.exports = dependencyRule(
     schema: rulesOptionsSchema(),
   },
   function ({ dependency, file, node, context, options }) {
-    if (dependency.isLocal && !dependency.isIgnored && dependency.type && !dependency.isInternal) {
-      const ruleData = elementRulesAllowDependencyType(file, dependency, options);
+    if (
+      dependency.isLocal &&
+      !dependency.isIgnored &&
+      dependency.type &&
+      !dependency.isInternal
+    ) {
+      const ruleData = elementRulesAllowDependencyType(
+        file,
+        dependency,
+        options,
+      );
       if (!ruleData.result) {
         context.report({
           message: errorMessage(ruleData, file, dependency),

package/src/rules/entry-point.js

@@ -25,7 +25,13 @@ function isMatchElementInternalPath(
   if (!isMatchImportKind(elementInfo, importKind)) {
     return { result: false };
   }
-  return isMatchElementKey(elementInfo, matcher, options, "internalPath", elementsCapturedValues);
+  return isMatchElementKey(
+    elementInfo,
+    matcher,
+    options,
+    "internalPath",
+    elementsCapturedValues,
+  );
 }
 
 function elementRulesAllowEntryPoint(element, dependency, options) {

package/src/rules/external.js

@@ -21,13 +21,19 @@ const { isArray } = require("../helpers/utils");
 function getSpecifiers(node) {
   if (node.parent.type === "ImportDeclaration") {
     return node.parent.specifiers
-      .filter((specifier) => specifier.type === "ImportSpecifier" && specifier.imported.name)
+      .filter(
+        (specifier) =>
+          specifier.type === "ImportSpecifier" && specifier.imported.name,
+      )
       .map((specifier) => specifier.imported.name);
   }
 
   if (node.parent.type === "ExportNamedDeclaration") {
     return node.parent.specifiers
-      .filter((specifier) => specifier.type === "ExportSpecifier" && specifier.exported.name)
+      .filter(
+        (specifier) =>
+          specifier.type === "ExportSpecifier" && specifier.exported.name,
+      )
       .map((specifier) => specifier.exported.name);
   }
 
@@ -78,7 +84,10 @@ function isMatchExternalDependency(
   if (!isMatchImportKind(dependency, importKind)) {
     return { result: false };
   }
-  const isMatch = micromatch.isMatch(dependency.baseModule, matcherWithTemplatesReplaced);
+  const isMatch = micromatch.isMatch(
+    dependency.baseModule,
+    matcherWithTemplatesReplaced,
+  );
   if (isMatch && options && Object.keys(options).length) {
     const isPathMatch = options.path
       ? pathMatch(dependency.path, options.path, elementsCapturedValues)
@@ -151,9 +160,13 @@ function errorMessage(ruleData, file, dependency) {
       dependency.baseModule
     }' ${fileReport}`;
   }
-  return `Usage of ${dependencyUsageKindMessage(ruleReport.importKind, dependency, {
-    suffix: " from ",
-  })}external module '${dependency.baseModule}' ${fileReport}`;
+  return `Usage of ${dependencyUsageKindMessage(
+    ruleReport.importKind,
+    dependency,
+    {
+      suffix: " from ",
+    },
+  )}external module '${dependency.baseModule}' ${fileReport}`;
 }
 
 module.exports = dependencyRule(

package/src/rules-factories/dependency-rule.js

@@ -18,14 +18,24 @@ module.exports = function (ruleMeta, rule, ruleOptions = {}) {
       const options = context.options[0];
       validateSettings(context.settings);
       const file = fileInfo(context);
-      if ((ruleOptions.validate !== false && !options) || file.isIgnored || !file.type) {
+      if (
+        (ruleOptions.validate !== false && !options) ||
+        file.isIgnored ||
+        !file.type
+      ) {
         return {};
       }
       if (ruleOptions.validate !== false) {
-        validateRules(context.settings, options.rules, ruleOptions.validateRules);
+        validateRules(
+          context.settings,
+          options.rules,
+          ruleOptions.validateRules,
+        );
       }
 
-      const dependencyNodesSetting = getArrayOrNull(context.settings[DEPENDENCY_NODES]);
+      const dependencyNodesSetting = getArrayOrNull(
+        context.settings[DEPENDENCY_NODES],
+      );
       const additionalDependencyNodesSetting = getArrayOrNull(
         context.settings[ADDITIONAL_DEPENDENCY_NODES],
       );