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

package/dist/Settings/Validations.js

@@ -1,46 +1,168 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.elementsMatcherSchema = elementsMatcherSchema;
+exports.legacyPoliciesSchema = legacyPoliciesSchema;
 exports.rulesOptionsSchema = rulesOptionsSchema;
-exports.validateElementTypesMatcher = validateElementTypesMatcher;
-exports.isValidElementAssigner = isValidElementAssigner;
+exports.getRuleMainSelector = getRuleMainSelector;
+exports.validateAndWarnRuleOptions = validateAndWarnRuleOptions;
+exports.isValidElementDescriptor = isValidElementDescriptor;
+exports.validateElementDescriptors = validateElementDescriptors;
+exports.validateDependencyNodes = validateDependencyNodes;
+exports.validateLegacyTemplates = validateLegacyTemplates;
+exports.isValidDependencyNodeSelector = isValidDependencyNodeSelector;
+exports.validateAdditionalDependencyNodes = validateAdditionalDependencyNodes;
+exports.isAliasSetting = isAliasSetting;
+exports.deprecateAlias = deprecateAlias;
+exports.deprecateTypes = deprecateTypes;
+exports.validateIgnore = validateIgnore;
+exports.validateInclude = validateInclude;
+exports.validateRootPath = validateRootPath;
+exports.validateFlagAsExternal = validateFlagAsExternal;
+exports.validateDebugFilterSelectors = validateDebugFilterSelectors;
+exports.validateDebugFilesFilter = validateDebugFilesFilter;
+exports.validateDebugDependenciesFilter = validateDebugDependenciesFilter;
+exports.validateDebug = validateDebug;
 exports.validateSettings = validateSettings;
 exports.getSettings = getSettings;
-exports.validateRules = validateRules;
 const elements_1 = require("@boundaries/elements");
-const micromatch_1 = __importDefault(require("micromatch"));
-const Common_1 = require("../Support/Common");
-const Debug_1 = require("../Support/Debug");
+const Debug_1 = require("../Debug");
+const Shared_1 = require("../Shared");
+const Settings_types_1 = require("../Shared/Settings.types");
 const Helpers_1 = require("./Helpers");
 const Settings_1 = require("./Settings");
-const Settings_types_1 = require("./Settings.types");
 const { TYPES, ALIAS, ELEMENTS, DEPENDENCY_NODES, ADDITIONAL_DEPENDENCY_NODES, VALID_DEPENDENCY_NODE_KINDS, DEFAULT_DEPENDENCY_NODES, VALID_MODES, } = Settings_types_1.SETTINGS;
