@boundaries/eslint-plugin 5.2.0-beta.1

package/dist/Config/Config.d.ts

@@ -0,0 +1,40 @@
+import type { Linter } from "eslint";
+import type { PluginBoundaries, Config } from "../Settings";
+import { PLUGIN_NAME } from "../Settings";
+export * from "../Public";
+type PluginFullConfig<PluginName extends string = typeof PLUGIN_NAME> = {
+    plugins: Record<PluginName, PluginBoundaries>;
+    files: Linter.Config["files"];
+} & Omit<Config<PluginName>, "plugins">;
+/**
+ * Returns an ESLint config object with the boundaries plugin registered, providing default JS and TS file patterns
+ * and enforcing valid types for settings and rules. Supports renaming the plugin. Rules can be prefixed with either
+ * the original plugin name or the provided plugin name.
+ *
+ * @param config - ESLint config object without the plugins field.
+ * @param name - The name of the plugin to register. Defaults to "boundaries".
+ * @returns {Linter.Config} The ESLint config object with the boundaries plugin registered and the provided config merged in.
+ * @throws {Error} If settings or rules are not from eslint-plugin-boundaries.
+ *
+ * @example
+ * ```ts
+ * import { createConfig, recommended } from "eslint-plugin-boundaries/config";
+ *
+ * const config = createConfig({
+ *   settings: {
+ *     ...recommended.settings,
+ *     "boundaries/elements": [],
+ *     "boundaries/ignore": ["ignored/*.js"],
+ *   },
+ *   rules: {
+ *     ...recommended.rules,
+ *     "boundaries/element-types": ["error", { default: "disallow" }],
+ *   }
+ * });
+ *
+ * export default [config];
+ * ```
+ */
+export declare function createConfig<PluginName extends string = typeof PLUGIN_NAME>(config: Omit<Config<PluginName> | Config, "plugins">, name?: PluginName): PluginFullConfig<PluginName>;
+export declare const recommended: Config<"boundaries">;
+export declare const strict: Config<"boundaries">;

package/dist/Config/Config.js

@@ -0,0 +1,119 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.strict = exports.recommended = void 0;
+exports.createConfig = createConfig;
+const index_1 = __importDefault(require("../index"));
+const Settings_1 = require("../Settings");
+const Recommended_1 = __importDefault(require("./Recommended"));
+const Strict_1 = __importDefault(require("./Strict"));
+__exportStar(require("../Public"), exports);
+function renamePluginRules(pluginName, rules) {
+    if (!rules) {
+        return {};
+    }
+    const allowedPrefixes = new Set([Settings_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}/".`);
+        }
+        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}/".`);
+        }
+        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);
+            newKey = `${pluginName}/${suffix}`;
+        }
+        else {
+            newKey = key;
+        }
+        acc[newKey] = value;
+        return acc;
+    }, {});
+}
+/**
+ * Returns an ESLint config object with the boundaries plugin registered, providing default JS and TS file patterns
+ * and enforcing valid types for settings and rules. Supports renaming the plugin. Rules can be prefixed with either
+ * the original plugin name or the provided plugin name.
+ *
+ * @param config - ESLint config object without the plugins field.
+ * @param name - The name of the plugin to register. Defaults to "boundaries".
+ * @returns {Linter.Config} The ESLint config object with the boundaries plugin registered and the provided config merged in.
+ * @throws {Error} If settings or rules are not from eslint-plugin-boundaries.
+ *
+ * @example
+ * ```ts
+ * import { createConfig, recommended } from "eslint-plugin-boundaries/config";
+ *
+ * const config = createConfig({
+ *   settings: {
+ *     ...recommended.settings,
+ *     "boundaries/elements": [],
+ *     "boundaries/ignore": ["ignored/*.js"],
+ *   },
+ *   rules: {
+ *     ...recommended.rules,
+ *     "boundaries/element-types": ["error", { default: "disallow" }],
+ *   }
+ * });
+ *
+ * export default [config];
+ * ```
+ */
+function createConfig(config, name = Settings_1.PLUGIN_NAME) {
+    const pluginsRegistration = {
+        [name]: index_1.default,
+    };
+    if (Object.hasOwn(config, "plugins")) {
+        throw new Error("The 'plugins' field is managed by createConfig and should not be provided in the config argument.");
+    }
+    if (Object.hasOwn(config, "settings")) {
+        const settings = config.settings;
+        if (settings) {
+            for (const key of Object.keys(settings)) {
+                if (!(0, Settings_1.isSettingsKey)(key)) {
+                    throw new Error(`Invalid settings key "${key}". When using createConfig, all settings keys must belong to eslint-plugin-boundaries.`);
+                }
+            }
+        }
+    }
+    return {
+        files: [
+            "**/*.js",
+            "**/*.jsx",
+            "**/*.ts",
+            "**/*.tsx",
+            "**/*.mjs",
+            "**/*.cjs",
+        ],
+        ...config,
+        plugins: pluginsRegistration,
+        rules: renamePluginRules(name, config.rules),
+    };
+}
+exports.recommended = Recommended_1.default;
+exports.strict = Strict_1.default;

