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

package/dist/Public/Rules.types.js

@@ -1,15 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isRuleName = exports.isRuleShortName = exports.RULE_NAMES_MAP = exports.RULE_SHORT_NAMES_MAP = exports.isRulePolicy = exports.RULE_POLICIES_MAP = exports.isExternalLibrariesSelector = exports.isExternalLibrarySelector = exports.isElementsSelector = exports.isElementSelector = void 0;
+exports.isRuleName = exports.isRuleShortName = exports.isRulePolicy = exports.RULE_NAMES_MAP = exports.RULE_SHORT_NAMES_MAP = exports.RULE_POLICIES_MAP = exports.isElementsSelector = exports.isElementSelector = void 0;
 var elements_1 = require("@boundaries/elements");
 Object.defineProperty(exports, "isElementSelector", { enumerable: true, get: function () { return elements_1.isElementSelector; } });
 Object.defineProperty(exports, "isElementsSelector", { enumerable: true, get: function () { return elements_1.isElementsSelector; } });
-Object.defineProperty(exports, "isExternalLibrarySelector", { enumerable: true, get: function () { return elements_1.isExternalLibrarySelector; } });
-Object.defineProperty(exports, "isExternalLibrariesSelector", { enumerable: true, get: function () { return elements_1.isExternalLibrariesSelector; } });
+var Shared_1 = require("../Shared");
+Object.defineProperty(exports, "RULE_POLICIES_MAP", { enumerable: true, get: function () { return Shared_1.RULE_POLICIES_MAP; } });
+Object.defineProperty(exports, "RULE_SHORT_NAMES_MAP", { enumerable: true, get: function () { return Shared_1.RULE_SHORT_NAMES_MAP; } });
+Object.defineProperty(exports, "RULE_NAMES_MAP", { enumerable: true, get: function () { return Shared_1.RULE_NAMES_MAP; } });
 var Settings_1 = require("../Settings");
-Object.defineProperty(exports, "RULE_POLICIES_MAP", { enumerable: true, get: function () { return Settings_1.RULE_POLICIES_MAP; } });
 Object.defineProperty(exports, "isRulePolicy", { enumerable: true, get: function () { return Settings_1.isRulePolicy; } });
-Object.defineProperty(exports, "RULE_SHORT_NAMES_MAP", { enumerable: true, get: function () { return Settings_1.RULE_SHORT_NAMES_MAP; } });
-Object.defineProperty(exports, "RULE_NAMES_MAP", { enumerable: true, get: function () { return Settings_1.RULE_NAMES_MAP; } });
 Object.defineProperty(exports, "isRuleShortName", { enumerable: true, get: function () { return Settings_1.isRuleShortName; } });
 Object.defineProperty(exports, "isRuleName", { enumerable: true, get: function () { return Settings_1.isRuleName; } });

package/dist/Public/Settings.types.d.ts

@@ -1,7 +1,8 @@
 export { DEPENDENCY_KINDS_MAP, isDependencyKind } from "@boundaries/elements";
 export type { ElementDescriptorMode, ElementDescriptor, ElementDescriptors, } from "@boundaries/elements";
 export { ELEMENT_DESCRIPTOR_MODES_MAP, isElementDescriptorMode, } from "@boundaries/elements";
