@boundaries/eslint-plugin 5.2.0-beta.1

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";

package/dist/Public/Settings.types.js

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

package/dist/Public/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./Config.types";
+export * from "./Settings.types";
+export * from "./Rules.types";

package/dist/Public/index.js

@@ -0,0 +1,19 @@
+"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("./Config.types"), exports);
+__exportStar(require("./Settings.types"), exports);
+__exportStar(require("./Rules.types"), exports);

package/dist/Rules/ElementTypes.d.ts

@@ -0,0 +1,25 @@
+import type { DependencyDescription, Matcher } from "@boundaries/elements";
+import type { ElementTypesRuleOptions, RuleResult, SettingsNormalized } from "../Settings";
+type PolicyMatch = {
+    isMatch: boolean;
+    specifiers?: string | string[];
+    internalPath?: string;
+};
+export declare function getRulesResults(ruleOptions: ElementTypesRuleOptions, dependencyDescription: DependencyDescription, matcher: Matcher, settings: SettingsNormalized): {
+    index: number;
+    originalRuleIndex: any;
+    selectorsMatching: {
+        selectors: {
+            [x: string]: string | import("@boundaries/elements").BaseElementSelectorData | import("@boundaries/elements").BaseElementSelectorWithOptions | import("@boundaries/elements").BaseElementSelector[] | null;
+        };
+        selectorsData: {
+            isMatch: boolean;
+        } | null;
+    };
+    ruleHasImportKind: boolean;
+    allowPolicyMatches: PolicyMatch;
+    denyPolicyMatches: PolicyMatch;
+}[];
+export declare function elementRulesAllowDependency(dependency: DependencyDescription, settings: SettingsNormalized, ruleOptions?: ElementTypesRuleOptions): RuleResult;
+declare const _default: import("eslint").Rule.RuleModule;
+export default _default;

package/dist/Rules/ElementTypes.js