package/dist/Config/Recommended.d.ts

@@ -0,0 +1,10 @@
+import type { Config } from "../Settings";
+/**
+ * Recommended configuration for eslint-plugin-boundaries.
+ *
+ * It is recommended for applying the plugin to an already existing project.
+ * Rules `boundaries/no-unknown`, `boundaries/no-unknown-files` and `boundaries/no-ignored` are disabled,
+ * so it allows to have parts of the project non-compliant with defined rules, allowing to refactor the code progressively.
+ */
+declare const config: Config;
+export default config;

package/dist/Config/Recommended.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Settings_1 = require("../Settings");
+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;
+// TODO In next major version: Export also files, plugin, etc.
+/**
+ * Recommended configuration for eslint-plugin-boundaries.
+ *
+ * It is recommended for applying the plugin to an already existing project.
+ * Rules `boundaries/no-unknown`, `boundaries/no-unknown-files` and `boundaries/no-ignored` are disabled,
+ * so it allows to have parts of the project non-compliant with defined rules, allowing to refactor the code progressively.
+ */
+const config = {
+    rules: {
+        [RULE_ELEMENT_TYPES]: [2],
+        [RULE_ENTRY_POINT]: [2],
+        [RULE_EXTERNAL]: [2],
+        [RULE_NO_IGNORED]: 0,
+        [RULE_NO_PRIVATE]: [
+            2,
+            {
+                allowUncles: true,
+            },
+        ],
+        [RULE_NO_UNKNOWN_FILES]: 0,
+        [RULE_NO_UNKNOWN]: 0,
+    },
+    settings: {
+        [ELEMENTS]: [],
+    },
+};
+exports.default = config;
+// For CommonJS compatibility
+module.exports = config;

package/dist/Config/Strict.d.ts

@@ -0,0 +1,8 @@
+import type { Config } from "../Settings";
+/**
+ * Strict configuration for eslint-plugin-boundaries.
+ *
+ * It enables all rules, enforcing full compliance with defined boundaries. Unknown files and importing ignored files are not allowed.
+ */
+declare const config: Config;
+export default config;

package/dist/Config/Strict.js

@@ -0,0 +1,26 @@
+"use strict";
+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 Recommended_1 = __importDefault(require("./Recommended"));
+const { RULE_NO_IGNORED, RULE_NO_UNKNOWN_FILES, RULE_NO_UNKNOWN } = Settings_1.SETTINGS;
+// TODO In next major version: Export also files, plugin, etc.
+/**
+ * Strict configuration for eslint-plugin-boundaries.
+ *
+ * It enables all rules, enforcing full compliance with defined boundaries. Unknown files and importing ignored files are not allowed.
+ */
+const config = {
+    ...Recommended_1.default,
+    rules: {
+        ...Recommended_1.default.rules,
+        [RULE_NO_IGNORED]: 2,
+        [RULE_NO_UNKNOWN_FILES]: 2,
+        [RULE_NO_UNKNOWN]: 2,
+    },
+};
+exports.default = config;
+// For CommonJS compatibility
+module.exports = config;

