@ethlete/eslint-plugin 0.1.0-next.0 → 0.1.0-next.10

package/src/rules/angular-decorator-property-order.js

@@ -0,0 +1,205 @@
+// @ts-check
+'use strict';
+
+/** @typedef {'Component' | 'Directive'} TDecoratorName */
+/** @typedef {{ order: string[]; orderText: string }} TDecoratorConfig */
+/** @typedef {{ range: [number, number] }} TNodeWithRange */
+/** @typedef {import('estree').Property & TNodeWithRange} TPropertyNode */
+/** @typedef {import('estree').SpreadElement & TNodeWithRange} TSpreadElementNode */
+/** @typedef {import('estree').ObjectExpression & TNodeWithRange & { properties: Array<TPropertyNode | TSpreadElementNode> }} TObjectExpressionNode */
+/** @typedef {{ hasComma: boolean; originalIndex: number; orderIndex: number; property: TPropertyNode; segmentText: string }} TPropertyEntry */
+
+/** @type {Record<TDecoratorName, TDecoratorConfig>} */
+const DECORATOR_CONFIG = {
+  Component: {
+    order: [
+      'selector',
+      'template',
+      'styleUrl',
+      'encapsulation',
+      'changeDetection',
+      'imports',
+      'providers',
+      'viewProviders',
+      'animations',
+      'hostDirectives',
+      'host',
+      'styles',
+      'inputs',
+      'outputs',
+      'queries',
+      'preserveWhitespaces',
+      'schemas',
+      'jit',
+      'exportAs',
+    ],
+    orderText:
+      'selector, template/templateUrl, styleUrl/styleUrls, encapsulation, changeDetection, imports, providers, viewProviders, animations, hostDirectives, host, styles, inputs, outputs, queries, preserveWhitespaces, schemas, jit, exportAs',
+  },
+  Directive: {
+    order: ['selector', 'exportAs', 'providers', 'inputs', 'outputs', 'queries', 'hostDirectives', 'host', 'jit'],
+    orderText: 'selector, exportAs, providers, inputs, outputs, queries, hostDirectives, host, jit',
+  },
+};
+
+/**
+ * @param {import('estree').Property['key']} key
+ */
+const getPropertyName = (key) => {
+  if (key.type === 'Identifier') return key.name;
+  if (key.type === 'Literal' && typeof key.value === 'string') return key.value;
+  return null;
+};
+
+/**
+ * @param {TDecoratorName} decoratorName
+ * @param {string | null} propertyName
+ */
+const getOrderKey = (decoratorName, propertyName) => {
+  if (propertyName === null) return null;
+
+  if (decoratorName === 'Component') {
+    if (propertyName === 'template' || propertyName === 'templateUrl') return 'template';
+    if (propertyName === 'styleUrl' || propertyName === 'styleUrls') return 'styleUrl';
+  }
+
+  return propertyName;
+};
+
+/**
+ * @param {import('eslint').Rule.Node} node
+ * @returns {TDecoratorName | null}
+ */
+const getDecoratorName = (node) => {
+  const decorator = /** @type {any} */ (node);
+  if (decorator.type !== 'Decorator') return null;
+
+  const expression = decorator.expression;
+  if (expression.type === 'CallExpression') {
+    return expression.callee.type === 'Identifier' ? expression.callee.name : null;
+  }
+
+  return expression.type === 'Identifier' ? expression.name : null;
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const angularDecoratorPropertyOrder = {
+  meta: {
+    type: 'layout',
+    docs: {
+      description: 'Require a consistent property order in Angular @Component and @Directive metadata objects.',
+    },
+    fixable: 'code',
+    messages: {
+      outOfOrder: '{{decorator}} metadata properties should be ordered as: {{order}}.',
+    },
+    schema: [],
+  },
+  create(context) {
+    const sourceCode = context.sourceCode;
+
+    return {
+      /** @param {import('eslint').Rule.Node} node */
+      Decorator(node) {
+        const decoratorName = getDecoratorName(node);
+        if (decoratorName !== 'Component' && decoratorName !== 'Directive') return;
+
+        const decorator = /** @type {any} */ (node);
+        const expression = decorator.expression;
+        if (expression.type !== 'CallExpression' || expression.arguments.length === 0) return;
+
+        const metadata = /** @type {TObjectExpressionNode | undefined} */ (expression.arguments[0]);
+        if (!metadata || metadata.type !== 'ObjectExpression' || metadata.properties.length < 2) return;
+
+        if (
+          metadata.properties.some(
+            /** @param {TPropertyNode | TSpreadElementNode} property */ (property) => property.type !== 'Property',
+          )
+        )
+          return;
+
+        const config = DECORATOR_CONFIG[decoratorName];
+        const orderIndexMap = new Map(
+          config.order.map(/** @param {string} value @param {number} index */ (value, index) => [value, index]),
+        );
+        const openingBrace = sourceCode.getFirstToken(metadata);
+        const closingBrace = sourceCode.getLastToken(metadata);
+
+        if (!openingBrace || !closingBrace || openingBrace.value !== '{' || closingBrace.value !== '}') return;
+
+        let segmentStart = openingBrace.range[1];
+
+        const entries = metadata.properties.map(
+          /** @param {TPropertyNode | TSpreadElementNode} property @param {number} originalIndex @returns {TPropertyEntry} */
+          (property, originalIndex) => {
+            const propertyNode = /** @type {TPropertyNode} */ (property);
+            const propertyName = getPropertyName(propertyNode.key);
+            const orderKey = getOrderKey(decoratorName, propertyName);
+            const orderIndex =
+              orderKey === null ? config.order.length : (orderIndexMap.get(orderKey) ?? config.order.length);
+            const tokenAfter = sourceCode.getTokenAfter(propertyNode);
+            const hasComma = Boolean(tokenAfter && tokenAfter.type === 'Punctuator' && tokenAfter.value === ',');
+            const segmentEnd = hasComma && tokenAfter ? tokenAfter.range[0] : propertyNode.range[1];
+            const segmentText = sourceCode.text.slice(segmentStart, segmentEnd);
+
+            if (hasComma && tokenAfter) {
+              segmentStart = tokenAfter.range[1];
+            } else {
+              segmentStart = propertyNode.range[1];
+            }
+
+            return {
+              hasComma,
+              originalIndex,
+              orderIndex,
+              property: propertyNode,
+              segmentText,
+            };
+          },
+        );
+
+        const trailingComma = entries[entries.length - 1].hasComma;
+        const suffix = sourceCode.text.slice(segmentStart, closingBrace.range[0]);
+        const sortedEntries = [...entries].sort(
+          /** @param {TPropertyEntry} left @param {TPropertyEntry} right */ (left, right) => {
+            if (left.orderIndex !== right.orderIndex) return left.orderIndex - right.orderIndex;
+            return left.originalIndex - right.originalIndex;
+          },
+        );
+
+        const isSorted = entries.every(
+          /** @param {TPropertyEntry} entry @param {number} index */ (entry, index) =>
+            entry.property === sortedEntries[index].property,
+        );
+        if (isSorted) return;
+
+        const firstMismatch = entries.find(
+          /** @param {TPropertyEntry} entry @param {number} index */ (entry, index) =>
+            entry.property !== sortedEntries[index].property,
+        );
+
+        context.report({
+          node: firstMismatch ? firstMismatch.property : metadata,
+          messageId: 'outOfOrder',
+          data: {
+            decorator: `@${decoratorName}`,
+            order: config.orderText,
+          },
+          fix(fixer) {
+            const reorderedBody =
+              sortedEntries
+                .map(
+                  (entry, index) =>
+                    `${entry.segmentText}${index < sortedEntries.length - 1 || trailingComma ? ',' : ''}`,
+                )
+                .join('') + suffix;
+
+            return fixer.replaceTextRange([openingBrace.range[1], closingBrace.range[0]], reorderedBody);
+          },
+        });
+      },
+    };
+  },
+};
+
+module.exports = angularDecoratorPropertyOrder;

package/src/rules/class-constant-property.js

@@ -0,0 +1,365 @@
+// @ts-check
+'use strict';
+
+const SCREAMING_CASE_RE = /^[A-Z][A-Z0-9_]*$/;
+
+/**
+ * @param {any} classNode
+ */
+const hasPipeDecorator = (classNode) => {
+  const decorators = classNode.decorators ?? [];
+  return decorators.some((/** @type {any} */ dec) => {
+    const expr = dec.expression;
+    if (expr.type === 'CallExpression') {
+      return expr.callee.type === 'Identifier' && expr.callee.name === 'Pipe';
+    }
+    if (expr.type === 'Identifier') {
+      return expr.name === 'Pipe';
+    }
+    return false;
+  });
+};
+
+const REACTIVE_APIS = new Set([
+  'signal',
+  'computed',
+  'linkedSignal',
+  'input',
+  'model',
+  'output',
+  'outputFromObservable',
+  'viewChild',
+  'viewChildren',
+  'contentChild',
+  'contentChildren',
+  'inject',
+  'effect',
+  'afterNextRender',
+  'afterRender',
+  'toSignal',
+  'toObservable',
+]);
+
+/**
+ * @param {any} node
+ */
+const getMemberName = (node) => {
+  if (!node || !node.key) return null;
+
+  if (node.key.type === 'Identifier' || node.key.type === 'PrivateIdentifier') {
+    return node.key.name;
+  }
+
+  if (node.key.type === 'Literal' && typeof node.key.value === 'string') {
+    return node.key.value;
+  }
+
+  return null;
+};
+
+/**
+ * @param {any} node
+ */
+const getCallRootName = (node) => {
+  if (!node || node.type !== 'CallExpression') return null;
+
+  const { callee } = node;
+
+  if (callee.type === 'Identifier') {
+    return callee.name;
+  }
+
+  if (callee.type === 'MemberExpression' && callee.object.type === 'Identifier') {
+    return callee.object.name;
+  }
+
+  return null;
+};
+
+/**
+ * @param {any} node
+ */
+const isReactiveInitializer = (node) => {
+  const apiName = getCallRootName(node);
+  return apiName !== null && REACTIVE_APIS.has(apiName);
+};
+
+/**
+ * @param {any} node
+ */
+const isThisReference = (node) => node && (node.type === 'ThisExpression' || node.type === 'Super');
+
+/**
+ * @param {any} node
+ */
+const isConstantExpression = (node) => {
+  if (!node) return false;
+
+  switch (node.type) {
+    case 'Literal':
+    case 'Identifier':
+      return true;
+    case 'TemplateLiteral':
+      return node.expressions.every((expression) => isConstantExpression(expression));
+    case 'UnaryExpression':
+    case 'UpdateExpression':
+      return isConstantExpression(node.argument);
+    case 'BinaryExpression':
+    case 'LogicalExpression':
+      return isConstantExpression(node.left) && isConstantExpression(node.right);
+    case 'ConditionalExpression':
+      return (
+        isConstantExpression(node.test) && isConstantExpression(node.consequent) && isConstantExpression(node.alternate)
+      );
+    case 'ArrayExpression':
+      return node.elements.every((element) => {
+        if (element === null) return true;
+
+        if (element.type === 'SpreadElement') {
+          return isConstantExpression(element.argument);
+        }
+
+        return isConstantExpression(element);
+      });
+    case 'ObjectExpression':
+      return node.properties.every((property) => {
+        if (property.type === 'SpreadElement') {
+          return isConstantExpression(property.argument);
+        }
+
+        if (property.type !== 'Property' || property.kind !== 'init') {
+          return false;
+        }
+
+        if (property.computed && !isConstantExpression(property.key)) {
+          return false;
+        }
+
+        return isConstantExpression(property.value);
+      });
+    case 'MemberExpression':
+      if (isThisReference(node.object)) {
+        return false;
+      }
+
+      if (!isConstantExpression(node.object)) {
+        return false;
+      }
+
+      return node.computed ? isConstantExpression(node.property) : true;
+    case 'TSAsExpression':
+    case 'TSTypeAssertion':
+    case 'TSNonNullExpression':
+    case 'ChainExpression':
+      return isConstantExpression(node.expression);
+    case 'ParenthesizedExpression':
+      return isConstantExpression(node.expression);
+    case 'SequenceExpression':
+      return node.expressions.every((expression) => isConstantExpression(expression));
+    default:
+      return false;
+  }
+};
+
+/**
+ * @param {any} node
+ */
+const getWrittenMemberName = (node) => {
+  if (!node || node.type !== 'MemberExpression' || !isThisReference(node.object)) {
+    return null;
+  }
+
+  if (!node.computed && (node.property.type === 'Identifier' || node.property.type === 'PrivateIdentifier')) {
+    return node.property.name;
+  }
+
+  if (node.computed && node.property.type === 'Literal' && typeof node.property.value === 'string') {
+    return node.property.value;
+  }
+
+  return null;
+};
+
+/**
+ * @param {any} target
+ * @param {Set<string>} writtenMembers
+ */
+const collectAssignedMemberNames = (target, writtenMembers) => {
+  if (!target) return;
+
+  if (target.type === 'MemberExpression') {
+    const memberName = getWrittenMemberName(target);
+
+    if (memberName !== null) {
+      writtenMembers.add(memberName);
+    }
+
+    return;
+  }
+
+  if (target.type === 'ArrayPattern') {
+    for (const element of target.elements) {
+      collectAssignedMemberNames(element, writtenMembers);
+    }
+
+    return;
+  }
+
+  if (target.type === 'ObjectPattern') {
+    for (const property of target.properties) {
+      if (property.type === 'Property') {
+        collectAssignedMemberNames(property.value, writtenMembers);
+      } else if (property.type === 'RestElement') {
+        collectAssignedMemberNames(property.argument, writtenMembers);
+      }
+    }
+
+    return;
+  }
+
+  if (target.type === 'AssignmentPattern') {
+    collectAssignedMemberNames(target.left, writtenMembers);
+
+    return;
+  }
+
+  if (target.type === 'RestElement') {
+    collectAssignedMemberNames(target.argument, writtenMembers);
+  }
+};
+
+/**
+ * @param {any} node
+ * @param {Set<string>} writtenMembers
+ */
+const collectWrittenMembers = (node, writtenMembers) => {
+  if (!node || typeof node !== 'object') return;
+
+  if (Array.isArray(node)) {
+    for (const entry of node) {
+      collectWrittenMembers(entry, writtenMembers);
+    }
+
+    return;
+  }
+
+  if (node.type === 'ClassDeclaration' || node.type === 'ClassExpression') {
+    return;
+  }
+
+  if (node.type === 'AssignmentExpression') {
+    collectAssignedMemberNames(node.left, writtenMembers);
+  }
+
+  if (node.type === 'UpdateExpression') {
+    const memberName = getWrittenMemberName(node.argument);
+
+    if (memberName !== null) {
+      writtenMembers.add(memberName);
+    }
+  }
+
+  for (const [key, value] of Object.entries(node)) {
+    if (key === 'parent' || key === 'range' || key === 'loc') continue;
+    if (!value || typeof value !== 'object') continue;
+
+    collectWrittenMembers(value, writtenMembers);
+  }
+};
+
+/**
+ * @param {any} classBodyNode
+ */
+const getWrittenMembers = (classBodyNode) => {
+  const writtenMembers = new Set();
+
+  for (const member of classBodyNode.body) {
+    collectWrittenMembers(member, writtenMembers);
+  }
+
+  return writtenMembers;
+};
+
+/**
+ * @param {any} node
+ */
+const isConstantProperty = (node) => {
+  if (node.type !== 'PropertyDefinition' || node.static || node.computed || !node.value) {
+    return false;
+  }
+
+  if (isReactiveInitializer(node.value)) {
+    return false;
+  }
+
+  return isConstantExpression(node.value);
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const classConstantProperty = {
+  meta: {
+    type: 'suggestion',
+    fixable: 'code',
+    docs: {
+      description: 'Require true class constants to use readonly and SCREAMING_CASE.',
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      shouldBeReadonly: "'{{name}}' is a class constant and should be declared readonly.",
+      shouldUseScreamingCase: "Readonly class constant '{{name}}' should use SCREAMING_CASE.",
+    },
+  },
+  create(context) {
+    return {
+      ClassBody(node) {
+        const writtenMembers = getWrittenMembers(node);
+
+        for (const member of node.body) {
+          if (!isConstantProperty(member)) {
+            continue;
+          }
+
+          const memberName = getMemberName(member);
+
+          if (memberName === null || writtenMembers.has(memberName)) {
+            continue;
+          }
+
+          if (memberName === 'transform' && hasPipeDecorator(node.parent)) {
+            continue;
+          }
+
+          if (!member.readonly) {
+            context.report({
+              node: member,
+              messageId: 'shouldBeReadonly',
+              data: { name: memberName },
+              fix(fixer) {
+                const keyToken = context.sourceCode.getFirstToken(member.key);
+
+                if (!keyToken) {
+                  return null;
+                }
+
+                return fixer.insertTextBefore(keyToken, 'readonly ');
+              },
+            });
+
+            continue;
+          }
+
+          if (!SCREAMING_CASE_RE.test(memberName)) {
+            context.report({
+              node: member.key,
+              messageId: 'shouldUseScreamingCase',
+              data: { name: memberName },
+            });
+          }
+        }
+      },
+    };
+  },
+};
+
+module.exports = classConstantProperty;