@boundaries/eslint-plugin 5.3.1 → 6.0.0-beta.1

package/dist/Rules/EntryPoint.js

@@ -1,121 +1,71 @@
 "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 Shared_1 = require("../Shared");
+const Dependencies_1 = require("./Dependencies");
 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 { RULE_ENTRY_POINT } = Shared_1.SETTINGS;
+/**
+ * Adapts legacy template placeholders from `target` to `to` notation.
+ *
+ * @param templates - Legacy templates from rule options.
+ * @returns Normalized templates or `undefined` when not provided.
+ */
+function modifyLegacyTemplates(templates) {
     const templatesArray = Array.isArray(templates) ? templates : [templates];
     return templatesArray.map((template) => template.replaceAll("${target.", "${to."));
 }
-function modifyRules(rules) {
+/**
+ * Converts `entry-point` legacy rules to `dependencies` rule shape.
+ *
+ * @param rules - Entry-point rules as defined by user configuration.
+ * @returns Equivalent dependencies rules for shared evaluator.
+ */
+function transformToDependenciesRules(rules) {
     const newRules = [];
-    for (let i = 0; i < rules.length; i++) {
-        const rule = rules[i];
+    for (const rule of rules) {
         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 = ["*"];
+        for (const target of newTargets) {
+            newRules.push({
+                to: target,
+                allow: rule.allow
+                    ? { to: { internalPath: modifyLegacyTemplates(rule.allow) } }
+                    : undefined,
+                disallow: rule.disallow
+                    ? { to: { internalPath: modifyLegacyTemplates(rule.disallow) } }
+                    : undefined,
+                importKind: rule.importKind,
+                message: rule.message,
+            });
         }
-        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`,
+    description: `Check elements entry point`,
     schema: (0, Settings_1.rulesOptionsSchema)({
         rulesMainKey: "target",
+        isLegacy: true,
     }),
 }, function ({ dependency, node, context, settings, options }) {
+    (0, Settings_1.warnMigrationToDependencies)(Shared_1.RULE_NAMES_MAP.ENTRY_POINT);
+    // Validate and warn about legacy selector syntax
+    (0, Settings_1.validateAndWarnRuleOptions)(options, Shared_1.RULE_NAMES_MAP.ENTRY_POINT, "target");
     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,
-            });
-        }
+        const rules = transformToDependenciesRules(options?.rules ?? []);
+        (0, Dependencies_1.evaluateRulesAndReport)({
+            rules,
+            settings,
+            context,
+            node,
+            options,
+            dependency,
+        });
     }
 }, {
     validateRules: { onlyMainKey: true, mainKey: "target" },

package/dist/Rules/External.js

@@ -1,72 +1,103 @@
 "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;
+const Shared_1 = require("../Shared");
+const Dependencies_1 = require("./Dependencies");
+const Support_1 = require("./Support");
+const { RULE_EXTERNAL } = Shared_1.SETTINGS;
+/**
+ * Type guard for external selectors using tuple syntax with options.
+ *
+ * @param selector - External library selector from rule options.
+ * @returns `true` when selector is `[module, options]`.
+ */
+function isExternalLibrarySelectorWithOptions(selector) {
+    return ((0, Shared_1.isArray)(selector) &&
+        selector.length === 2 &&
+        (0, Shared_1.isString)(selector[0]) &&
+        (0, Shared_1.isObject)(selector[1]));
 }
-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}`;
+/**
+ * Builds a dependency selector from a legacy external selector using tuple syntax with options.
+ * @param selector The external library selector in legacy format with options.
+ * @returns The corresponding dependency selector compatible with `dependencies` rule evaluator.
+ */
+function buildSelectorFromLegacySelectorWithOptions(selector) {
+    const moduleSelector = selector[0];
+    const selectorOptions = selector[1];
+    const hasPathSelector = !(0, Shared_1.isNullish)(selectorOptions.path);
+    return {
+        to: {
+            origin: [elements_1.ELEMENT_ORIGINS_MAP.EXTERNAL, elements_1.ELEMENT_ORIGINS_MAP.CORE],
+            ...(hasPathSelector ? { internalPath: selectorOptions.path } : {}),
+        },
+        dependency: {
+            module: moduleSelector,
+            ...(selectorOptions.specifiers
+                ? {
+                    specifiers: selectorOptions.specifiers,
+                }
+                : {}),
+        },
+    };
 }
+/**
+ * Transforms legacy external selectors into dependency selectors.
+ *
+ * @param selectors - External selector(s) from legacy rule format.
+ * @returns Dependency selector(s) compatible with `dependencies` rule evaluator.
+ */
 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 }];
+    if (isExternalLibrarySelectorWithOptions(selectors)) {
+        return buildSelectorFromLegacySelectorWithOptions(selectors);
     }
-    return selectors.map((selector) => {
-        if ((0, Support_1.isArray)(selector)) {
-            return {
+    if ((0, Shared_1.isString)(selectors)) {
+        return {
+            to: {
                 origin: originsToMatch,
-                baseSource: selector[0],
-                specifiers: selector[1].specifiers,
-                internalPath: selector[1].path,
-            };
+            },
+            dependency: {
+                module: selectors,
+            },
+        };
+    }
+    return selectors.map((selector) => {
+        if (isExternalLibrarySelectorWithOptions(selector)) {
+            return buildSelectorFromLegacySelectorWithOptions(selector);
         }
         return {
-            origin: originsToMatch,
-            baseSource: selector,
+            to: { origin: originsToMatch },
+            dependency: {
+                module: selector,
+            },
         };
     });
 }
-exports.default = (0, Support_2.dependencyRule)({
+/**
+ * Converts `external` legacy rules to `dependencies` rule shape.
+ *
+ * @param rules - External rules as configured by the user.
+ * @returns Equivalent dependencies rules consumed by shared evaluator.
+ */
+function transformToDependenciesRules(rules) {
+    return rules.map((rule) => ({
+        from: rule.from,
+        allow: rule.allow ? modifySelectors(rule.allow) : undefined,
+        disallow: rule.disallow ? modifySelectors(rule.disallow) : undefined,
+        importKind: rule.importKind,
+        message: rule.message,
+    }));
+}
+exports.default = (0, Support_1.dependencyRule)({
     ruleName: RULE_EXTERNAL,
-    description: `Check allowed external dependencies by element type`,
+    description: `Check dependencies to external and core libraries`,
     schema: (0, Settings_1.rulesOptionsSchema)({
+        isLegacy: true,
         targetMatcherOptions: {
             type: "object",
             properties: {
@@ -77,7 +108,7 @@ exports.default = (0, Support_2.dependencyRule)({
                     },
                 },
                 path: {
-                    oneOf: [
+                    anyOf: [
                         {
                             type: "string",
                         },
@@ -94,26 +125,20 @@ exports.default = (0, Support_2.dependencyRule)({
         },
     }),
 }, function ({ dependency, node, context, settings, options }) {
+    (0, Settings_1.warnMigrationToDependencies)(Shared_1.RULE_NAMES_MAP.EXTERNAL);
+    // Validate and warn about legacy selector syntax
+    (0, Settings_1.validateAndWarnRuleOptions)(options, Shared_1.RULE_NAMES_MAP.EXTERNAL, "from");
     if ((0, elements_1.isExternalDependencyElement)(dependency.to) ||
         (0, elements_1.isCoreDependencyElement)(dependency.to)) {
-        const adaptedRuleOptions = {
-            ...options,
-            // @ts-expect-error TODO: Fix type
-            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,
-            });
-        }
+        const rules = transformToDependenciesRules(options?.rules ?? []);
+        (0, Dependencies_1.evaluateRulesAndReport)({
+            rules,
+            settings,
+            context,
+            node,
+            options,
+            dependency,
+        });
     }
 }, {
     validateRules: { onlyMainKey: true },

package/dist/Rules/NoIgnored.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const Settings_1 = require("../Settings");
+const Shared_1 = require("../Shared");
 const Support_1 = require("./Support");
-const { RULE_NO_IGNORED } = Settings_1.SETTINGS;
+const { RULE_NO_IGNORED } = Shared_1.SETTINGS;
 exports.default = (0, Support_1.dependencyRule)({
     schema: [],
     ruleName: RULE_NO_IGNORED,
-    description: `Prevent importing ignored files from recognized elements`,
+    description: `Prevent dependencies to ignored files from recognized elements`,
 }, function ({ dependency, node, context }) {
     if (dependency.to.isIgnored) {
         context.report({
-            message: `Importing ignored files is not allowed`,
+            message: `Dependencies to ignored files are not allowed`,
             node: node,
         });
     }

package/dist/Rules/NoPrivate.js

@@ -3,18 +3,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const elements_1 = require("@boundaries/elements");
 const Messages_1 = require("../Messages");
 const Settings_1 = require("../Settings");
+const Shared_1 = require("../Shared");
 const Support_1 = require("./Support");
-const { RULE_NO_PRIVATE } = Settings_1.SETTINGS;
+const { RULE_NO_PRIVATE } = Shared_1.SETTINGS;
+/**
+ * Builds the user-facing error message for private dependency violations.
+ *
+ * @param dependency - Described dependency that triggered the violation.
+ * @param options - Optional rule options with custom message template.
+ * @returns Final error message reported by ESLint.
+ */
 function errorMessage(dependency, options) {
     if (options?.message) {
         return (0, Messages_1.customErrorMessage)(options.message, dependency);
     }
-    // @ts-expect-error could not be defined. TODO: I have to decide whether to unify properties in all elements, or to use type guards
-    return `Dependency is private of element ${(0, Messages_1.elementMessage)(dependency.to.parents?.[0])}`;
+    const privateParent = dependency.to.parents?.[0];
+    /* istanbul ignore next - Defensive: This should not happen */
+    if (!privateParent) {
+        return `Not able to create a message for this violation. Please report this at: ${Shared_1.PLUGIN_ISSUES_URL}`;
+    }
+    return `Dependency is private of ${(0, Messages_1.elementDescriptionMessage)(privateParent, ["type", "category", "captured"], { singleElement: true })}`;
 }
 exports.default = (0, Support_1.dependencyRule)({
     ruleName: RULE_NO_PRIVATE,
-    description: `Prevent importing private elements of another element`,
+    description: `Prevent dependencies to private elements`,
     schema: [
         {
             type: "object",
@@ -30,8 +42,9 @@ exports.default = (0, Support_1.dependencyRule)({
         },
     ],
 }, function ({ dependency, node, context, options }) {
+    (0, Settings_1.warnMigrationToDependencies)(Shared_1.RULE_NAMES_MAP.NO_PRIVATE);
     if (!dependency.to.isIgnored &&
-        (0, elements_1.isLocalDependencyElement)(dependency.to) &&
+        (0, elements_1.isLocalElement)(dependency.to) &&
         dependency.to.type &&
         dependency.to.parents.length &&
         dependency.dependency.relationship.to !==

package/dist/Rules/NoUnknown.js

@@ -1,19 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const elements_1 = require("@boundaries/elements");
-const Settings_1 = require("../Settings");
+const Shared_1 = require("../Shared");
 const Support_1 = require("./Support");
-const { RULE_NO_UNKNOWN } = Settings_1.SETTINGS;
+const { RULE_NO_UNKNOWN } = Shared_1.SETTINGS;
 exports.default = (0, Support_1.dependencyRule)({
     schema: [],
     ruleName: RULE_NO_UNKNOWN,
-    description: `Prevent importing unknown elements from the known ones`,
+    description: `Prevent dependencies to unknown elements`,
 }, function ({ dependency, node, context }) {
     if (!dependency.to.isIgnored &&
-        (0, elements_1.isLocalDependencyElement)(dependency.to) &&
+        (0, elements_1.isLocalElement)(dependency.to) &&
         dependency.to.isUnknown) {
         context.report({
-            message: `Importing unknown elements is not allowed`,
+            message: `Dependencies to unknown elements are not allowed`,
             node: node,
         });
     }

package/dist/Rules/NoUnknownFiles.js

@@ -2,13 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const Elements_1 = require("../Elements");
 const Settings_1 = require("../Settings");
+const Shared_1 = require("../Shared");
 const Support_1 = require("./Support");
-const { RULE_NO_UNKNOWN_FILES } = Settings_1.SETTINGS;
+const { RULE_NO_UNKNOWN_FILES } = Shared_1.SETTINGS;
 const noUnknownFilesRule = {
     ...(0, Support_1.meta)({
         ruleName: RULE_NO_UNKNOWN_FILES,
         schema: [],
-        description: `Prevent creating files not recognized as any of the element types`,
+        description: `Prevent creating files not recognized by any element patterns`,
     }),
     create: function (context) {
         const settings = (0, Settings_1.getSettings)(context);
@@ -19,7 +20,7 @@ const noUnknownFilesRule = {
         return {
             Program: (node) => {
                 context.report({
-                    message: `File is not of any known element type`,
+                    message: `File does not match any element pattern`,
                     node: node,
                 });
             },

package/dist/Rules/Support/DependencyRule.d.ts

@@ -1,4 +1,12 @@
 import type { Rule } from "eslint";
-import type { RuleOptionsWithRules, RuleMetaDefinition } from "../../Settings";
+import type { RuleOptionsWithRules, RuleMetaDefinition } from "../../Shared";
 import type { DependencyRuleRunner, DependencyRuleOptions } from "./DependencyRule.types";
+/**
+ * Creates a rule module that evaluates dependency nodes using shared matcher logic.
+ *
+ * @param ruleMeta - Metadata used to build ESLint rule `meta` information.
+ * @param rule - Rule runner invoked for each described dependency.
+ * @param ruleOptions - Optional behavior flags for validation and rule shape.
+ * @returns ESLint rule module ready to be exported by concrete rules.
+ */
 export declare function dependencyRule<Options extends RuleOptionsWithRules>(ruleMeta: RuleMetaDefinition, rule: DependencyRuleRunner<Options>, ruleOptions?: DependencyRuleOptions): Rule.RuleModule;

package/dist/Rules/Support/DependencyRule.js

@@ -1,17 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dependencyRule = dependencyRule;
+const Debug_1 = require("../../Debug");
 const Elements_1 = require("../../Elements");
 const Settings_1 = require("../../Settings");
-const Support_1 = require("../../Support");
+const Shared_1 = require("../../Shared");
 const Helpers_1 = require("./Helpers");
-const { ADDITIONAL_DEPENDENCY_NODES } = Settings_1.SETTINGS;
-function optionsHaveRules(options) {
-    if (!options) {
-        return false;
-    }
-    return Boolean(options.rules);
-}
+const { ADDITIONAL_DEPENDENCY_NODES } = Shared_1.SETTINGS;
+/**
+ * Creates a rule module that evaluates dependency nodes using shared matcher logic.
+ *
+ * @param ruleMeta - Metadata used to build ESLint rule `meta` information.
+ * @param rule - Rule runner invoked for each described dependency.
+ * @param ruleOptions - Optional behavior flags for validation and rule shape.
+ * @returns ESLint rule module ready to be exported by concrete rules.
+ */
 function dependencyRule(ruleMeta, rule, ruleOptions = {}) {
     return {
         ...(0, Helpers_1.meta)(ruleMeta),
@@ -22,17 +25,14 @@ function dependencyRule(ruleMeta, rule, ruleOptions = {}) {
             if (ruleOptions.validate !== false && !options) {
                 return {};
             }
-            if (ruleOptions.validate !== false && optionsHaveRules(options)) {
-                (0, Settings_1.validateRules)(settings, options.rules, ruleOptions.validateRules);
-            }
-            // TODO: Remove this check when allowing to select by any other property
-            if (file.isIgnored || !file.type) {
+            if (file.isIgnored || file.isUnknown) {
                 return {};
             }
             return settings.dependencyNodes.reduce((visitors, { selector, kind, name }) => {
                 visitors[selector] = (node) => {
-                    if (!(0, Support_1.isString)(node.value)) {
-                        (0, Support_1.warnOnce)(`Dependency node is not a Literal, skipping node. Please check your ${ADDITIONAL_DEPENDENCY_NODES} setting.`);
+                    /* istanbul ignore next - Defensive check */
+                    if (!(0, Shared_1.isString)(node.value)) {
+                        (0, Debug_1.warnOnce)(`Dependency node value is not a string, skipping node.`, `Please check your ${ADDITIONAL_DEPENDENCY_NODES} setting. ${(0, Settings_1.moreInfoSettingsLink)()}`);
                         return;
                     }
                     const dependency = (0, Elements_1.dependencyDescription)({

package/dist/Rules/Support/DependencyRule.types.d.ts

@@ -1,7 +1,7 @@
 import type { DependencyDescription } from "@boundaries/elements";
 import type { Rule } from "eslint";
 import type { EslintLiteralNode } from "../../Elements";
-import type { ValidateRulesOptions, SettingsNormalized } from "../../Settings";
+import type { ValidateRulesOptions, SettingsNormalized } from "../../Shared";
 export type DependencyRuleRunner<Options> = (options: {
     dependency: DependencyDescription;
     options?: Options;

package/dist/Rules/Support/Helpers.d.ts

@@ -1,8 +1,12 @@
 import type { Rule } from "eslint";
-import type { RuleMetaDefinition } from "../../Settings";
+import type { RuleMetaDefinition } from "../../Shared";
 /**
  * Returns the meta object for an ESLint rule.
- * @param param0 The rule metadata definition.
+ * @param options The rule metadata definition.
+ * @param options.description The description of the rule.
+ * @param options.schema The JSON schema for rule options validation.
+ * @param options.ruleName The name of the rule.
+ * @param options.type The type of the rule (problem, suggestion, or layout).
  * @returns The meta object for the ESLint rule.
  */
 export declare function meta({ description, schema, ruleName, type, }: RuleMetaDefinition): Pick<Rule.RuleModule, "meta">;

package/dist/Rules/Support/Helpers.js

@@ -2,46 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.meta = meta;
 const Settings_1 = require("../../Settings");
-/**
- * Removes the plugin namespace from a rule name.
- * @param ruleName The name of the rule.
- * @returns The rule name without the plugin namespace.
- */
-function removePluginNamespace(ruleName) {
-    return ruleName.replace(`${Settings_1.PLUGIN_NAME}/`, "");
-}
-/**
- * Adapts the rule name to be used in a URL.
- * @param ruleName The name of the rule.
- * @returns The adapted rule name for URL usage.
- */
-function adaptRuleNameToUrl(ruleName) {
-    // NOTE: Urls are already prepared for the next major release where "element-types" rule will be renamed to "dependencies", so no 301 redirect will be needed then.
-    if (ruleName === "element-types") {
-        return "dependencies";
-    }
-    return ruleName;
-}
-/**
- * Returns the documentation URL for an ESLint rule.
- * @param ruleName The name of the rule.
- * @returns The documentation URL for the ESLint rule.
- */
-function docsUrl(ruleName) {
-    return `${Settings_1.WEBSITE_URL}/docs/rules/${adaptRuleNameToUrl(removePluginNamespace(ruleName))}/`;
-}
 /**
  * Returns the meta object for an ESLint rule.
- * @param param0 The rule metadata definition.
+ * @param options The rule metadata definition.
+ * @param options.description The description of the rule.
+ * @param options.schema The JSON schema for rule options validation.
+ * @param options.ruleName The name of the rule.
+ * @param options.type The type of the rule (problem, suggestion, or layout).
  * @returns The meta object for the ESLint rule.
  */
-function meta({ description, schema = [], ruleName, type, }) {
+function meta({ description, schema, ruleName, type, }) {
     return {
         meta: {
             // TODO: Consider changing default to "suggestion" in a future major release, because most rules are not fixing code issues, but only suggesting best practices.
             type: type || "problem",
             docs: {
-                url: docsUrl(ruleName),
+                url: (0, Settings_1.ruleDocsUrl)(ruleName),
                 description,
                 category: "dependencies",
             },