package/dist/Elements/Elements.d.ts

@@ -0,0 +1,43 @@
+import type { Matcher, DependencyDescription, DependencyKind, ElementDescription } from "@boundaries/elements";
+import type { Rule } from "eslint";
+import type { SettingsNormalized } from "../Settings";
+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
+ */
+export declare function getElementsMatcher(settings: SettingsNormalized): Matcher;
+/**
+ * Returns the specifiers used in an import or export statement
+ * @param node The AST node representing the import or export
+ * @returns The list of specifiers used in the import or export
+ */
+export declare function getSpecifiers(node: Rule.Node): string[];
+/**
+ * Returns the description of the current file being linted
+ * @param fileName The file name
+ * @param settings The ESLint rule context settings normalized
+ * @returns The description of the current file being linted
+ */
+export declare function elementDescription(fileName: string, settings: SettingsNormalized): ElementDescription;
+/**
+ * Returns the description of a dependency node
+ * @param param0 The dependency node info
+ * @param 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 */
+fileName: string, 
+/** The ESLint rule context settings normalized */
+settings: SettingsNormalized, 
+/** The ESLint rule context */
+context: Rule.RuleContext): DependencyDescription;

package/dist/Elements/Elements.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getElementsMatcher = getElementsMatcher;
+exports.getSpecifiers = getSpecifiers;
+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 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
+ */
+function getElementsMatcher(settings) {
+    const elementsMatcher = elements.getMatcher(settings.elementDescriptors, {
+        ignorePaths: settings.ignorePaths,
+        includePaths: settings.includePaths,
+        legacyTemplates: settings.legacyTemplates,
+    });
+    return elementsMatcher;
+}
+/**
+ * Replaces backslashes with forward slashes in a given path
+ * @param filePath The file path to modify
+ * @returns The modified file path with forward slashes
+ */
+function replacePathSlashes(filePath) {
+    return filePath.replaceAll("\\", "/");
+}
+/**
+ * Transforms an absolute path into a project-relative path
+ * @param absolutePath The absolute path to transform
+ * @param rootPath The root path of the project
+ * @returns The relative path from the project root
+ */
+function projectPath(absolutePath, rootPath) {
+    if (absolutePath) {
+        // TODO: Use path.relative when possible. With caution because this would break current external paths
+        return replacePathSlashes(absolutePath).replace(`${replacePathSlashes(rootPath)}/`, "");
+    }
+    return "";
+}
+/**
+ * Returns the specifiers used in an import or export statement
+ * @param node The AST node representing the import or export
+ * @returns The list of specifiers used in the import or export
+ */
+function getSpecifiers(node) {
+    if (node.parent.type === "ImportDeclaration") {
+        return node.parent.specifiers
+            .filter((specifier) => specifier.type === "ImportSpecifier" &&
+            specifier.imported &&
+            specifier.imported.name)
+            .map((specifier) => specifier.imported.name);
+    }
+    if (node.parent.type === "ExportNamedDeclaration") {
+        return node.parent.specifiers
+            .filter((specifier) => specifier.type === "ExportSpecifier" &&
+            specifier.exported.name)
+            .map((specifier) => specifier.exported.name);
+    }
+    return [];
+}
+/**
+ * Returns the description of the current file being linted
+ * @param fileName The file name
+ * @param settings The ESLint rule context settings normalized
+ * @returns The description of the current file being linted
+ */
+function elementDescription(fileName, settings) {
+    const matcher = getElementsMatcher(settings);
+    const path = projectPath(fileName, settings.rootPath);
+    const result = matcher.describeElement(path);
+    (0, Support_1.debugDescription)(result);
+    return result;
+}
+/**
+ * Returns the description of a dependency node
+ * @param param0 The dependency node info
+ * @param context The ESLint rule context
+ * @returns The description of the dependency node
+ */
+function dependencyDescription({ node, kind, nodeKind, }, 
+/** The file name */
+fileName, 
+/** The ESLint rule context settings normalized */
+settings, 
+/** The ESLint rule context */
+context) {
+    const source = String(node.value);
+    const matcher = getElementsMatcher(settings);
+    const description = matcher.describeDependency({
+        from: projectPath(fileName, settings.rootPath),
+        to: projectPath((0, resolve_1.default)(source, context), settings.rootPath),
+        source,
+        kind: kind || "value", // TODO: Change by runtime in a backwards compatible way
+        nodeKind,
+        specifiers: getSpecifiers(node),
+    });
+    (0, Support_1.debugDescription)(description);
+    return description;
+}

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

