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

package/dist/Messages/Messages.js

@@ -1,204 +1,427 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.replaceObjectValuesInTemplates = replaceObjectValuesInTemplates;
-exports.replaceObjectValuesInTemplate = replaceObjectValuesInTemplate;
-exports.quote = quote;
-exports.micromatchPatternReplacingObjectsValues = micromatchPatternReplacingObjectsValues;
-exports.ruleElementMessage = ruleElementMessage;
-exports.customErrorMessage = customErrorMessage;
-exports.elementMessage = elementMessage;
-exports.dependencyImportKindMessage = dependencyImportKindMessage;
-exports.dependencyUsageKindMessage = dependencyUsageKindMessage;
-const elements_1 = require("@boundaries/elements");
-const Support_1 = require("../Support");
-function replaceObjectValueInTemplate(template, key, value, namespace) {
-    const keyToReplace = namespace ? `${namespace}.${key}` : key;
-    const regexp = new RegExp(`\\$\\{${keyToReplace}\\}`, "g");
-    return template.replace(regexp, value);
-}
-function replaceObjectValuesInTemplates(strings, object, namespace) {
-    const finalResult = (0, Support_1.isArray)(strings) ? [...strings] : strings;
-    return Object.keys(object).reduce((result, objectKey) => {
-        // If template is an array, replace key by value in all patterns
-        if ((0, Support_1.isArray)(result)) {
-            return result.map((resultEntry) => {
-                return replaceObjectValueInTemplate(resultEntry, objectKey, object[objectKey], namespace);
-            });
-        }
-        return replaceObjectValueInTemplate(result, objectKey, object[objectKey], namespace);
-    }, finalResult);
+exports.elementDescriptionMessage = elementDescriptionMessage;
+exports.elementDescriptionMessageFromSelector = elementDescriptionMessageFromSelector;
+exports.dependencyDescriptionMessage = dependencyDescriptionMessage;
+exports.dependencyDescriptionMessageFromSelector = dependencyDescriptionMessageFromSelector;
+exports.dependenciesRuleDefaultErrorMessage = dependenciesRuleDefaultErrorMessage;
+const Shared_1 = require("../Shared");
+const MESSAGE_ERROR = `Not able to create a message for this violation. Please report this at: ${Shared_1.PLUGIN_ISSUES_URL}`;
+const NO_RULE_MESSAGE = "There is no rule allowing dependencies";
+/**
+ * Wraps a value in double quotes.
+ * @param value - Value to quote.
+ * @returns Quoted string.
+ */
+function quote(value) {
+    return `"${String(value)}"`;
 }
-function replaceObjectValuesInTemplate(template, object, namespace) {
-    return replaceObjectValuesInTemplates(template, object, namespace);
+/**
+ * Joins message parts with commas and a final "and".
+ * @param parts - List of message parts to join.
+ * @returns Joined message string with proper comma and "and" placement.
+ */
+function joinWithCommasAndAnd(parts) {
+    /* istanbul ignore next -- Defensive: callers always guard against empty array */
+    if (parts.length === 0) {
+        return "";
+    }
+    if (parts.length === 1) {
+        return parts[0];
+    }
+    if (parts.length === 2) {
+        return `${parts[0]} and ${parts[1]}`;
+    }
+    return `${parts.slice(0, -1).join(", ")} and ${parts.at(-1)}`;
 }
-function quote(str) {
-    return `'${str || ""}'`;
+/**
+ * Converts a primitive or array value to a quoted string representation.
+ * @param value - Value to format, which can be a primitive or an array of primitives.
+ * @returns Quoted string representation of the value, with arrays joined by commas.
+ */
+function formatPropertyValue(value) {
+    if ((0, Shared_1.isArray)(value)) {
+        return value.map((entry) => quote(entry)).join(", ");
+    }
+    return quote(value);
 }
-function typeMessage(elementMatcher) {
-    return `elements of type ${quote(elementMatcher)}`;
+/**
+ * Capitalizes the first character of a message.
+ * @param message - Message to capitalize.
+ * @returns Message with the first character capitalized.
+ */
+function capitalizeFirstLetter(message) {
+    /* istanbul ignore next -- Defensive: capitalizeFirstLetter is always called with non-empty message strings */
+    if (!message.length) {
+        return message;
+    }
+    return `${message.charAt(0).toUpperCase()}${message.slice(1)}`;
 }
-function categoryMessage(category) {
-    return `category ${quote(category)}`;
+/**
+ * Builds message fragments from a selector-driven list of properties.
+ * @param elementDescription - Element to describe.
+ * @param properties - List of element properties to include in the description.
+ * @param options - Additional options for handling specific properties like "captured".
+ * @param options.capturedKeys - If "captured" is included in properties, specifies which captured keys to include in the description.
+ * @returns List of formatted message fragments describing the element based on the selected properties.
+ */
+function buildElementPropertyFragments(elementDescription, properties, options) {
+    const includeNullValues = options.includeNullValues;
+    const fragments = [];
+    for (const propertyName of properties) {
+        if (propertyName === "parent") {
+            const parentFragment = buildParentFragment(elementDescription, options, includeNullValues);
+            if (parentFragment) {
+                fragments.push(parentFragment);
+            }
+            continue;
+        }
+        const value = getElementPropertyValue(elementDescription, propertyName);
+        if (shouldSkipFragmentValue(value, includeNullValues)) {
+            continue;
+        }
+        if (propertyName === "captured") {
+            fragments.push(...buildCapturedFragments(value, options?.capturedKeys, includeNullValues));
+            continue;
+        }
+        fragments.push(formatPropertyFragment(propertyName, value));
+    }
+    return fragments;
 }
-function propertiesConcatenator(properties, index) {
-    if (properties.length > 1 && index === properties.length - 1) {
-        return " and";
+/**
+ * Builds a message fragment for the first parent element when requested.
+ * @param elementDescription - Element that may include parent information.
+ * @param options - Selector-driven options for parent and captured properties.
+ * @param includeNullValues - Whether null parent values should be rendered.
+ * @returns Parent fragment string, or null when no parent information should be emitted.
+ */
+function buildParentFragment(elementDescription, options, includeNullValues) {
+    const firstParent = elementDescription.parents?.[0];
+    if (!firstParent) {
+        return includeNullValues ? `parent ${quote(null)}` : null;
     }
-    if (index === 0) {
-        return " with";
+    const parentProperties = options?.parentProperties ?? [];
+    const parentFragments = buildElementPropertyFragments(firstParent, parentProperties, {
+        capturedKeys: options?.parentCapturedKeys,
+        includeNullValues,
+    });
+    if (!parentFragments.length) {
+        return null;
     }
-    return ",";
+    return `parent ${joinWithCommasAndAnd(parentFragments)}`;
 }
-function micromatchPatternReplacingObjectsValues(pattern, object) {
-    let patternToReplace = pattern;
-    if (!patternToReplace) {
-        return "";
-    }
-    // Backward compatibility. Possibly unused, because the value is already replaced in the next step.
-    // For the moment, keep it to avoid unexpected issues until the oncoming refactor.
-    if (object.from) {
-        patternToReplace = replaceObjectValuesInTemplates(patternToReplace, object.from);
+/**
+ * Reads an element property value using a dynamic property name.
+ * @param elementDescription - Element metadata source object.
+ * @param propertyName - Property name to read.
+ * @returns Raw value for the requested property.
+ */
+function getElementPropertyValue(elementDescription, propertyName) {
+    return elementDescription[propertyName];
+}
+/**
+ * Determines whether a property value should be skipped when building fragments.
+ * @param value - Property value to evaluate.
+ * @param includeNullValues - Whether null values are allowed in output.
+ * @returns True when the value should be ignored for message output.
+ */
+function shouldSkipFragmentValue(value, includeNullValues) {
+    return (0, Shared_1.isUndefined)(value) || ((0, Shared_1.isNull)(value) && !includeNullValues);
+}
+/**
+ * Builds captured-property message fragments from selected captured keys.
+ * @param value - Captured value container to inspect.
+ * @param capturedKeys - Captured keys selected by the selector.
+ * @param includeNullValues - Whether empty captured values should render as null.
+ * @returns List of captured fragments ready to be joined in a message.
+ */
+function buildCapturedFragments(value, capturedKeys, includeNullValues) {
+    if (!(0, Shared_1.isObject)(value) || Object.keys(value).length === 0) {
+        return includeNullValues ? [`captured ${quote(null)}`] : [];
     }
-    return Object.keys(object).reduce((replacedPattern, namespace) => {
-        if (!object[namespace]) {
-            return replacedPattern;
+    const fragments = [];
+    const keys = capturedKeys ?? Object.keys(value);
+    for (const capturedKey of keys) {
+        const capturedValue = value[capturedKey];
+        if ((0, Shared_1.isUndefined)(capturedValue)) {
+            continue;
         }
-        return replaceObjectValuesInTemplates(replacedPattern, object[namespace] || {}, namespace);
-    }, patternToReplace);
-}
-function micromatchPatternMessage(micromatchPatterns, elementCapturedValues) {
-    const micromatchPatternsWithValues = micromatchPatternReplacingObjectsValues(micromatchPatterns, { from: elementCapturedValues || {} });
-    if ((0, Support_1.isArray)(micromatchPatternsWithValues)) {
-        if (micromatchPatternsWithValues.length === 1) {
-            return quote(micromatchPatternsWithValues[0]);
+        fragments.push(`${capturedKey} ${formatPropertyValue(capturedValue)}`);
+    }
+    return fragments;
+}
+/**
+ * Formats a generic property fragment using key and value.
+ * @param propertyName - Property name label.
+ * @param value - Property value to serialize.
+ * @returns Formatted property fragment.
+ */
+function formatPropertyFragment(propertyName, value) {
+    return `${propertyName} ${formatPropertyValue(value)}`;
+}
+/**
+ * Determines whether a dependency property value should be rendered.
+ * @param value - Property value to evaluate.
+ * @param includeNullValues - Whether null values should be included in the output.
+ * @returns True when the value should be rendered.
+ */
+function shouldRenderDependencyValue(value, includeNullValues) {
+    return !(0, Shared_1.isUndefined)(value) && (!(0, Shared_1.isNull)(value) || includeNullValues);
+}
+/**
+ * Builds a relationship-side fragment when the selected side should be rendered.
+ * @param relationship - Relationship metadata value.
+ * @param relationshipKey - Relationship side to describe.
+ * @param includeNullValues - Whether null values should be included in the output.
+ * @returns Formatted relationship fragment, or null when the side should be ignored.
+ */
+function buildRelationshipFragment(relationship, relationshipKey, includeNullValues) {
+    const relationshipValue = relationship[relationshipKey];
+    if (!shouldRenderDependencyValue(relationshipValue, includeNullValues)) {
+        return null;
+    }
+    return `relationship ${relationshipKey} ${formatPropertyValue(relationshipValue)}`;
+}
+/**
+ * Builds message fragments for selected relationship sides.
+ * @param relationship - Relationship metadata value.
+ * @param relationshipKeys - Relationship sides to include.
+ * @param includeNullValues - Whether null values should be included in the output.
+ * @returns List of relationship fragments.
+ */
+function buildRelationshipFragments(relationship, relationshipKeys, includeNullValues) {
+    const fragments = [];
+    for (const relationshipKey of relationshipKeys ?? ["from", "to"]) {
+        const fragment = buildRelationshipFragment(relationship, relationshipKey, includeNullValues);
+        if (fragment) {
+            fragments.push(fragment);
         }
-        return micromatchPatternsWithValues.reduce((message, micromatchPattern, index) => {
-            if (index === 0) {
-                return quote(micromatchPattern);
-            }
-            if (index === micromatchPatternsWithValues.length - 1) {
-                return `${message} or ${quote(micromatchPattern)}`;
-            }
-            return `${message}, ${quote(micromatchPattern)}`;
-        }, "");
-    }
-    return quote(micromatchPatternsWithValues);
-}
-function capturedValuesMatcherMessage(capturedValuesPattern, elementCapturedValues) {
-    const capturedValuesPatternKeys = Object.keys(capturedValuesPattern || {});
-    return capturedValuesPatternKeys
-        .map((key) => {
-        return [key, capturedValuesPattern?.[key]];
-    })
-        .reduce((message, propertyNameAndMatcher, index) => {
-        return `${message}${propertiesConcatenator(capturedValuesPatternKeys, index)} ${propertyNameAndMatcher[0]
-        // TODO: Support array patterns
-        } ${micromatchPatternMessage(propertyNameAndMatcher[1], elementCapturedValues)}`;
-    }, "");
-}
-function elementMatcherMessage(elementMatcher, elementCapturedValues) {
-    if (!elementMatcher) {
+    }
+    return fragments;
+}
+/**
+ * Describes elements using the selected relevant properties.
+ * @param elementDescription - Element to describe.
+ * @param properties - List of element properties to include in the description.
+ * @param options - Additional options for message formatting.
+ * @param options.singleElement - If `true`, uses singular "element" label instead of "elements of".
+ * @returns Formatted message describing the element based on the selected properties.
+ */
+function elementDescriptionMessage(elementDescription, properties, { singleElement = false, includeNullValues = false, } = {}) {
+    const propertyFragments = buildElementPropertyFragments(elementDescription, properties, {
+        includeNullValues,
+    });
+    if (!propertyFragments.length) {
         return "";
     }
-    if ((0, elements_1.isElementSelector)(elementMatcher)) {
-        const selector = (0, elements_1.normalizeElementsSelector)(elementMatcher);
-        const parts = [];
-        const toAdd = [];
-        if (selector[0].type) {
-            // @ts-expect-error Types have to be aligned properly
-            toAdd.push(typeMessage(selector[0].type));
-        }
-        if (selector[0].category) {
-            toAdd.push(propertiesConcatenator(parts, parts.length + toAdd.length + 1), 
-            // @ts-expect-error Types have to be aligned properly
-            categoryMessage(selector[0].category));
-        }
-        if (selector[0].captured) {
-            toAdd.push(capturedValuesMatcherMessage(selector[0].captured, elementCapturedValues));
-        }
-        parts.push(...toAdd);
-        return parts.map((part) => part.trim()).join(" ");
+    const elementLabel = singleElement ? "element" : "elements";
+    return `${elementLabel} of ${joinWithCommasAndAnd(propertyFragments)}`;
+}
+/**
+ * Describes elements using selector-driven relevant properties and captured keys.
+ * @param elementDescription - Element to describe.
+ * @param selectorData - Selector data that determines which properties and captured keys to include in the description.
+ */
+function elementDescriptionMessageFromSelector(elementDescription, selectorData) {
+    if (!selectorData) {
+        return null;
     }
-    // Backward compatibility. Code should not reach here normally.
-    if ((0, Support_1.isString)(elementMatcher)) {
-        return typeMessage(elementMatcher);
+    const properties = Object.keys(selectorData);
+    if (!properties.length) {
+        return null;
     }
-    // TODO: Support array patterns
-    return `${typeMessage(elementMatcher[0])}${capturedValuesMatcherMessage(elementMatcher[1], elementCapturedValues)}`;
+    const capturedKeys = (0, Shared_1.isObject)(selectorData.captured)
+        ? Object.keys(selectorData.captured)
+        : undefined;
+    const parentProperties = (0, Shared_1.isObject)(selectorData.parent)
+        ? Object.keys(selectorData.parent)
+        : undefined;
+    const parentCapturedKeys = (0, Shared_1.isObject)(selectorData.parent) && (0, Shared_1.isObject)(selectorData.parent.captured)
+        ? Object.keys(selectorData.parent.captured)
+        : undefined;
+    const propertyFragments = buildElementPropertyFragments(elementDescription, properties, {
+        capturedKeys,
+        parentProperties,
+        parentCapturedKeys,
+        includeNullValues: true,
+    });
+    if (!propertyFragments.length) {
+        return null;
+    }
+    return `elements of ${joinWithCommasAndAnd(propertyFragments)}`;
 }
-function ruleElementMessage(elementPatterns, elementCapturedValues) {
-    if ((0, Support_1.isArray)(elementPatterns)) {
-        if (elementPatterns.length === 1) {
-            return elementMatcherMessage(elementPatterns[0], elementCapturedValues);
+/**
+ * Builds message fragments for dependency metadata from selected properties.
+ * @param dependencyMetadata - Dependency metadata to describe.
+ * @param properties - List of dependency metadata properties to include in the description.
+ * @param options - Additional options for handling specific properties like "relationship".
+ * @param options.relationshipKeys - If "relationship" is included in properties, specifies which relationship sides ("from", "to") to include in the description.
+ * @returns List of formatted message fragments describing the dependency metadata.
+ */
+function buildDependencyPropertyFragments(dependencyMetadata, properties, options) {
+    const fragments = [];
+    const includeNullValues = options?.includeNullValues ?? false;
+    for (const propertyName of properties) {
+        const value = dependencyMetadata[propertyName];
+        if (!shouldRenderDependencyValue(value, includeNullValues)) {
+            continue;
         }
-        return elementPatterns.reduce((message, elementPattern, index) => {
-            if (index === 0) {
-                return elementMatcherMessage(elementPattern, elementCapturedValues);
-            }
-            return `${message}, or ${elementMatcherMessage(elementPattern, elementCapturedValues)}`;
-        }, "");
-    }
-    return elementMatcherMessage(elementPatterns, elementCapturedValues);
-}
-function elementPropertiesToReplaceInTemplate(element, importKind) {
-    if ((0, elements_1.isElementDescription)(element)) {
-        return {
-            ...element.captured,
-            type: element.type || "",
-            internalPath: element.internalPath || "",
-            source: element.source || "",
-            importKind: importKind || "",
-        };
-    }
-    return {
-        ...element.captured,
-        type: element.type || "",
-        internalPath: "",
-        source: "",
-        importKind: importKind || "",
-    };
-}
-function customErrorMessage(message, dependency, report = {}) {
-    let replacedMessage = replaceObjectValuesInTemplate(replaceObjectValuesInTemplate(message, elementPropertiesToReplaceInTemplate(dependency.from, dependency.dependency.kind), "file"), elementPropertiesToReplaceInTemplate(dependency.to, dependency.dependency.kind), "dependency");
-    replacedMessage = replaceObjectValuesInTemplate(replaceObjectValuesInTemplate(replacedMessage, elementPropertiesToReplaceInTemplate(dependency.from, dependency.dependency.kind), "from"), elementPropertiesToReplaceInTemplate(dependency.to, dependency.dependency.kind), "target");
-    if (dependency.from.parents?.[0]) {
-        replacedMessage = replaceObjectValuesInTemplate(replacedMessage, elementPropertiesToReplaceInTemplate(dependency.from.parents?.[0], dependency.dependency.kind), "file.parent");
-        replacedMessage = replaceObjectValuesInTemplate(replacedMessage, elementPropertiesToReplaceInTemplate(dependency.from.parents?.[0], dependency.dependency.kind), "from.parent");
-    }
-    if (dependency.to.parents?.[0]) {
-        replacedMessage = replaceObjectValuesInTemplate(replacedMessage, elementPropertiesToReplaceInTemplate(dependency.to.parents?.[0], dependency.dependency.kind), "dependency.parent");
-        replacedMessage = replaceObjectValuesInTemplate(replacedMessage, elementPropertiesToReplaceInTemplate(dependency.to.parents?.[0], dependency.dependency.kind), "target.parent");
-    }
-    return replaceObjectValuesInTemplate(replacedMessage, report, "report");
-}
-function elementCapturedValuesMessage(capturedValues) {
-    if (!capturedValues) {
-        return "";
+        if (propertyName === "relationship" && (0, Shared_1.isObject)(value)) {
+            fragments.push(...buildRelationshipFragments(value, options?.relationshipKeys, includeNullValues));
+            continue;
+        }
+        fragments.push(formatPropertyFragment(propertyName, value));
     }
-    const capturedValuesKeys = Object.keys(capturedValues);
-    return capturedValuesKeys
-        .map((key) => {
-        return [key, capturedValues[key]];
-    })
-        .reduce((message, propertyNameAndValue, index) => {
-        return `${message}${propertiesConcatenator(capturedValuesKeys, index)} ${propertyNameAndValue[0]} ${quote(propertyNameAndValue[1])}`;
-    }, "");
+    return fragments;
 }
-function elementMessage(elementInfo) {
-    return `of type ${quote(elementInfo.type)}${elementCapturedValuesMessage(elementInfo.captured)}`;
+/**
+ * Describes dependency metadata using selected relevant properties.
+ * @param dependencyMetadata - Dependency metadata to describe.
+ * @param properties - List of dependency metadata properties to include in the description.
+ * @returns Formatted message describing the dependency metadata based on the selected properties.
+ */
+function dependencyDescriptionMessage(dependencyMetadata, properties, options) {
+    const propertyFragments = buildDependencyPropertyFragments(dependencyMetadata, properties, {
+        includeNullValues: options?.includeNullValues,
+    });
+    if (!propertyFragments.length) {
+        return "";
+    }
+    return joinWithCommasAndAnd(propertyFragments);
 }
-function hasToPrintKindMessage(ruleImportKind, dependency) {
-    return ruleImportKind && dependency.dependency.kind;
+/**
+ * Describes dependency metadata using selector-driven relevant properties.
+ * @param dependencyMetadata - Dependency metadata to describe.
+ * @param selectorData - Selector data that determines which properties and captured keys to include in the description.
+ * @returns Formatted message describing the dependency metadata based on the selected properties.
+ */
+function dependencyDescriptionMessageFromSelector(dependencyMetadata, selectorData) {
+    if (!selectorData) {
+        return null;
+    }
+    const properties = Object.keys(selectorData);
+    if (!properties.length) {
+        return null;
+    }
+    const relationshipKeys = (0, Shared_1.isObject)(selectorData.relationship)
+        ? Object.keys(selectorData.relationship)
+        : undefined;
+    const propertyFragments = buildDependencyPropertyFragments(dependencyMetadata, properties, {
+        relationshipKeys,
+        includeNullValues: true,
+    });
+    if (!propertyFragments.length) {
+        return null;
+    }
+    return joinWithCommasAndAnd(propertyFragments);
 }
-function dependencyImportKindMessage(ruleImportKind, dependency) {
-    if (hasToPrintKindMessage(ruleImportKind, dependency)) {
-        return `kind ${quote(dependency.dependency.kind)} from `;
+/**
+ * Resolves the fallback no-rules message from available description fragments.
+ * @param fromDescription - Description of the source element.
+ * @param toDescription - Description of the target element.
+ * @param dependencyDescription - Description of dependency metadata.
+ * @param originDescription - Optional origin description when target details are not available.
+ * @returns The most specific no-rules message that can be composed.
+ */
+function resolveNoRulesMatchedMessage(fromDescription, toDescription, dependencyDescription, originDescription) {
+    if (fromDescription && toDescription) {
+        return `${NO_RULE_MESSAGE} from ${fromDescription} to ${toDescription}`;
+    }
+    if (fromDescription && dependencyDescription && originDescription) {
+        return `${NO_RULE_MESSAGE} from ${fromDescription} to ${originDescription} with ${dependencyDescription}`;
+    }
+    if (fromDescription && dependencyDescription) {
+        return `${NO_RULE_MESSAGE} from ${fromDescription} with ${dependencyDescription}`;
+    }
+    if (toDescription && dependencyDescription) {
+        return `${NO_RULE_MESSAGE} to ${toDescription} with ${dependencyDescription}`;
     }
-    return "";
+    if (dependencyDescription && originDescription) {
+        return `${NO_RULE_MESSAGE} to ${originDescription} with ${dependencyDescription}`;
+    }
+    if (fromDescription) {
+        return `${NO_RULE_MESSAGE} from ${fromDescription}`;
+    }
+    if (toDescription) {
+        return `${NO_RULE_MESSAGE} to ${toDescription}`;
+    }
+    if (dependencyDescription) {
+        return `${NO_RULE_MESSAGE} with ${dependencyDescription}`;
+    }
+    if (originDescription) {
+        return `${NO_RULE_MESSAGE} to ${originDescription}`;
+    }
+    return MESSAGE_ERROR;
+}
+/**
+ * Builds the fallback no-rules message when no rule matches a dependency.
+ * @param dependency - Dependency description used to derive message details.
+ * @returns Human-readable fallback message for no-rules scenarios.
+ */
+function elementTypesNoRulesMatchedMessage(dependency) {
+    const fromDescription = elementDescriptionMessage(dependency.from, [
+        "type",
+        "category",
+        "captured",
+    ]);
+    const toDescription = elementDescriptionMessage(dependency.to, [
+        "type",
+        "category",
+        "captured",
+    ]);
+    const propertyToShowInDependency = dependency.dependency.module
+        ? "module"
+        : "source";
+    const dependencyDescription = dependencyDescriptionMessage(dependency.dependency, [propertyToShowInDependency]);
+    const originDescription = toDescription.length
+        ? null
+        : elementDescriptionMessage(dependency.to, ["origin"]);
+    return resolveNoRulesMatchedMessage(fromDescription, toDescription, dependencyDescription, originDescription);
 }
-function dependencyUsageKindMessage(ruleImportKind, dependency, { suffix = " ", prefix = "", } = {}) {
-    if (hasToPrintKindMessage(ruleImportKind, dependency)) {
-        return `${prefix}${dependency.dependency.kind}${suffix}`;
+/**
+ * Builds the default message for dependencies rule violations from the matching selector data.
+ * @param matchResult - Result of matching the dependency against the rule's selector, containing the relevant selector data for the from/to elements and the dependency metadata.
+ * @param ruleIndex - Index of the matching rule.
+ * @param dependency - Described dependency that triggered the violation, used to extract element and dependency metadata for message construction.
+ * @returns Formatted error message describing the violation based on the matching selector data.
+ */
+function dependenciesRuleDefaultErrorMessage(matchResult, ruleIndex, dependency) {
+    if ((0, Shared_1.isNull)(ruleIndex)) {
+        return elementTypesNoRulesMatchedMessage(dependency);
+    }
+    const fromProperties = Object.keys((matchResult?.from ?? {}));
+    const toProperties = Object.keys((matchResult?.to ?? {}));
+    const dependencyProperties = Object.keys((matchResult?.dependency ?? {}));
+    const fromPart = fromProperties.length
+        ? elementDescriptionMessageFromSelector(dependency.from, matchResult.from)
+        : null;
+    const toPart = toProperties.length
+        ? elementDescriptionMessageFromSelector(dependency.to, matchResult.to)
+        : null;
+    const dependencyPart = dependencyProperties.length
+        ? dependencyDescriptionMessageFromSelector(dependency.dependency, matchResult.dependency)
+        : null;
+    let message = MESSAGE_ERROR;
+    if (dependencyPart && toPart && fromPart) {
+        message = `Dependencies with ${dependencyPart} to ${toPart} are not allowed in ${fromPart}`;
+    }
+    else if (dependencyPart && toPart) {
+        message = `Dependencies with ${dependencyPart} to ${toPart} are not allowed`;
+    }
+    else if (dependencyPart && fromPart) {
+        message = `Dependencies with ${dependencyPart} are not allowed in ${fromPart}`;
+    }
+    else if (toPart && fromPart) {
+        message = `Dependencies to ${toPart} are not allowed in ${fromPart}`;
+    }
+    else if (toPart) {
+        message = `Dependencies to ${toPart} are not allowed`;
+    }
+    else if (fromPart) {
+        message = `Dependencies are not allowed in ${fromPart}`;
+    }
+    else if (dependencyPart) {
+        message = `Dependencies with ${dependencyPart} are not allowed`;
     }
-    return "";
+    return `${capitalizeFirstLetter(message)}. Denied by rule at index ${ruleIndex}`;
 }

package/dist/Messages/index.d.ts

@@ -1 +1,3 @@
+export * from "./CustomMessages";
 export * from "./Messages";
+export * from "./CustomMessages.types";

package/dist/Messages/index.js

@@ -14,4 +14,6 @@ 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("./CustomMessages"), exports);
 __exportStar(require("./Messages"), exports);
+__exportStar(require("./CustomMessages.types"), exports);

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

@@ -1,2 +1,2 @@
-export type { Rules, Config, PluginBoundaries } from "../Settings";
-export { PLUGIN_NAME } from "../Settings";
+export type { Rules, Config, PluginBoundaries } from "../Shared";
+export { PLUGIN_NAME } from "../Shared";

package/dist/Public/Config.types.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PLUGIN_NAME = void 0;
-var Settings_1 = require("../Settings");
-Object.defineProperty(exports, "PLUGIN_NAME", { enumerable: true, get: function () { return Settings_1.PLUGIN_NAME; } });
+var Shared_1 = require("../Shared");
+Object.defineProperty(exports, "PLUGIN_NAME", { enumerable: true, get: function () { return Shared_1.PLUGIN_NAME; } });

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

@@ -1,8 +1,9 @@
 import type { DependencyKind } from "@boundaries/elements";
-export type { DependencyKind, CapturedValuesSelector, ElementSelector, ElementSelectors, ElementsSelector, ExternalLibrarySelectorOptions, ExternalLibrarySelectorWithOptions, ExternalLibrarySelector, ExternalLibrarySelectors, ExternalLibrariesSelector, ElementSelectorWithOptions, FlagAsExternalOptions, } from "@boundaries/elements";
-export { isElementSelector, isElementsSelector, isExternalLibrarySelector, isExternalLibrariesSelector, } from "@boundaries/elements";
-export type { RulePolicy, RuleBaseOptions, ElementTypesRule, ElementTypesRuleOptions, EntryPointRule, EntryPointRuleOptions, ExternalRule, ExternalRuleOptions, NoPrivateOptions, RuleShortName, RuleName, } from "../Settings";
-export { RULE_POLICIES_MAP, isRulePolicy, RULE_SHORT_NAMES_MAP, RULE_NAMES_MAP, isRuleShortName, isRuleName, } from "../Settings";
+export type { DependencyKind, CapturedValuesSelector, ElementSelector, ElementSelectors, ElementsSelector, ElementSelectorWithOptions, FlagAsExternalOptions, } from "@boundaries/elements";
+export { isElementSelector, isElementsSelector } from "@boundaries/elements";
+export type { RulePolicy, RuleBaseOptions, ElementTypesRule, ElementTypesRuleOptions, DependenciesRule, DependenciesRuleOptions, EntryPointRule, EntryPointRuleOptions, ExternalRule, ExternalRuleOptions, NoPrivateOptions, RuleShortName, RuleName, } from "../Shared";
+export { RULE_POLICIES_MAP, RULE_SHORT_NAMES_MAP, RULE_NAMES_MAP, } from "../Shared";
+export { isRulePolicy, isRuleShortName, isRuleName } from "../Settings";
 /**
  * Kind of import that the rule applies to (e.g., "type", "value")
  * @deprecated Use DependencyKind instead