@depup/angular-eslint__eslint-plugin 21.3.1-depup.0

package/dist/rules/component-class-suffix.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_DOCS_EXTENSION = exports.RULE_NAME = void 0;
+const utils_1 = require("@angular-eslint/utils");
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+exports.RULE_NAME = 'component-class-suffix';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: `Classes decorated with @Component must have suffix "Component" (or custom) in their name. Note: As of v20, this is no longer recommended by the Angular Team.`,
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    suffixes: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            componentClassSuffix: `Component class names should end with one of these suffixes: {{suffixes}}`,
+        },
+    },
+    defaultOptions: [
+        {
+            suffixes: ['Component'],
+        },
+    ],
+    create(context, [{ suffixes }]) {
+        return {
+            [utils_1.Selectors.COMPONENT_CLASS_DECORATOR](node) {
+                const classParent = node.parent;
+                const className = utils_1.ASTUtils.getClassName(classParent);
+                if (!className ||
+                    !suffixes.some((suffix) => className.endsWith(suffix))) {
+                    context.report({
+                        node: classParent.id ? classParent.id : classParent,
+                        messageId: 'componentClassSuffix',
+                        data: { suffixes: (0, utils_1.toHumanReadableText)(suffixes) },
+                    });
+                }
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: "Historically, appending 'Component' to component class names was recommended to make component files easily identifiable. However, as of Angular v20, the Angular Team no longer recommends this convention, favoring simpler class names. This rule remains available for teams that have established this naming pattern and wish to maintain consistency in their existing codebase.",
+};

package/dist/rules/component-max-inline-declarations.d.ts

@@ -0,0 +1,17 @@
+export type Options = [
+    {
+        readonly template?: number;
+        readonly styles?: number;
+        readonly animations?: number;
+    }
+];
+export type MessageIds = 'componentMaxInlineDeclarations';
+export declare const RULE_NAME = "component-max-inline-declarations";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"componentMaxInlineDeclarations", Options, import("../utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;
+export declare const RULE_DOCS_EXTENSION: {
+    rationale: string;
+};
+//# sourceMappingURL=component-max-inline-declarations.d.ts.map

package/dist/rules/component-max-inline-declarations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-max-inline-declarations.d.ts","sourceRoot":"","sources":["../../src/rules/component-max-inline-declarations.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAC3B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QACzB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;KAC9B;CACF,CAAC;AACF,MAAM,MAAM,UAAU,GAAG,gCAAgC,CAAC;AAC1D,eAAO,MAAM,SAAS,sCAAsC,CAAC;;;;AAkB7D,wBA4GG;AAEH,eAAO,MAAM,mBAAmB;;CAE/B,CAAC"}

package/dist/rules/component-max-inline-declarations.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_DOCS_EXTENSION = exports.RULE_NAME = void 0;
+const utils_1 = require("@angular-eslint/utils");
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+exports.RULE_NAME = 'component-max-inline-declarations';
+const NEW_LINE_REGEXP = /\r\n|\r|\n/;
+const DEFAULT_TEMPLATE_LIMIT = 3;
+const DEFAULT_STYLES_LIMIT = 3;
+const DEFAULT_ANIMATIONS_LIMIT = 15;
+function getLinesCount(node) {
+    if (utils_1.ASTUtils.isTemplateLiteral(node)) {
+        return node.quasis[0].value.raw.trim().split(NEW_LINE_REGEXP).length;
+    }
+    if (utils_1.ASTUtils.isLiteral(node)) {
+        return node.raw.trim().split(NEW_LINE_REGEXP).length;
+    }
+    return 0;
+}
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: `Enforces a maximum number of lines in inline template, styles and animations.`,
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    template: { minimum: 0, type: 'number' },
+                    styles: { minimum: 0, type: 'number' },
+                    animations: { minimum: 0, type: 'number' },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            componentMaxInlineDeclarations: `\`{{propertyType}}\` has too many lines ({{lineCount}}). Maximum allowed is {{max}}`,
+        },
+    },
+    defaultOptions: [
+        {
+            template: DEFAULT_TEMPLATE_LIMIT,
+            styles: DEFAULT_STYLES_LIMIT,
+            animations: DEFAULT_ANIMATIONS_LIMIT,
+        },
+    ],
+    create(context, [{ template = DEFAULT_TEMPLATE_LIMIT, styles = DEFAULT_STYLES_LIMIT, animations = DEFAULT_ANIMATIONS_LIMIT, },]) {
+        return {
+            [`${utils_1.Selectors.COMPONENT_CLASS_DECORATOR} Property[key.name='template']`]({ value, }) {
+                const lineCount = getLinesCount(value);
+                if (lineCount <= template)
+                    return;
+                context.report({
+                    node: value,
+                    messageId: 'componentMaxInlineDeclarations',
+                    data: {
+                        lineCount,
+                        max: template,
+                        propertyType: 'template',
+                    },
+                });
+            },
+            [`${utils_1.Selectors.COMPONENT_CLASS_DECORATOR} Property[key.name='styles']`]({ value, }) {
+                let lineCount;
+                if (!utils_1.ASTUtils.isArrayExpression(value)) {
+                    lineCount = getLinesCount(value);
+                }
+                else {
+                    lineCount = value.elements.reduce((lines, element) => lines + (element ? getLinesCount(element) : 0), 0);
+                }
+                if (lineCount <= styles)
+                    return;
+                context.report({
+                    node: value,
+                    messageId: 'componentMaxInlineDeclarations',
+                    data: {
+                        lineCount,
+                        max: styles,
+                        propertyType: 'styles',
+                    },
+                });
+            },
+            [`${utils_1.Selectors.COMPONENT_CLASS_DECORATOR} Property[key.name='animations']`]({ value, }) {
+                if (!utils_1.ASTUtils.isArrayExpression(value) || value.elements.length === 0)
+                    return;
+                const animationsBracketsSize = 2;
+                const lineCount = Math.max(value.loc.end.line - value.loc.start.line - animationsBracketsSize, 1);
+                if (lineCount <= animations)
+                    return;
+                context.report({
+                    node: value,
+                    messageId: 'componentMaxInlineDeclarations',
+                    data: {
+                        lineCount,
+                        max: animations,
+                        propertyType: 'animations',
+                    },
+                });
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: `When templates or styles exceed a few lines, keeping them inline makes components harder to read and maintain. Inline templates and styles cannot be syntax-highlighted as effectively as separate files, complicate code reviews, and make it difficult to quickly understand a component's structure. Moving larger templates and styles to separate files improves readability, enables better IDE support, and follows the separation of concerns principle.`,
+};

package/dist/rules/component-selector.d.ts

@@ -0,0 +1,14 @@
+import { SelectorUtils } from '@angular-eslint/utils';
+export type Options = readonly [
+    SelectorUtils.SingleConfigOption | SelectorUtils.MultipleConfigOption
+];
+export type MessageIds = 'prefixFailure' | 'styleFailure' | 'styleAndPrefixFailure' | 'typeFailure' | 'shadowDomEncapsulatedStyleFailure' | 'selectorAfterPrefixFailure';
+export declare const RULE_NAME = "component-selector";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, Options, import("../utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;
+export declare const RULE_DOCS_EXTENSION: {
+    rationale: string;
+};
+//# sourceMappingURL=component-selector.d.ts.map

package/dist/rules/component-selector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-selector.d.ts","sourceRoot":"","sources":["../../src/rules/component-selector.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,aAAa,EACd,MAAM,uBAAuB,CAAC;AAK/B,MAAM,MAAM,OAAO,GAAG,SAAS;IAC7B,aAAa,CAAC,kBAAkB,GAAG,aAAa,CAAC,oBAAoB;CACtE,CAAC;AACF,MAAM,MAAM,UAAU,GAClB,eAAe,GACf,cAAc,GACd,uBAAuB,GACvB,aAAa,GACb,mCAAmC,GACnC,4BAA4B,CAAC;AACjC,eAAO,MAAM,SAAS,uBAAuB,CAAC;;;;AAS9C,wBAgOG;AAiBH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

package/dist/rules/component-selector.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_DOCS_EXTENSION = exports.RULE_NAME = void 0;
+const utils_1 = require("@angular-eslint/utils");
+const utils_2 = require("@typescript-eslint/utils");
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+exports.RULE_NAME = 'component-selector';
+const VIEW_ENCAPSULATION_SHADOW_DOM = 'ShadowDom';
+const VIEW_ENCAPSULATION = 'ViewEncapsulation';
+const STYLE_GUIDE_LINK = 'https://angular.dev/style-guide#choosing-component-selectors';
+const SHADOW_DOM_ENCAPSULATED_STYLE_LINK = 'https://github.com/angular-eslint/angular-eslint/issues/534';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: `Component selectors should follow given naming rules. See more at ${STYLE_GUIDE_LINK}.`,
+        },
+        schema: [
+            {
+                oneOf: [
+                    // Single config object
+                    {
+                        type: 'object',
+                        properties: {
+                            type: {
+                                oneOf: [
+                                    { type: 'string' },
+                                    {
+                                        type: 'array',
+                                        items: {
+                                            type: 'string',
+                                            enum: [
+                                                utils_1.SelectorUtils.OPTION_TYPE_ELEMENT,
+                                                utils_1.SelectorUtils.OPTION_TYPE_ATTRIBUTE,
+                                            ],
+                                        },
+                                    },
+                                ],
+                            },
+                            prefix: {
+                                oneOf: [{ type: 'string' }, { type: 'array' }],
+                            },
+                            style: {
+                                type: 'string',
+                                enum: [
+                                    utils_1.ASTUtils.OPTION_STYLE_CAMEL_CASE,
+                                    utils_1.ASTUtils.OPTION_STYLE_KEBAB_CASE,
+                                ],
+                            },
+                        },
+                        required: ['type', 'style'],
+                        additionalProperties: false,
+                    },
+                    // Array of 1-2 config objects
+                    {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                type: {
+                                    type: 'string',
+                                    enum: [
+                                        utils_1.SelectorUtils.OPTION_TYPE_ELEMENT,
+                                        utils_1.SelectorUtils.OPTION_TYPE_ATTRIBUTE,
+                                    ],
+                                },
+                                prefix: {
+                                    oneOf: [{ type: 'string' }, { type: 'array' }],
+                                },
+                                style: {
+                                    type: 'string',
+                                    enum: [
+                                        utils_1.ASTUtils.OPTION_STYLE_CAMEL_CASE,
+                                        utils_1.ASTUtils.OPTION_STYLE_KEBAB_CASE,
+                                    ],
+                                },
+                            },
+                            additionalProperties: false,
+                            required: ['type', 'style'],
+                        },
+                        minItems: 1,
+                        maxItems: 2,
+                    },
+                ],
+            },
+        ],
+        messages: {
+            prefixFailure: `The selector should start with one of these prefixes: {{prefix}} (${STYLE_GUIDE_LINK})`,
+            styleFailure: `The selector should be {{style}} (${STYLE_GUIDE_LINK})`,
+            styleAndPrefixFailure: `The selector should be {{style}} and start with one of these prefixes: {{prefix}} (${STYLE_GUIDE_LINK} and ${STYLE_GUIDE_LINK})`,
+            typeFailure: `The selector should be used as an {{type}} (${STYLE_GUIDE_LINK})`,
+            shadowDomEncapsulatedStyleFailure: `The selector of a ShadowDom-encapsulated component should be \`${utils_1.ASTUtils.OPTION_STYLE_KEBAB_CASE}\` (${SHADOW_DOM_ENCAPSULATED_STYLE_LINK})`,
+            selectorAfterPrefixFailure: `There should be a selector after the {{prefix}} prefix`,
+        },
+    },
+    defaultOptions: [
+        {
+            type: undefined,
+            prefix: 'app', // Match default Angular CLI prefix
+            style: undefined,
+        },
+    ],
+    create(context, [options]) {
+        // Options are required by schema, so if undefined, ESLint will throw an error
+        if (!options) {
+            return {};
+        }
+        // Normalize options to a consistent format using shared utility
+        const configByType = utils_1.SelectorUtils.normalizeOptionsToConfigs(options);
+        return {
+            [utils_1.Selectors.COMPONENT_CLASS_DECORATOR](node) {
+                const rawSelectors = utils_1.ASTUtils.getDecoratorPropertyValue(node, 'selector');
+                if (!rawSelectors) {
+                    return;
+                }
+                // Parse selectors once for reuse
+                const parsedSelectors = utils_1.SelectorUtils.parseSelectorNode(rawSelectors);
+                if (!parsedSelectors || parsedSelectors.length === 0) {
+                    return;
+                }
+                const applicableConfig = utils_1.SelectorUtils.getApplicableConfig(rawSelectors, configByType);
+                if (!applicableConfig) {
+                    return;
+                }
+                const { type, prefix, style } = applicableConfig;
+                const isValidOptions = utils_1.SelectorUtils.checkValidOptions(type, prefix, style);
+                if (!isValidOptions) {
+                    return;
+                }
+                // Override `style` for ShadowDom-encapsulated components. See https://github.com/angular-eslint/angular-eslint/issues/534.
+                const overrideStyle = style !== utils_1.ASTUtils.OPTION_STYLE_KEBAB_CASE &&
+                    hasEncapsulationShadowDomProperty(node)
+                    ? utils_1.ASTUtils.OPTION_STYLE_KEBAB_CASE
+                    : style;
+                const hasExpectedSelector = utils_1.SelectorUtils.checkSelector(rawSelectors, type, prefix, overrideStyle, parsedSelectors);
+                if (hasExpectedSelector === null) {
+                    return;
+                }
+                // Special check for ShadowDom-encapsulated components
+                // They must have a hyphen in the selector (e.g., 'app-selector' not 'appSelector')
+                const isShadowDom = style !== overrideStyle;
+                if (isShadowDom) {
+                    // For ShadowDom components, check if any selector contains a hyphen
+                    // We need to check the raw selector values from parsedSelectors
+                    const hasHyphen = parsedSelectors.some((selector) => {
+                        // Check if the element selector contains a hyphen
+                        return selector.element && selector.element.includes('-');
+                    });
+                    if (!hasHyphen) {
+                        context.report({
+                            node: rawSelectors,
+                            messageId: 'shadowDomEncapsulatedStyleFailure',
+                        });
+                        return;
+                    }
+                }
+                // Component-specific validation logic (includes styleAndPrefixFailure)
+                if (!hasExpectedSelector.hasExpectedType) {
+                    utils_1.SelectorUtils.reportTypeError(rawSelectors, type, context);
+                }
+                else if (!hasExpectedSelector.hasSelectorAfterPrefix) {
+                    // Only report selector after prefix error if prefix is actually required
+                    if (prefix !== undefined) {
+                        const prefixArray = (0, utils_1.arrayify)(prefix);
+                        if (prefixArray.length > 0) {
+                            utils_1.SelectorUtils.reportSelectorAfterPrefixError(rawSelectors, prefix, context);
+                        }
+                    }
+                }
+                else if (!hasExpectedSelector.hasExpectedStyle) {
+                    if (style === overrideStyle) {
+                        if (!hasExpectedSelector.hasExpectedPrefix) {
+                            if (prefix !== undefined) {
+                                // Only report style and prefix error if prefix is actually required
+                                utils_1.SelectorUtils.reportStyleAndPrefixError(rawSelectors, style, prefix, context);
+                            }
+                            else {
+                                // If no prefix required, just report style error
+                                utils_1.SelectorUtils.reportStyleError(rawSelectors, style, context);
+                            }
+                        }
+                        else {
+                            utils_1.SelectorUtils.reportStyleError(rawSelectors, style, context);
+                        }
+                    }
+                    else {
+                        context.report({
+                            node: rawSelectors,
+                            messageId: 'shadowDomEncapsulatedStyleFailure',
+                        });
+                    }
+                }
+                else if (!hasExpectedSelector.hasExpectedPrefix) {
+                    // Only report prefix error if prefix is actually required (not empty)
+                    if (prefix !== undefined) {
+                        const prefixArray = (0, utils_1.arrayify)(prefix);
+                        if (prefixArray.length > 0) {
+                            utils_1.SelectorUtils.reportPrefixError(rawSelectors, prefix, context);
+                        }
+                    }
+                }
+            },
+        };
+    },
+});
+function hasEncapsulationShadowDomProperty(node) {
+    const encapsulationValue = utils_1.ASTUtils.getDecoratorPropertyValue(node, 'encapsulation');
+    return (encapsulationValue &&
+        utils_1.ASTUtils.isMemberExpression(encapsulationValue) &&
+        utils_2.ASTUtils.isIdentifier(encapsulationValue.object) &&
+        encapsulationValue.object.name === VIEW_ENCAPSULATION &&
+        utils_2.ASTUtils.isIdentifier(encapsulationValue.property) &&
+        encapsulationValue.property.name === VIEW_ENCAPSULATION_SHADOW_DOM);
+}
+exports.RULE_DOCS_EXTENSION = {
+    rationale: "Consistent component selector naming conventions provide several benefits: they make components easily identifiable in templates and browser DevTools, prevent naming collisions with native HTML elements and third-party components, enable teams to quickly identify which library or feature area a component belongs to, and align with the Web Components specification for custom elements. For example, prefixing selectors with 'app-' (like 'app-user-profile') clearly distinguishes your application components from third-party libraries.",
+};

