eslint-plugin-boundaries 5.1.0 → 5.2.0-beta.2

package/README.md

@@ -320,6 +320,18 @@ You can also provide an absolute path in the environment variable, but it may be
 
 </details>
 
+#### __`boundaries/cache`__
+
+Enable or disable the cache mechanism used to boost performance. By default, it is enabled. We recommend to keep it enabled unless you experience issues. In such case, please, open an issue describing the problem.
+
+```js
+export default [{
+  settings: {
+    "boundaries/cache": true // or false to disable the cache
+  }
+}]
+```
+
 ### Predefined configurations
 
 The plugin is distributed with two different predefined configurations: "recommended" and "strict".

package/dist/{configs/config.d.ts → Config/Config.d.ts}

@@ -1,7 +1,7 @@
 import type { Linter } from "eslint";
-import { PLUGIN_NAME } from "../constants/plugin";
-import type { PluginBoundaries, Config } from "./Config.types";
-export * from "../types";
+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"];

package/dist/{configs/config.js → Config/Config.js}

@@ -19,35 +19,38 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.strict = exports.recommended = void 0;
 exports.createConfig = createConfig;
-const plugin_1 = require("../constants/plugin");
-const rules_1 = require("../constants/rules");
-const settings_1 = require("../constants/settings");
 const index_1 = __importDefault(require("../index"));
-const recommended_1 = __importDefault(require("./recommended"));
-const strict_1 = __importDefault(require("./strict"));
-__exportStar(require("../types"), exports);
-function renamePluginRules(rules, pluginName = plugin_1.PLUGIN_NAME) {
+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 = [plugin_1.PLUGIN_NAME, pluginName];
+    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 "${plugin_1.PLUGIN_NAME}/", or with the provided plugin name "${pluginName}/".`);
+            throw new Error(`Invalid rule key "${key}". When using createConfig, all rules must belong to eslint-plugin-boundaries. You can prefix them with the original plugin name "${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.includes(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 "${plugin_1.PLUGIN_NAME}/", or with the provided plugin name "${pluginName}/".`);
+        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, rules_1.isRuleShortName)(ruleName)) {
+        if (!(0, Settings_1.isRuleShortName)(ruleName)) {
             throw new Error(`Invalid rule name "${ruleName}". When using createConfig, all rules must belong to eslint-plugin-boundaries.`);
         }
-        const newKey = rulePrefix === plugin_1.PLUGIN_NAME
-            ? `${pluginName}/${key.slice(`${plugin_1.PLUGIN_NAME}/`.length)}`
-            : key;
+        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;
     }, {});
@@ -81,18 +84,18 @@ function renamePluginRules(rules, pluginName = plugin_1.PLUGIN_NAME) {
  * export default [config];
  * ```
  */
-function createConfig(config, name = plugin_1.PLUGIN_NAME) {
+function createConfig(config, name = Settings_1.PLUGIN_NAME) {
     const pluginsRegistration = {
         [name]: index_1.default,
     };
-    if (Object.prototype.hasOwnProperty.call(config, "plugins")) {
+    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.prototype.hasOwnProperty.call(config, "settings")) {
+    if (Object.hasOwn(config, "settings")) {
         const settings = config.settings;
         if (settings) {
             for (const key of Object.keys(settings)) {
-                if (!(0, settings_1.isSettingsKey)(key)) {
+                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.`);
                 }
             }
@@ -109,8 +112,8 @@ function createConfig(config, name = plugin_1.PLUGIN_NAME) {
         ],
         ...config,
         plugins: pluginsRegistration,
-        rules: renamePluginRules(config.rules, name),
+        rules: renamePluginRules(name, config.rules),
     };
 }
-exports.recommended = recommended_1.default;
-exports.strict = strict_1.default;
+exports.recommended = Recommended_1.default;
+exports.strict = Strict_1.default;

package/dist/{configs/recommended.d.ts → Config/Recommended.d.ts}

@@ -1,4 +1,4 @@
-import type { Config } from "./Config.types";
+import type { Config } from "../Settings";
 /**
  * Recommended configuration for eslint-plugin-boundaries.
  *

package/dist/{configs/recommended.js → Config/Recommended.js}

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const settings_1 = require("../constants/settings");
+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;
+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.

package/dist/{configs/strict.d.ts → Config/Strict.d.ts}

@@ -1,4 +1,4 @@
-import type { Config } from "./Config.types";
+import type { Config } from "../Settings";
 /**
  * Strict configuration for eslint-plugin-boundaries.
  *

package/dist/{configs/strict.js → Config/Strict.js}

@@ -3,9 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const settings_1 = require("../constants/settings");
-const recommended_1 = __importDefault(require("./recommended"));
-const { RULE_NO_IGNORED, RULE_NO_UNKNOWN_FILES, RULE_NO_UNKNOWN } = settings_1.SETTINGS;
+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.
@@ -13,9 +13,9 @@ const { RULE_NO_IGNORED, RULE_NO_UNKNOWN_FILES, RULE_NO_UNKNOWN } = settings_1.S
  * It enables all rules, enforcing full compliance with defined boundaries. Unknown files and importing ignored files are not allowed.
  */
 const config = {
-    ...recommended_1.default,
+    ...Recommended_1.default,
     rules: {
-        ...recommended_1.default.rules,
+        ...Recommended_1.default.rules,
         [RULE_NO_IGNORED]: 2,
         [RULE_NO_UNKNOWN_FILES]: 2,
         [RULE_NO_UNKNOWN]: 2,

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,108 @@
+"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,
+        cache: settings.cache,
+    });
+    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/index.d.ts

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

package/dist/{types/Config.types.js → Elements/index.js}

@@ -14,7 +14,5 @@ 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 });
-exports.PLUGIN_NAME = void 0;
-__exportStar(require("../configs/Config.types"), exports);
-var plugin_1 = require("../constants/plugin");
-Object.defineProperty(exports, "PLUGIN_NAME", { enumerable: true, get: function () { return plugin_1.PLUGIN_NAME; } });
+__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";

package/dist/Messages/index.js

@@ -0,0 +1,17 @@
+"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("./Messages"), exports);

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

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

package/dist/Public/Config.types.js

@@ -0,0 +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; } });

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

@@ -0,0 +1,10 @@
+import type { DependencyKind } from "@boundaries/elements";
+export type { DependencyKind, CapturedValuesSelector, ElementSelector, ElementSelectors, ElementsSelector, ExternalLibrarySelectorOptions, ExternalLibrarySelectorWithOptions, ExternalLibrarySelector, ExternalLibrarySelectors, ExternalLibrariesSelector, ElementSelectorWithOptions, } 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";
+/**
+ * Kind of import that the rule applies to (e.g., "type", "value")
+ * @deprecated Use DependencyKind instead
+ */
+export type ImportKind = DependencyKind;

package/dist/Public/Rules.types.js

@@ -0,0 +1,15 @@
+"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;
+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 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

@@ -0,0 +1,13 @@
+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";
+/**
+ * Map of the kinds of import, either a type import or a value import.
+ * @deprecated Use DEPENDENCY_KINDS_MAP instead
+ */
+export declare const IMPORT_KINDS_MAP: {
+    readonly TYPE: "type";
+    readonly VALUE: "value";
+};
+export { isImportKind, DEPENDENCY_NODE_KEYS_MAP, isDependencyNodeKey, SETTINGS_KEYS_MAP, isSettingsKey, } from "../Settings";