@boundaries/eslint-plugin 5.3.1 → 6.0.0-beta.1

package/README.md

@@ -25,8 +25,8 @@ Enforce architectural boundaries in your JavaScript and TypeScript projects.
 
 **ESLint Plugin Boundaries** is an ESLint plugin that helps you maintain clean architecture by enforcing boundaries between different parts of your codebase. Define your architectural layers, specify how they can interact, and get instant feedback when boundaries are violated.
 
-- **Architectural Enforcement**: Define element types and dependency rules that match your project's architecture
-- **Flexible Configuration**: Adapt the plugin to any project structure. It works with monorepos, modular architectures, layered patterns, and more
+- **Architectural Enforcement**: Define elements and dependency rules that match your project's architecture
+- **Flexible Configuration**: Adapt the plugin to any project structure. It works with monorepos, modular architectures, layered patterns, and any custom structure you can imagine
 - **Real-time Feedback**: Get immediate ESLint errors when imports violate your architectural rules
 
 ## Documentation
@@ -63,9 +63,9 @@ export default [
     plugins: { boundaries },
     settings: {
       "boundaries/elements": [
-        { type: "controllers", pattern: "controllers/*" },
-        { type: "models", pattern: "models/*" },
-        { type: "views", pattern: "views/*" }
+        { type: "controller", pattern: "controllers/*" },
+        { type: "model", pattern: "models/*" },
+        { type: "view", pattern: "views/*" }
       ]
     }
   }
@@ -77,12 +77,12 @@ Define your dependency rules:
 ```javascript
 {
   rules: {
-    "boundaries/element-types": [2, {
+    "boundaries/dependencies": [2, {
       default: "disallow",
       rules: [
-        { from: "controllers", allow: ["models", "views"] },
-        { from: "views", allow: ["models"] },
-        { from: "models", disallow: ["*"] }
+        { from: { type: "controller" }, allow: { to: { type: ["model", "view"] } } },
+        { from: { type: "view" }, allow: { to: { type: "model" } } },
+        { from: { type: "model" }, disallow: { to: { type: "*" } } }
       ]
     }]
   }

package/dist/Config/Config.d.ts

@@ -1,7 +1,10 @@
 import type { Linter } from "eslint";
-import type { PluginBoundaries, Config } from "../Settings";
-import { PLUGIN_NAME } from "../Settings";
+import type { PluginBoundaries, Config } from "../Shared";
+import { PLUGIN_NAME } from "../Shared";
 export * from "../Public";
+/**
+ * The full ESLint config object returned by createConfig, including the plugins field with the boundaries plugin registered.
+ */
 type PluginFullConfig<PluginName extends string = typeof PLUGIN_NAME> = {
     plugins: Record<PluginName, PluginBoundaries>;
     files: Linter.Config["files"];
@@ -28,7 +31,7 @@ type PluginFullConfig<PluginName extends string = typeof PLUGIN_NAME> = {
  *   },
  *   rules: {
  *     ...recommended.rules,
- *     "boundaries/element-types": ["error", { default: "disallow" }],
+ *     "boundaries/dependencies": ["error", { default: "disallow" }],
  *   }
  * });
  *

package/dist/Config/Config.js

@@ -21,31 +21,42 @@ exports.strict = exports.recommended = void 0;
 exports.createConfig = createConfig;
 const index_1 = __importDefault(require("../index"));
 const Settings_1 = require("../Settings");
+const Shared_1 = require("../Shared");
 const Recommended_1 = __importDefault(require("./Recommended"));
 const Strict_1 = __importDefault(require("./Strict"));
 __exportStar(require("../Public"), exports);
+/**
+ * Rewrites rule keys to the effective plugin namespace used by `createConfig`.
+ *
+ * It accepts rules prefixed either with the default plugin name (`boundaries`)
+ * or with the custom plugin name passed to `createConfig`.
+ *
+ * @param pluginName - Plugin namespace to enforce in output rule keys.
+ * @param rules - Input rule entries from the user config.
+ * @returns Rules object normalized to the requested plugin namespace.
+ */
 function renamePluginRules(pluginName, rules) {
     if (!rules) {
         return {};
     }
-    const allowedPrefixes = new Set([Settings_1.PLUGIN_NAME, pluginName]);
+    const allowedPrefixes = new Set([Shared_1.PLUGIN_NAME, pluginName]);
     // Return the same rules objects, but converting plugin default rule keys with provided plugin name
     return Object.entries(rules).reduce((acc, [key, value]) => {
         if (!key.includes("/")) {
-            throw new Error(`Invalid rule key "${key}". When using createConfig, all rules must belong to eslint-plugin-boundaries. You can prefix them with the original plugin name "${Settings_1.PLUGIN_NAME}/", or with the provided plugin name "${pluginName}/".`);
+            throw new Error(`Invalid rule key "${key}". When using createConfig, all rules must belong to eslint-plugin-boundaries. You can prefix them with the original plugin name "${Shared_1.PLUGIN_NAME}/", or with the provided plugin name "${pluginName}/".`);
         }
         const splittedRuleKey = key.split("/");
         const rulePrefix = splittedRuleKey[0];
         const ruleName = splittedRuleKey[1];
         if (!allowedPrefixes.has(rulePrefix)) {
-            throw new Error(`Invalid rule key "${key}". When using createConfig, all rules must belong to eslint-plugin-boundaries. You can prefix them with the original plugin name "${Settings_1.PLUGIN_NAME}/", or with the provided plugin name "${pluginName}/".`);
+            throw new Error(`Invalid rule key "${key}". When using createConfig, all rules must belong to eslint-plugin-boundaries. You can prefix them with the original plugin name "${Shared_1.PLUGIN_NAME}/", or with the provided plugin name "${pluginName}/".`);
         }
         if (!(0, Settings_1.isRuleShortName)(ruleName)) {
             throw new Error(`Invalid rule name "${ruleName}". When using createConfig, all rules must belong to eslint-plugin-boundaries.`);
         }
         let newKey;
-        if (rulePrefix === Settings_1.PLUGIN_NAME) {
-            const suffix = key.slice(Settings_1.PLUGIN_NAME.length + 1);
+        if (rulePrefix === Shared_1.PLUGIN_NAME) {
+            const suffix = key.slice(Shared_1.PLUGIN_NAME.length + 1);
             newKey = `${pluginName}/${suffix}`;
         }
         else {
@@ -77,14 +88,14 @@ function renamePluginRules(pluginName, rules) {
  *   },
  *   rules: {
  *     ...recommended.rules,
- *     "boundaries/element-types": ["error", { default: "disallow" }],
+ *     "boundaries/dependencies": ["error", { default: "disallow" }],
  *   }
  * });
  *
  * export default [config];
  * ```
  */