-export type { Settings, IgnoreSetting, IncludeSetting, RootPathSetting, SettingsKey, DependencyNodeKey, DependencyNodeSelector, AliasSetting, } from "../Settings";
+export type { Settings, IgnoreSetting, IncludeSetting, RootPathSetting, DebugSetting, DebugFilterSetting, SettingsKey, DependencyNodeKey, DependencyNodeSelector, AliasSetting, } from "../Shared";
+export { DEPENDENCY_NODE_KEYS_MAP, SETTINGS_KEYS_MAP } from "../Shared";
 /**
  * Map of the kinds of import, either a type import or a value import.
  * @deprecated Use DEPENDENCY_KINDS_MAP instead
@@ -11,4 +12,4 @@ export declare const IMPORT_KINDS_MAP: {
     readonly VALUE: "value";
     readonly TYPE_OF: "typeof";
 };
-export { isImportKind, DEPENDENCY_NODE_KEYS_MAP, isDependencyNodeKey, SETTINGS_KEYS_MAP, isSettingsKey, } from "../Settings";
+export { isImportKind, isDependencyNodeKey, isSettingsKey } from "../Settings";

package/dist/Public/Settings.types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isSettingsKey = exports.SETTINGS_KEYS_MAP = exports.isDependencyNodeKey = exports.DEPENDENCY_NODE_KEYS_MAP = exports.isImportKind = exports.IMPORT_KINDS_MAP = exports.isElementDescriptorMode = exports.ELEMENT_DESCRIPTOR_MODES_MAP = exports.isDependencyKind = exports.DEPENDENCY_KINDS_MAP = void 0;
+exports.isSettingsKey = exports.isDependencyNodeKey = exports.isImportKind = exports.IMPORT_KINDS_MAP = exports.SETTINGS_KEYS_MAP = exports.DEPENDENCY_NODE_KEYS_MAP = exports.isElementDescriptorMode = exports.ELEMENT_DESCRIPTOR_MODES_MAP = exports.isDependencyKind = exports.DEPENDENCY_KINDS_MAP = void 0;
 var elements_1 = require("@boundaries/elements");
 Object.defineProperty(exports, "DEPENDENCY_KINDS_MAP", { enumerable: true, get: function () { return elements_1.DEPENDENCY_KINDS_MAP; } });
 Object.defineProperty(exports, "isDependencyKind", { enumerable: true, get: function () { return elements_1.isDependencyKind; } });
@@ -8,6 +8,9 @@ const elements_2 = require("@boundaries/elements");
 var elements_3 = require("@boundaries/elements");
 Object.defineProperty(exports, "ELEMENT_DESCRIPTOR_MODES_MAP", { enumerable: true, get: function () { return elements_3.ELEMENT_DESCRIPTOR_MODES_MAP; } });
 Object.defineProperty(exports, "isElementDescriptorMode", { enumerable: true, get: function () { return elements_3.isElementDescriptorMode; } });
+var Shared_1 = require("../Shared");
+Object.defineProperty(exports, "DEPENDENCY_NODE_KEYS_MAP", { enumerable: true, get: function () { return Shared_1.DEPENDENCY_NODE_KEYS_MAP; } });
+Object.defineProperty(exports, "SETTINGS_KEYS_MAP", { enumerable: true, get: function () { return Shared_1.SETTINGS_KEYS_MAP; } });
 /**
  * Map of the kinds of import, either a type import or a value import.
  * @deprecated Use DEPENDENCY_KINDS_MAP instead
@@ -15,7 +18,5 @@ Object.defineProperty(exports, "isElementDescriptorMode", { enumerable: true, ge
 exports.IMPORT_KINDS_MAP = elements_2.DEPENDENCY_KINDS_MAP;
 var Settings_1 = require("../Settings");
 Object.defineProperty(exports, "isImportKind", { enumerable: true, get: function () { return Settings_1.isImportKind; } });
-Object.defineProperty(exports, "DEPENDENCY_NODE_KEYS_MAP", { enumerable: true, get: function () { return Settings_1.DEPENDENCY_NODE_KEYS_MAP; } });
 Object.defineProperty(exports, "isDependencyNodeKey", { enumerable: true, get: function () { return Settings_1.isDependencyNodeKey; } });
-Object.defineProperty(exports, "SETTINGS_KEYS_MAP", { enumerable: true, get: function () { return Settings_1.SETTINGS_KEYS_MAP; } });
 Object.defineProperty(exports, "isSettingsKey", { enumerable: true, get: function () { return Settings_1.isSettingsKey; } });

package/dist/Public/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./Config.types";
 export * from "./Settings.types";
 export * from "./Rules.types";
+export type { CustomMessageTemplateRuleContext, CustomMessageTemplateContext, } from "../Messages";

package/dist/Rules/Dependencies.d.ts

@@ -0,0 +1,59 @@
+import type { DependencyDescription, Matcher, DependencyMatchResult } from "@boundaries/elements";
+import type { Rule } from "eslint";
+import type { EslintLiteralNode } from "../Elements";
+import type { RuleOptionsWithRules, DependenciesRuleOptions, DependenciesRule, SettingsNormalized, RuleName } from "../Shared";
+export type EvaluateRulesResult = {
+    allowed: true;
+} | {
+    allowed: false;
+    /** Index into `rules[]` of the rule that produced the result, or null if no rule matched. */
+    ruleIndex: number | null;
+    /** The match result from the selector that triggered the outcome, or null when no rule matched. */
+    matchResult: DependencyMatchResult | null;
+};
+/**
+ * Evaluates the configured rules against a dependency description using a simplified path
+ * that delegates all matching entirely to the elements package.
+ *
+ * For each rule, the outer `from`/`to`/`dependency` fields are merged with each entry in
+ * `allow`/`disallow` to build the final {@link DependencySelector}. Rules follow
+ * **last-write-wins** semantics: the last rule that produces a match determines the outcome.
+ * Within a single rule, `disallow`/`deny` takes precedence over `allow` — `allow` is not
+ * evaluated when `disallow` already matched.
+ */
+export declare function evaluateRules(rules: DependenciesRule[], dep: DependencyDescription, matcher: Matcher, settings: SettingsNormalized): EvaluateRulesResult;
+/**
+ * Resolves the custom error message for a violation, preferring the rule-specific message
+ * over the global options message.
+ */
+export declare function resolveCustomMessage(ruleIndex: number | null, ruleOptions: DependenciesRuleOptions): string | undefined;
+type BuildErrorMessageParams = {
+    matchResult: DependencyMatchResult | null;
+    ruleIndex: number | null;
+    customMessage: string | undefined;
+    dependency: DependencyDescription;
+};
+/**
+ * Builds the error message for a dependency violation.
+ */
+export declare function buildErrorMessage({ matchResult, ruleIndex, customMessage, dependency, }: BuildErrorMessageParams): string;
+/**
+ * Evaluates configured rules for a dependency and reports ESLint violations.
+ *
+ * @param params - Rule evaluation context and dependency information.
+ */
+export declare function evaluateRulesAndReport({ rules, dependency, settings, context, node, options, }: {
+    rules: DependenciesRule[];
+    settings: SettingsNormalized;
+    context: Rule.RuleContext;
+    node: EslintLiteralNode;
+    options?: RuleOptionsWithRules;
+    dependency: DependencyDescription;
+}): void;
+/**
+ * Returns an ESLint rule definition for the dependencies rule, which checks dependencies between elements based on configured rules.
+ * @param customRuleName - Optional custom name for the rule.
+ * @returns ESLint rule definition.
+ */
+export default function getDependencyRule(ruleName?: RuleName): Rule.RuleModule;
+export {};

