@boundaries/eslint-plugin 5.4.0 → 6.0.0-beta.2

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,15 +15,11 @@ 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,
-        [RULE_NO_PRIVATE]: [
-            2,
-            {
-                allowUncles: true,
-            },
-        ],
+        [RULE_NO_PRIVATE]: 0,
         [RULE_NO_UNKNOWN_FILES]: 0,
         [RULE_NO_UNKNOWN]: 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;
@@ -23,16 +23,18 @@ export declare function getSpecifiers(node: Rule.Node): string[];
 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 (absolute path) */

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) {
@@ -57,12 +57,17 @@ function getSpecifiers(node) {
 function elementDescription(fileName, settings) {
     const matcher = getElementsMatcher(settings);
     const result = matcher.describeElement(fileName);
-    (0, Support_1.debugDescription)(result);
+    (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
  */
@@ -80,10 +85,10 @@ context) {
         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;
 };

package/dist/Messages/CustomMessages.d.ts

@@ -0,0 +1,44 @@
+import type { ElementParent, DependencyDescription, ElementDescription, DependencyMatchResult } from "@boundaries/elements";
+/**
+ * Replaces all occurrences of a placeholder key in a template string.
+ *
+ * Placeholders use the `${key}` syntax and optionally support namespacing
+ * (for example `${from.type}` or `${dependency.parent.category}`).
+ *
+ * @param template - Message template where placeholders are replaced.
+ * @param key - Placeholder key to replace (without `${}` delimiters).
+ * @param value - Value injected in place of the placeholder.
+ * @param namespace - Optional namespace prepended to the key before replacing.
+ * @returns Template string with the requested placeholder replaced.
+ */
+export declare function replaceObjectValueInLegacyTemplate(template: string, key: string, value: string, namespace?: string | null): string;
+/**
+ * Creates the replacement context consumed by legacy `${...}` placeholders.
+ *
+ * The resulting object normalizes available element information and dependency
+ * metadata so templates can use keys consistently regardless of source.
+ *
+ * @param element - Element or parent element that provides captured values.
+ * @param importKind - Dependency kind (`value`, `type`, etc.).
+ * @param dependencyMetadata - Extra dependency metadata for full elements.
+ * @returns Normalized key/value map used during placeholder replacement.
+ */
+export declare function elementPropertiesToReplaceInLegacyTemplate(element: ElementDescription | ElementParent, importKind: string, dependencyMetadata?: DependencyDescription["dependency"]): {
+    type: string;
+    internalPath: string;
+    source: string;
+    module: string;
+    importKind: string;
+};
+/**
+ * Builds the final custom error message for a dependency violation.
+ *
+ * This function first resolves legacy `${...}` placeholders (`file`, `from`,
+ * `dependency`, `target`, and parent variants) and then evaluates optional
+ * Handlebars expressions with the same dependency context.
+ *
+ * @param template - User-defined message template from rule configuration.
+ * @param dependency - Runtime dependency information used by placeholders.
+ * @returns Rendered, user-facing error message.
+ */
+export declare function customErrorMessage(template: string, dependency: DependencyDescription, ruleIndex?: number | null, matchResult?: DependencyMatchResult | null): string;