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

package/dist/Messages/CustomMessages.js

@@ -0,0 +1,156 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceObjectValueInLegacyTemplate = replaceObjectValueInLegacyTemplate;
+exports.elementPropertiesToReplaceInLegacyTemplate = elementPropertiesToReplaceInLegacyTemplate;
+exports.customErrorMessage = customErrorMessage;
+const elements_1 = require("@boundaries/elements");
+const handlebars_1 = __importDefault(require("handlebars"));
+const Shared_1 = require("../Shared");
+/** Regular expression to detect Handlebars expressions in custom message templates */
+const HANDLEBARS_TEMPLATE_REGEX = /{{\s*[^{}\s][^{}]*}}/;
+/**
+ * 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.
+ */
+function replaceObjectValueInLegacyTemplate(template, key, value, namespace) {
+    const keyToReplace = namespace ? `${namespace}.${key}` : key;
+    const regexp = new RegExp(String.raw `\$\{${keyToReplace}\}`, "g");
+    return template.replace(regexp, value);
+}
+/**
+ * Replaces multiple placeholders in a template string using values from an object.
+ *
+ * @param template - One template string.
+ * @param object - Key/value pairs used for placeholder replacement.
+ * @param namespace - Optional namespace prepended to every object key.
+ * @returns Replaced template string.
+ */
+function replaceObjectValuesInLegacyTemplate(template, object, namespace) {
+    const finalResult = template;
+    return Object.keys(object).reduce((result, objectKey) => {
+        return replaceObjectValueInLegacyTemplate(result, objectKey, object[objectKey], namespace);
+    }, finalResult);
+}
+/**
+ * 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.
+ */
+function elementPropertiesToReplaceInLegacyTemplate(element, importKind, dependencyMetadata) {
+    if ((0, elements_1.isElementDescription)(element)) {
+        const source = dependencyMetadata?.source || "";
+        const dependencyModule = dependencyMetadata?.module || "";
+        return {
+            ...element.captured,
+            type: element.type || "",
+            internalPath: element.internalPath || "",
+            source,
+            module: dependencyModule,
+            importKind: importKind || "",
+        };
+    }
+    return {
+        ...element.captured,
+        type: element.type || "",
+        internalPath: "",
+        source: "",
+        module: "",
+        importKind: importKind || "",
+    };
+}
+/**
+ * Checks whether a template uses Handlebars syntax.
+ *
+ * @param template - Custom message template.
+ * @returns `true` when the template contains at least one Handlebars token.
+ */
+function hasHandlebarsTemplate(template) {
+    return HANDLEBARS_TEMPLATE_REGEX.test(template);
+}
+/**
+ * Renders Handlebars expressions in a custom message template.
+ *
+ * If the template does not contain Handlebars expressions, it is returned as-is.
+ *
+ * @param template - Message template that may include Handlebars expressions.
+ * @param dependency - Dependency context exposed to the template.
+ * @param ruleIndex - Index of the rule that triggered the error, if applicable.
+ * @param matchResult - Full result of the dependency matching process, if applicable.
+ * @returns Final message after optional Handlebars rendering.
+ */
+function renderCustomMessageHandlebarsTemplate(template, dependency, ruleIndex, matchResult) {
+    if (!hasHandlebarsTemplate(template)) {
+        return template;
+    }
+    const context = {
+        from: dependency.from,
+        to: dependency.to,
+        dependency: dependency.dependency,
+        rule: !(0, Shared_1.isNull)(ruleIndex) && matchResult
+            ? {
+                index: ruleIndex,
+                selector: {
+                    from: matchResult.from,
+                    to: matchResult.to,
+                    dependency: matchResult.dependency,
+                },
+            }
+            : null,
+    };
+    const compiledTemplate = handlebars_1.default.compile(template, { noEscape: true });
+    return compiledTemplate(context);
+}
+/**
+ * Returns message fragments replacing legacy `${...}` placeholders with dependency information.
+ * @param template Template string containing `${...}` placeholders.
+ * @param dependency The dependency information used to replace placeholders in the template.
+ * @returns Template string with `${...}` placeholders replaced by corresponding values from the dependency information.
+ */
+function replaceLegacyTemplateVariables(template, dependency) {
+    let replacedMessage = replaceObjectValuesInLegacyTemplate(replaceObjectValuesInLegacyTemplate(template, elementPropertiesToReplaceInLegacyTemplate(dependency.from, dependency.dependency.kind), "file"), elementPropertiesToReplaceInLegacyTemplate(dependency.to, dependency.dependency.kind, dependency.dependency), "dependency");
+    replacedMessage = replaceObjectValuesInLegacyTemplate(replaceObjectValuesInLegacyTemplate(replacedMessage, elementPropertiesToReplaceInLegacyTemplate(dependency.from, dependency.dependency.kind), "from"), elementPropertiesToReplaceInLegacyTemplate(dependency.to, dependency.dependency.kind, dependency.dependency), "target");
+    if (dependency.from.parents?.[0]) {
+        replacedMessage = replaceObjectValuesInLegacyTemplate(replacedMessage, elementPropertiesToReplaceInLegacyTemplate(dependency.from.parents?.[0], dependency.dependency.kind), "file.parent");
+        replacedMessage = replaceObjectValuesInLegacyTemplate(replacedMessage, elementPropertiesToReplaceInLegacyTemplate(dependency.from.parents?.[0], dependency.dependency.kind), "from.parent");
+    }
+    if (dependency.to.parents?.[0]) {
+        replacedMessage = replaceObjectValuesInLegacyTemplate(replacedMessage, elementPropertiesToReplaceInLegacyTemplate(dependency.to.parents?.[0], dependency.dependency.kind), "dependency.parent");
+        replacedMessage = replaceObjectValuesInLegacyTemplate(replacedMessage, elementPropertiesToReplaceInLegacyTemplate(dependency.to.parents?.[0], dependency.dependency.kind), "target.parent");
+    }
+    return replaceObjectValuesInLegacyTemplate(replacedMessage, {
+        path: dependency.to.internalPath || "",
+        specifiers: dependency.dependency.specifiers?.join(", ") || "",
+    }, "report");
+}
+/**
+ * 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.
+ */
+function customErrorMessage(template, dependency, ruleIndex = null, matchResult = null) {
+    const replacedMessage = replaceLegacyTemplateVariables(template, dependency);
+    return renderCustomMessageHandlebarsTemplate(replacedMessage, dependency, ruleIndex, matchResult);
+}

