@angular-eslint/eslint-plugin 16.1.0-alpha.0 → 16.1.1-alpha.0

package/dist/configs/all.json

@@ -27,8 +27,8 @@
     "@angular-eslint/pipe-prefix": "error",
     "@angular-eslint/prefer-on-push-component-change-detection": "error",
     "@angular-eslint/prefer-output-readonly": "error",
+    "@angular-eslint/prefer-standalone-component": "error",
     "@angular-eslint/relative-url-prefix": "error",
-    "@angular-eslint/sort-imports-metadata": "error",
     "@angular-eslint/sort-ngmodule-metadata-arrays": "error",
     "@angular-eslint/use-component-selector": "error",
     "@angular-eslint/use-component-view-encapsulation": "error",

package/dist/index.js

@@ -51,9 +51,9 @@ const no_pipe_impure_1 = __importStar(require("./rules/no-pipe-impure"));
 const no_queries_metadata_property_1 = __importStar(require("./rules/no-queries-metadata-property"));
 const pipe_prefix_1 = __importStar(require("./rules/pipe-prefix"));
 const prefer_on_push_component_change_detection_1 = __importStar(require("./rules/prefer-on-push-component-change-detection"));
+const prefer_standalone_component_1 = __importStar(require("./rules/prefer-standalone-component"));
 const prefer_output_readonly_1 = __importStar(require("./rules/prefer-output-readonly"));
 const relative_url_prefix_1 = __importStar(require("./rules/relative-url-prefix"));
-const sort_imports_metadata_1 = __importStar(require("./rules/sort-imports-metadata"));
 const sort_ngmodule_metadata_arrays_1 = __importStar(require("./rules/sort-ngmodule-metadata-arrays"));
 const use_component_selector_1 = __importStar(require("./rules/use-component-selector"));
 const use_component_view_encapsulation_1 = __importStar(require("./rules/use-component-view-encapsulation"));
@@ -90,9 +90,9 @@ module.exports = {
         [no_queries_metadata_property_1.RULE_NAME]: no_queries_metadata_property_1.default,
         [pipe_prefix_1.RULE_NAME]: pipe_prefix_1.default,
         [prefer_on_push_component_change_detection_1.RULE_NAME]: prefer_on_push_component_change_detection_1.default,
+        [prefer_standalone_component_1.RULE_NAME]: prefer_standalone_component_1.default,
         [prefer_output_readonly_1.RULE_NAME]: prefer_output_readonly_1.default,
         [relative_url_prefix_1.RULE_NAME]: relative_url_prefix_1.default,
-        [sort_imports_metadata_1.RULE_NAME]: sort_imports_metadata_1.default,
         [sort_ngmodule_metadata_arrays_1.RULE_NAME]: sort_ngmodule_metadata_arrays_1.default,
         [use_component_selector_1.RULE_NAME]: use_component_selector_1.default,
         [use_component_view_encapsulation_1.RULE_NAME]: use_component_view_encapsulation_1.default,

package/dist/rules/prefer-standalone-component.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 = 'prefer-standalone-component';
+const METADATA_PROPERTY_NAME = 'standalone';
+const IS_STANDALONE = 'true';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: `Ensures component \`${METADATA_PROPERTY_NAME}\` property is set to \`${IS_STANDALONE}\` in the component decorator`,
+            recommended: false,
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            preferStandaloneComponent: `The component \`${METADATA_PROPERTY_NAME}\` property should be set to \`${IS_STANDALONE}\``,
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            [utils_1.Selectors.COMPONENT_CLASS_DECORATOR](node) {
+                const standalone = utils_1.ASTUtils.getDecoratorPropertyValue(node, METADATA_PROPERTY_NAME);
+                if (standalone &&
+                    utils_1.ASTUtils.isLiteral(standalone) &&
+                    standalone.value === true) {
+                    return;
+                }
+                context.report({
+                    node: nodeToReport(node),
+                    messageId: 'preferStandaloneComponent',
+                    fix: (fixer) => {
+                        if (standalone &&
+                            utils_1.ASTUtils.isLiteral(standalone) &&
+                            standalone.value !== true) {
+                            return [fixer.replaceText(standalone, IS_STANDALONE)].filter(utils_1.isNotNullOrUndefined);
+                        }
+                        return [
+                            utils_1.RuleFixes.getDecoratorPropertyAddFix(node, fixer, `${METADATA_PROPERTY_NAME}: ${IS_STANDALONE}`),
+                        ].filter(utils_1.isNotNullOrUndefined);
+                    },
+                });
+            },
+        };
+    },
+});
+function nodeToReport(node) {
+    if (!utils_1.ASTUtils.isProperty(node)) {
+        return node;
+    }
+    return utils_1.ASTUtils.isMemberExpression(node.value)
+        ? node.value.property
+        : node.value;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-eslint/eslint-plugin",
-  "version": "16.1.0-alpha.0",
+  "version": "16.1.1-alpha.0+dce6381",
   "description": "ESLint plugin for Angular applications, following angular.io/styleguide",
   "license": "MIT",
   "main": "dist/index.js",
@@ -17,12 +17,12 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@angular-eslint/utils": "16.1.0-alpha.0",
-    "@typescript-eslint/utils": "5.59.7"
+    "@angular-eslint/utils": "16.1.1-alpha.0+dce6381",
+    "@typescript-eslint/utils": "5.62.0"
   },
   "peerDependencies": {
     "eslint": "^7.20.0 || ^8.0.0",
     "typescript": "*"
   },