@@ -0,0 +1,269 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRulesResults = getRulesResults;
+exports.elementRulesAllowDependency = elementRulesAllowDependency;
+const elements_1 = require("@boundaries/elements");
+const micromatch_1 = __importDefault(require("micromatch"));
+const Elements_1 = require("../Elements");
+const Messages_1 = require("../Messages");
+const Settings_1 = require("../Settings");
+const Support_1 = require("../Support");
+const Support_2 = require("./Support");
+const { RULE_ELEMENT_TYPES } = Settings_1.SETTINGS;
+/**
+ * Safely matches a dependency selector, catching and logging any errors
+ */
+function createSafeMatcherFunction(dependencyDescription, matcher) {
+    return (dependencySelector, extraTemplateData, dependencySelectorsGlobals) => {
+        // Just in case selectors are invalid, we catch errors here to avoid breaking the whole rule evaluation
+        try {
+            return matcher.getSelectorMatchingDescription(dependencyDescription, dependencySelector, {
+                extraTemplateData,
+                dependencySelectorsGlobals,
+            });
+        }
+        catch (error) {
+            (0, Support_1.warnOnce)(`Error occurred while matching dependency: ${String(error)}`);
+            return { isMatch: false };
+        }
+    };
+}
+/**
+ * Determines the rule matching context (directions, template data, etc.)
+ */
+function createRuleMatchContext(rule, dependencyDescription) {
+    const targetElementDirection = rule.from ? "from" : "to";
+    const policyElementDirection = rule.from ? "to" : "from";
+    const denyKeyToUse = rule.deny ? "deny" : "disallow";
+    const capturedValuesTemplateData = targetElementDirection === "from"
+        ? {
+            ...dependencyDescription.from.captured,
+            from: dependencyDescription.from.captured,
+            to: dependencyDescription.to.captured,
+        }
+        : {
+            ...dependencyDescription.to.captured,
+            from: dependencyDescription.from.captured,
+            to: dependencyDescription.to.captured,
+        };
+    const dependencySelectorsGlobals = rule.importKind ? { kind: rule.importKind } : {};
+    const targetElementSelector = rule[targetElementDirection];
+    return {
+        targetElementDirection,
+        policyElementDirection,
+        denyKeyToUse,
+        capturedValuesTemplateData,
+        dependencySelectorsGlobals,
+        targetElementSelector,
+    };
+}
+/**
+ * Evaluates both deny and allow policy matches for a rule
+ */
+function evaluatePolicyMatches(rule, context, isMatch, settings) {
+    const { targetElementDirection, policyElementDirection, denyKeyToUse, capturedValuesTemplateData, dependencySelectorsGlobals, targetElementSelector, } = context;
+    const disallowPolicyMatches = rule[denyKeyToUse]
+        ? isMatch({
+            [targetElementDirection]: targetElementSelector,
+            [policyElementDirection]: rule[denyKeyToUse],
+        }, settings.legacyTemplates ? capturedValuesTemplateData : {}, dependencySelectorsGlobals)
+        : { isMatch: false };
+    const allowPolicyMatches = !disallowPolicyMatches.isMatch && rule.allow
+        ? isMatch({
+            [targetElementDirection]: targetElementSelector,
+            [policyElementDirection]: rule.allow,
+        }, settings.legacyTemplates ? capturedValuesTemplateData : {}, dependencySelectorsGlobals)
+        : { isMatch: false };
+    return { disallowPolicyMatches, allowPolicyMatches };
+}
+/**
+ * Creates rule selectors data based on policy matches
+ */
+function createRuleSelectorsData(rule, context, disallowPolicyMatches, allowPolicyMatches) {
+    const { targetElementDirection, policyElementDirection, denyKeyToUse } = context;
+    const allowPolicyMatchesIsMatch = allowPolicyMatches.isMatch;
+    const disallowPolicyMatchesIsMatch = disallowPolicyMatches.isMatch;
+    const targetSelector = disallowPolicyMatchesIsMatch || allowPolicyMatchesIsMatch
+        ? context.targetElementSelector
+        : null;
+    let policySelector = null;
+    if (disallowPolicyMatchesIsMatch) {
+        policySelector = rule[denyKeyToUse];
+    }
+    else if (allowPolicyMatchesIsMatch) {
+        policySelector = rule.allow;
+    }
+    let selectorsData = null;
+    if (disallowPolicyMatchesIsMatch) {
+        selectorsData = disallowPolicyMatches;
+    }
+    else if (allowPolicyMatchesIsMatch) {
+        selectorsData = allowPolicyMatches;
+    }
+    return {
+        selectors: {
+            [targetElementDirection]: targetSelector,
+            [policyElementDirection]: policySelector,
+        },
+        selectorsData,
+    };
+}
+function getRulesResults(ruleOptions, dependencyDescription, matcher, settings) {
+    if (!ruleOptions.rules) {
+        return [];
+    }
+    const isMatch = createSafeMatcherFunction(dependencyDescription, matcher);
+    return ruleOptions.rules.map((rule, index) => {
+        const context = createRuleMatchContext(rule, dependencyDescription);
+        const { disallowPolicyMatches, allowPolicyMatches } = evaluatePolicyMatches(rule, context, isMatch, settings);
+        const selectorsMatching = createRuleSelectorsData(rule, context, disallowPolicyMatches, allowPolicyMatches);
+        return {
+            index,
+            // @ts-expect-error Workaround to support both allow and disallow in the same entry point rule
+            originalRuleIndex: rule.originalRuleIndex,
+            selectorsMatching,
+            ruleHasImportKind: !!rule.importKind,
+            allowPolicyMatches,
+            denyPolicyMatches: disallowPolicyMatches,
+        };
+    });
+}
+/**
+ * Determines the rule result based on policy matches
+ */
+function determineRuleResult(rulesResults) {
+    let isAllowed = false;
+    let ruleIndexMatching = null;
+    for (const ruleResult of rulesResults) {
+        if (ruleResult.denyPolicyMatches.isMatch) {
+            isAllowed = false;
+            ruleIndexMatching = ruleResult.index;
+        }
+        else if (ruleResult.allowPolicyMatches.isMatch) {
+            isAllowed = true;
+            ruleIndexMatching = ruleResult.index;
+        }
+    }
+    return { isAllowed, ruleIndexMatching };
+}
+/**
+ * Gets the message for the rule, prioritizing rule-specific messages
+ */
+function getRuleMessage(ruleIndexMatching, ruleOptions) {
+    return ((ruleIndexMatching === null
+        ? ruleOptions.message
+        : ruleOptions.rules?.[ruleIndexMatching]?.message) || ruleOptions.message);
+}
+/**
+ * Gets specifiers that match the rule for error reporting
+ */
+function getMatchingSpecifiers(ruleIndexMatching, rulesResults, dependency) {
+    if (ruleIndexMatching === null)
+        return null;
+    const selectorDataSpecifiers = 
+    // @ts-expect-error TODO: Align types. At this point, selectorsData.to must always be defined, because otherwise isMatch would be false
+    rulesResults[ruleIndexMatching].selectorsMatching?.selectorsData?.to
+        ?.specifiers;
+    if (!selectorDataSpecifiers) {
+        return null;
+    }
+    if ((0, Support_1.isString)(selectorDataSpecifiers)) {
+        const hasMatchingSpecifier = dependency.dependency.specifiers?.some((specifier) => micromatch_1.default.isMatch(specifier, selectorDataSpecifiers));
+        return hasMatchingSpecifier ? [selectorDataSpecifiers] : null;
+    }
+    return selectorDataSpecifiers.filter((pattern) => {
+        return dependency.dependency.specifiers?.some((specifier) => micromatch_1.default.isMatch(specifier, pattern));
+    });
+}
+/**
+ * Creates the rule report object
+ */
+function createRuleReport(ruleIndexMatching, message, dependency, rulesResults) {
+    if (ruleIndexMatching === null) {
+        return {
+            message,
+            isDefault: true,
+            importKind: undefined,
+            disallow: dependency.to,
+            element: dependency.from,
+            index: -1,
+        };
+    }
+    return {
+        message,
+        isDefault: false,
+        importKind: rulesResults[ruleIndexMatching].ruleHasImportKind
+            ? dependency.dependency.kind
+            : undefined,
+        disallow: rulesResults[ruleIndexMatching].selectorsMatching?.selectors.to,
+        element: rulesResults[ruleIndexMatching].selectorsMatching?.selectors.from,
+        index: rulesResults[ruleIndexMatching].originalRuleIndex ?? ruleIndexMatching,
+    };
+}
+/**
+ * Determines the report path for error reporting
+ */
+function getReportPath(ruleIndexMatching, rulesResults, dependency) {
+    return ruleIndexMatching === null ||
+        // @ts-expect-error TODO: Align types. At this point, selectorsData should always be defined
+        !rulesResults[ruleIndexMatching].selectorsMatching?.selectorsData?.to
+            ?.internalPath
+        ? null
+        : dependency.to.internalPath;
+}
+function elementRulesAllowDependency(dependency, settings, ruleOptions = {}) {
+    const defaultIsAllowed = ruleOptions.default === "allow";
+    const matcher = (0, Elements_1.getElementsMatcher)(settings);
+    const rulesResults = getRulesResults(ruleOptions, dependency, matcher, settings);
+    const { isAllowed, ruleIndexMatching } = determineRuleResult(rulesResults);
+    const finalIsAllowed = ruleIndexMatching === null ? defaultIsAllowed : isAllowed;
+    const message = getRuleMessage(ruleIndexMatching, ruleOptions);
+    const ruleReport = createRuleReport(ruleIndexMatching, message, dependency, rulesResults);
+    const reportPath = getReportPath(ruleIndexMatching, rulesResults, dependency);
+    const result = {
+        result: finalIsAllowed,
+        // @ts-expect-error Temporary workaround for RuleResult type until types are aligned
+        ruleReport,
+        report: {
+            specifiers: getMatchingSpecifiers(ruleIndexMatching, rulesResults, dependency) ||
+                undefined,
+            path: reportPath,
+        },
+    };
+    return result;
+}
+function errorMessage(ruleData, dependency) {
+    const ruleReport = ruleData.ruleReport;
+    if (!ruleReport) {
+        return `No detailed rule report available. This is likely a bug in ${Settings_1.PLUGIN_NAME}. Please report it at ${Settings_1.PLUGIN_ISSUES_URL}`;
+    }
+    if (ruleReport.message) {
+        return (0, Messages_1.customErrorMessage)(ruleReport.message, dependency);
+    }
+    if (ruleReport.isDefault) {
+        return `No rule allowing this dependency was found. File is ${(0, Messages_1.elementMessage)(dependency.from)}. Dependency is ${(0, Messages_1.elementMessage)(dependency.to)}`;
+    }
+    return `Importing ${(0, Messages_1.dependencyImportKindMessage)(ruleReport.importKind, dependency)}${(0, Messages_1.ruleElementMessage)(ruleReport.disallow, dependency.from.captured)} is not allowed in ${(0, Messages_1.ruleElementMessage)(ruleReport.element, dependency.from.captured)}. Disallowed in rule ${ruleReport.index + 1}`;
+}
+exports.default = (0, Support_2.dependencyRule)({
+    ruleName: RULE_ELEMENT_TYPES,
+    description: `Check allowed dependencies between element types`,
+    schema: (0, Settings_1.rulesOptionsSchema)(),
+}, function ({ dependency, node, context, settings, options }) {
+    // TODO: Remove these checks when allowing to use more selectors in ESLint rules
+    if ((0, elements_1.isLocalElement)(dependency.to) &&
+        !(0, elements_1.isIgnoredElement)(dependency.to) &&
+        !(0, elements_1.isUnknownLocalElement)(dependency.to) &&
+        !(0, elements_1.isInternalDependency)(dependency)) {
+        const ruleData = elementRulesAllowDependency(dependency, settings, options);
+        if (!ruleData.result) {
+            context.report({
+                message: errorMessage(ruleData, dependency),
+                node,
+            });
+        }
+    }
+});