-const DEFAULT_MATCHER_OPTIONS = {
+const trackedValidatedSettings = new WeakMap();
+const trackedWarnedOptions = new WeakSet();
+const defaultLegacyMatcherOptionsSchema = {
+    type: "object",
+};
+/** Schema for validating a micromatch pattern or array of patterns that can also be null. */
+const micromatchPatternNullableSchema = {
+    oneOf: [
+        { type: ["string", "null"] },
+        { type: "array", items: { type: ["string", "null"] } },
+    ],
+};
+const dependencyRelationshipSchema = {
+    type: "object",
+    properties: {
+        from: micromatchPatternNullableSchema,
+        to: micromatchPatternNullableSchema,
+    },
+    additionalProperties: false,
+};
+const dependencyMatcherItemSchema = {
+    type: "object",
+    properties: {
+        relationship: dependencyRelationshipSchema,
+        kind: micromatchPatternNullableSchema,
+        specifiers: micromatchPatternNullableSchema,
+        nodeKind: micromatchPatternNullableSchema,
+        source: micromatchPatternNullableSchema,
+        module: micromatchPatternNullableSchema,
+    },
+    additionalProperties: false,
+};
+const dependencyMatcherSchema = {
+    oneOf: [
+        dependencyMatcherItemSchema,
+        {
+            type: "array",
+            items: dependencyMatcherItemSchema,
+        },
+    ],
+};
+const capturedValuesSelectorSchema = {
+    type: "object",
+    additionalProperties: micromatchPatternNullableSchema,
+};
+const capturedValuesSchema = {
+    oneOf: [
+        {
+            type: "null",
+        },
+        capturedValuesSelectorSchema,
+        {
+            type: "array",
+            items: capturedValuesSelectorSchema,
+        },
+    ],
+};
+const parentElementMatcherSchema = {
     type: "object",
+    properties: {
+        type: micromatchPatternNullableSchema,
+        category: micromatchPatternNullableSchema,
+        elementPath: micromatchPatternNullableSchema,
+        captured: capturedValuesSchema,
+    },
+    additionalProperties: false,
+};
+const objectElementMatcherSchemaItem = {
+    type: "object", // single object-based selector (new format)
+    properties: {
+        path: micromatchPatternNullableSchema,
+        elementPath: micromatchPatternNullableSchema,
+        internalPath: micromatchPatternNullableSchema,
+        type: micromatchPatternNullableSchema,
+        category: micromatchPatternNullableSchema,
+        captured: capturedValuesSchema,
+        parent: {
+            oneOf: [
+                { type: "null" },
+                parentElementMatcherSchema,
+                { type: "array", items: parentElementMatcherSchema },
+            ],
+        },
+        origin: micromatchPatternNullableSchema,
+        isIgnored: { type: "boolean" },
+        isUnknown: { type: "boolean" },
+    },
+    additionalProperties: false,
+};
+const objectElementMatcherSchema = {
+    oneOf: [
+        objectElementMatcherSchemaItem,
+        {
+            type: "array",
+            items: objectElementMatcherSchemaItem,
+        },
+    ],
 };
-function elementsMatcherSchema(matcherOptions = DEFAULT_MATCHER_OPTIONS) {
+/**
+ * Builds JSON schema for legacy policy selectors.
+ *
+ * @param matcherOptions - Extra matcher options accepted in legacy tuple syntax.
+ * @returns JSON schema definition for legacy policy values.
+ */
+function legacyPoliciesSchema(matcherOptions = defaultLegacyMatcherOptionsSchema) {
     return {
-        oneOf: [
+        anyOf: [
             {
-                type: "string", // single matcher
+                type: "string", // single matcher (legacy)
+            },
+            {
+                type: "array", // matcher with captured values (legacy)
+                items: [
+                    {
+                        type: "string", // matcher
+                    },
+                    matcherOptions, // Extra options for legacy rules with custom syntax
+                ],
             },
             {
                 type: "array", // multiple matchers
                 items: {
-                    oneOf: [
+                    anyOf: [
                         {
-                            type: "string", // matcher with options
+                            type: "string", // matcher (legacy)
                         },
                         {
-                            type: "array",
+                            type: "array", // matcher with captured values (legacy)
                             items: [
                                 {
                                     type: "string", // matcher
                                 },
-                                matcherOptions, // options
+                                matcherOptions, // Extra options for legacy rules with custom syntax
                             ],
                         },
                     ],
@@ -49,9 +171,116 @@ function elementsMatcherSchema(matcherOptions = DEFAULT_MATCHER_OPTIONS) {
         ],
     };
 }
-function rulesOptionsSchema(options = {}) {
-    const mainKey = (0, Helpers_1.rulesMainKey)(options.rulesMainKey);
-    return [
+const legacyElementsSelectorItemSchema = {
+    anyOf: [
+        {
+            type: "string", // single matcher (legacy)
+        },
+        {
+            type: "array", // matcher with captured values (legacy)
+            items: [
+                {
+                    type: "string", // matcher
+                },
+                defaultLegacyMatcherOptionsSchema, // Extra options for legacy rules with custom syntax
+            ],
+        },
+    ],
+};
+const legacyElementsSelectorSchema = {
+    anyOf: [
+        legacyElementsSelectorItemSchema,
+        {
+            type: "array",
+            items: legacyElementsSelectorItemSchema,
+        },
+    ],
+};
+/**
+ * Builds JSON schema for rule options of dependency-based rules.
+ *
+ * @param options - Schema customization options for rule main key and extras.
+ * @returns ESLint-compatible schema array for rule options.
+ */
+function rulesOptionsSchema({ rulesMainKey: mainKey, targetMatcherOptions, extraOptionsSchema, isLegacy = false, } = {}) {
+    const policySchema = isLegacy
+        ? legacyPoliciesSchema(targetMatcherOptions)
+        : {
+            anyOf: [
+                legacyPoliciesSchema(targetMatcherOptions),
+                {
+                    type: "object",
+                    properties: {
+                        from: objectElementMatcherSchema,
+                        to: objectElementMatcherSchema,
+                        dependency: dependencyMatcherSchema,
+                    },
+                    additionalProperties: false,
+                },
+            ],
+        };
+    const policiesSchema = {
+        anyOf: [
+            policySchema,
+            {
+                type: "array",
+                items: policySchema,
+            },
+        ],
+    };
+    const elementSelectorSchema = {
+        anyOf: [legacyElementsSelectorSchema, objectElementMatcherSchema],
+    };
+    const legacyMainKey = (0, Helpers_1.rulesMainKey)(mainKey);
+    const ruleSupportedProperties = isLegacy
+        ? {
+            [legacyMainKey]: elementSelectorSchema,
+            allow: policiesSchema,
+            disallow: policiesSchema,
+        }
+        : {
+            from: elementSelectorSchema,
+            to: elementSelectorSchema,
+            dependency: dependencyMatcherSchema,
+            allow: policiesSchema,
+            disallow: policiesSchema,
+        };
+    const requiredProperties = isLegacy
+        ? [
+            {
+                required: [legacyMainKey, "allow"],
+            },
+            {
+                required: [legacyMainKey, "disallow"],
+            },
+        ]
+        : [
+            {
+                required: ["allow"],
+            },
+            {
+                required: ["disallow"],
+            },
+            {
+                required: ["from", "allow"],
+            },
+            {
+                required: ["from", "disallow"],
+            },
+            {
+                required: ["to", "allow"],
+            },
+            {
+                required: ["to", "disallow"],
+            },
+            {
+                required: ["dependency", "allow"],
+            },
+            {
+                required: ["dependency", "disallow"],
+            },
+        ];
+    const schema = [
         {
             type: "object",
             properties: {
@@ -67,11 +296,9 @@ function rulesOptionsSchema(options = {}) {
                     items: {
                         type: "object",
                         properties: {
-                            [mainKey]: elementsMatcherSchema(),
-                            allow: elementsMatcherSchema(options.targetMatcherOptions),
-                            disallow: elementsMatcherSchema(options.targetMatcherOptions),
+                            ...ruleSupportedProperties,
                             importKind: {
-                                oneOf: [
+                                anyOf: [
                                     {
                                         type: "string",
                                     },
@@ -88,221 +315,611 @@ function rulesOptionsSchema(options = {}) {
                             },
                         },
                         additionalProperties: false,
-                        anyOf: [
-                            {
-                                required: [mainKey, "allow", "disallow"],
-                            },
-                            {
-                                required: [mainKey, "allow"],
-                            },
-                            {
-                                required: [mainKey, "disallow"],
-                            },
-                        ],
+                        anyOf: requiredProperties,
                     },
                 },
+                ...extraOptionsSchema,
             },
             additionalProperties: false,
         },
     ];
+    return schema;
+}
+/**
+ * Returns the selector configured under the active rule main key.
+ *
+ * @param rule - Single rule entry from options.
+ * @param mainKey - Main selector key configured for current rule.
+ * @returns Selector value from the corresponding property, when present.
+ */
+function getRuleMainSelector(rule, mainKey) {
+    if (mainKey === "from") {
+        return "from" in rule ? rule.from : undefined;
+    }
+    if (mainKey === "to") {
+        return "to" in rule ? rule.to : undefined;
+    }
+    return "target" in rule ? rule.target : undefined;
 }
-function isValidElementTypesMatcher(matcher, settings) {
-    const matcherToCheck = (0, Common_1.isArray)(matcher)
-        ? matcher[0]
-        : matcher;
-    return (!matcherToCheck ||
-        (matcherToCheck &&
-            micromatch_1.default.some(settings.elementTypeNames, matcherToCheck)));
+/**
+ * Returns all rule selectors that must be checked for legacy syntax.
+ *
+ * @param rule - Rule entry from options.
+ * @param mainKey - Main key used by the current rule.
+ * @returns List of selectors from main key, allow and disallow.
+ */
+function getRuleSelectorsToCheck(rule, mainKey) {
+    const ruleMainKey = (0, Helpers_1.rulesMainKey)(mainKey);
+    return [getRuleMainSelector(rule, ruleMainKey), rule.allow, rule.disallow];
 }
 /**
- * Checks if the value is a single matcher with options (tuple of [string, object])
+ * Detects deprecated selector and template syntax across selectors.
+ *
+ * @param selectors - Selector values to inspect.
+ * @returns Flags describing whether each deprecated syntax was found.
  */
-function isSingleMatcherWithOptions(value) {
-    return ((0, Common_1.isArray)(value) &&
-        value.length === 2 &&
-        (0, Common_1.isString)(value[0]) &&
-        (0, Common_1.isObject)(value[1]));
+function detectLegacyFlags(selectors) {
+    let hasLegacySelector = false;
+    let hasLegacyTemplate = false;
+    for (const selector of selectors) {
+        if (!selector) {
+            continue;
+        }
+        if ((0, Helpers_1.detectLegacyElementSelector)(selector)) {
+            hasLegacySelector = true;
+        }
+        if ((0, Helpers_1.detectLegacyTemplateSyntax)(selector)) {
+            hasLegacyTemplate = true;
+        }
+    }
+    return {
+        hasLegacySelector,
+        hasLegacyTemplate,
+    };
+}
+/**
+ * Collects indices of rules using deprecated selector/template/importKind syntax.
+ *
+ * @param rules - Rule list to inspect.
+ * @param mainKey - Main selector key configured for current rule.
+ * @returns Rule indices grouped by deprecated syntax type.
+ */
+function collectRuleWarningIndexes(rules, mainKey) {
+    const indexes = {
+        rulesWithLegacySelector: [],
+        rulesWithLegacyTemplate: [],
+        rulesWithDeprecatedImportKind: [],
+    };
+    for (const [index, rule] of rules.entries()) {
+        const selectorsToCheck = getRuleSelectorsToCheck(rule, mainKey);
+        const { hasLegacySelector, hasLegacyTemplate } = detectLegacyFlags(selectorsToCheck);
+        if (hasLegacySelector) {
+            indexes.rulesWithLegacySelector.push(index);
+        }
+        if (hasLegacyTemplate) {
+            indexes.rulesWithLegacyTemplate.push(index);
+        }
+        if (!(0, Shared_1.isUndefined)(rule.importKind)) {
+            indexes.rulesWithDeprecatedImportKind.push(index);
+        }
+    }
+    return indexes;
 }
-// TODO: Remove this validation. Selectors should not be limited to element types defined in settings when using selector objects
-function validateElementTypesMatcher(elementsMatcher, settings) {
-    // Handle empty array case
-    if ((0, Common_1.isArray)(elementsMatcher) && elementsMatcher.length === 0) {
+/**
+ * Warns once when deprecated selector/template syntax is detected in rules.
+ *
+ * @param options - Rule options containing `rules` entries.
+ * @param ruleName - Rule name displayed in warning messages.
+ * @param mainKey - Main selector key used by the current rule.
+ */
+function validateAndWarnRuleOptions(options, ruleName, mainKey = "from") {
+    if (!options || trackedWarnedOptions.has(options)) {
         return;
     }
-    // Determine if it's a single matcher or an array of matchers
-    let matcher;
-    if ((0, Common_1.isString)(elementsMatcher)) {
-        matcher = elementsMatcher;
+    if (!options.rules || !(0, Shared_1.isArray)(options.rules)) {
+        return;
     }
-    else if (isSingleMatcherWithOptions(elementsMatcher)) {
-        // It's a single matcher with options: ["type", { option: value }]
-        matcher = elementsMatcher;
+    trackedWarnedOptions.add(options);
+    const { rulesWithLegacySelector, rulesWithLegacyTemplate, rulesWithDeprecatedImportKind, } = collectRuleWarningIndexes(options.rules, mainKey);
+    if (rulesWithLegacySelector.length > 0) {
+        (0, Debug_1.warnOnce)(`[${ruleName}] Detected legacy selector syntax in ${rulesWithLegacySelector.length} rule(s) at indices: ${rulesWithLegacySelector.join(", ")}.`, `Consider migrating to object-based selectors. ${(0, Helpers_1.migrationToV6GuideLink)()}`);
     }
-    else if ((0, Common_1.isArray)(elementsMatcher)) {
-        // It's an array of matchers: ["helpers", "components"] or [["helpers", {...}], "components"]
-        // NOTE: Validate only the first matcher. It is wrong, but we don't want to impact performance, and anyway it was already validating only the first one.
-        // In next major version, validation will be removed, because schema validation will handle it.
-        matcher = elementsMatcher[0];
+    if (rulesWithLegacyTemplate.length > 0) {
+        (0, Debug_1.warnOnce)(`[${ruleName}] Detected legacy template syntax \${...} in ${rulesWithLegacyTemplate.length} rule(s) at indices: ${rulesWithLegacyTemplate.join(", ")}.`, `Consider migrating to {{...}} syntax. ${(0, Helpers_1.migrationToV6GuideLink)("new-template-syntax")}`);
     }
-    else {
-        (0, Debug_1.warnOnce)(`Option is not a valid elements selector: '${JSON.stringify(elementsMatcher)}'`);
-        return;
+    if (rulesWithDeprecatedImportKind.length > 0) {
+        (0, Debug_1.warnOnce)(`[${ruleName}] Detected deprecated rule-level "importKind" in ${rulesWithDeprecatedImportKind.length} rule(s) at indices: ${rulesWithDeprecatedImportKind.join(", ")}.`, `Use selector-level "dependency.kind" instead. When both are defined, "dependency.kind" takes precedence. ${(0, Helpers_1.migrationToV6GuideLink)("rule-level-importkind-is-deprecated")}`);
     }
-    // Validate the matcher
-    if (!isValidElementTypesMatcher(matcher, settings)) {
-        (0, Debug_1.warnOnce)(`Option '${JSON.stringify(matcher)}' does not match any element type from '${ELEMENTS}' setting`);
+}
+/**
+ * Emits a generic warning for invalid element descriptor values.
+ */
+function warnInvalidElementDescriptor() {
+    (0, Debug_1.warnOnce)(`Invalid element descriptor in '${ELEMENTS}' setting.`, (0, Helpers_1.moreInfoSettingsLink)());
+}
+/**
+ * Validates that descriptor contains at least one identity property.
+ *
+ * @param element - Candidate element descriptor object.
+ * @returns `true` when descriptor has either `type` or `category`.
+ */
+function hasTypeOrCategory(element) {
+    return Boolean(element.type || element.category);
+}
+/**
+ * Checks whether descriptor `type` property, when present, is valid.
+ *
+ * @param element - Candidate element descriptor object.
+ * @returns `true` when `type` is absent or a string.
+ */
+function hasValidTypeProperty(element) {
+    return !element.type || (0, Shared_1.isString)(element.type);
+}
+/**
+ * Checks whether descriptor `category` property, when present, is valid.
+ *
+ * @param element - Candidate element descriptor object.
+ * @returns `true` when `category` is absent or a string.
+ */
+function hasValidCategoryProperty(element) {
+    return !element.category || (0, Shared_1.isString)(element.category);
+}
+/**
+ * Checks whether descriptor `mode` property uses a supported mode value.
+ *
+ * @param element - Candidate element descriptor object.
+ * @returns `true` when mode is absent, non-string, or included in valid modes.
+ */
+function hasValidModeProperty(element) {
+    if (!element.mode || !(0, Shared_1.isString)(element.mode)) {
+        return true;
     }
+    return VALID_MODES.includes(element.mode);
 }
-function isValidElementAssigner(element) {
+/**
+ * Checks whether descriptor `pattern` property is valid.
+ *
+ * @param element - Candidate element descriptor object.
+ * @returns `true` when pattern exists and is a string or array.
+ */
+function hasValidPatternProperty(element) {
+    return Boolean(element.pattern && ((0, Shared_1.isString)(element.pattern) || (0, Shared_1.isArray)(element.pattern)));
+}
+/**
+ * Checks whether descriptor `capture` property, when present, is valid.
+ *
+ * @param element - Candidate element descriptor object.
+ * @returns `true` when capture is absent or an array.
+ */
+function hasValidCaptureProperty(element) {
+    return !element.capture || (0, Shared_1.isArray)(element.capture);
+}
+/**
+ * Validates object-based element descriptor properties and emits warnings.
+ *
+ * @param element - Candidate element descriptor object.
+ * @returns `true` when descriptor object is valid.
+ */
+function validateObjectElementDescriptor(element) {
+    if (!hasTypeOrCategory(element)) {
+        (0, Debug_1.warnOnce)(`Missing "type" or "category" property in an element descriptor in '${ELEMENTS}' setting.`, (0, Helpers_1.moreInfoSettingsLink)());
+        return false;
+    }
+    if (!hasValidTypeProperty(element)) {
+        (0, Debug_1.warnOnce)(`Invalid "type" property in an element descriptor in '${ELEMENTS}' setting.`, (0, Helpers_1.moreInfoSettingsLink)());
+        return false;
+    }
+    if (!hasValidCategoryProperty(element)) {
+        (0, Debug_1.warnOnce)(`Invalid "category" property in an element descriptor in '${ELEMENTS}' setting.`, (0, Helpers_1.moreInfoSettingsLink)());
+        return false;
+    }
+    if (!hasValidModeProperty(element)) {
+        (0, Debug_1.warnOnce)(`Invalid "mode" property in an element descriptor in '${ELEMENTS}' setting.`, `It should be one of ${VALID_MODES.join(", ")}. ${(0, Helpers_1.moreInfoSettingsLink)()}`);
+        return false;
+    }
+    if (!hasValidPatternProperty(element)) {
+        (0, Debug_1.warnOnce)(`Invalid "pattern" property in an element descriptor in '${ELEMENTS}' setting.`, (0, Helpers_1.moreInfoSettingsLink)());
+        return false;
+    }
+    if (!hasValidCaptureProperty(element)) {
+        (0, Debug_1.warnOnce)(`Invalid "capture" property in an element descriptor in '${ELEMENTS}' setting.`, `Capture should be an array of strings. ${(0, Helpers_1.moreInfoSettingsLink)()}`);
+        return false;
+    }
+    return true;
+}
+/**
+ * Validates one element descriptor item from plugin settings.
+ *
+ * @param element - Candidate element descriptor from settings.
+ * @returns `true` when descriptor is valid or accepted legacy string.
+ */
+function isValidElementDescriptor(element) {
     if (!element) {
-        (0, Debug_1.warnOnce)(`Please provide a valid object to define element types in '${ELEMENTS}' setting`);
+        warnInvalidElementDescriptor();
         return false;
     }
     if ((0, Helpers_1.isLegacyType)(element)) {
-        (0, Debug_1.warnOnce)(`Defining elements as strings in settings is deprecated. Will be automatically converted, but this feature will be removed in next major versions`);
+        (0, Debug_1.warnOnce)(`Defining elements as strings in settings is deprecated.`, `It will be automatically converted, but this feature will be removed in next major versions. ${(0, Helpers_1.migrationToV6GuideLink)()}`);
         return true;
     }
-    else {
-        const isObjectElement = (0, Common_1.isObject)(element);
-        if (!isObjectElement) {
-            (0, Debug_1.warnOnce)(`Please provide a valid object to define element types in '${ELEMENTS}' setting`);
-            return false;
-        }
-        if (!element.type || !(0, Common_1.isString)(element.type)) {
-            (0, Debug_1.warnOnce)(`Please provide type in '${ELEMENTS}' setting`);
-            return false;
-        }
-        if (element.mode &&
-            (0, Common_1.isString)(element.mode) &&
-            !VALID_MODES.includes(element.mode)) {
-            (0, Debug_1.warnOnce)(`Invalid mode property of type ${element.type} in '${ELEMENTS}' setting. Should be one of ${VALID_MODES.join(",")}. Default value "${VALID_MODES[0]}" will be used instead`);
-            return false;
-        }
-        if (!element.pattern ||
-            !((0, Common_1.isString)(element.pattern) || (0, Common_1.isArray)(element.pattern))) {
-            (0, Debug_1.warnOnce)(`Please provide a valid pattern to type ${element.type} in '${ELEMENTS}' setting`);
-            return false;
-        }
-        if (element.capture && !(0, Common_1.isArray)(element.capture)) {
-            (0, Debug_1.warnOnce)(`Invalid capture property of type ${element.type} in '${ELEMENTS}' setting`);
-            return false;
-        }
-        return true;
+    if (!(0, Shared_1.isObject)(element)) {
+        warnInvalidElementDescriptor();
+        return false;
     }
+    return validateObjectElementDescriptor(element);
 }
-function validateElements(elements) {
-    if (!elements || !(0, Common_1.isArray)(elements) || !elements.length) {
-        (0, Debug_1.warnOnce)(`Please provide element types using the '${ELEMENTS}' setting`);
+/**
+ * Validates and filters the configured list of element descriptors.
+ *
+ * @param elements - Raw `boundaries/elements` setting value.
+ * @returns Valid descriptors or `undefined` when setting is invalid/missing.
+ */
+function validateElementDescriptors(elements) {
+    if (!elements || !(0, Shared_1.isArray)(elements) || !elements.length) {
+        (0, Debug_1.warnOnce)(`Please provide element descriptors using the '${ELEMENTS}' setting.`, (0, Helpers_1.moreInfoSettingsLink)());
         return;
     }
-    return elements.filter(isValidElementAssigner);
+    return elements.filter(isValidElementDescriptor);
 }
+/**
+ * Validates configured dependency node keys.
+ *
+ * @param dependencyNodes - Raw dependency node keys from settings.
+ * @returns Filtered valid keys or `undefined` for missing/invalid setting.
+ */
 function validateDependencyNodes(dependencyNodes) {
     if (!dependencyNodes) {
         return;
     }
     const defaultNodesNames = Object.keys(DEFAULT_DEPENDENCY_NODES);
-    const invalidFormatMessage = [
-        `Please provide a valid value in ${DEPENDENCY_NODES} setting.`,
-        `The value should be an array of the following strings:`,
-        ` "${defaultNodesNames.join('", "')}".`,
-    ].join(" ");
-    if (!(0, Common_1.isArray)(dependencyNodes)) {
-        (0, Debug_1.warnOnce)(invalidFormatMessage);
+    const invalidFormatTitle = `Invalid ${DEPENDENCY_NODES} setting format.`;
+    const invalidNodeMessage = `It should be an array of the following strings: "${defaultNodesNames.join('", "')}". ${(0, Helpers_1.moreInfoSettingsLink)()}`;
+    if (!(0, Shared_1.isArray)(dependencyNodes)) {
+        (0, Debug_1.warnOnce)(invalidFormatTitle, invalidNodeMessage);
         return;
     }
     for (const dependencyNode of dependencyNodes) {
         if (!(0, Helpers_1.isDependencyNodeKey)(dependencyNode)) {
-            (0, Debug_1.warnOnce)(invalidFormatMessage);
+            (0, Debug_1.warnOnce)(invalidFormatTitle, invalidNodeMessage);
         }
     }
     return dependencyNodes.filter(Helpers_1.isDependencyNodeKey);
 }
 /**
  * Validates the legacyTemplates setting.
- * @param legacyTemplates The legacyTemplates setting value
- * @returns The validated legacyTemplates value or undefined
+ *
+ * @param legacyTemplates - Raw legacyTemplates setting value.
+ * @returns Validated boolean value or `undefined` when missing/invalid.
  */
-function validateLegacyTemplates(
-/** The legacyTemplates setting value */
-legacyTemplates) {
-    if (legacyTemplates === undefined) {
+function validateLegacyTemplates(legacyTemplates) {
+    if ((0, Shared_1.isUndefined)(legacyTemplates)) {
         return;
     }
-    if ((0, Common_1.isBoolean)(legacyTemplates)) {
+    if ((0, Shared_1.isBoolean)(legacyTemplates)) {
         return legacyTemplates;
     }
-    (0, Debug_1.warnOnce)(`Please provide a valid value in '${Settings_types_1.SETTINGS_KEYS_MAP.LEGACY_TEMPLATES}' setting. The value should be a boolean.`);
+    (0, Debug_1.warnOnce)(`Please provide a valid value in '${Settings_types_1.SETTINGS_KEYS_MAP.LEGACY_TEMPLATES}' setting.`, `The value should be a boolean. ${(0, Helpers_1.moreInfoSettingsLink)()}`);
 }
+/**
+ * Validates one custom dependency-node selector object.
+ *
+ * @param selector - Candidate additional dependency node selector.
+ * @returns `true` when selector has a valid shape.
+ */
 function isValidDependencyNodeSelector(selector) {
-    const isValidObject = (0, Common_1.isObject)(selector) &&
-        (0, Common_1.isString)(selector.selector) &&
+    const isValidObject = (0, Shared_1.isObject)(selector) &&
+        (0, Shared_1.isString)(selector.selector) &&
         (!selector.kind ||
-            ((0, Common_1.isString)(selector.kind) &&
-                VALID_DEPENDENCY_NODE_KINDS.includes(selector.kind)));
+            ((0, Shared_1.isString)(selector.kind) &&
+                VALID_DEPENDENCY_NODE_KINDS.includes(selector.kind))) &&
+        (!selector.name || (0, Shared_1.isString)(selector.name));
     if (!isValidObject) {
-        (0, Debug_1.warnOnce)(`Please provide a valid object in ${ADDITIONAL_DEPENDENCY_NODES} setting. The object should be composed of the following properties: { selector: "<esquery selector>", kind: "value" | "type" }. The invalid object will be ignored.`);
+        (0, Debug_1.warnOnce)(`Please provide a valid object in ${ADDITIONAL_DEPENDENCY_NODES} setting.`, `The object should be composed of the following properties: { selector: "<esquery selector>", kind: "value" | "type", name: "<string>" (optional) }. The invalid object will be ignored. ${(0, Helpers_1.moreInfoSettingsLink)()}`);
+    }
+    else if ((0, Shared_1.isObject)(selector) && !selector.name) {
+        (0, Debug_1.warnOnce)(`Consider adding a "name" property to your custom dependency node for using it in selectors and custom messages.`, (0, Helpers_1.moreInfoSettingsLink)());
     }
     return isValidObject;
 }
+/**
+ * Validates the list of additional dependency node selectors.
+ *
+ * @param additionalDependencyNodes - Raw custom dependency nodes setting.
+ * @returns Valid selectors or `undefined` when absent/invalid.
+ */
 function validateAdditionalDependencyNodes(additionalDependencyNodes) {
     if (!additionalDependencyNodes) {
         return;
     }
-    const invalidFormatMessage = [
-        `Please provide a valid value in ${ADDITIONAL_DEPENDENCY_NODES} setting.`,
-        "The value should be an array composed of the following objects:",
-        '{ selector: "<esquery selector>", kind: "value" | "type" }.',
-    ].join(" ");
-    if (!(0, Common_1.isArray)(additionalDependencyNodes)) {
-        (0, Debug_1.warnOnce)(invalidFormatMessage);
+    const invalidFormatTitle = `Invalid ${ADDITIONAL_DEPENDENCY_NODES} setting format.`;
+    const invalidNodeMessage = `It should be an array containing objects with the following properties: { selector: "<esquery selector>", kind: "value" | "type", name: "<string>" (optional) }. ${(0, Helpers_1.moreInfoSettingsLink)()}`;
+    if (!(0, Shared_1.isArray)(additionalDependencyNodes)) {
+        (0, Debug_1.warnOnce)(invalidFormatTitle, invalidNodeMessage);
         return;
     }
     return additionalDependencyNodes.filter(isValidDependencyNodeSelector);
 }
+/**
+ * Type guard for alias setting object.
+ *
+ * @param value - Candidate alias setting value.
+ * @returns `true` when value is an object whose values are strings.
+ */
+function isAliasSetting(value) {
+    return (0, Shared_1.isObject)(value) && Object.values(value).every(Shared_1.isString);
+}
+/**
+ * Emits deprecation warning for legacy `alias` setting.
+ *
+ * @param aliases - Alias setting value when present.
+ */
 function deprecateAlias(aliases) {
     if (aliases) {
-        (0, Debug_1.warnOnce)(`Defining aliases in '${ALIAS}' setting is deprecated. Please use 'import/resolver' setting`);
+        (0, Debug_1.warnOnce)(`Defining aliases in '${ALIAS}' setting is deprecated.`, `Please use 'import/resolver' setting. ${(0, Helpers_1.moreInfoSettingsLink)()}`);
     }
 }
+/**
+ * Emits deprecation warning for legacy `types` setting.
+ *
+ * @param types - Legacy types setting value when present.
+ */
 function deprecateTypes(types) {
     if (types) {
-        (0, Debug_1.warnOnce)(`'${TYPES}' setting is deprecated. Please use '${ELEMENTS}' instead`);
+        (0, Debug_1.warnOnce)(`'${TYPES}' setting is deprecated.`, `Please use '${ELEMENTS}' instead. ${(0, Helpers_1.migrationToV2GuideLink)()}`);
     }
 }
+/**
+ * Validates `ignore` setting values.
+ *
+ * @param ignore - Raw ignore setting.
+ * @returns String or string array when valid.
+ */
 function validateIgnore(ignore) {
     if (!ignore) {
         return;
     }
-    if ((0, Common_1.isString)(ignore) || ((0, Common_1.isArray)(ignore) && ignore.every(Common_1.isString))) {
+    if ((0, Shared_1.isString)(ignore) || ((0, Shared_1.isArray)(ignore) && ignore.every(Shared_1.isString))) {
         return ignore;
     }
-    (0, Debug_1.warnOnce)(`Please provide a valid value in '${Settings_types_1.SETTINGS_KEYS_MAP.IGNORE}' setting. The value should be a string or an array of strings.`);
+    (0, Debug_1.warnOnce)(`Please provide a valid value in '${Settings_types_1.SETTINGS_KEYS_MAP.IGNORE}' setting.`, `The value should be a string or an array of strings. ${(0, Helpers_1.moreInfoSettingsLink)()}`);
 }
+/**
+ * Validates `include` setting values.
+ *
+ * @param include - Raw include setting.
+ * @returns String or string array when valid.
+ */
 function validateInclude(include) {
     if (!include) {
         return;
     }
-    if ((0, Common_1.isString)(include) || ((0, Common_1.isArray)(include) && include.every(Common_1.isString))) {
+    if ((0, Shared_1.isString)(include) || ((0, Shared_1.isArray)(include) && include.every(Shared_1.isString))) {
         return include;
     }
-    (0, Debug_1.warnOnce)(`Please provide a valid value in '${Settings_types_1.SETTINGS_KEYS_MAP.INCLUDE}' setting. The value should be a string or an array of strings.`);
+    (0, Debug_1.warnOnce)(`Please provide a valid value in '${Settings_types_1.SETTINGS_KEYS_MAP.INCLUDE}' setting.`, `The value should be a string or an array of strings. ${(0, Helpers_1.moreInfoSettingsLink)()}`);
 }
+/**
+ * Validates `root-path` setting values.
+ *
+ * @param rootPath - Raw root-path setting.
+ * @returns Root path string when valid.
+ */
 function validateRootPath(rootPath) {
     if (!rootPath) {
         return;
     }
-    if ((0, Common_1.isString)(rootPath)) {
+    if ((0, Shared_1.isString)(rootPath)) {
         return rootPath;
     }
-    (0, Debug_1.warnOnce)(`Please provide a valid value in '${Settings_types_1.SETTINGS_KEYS_MAP.ROOT_PATH}' setting. The value should be a string.`);
+    (0, Debug_1.warnOnce)(`Please provide a valid value in '${Settings_types_1.SETTINGS_KEYS_MAP.ROOT_PATH}' setting.`, `The value should be a string. ${(0, Helpers_1.moreInfoSettingsLink)()}`);
+}
+/**
+ * Validates and assigns an optional boolean field in `flag-as-external` settings.
+ *
+ * @param options - Raw `flag-as-external` settings object.
+ * @param validated - Accumulator for validated options.
+ * @param optionKey - Optional boolean field to validate and assign.
+ */
+function assignFlagAsExternalBooleanOption(options, validated, optionKey) {
+    const value = options[optionKey];
+    if ((0, Shared_1.isUndefined)(value)) {
+        return;
+    }
+    if ((0, Shared_1.isBoolean)(value)) {
+        validated[optionKey] = value;
+        return;
+    }
+    (0, Debug_1.warnOnce)(`Please provide a valid boolean for '${optionKey}' in '${Settings_types_1.SETTINGS_KEYS_MAP.FLAG_AS_EXTERNAL}' setting.`, (0, Helpers_1.moreInfoSettingsLink)());
 }
-// TODO: Remove settings validation in next major version. It should be done by schema validation only
+/**
+ * Validates and assigns `customSourcePatterns` in `flag-as-external` settings.
+ *
+ * @param options - Raw `flag-as-external` settings object.
+ * @param validated - Accumulator for validated options.
+ */
+function assignFlagAsExternalCustomSourcePatterns(options, validated) {
+    const value = options.customSourcePatterns;
+    if ((0, Shared_1.isUndefined)(value)) {
+        return;
+    }
+    if ((0, Shared_1.isArray)(value) && value.every(Shared_1.isString)) {
+        validated.customSourcePatterns = value;
+        return;
+    }
+    (0, Debug_1.warnOnce)(`Please provide a valid array of strings for 'customSourcePatterns' in '${Settings_types_1.SETTINGS_KEYS_MAP.FLAG_AS_EXTERNAL}' setting.`, (0, Helpers_1.moreInfoSettingsLink)());
+}
+/**
+ * Validates `flag-as-external` setting object and fields.
+ *
+ * @param flagAsExternal - Raw flag-as-external setting value.
+ * @returns Normalized options object with valid fields only.
+ */
+function validateFlagAsExternal(flagAsExternal) {
+    if (!flagAsExternal) {
+        return;
+    }
+    if (!(0, Shared_1.isObject)(flagAsExternal)) {
+        (0, Debug_1.warnOnce)(`Please provide a valid value in '${Settings_types_1.SETTINGS_KEYS_MAP.FLAG_AS_EXTERNAL}' setting.`, `The value should be an object. ${(0, Helpers_1.moreInfoSettingsLink)()}`);
+        return;
+    }
+    const options = flagAsExternal;
+    const validated = {};
+    assignFlagAsExternalBooleanOption(options, validated, "unresolvableAlias");
+    assignFlagAsExternalBooleanOption(options, validated, "inNodeModules");
+    assignFlagAsExternalBooleanOption(options, validated, "outsideRootPath");
+    assignFlagAsExternalCustomSourcePatterns(options, validated);
+    return validated;
+}
+/**
+ * Validates debug filter selectors for files or dependencies.
+ *
+ * @param value - Raw filter value.
+ * @param filterName - Filter key used in warning messages.
+ * @returns Filter array when valid, otherwise `undefined`.
+ */
+function validateDebugFilterSelectors(value, filterName) {
+    if ((0, Shared_1.isUndefined)(value)) {
+        return undefined;
+    }
+    if ((0, Shared_1.isArray)(value)) {
+        return value;
+    }
+    (0, Debug_1.warnOnce)(`Please provide a valid array for '${filterName}' in '${Settings_types_1.SETTINGS_KEYS_MAP.DEBUG}' setting.`, (0, Helpers_1.moreInfoSettingsLink)());
+    return undefined;
+}
+/**
+ * Validates debug `files` filter selector list.
+ *
+ * @param value - Raw `debug.filter.files` setting value.
+ * @returns Valid files filter selectors.
+ */
+function validateDebugFilesFilter(value) {
+    return validateDebugFilterSelectors(value, "files");
+}
+/**
+ * Validates debug `dependencies` filter selector list.
+ *
+ * @param value - Raw `debug.filter.dependencies` setting value.
+ * @returns Valid dependency filter selectors.
+ */
+function validateDebugDependenciesFilter(value) {
+    return validateDebugFilterSelectors(value, "dependencies");
+}
+/**
+ * Validates and assigns `debug.enabled` when provided.
+ *
+ * @param debug - Raw debug setting object.
+ * @param validated - Debug setting accumulator.
+ */
+function assignDebugEnabled(debug, validated) {
+    if ((0, Shared_1.isUndefined)(debug.enabled)) {
+        return;
+    }
+    if ((0, Shared_1.isBoolean)(debug.enabled)) {
+        validated.enabled = debug.enabled;
+        return;
+    }
+    (0, Debug_1.warnOnce)(`Please provide a valid boolean for 'enabled' in '${Settings_types_1.SETTINGS_KEYS_MAP.DEBUG}' setting.`, (0, Helpers_1.moreInfoSettingsLink)());
+}
+/**
+ * Validates and assigns a `debug.messages.*` boolean flag when provided.
+ *
+ * @param messages - Raw `debug.messages` object.
+ * @param validated - Debug setting accumulator.
+ * @param key - Message flag key to validate.
+ */
+function assignDebugMessageFlag(messages, validated, key) {
+    const value = messages[key];
+    if ((0, Shared_1.isUndefined)(value)) {
+        return;
+    }
+    if ((0, Shared_1.isBoolean)(value)) {
+        validated.messages[key] = value;
+        return;
+    }
+    (0, Debug_1.warnOnce)(`Please provide a valid boolean for 'messages.${key}' in '${Settings_types_1.SETTINGS_KEYS_MAP.DEBUG}' setting.`, (0, Helpers_1.moreInfoSettingsLink)());
+}
+/**
+ * Validates and assigns `debug.messages` object and known flags.
+ *
+ * @param debug - Raw debug setting object.
+ * @param validated - Debug setting accumulator.
+ */
+function assignDebugMessages(debug, validated) {
+    if ((0, Shared_1.isUndefined)(debug.messages)) {
+        return;
+    }
+    if (!(0, Shared_1.isObject)(debug.messages)) {
+        (0, Debug_1.warnOnce)(`Please provide a valid object for 'messages' in '${Settings_types_1.SETTINGS_KEYS_MAP.DEBUG}' setting.`, (0, Helpers_1.moreInfoSettingsLink)());
+        return;
+    }
+    assignDebugMessageFlag(debug.messages, validated, "files");
+    assignDebugMessageFlag(debug.messages, validated, "dependencies");
+    assignDebugMessageFlag(debug.messages, validated, "violations");
+}
+/**
+ * Validates and assigns `debug.filter` object and supported selectors.
+ *
+ * @param debug - Raw debug setting object.
+ * @param validated - Debug setting accumulator.
+ */
+function assignDebugFilter(debug, validated) {
+    if ((0, Shared_1.isUndefined)(debug.filter)) {
+        return;
+    }
+    if (!(0, Shared_1.isObject)(debug.filter)) {
+        (0, Debug_1.warnOnce)(`Please provide a valid object for 'filter' in '${Settings_types_1.SETTINGS_KEYS_MAP.DEBUG}' setting.`, (0, Helpers_1.moreInfoSettingsLink)());
+        return;
+    }
+    const files = validateDebugFilesFilter(debug.filter.files);
+    const dependencies = validateDebugDependenciesFilter(debug.filter.dependencies);
+    validated.filter = {
+        ...((0, Shared_1.isUndefined)(files) ? {} : { files }),
+        ...((0, Shared_1.isUndefined)(dependencies) ? {} : { dependencies }),
+    };
+}
+/**
+ * Validates the `debug` setting object and nested filters.
+ *
+ * @param debug - Raw debug setting value.
+ * @returns Normalized debug setting when valid.
+ */
+function validateDebug(debug) {
+    const validated = {
+        enabled: false,
+        filter: {
+            files: undefined,
+            dependencies: undefined,
+        },
+        messages: {
+            files: true,
+            dependencies: true,
+            violations: true,
+        },
+    };
+    if (!debug) {
+        return validated;
+    }
+    if (!(0, Shared_1.isObject)(debug)) {
+        (0, Debug_1.warnOnce)(`Please provide a valid value in '${Settings_types_1.SETTINGS_KEYS_MAP.DEBUG}' setting.`, `The value should be an object. ${(0, Helpers_1.moreInfoSettingsLink)()}`);
+        return validated;
+    }
+    assignDebugEnabled(debug, validated);
+    assignDebugMessages(debug, validated);
+    assignDebugFilter(debug, validated);
+    return validated;
+}
+/**
+ * Validates plugin settings and returns a sanitized settings object.
+ *
+ * @param settings - Raw ESLint context settings.
+ * @returns Validated settings ready for normalization.
+ */
 function validateSettings(settings) {
     deprecateTypes(settings[TYPES]);
-    deprecateAlias(settings[ALIAS]);
+    deprecateAlias(isAliasSetting(settings[ALIAS]) ? settings[ALIAS] : undefined);
     return {
-        [Settings_types_1.SETTINGS_KEYS_MAP.ELEMENTS]: validateElements(settings[ELEMENTS] || settings[TYPES]),
+        [Settings_types_1.SETTINGS_KEYS_MAP.ELEMENTS]: validateElementDescriptors(settings[ELEMENTS] || settings[TYPES]),
         [Settings_types_1.SETTINGS_KEYS_MAP.IGNORE]: validateIgnore(settings[Settings_types_1.SETTINGS_KEYS_MAP.IGNORE]),
         [Settings_types_1.SETTINGS_KEYS_MAP.INCLUDE]: validateInclude(settings[Settings_types_1.SETTINGS_KEYS_MAP.INCLUDE]),
         [Settings_types_1.SETTINGS_KEYS_MAP.ROOT_PATH]: validateRootPath(settings[Settings_types_1.SETTINGS_KEYS_MAP.ROOT_PATH]),
@@ -310,46 +927,45 @@ function validateSettings(settings) {
         [Settings_types_1.SETTINGS_KEYS_MAP.LEGACY_TEMPLATES]: validateLegacyTemplates(settings[Settings_types_1.SETTINGS_KEYS_MAP.LEGACY_TEMPLATES]),
         [Settings_types_1.SETTINGS_KEYS_MAP.ADDITIONAL_DEPENDENCY_NODES]: validateAdditionalDependencyNodes(settings[ADDITIONAL_DEPENDENCY_NODES]),
         [Settings_types_1.SETTINGS_KEYS_MAP.CACHE]: settings[Settings_types_1.SETTINGS_KEYS_MAP.CACHE],
+        [Settings_types_1.SETTINGS_KEYS_MAP.FLAG_AS_EXTERNAL]: validateFlagAsExternal(settings[Settings_types_1.SETTINGS_KEYS_MAP.FLAG_AS_EXTERNAL]),
+        [Settings_types_1.SETTINGS_KEYS_MAP.DEBUG]: validateDebug(settings[Settings_types_1.SETTINGS_KEYS_MAP.DEBUG]),
     };
 }
 /**
- * Returns the normalized settings from the ESLint rule context
- * @param context The ESLint rule context
- * @returns The normalized settings
+ * Returns normalized and cached settings from ESLint rule context.
+ *
+ * @param context - ESLint rule context.
+ * @returns Normalized settings object used by rules.
  */
 function getSettings(context) {
+    const alreadyValidatedSettings = trackedValidatedSettings.get(context.settings);
+    if (alreadyValidatedSettings) {
+        return alreadyValidatedSettings;
+    }
     const validatedSettings = validateSettings(context.settings);
-    const dependencyNodesSetting = (0, Common_1.getArrayOrNull)(validatedSettings[Settings_types_1.SETTINGS_KEYS_MAP.DEPENDENCY_NODES]);
-    const additionalDependencyNodesSetting = (0, Common_1.getArrayOrNull)(validatedSettings[ADDITIONAL_DEPENDENCY_NODES]);
-    const dependencyNodes = 
-    // TODO In next major version, make this default to all types of nodes!!!
-    (dependencyNodesSetting || [Settings_types_1.DEPENDENCY_NODE_KEYS_MAP.IMPORT])
-        .flatMap((dependencyNode) => [
-        ...DEFAULT_DEPENDENCY_NODES[dependencyNode],
+    const dependencyNodesSetting = (0, Shared_1.getArrayOrNull)(validatedSettings[Settings_types_1.SETTINGS_KEYS_MAP.DEPENDENCY_NODES]);
+    const additionalDependencyNodesSetting = (0, Shared_1.getArrayOrNull)(validatedSettings[ADDITIONAL_DEPENDENCY_NODES]);
+    const dependencyNodes = (dependencyNodesSetting || [
+        Settings_types_1.DEPENDENCY_NODE_KEYS_MAP.IMPORT,
+        Settings_types_1.DEPENDENCY_NODE_KEYS_MAP.EXPORT,
+        Settings_types_1.DEPENDENCY_NODE_KEYS_MAP.REQUIRE,
+        Settings_types_1.DEPENDENCY_NODE_KEYS_MAP.DYNAMIC_IMPORT,
     ])
+        .flatMap((dependencyNode) => [...DEFAULT_DEPENDENCY_NODES[dependencyNode]])
         .filter(Boolean);
     const additionalDependencyNodes = additionalDependencyNodesSetting || [];
     const ignoreSetting = validatedSettings[Settings_types_1.SETTINGS_KEYS_MAP.IGNORE];
-    const ignorePaths = (0, Common_1.isString)(ignoreSetting) ? [ignoreSetting] : ignoreSetting;
+    const ignorePaths = (0, Shared_1.isString)(ignoreSetting) ? [ignoreSetting] : ignoreSetting;
     const includeSetting = validatedSettings[Settings_types_1.SETTINGS_KEYS_MAP.INCLUDE];
-    const includePaths = (0, Common_1.isString)(includeSetting)
+    const includePaths = (0, Shared_1.isString)(includeSetting)
         ? [includeSetting]
         : includeSetting;
+    const debugSetting = validatedSettings[Settings_types_1.SETTINGS_KEYS_MAP.DEBUG];
     const descriptors = (0, Settings_1.transformLegacyTypes)(validatedSettings[ELEMENTS]);
-    // NOTE: Filter valid descriptors only to avoid a breaking change for the moment
     const validDescriptors = descriptors.filter(elements_1.isElementDescriptor);
-    const invalidDescriptors = descriptors.filter((desc) => !(0, elements_1.isElementDescriptor)(desc));
-    if (invalidDescriptors.length > 0) {
-        /*
-         * TODO: Report invalid descriptors in ESLint context as a warning in a separate rule:
-         * context.report({
-         * message: `Some element descriptors are invalid and will be ignored: ${JSON.stringify(
-         *   invalidDescriptors,
-         * )}`,
-         * loc: { line: 1, column: 0 },
-         * });
-         */
-        (0, Debug_1.warnOnce)(`Some element descriptors are invalid and will be ignored: ${JSON.stringify(invalidDescriptors)}`);
+    if (validDescriptors.length < descriptors.length) {
+        const invalidDescriptors = descriptors.filter((desc) => !(0, elements_1.isElementDescriptor)(desc));
+        (0, Debug_1.warnOnce)(`Some element descriptors are invalid and will be ignored.`, `Invalid descriptors:\n${JSON.stringify(invalidDescriptors)}.\n${(0, Helpers_1.moreInfoSettingsLink)()}`);
     }
     const result = {
         elementDescriptors: validDescriptors,
@@ -361,21 +977,18 @@ function getSettings(context) {
         legacyTemplates: validatedSettings[Settings_types_1.SETTINGS_KEYS_MAP.LEGACY_TEMPLATES] ??
             Settings_types_1.LEGACY_TEMPLATES_DEFAULT,
         cache: validatedSettings[Settings_types_1.SETTINGS_KEYS_MAP.CACHE] ?? Settings_types_1.CACHE_DEFAULT,
+        flagAsExternal: {
+            unresolvableAlias: validatedSettings[Settings_types_1.SETTINGS_KEYS_MAP.FLAG_AS_EXTERNAL]
+                ?.unresolvableAlias ?? true,
+            inNodeModules: validatedSettings[Settings_types_1.SETTINGS_KEYS_MAP.FLAG_AS_EXTERNAL]?.inNodeModules ??
+                true,
+            outsideRootPath: validatedSettings[Settings_types_1.SETTINGS_KEYS_MAP.FLAG_AS_EXTERNAL]
+                ?.outsideRootPath ?? false,
+            customSourcePatterns: validatedSettings[Settings_types_1.SETTINGS_KEYS_MAP.FLAG_AS_EXTERNAL]
+                ?.customSourcePatterns ?? [],
+        },
+        debug: debugSetting,
     };
+    trackedValidatedSettings.set(context.settings, result);
     return result;
 }
-function validateRules(settings, rules = [], options = {}) {
-    const mainKey = (0, Helpers_1.rulesMainKey)(options.mainKey);
-    for (const rule of rules) {
-        //@ts-expect-error TODO: Add a different schema validation for each rule type, so keys are properly validated
-        validateElementTypesMatcher([rule[mainKey]], settings);
-        if (!options.onlyMainKey) {
-            if (rule.allow) {
-                validateElementTypesMatcher(rule.allow, settings);
-            }
-            if (rule.disallow) {
-                validateElementTypesMatcher(rule.disallow, settings);
-            }
-        }
-    }
-}