package/dist/Messages/CustomMessages.types.d.ts

@@ -0,0 +1,25 @@
+import type { DependencyDescription, DependencySelector } from "@boundaries/elements";
+export type CustomMessageTemplateRuleContext = {
+    /** Index of the rule that triggered the error */
+    index: number | null;
+    /** Selector of the rule that matched the dependency */
+    selector: {
+        /** Information about the selector that matched the dependency importer element */
+        from: DependencySelector["from"] | null;
+        /** Information about the selector that matched the dependency target element */
+        to: DependencySelector["to"] | null;
+        /** Information about the selector that matched the dependency metadata */
+        dependency: DependencySelector["dependency"] | null;
+    };
+} | null;
+/** Context received by custom message templates */
+export type CustomMessageTemplateContext = {
+    /** Information about the dependency importer element */
+    from: DependencyDescription["from"] | null;
+    /** Information about the dependency target element */
+    to: DependencyDescription["to"] | null;
+    /** Information about the dependency itself */
+    dependency: DependencyDescription["dependency"] | null;
+    /** Context about the rule that matched the dependency, if any */
+    rule: CustomMessageTemplateRuleContext;
+};

package/dist/Messages/CustomMessages.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/Messages/Messages.d.ts

@@ -1,14 +1,43 @@
-import type { DependencyKind, CapturedValuesSelector, ElementParent, ElementsSelector, CapturedValues, DependencyDescription, ElementDescription } from "@boundaries/elements";
-import type { RuleMatcherElementsCapturedValues } from "../Settings";
-export declare function replaceObjectValuesInTemplates(strings: string | string[], object: Record<string, string>, namespace?: string | null): string | string[];
-export declare function replaceObjectValuesInTemplate(template: string, object: Record<string, string>, namespace?: string | null): string;
-export declare function quote(str: string | undefined | null): string;
-export declare function micromatchPatternReplacingObjectsValues(pattern: string | string[] | undefined, object: Partial<RuleMatcherElementsCapturedValues>): string | string[];
-export declare function ruleElementMessage(elementPatterns: ElementsSelector | undefined, elementCapturedValues: CapturedValues | null): string | import("@boundaries/elements").BaseElementSelectorData | import("@boundaries/elements").BaseElementSelectorWithOptions | CapturedValuesSelector;
-export declare function customErrorMessage(message: string, dependency: DependencyDescription, report?: {}): string;
-export declare function elementMessage(elementInfo: ElementDescription | ElementParent): string;
-export declare function dependencyImportKindMessage(ruleImportKind: DependencyKind | undefined, dependency: DependencyDescription): string;
-export declare function dependencyUsageKindMessage(ruleImportKind: DependencyKind | undefined, dependency: DependencyDescription, { suffix, prefix, }?: {
-    suffix?: string;
-    prefix?: string;
+import type { DependencyDescription, DependencyMatchResult, BaseElementSelectorData, DependencyDataSelectorData, ElementDescription, ElementParent, ElementsDependencyInfo } from "@boundaries/elements";
+/**
+ * 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.
+ */
+export declare function elementDescriptionMessage(elementDescription: ElementDescription | ElementParent, properties: string[], { singleElement, includeNullValues, }?: {
+    singleElement?: boolean;
+    includeNullValues?: boolean;
 }): string;
+/**
+ * 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.
+ */
+export declare function elementDescriptionMessageFromSelector(elementDescription: ElementDescription | ElementParent, selectorData: BaseElementSelectorData | null): string | null;
+/**
+ * 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.
+ */
+export declare function dependencyDescriptionMessage(dependencyMetadata: ElementsDependencyInfo, properties: string[], options?: {
+    includeNullValues?: boolean;
+}): string;
+/**
+ * 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.
+ */
+export declare function dependencyDescriptionMessageFromSelector(dependencyMetadata: ElementsDependencyInfo, selectorData: DependencyDataSelectorData | null): string | null;
+/**
+ * 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.
+ */
+export declare function dependenciesRuleDefaultErrorMessage(matchResult: DependencyMatchResult | null, ruleIndex: number | null, dependency: DependencyDescription): string;