-function createConfig(config, name = Settings_1.PLUGIN_NAME) {
+function createConfig(config, name = Shared_1.PLUGIN_NAME) {
     const pluginsRegistration = {
         [name]: index_1.default,
     };

package/dist/Config/Recommended.d.ts

@@ -1,4 +1,4 @@
-import type { Config } from "../Settings";
+import type { Config } from "../Shared";
 /**
  * Recommended configuration for eslint-plugin-boundaries.
  *

package/dist/Config/Recommended.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const Settings_1 = require("../Settings");
+const Shared_1 = require("../Shared");
 const { ELEMENTS, 
 // rules
-RULE_ELEMENT_TYPES, RULE_ENTRY_POINT, RULE_EXTERNAL, RULE_NO_IGNORED, RULE_NO_PRIVATE, RULE_NO_UNKNOWN_FILES, RULE_NO_UNKNOWN, } = Settings_1.SETTINGS;
+RULE_ELEMENT_TYPES, RULE_DEPENDENCIES, RULE_ENTRY_POINT, RULE_EXTERNAL, RULE_NO_IGNORED, RULE_NO_PRIVATE, RULE_NO_UNKNOWN_FILES, RULE_NO_UNKNOWN, } = Shared_1.SETTINGS;
 // TODO In next major version: Export also files, plugin, etc.
 /**
  * Recommended configuration for eslint-plugin-boundaries.
@@ -15,6 +15,7 @@ RULE_ELEMENT_TYPES, RULE_ENTRY_POINT, RULE_EXTERNAL, RULE_NO_IGNORED, RULE_NO_PR
 const config = {
     rules: {
         [RULE_ELEMENT_TYPES]: [2],
+        [RULE_DEPENDENCIES]: [2],
         [RULE_ENTRY_POINT]: [2],
         [RULE_EXTERNAL]: [2],
         [RULE_NO_IGNORED]: 0,

package/dist/Config/Strict.d.ts

@@ -1,4 +1,4 @@
-import type { Config } from "../Settings";
+import type { Config } from "../Shared";
 /**
  * Strict configuration for eslint-plugin-boundaries.
  *

package/dist/Config/Strict.js

@@ -3,9 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const Settings_1 = require("../Settings");
+const Shared_1 = require("../Shared");
 const Recommended_1 = __importDefault(require("./Recommended"));
-const { RULE_NO_IGNORED, RULE_NO_UNKNOWN_FILES, RULE_NO_UNKNOWN } = Settings_1.SETTINGS;
+const { RULE_NO_IGNORED, RULE_NO_UNKNOWN_FILES, RULE_NO_UNKNOWN } = Shared_1.SETTINGS;
 // TODO In next major version: Export also files, plugin, etc.
 /**
  * Strict configuration for eslint-plugin-boundaries.

package/dist/Debug/Debug.d.ts

@@ -0,0 +1,34 @@
+import type { DependencyDescription, ElementDescription, Matcher, DependencyMatchResult } from "@boundaries/elements";
+import type { SettingsNormalized } from "../Shared";
+/**
+ * Prints a warning message using warning color.
+ * @param title - Warning title shown before message.
+ * @param message - Warning message.
+ */
+export declare function warn(title: string, message?: string): void;
+/**
+ * Prints a warning only once for each unique message.
+ *
+ * @param title - Warning title shown before message.
+ * @param message - Warning message candidate.
+ * @returns `true` when warning was emitted, `false` when skipped.
+ */
+export declare function warnOnce(title: string, message?: string): boolean;
+/**
+ * Emits debug output for file or dependency descriptions when enabled.
+ *
+ * @param description - Element or dependency description to debug.
+ * @param settings - Normalized plugin settings including debug filters.
+ * @param matcher - Matcher used to evaluate debug filters.
+ */
+export declare function debugDescription(description: ElementDescription | DependencyDescription, settings: SettingsNormalized, matcher: Matcher): void;
+/**
+ * Prints debug information for a rule result when debug mode is enabled
+ *
+ * @param dependencyMatchResult - The result of matching a dependency against rules, including match status and captured values.
+ * @param ruleIndex - The index of the rule that was matched, if any.
+ * @param dependency - The original dependency description that was evaluated against the rules.
+ * @param settings - Normalized plugin settings including debug filters.
+ * @param matcher - Matcher used to evaluate debug filters.
+ */
+export declare function printDependenciesRuleResult(dependencyMatchResult: DependencyMatchResult | null, ruleIndex: number | null, dependency: DependencyDescription, settings: SettingsNormalized, matcher: Matcher): void;

package/dist/Debug/Debug.js

@@ -0,0 +1,285 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.warn = warn;
+exports.warnOnce = warnOnce;
+exports.debugDescription = debugDescription;
+exports.printDependenciesRuleResult = printDependenciesRuleResult;
+const elements_1 = require("@boundaries/elements");
+const chalk_1 = __importDefault(require("chalk"));
+const Shared_1 = require("../Shared");
+const warns = new Set();
+const debuggedFiles = new Set();
+const debuggedDependencies = new Set();
+const PREFIX_COLOR = "#A8B3D8";
+const CONSOLE_LEVELS = {
+    log: "log",
+    warn: "warn",
+};
+const LOG_LEVELS = {
+    debug: "debug",
+    warning: "warning",
+};
+/**
+ * Checks whether debug mode is globally enabled through environment variable.
+ *
+ * @returns `true` when debug env flag is active.
+ */
+function isDebugModeEnabled() {
+    return Boolean(process.env[Shared_1.SETTINGS.DEBUG]);
+}
+/**
+ * Computes final debug activation combining setting flag and environment flag.
+ *
+ * @param settingEnabled - Debug flag configured in plugin settings.
+ * @returns `true` when either setting or environment enables debug mode.
+ */
+function isDebugEnabled(settingEnabled) {
+    return settingEnabled || isDebugModeEnabled();
+}
+/**
+ * Prints a log line to stdout with optional color formatting.
+ *
+ * @param message - Message text to print.
+ * @param options - Optional parameters for color and log level.
+ * @param options.color - Optional color key from the internal color map.
+ * @param options.level - Optional log level determining which console method to use (default is "log").
+ */
+function printLog(message, level) {
+    // eslint-disable-next-line no-console
+    console[level](message);
+}
+/**
+ * Indents every line except the first one by a fixed number of spaces.
+ *
+ * @param text - Multi-line text to indent.
+ * @param spaces - Number of spaces to prepend.
+ * @returns Text with indentation applied.
+ */
+function indentLines(text, spaces) {
+    const pad = " ".repeat(spaces);
+    return text
+        .split("\n")
+        .map((line) => `${pad}${line}`)
+        .join("\n");
+}
+/**
+ * Generates a log prefix with plugin name and log level, applying color formatting based on log level.
+ * @param logLevel Type of log level to determine prefix formatting (default is "debug").
+ * @returns The formatted log prefix string to prepend to debug messages.
+ */
+function getLogPrefix(logLevel) {
+    const colorMethod = logLevel === LOG_LEVELS.warning ? chalk_1.default.yellow : chalk_1.default.blue;
+    const pluginTag = `[${Shared_1.PLUGIN_NAME}]`;
+    const levelTag = `[${logLevel}]`;
+    return `${chalk_1.default.hex(PREFIX_COLOR)(pluginTag)}${colorMethod(levelTag)}:`;
+}
+/**
+ * Prints a titled block of text in debug output, with the title formatted according to the log level.
+ * @param title - Block title shown before the message.
+ * @param options - Optional parameters for log level.
+ * @param options.level - Log level determining the title formatting (default is "debug").
+ * @param options.message - Message text to print within the block.
+ * @param level - Log level determining the title formatting (default is "debug").
+ */
+function printBlock(title, { level, message, }) {
+    const header = `${getLogPrefix(level)} ${title}`;
+    const consoleLevel = level === LOG_LEVELS.warning ? CONSOLE_LEVELS.warn : CONSOLE_LEVELS.log;
+    if (!message) {
+        printLog(header, consoleLevel);
+        return;
+    }
+    printLog(`${header}\n${indentLines(message, 2)}\n`, consoleLevel);
+}
+/**
+ * Prints a titled JSON block in debug output.
+ *
+ * @param title - Block title shown before data.
+ * @param data - Data serialized as formatted JSON.
+ */
+function printDebugBlock(title, data) {
+    printBlock(title, {
+        message: JSON.stringify(data, null, 2),
+        level: LOG_LEVELS.debug,
+    });
+}
+/**
+ * Prints a warning message using warning color.
+ * @param title - Warning title shown before message.
+ * @param message - Warning message.
+ */
+function warn(title, message) {
+    printBlock(title, { message, level: LOG_LEVELS.warning });
+}
+/**
+ * Prints a warning only once for each unique message.
+ *
+ * @param title - Warning title shown before message.
+ * @param message - Warning message candidate.
+ * @returns `true` when warning was emitted, `false` when skipped.
+ */
+function warnOnce(title, message) {
+    const messageKey = `${title}-${message}`;
+    if (warns.has(messageKey)) {
+        return false;
+    }
+    warns.add(messageKey);
+    warn(title, message);
+    return true;
+}
+/**
+ * Emits debug output for file or dependency descriptions when enabled.
+ *
+ * @param description - Element or dependency description to debug.
+ * @param settings - Normalized plugin settings including debug filters.
+ * @param matcher - Matcher used to evaluate debug filters.
+ */
+function debugDescription(description, settings, matcher) {
+    if (!isDebugEnabled(settings.debug.enabled)) {
+        return;
+    }
+    if ((0, elements_1.isDependencyDescription)(description)) {
+        printDependencyDebug(description, settings, matcher);
+        return;
+    }
+    printFileDebug(description, settings, matcher);
+}
+/**
+ * Returns an unique identifier for a file description, used to track which files have already been debugged.
+ * @param description - File element description.
+ * @returns Unique identifier string for the file.
+ */
+function getFileIdentifier(description) {
+    /* istanbul ignore next - Fallback for descriptions missing path, which should not happen but ensures stability of debug logging. */
+    return description.path || "<unknown-file>";
+}
+/**
+ * Prints debug info for a file description once per file path.
+ *
+ * @param description - File element description.
+ * @param settings - Normalized plugin settings.
+ * @param matcher - Matcher used for filter checks.
+ */
+function printFileDebug(description, settings, matcher) {
+    if (!settings.debug.messages.files) {
+        return;
+    }
+    const fileIdentifier = getFileIdentifier(description);
+    if (debuggedFiles.has(fileIdentifier)) {
+        return;
+    }
+    debuggedFiles.add(fileIdentifier);
+    if (shouldPrintFile(description, settings, matcher)) {
+        const title = `Description of file "${chalk_1.default.green(fileIdentifier)}":`;
+        printDebugBlock(title, description);
+    }
+}
+/**
+ * Prints debug info for a dependency description once per file/source pair.
+ *
+ * @param description - Dependency description.
+ * @param settings - Normalized plugin settings.
+ * @param matcher - Matcher used for filter checks.
+ */
+function printDependencyDebug(description, settings, matcher) {
+    printFileDebug(description.from, settings, matcher);
+    if (!settings.debug.messages.dependencies) {
+        return;
+    }
+    /* istanbul ignore next - Fallback for descriptions missing path, which should not happen but ensures stability of debug logging. */
+    const dependencySource = description.dependency.source || "<unknown-source>";
+    const fileIdentifier = getFileIdentifier(description.from);
+    const dependencyIdentifier = `${dependencySource}-${fileIdentifier}`;
+    if (debuggedDependencies.has(dependencyIdentifier)) {
+        return;
+    }
+    debuggedDependencies.add(dependencyIdentifier);
+    if (shouldPrintDependency(description, settings, matcher)) {
+        const title = `Description of dependency "${chalk_1.default.green(dependencySource)}" in file "${chalk_1.default.green(fileIdentifier)}":`;
+        printDebugBlock(title, description);
+    }
+}
+const DEPENDENCIES_VIOLATION_PREFIX = `${Shared_1.DEPENDENCIES} rule violation:`;
+/**
+ * Prints debug information for a rule result when debug mode is enabled
+ *
+ * @param dependencyMatchResult - The result of matching a dependency against rules, including match status and captured values.
+ * @param ruleIndex - The index of the rule that was matched, if any.
+ * @param dependency - The original dependency description that was evaluated against the rules.
+ * @param settings - Normalized plugin settings including debug filters.
+ * @param matcher - Matcher used to evaluate debug filters.
+ */
+function printDependenciesRuleResult(dependencyMatchResult, ruleIndex, dependency, settings, matcher) {
+    if (!isDebugEnabled(settings.debug.enabled) ||
+        !settings.debug.messages.violations ||
+        !shouldPrintDependency(dependency, settings, matcher) ||
+        !shouldPrintFile(dependency.from, settings, matcher)) {
+        return;
+    }
+    if ((0, Shared_1.isNull)(ruleIndex) || !dependencyMatchResult) {
+        printDebugBlock(`${DEPENDENCIES_VIOLATION_PREFIX} Dependency did not match any rule, and default policy is to deny.`, {
+            dependency,
+        });
+        return;
+    }
+    const title = `${DEPENDENCIES_VIOLATION_PREFIX} Rule at index ${ruleIndex} reported a violation because the following selector matched the dependency:`;
+    const selectorRelevantData = {};
+    if (dependencyMatchResult.from) {
+        selectorRelevantData.from = dependencyMatchResult.from;
+    }
+    if (dependencyMatchResult.to) {
+        selectorRelevantData.to = dependencyMatchResult.to;
+    }
+    if (dependencyMatchResult.dependency) {
+        selectorRelevantData.dependency = dependencyMatchResult.dependency;
+    }
+    printDebugBlock(title, {
+        rule: {
+            index: ruleIndex,
+            selector: selectorRelevantData,
+        },
+        dependency,
+    });
+}
+/**
+ * Checks whether a file description passes debug file filters.
+ *
+ * @param description - File description to evaluate.
+ * @param settings - Normalized plugin settings.
+ * @param matcher - Matcher used to evaluate selectors.
+ * @returns `true` when file should be printed in debug output.
+ */
+function shouldPrintFile(description, settings, matcher) {
+    const fileFilters = settings.debug.filter.files;
+    if ((0, Shared_1.isUndefined)(fileFilters)) {
+        return true;
+    }
+    if (fileFilters.length === 0) {
+        return false;
+    }
+    return fileFilters.some((selector) => !(0, Shared_1.isNull)(matcher.getElementSelectorMatchingDescription(description, selector)));
+}
+/**
+ * Checks whether a dependency description passes debug dependency filters.
+ *
+ * @param description - Dependency description to evaluate.
+ * @param settings - Normalized plugin settings.
+ * @param matcher - Matcher used to evaluate selectors.
+ * @returns `true` when dependency should be printed in debug output.
+ */
+function shouldPrintDependency(description, settings, matcher) {
+    const dependencyFilters = settings.debug.filter.dependencies;
+    if ((0, Shared_1.isUndefined)(dependencyFilters)) {
+        return true;
+    }
+    if (dependencyFilters.length === 0) {
+        return false;
+    }
+    if (!shouldPrintFile(description.from, settings, matcher)) {
+        return false;
+    }
+    return dependencyFilters.some((selector) => matcher.getDependencySelectorMatchingDescription(description, selector)
+        .isMatch);
+}

package/dist/Debug/index.d.ts

@@ -0,0 +1 @@
+export * from "./Debug";

package/dist/{Support → Debug}/index.js

@@ -14,5 +14,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./Common"), exports);
 __exportStar(require("./Debug"), exports);

package/dist/Elements/Elements.d.ts

@@ -1,10 +1,10 @@
 import type { Matcher, DependencyDescription, DependencyKind, ElementDescription } from "@boundaries/elements";
 import type { Rule } from "eslint";
-import type { SettingsNormalized } from "../Settings";
+import type { SettingsNormalized } from "../Shared";
 import type { EslintLiteralNode } from "./Elements.types";
 /**
- * Returns the elements matcher based on the ESLint rule context, filtering out invalid descriptors
- * @param context The ESLint rule context
+ * Returns the elements matcher based on the ESLint rule context settings already normalized, filtering out invalid descriptors
+ * @param settings The ESLint rule context settings normalized
  * @returns The elements matcher
  */
 export declare function getElementsMatcher(settings: SettingsNormalized): Matcher;
@@ -16,26 +16,28 @@ export declare function getElementsMatcher(settings: SettingsNormalized): Matche
 export declare function getSpecifiers(node: Rule.Node): string[];
 /**
  * Returns the description of the current file being linted
- * @param fileName The file name
+ * @param fileName The file name (absolute path)
  * @param settings The ESLint rule context settings normalized
  * @returns The description of the current file being linted
  */
 export declare function elementDescription(fileName: string, settings: SettingsNormalized): ElementDescription;
 /**
  * Returns the description of a dependency node
- * @param param0 The dependency node info
+ * @param options The dependency node info
+ * @param options.node The dependency node
+ * @param options.kind The kind of the dependency
+ * @param options.nodeKind The kind of the node generating the dependency
+ * @param fileName The file name (absolute path)
+ * @param settings The ESLint rule context settings normalized
  * @param context The ESLint rule context
  * @returns The description of the dependency node
  */
 export declare function dependencyDescription({ node, kind, nodeKind, }: {
-    /** The dependency node */
     node: EslintLiteralNode;
-    /** The kind of the dependency */
     kind: DependencyKind;
-    /** The kind of the node generating the dependency */
     nodeKind?: string;
 }, 
-/** The file name */
+/** The file name (absolute path) */
 fileName: string, 
 /** The ESLint rule context settings normalized */
 settings: SettingsNormalized, 

package/dist/Elements/Elements.js

@@ -9,11 +9,11 @@ exports.elementDescription = elementDescription;
 exports.dependencyDescription = dependencyDescription;
 const elements_1 = require("@boundaries/elements");
 const resolve_1 = __importDefault(require("eslint-module-utils/resolve"));
-const Support_1 = require("../Support");
+const Debug_1 = require("../Debug");
 const elements = new elements_1.Elements();
 /**
- * Returns the elements matcher based on the ESLint rule context, filtering out invalid descriptors
- * @param context The ESLint rule context
+ * Returns the elements matcher based on the ESLint rule context settings already normalized, filtering out invalid descriptors
+ * @param settings The ESLint rule context settings normalized
  * @returns The elements matcher
  */
 function getElementsMatcher(settings) {
@@ -22,30 +22,11 @@ function getElementsMatcher(settings) {
         includePaths: settings.includePaths,
         legacyTemplates: settings.legacyTemplates,
         cache: settings.cache,
+        flagAsExternal: settings.flagAsExternal,
+        rootPath: settings.rootPath,
     });
     return elementsMatcher;
 }
-/**
- * Replaces backslashes with forward slashes in a given path
- * @param filePath The file path to modify
- * @returns The modified file path with forward slashes
- */
-function replacePathSlashes(filePath) {
-    return filePath.replaceAll("\\", "/");
-}
-/**
- * Transforms an absolute path into a project-relative path
- * @param absolutePath The absolute path to transform
- * @param rootPath The root path of the project
- * @returns The relative path from the project root
- */
-function projectPath(absolutePath, rootPath) {
-    if (absolutePath) {
-        // TODO: Use path.relative when possible. With caution because this would break current external paths
-        return replacePathSlashes(absolutePath).replace(`${replacePathSlashes(rootPath)}/`, "");
-    }
-    return "";
-}
 /**
  * Returns the specifiers used in an import or export statement
  * @param node The AST node representing the import or export
@@ -69,25 +50,29 @@ function getSpecifiers(node) {
 }
 /**
  * Returns the description of the current file being linted
- * @param fileName The file name
+ * @param fileName The file name (absolute path)
  * @param settings The ESLint rule context settings normalized
  * @returns The description of the current file being linted
  */
 function elementDescription(fileName, settings) {
     const matcher = getElementsMatcher(settings);
-    const path = projectPath(fileName, settings.rootPath);
-    const result = matcher.describeElement(path);
-    (0, Support_1.debugDescription)(result);
+    const result = matcher.describeElement(fileName);
+    (0, Debug_1.debugDescription)(result, settings, matcher);
     return result;
 }
 /**
  * Returns the description of a dependency node
- * @param param0 The dependency node info
+ * @param options The dependency node info
+ * @param options.node The dependency node
+ * @param options.kind The kind of the dependency
+ * @param options.nodeKind The kind of the node generating the dependency
+ * @param fileName The file name (absolute path)
+ * @param settings The ESLint rule context settings normalized
  * @param context The ESLint rule context
  * @returns The description of the dependency node
  */
 function dependencyDescription({ node, kind, nodeKind, }, 
-/** The file name */
+/** The file name (absolute path) */
 fileName, 
 /** The ESLint rule context settings normalized */
 settings, 
@@ -95,14 +80,15 @@ settings,
 context) {
     const source = String(node.value);
     const matcher = getElementsMatcher(settings);
+    const resolvedPath = (0, resolve_1.default)(source, context);
     const description = matcher.describeDependency({
-        from: projectPath(fileName, settings.rootPath),
-        to: projectPath((0, resolve_1.default)(source, context), settings.rootPath),
+        from: fileName,
+        to: resolvedPath || undefined,
         source,
-        kind: kind || "value", // TODO: Change by runtime in a backwards compatible way
+        kind: kind || "value",
         nodeKind,
         specifiers: getSpecifiers(node),
     });
-    (0, Support_1.debugDescription)(description);
+    (0, Debug_1.debugDescription)(description, settings, matcher);
     return description;
 }

package/dist/Elements/Elements.types.d.ts

@@ -1,5 +1,6 @@
 import type { Rule } from "eslint";
 import type { Literal } from "estree";
+/** Represents an ESLint literal node with a parent node */
 export type EslintLiteralNode = Literal & {
     parent: Rule.Node;
 };