package/dist/Rules/EntryPoint.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("eslint").Rule.RuleModule;
+export default _default;

package/dist/Rules/EntryPoint.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const elements_1 = require("@boundaries/elements");
+const Messages_1 = require("../Messages");
+const Settings_1 = require("../Settings");
+const ElementTypes_1 = require("./ElementTypes");
+const Support_1 = require("./Support");
+const { RULE_ENTRY_POINT } = Settings_1.SETTINGS;
+function errorMessage(ruleData, dependency) {
+    const ruleReport = ruleData.ruleReport;
+    if (!ruleReport) {
+        return `No detailed rule report available. This is likely a bug in ${Settings_1.PLUGIN_NAME}. Please report it at ${Settings_1.PLUGIN_ISSUES_URL}`;
+    }
+    if (ruleReport.message) {
+        return (0, Messages_1.customErrorMessage)(ruleReport.message, dependency);
+    }
+    if (ruleReport.isDefault) {
+        return `No rule allows the entry point '${dependency.to.internalPath}' in dependencies ${(0, Messages_1.elementMessage)(dependency.to)}`;
+    }
+    return `The entry point '${dependency.to.internalPath}' is not allowed in ${(0, Messages_1.ruleElementMessage)(ruleReport.disallow, dependency.to.captured)}${(0, Messages_1.dependencyUsageKindMessage)(ruleReport.importKind, dependency, {
+        prefix: " when importing ",
+        suffix: "",
+    })}. Disallowed in rule ${ruleReport.index + 1}`;
+}
+function modifyTemplates(templates) {
+    if (!templates) {
+        return undefined;
+    }
+    const templatesArray = Array.isArray(templates) ? templates : [templates];
+    return templatesArray.map((template) => template.replaceAll("${target.", "${to."));
+}
+function modifyRules(rules) {
+    const newRules = [];
+    for (let i = 0; i < rules.length; i++) {
+        const rule = rules[i];
+        const newTargets = (0, elements_1.normalizeElementsSelector)(rule.target);
+        const ruleHasDisallow = !!rule.disallow;
+        const ruleHasAllow = !!rule.allow;
+        let internalPathPatterns = undefined;
+        let allowPattern = undefined;
+        let disallowPattern = undefined;
+        if (ruleHasDisallow && ruleHasAllow) {
+            // Workaround to support both allow and disallow in the same rule
+            const toAdd = [
+                {
+                    to: newTargets.map((target) => {
+                        return {
+                            ...target,
+                            internalPath: modifyTemplates(rule.allow),
+                        };
+                    }),
+                    allow: ["*"],
+                    importKind: rule.importKind,
+                    message: rule.message,
+                    originalRuleIndex: i,
+                },
+                {
+                    to: newTargets.map((target) => {
+                        return {
+                            ...target,
+                            internalPath: modifyTemplates(rule.disallow),
+                        };
+                    }),
+                    disallow: ["*"],
+                    importKind: rule.importKind,
+                    message: rule.message,
+                    originalRuleIndex: i,
+                },
+            ];
+            newRules.push(...toAdd);
+        }
+        if (ruleHasDisallow) {
+            internalPathPatterns = modifyTemplates(rule.disallow);
+            disallowPattern = ["*"];
+        }
+        else if (ruleHasAllow) {
+            internalPathPatterns = modifyTemplates(rule.allow);
+            allowPattern = ["*"];
+        }
+        newRules.push({
+            to: newTargets.map((target) => {
+                return {
+                    ...target,
+                    internalPath: internalPathPatterns,
+                };
+            }),
+            allow: allowPattern,
+            disallow: disallowPattern,
+            importKind: rule.importKind,
+            message: rule.message,
+            // @ts-expect-error Workaround to support both allow and disallow in the same entry point rule
+            originalRuleIndex: i,
+        });
+    }
+    return newRules;
+}
+exports.default = (0, Support_1.dependencyRule)({
+    ruleName: RULE_ENTRY_POINT,
+    description: `Check entry point used for each element type`,
+    schema: (0, Settings_1.rulesOptionsSchema)({
+        rulesMainKey: "target",
+    }),
+}, function ({ dependency, node, context, settings, options }) {
+    if (!dependency.to.isIgnored &&
+        dependency.to.type &&
+        dependency.dependency.relationship.to !==
+            elements_1.DEPENDENCY_RELATIONSHIPS_MAP.INTERNAL) {
+        const adaptedRuleOptions = {
+            ...options,
+            rules: options && options.rules ? modifyRules(options.rules) : [],
+        };
+        const ruleData = (0, ElementTypes_1.elementRulesAllowDependency)(dependency, settings, adaptedRuleOptions);
+        if (!ruleData.result) {
+            context.report({
+                message: errorMessage(ruleData, dependency),
+                node: node,
+            });
+        }
+    }
+}, {
+    validateRules: { onlyMainKey: true, mainKey: "target" },
+});