package/dist/rules/computed-must-return.d.ts

@@ -0,0 +1,11 @@
+export type Options = [];
+export type MessageIds = 'computedMissingReturn';
+export declare const RULE_NAME = "computed-must-return";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"computedMissingReturn", [], import("../utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;
+export declare const RULE_DOCS_EXTENSION: {
+    rationale: string;
+};
+//# sourceMappingURL=computed-must-return.d.ts.map

package/dist/rules/computed-must-return.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computed-must-return.d.ts","sourceRoot":"","sources":["../../src/rules/computed-must-return.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,uBAAuB,CAAC;AACjD,eAAO,MAAM,SAAS,yBAAyB,CAAC;;;;AAEhD,wBAqEG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

package/dist/rules/computed-must-return.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_DOCS_EXTENSION = exports.RULE_NAME = void 0;
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+const utils_1 = require("@typescript-eslint/utils");
+exports.RULE_NAME = 'computed-must-return';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'problem',
+        docs: {
+            description: `Ensures that computed() returns a value. Omitting the value is likely a mistake.`,
+        },
+        schema: [],
+        messages: {
+            computedMissingReturn: 'computed() is missing a return value',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const functionStack = [];
+        function enterFunction(node) {
+            functionStack.push({
+                node,
+                hasReturn: false,
+            });
+        }
+        function exitFunction(node) {
+            const funcInfo = functionStack.pop();
+            if (node.parent?.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                node.parent.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                node.parent.callee.name === 'computed' &&
+                node.parent.arguments[0] === node) {
+                // Arrow function without a body
+                if (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+                    node.expression) {
+                    return;
+                }
+                if (!funcInfo?.hasReturn) {
+                    context.report({
+                        node: node.parent,
+                        messageId: 'computedMissingReturn',
+                    });
+                }
+            }
+        }
+        return {
+            ArrowFunctionExpression: enterFunction,
+            'ArrowFunctionExpression:exit': exitFunction,
+            FunctionExpression: enterFunction,
+            'FunctionExpression:exit': exitFunction,
+            ReturnStatement(node) {
+                if (node.argument && functionStack.length > 0) {
+                    functionStack[functionStack.length - 1].hasReturn = true;
+                }
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: "`computed()` is used to transform signal values. If no value is returned from `computed()`, it's likely a mistake.",
+};

package/dist/rules/consistent-component-styles.d.ts

@@ -0,0 +1,12 @@
+type Mode = 'array' | 'string';
+export type Options = [mode: Mode];
+export type MessageIds = 'useStylesArray' | 'useStylesString' | 'useStyleUrl' | 'useStyleUrls';
+export declare const RULE_NAME = "consistent-component-styles";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, Options, import("../utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;
+export declare const RULE_DOCS_EXTENSION: {
+    rationale: string;
+};
+//# sourceMappingURL=consistent-component-styles.d.ts.map

package/dist/rules/consistent-component-styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consistent-component-styles.d.ts","sourceRoot":"","sources":["../../src/rules/consistent-component-styles.ts"],"names":[],"mappings":"AAIA,KAAK,IAAI,GAAG,OAAO,GAAG,QAAQ,CAAC;AAC/B,MAAM,MAAM,OAAO,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;AACnC,MAAM,MAAM,UAAU,GAClB,gBAAgB,GAChB,iBAAiB,GACjB,aAAa,GACb,cAAc,CAAC;AACnB,eAAO,MAAM,SAAS,gCAAgC,CAAC;;;;AAEvD,wBAsHG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

package/dist/rules/consistent-component-styles.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_DOCS_EXTENSION = exports.RULE_NAME = void 0;
+const utils_1 = require("@angular-eslint/utils");
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+exports.RULE_NAME = 'consistent-component-styles';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Ensures consistent usage of `styles`/`styleUrls`/`styleUrl` within Component metadata',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'string',
+                enum: ['array', 'string'],
+            },
+        ],
+        messages: {
+            useStyleUrl: 'Use `styleUrl` instead of `styleUrls` for a single stylesheet',
+            useStyleUrls: 'Use `styleUrls` instead of `styleUrl`',
+            useStylesArray: 'Use a `string[]` instead of a `string` for the `styles` property',
+            useStylesString: 'Use a `string` instead of a `string[]` for the `styles` property',
+        },
+    },
+    defaultOptions: ['string'],
+    create(context, [mode]) {
+        const { COMPONENT_CLASS_DECORATOR, metadataProperty } = utils_1.Selectors;
+        const LITERAL_OR_TEMPLATE_LITERAL = ':matches(Literal, TemplateLiteral)';
+        if (mode === 'array') {
+            const stylesStringExpression = `${COMPONENT_CLASS_DECORATOR} ${metadataProperty('styles')} > ${LITERAL_OR_TEMPLATE_LITERAL}`;
+            const styleUrlProperty = `${COMPONENT_CLASS_DECORATOR} ${metadataProperty('styleUrl')}:has(:matches(Literal, TemplateElement))`;
+            return {
+                [stylesStringExpression](node) {
+                    context.report({
+                        node,
+                        messageId: 'useStylesArray',
+                        fix: (fixer) => {
+                            return fixer.replaceText(node, utils_1.ASTUtils.isStringLiteral(node)
+                                ? `[${node.raw}]`
+                                : `[${context.sourceCode.getText(node)}]`);
+                        },
+                    });
+                },
+                [styleUrlProperty](node) {
+                    context.report({
+                        node,
+                        messageId: 'useStyleUrls',
+                        fix: (fixer) => {
+                            return fixer.replaceText(node, utils_1.ASTUtils.isStringLiteral(node.value)
+                                ? `styleUrls: [${node.value.raw}]`
+                                : `styleUrls: [${context.sourceCode.getText(node.value)}]`);
+                        },
+                    });
+                },
+            };
+        }
+        else {
+            const singleArrayStringLiteral = `ArrayExpression:matches([elements.length=1]:has(${LITERAL_OR_TEMPLATE_LITERAL}))`;
+            const singleStylesArrayExpression = `${COMPONENT_CLASS_DECORATOR} ${metadataProperty('styles')} > ${singleArrayStringLiteral}`;
+            const singleStyleUrlsProperty = `${COMPONENT_CLASS_DECORATOR} ${metadataProperty('styleUrls')}:has(${singleArrayStringLiteral})`;
+            return {
+                [singleStylesArrayExpression](node) {
+                    // The selector ensures the element is not null.
+                    const el = node.elements[0];
+                    context.report({
+                        node,
+                        messageId: 'useStylesString',
+                        fix: (fixer) => {
+                            return fixer.replaceText(node, utils_1.ASTUtils.isStringLiteral(el)
+                                ? el.raw
+                                : context.sourceCode.getText(el));
+                        },
+                    });
+                },
+                [singleStyleUrlsProperty](node) {
+                    // The selector ensures the value is an array with a single non-null element.
+                    const el = node.value.elements[0];
+                    context.report({
+                        node,
+                        messageId: 'useStyleUrl',
+                        fix: (fixer) => {
+                            return fixer.replaceText(node, utils_1.ASTUtils.isStringLiteral(el)
+                                ? `styleUrl: ${el.raw}`
+                                : `styleUrl: ${context.sourceCode.getText(el)}`);
+                        },
+                    });
+                },
+            };
+        }
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: "Consistency in how styles are declared makes codebases easier to navigate and maintain. When some components use styleUrl while others use styleUrls, or when styles are sometimes arrays and sometimes strings, it becomes harder for developers to predict what they'll find when opening a component. This rule enforces a consistent pattern across your codebase. Angular 17+ introduced the singular styleUrl property alongside the existing styleUrls array for common cases where components have only one stylesheet. Choosing one approach and sticking with it reduces cognitive load and makes the codebase feel more cohesive.",
+};

package/dist/rules/contextual-decorator.d.ts

@@ -0,0 +1,12 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+export type Options = [];
+export type MessageIds = 'contextualDecorator';
+export declare const RULE_NAME = "contextual-decorator";
+declare const _default: TSESLint.RuleModule<"contextualDecorator", [], import("../utils/create-eslint-rule").RuleDocs, TSESLint.RuleListener> & {
+    name: string;
+};
+export default _default;
+export declare const RULE_DOCS_EXTENSION: {
+    rationale: string;
+};
+//# sourceMappingURL=contextual-decorator.d.ts.map

package/dist/rules/contextual-decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contextual-decorator.d.ts","sourceRoot":"","sources":["../../src/rules/contextual-decorator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAGnE,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,qBAAqB,CAAC;AAC/C,eAAO,MAAM,SAAS,yBAAyB,CAAC;;;;AAEhD,wBA2BG;AA2DH,eAAO,MAAM,mBAAmB;;CAE/B,CAAC"}