-  "gitHead": "255cd39008e9e9a608704f8b62a08c9dc45f8e53"
+  "gitHead": "dce6381cafcbe2de109d0a53b4c9c3e3bf1ae569"
 }

package/dist/rules/sort-imports-metadata.js

@@ -1,156 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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 = 'sort-imports-metadata';
-const DEFAULT_LOCALE = 'en-US';
-exports.default = (0, create_eslint_rule_1.createESLintRule)({
-    name: exports.RULE_NAME,
-    meta: {
-        type: 'suggestion',
-        docs: {
-            description: 'Ensures ASC alphabetical order for import arrays for easy visual scanning',
-            recommended: false,
-        },
-        fixable: 'code',
-        schema: [
-            {
-                type: 'object',
-                properties: {
-                    locale: {
-                        type: 'string',
-                        description: 'A string with a BCP 47 language tag.',
-                        default: DEFAULT_LOCALE,
-                    },
-                },
-                additionalProperties: false,
-            },
-        ],
-        messages: {
-            sortImportsMetadata: 'Imports should be sorted in ASC alphabetical order',
-        },
-    },
-    defaultOptions: [
-        {
-            locale: DEFAULT_LOCALE,
-        },
-    ],
-    create(context, [{ locale }]) {
-        const selectors = [
-            `${utils_1.Selectors.COMPONENT_OR_DIRECTIVE_CLASS_DECORATOR} Property[key.name="imports"] > ArrayExpression`,
-            `${utils_1.Selectors.MODULE_CLASS_DECORATOR} Property[key.name="imports"] > ArrayExpression`,
-            `${utils_1.Selectors.PIPE_CLASS_DECORATOR} Property[key.name="imports"] > ArrayExpression`,
-        ].join(',');
-        return {
-            [selectors]({ elements }) {
-                var _a, _b;
-                const imports = elements.filter(utils_2.ASTUtils.isIdentifier);
-                if (importsAreSorted(imports, locale)) {
-                    return;
-                }
-                const firstOriginalElement = elements[0];
-                const lastOriginalElement = elements[elements.length - 1];
-                const nodeForFixer = firstOriginalElement.parent;
-                // IMPORTANT NOTE: Although we want to delegate formatting to the user's formatter of choice, this rule will perform basic formatting to ensure some presentability (especially around block comments)
-                // If all of the imports are on one line, indent the output 2 columns ahead of the `imports` keyword
-                // Else, indent the output to match the indentation of the first import
-                const whitespacePrefix = elements.every((element) => (element === null || element === void 0 ? void 0 : element.loc.start.line) === firstOriginalElement.loc.start.line)
-                    ? ' '.repeat(((_a = nodeForFixer.parent) === null || _a === void 0 ? void 0 : _a.loc.start.column) + 2)
-                    : ' '.repeat(firstOriginalElement.loc.start.column);
-                // For each import entry, get all related comments, stringify them, and group them with the import entry
-                const importEntriesWithComments = getImportEntriesWithComments(imports, context, whitespacePrefix);
-                // Sort the imports
-                importEntriesWithComments.sort((importA, importB) => importA.importName.localeCompare(importB.importName, locale));
-                const sortedImportsWithCommentsString = `[\n${getSortedImportsWithCommentsAsString(importEntriesWithComments, whitespacePrefix)}${' '.repeat((_b = nodeForFixer.parent) === null || _b === void 0 ? void 0 : _b.loc.start.column)}]`;
-                context.report({
-                    messageId: 'sortImportsMetadata',
-                    loc: {
-                        start: firstOriginalElement.loc.start,
-                        end: lastOriginalElement.loc.end,
-                    },
-                    fix: (fixer) => fixer.replaceText(nodeForFixer, sortedImportsWithCommentsString),
-                });
-            },
-        };
-    },
-});
-function getImportEntriesWithComments(imports, context, whitespacePrefix) {
-    const sourceCode = context.getSourceCode();
-    const importEntriesWithComments = [];
-    for (let i = 0; i < imports.length; i++) {
-        const importEntry = imports[i];
-        // Handle comments above the import entry
-        let commentsBeforeImport = sourceCode.getCommentsBefore(importEntry);
-        const previousImportEntry = imports[i - 1];
-        if (previousImportEntry) {
-            commentsBeforeImport = commentsBeforeImport.filter((comment) => comment.loc.start.line !== previousImportEntry.loc.start.line);
-        }
-        const commentsBeforeString = getCommentsAsString(commentsBeforeImport, whitespacePrefix);
-        // Handle comments on the same line as the import entry
-        // Same-line comments appear in the next import entry's `getCommentsBefore`
-        let commentsSameLineString = '';
-        const nextImportEntry = imports[i + 1];
-        if (nextImportEntry) {
-            commentsSameLineString = getCommentsAsString(sourceCode
-                .getCommentsBefore(nextImportEntry)
-                .filter((comment) => comment.loc.start.line === importEntry.loc.start.line));
-        }
-        // Handle comments after the import entry
-        const commentsAfterString = getCommentsAsString(sourceCode.getCommentsAfter(importEntry), whitespacePrefix);
-        const importEntryWithComments = {
-            commentsBefore: commentsBeforeString,
-            commentsSameLine: commentsSameLineString,
-            commentsAfter: commentsAfterString,
-            importName: importEntry.name,
-        };
-        importEntriesWithComments.push(importEntryWithComments);
-    }
-    return importEntriesWithComments;
-}
-function getSortedImportsWithCommentsAsString(sortedImportEntriesWithComments, whitespacePrefix) {
-    let sortedImportsWithCommentsString = '';
-    for (const importEntry of sortedImportEntriesWithComments) {
-        if (importEntry.commentsBefore) {
-            sortedImportsWithCommentsString += `${importEntry.commentsBefore}`;
-        }
-        sortedImportsWithCommentsString += `${whitespacePrefix}${importEntry.importName},`;
-        if (importEntry.commentsSameLine) {
-            sortedImportsWithCommentsString += ` ${importEntry.commentsSameLine}`;
-        }
-        else {
-            sortedImportsWithCommentsString += '\n';
-        }
-        if (importEntry.commentsAfter) {
-            sortedImportsWithCommentsString += `${importEntry.commentsAfter}`;
-        }
-    }
-    return sortedImportsWithCommentsString;
-}
-function getCommentsAsString(comments, whitespacePrefix) {
-    let commentsString = '';
-    if (comments) {
-        for (const comment of comments) {
-            if (comment.type === 'Line') {
-                commentsString += `${whitespacePrefix ? whitespacePrefix : ''}//${comment.value}\n`;
-            }
-            else if (comment.type === 'Block') {
-                commentsString += `${whitespacePrefix ? whitespacePrefix : ''}/*${comment.value}*/\n`;
-            }
-        }
-    }
-    return commentsString;
-}
-function importsAreSorted(imports, locale) {
-    const importNames = imports.map((importEntry) => importEntry.name);
-    let secondIndex;
-    for (let firstIndex = 0; firstIndex < importNames.length; firstIndex++) {
-        secondIndex = firstIndex + 1;
-        if (importNames[firstIndex].localeCompare(importNames[secondIndex], locale) >
-            0) {
-            return false;
-        }
-    }
-    return true;
-}