eslint-plugin-boundaries 3.2.0 → 3.4.0

package/README.md

@@ -228,6 +228,37 @@ Files or dependencies matching these [`micromatch` patterns](https://github.com/
 
 > Note: The `boundaries/include` option has preference over `boundaries/ignore`. If you define `boundaries/include`, use `boundaries/ignore` to ignore subsets of included files.
 
+#### __`boundaries/root-path`__
+
+Use this setting only if you are facing issues with the plugin when executing the lint command from a different path than the project root.
+
+<details>
+<summary>How to define the root path of the project</summary>
+
+By default, the plugin uses the current working directory (`process.cwd()`) as root path of the project. This path is used as the base path when resolving file matchers from rules and `boundaries/elements` settings. This is specially important when using the `basePattern` option or the `full` mode in the `boundaries/elements` setting. This may produce unexpected results [when the lint command is executed from a different path than the project root](https://github.com/javierbrea/eslint-plugin-boundaries/issues/296). To fix this, you can define a different root path using this option.
+
+For example, supposing that the `.eslintrc.js` file is located in the project root, you could define the root path as in:
+
+```js
+{
+  settings: {
+    "boundaries/root-path": path.resolve(__dirname)
+  }
+}
+```
+
+Note that the path should be absolute and resolved before passing it to the plugin. Otherwise, it will be resolved using the current working directory, and the problem will persist. In case you are defining the configuration in a `.eslintrc.(yml|json)` file, and you don't want to hardcode an absolute path, you can use the next environment variable to define the root path when executing the lint command:
+
+```bash
+ESLINT_PLUGIN_BOUNDARIES_ROOT_PATH=../../project-root npm run lint
+```
+
+You can also provide an absolute path in the environment variable, but it may be more useful to use a relative path to the project root. Remember that it will be resolved from the path where the lint command is executed.
+
+</details>
+
+
+
 ### Predefined configurations
 
 This plugin is distributed with two different predefined configurations: "recommended" and "strict".
@@ -261,7 +292,7 @@ Some rules require extra configuration, and it has to be defined in each specifi
 
 The docs of each rule contains an specification of their own options, but __the main rules share the format in which the options have to be defined__. The format described here is valid for options of [`element-types`](docs/rules/element-types.md), [`external`](docs/rules/external.md) and [`entry-point`](docs/rules/entry-point.md) rules.
 
-Options set an `allow` or `disallow` value by default, and provide an array of rules. Each matching rule will override the default value and the value returned by previous matching rules. So, the final result of the options, once processed for each case, will be `allow` or `disallow`, and this value will be applied by the plugin rule in the correspondant way, making it to produce an eslint error or not.
+Options set an `allow` or `disallow` value by default, and provide an array of rules. Each matching rule will override the default value and the value returned by previous matching rules. So, the final result of the options, once processed for each case, will be `allow` or `disallow`, and this value will be applied by the plugin rule in the correspondent way, making it to produce an eslint error or not.
 
 ```jsonc
 {
@@ -277,6 +308,8 @@ Options set an `allow` or `disallow` value by default, and provide an array of r
           "from": ["helpers"],
           // ...disallow importing this type of elements
           "disallow": ["modules", "components"],
+          // ..for this kind of imports (applies only when using TypeScript)
+          "importKind": "value",
           // ...and return this custom error message
           "message": "Helpers must not import other thing than helpers"
         },
@@ -300,6 +333,7 @@ Remember that:
 
 * __`from/target`__: `<element matchers>` Depending of the rule to which the options are for, the rule will be applied only if the file being analyzed matches with this element matcher (`from`), or the dependency being imported matches with this element matcher (`target`).
 * __`disallow/allow`__: `<value matchers>` If the plugin rule target matches with this, then the result of the rule will be "disallow/allow". Each rule will require a type of value here depending of what it is checking. In the case of the `element-types` rule, for example, another `<element matcher>` has to be provided in order to check the type of the local dependency.
+* __`importKind`__: `<string>` _Optional_. It is useful only when using TypeScript, as it allows to define if the rule applies when the dependency is being imported as a value or as a type. It can be also defined as an array of strings, or a micromatch pattern. Note that possible values to match with are `"value"`, `"type"` or `"typeof"`. For example, you could define that "components" can import "helpers" as a value, but not as a type. So, `import { helper } from "helpers/helper-a"` would be allowed, but `import type { Helper } from "helpers/helper-a"` would be disallowed.
 * __`message`__: `<string>` Optional. If the rule results in an error, the plugin will return this message instead of the default one. Read [error messages](#error-messages) for further info.
 
 > Tip: Properties `from/target` and `disallow/allow` can receive a single matcher, or an array of matchers.
@@ -340,6 +374,7 @@ Available properties in error templates both from `file` or `dependency` are:
 * `internalPath`: File path being analyzed or imported. Relative to the element's root path.
 * `source`: Available only for `dependency`. The source of the `import` statement as it is in the code.
 * `parent`: If the element is child of another element, it is also available in this property, which contains correspondent `type`, `internalPath` and captured properties as well.
+* `importKind`: Available only for `dependency` when using TypeScript. It contains the kind of import being analyzed. Possible values are `"value"`, `"type"` or `"typeof"`.
 * ...All captured properties are also available
 
 > Tip: Read ["Global settings"](#global-settings) for further info about how to capture values from elements.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-boundaries",
-  "version": "3.2.0",
+  "version": "3.4.0",
   "description": "Eslint plugin checking architecture boundaries between elements",
   "keywords": [
     "eslint",
@@ -32,21 +32,24 @@
   },
   "dependencies": {
     "chalk": "4.1.2",
-    "eslint-import-resolver-node": "0.3.7",
-    "eslint-module-utils": "2.7.4",
-    "is-core-module": "2.11.0",
+    "eslint-import-resolver-node": "0.3.9",
+    "eslint-module-utils": "2.8.0",
+    "is-core-module": "2.13.0",
     "micromatch": "4.0.5"
   },
   "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "6.4.0",
+    "@typescript-eslint/parser": "6.4.0",
     "cross-env": "7.0.3",
-    "eslint": "8.37.0",
-    "eslint-config-prettier": "8.8.0",
-    "eslint-plugin-prettier": "4.2.1",
+    "eslint": "8.47.0",
+    "eslint-config-prettier": "9.0.0",
+    "eslint-import-resolver-typescript": "3.6.0",
+    "eslint-plugin-prettier": "5.0.0",
     "husky": "8.0.3",
     "is-ci": "3.0.1",
-    "jest": "29.5.0",
-    "lint-staged": "13.2.0",
-    "prettier": "2.8.7"
+    "jest": "29.6.2",
+    "lint-staged": "14.0.0",
+    "prettier": "3.0.1"
   },
   "lint-staged": {
     "test/**/*.js": "eslint",

package/src/constants/plugin.js

@@ -1,5 +1,7 @@
 const PLUGIN_NAME = "boundaries";
+const PLUGIN_ENV_VARS_PREFIX = "ESLINT_PLUGIN_BOUNDARIES";
 
 module.exports = {
   PLUGIN_NAME,
+  PLUGIN_ENV_VARS_PREFIX,
 };

package/src/constants/settings.js

@@ -1,4 +1,4 @@
-const { PLUGIN_NAME } = require("./plugin");
+const { PLUGIN_NAME, PLUGIN_ENV_VARS_PREFIX } = require("./plugin");
 
 const {
   ELEMENT_TYPES,
@@ -15,6 +15,11 @@ module.exports = {
   ELEMENTS: `${PLUGIN_NAME}/elements`,
   IGNORE: `${PLUGIN_NAME}/ignore`,
   INCLUDE: `${PLUGIN_NAME}/include`,
+  ROOT_PATH: `${PLUGIN_NAME}/root-path`,
+
+  // env vars
+  DEBUG: `${PLUGIN_ENV_VARS_PREFIX}_DEBUG`,
+  ENV_ROOT_PATH: `${PLUGIN_ENV_VARS_PREFIX}_ROOT_PATH`,
 
   // rules
   RULE_ELEMENT_TYPES: `${PLUGIN_NAME}/${ELEMENT_TYPES}`,

package/src/core/dependencyInfo.js

@@ -1,8 +1,7 @@
 const { fileInfo, importInfo } = require("./elementsInfo");
 
 function getParent(elementInfo) {
-  const parent = elementInfo.parents && elementInfo.parents[0];
-  return parent && parent.elementPath;
+  return elementInfo.parents?.[0]?.elementPath;
 }
 
 function getCommonAncestor(elementInfoA, elementInfoB) {
@@ -11,7 +10,7 @@ function getCommonAncestor(elementInfoA, elementInfoB) {
       return elementParentA.elementPath === elementParentB.elementPath;
     });
   });
-  return commonAncestor && commonAncestor.elementPath;
+  return commonAncestor?.elementPath;
 }
 
 function isUncle(elementA, elementB) {
@@ -65,12 +64,13 @@ function dependencyRelationship(dependency, element) {
   return null;
 }
 
-function dependencyInfo(source, context) {
+function dependencyInfo(source, importKind, context) {
   const elementInfo = fileInfo(context);
   const dependency = importInfo(source, context);
 
   return {
     ...dependency,
+    importKind: importKind || "value",
     relationship: dependencyRelationship(dependency, elementInfo),
     isInternal: isInternal(dependency, elementInfo),
   };

package/src/core/elementsInfo.js

@@ -3,7 +3,7 @@ const micromatch = require("micromatch");
 const resolve = require("eslint-module-utils/resolve").default;
 
 const { IGNORE, INCLUDE, VALID_MODES } = require("../constants/settings");
-const { getElements } = require("../helpers/settings");
+const { getElements, getRootPath } = require("../helpers/settings");
 const { debugFileInfo } = require("../helpers/debug");
 const { isArray } = require("../helpers/utils");
 
@@ -126,12 +126,12 @@ function elementTypeAndParents(path, settings) {
                   path
                     .split("/")
                     .slice(0, path.split("/").length - lastSegmentMatching)
-                    .join("/")
+                    .join("/"),
                 );
               }
               const capture = micromatch.capture(
                 pattern,
-                useFullPathMatch ? path : accumulator.join("/")
+                useFullPathMatch ? path : accumulator.join("/"),
               );
 
               if (capture && basePatternCapture) {
@@ -171,7 +171,7 @@ function elementTypeAndParents(path, settings) {
         });
         return { accumulator, lastSegmentMatching };
       },
-      { accumulator: [], lastSegmentMatching: 0 }
+      { accumulator: [], lastSegmentMatching: 0 },
     );
 
   return {
@@ -184,9 +184,9 @@ function replacePathSlashes(absolutePath) {
   return absolutePath.replace(/\\/g, "/");
 }
 
-function projectPath(absolutePath) {
+function projectPath(absolutePath, rootPath) {
   if (absolutePath) {
-    return replacePathSlashes(absolutePath).replace(`${replacePathSlashes(process.cwd())}/`, "");
+    return replacePathSlashes(absolutePath).replace(`${replacePathSlashes(rootPath)}/`, "");
   }
 }
 
@@ -195,7 +195,7 @@ function externalModulePath(source, baseModuleValue) {
 }
 
 function importInfo(source, context) {
-  const path = projectPath(resolve(source, context));
+  const path = projectPath(resolve(source, context), getRootPath(context.settings));
   const isExternalModule = isExternal(source, path);
   const resultCache = importsCache.load(isExternalModule ? source : path, context.settings);
   let elementCache;
@@ -237,7 +237,7 @@ function importInfo(source, context) {
 }
 
 function fileInfo(context) {
-  const path = projectPath(context.getFilename());
+  const path = projectPath(context.getFilename(), getRootPath(context.settings));
   const resultCache = filesCache.load(path, context.settings);
   let elementCache;
   let result;

package/src/helpers/debug.js

@@ -1,6 +1,7 @@
 const chalk = require("chalk");
 
 const { PLUGIN_NAME } = require("../constants/plugin");
+const { isDebugModeEnabled } = require("./settings");
 
 const warns = [];
 const debuggedFiles = [];
@@ -13,12 +14,6 @@ function warn(message) {
   trace(message, "yellow");
 }
 
-function debug(message) {
-  if (process.env.ESLINT_PLUGIN_BOUNDARIES_DEBUG) {
-    trace(message, "grey");
-  }
-}
-
 function success(message) {
   trace(message, "green");
 }
@@ -32,7 +27,7 @@ function warnOnce(message) {
 
 function debugFileInfo(fileInfo) {
   const fileInfoKey = fileInfo.path || fileInfo.source;
-  if (process.env.ESLINT_PLUGIN_BOUNDARIES_DEBUG && !debuggedFiles.includes(fileInfoKey)) {
+  if (isDebugModeEnabled() && !debuggedFiles.includes(fileInfoKey)) {
     debuggedFiles.push(fileInfoKey);
     if (fileInfo.type) {
       success(`'${fileInfoKey}' is of type '${fileInfo.type}'`);
@@ -44,7 +39,6 @@ function debugFileInfo(fileInfo) {
 }
 
 module.exports = {
-  debug,
   success,
   debugFileInfo,
   warnOnce,

package/src/helpers/messages.js

@@ -22,7 +22,7 @@ function propertiesConcater(properties, index) {
 function micromatchPatternMessage(micromatchPatterns, elementCapturedValues) {
   const micromatchPatternsWithValues = micromatchPatternReplacingObjectsValues(
     micromatchPatterns,
-    { from: elementCapturedValues }
+    { from: elementCapturedValues },
   );
   if (isArray(micromatchPatternsWithValues)) {
     if (micromatchPatternsWithValues.length === 1) {
@@ -60,7 +60,7 @@ function elementMatcherMessage(elementMatcher, elementCapturedValues) {
   }
   return `${typeMessage(elementMatcher[0])}${capturedValuesMatcherMessage(
     elementMatcher[1],
-    elementCapturedValues
+    elementCapturedValues,
   )}`;
 }
 
@@ -85,6 +85,7 @@ function elementPropertiesToReplaceInTemplate(element) {
     type: element.type,
     internalPath: element.internalPath,
     source: element.source,
+    importKind: element.importKind,
   };
 }
 
@@ -92,39 +93,39 @@ function customErrorMessage(message, file, dependency, report = {}) {
   let replacedMessage = replaceObjectValuesInTemplates(
     replaceObjectValuesInTemplates(message, elementPropertiesToReplaceInTemplate(file), "file"),
     elementPropertiesToReplaceInTemplate(dependency),
-    "dependency"
+    "dependency",
   );
   replacedMessage = replaceObjectValuesInTemplates(
     replaceObjectValuesInTemplates(
       replacedMessage,
       elementPropertiesToReplaceInTemplate(file),
-      "from"
+      "from",
     ),
     elementPropertiesToReplaceInTemplate(dependency),
-    "target"
+    "target",
   );
   if (file.parents[0]) {
     replacedMessage = replaceObjectValuesInTemplates(
       replacedMessage,
       elementPropertiesToReplaceInTemplate(file.parents[0]),
-      "file.parent"
+      "file.parent",
     );
     replacedMessage = replaceObjectValuesInTemplates(
       replacedMessage,
       elementPropertiesToReplaceInTemplate(file.parents[0]),
-      "from.parent"
+      "from.parent",
     );
   }
   if (dependency.parents[0]) {
     replacedMessage = replaceObjectValuesInTemplates(
       replacedMessage,
       elementPropertiesToReplaceInTemplate(dependency.parents[0]),
-      "dependency.parent"
+      "dependency.parent",
     );
     replacedMessage = replaceObjectValuesInTemplates(
       replacedMessage,
       elementPropertiesToReplaceInTemplate(dependency.parents[0]),
-      "target.parent"
+      "target.parent",
     );
   }
   return replaceObjectValuesInTemplates(replacedMessage, report, "report");
@@ -148,13 +149,37 @@ function elementCapturedValuesMessage(capturedValues) {
 
 function elementMessage(elementInfo) {
   return `of type ${quote(elementInfo.type)}${elementCapturedValuesMessage(
-    elementInfo.capturedValues
+    elementInfo.capturedValues,
   )}`;
 }
 
+function hasToPrintKindMessage(ruleImportKind, dependencyInfo) {
+  return ruleImportKind && dependencyInfo.importKind;
+}
+
+function dependencyImportKindMessage(ruleImportKind, dependencyInfo) {
+  if (hasToPrintKindMessage(ruleImportKind, dependencyInfo)) {
+    return `kind ${quote(dependencyInfo.importKind)} from `;
+  }
+  return "";
+}
+
+function dependencyUsageKindMessage(
+  ruleImportKind,
+  dependencyInfo,
+  { suffix = " ", prefix = "" } = {},
+) {
+  if (hasToPrintKindMessage(ruleImportKind, dependencyInfo)) {
+    return `${prefix}${dependencyInfo.importKind}${suffix}`;
+  }
+  return "";
+}
+
 module.exports = {
   quote,
   ruleElementMessage,
   customErrorMessage,
   elementMessage,
+  dependencyImportKindMessage,
+  dependencyUsageKindMessage,
 };

package/src/helpers/rules.js

@@ -62,9 +62,12 @@ function micromatchPatternReplacingObjectsValues(pattern, object) {
 function isObjectMatch(objectWithMatchers, object, objectsWithValuesToReplace) {
   return Object.keys(objectWithMatchers).reduce((isMatch, key) => {
     if (isMatch) {
+      if (!object) {
+        return false;
+      }
       const micromatchPattern = micromatchPatternReplacingObjectsValues(
         objectWithMatchers[key],
-        objectsWithValuesToReplace
+        objectsWithValuesToReplace,
       );
       return micromatch.isMatch(object[key], micromatchPattern);
     }
@@ -76,17 +79,23 @@ function rulesMainKey(key) {
   return key || FROM;
 }
 
-function ruleMatch(ruleMatchers, targetElement, isMatch, fromElement) {
+function ruleMatch(ruleMatchers, targetElement, isMatch, fromElement, importKind) {
   let match = { result: false, report: null };
   const matchers = !isArray(ruleMatchers) ? [ruleMatchers] : ruleMatchers;
   matchers.forEach((matcher) => {
     if (!match.result) {
       if (isArray(matcher)) {
         const [value, captures] = matcher;
-        match = isMatch(targetElement, value, captures, {
-          from: fromElement.capturedValues,
-          target: targetElement.capturedValues,
-        });
+        match = isMatch(
+          targetElement,
+          value,
+          captures,
+          {
+            from: fromElement.capturedValues,
+            target: targetElement.capturedValues,
+          },
+          importKind,
+        );
       } else {
         match = isMatch(
           targetElement,
@@ -95,7 +104,8 @@ function ruleMatch(ruleMatchers, targetElement, isMatch, fromElement) {
           {
             from: fromElement.capturedValues,
             target: targetElement.capturedValues,
-          }
+          },
+          importKind,
         );
       }
     }
@@ -108,11 +118,11 @@ function isMatchElementKey(
   matcher,
   options,
   elementKey,
-  elementsToCompareCapturedValues
+  elementsToCompareCapturedValues,
 ) {
   const isMatch = micromatch.isMatch(
     elementInfo[elementKey],
-    micromatchPatternReplacingObjectsValues(matcher, elementsToCompareCapturedValues)
+    micromatchPatternReplacingObjectsValues(matcher, elementsToCompareCapturedValues),
   );
   if (isMatch && options) {
     return {
@@ -124,7 +134,23 @@ function isMatchElementKey(
   };
 }
 
-function isMatchElementType(elementInfo, matcher, options, elementsToCompareCapturedValues) {
+function isMatchImportKind(elementInfo, importKind) {
+  if (!elementInfo.importKind || !importKind) {
+    return true;
+  }
+  return micromatch.isMatch(elementInfo.importKind, importKind);
+}
+
+function isMatchElementType(
+  elementInfo,
+  matcher,
+  options,
+  elementsToCompareCapturedValues,
+  importKind,
+) {
+  if (!isMatchImportKind(elementInfo, importKind)) {
+    return { result: false };
+  }
   return isMatchElementKey(elementInfo, matcher, options, "type", elementsToCompareCapturedValues);
 }
 
@@ -166,11 +192,11 @@ function elementRulesAllowDependency({
   const [result, report, ruleReport] = getElementRules(
     elementToGetRulesFrom(element, dependency, mainKey),
     options,
-    mainKey
+    mainKey,
   ).reduce(
     (allowed, rule) => {
       if (rule.disallow) {
-        const match = ruleMatch(rule.disallow, dependency, isMatch, element);
+        const match = ruleMatch(rule.disallow, dependency, isMatch, element, rule.importKind);
         if (match.result) {
           return [
             false,
@@ -180,12 +206,13 @@ function elementRulesAllowDependency({
               disallow: rule.disallow,
               index: rule.index,
               message: rule.message || options.message,
+              importKind: rule.importKind,
             },
           ];
         }
       }
       if (rule.allow) {
-        const match = ruleMatch(rule.allow, dependency, isMatch, element);
+        const match = ruleMatch(rule.allow, dependency, isMatch, element, rule.importKind);
         if (match.result) {
           return [true, match.report];
         }
@@ -199,7 +226,7 @@ function elementRulesAllowDependency({
         isDefault: true,
         message: options.message,
       },
-    ]
+    ],
   );
   return {
     result,
@@ -218,4 +245,5 @@ module.exports = {
   getElementRules,
   rulesMainKey,
   micromatchPatternReplacingObjectsValues,
+  isMatchImportKind,
 };

package/src/helpers/settings.js

@@ -1,5 +1,13 @@
-const { TYPES, ELEMENTS, VALID_MODES } = require("../constants/settings");
+const {
+  TYPES,
+  ELEMENTS,
+  VALID_MODES,
+  ROOT_PATH,
+  ENV_ROOT_PATH,
+  DEBUG,
+} = require("../constants/settings");
 const { isString } = require("./utils");
+const { isAbsolute, resolve } = require("path");
 
 function isLegacyType(type) {
   return isString(type);
@@ -34,8 +42,24 @@ function getElementsTypeNames(settings) {
   return getElements(settings).map((element) => element.type);
 }
 
+function getRootPath(settings) {
+  const rootPathUserSetting = process.env[ENV_ROOT_PATH] || settings[ROOT_PATH];
+  if (rootPathUserSetting) {
+    return isAbsolute(rootPathUserSetting)
+      ? rootPathUserSetting
+      : resolve(process.cwd(), rootPathUserSetting);
+  }
+  return process.cwd();
+}
+
+function isDebugModeEnabled() {
+  return process.env[DEBUG];
+}
+
 module.exports = {
   isLegacyType,
   getElements,
   getElementsTypeNames,
+  isDebugModeEnabled,
+  getRootPath,
 };

package/src/helpers/utils.js

@@ -8,7 +8,8 @@ function isArray(object) {
 
 function replaceObjectValueInTemplate(template, key, value, namespace) {
   const keyToReplace = namespace ? `${namespace}.${key}` : key;
-  return template.replace(`\${${keyToReplace}}`, value);
+  const regexp = new RegExp(`\\$\\{${keyToReplace}\\}`, "g");
+  return template.replace(regexp, value);
 }
 
 function replaceObjectValuesInTemplates(strings, object, namespace) {

package/src/helpers/validations.js

@@ -63,6 +63,19 @@ function rulesOptionsSchema(options = {}) {
               [mainKey]: elementsMatcherSchema(),
               allow: elementsMatcherSchema(options.targetMatcherOptions),
               disallow: elementsMatcherSchema(options.targetMatcherOptions),
+              importKind: {
+                oneOf: [
+                  {
+                    type: "string",
+                  },
+                  {
+                    type: "array",
+                    items: {
+                      type: "string",
+                    },
+                  },
+                ],
+              },
               message: {
                 type: "string",
               },
@@ -109,7 +122,7 @@ function validateElements(elements) {
     // TODO, remove in next major version
     if (isLegacyType(element)) {
       warnOnce(
-        `Defining elements as strings in settings is deprecated. Will be automatically converted, but this feature will be removed in next major versions`
+        `Defining elements as strings in settings is deprecated. Will be automatically converted, but this feature will be removed in next major versions`,
       );
     } else {
       Object.keys(element).forEach(() => {
@@ -119,8 +132,8 @@ function validateElements(elements) {
         if (element.mode && !VALID_MODES.includes(element.mode)) {
           warnOnce(
             `Invalid mode property in '${ELEMENTS}' setting. Should be one of ${VALID_MODES.join(
-              ","
-            )}. Default value "${VALID_MODES[0]}" will be used instead`
+              ",",
+            )}. Default value "${VALID_MODES[0]}" will be used instead`,
           );
         }
         if (!element.pattern || !(isString(element.pattern) || isArray(element.pattern))) {
@@ -137,7 +150,7 @@ function validateElements(elements) {
 function deprecateAlias(aliases) {
   if (aliases) {
     warnOnce(
-      `Defining aliases in '${ALIAS}' setting is deprecated. Please use 'import/resolver' setting`
+      `Defining aliases in '${ALIAS}' setting is deprecated. Please use 'import/resolver' setting`,
     );
   }
 }

package/src/index.js

@@ -1,3 +1,4 @@
+const packageJson = require("../package.json");
 const rules = require("./constants/rules");
 const recommendedConfig = require("./configs/recommended");
 const strictConfig = require("./configs/strict");
@@ -17,6 +18,10 @@ const importRules = (ruleNames) => {
 // export all configs
 
 module.exports = {
+  meta: {
+    name: packageJson.name,
+    version: packageJson.version,
+  },
   rules: importRules(rules),
   configs: {
     recommended: recommendedConfig,

package/src/rules/element-types.js

@@ -8,7 +8,12 @@ const {
   isMatchElementType,
   elementRulesAllowDependency,
 } = require("../helpers/rules");
-const { customErrorMessage, ruleElementMessage, elementMessage } = require("../helpers/messages");
+const {
+  customErrorMessage,
+  ruleElementMessage,
+  elementMessage,
+  dependencyImportKindMessage,
+} = require("../helpers/messages");
 
 function elementRulesAllowDependencyType(element, dependency, options) {
   return elementRulesAllowDependency({
@@ -26,15 +31,18 @@ function errorMessage(ruleData, file, dependency) {
   }
   if (ruleReport.isDefault) {
     return `No rule allowing this dependency was found. File is ${elementMessage(
-      file
+      file,
     )}. Dependency is ${elementMessage(dependency)}`;
   }
-  return `Importing ${ruleElementMessage(
+  return `Importing ${dependencyImportKindMessage(
+    ruleReport.importKind,
+    dependency,
+  )}${ruleElementMessage(
     ruleReport.disallow,
-    file.capturedValues
+    file.capturedValues,
   )} is not allowed in ${ruleElementMessage(
     ruleReport.element,
-    file.capturedValues
+    file.capturedValues,
   )}. Disallowed in rule ${ruleReport.index + 1}`;
 }
 
@@ -55,5 +63,5 @@ module.exports = dependencyRule(
         });
       }
     }
-  }
+  },
 );

package/src/rules/entry-point.js

@@ -7,10 +7,25 @@ const {
   dependencyLocation,
   isMatchElementKey,
   elementRulesAllowDependency,
+  isMatchImportKind,
 } = require("../helpers/rules");
-const { customErrorMessage, ruleElementMessage, elementMessage } = require("../helpers/messages");
+const {
+  customErrorMessage,
+  ruleElementMessage,
+  elementMessage,
+  dependencyUsageKindMessage,
+} = require("../helpers/messages");
 
-function isMatchElementInternalPath(elementInfo, matcher, options, elementsCapturedValues) {
+function isMatchElementInternalPath(
+  elementInfo,
+  matcher,
+  options,
+  elementsCapturedValues,
+  importKind,
+) {
+  if (!isMatchImportKind(elementInfo, importKind)) {
+    return { result: false };
+  }
   return isMatchElementKey(elementInfo, matcher, options, "internalPath", elementsCapturedValues);
 }
 
@@ -36,8 +51,11 @@ function errorMessage(ruleData, file, dependency) {
   }
   return `The entry point '${dependency.internalPath}' is not allowed in ${ruleElementMessage(
     ruleReport.element,
-    dependency.capturedValues
-  )}. Disallowed in rule ${ruleReport.index + 1}`;
+    dependency.capturedValues,
+  )}${dependencyUsageKindMessage(ruleReport.importKind, dependency, {
+    prefix: " when importing ",
+    suffix: "",
+  })}. Disallowed in rule ${ruleReport.index + 1}`;
 }
 
 module.exports = dependencyRule(
@@ -62,5 +80,5 @@ module.exports = dependencyRule(
   },
   {
     validateRules: { onlyMainKey: true, mainKey: "target" },
-  }
+  },
 );

package/src/rules/external.js

@@ -9,8 +9,14 @@ const {
   dependencyLocation,
   elementRulesAllowDependency,
   micromatchPatternReplacingObjectsValues,
+  isMatchImportKind,
 } = require("../helpers/rules");
-const { customErrorMessage, ruleElementMessage, elementMessage } = require("../helpers/messages");
+const {
+  customErrorMessage,
+  ruleElementMessage,
+  elementMessage,
+  dependencyUsageKindMessage,
+} = require("../helpers/messages");
 const { isArray } = require("../helpers/utils");
 
 function specifiersMatch(specifiers, specifierOptions, elementsCapturedValues) {
@@ -22,7 +28,7 @@ function specifiersMatch(specifiers, specifierOptions, elementsCapturedValues) {
   return specifierOptions.reduce((found, option) => {
     const matcherWithTemplateReplaced = micromatchPatternReplacingObjectsValues(
       option,
-      elementsCapturedValues
+      elementsCapturedValues,
     );
     if (micromatch.some(importedSpecifiersNames, matcherWithTemplateReplaced)) {
       found.push(option);
@@ -39,7 +45,7 @@ function pathMatch(path, pathOptions, elementsCapturedValues) {
     }
     const matcherWithTemplateReplaced = micromatchPatternReplacingObjectsValues(
       option,
-      elementsCapturedValues
+      elementsCapturedValues,
     );
     if (micromatch.some(path, matcherWithTemplateReplaced)) {
       isMatch = true;
@@ -48,11 +54,20 @@ function pathMatch(path, pathOptions, elementsCapturedValues) {
   }, false);
 }
 
-function isMatchExternalDependency(dependency, matcher, options, elementsCapturedValues) {
+function isMatchExternalDependency(
+  dependency,
+  matcher,
+  options,
+  elementsCapturedValues,
+  importKind,
+) {
   const matcherWithTemplatesReplaced = micromatchPatternReplacingObjectsValues(
     matcher,
-    elementsCapturedValues
+    elementsCapturedValues,
   );
+  if (!isMatchImportKind(dependency, importKind)) {
+    return { result: false };
+  }
   const isMatch = micromatch.isMatch(dependency.baseModule, matcherWithTemplatesReplaced);
   if (isMatch && options && Object.keys(options).length) {
     const isPathMatch = options.path
@@ -62,7 +77,7 @@ function isMatchExternalDependency(dependency, matcher, options, elementsCapture
       const specifiersResult = specifiersMatch(
         dependency.specifiers,
         options.specifiers,
-        elementsCapturedValues
+        elementsCapturedValues,
       );
       return {
         result: specifiersResult.length > 0,
@@ -103,9 +118,8 @@ function errorMessage(ruleData, file, dependency) {
   const ruleReport = ruleData.ruleReport;
   if (ruleReport.message) {
     return customErrorMessage(ruleReport.message, file, dependency, {
-      specifiers:
-        ruleData.report && ruleData.report.specifiers && ruleData.report.specifiers.join(", "),
-      path: ruleData.report && ruleData.report.path,
+      specifiers: ruleData.report?.specifiers?.join(", "),
+      path: ruleData.report?.path,
     });
   }
   if (ruleReport.isDefault) {
@@ -116,15 +130,20 @@ function errorMessage(ruleData, file, dependency) {
 
   const fileReport = `is not allowed in ${ruleElementMessage(
     ruleReport.element,
-    file.capturedValues
+    file.capturedValues,
   )}. Disallowed in rule ${ruleReport.index + 1}`;
 
   if (ruleData.report) {
-    return `Usage of '${getErrorReportMessage(ruleData.report)}' from external module '${
+    return `Usage of ${dependencyUsageKindMessage(
+      ruleReport.importKind,
+      dependency,
+    )}'${getErrorReportMessage(ruleData.report)}' from external module '${
       dependency.baseModule
     }' ${fileReport}`;
   }
-  return `Usage of external module '${dependency.baseModule}' ${fileReport}`;
+  return `Usage of ${dependencyUsageKindMessage(ruleReport.importKind, dependency, {
+    suffix: " from ",
+  })}external module '${dependency.baseModule}' ${fileReport}`;
 }
 
 module.exports = dependencyRule(
@@ -164,7 +183,7 @@ module.exports = dependencyRule(
       const ruleData = elementRulesAllowExternalDependency(
         file,
         { ...dependency, specifiers: node.source.parent.specifiers },
-        options
+        options,
       );
       if (!ruleData.result) {
         context.report({
@@ -177,5 +196,5 @@ module.exports = dependencyRule(
   },
   {
     validateRules: { onlyMainKey: true },
-  }
+  },
 );

package/src/rules/no-ignored.js

@@ -20,5 +20,5 @@ module.exports = dependencyRule(
   },
   {
     validate: false,
-  }
+  },
 );

package/src/rules/no-private.js

@@ -40,7 +40,7 @@ module.exports = dependencyRule(
       dependency.relationship !== "internal" &&
       dependency.relationship !== "child" &&
       dependency.relationship !== "brother" &&
-      (!options || !options.allowUncles || dependency.relationship !== "uncle")
+      (!options?.allowUncles || dependency.relationship !== "uncle")
     ) {
       context.report({
         message: errorMessage(file, dependency, options),
@@ -51,5 +51,5 @@ module.exports = dependencyRule(
   },
   {
     validate: false,
-  }
+  },
 );

package/src/rules/no-unknown.js

@@ -20,5 +20,5 @@ module.exports = dependencyRule(
   },
   {
     validate: false,
-  }
+  },
 );

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

@@ -21,7 +21,7 @@ module.exports = function (ruleMeta, rule, ruleOptions = {}) {
 
       return {
         ImportDeclaration: (node) => {
-          const dependency = dependencyInfo(node.source.value, context);
+          const dependency = dependencyInfo(node.source.value, node.importKind, context);
 
           rule({ file, dependency, options, node, context });
         },