package/dist/Rules/External.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("eslint").Rule.RuleModule;
+export default _default;

package/dist/Rules/External.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const elements_1 = require("@boundaries/elements");
+const Messages_1 = require("../Messages");
+const Settings_1 = require("../Settings");
+const Support_1 = require("../Support");
+const ElementTypes_1 = require("./ElementTypes");
+const Support_2 = require("./Support");
+const { RULE_EXTERNAL } = Settings_1.SETTINGS;
+function getErrorReportMessage(report) {
+    if (report.path) {
+        return report.path;
+    }
+    return report.specifiers && report.specifiers.length > 0
+        ? report.specifiers.join(", ")
+        : undefined;
+}
+function errorMessage(ruleData, dependency) {
+    const ruleReport = ruleData.ruleReport;
+    if (!ruleReport) {
+        return `No detailed rule report available. This is likely a bug in ${Settings_1.PLUGIN_NAME}. Please report it at ${Settings_1.PLUGIN_ISSUES_URL}`;
+    }
+    if (ruleReport.message) {
+        return (0, Messages_1.customErrorMessage)(ruleReport.message, dependency, {
+            specifiers: ruleData.report?.specifiers && ruleData.report?.specifiers.length > 0
+                ? ruleData.report?.specifiers?.join(", ")
+                : undefined,
+            path: ruleData.report?.path,
+        });
+    }
+    if (ruleReport.isDefault) {
+        return `No rule allows the usage of external module '${dependency.to.baseSource}' in elements ${(0, Messages_1.elementMessage)(dependency.from)}`;
+    }
+    const fileReport = `is not allowed in ${(0, Messages_1.ruleElementMessage)(ruleReport.element, dependency.from.captured)}. Disallowed in rule ${ruleReport.index + 1}`;
+    if ((ruleData.report?.specifiers && ruleData.report?.specifiers.length > 0) ||
+        ruleData.report?.path) {
+        return `Usage of ${(0, Messages_1.dependencyUsageKindMessage)(ruleReport.importKind, dependency)}'${getErrorReportMessage(ruleData.report)}' from external module '${dependency.to.baseSource}' ${fileReport}`;
+    }
+    return `Usage of ${(0, Messages_1.dependencyUsageKindMessage)(ruleReport.importKind, dependency, {
+        suffix: " from ",
+    })}external module '${dependency.to.baseSource}' ${fileReport}`;
+}
+function modifySelectors(selectors) {
+    const originsToMatch = [
+        elements_1.ELEMENT_ORIGINS_MAP.EXTERNAL,
+        elements_1.ELEMENT_ORIGINS_MAP.CORE,
+    ];
+    if ((0, Support_1.isString)(selectors)) {
+        return [{ baseSource: selectors, origin: originsToMatch }];
+    }
+    return selectors.map((selector) => {
+        if ((0, Support_1.isArray)(selector)) {
+            return {
+                origin: originsToMatch,
+                baseSource: selector[0],
+                specifiers: selector[1].specifiers,
+                internalPath: selector[1].path,
+            };
+        }
+        return {
+            origin: originsToMatch,
+            baseSource: selector,
+        };
+    });
+}
+exports.default = (0, Support_2.dependencyRule)({
+    ruleName: RULE_EXTERNAL,
+    description: `Check allowed external dependencies by element type`,
+    schema: (0, Settings_1.rulesOptionsSchema)({
+        targetMatcherOptions: {
+            type: "object",
+            properties: {
+                specifiers: {
+                    type: "array",
+                    items: {
+                        type: "string",
+                    },
+                },
+                path: {
+                    oneOf: [
+                        {
+                            type: "string",
+                        },
+                        {
+                            type: "array",
+                            items: {
+                                type: "string",
+                            },
+                        },
+                    ],
+                },
+            },
+            additionalProperties: false,
+        },
+    }),
+}, function ({ dependency, node, context, settings, options }) {
+    if ((0, elements_1.isExternalDependencyElement)(dependency.to) ||
+        (0, elements_1.isCoreDependencyElement)(dependency.to)) {
+        const adaptedRuleOptions = {
+            ...options,
+            rules: options && options.rules
+                ? options.rules.map((rule) => ({
+                    ...rule,
+                    allow: rule.allow && modifySelectors(rule.allow),
+                    disallow: rule.disallow && modifySelectors(rule.disallow),
+                }))
+                : [],
+        };
+        const ruleData = (0, ElementTypes_1.elementRulesAllowDependency)(dependency, settings, adaptedRuleOptions);
+        if (!ruleData.result) {
+            context.report({
+                message: errorMessage(ruleData, dependency),
+                node: node,
+            });
+        }
+    }
+}, {
+    validateRules: { onlyMainKey: true },
+});

package/dist/Rules/NoIgnored.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("eslint").Rule.RuleModule;
+export default _default;