@@ -0,0 +1,5 @@
+import type { Rule } from "eslint";
+import type { Literal } from "estree";
+export type EslintLiteralNode = Literal & {
+    parent: Rule.Node;
+};

package/dist/Elements/Elements.types.js

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

package/dist/Elements/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Elements.types";
+export * from "./Elements";

package/dist/Elements/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./Elements.types"), exports);
+__exportStar(require("./Elements"), exports);

package/dist/Messages/Messages.d.ts

@@ -0,0 +1,14 @@
+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;
+}): string;

package/dist/Messages/Messages.js

@@ -0,0 +1,204 @@
+"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);
+}
+function replaceObjectValuesInTemplate(template, object, namespace) {
+    return replaceObjectValuesInTemplates(template, object, namespace);
+}
+function quote(str) {
+    return `'${str || ""}'`;
+}
+function typeMessage(elementMatcher) {
+    return `elements of type ${quote(elementMatcher)}`;
+}
+function categoryMessage(category) {
+    return `category ${quote(category)}`;
+}
+function propertiesConcatenator(properties, index) {
+    if (properties.length > 1 && index === properties.length - 1) {
+        return " and";
+    }
+    if (index === 0) {
+        return " with";
+    }
+    return ",";
+}
+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);
+    }
+    return Object.keys(object).reduce((replacedPattern, namespace) => {
+        if (!object[namespace]) {
+            return replacedPattern;
+        }
+        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]);
+        }
+        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 "";
+    }
+    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(" ");
+    }
+    // Backward compatibility. Code should not reach here normally.
+    if ((0, Support_1.isString)(elementMatcher)) {
+        return typeMessage(elementMatcher);
+    }
+    // TODO: Support array patterns
+    return `${typeMessage(elementMatcher[0])}${capturedValuesMatcherMessage(elementMatcher[1], elementCapturedValues)}`;
+}
+function ruleElementMessage(elementPatterns, elementCapturedValues) {
+    if ((0, Support_1.isArray)(elementPatterns)) {
+        if (elementPatterns.length === 1) {
+            return elementMatcherMessage(elementPatterns[0], elementCapturedValues);
+        }
+        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 "";
+    }
+    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])}`;
+    }, "");
+}
+function elementMessage(elementInfo) {
+    return `of type ${quote(elementInfo.type)}${elementCapturedValuesMessage(elementInfo.captured)}`;
+}
+function hasToPrintKindMessage(ruleImportKind, dependency) {
+    return ruleImportKind && dependency.dependency.kind;
+}
+function dependencyImportKindMessage(ruleImportKind, dependency) {
+    if (hasToPrintKindMessage(ruleImportKind, dependency)) {
+        return `kind ${quote(dependency.dependency.kind)} from `;
+    }
+    return "";
+}
+function dependencyUsageKindMessage(ruleImportKind, dependency, { suffix = " ", prefix = "", } = {}) {
+    if (hasToPrintKindMessage(ruleImportKind, dependency)) {
+        return `${prefix}${dependency.dependency.kind}${suffix}`;
+    }
+    return "";
+}

package/dist/Messages/index.d.ts

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