package/dist/Rules/Dependencies.js

@@ -0,0 +1,439 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateRules = evaluateRules;
+exports.resolveCustomMessage = resolveCustomMessage;
+exports.buildErrorMessage = buildErrorMessage;
+exports.evaluateRulesAndReport = evaluateRulesAndReport;
+exports.default = getDependencyRule;
+const elements_1 = require("@boundaries/elements");
+const Debug_1 = require("../Debug");
+const Elements_1 = require("../Elements");
+const Messages_1 = require("../Messages");
+const Settings_1 = require("../Settings");
+const Shared_1 = require("../Shared");
+const Support_1 = require("./Support");
+/**
+ * Merges the legacy `importKind` field from the rule level into the `kind` field of the dependency selector, if applicable.
+ * This is needed to support the legacy `importKind` rule option, which allowed specifying the import kind at the rule level instead of the selector level.
+ * @param dependencyMetadata - The dependency metadata selector data to merge the `importKind` into.
+ * @param importKind - The legacy import kind specified at the rule level, if any.
+ * @returns The merged dependency metadata selector data with the `importKind` merged into the `kind` field.
+ *
+ * @deprecated This function exists only for backward compatibility with the `importKind` rule
+ * option deprecated in v6. Remove in next major version once `importKind` is no longer supported.
+ */
+function mergeImportKindToDependencyMetadata(dependencyMetadata, importKind) {
+    if (!dependencyMetadata.kind) {
+        return {
+            kind: importKind,
+            ...dependencyMetadata,
+        };
+    }
+    if ((0, Shared_1.isArray)(dependencyMetadata.kind)) {
+        return {
+            ...dependencyMetadata,
+            kind: [...dependencyMetadata.kind, importKind],
+        };
+    }
+    return dependencyMetadata;
+}
+/**
+ * Merges a dependency selector by adding the `importKind` field from the rule level to the `dependency.kind` field in the selector, if applicable.
+ * This is needed to support the legacy `importKind` rule option, which allowed specifying the import kind at the rule level instead of the selector level.
+ * @param dependencySelector - The dependency selector object to add the `importKind` to.
+ * @param importKind - The legacy import kind specified at the rule level, if any.
+ *
+ * @deprecated This function exists only for backward compatibility with the `importKind` rule
+ * option deprecated in v6. Remove in next major version once `importKind` is no longer supported.
+ */
+function mergeImportKind(dependencySelector, importKind) {
+    if (!importKind) {
+        return dependencySelector;
+    }
+    if (!dependencySelector.dependency) {
+        return {
+            ...dependencySelector,
+            dependency: {
+                kind: importKind,
+            },
+        };
+    }
+    if ((0, elements_1.isDependencyDataSelectorData)(dependencySelector.dependency)) {
+        return {
+            ...dependencySelector,
+            dependency: mergeImportKindToDependencyMetadata(dependencySelector.dependency, importKind),
+        };
+    }
+    /* istanbul ignore next - Defensive check, it should be always an array, because options are validated */
+    if (!(0, Shared_1.isArray)(dependencySelector.dependency)) {
+        return dependencySelector;
+    }
+    return {
+        ...dependencySelector,
+        dependency: dependencySelector.dependency.map((dep) => {
+            return mergeImportKindToDependencyMetadata(dep, importKind);
+        }),
+    };
+}
+/**
+ * Wraps matcher.getDependencySelectorMatchingDescription catching any errors to avoid breaking the rule.
+ */
+function safeMatch(dep, matcher, selector, extraTemplateData) {
+    try {
+        return matcher.getDependencySelectorMatchingDescription(dep, selector, {
+            extraTemplateData,
+        });
+    }
+    catch (error) /* istanbul ignore next - Defensive check */ {
+        (0, Debug_1.warnOnce)(`Error occurred while matching dependency. Please report it at: ${Shared_1.PLUGIN_ISSUES_URL}`, `${JSON.stringify({
+            error: (0, Shared_1.isObject)(error)
+                ? { message: error.message, stack: error.stack }
+                : String(error),
+            dependency: dep,
+            selector,
+            extraTemplateData,
+        })}.`);
+        return { isMatch: false, from: null, to: null, dependency: null };
+    }
+}
+/**
+ * Builds template data for legacy `${...}` placeholders from captured values.
+ *
+ * @param rule - Rule currently being evaluated.
+ * @param dep - Dependency description under evaluation.
+ * @param legacyTemplates - Whether legacy template mode is enabled.
+ * @returns Template data object consumed by matcher template rendering.
+ */
+function getCapturedTemplateData(rule, dep, legacyTemplates) {
+    if (!legacyTemplates)
+        return {};
+    const targetDir = rule.from ? "from" : "to";
+    return targetDir === "from"
+        ? { ...dep.from.captured, from: dep.from.captured, to: dep.to.captured }
+        : { ...dep.to.captured, from: dep.from.captured, to: dep.to.captured };
+}
+/**
+ * Normalizes a policy value to an array of individual selector entries.
+ * For arrays that contain objects (new format), each element is a separate entry.
+ * For legacy string/array selectors the whole value is a single entry.
+ */
+function getPolicyEntries(policy) {
+    if ((0, Shared_1.isString)(policy)) {
+        return [policy];
+    }
+    if ((0, elements_1.isElementSelectorWithLegacyOptions)(policy)) {
+        return [policy];
+    }
+    if (!(0, Shared_1.isArray)(policy))
+        return [policy];
+    return policy;
+}
+/**
+ * Merges two objects by combining their properties, with entry properties taking precedence over outer properties.
+ * If both objects have a property that is also an object, they are merged to avoid losing any nested properties.
+ * @param outer The outer object.
+ * @param entry The entry object.
+ * @returns The merged object.
+ */
+function mergeProperties(outer, entry) {
+    if ((0, Shared_1.isObject)(outer) && (0, Shared_1.isObject)(entry)) {
+        return { ...outer, ...entry };
+    }
+    return (0, Shared_1.isUndefined)(entry) ? outer : entry;
+}
+/**
+ * Merges two element selectors by merging their fields, with entry fields taking precedence over outer fields.
+ * If both selectors have a `captured` field, they are merged separately to avoid losing any captured values.
+ */
+function mergeElementSelectorData(outer, entry) {
+    const result = { ...outer, ...entry };
+    const captured = mergeProperties(outer.captured, entry.captured);
+    if (!(0, Shared_1.isUndefined)(captured)) {
+        result.captured = captured;
+    }
+    const parent = mergeProperties(outer.parent, entry.parent);
+    if (!(0, Shared_1.isUndefined)(parent)) {
+        result.parent = parent;
+    }
+    return result;
+}
+function mergeDependencySelectorData(outer, entry) {
+    const result = { ...outer, ...entry };
+    const relationship = mergeProperties(outer.relationship, entry.relationship);
+    if (!(0, Shared_1.isUndefined)(relationship)) {
+        result.relationship = relationship;
+    }
+    return result;
+}
+/**
+ * Merges the outer selector with the entry selector(s) for a policy, composing the final
+ * selector(s) by merging all fields in all combinations.
+ * For example, a rule with `to: { type: "helper" }` and an dependency entry with `allow: { to: [{ internalPath: "index.js" }, { internalPath: "foo.js" }] }`,
+ * it would produce the merged selectors `[{ to: { type: "helper", internalPath: "index.js" } }, { to: { type: "helper", internalPath: "foo.js" } }]`.
+ * @param outerElementSelector The outer selector defined at the rule level.
+ * @param entryElementSelector The entry selector(s) defined at the policy level.
+ * @returns The merged selector(s) as an array of `BaseElementSelectorData` objects.
+ */
+function mergeElementsSelector(outerElementSelector, entryElementSelector) {
+    if (!entryElementSelector) {
+        return outerElementSelector;
+    }
+    if (!outerElementSelector) {
+        return (0, elements_1.normalizeElementsSelector)(entryElementSelector);
+    }
+    const normalizedEntrySelector = (0, elements_1.normalizeElementsSelector)(entryElementSelector);
+    return outerElementSelector?.flatMap((outerSelector) => {
+        return normalizedEntrySelector.map((entrySelector) => mergeElementSelectorData(outerSelector, entrySelector));
+    });
+}
+/**
+ * Merges the outer dependency selector with the entry dependency selector, composing the final selector by merging all fields in all combinations.
+ * For example, a rule with `dependency: { kind: "import" }` and an dependency entry with `allow: { dependency: [{ module: "react" }, { module: "lodash" }] }`,
+ * it would produce the merged selectors `[{ dependency: { kind: "import", module: "react" } }, { dependency: { kind: "import", module: "lodash" } }]`.
+ * @param outerDependencySelector The outer dependency selector defined at the rule level.
+ * @param entryDependencySelector The entry dependency selector(s) defined at the policy level.
+ * @returns The merged dependency selector(s) as an array of `DependencyDataSelector` objects.
+ */
+function mergeDependencyDataSelectors(outerDependencySelector, entryDependencySelector) {
+    if (!entryDependencySelector) {
+        return outerDependencySelector;
+    }
+    if (!outerDependencySelector) {
+        return entryDependencySelector;
+    }
+    const outer = (0, Shared_1.isArray)(outerDependencySelector)
+        ? outerDependencySelector
+        : [outerDependencySelector];
+    const entry = (0, Shared_1.isArray)(entryDependencySelector)
+        ? entryDependencySelector
+        : [entryDependencySelector];
+    return outer.flatMap((outerSelector) => {
+        return entry.map((entrySelector) => mergeDependencySelectorData(outerSelector, entrySelector));
+    });
+}
+/**
+ * Builds the final {@link DependencySelector} by merging the outer rule-level fields
+ * (`from`, `to`, `dependency`) with a single policy entry.
+ *
+ * - **Object entry** — each of `from`, `to` and `dependency` is merged field by field,
+ *   with entry fields taking precedence over outer fields. This allows composing criteria:
+ *   `{ to: { type: "helper" }, allow: { to: { internalPath: "index.js" } } }` →
+ *   selector `{ to: { type: "helper", internalPath: "index.js" } }`.
+ * - **Legacy entry** (string or array without objects) — interpreted as the element selector
+ *   for the "other" direction (opposite to the direction defined at the rule level).
+ */
+function buildEntrySelector(outerFrom, outerTo, outerDependency, entry) {
+    if ((0, elements_1.isDependencySelector)(entry)) {
+        const entryObj = entry;
+        const mergedFrom = mergeElementsSelector(outerFrom, entryObj.from ? (0, elements_1.normalizeElementsSelector)(entryObj.from) : undefined);
+        const mergedTo = mergeElementsSelector(outerTo, entryObj.to ? (0, elements_1.normalizeElementsSelector)(entryObj.to) : undefined);
+        const mergedDependency = mergeDependencyDataSelectors(outerDependency, entryObj.dependency);
+        const selectorResult = {};
+        if (!(0, Shared_1.isUndefined)(mergedFrom))
+            selectorResult.from = mergedFrom;
+        if (!(0, Shared_1.isUndefined)(mergedTo))
+            selectorResult.to = mergedTo;
+        if (!(0, Shared_1.isUndefined)(mergedDependency))
+            selectorResult.dependency = mergedDependency;
+        return selectorResult;
+    }
+    // Legacy entry: string or legacy array → becomes the "other direction" element selector
+    // They are not merged because legacy entries are not objects but strings/arrays, so they
+    // can not express criteria in the same direction as the outer selector but only in the opposite direction
+    const hasFrom = !(0, Shared_1.isUndefined)(outerFrom);
+    const result = {};
+    if (hasFrom) {
+        result.from = outerFrom;
+        result.to = entry;
+    }
+    else {
+        result.to = outerTo;
+        result.from = entry;
+    }
+    return result;
+}
+/**
+ * Iterates the entries of a single policy value returning the first match, or null.
+ * @param options - The rule options object containing the policy entries and outer selectors.
+ * @param options.policy - The policy value, which can be a single entry or an array of entries.
+ * @param options.outerFrom - The outer `from` selector defined at the rule level, to be merged with each entry.
+ * @param options.outerTo - The outer `to` selector defined at the rule level, to be merged with each entry.
+ * @param options.outerDependency - The outer `dependency` selector defined at the rule level, to be merged with each entry.
+ * @param options.dep - The dependency description under evaluation.
+ * @param options.matcher - The elements matcher instance used to evaluate matches.
+ * @param options.templateData - The template data object containing captured values for template rendering.
+ * @param options.legacyImportKind - The legacy import kind at rule level, if applicable.
+ * @returns The match result from the first matching entry, or null if no entries matched.
+ */
+function evaluatePolicyEntries({ policy, outerFrom, outerTo, outerDependency, dep, matcher, templateData, legacyImportKind, }) {
+    for (const entry of getPolicyEntries(policy)) {
+        const selector = buildEntrySelector(outerFrom ? (0, elements_1.normalizeElementsSelector)(outerFrom) : undefined, outerTo ? (0, elements_1.normalizeElementsSelector)(outerTo) : undefined, outerDependency, entry);
+        const selectorWithImportKind = mergeImportKind(selector, legacyImportKind);
+        const result = safeMatch(dep, matcher, selectorWithImportKind, templateData);
+        if (result.isMatch)
+            return result;
+    }
+    return null;
+}
+/**
+ * Evaluates the configured rules against a dependency description using a simplified path
+ * that delegates all matching entirely to the elements package.
+ *
+ * For each rule, the outer `from`/`to`/`dependency` fields are merged with each entry in
+ * `allow`/`disallow` to build the final {@link DependencySelector}. Rules follow
+ * **last-write-wins** semantics: the last rule that produces a match determines the outcome.
+ * Within a single rule, `disallow`/`deny` takes precedence over `allow` — `allow` is not
+ * evaluated when `disallow` already matched.
+ */
+function evaluateRules(rules, dep, matcher, settings) {
+    let allowed = null;
+    let ruleIndex = null;
+    let matchResult = null;
+    for (let i = 0; i < rules.length; i++) {
+        const rule = rules[i];
+        const templateData = getCapturedTemplateData(rule, dep, settings.legacyTemplates);
+        const outerFrom = rule.from;
+        const outerTo = rule.to;
+        const outerDependency = rule.dependency;
+        let denyMatched = false;
+        if (rule.disallow) {
+            const denyMatch = evaluatePolicyEntries({
+                policy: rule.disallow,
+                outerFrom,
+                outerTo,
+                outerDependency,
+                dep,
+                matcher,
+                templateData,
+                legacyImportKind: rule.importKind /* legacy importKind for backward compatibility */,
+            });
+            if (denyMatch) {
+                allowed = false;
+                ruleIndex = i;
+                matchResult = denyMatch;
+                denyMatched = true;
+            }
+        }
+        // Allow is only evaluated when disallow/deny did not match for this rule
+        if (!denyMatched && rule.allow) {
+            const allowMatch = evaluatePolicyEntries({
+                policy: rule.allow,
+                outerFrom,
+                outerTo,
+                outerDependency,
+                dep,
+                matcher,
+                templateData,
+                legacyImportKind: rule.importKind /* legacy importKind for backward compatibility */,
+            });
+            if (allowMatch) {
+                allowed = true;
+                ruleIndex = i;
+                matchResult = allowMatch;
+            }
+        }
+    }
+    if (allowed === true)
+        return { allowed: true };
+    return { allowed: false, ruleIndex, matchResult };
+}
+/**
+ * Resolves the custom error message for a violation, preferring the rule-specific message
+ * over the global options message.
+ */
+function resolveCustomMessage(ruleIndex, ruleOptions) {
+    const ruleMessage = (0, Shared_1.isNull)(ruleIndex)
+        ? undefined
+        : ruleOptions.rules?.[ruleIndex]?.message;
+    return ruleMessage ?? ruleOptions.message;
+}
+/**
+ * Builds the error message for a dependency violation.
+ */
+function buildErrorMessage({ matchResult, ruleIndex, customMessage, dependency, }) {
+    if (customMessage) {
+        return (0, Messages_1.customErrorMessage)(customMessage, dependency, ruleIndex, matchResult);
+    }
+    return (0, Messages_1.dependenciesRuleDefaultErrorMessage)(matchResult, ruleIndex, dependency);
+}
+/**
+ * Evaluates configured rules for a dependency and reports ESLint violations.
+ *
+ * @param params - Rule evaluation context and dependency information.
+ */
+function evaluateRulesAndReport({ rules, dependency, settings, context, node, options, }) {
+    const matcher = (0, Elements_1.getElementsMatcher)(settings);
+    const result = evaluateRules(rules, dependency, matcher, settings);
+    const defaultAllowed = options?.default === "allow";
+    let finalAllowed = false;
+    if (result.allowed === true) {
+        finalAllowed = true;
+    }
+    else if ((0, Shared_1.isNull)(result.ruleIndex)) {
+        finalAllowed = defaultAllowed;
+    }
+    if (!finalAllowed && result.allowed === false) {
+        (0, Debug_1.printDependenciesRuleResult)(result.matchResult, result.ruleIndex, dependency, settings, matcher);
+        /* istanbul ignore next - Defensive check, should not happen because options are validated */
+        const optionsForMessage = options ?? {};
+        context.report({
+            message: buildErrorMessage({
+                matchResult: result.matchResult,
+                ruleIndex: result.ruleIndex,
+                customMessage: resolveCustomMessage(result.ruleIndex, optionsForMessage),
+                dependency,
+            }),
+            node,
+        });
+    }
+}
+/**
+ * Returns an ESLint rule definition for the dependencies rule, which checks dependencies between elements based on configured rules.
+ * @param customRuleName - Optional custom name for the rule.
+ * @returns ESLint rule definition.
+ */
+function getDependencyRule(ruleName = Shared_1.RULE_NAMES_MAP.DEPENDENCIES) {
+    return (0, Support_1.dependencyRule)({
+        ruleName,
+        description: `Check dependencies between elements`,
+        schema: (0, Settings_1.rulesOptionsSchema)({
+            extraOptionsSchema: {
+                checkAllOrigins: {
+                    type: "boolean",
+                    description: "Whether to check dependencies from all origins (including external and core) or only from local elements. Default to false (only local).",
+                },
+                checkUnknownLocals: {
+                    type: "boolean",
+                    description: "Whether to check local dependencies with unknown elements (not matching any element descriptor) or to ignore them. Default to false (ignore).",
+                },
+                checkInternals: {
+                    type: "boolean",
+                    description: "Whether to check internal dependencies (dependencies within files in the same element). Default to false (ignore).",
+                },
+            },
+        }),
+    }, function ({ dependency, node, context, settings, options }) {
+        if (ruleName === Shared_1.RULE_NAMES_MAP.ELEMENT_TYPES) {
+            (0, Debug_1.warnOnce)(`Rule name "${Shared_1.RULE_NAMES_MAP.ELEMENT_TYPES}" is deprecated. Use "${Shared_1.RULE_NAMES_MAP.DEPENDENCIES}" instead.`, (0, Settings_1.migrationToV6GuideLink)("rule-element-types-renamed-to-dependencies"));
+        }
+        // Validate and warn about legacy selector syntax
+        (0, Settings_1.validateAndWarnRuleOptions)(options, ruleName, "from");
+        const checkAllOrigins = options?.checkAllOrigins ?? false;
+        const checkUnknownLocals = options?.checkUnknownLocals ?? false;
+        const checkInternals = options?.checkInternals ?? false;
+        if (!(0, elements_1.isIgnoredElement)(dependency.to) &&
+            (checkAllOrigins || (0, elements_1.isLocalElement)(dependency.to)) &&
+            (checkUnknownLocals || !(0, elements_1.isUnknownLocalElement)(dependency.to)) &&
+            (checkInternals || !(0, elements_1.isInternalDependency)(dependency))) {
+            const rules = options?.rules ?? [];
+            evaluateRulesAndReport({
+                rules,
+                settings,
+                context,
+                node,
+                options,
+                dependency,
+            });
+        }
+    });
+}