eslint-plugin-absolute 0.7.0 → 0.9.0

package/dist/index.js

@@ -1,26 +1,83 @@
 // @bun
-// src/rules/no-nested-jsx-return.ts
+// src/rules/angular-one-feature-per-file.ts
 import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+var FEATURE_DECORATOR_NAMES = new Set([
+  "Component",
+  "Directive",
+  "Injectable",
+  "NgModule",
+  "Pipe"
+]);
+var getDecoratorName = (decorator) => {
+  const { expression } = decorator;
+  if (expression.type === AST_NODE_TYPES.CallExpression && expression.callee.type === AST_NODE_TYPES.Identifier) {
+    return expression.callee.name;
+  }
+  if (expression.type === AST_NODE_TYPES.Identifier) {
+    return expression.name;
+  }
+  return null;
+};
+var isFeatureClass = (node) => {
+  if (!node.decorators || node.decorators.length === 0)
+    return false;
+  return node.decorators.some((decorator) => {
+    const name = getDecoratorName(decorator);
+    return name !== null && FEATURE_DECORATOR_NAMES.has(name);
+  });
+};
+var angularOneFeaturePerFile = {
+  create(context) {
+    const seenFeatures = [];
+    return {
+      ClassDeclaration(node) {
+        if (!isFeatureClass(node))
+          return;
+        seenFeatures.push(node);
+        if (seenFeatures.length === 1)
+          return;
+        context.report({
+          messageId: "multiFeature",
+          node: node.id ?? node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: 'Disallow defining more than one Angular feature class (@Component, @Directive, @Pipe, @Injectable, @NgModule) per file. Mirrors the Angular Style Guide\'s Single Responsibility / Rule of One. Test and Storybook files legitimately define stub/host classes alongside the subject under test \u2014 disable this rule for those files via an ESLint override (e.g., `{ files: ["**/*.spec.ts", "**/*.stories.ts"], rules: { "absolute/angular-one-feature-per-file": "off" } }`).'
+    },
+    messages: {
+      multiFeature: "Only one Angular feature class is allowed per file. Move this class into its own file (Angular Style Guide: Single Responsibility / Rule of One)."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+
+// src/rules/no-nested-jsx-return.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES2 } from "@typescript-eslint/utils";
 var noNestedJSXReturn = {
   create(context) {
-    const isJSX = (node) => node !== null && node !== undefined && (node.type === AST_NODE_TYPES.JSXElement || node.type === AST_NODE_TYPES.JSXFragment);
+    const isJSX = (node) => node !== null && node !== undefined && (node.type === AST_NODE_TYPES2.JSXElement || node.type === AST_NODE_TYPES2.JSXFragment);
     const getLeftmostJSXIdentifier = (name) => {
       let current = name;
-      while (current.type === AST_NODE_TYPES.JSXMemberExpression) {
+      while (current.type === AST_NODE_TYPES2.JSXMemberExpression) {
         current = current.object;
       }
-      if (current.type === AST_NODE_TYPES.JSXIdentifier) {
+      if (current.type === AST_NODE_TYPES2.JSXIdentifier) {
         return current;
       }
       return null;
     };
     const isJSXComponentElement = (node) => {
-      if (!node || node.type !== AST_NODE_TYPES.JSXElement) {
+      if (!node || node.type !== AST_NODE_TYPES2.JSXElement) {
         return false;
       }
       const opening = node.openingElement;
       const nameNode = opening.name;
-      if (nameNode.type === AST_NODE_TYPES.JSXIdentifier) {
+      if (nameNode.type === AST_NODE_TYPES2.JSXIdentifier) {
         return /^[A-Z]/.test(nameNode.name);
       }
       const leftmost = getLeftmostJSXIdentifier(nameNode);
@@ -31,7 +88,7 @@ var noNestedJSXReturn = {
     };
     const hasNoMeaningfulChildren = (children) => {
       const filtered = children.filter((child) => {
-        if (child.type === AST_NODE_TYPES.JSXText) {
+        if (child.type === AST_NODE_TYPES2.JSXText) {
           return child.value.trim() !== "";
         }
         return true;
@@ -42,7 +99,7 @@ var noNestedJSXReturn = {
       if (!isJSX(node))
         return false;
       const children = node.children.filter((child2) => {
-        if (child2.type === AST_NODE_TYPES.JSXText) {
+        if (child2.type === AST_NODE_TYPES2.JSXText) {
           return child2.value.trim() !== "";
         }
         return true;
@@ -57,7 +114,7 @@ var noNestedJSXReturn = {
       if (!child) {
         return false;
       }
-      if (child.type === AST_NODE_TYPES.JSXElement || child.type === AST_NODE_TYPES.JSXFragment) {
+      if (child.type === AST_NODE_TYPES2.JSXElement || child.type === AST_NODE_TYPES2.JSXFragment) {
         return hasNoMeaningfulChildren(child.children);
       }
       return true;
@@ -356,36 +413,29 @@ var hasDuplicateNames = (names) => {
   }
   return false;
 };
+var getStaticPropertyKeyName = (property) => {
+  if (property.key.type === "Identifier")
+    return property.key.name;
+  if (property.key.type === "Literal") {
+    const { value } = property.key;
+    return typeof value === "string" ? value : String(value);
+  }
+  return null;
+};
+var isAccessorPairOnly = (kinds) => kinds.length === 2 && kinds.includes("get") && kinds.includes("set");
 var hasDuplicatePropertyNames = (properties) => {
   const kindsByName = new Map;
-  for (const property of properties) {
-    if (property.type !== "Property") {
-      continue;
-    }
-    let keyName = null;
-    if (property.key.type === "Identifier") {
-      keyName = property.key.name;
-    } else if (property.key.type === "Literal") {
-      const { value } = property.key;
-      keyName = typeof value === "string" ? value : String(value);
-    }
-    if (keyName === null) {
-      continue;
-    }
+  properties.forEach((property) => {
+    if (property.type !== "Property")
+      return;
+    const keyName = getStaticPropertyKeyName(property);
+    if (keyName === null)
+      return;
     const kinds = kindsByName.get(keyName) ?? [];
     kinds.push(property.kind);
     kindsByName.set(keyName, kinds);
-  }
-  for (const kinds of kindsByName.values()) {
-    if (kinds.length === 1) {
-      continue;
-    }
-    if (kinds.length === 2 && kinds.includes("get") && kinds.includes("set")) {
-      continue;
-    }
-    return true;
-  }
-  return false;
+  });
+  return [...kindsByName.values()].some((kinds) => kinds.length > 1 && !isAccessorPairOnly(kinds));
 };
 var sortKeysFixable = {
   create(context) {
@@ -547,13 +597,11 @@ var sortKeysFixable = {
       const left = ancestor.type === "ForStatement" ? ancestor.init : ancestor.left;
       if (!left)
         return;
-      if (left.type === "VariableDeclaration") {
-        for (const declaration of left.declarations) {
-          addBoundIdentifiers(declaration.id, stableLocals);
-        }
-      } else {
+      if (left.type !== "VariableDeclaration") {
         addBoundIdentifiers(left, stableLocals);
+        return;
       }
+      left.declarations.forEach((declaration) => addBoundIdentifiers(declaration.id, stableLocals));
     };
     const addCatchClauseBindings = (ancestor, stableLocals) => {
       if (ancestor.type !== "CatchClause" || !ancestor.param)
@@ -604,10 +652,8 @@ var sortKeysFixable = {
     };
     const isPureLocalVariableStatement = (statement, stableLocals) => {
       for (const declaration of statement.declarations) {
-        if (declaration.init) {
-          if (!isPureRuntimeExpression(declaration.init, stableLocals)) {
-            return false;
-          }
+        if (declaration.init && !isPureRuntimeExpression(declaration.init, stableLocals)) {
+          return false;
         }
         addBoundIdentifiers(declaration.id, stableLocals);
       }
@@ -708,9 +754,7 @@ var sortKeysFixable = {
         return;
       }
       if (ts.isObjectBindingPattern(node) || ts.isArrayBindingPattern(node)) {
-        for (const element of node.elements) {
-          addTsBoundIdentifiers(element, stableLocals);
-        }
+        node.elements.forEach((element) => addTsBoundIdentifiers(element, stableLocals));
       }
     };
     const getCalleeIdentifier = (callee) => {
@@ -789,20 +833,21 @@ var sortKeysFixable = {
         return false;
       return isPureTsExpression(expression.right, stableLocals);
     };
+    const isPureTsVariableStatement = (statement, stableLocals) => {
+      for (const declaration of statement.declarationList.declarations) {
+        if (declaration.initializer && !isPureTsExpression(declaration.initializer, stableLocals)) {
+          return false;
+        }
+        addTsBoundIdentifiers(declaration.name, stableLocals);
+      }
+      return true;
+    };
     const isPureTsStatement = (statement, stableLocals) => {
       if (ts.isReturnStatement(statement)) {
         return !statement.expression || isPureTsExpression(statement.expression, stableLocals);
       }
       if (ts.isVariableStatement(statement)) {
-        for (const declaration of statement.declarationList.declarations) {
-          if (declaration.initializer) {
-            if (!isPureTsExpression(declaration.initializer, stableLocals)) {
-              return false;
-            }
-          }
-          addTsBoundIdentifiers(declaration.name, stableLocals);
-        }
-        return true;
+        return isPureTsVariableStatement(statement, stableLocals);
       }
       if (ts.isExpressionStatement(statement)) {
         return isPureTsLocalAssignment(statement.expression, stableLocals);
@@ -1059,20 +1104,12 @@ var sortKeysFixable = {
       }
       return isPureImportedCallExpression(callExpression);
     };
-    const getCallReturnTypeSymbol = (node) => {
-      if (!tsChecker || !esTreeNodeToTSNodeMap)
-        return;
-      const tsNode = esTreeNodeToTSNodeMap.get(node);
-      if (!tsNode)
-        return;
-      const type = tsChecker.getTypeAtLocation(tsNode);
-      return type.symbol ?? type.aliasSymbol;
-    };
+    const isUnionType = (type) => Boolean(type.flags & ts.TypeFlags.Union);
     const isObjectLikeType = (type) => {
       if (type.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.Void)) {
         return false;
       }
-      if (type.flags & ts.TypeFlags.Union) {
+      if (isUnionType(type)) {
         return type.types.every((member) => {
           if (member.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.Void)) {
             return true;
@@ -1208,10 +1245,7 @@ var sortKeysFixable = {
             return true;
           }
           if (node.callee.type === "Identifier") {
-            if (isPureIdentifierCall(node)) {
-              return true;
-            }
-            return callReturnsNominalInstance(node);
+            return isPureIdentifierCall(node) || callReturnsNominalInstance(node);
           }
           if (node.callee.type !== "MemberExpression") {
             return false;
@@ -1395,9 +1429,7 @@ ${indent}`;
       }
       if (autoFixable) {
         const impureCount = keys.filter((key) => key.node.type === "Property" && !isPureRuntimeExpression(key.node.value, getStableLocalsForNode(key.node))).length;
-        if (impureCount > 1) {
-          autoFixable = false;
-        }
+        autoFixable = impureCount <= 1;
       }
       let fixProvided = false;
       const createReportWithFix = (curr, shouldFix) => {
@@ -2234,7 +2266,7 @@ var sortExports = {
 };
 
 // src/rules/localize-react-props.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES2 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES3 } from "@typescript-eslint/utils";
 var localizeReactProps = {
   create(context) {
     const candidateVariables = [];
@@ -2246,20 +2278,20 @@ var localizeReactProps = {
     };
     const getRightmostJSXIdentifier = (name) => {
       let current = name;
-      while (current.type === AST_NODE_TYPES2.JSXMemberExpression) {
+      while (current.type === AST_NODE_TYPES3.JSXMemberExpression) {
         current = current.property;
       }
-      if (current.type === AST_NODE_TYPES2.JSXIdentifier) {
+      if (current.type === AST_NODE_TYPES3.JSXIdentifier) {
         return current;
       }
       return null;
     };
     const getLeftmostJSXIdentifier = (name) => {
       let current = name;
-      while (current.type === AST_NODE_TYPES2.JSXMemberExpression) {
+      while (current.type === AST_NODE_TYPES3.JSXMemberExpression) {
         current = current.object;
       }
-      if (current.type === AST_NODE_TYPES2.JSXIdentifier) {
+      if (current.type === AST_NODE_TYPES3.JSXIdentifier) {
         return current;
       }
       return null;
@@ -2269,7 +2301,7 @@ var localizeReactProps = {
         return "";
       }
       const nameNode = jsxElement.openingElement.name;
-      if (nameNode.type === AST_NODE_TYPES2.JSXIdentifier) {
+      if (nameNode.type === AST_NODE_TYPES3.JSXIdentifier) {
         return nameNode.name;
       }
       const rightmost = getRightmostJSXIdentifier(nameNode);
@@ -2278,12 +2310,12 @@ var localizeReactProps = {
       }
       return "";
     };
-    const isUseStateCall = (node) => node !== null && node.type === AST_NODE_TYPES2.CallExpression && node.callee !== null && (node.callee.type === AST_NODE_TYPES2.Identifier && node.callee.name === "useState" || node.callee.type === AST_NODE_TYPES2.MemberExpression && node.callee.property !== null && node.callee.property.type === AST_NODE_TYPES2.Identifier && node.callee.property.name === "useState");
-    const isHookCall = (node) => node !== null && node.type === AST_NODE_TYPES2.CallExpression && node.callee !== null && node.callee.type === AST_NODE_TYPES2.Identifier && /^use[A-Z]/.test(node.callee.name) && node.callee.name !== "useState";
+    const isUseStateCall = (node) => node !== null && node.type === AST_NODE_TYPES3.CallExpression && node.callee !== null && (node.callee.type === AST_NODE_TYPES3.Identifier && node.callee.name === "useState" || node.callee.type === AST_NODE_TYPES3.MemberExpression && node.callee.property !== null && node.callee.property.type === AST_NODE_TYPES3.Identifier && node.callee.property.name === "useState");
+    const isHookCall = (node) => node !== null && node.type === AST_NODE_TYPES3.CallExpression && node.callee !== null && node.callee.type === AST_NODE_TYPES3.Identifier && /^use[A-Z]/.test(node.callee.name) && node.callee.name !== "useState";
     const getJSXAncestor = (node) => {
       let current = node.parent;
       while (current) {
-        if (current.type === AST_NODE_TYPES2.JSXElement) {
+        if (current.type === AST_NODE_TYPES3.JSXElement) {
           return current;
         }
         current = current.parent;
@@ -2292,14 +2324,14 @@ var localizeReactProps = {
     };
     const getTagNameFromOpening = (openingElement) => {
       const nameNode = openingElement.name;
-      if (nameNode.type === AST_NODE_TYPES2.JSXIdentifier) {
+      if (nameNode.type === AST_NODE_TYPES3.JSXIdentifier) {
         return nameNode.name;
       }
       const rightmost = getRightmostJSXIdentifier(nameNode);
       return rightmost ? rightmost.name : null;
     };
     const isProviderOrContext = (tagName) => tagName.endsWith("Provider") || tagName.endsWith("Context");
-    const isValueAttributeOnProvider = (node) => node.type === AST_NODE_TYPES2.JSXAttribute && node.name && node.name.type === AST_NODE_TYPES2.JSXIdentifier && node.name.name === "value" && node.parent && node.parent.type === AST_NODE_TYPES2.JSXOpeningElement && (() => {
+    const isValueAttributeOnProvider = (node) => node.type === AST_NODE_TYPES3.JSXAttribute && node.name && node.name.type === AST_NODE_TYPES3.JSXIdentifier && node.name.name === "value" && node.parent && node.parent.type === AST_NODE_TYPES3.JSXOpeningElement && (() => {
       const tagName = getTagNameFromOpening(node.parent);
       return tagName !== null && isProviderOrContext(tagName);
     })();
@@ -2318,7 +2350,7 @@ var localizeReactProps = {
         return false;
       }
       const nameNode = jsxElement.openingElement.name;
-      if (nameNode.type === AST_NODE_TYPES2.JSXIdentifier) {
+      if (nameNode.type === AST_NODE_TYPES3.JSXIdentifier) {
         return /^[A-Z]/.test(nameNode.name);
       }
       const leftmost = getLeftmostJSXIdentifier(nameNode);
@@ -2327,7 +2359,7 @@ var localizeReactProps = {
     const getComponentFunction = (node) => {
       let current = node;
       while (current) {
-        if (current.type === AST_NODE_TYPES2.FunctionDeclaration || current.type === AST_NODE_TYPES2.FunctionExpression || current.type === AST_NODE_TYPES2.ArrowFunctionExpression) {
+        if (current.type === AST_NODE_TYPES3.FunctionDeclaration || current.type === AST_NODE_TYPES3.FunctionExpression || current.type === AST_NODE_TYPES3.ArrowFunctionExpression) {
           return current;
         }
         current = current.parent;
@@ -2399,11 +2431,11 @@ var localizeReactProps = {
       return false;
     };
     const processUseStateDeclarator = (node) => {
-      if (!node.init || !isUseStateCall(node.init) || node.id.type !== AST_NODE_TYPES2.ArrayPattern || node.id.elements.length < 2) {
+      if (!node.init || !isUseStateCall(node.init) || node.id.type !== AST_NODE_TYPES3.ArrayPattern || node.id.elements.length < 2) {
         return false;
       }
       const [stateElem, setterElem] = node.id.elements;
-      if (!stateElem || stateElem.type !== AST_NODE_TYPES2.Identifier || !setterElem || setterElem.type !== AST_NODE_TYPES2.Identifier) {
+      if (!stateElem || stateElem.type !== AST_NODE_TYPES3.Identifier || !setterElem || setterElem.type !== AST_NODE_TYPES3.Identifier) {
         return false;
       }
       const stateVarName = stateElem.name;
@@ -2427,7 +2459,7 @@ var localizeReactProps = {
       return true;
     };
     const processGeneralVariable = (node, componentFunction) => {
-      if (!node.id || node.id.type !== AST_NODE_TYPES2.Identifier) {
+      if (!node.id || node.id.type !== AST_NODE_TYPES3.Identifier) {
         return;
       }
       const varName = node.id.name;
@@ -2479,7 +2511,7 @@ var localizeReactProps = {
         const componentFunction = getComponentFunction(node);
         if (!componentFunction || !componentFunction.body)
           return;
-        if (node.init && node.id && node.id.type === AST_NODE_TYPES2.Identifier && node.init.type === AST_NODE_TYPES2.CallExpression && isHookCall(node.init)) {
+        if (node.init && node.id && node.id.type === AST_NODE_TYPES3.Identifier && node.init.type === AST_NODE_TYPES3.CallExpression && isHookCall(node.init)) {
           const hookSet = getHookSet(componentFunction);
           hookSet.add(node.id.name);
         }
@@ -3329,71 +3361,170 @@ var inlineStyleLimit = {
   }
 };
 
-// src/rules/no-inline-prop-types.ts
-var noInlinePropTypes = {
+// src/rules/no-inline-object-types.ts
+var DEFAULT_MIN_PROPERTIES = 2;
+var toPascalCase = (name) => {
+  const parts = name.replace(/[_-]+/g, " ").split(/\s+/).filter(Boolean);
+  if (parts.length === 0)
+    return name;
+  return parts.map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+};
+var collectInlineObjectTypes = (node, found) => {
+  if (node.type === "TSTypeLiteral") {
+    found.push(node);
+    return;
+  }
+  if (node.type === "TSArrayType") {
+    collectInlineObjectTypes(node.elementType, found);
+    return;
+  }
+  if (node.type === "TSUnionType" || node.type === "TSIntersectionType") {
+    node.types.forEach((member) => collectInlineObjectTypes(member, found));
+    return;
+  }
+  if (node.type === "TSTypeReference" && node.typeArguments) {
+    node.typeArguments.params.forEach((arg) => collectInlineObjectTypes(arg, found));
+  }
+};
+var unwrapParamTarget = (node) => {
+  if (node.type === "TSParameterProperty") {
+    return unwrapParamTarget(node.parameter);
+  }
+  if (node.type === "AssignmentPattern") {
+    return unwrapParamTarget(node.left);
+  }
+  return node;
+};
+var SCOPE_BOUNDARY_TYPES = new Set([
+  "ArrowFunctionExpression",
+  "ClassDeclaration",
+  "ClassExpression",
+  "FunctionDeclaration",
+  "FunctionExpression"
+]);
+var deriveNameFromAncestors = (node) => {
+  let current = node.parent;
+  while (current) {
+    if (current.type === "VariableDeclarator" && current.id.type === "Identifier") {
+      return toPascalCase(current.id.name);
+    }
+    if (current.type === "PropertyDefinition" && current.key.type === "Identifier") {
+      return toPascalCase(current.key.name);
+    }
+    if (SCOPE_BOUNDARY_TYPES.has(current.type))
+      return "T";
+    current = current.parent;
+  }
+  return "T";
+};
+var noInlineObjectTypes = {
   create(context) {
-    const checkParameter = (param) => {
-      if (param.type !== "ObjectPattern" || !param.typeAnnotation || param.typeAnnotation.type !== "TSTypeAnnotation") {
-        return;
-      }
-      const annotation = param.typeAnnotation.typeAnnotation;
-      if (annotation.type === "TSTypeLiteral") {
+    const [options] = context.options;
+    const minProperties = options?.minProperties ?? DEFAULT_MIN_PROPERTIES;
+    const reportAnnotation = (typeNode, suggestedName) => {
+      const literals = [];
+      collectInlineObjectTypes(typeNode, literals);
+      for (const literal of literals) {
+        if (literal.members.length < minProperties)
+          continue;
+        const hasIndexSignature = literal.members.some((member) => member.type === "TSIndexSignature");
+        if (hasIndexSignature)
+          continue;
         context.report({
-          messageId: "noInlinePropTypes",
-          node: param
+          data: { suggestedName },
+          messageId: "inlineObjectType",
+          node: literal
         });
       }
     };
+    const handleFunctionParams = (params) => {
+      for (const param of params) {
+        const target = unwrapParamTarget(param);
+        if (!("typeAnnotation" in target))
+          continue;
+        const annotation = target.typeAnnotation;
+        if (!annotation || annotation.type !== "TSTypeAnnotation")
+          continue;
+        const name = target.type === "Identifier" ? toPascalCase(target.name) : "Params";
+        reportAnnotation(annotation.typeAnnotation, name);
+      }
+    };
     return {
-      "FunctionDeclaration, ArrowFunctionExpression, FunctionExpression"(node) {
-        if (node.params.length === 0) {
+      "CallExpression, NewExpression"(node) {
+        if (!node.typeArguments)
           return;
+        const name = deriveNameFromAncestors(node);
+        for (const typeArg of node.typeArguments.params) {
+          reportAnnotation(typeArg, name);
         }
-        const [firstParam] = node.params;
-        if (!firstParam) {
+      },
+      "FunctionDeclaration, FunctionExpression, ArrowFunctionExpression"(node) {
+        handleFunctionParams(node.params);
+      },
+      PropertyDefinition(node) {
+        if (!node.typeAnnotation || node.typeAnnotation.type !== "TSTypeAnnotation")
           return;
-        }
-        checkParameter(firstParam);
+        const name = node.key.type === "Identifier" ? toPascalCase(node.key.name) : "Field";
+        reportAnnotation(node.typeAnnotation.typeAnnotation, name);
+      },
+      VariableDeclarator(node) {
+        if (node.id.type !== "Identifier")
+          return;
+        const annotation = node.id.typeAnnotation;
+        if (!annotation || annotation.type !== "TSTypeAnnotation")
+          return;
+        reportAnnotation(annotation.typeAnnotation, toPascalCase(node.id.name));
       }
     };
   },
-  defaultOptions: [],
+  defaultOptions: [{ minProperties: DEFAULT_MIN_PROPERTIES }],
   meta: {
     docs: {
-      description: "Enforce that component prop types are not defined inline (using an object literal) but rather use a named type or interface."
+      description: "Disallow inline object type literals on annotations (variables, class fields, function params, generic type arguments); prefer extracting them to a named type alias."
     },
     messages: {
-      noInlinePropTypes: "Inline prop type definitions are not allowed. Use a named type alias or interface instead of an inline object type."
+      inlineObjectType: "Inline object type should be extracted to a named type alias (e.g., `type {{suggestedName}} = { ... }`)."
     },
-    schema: [],
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          minProperties: {
+            minimum: 1,
+            type: "number"
+          }
+        },
+        type: "object"
+      }
+    ],
     type: "suggestion"
   }
 };
 
 // src/rules/no-nondeterministic-render.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES3 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES4 } from "@typescript-eslint/utils";
 var BANNED_TEMPLATE_PATTERN = /\bMath\.random\s*\(|\bDate\.now\s*\(|\bnew\s+Date\s*\(\s*\)|\bcrypto\.randomUUID\s*\(|\bperformance\.now\s*\(/;
-var isIdentifier2 = (node, name) => node?.type === AST_NODE_TYPES3.Identifier && node.name === name;
-var isStaticMemberCall = (node, objectName, propertyName) => node.callee.type === AST_NODE_TYPES3.MemberExpression && !node.callee.computed && isIdentifier2(node.callee.object, objectName) && isIdentifier2(node.callee.property, propertyName);
+var isIdentifier2 = (node, name) => node?.type === AST_NODE_TYPES4.Identifier && node.name === name;
+var isStaticMemberCall = (node, objectName, propertyName) => node.callee.type === AST_NODE_TYPES4.MemberExpression && !node.callee.computed && isIdentifier2(node.callee.object, objectName) && isIdentifier2(node.callee.property, propertyName);
 var getPropertyName2 = (node) => {
   const { key } = node;
-  if (key.type === AST_NODE_TYPES3.Identifier)
+  if (key.type === AST_NODE_TYPES4.Identifier)
     return key.name;
-  if (key.type === AST_NODE_TYPES3.Literal && typeof key.value === "string") {
+  if (key.type === AST_NODE_TYPES4.Literal && typeof key.value === "string") {
     return key.value;
   }
   return null;
 };
 var isComponentDecorator = (decorator) => {
   const { expression } = decorator;
-  return expression.type === AST_NODE_TYPES3.CallExpression && isIdentifier2(expression.callee, "Component");
+  return expression.type === AST_NODE_TYPES4.CallExpression && isIdentifier2(expression.callee, "Component");
 };
-var isAngularComponentClass = (node) => node.type === AST_NODE_TYPES3.ClassDeclaration && (node.decorators ?? []).some(isComponentDecorator);
+var isAngularComponentClass = (node) => node.type === AST_NODE_TYPES4.ClassDeclaration && (node.decorators ?? []).some(isComponentDecorator);
 var getTemplateText = (node) => {
-  if (node.type === AST_NODE_TYPES3.Literal && typeof node.value === "string") {
+  if (node.type === AST_NODE_TYPES4.Literal && typeof node.value === "string") {
     return node.value;
   }
-  if (node.type === AST_NODE_TYPES3.TemplateLiteral) {
+  if (node.type === AST_NODE_TYPES4.TemplateLiteral) {
     return node.quasis.map((quasi) => quasi.value.cooked ?? "").join("");
   }
   return null;
@@ -3410,10 +3541,10 @@ var getEnclosingAngularComponentClass = (node) => {
 var getEnclosingPropertyDefinition = (node) => {
   let current = node.parent;
   while (current) {
-    if (current.type === AST_NODE_TYPES3.PropertyDefinition) {
+    if (current.type === AST_NODE_TYPES4.PropertyDefinition) {
       return current;
     }
-    if (current.type === AST_NODE_TYPES3.MethodDefinition || current.type === AST_NODE_TYPES3.FunctionDeclaration || current.type === AST_NODE_TYPES3.FunctionExpression || current.type === AST_NODE_TYPES3.ArrowFunctionExpression) {
+    if (current.type === AST_NODE_TYPES4.MethodDefinition || current.type === AST_NODE_TYPES4.FunctionDeclaration || current.type === AST_NODE_TYPES4.FunctionExpression || current.type === AST_NODE_TYPES4.ArrowFunctionExpression) {
       return null;
     }
     current = current.parent;
@@ -3475,16 +3606,91 @@ var noNondeterministicRender = {
   }
 };
 
+// src/rules/no-redundant-type-annotation.ts
+import * as ts2 from "typescript";
+var ALLOWED_INIT_TYPES = new Set([
+  "CallExpression",
+  "Identifier",
+  "MemberExpression",
+  "NewExpression",
+  "TSAsExpression"
+]);
+var noRedundantTypeAnnotation = {
+  create(context) {
+    const { sourceCode } = context;
+    const parserServices = sourceCode.parserServices ?? null;
+    const tsProgram = parserServices && "program" in parserServices ? parserServices.program : null;
+    const tsChecker = tsProgram ? tsProgram.getTypeChecker() : null;
+    const esTreeNodeToTSNodeMap = parserServices && "esTreeNodeToTSNodeMap" in parserServices ? parserServices.esTreeNodeToTSNodeMap : null;
+    if (!tsChecker || !esTreeNodeToTSNodeMap) {
+      return {};
+    }
+    const stringify = (type) => tsChecker.typeToString(type, undefined, ts2.TypeFormatFlags.NoTruncation | ts2.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope);
+    return {
+      VariableDeclarator(node) {
+        if (node.id.type !== "Identifier")
+          return;
+        if (!node.id.typeAnnotation)
+          return;
+        if (!node.init)
+          return;
+        if (!ALLOWED_INIT_TYPES.has(node.init.type))
+          return;
+        const annotationASTNode = node.id.typeAnnotation.typeAnnotation;
+        const annotationTSNode = esTreeNodeToTSNodeMap.get(annotationASTNode);
+        const initTSNode = esTreeNodeToTSNodeMap.get(node.init);
+        if (!annotationTSNode || !initTSNode)
+          return;
+        if (!ts2.isTypeNode(annotationTSNode))
+          return;
+        const annotationType = tsChecker.getTypeFromTypeNode(annotationTSNode);
+        const initType = tsChecker.getTypeAtLocation(initTSNode);
+        const aliasSymbol = ts2.isTypeReferenceNode(annotationTSNode) ? tsChecker.getSymbolAtLocation(annotationTSNode.typeName) : undefined;
+        if (aliasSymbol && aliasSymbol.flags & ts2.SymbolFlags.TypeAlias && initType.aliasSymbol !== aliasSymbol) {
+          return;
+        }
+        const bothAny = (annotationType.flags & ts2.TypeFlags.Any) !== 0 && (initType.flags & ts2.TypeFlags.Any) !== 0;
+        if (bothAny)
+          return;
+        if (annotationType.aliasSymbol !== initType.aliasSymbol)
+          return;
+        if (stringify(annotationType) !== stringify(initType))
+          return;
+        const annotationNode = node.id.typeAnnotation;
+        context.report({
+          fix(fixer) {
+            return fixer.removeRange(annotationNode.range);
+          },
+          messageId: "redundantTypeAnnotation",
+          node: annotationNode
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Disallow type annotations on variable declarations whose initializer already has the same inferred type."
+    },
+    fixable: "code",
+    messages: {
+      redundantTypeAnnotation: "Type annotation is redundant \u2014 the initializer already has this type. Remove the annotation and let TypeScript infer it."
+    },
+    schema: [],
+    type: "suggestion"
+  }
+};
+
 // src/rules/no-unnecessary-div.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES4 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES5 } from "@typescript-eslint/utils";
 var noUnnecessaryDiv = {
   create(context) {
     const isDivElement = (node) => {
       const nameNode = node.openingElement.name;
-      return nameNode.type === AST_NODE_TYPES4.JSXIdentifier && nameNode.name === "div";
+      return nameNode.type === AST_NODE_TYPES5.JSXIdentifier && nameNode.name === "div";
     };
     const isMeaningfulChild = (child) => {
-      if (child.type === AST_NODE_TYPES4.JSXText) {
+      if (child.type === AST_NODE_TYPES5.JSXText) {
         return child.value.trim() !== "";
       }
       return true;
@@ -3503,7 +3709,7 @@ var noUnnecessaryDiv = {
         if (!onlyChild) {
           return;
         }
-        if (onlyChild.type === AST_NODE_TYPES4.JSXElement) {
+        if (onlyChild.type === AST_NODE_TYPES5.JSXElement) {
           context.report({
             messageId: "unnecessaryDivWrapper",
             node
@@ -3545,11 +3751,8 @@ var findOwnDeclaration = (program, name) => {
     if (stmt.type === "ExportNamedDeclaration" && stmt.declaration && isLocalDeclaration(stmt.declaration) && declarationName(stmt.declaration) === name) {
       return { alreadyExported: true, decl: stmt.declaration };
     }
-    if (stmt.type === "ExportDefaultDeclaration" && stmt.declaration.type !== "Identifier" && isLocalDeclaration(stmt.declaration) && declarationName(stmt.declaration) === name) {
-      return {
-        alreadyExported: true,
-        decl: stmt.declaration
-      };
+    if (stmt.type === "ExportDefaultDeclaration" && isLocalDeclaration(stmt.declaration) && declarationName(stmt.declaration) === name) {
+      return { alreadyExported: true, decl: stmt.declaration };
     }
     if (isLocalDeclaration(stmt) && declarationName(stmt) === name) {
       return { alreadyExported: false, decl: stmt };
@@ -3634,6 +3837,7 @@ var preferInlineExports = {
 // src/index.ts
 var src_default = {
   rules: {
+    "angular-one-feature-per-file": angularOneFeaturePerFile,
     "explicit-object-types": explicitObjectTypes,
     "inline-style-limit": inlineStyleLimit,
     "localize-react-props": localizeReactProps,
@@ -3642,11 +3846,12 @@ var src_default = {
     "min-var-length": minVarLength,
     "no-button-navigation": noButtonNavigation,
     "no-explicit-return-type": noExplicitReturnTypes,
-    "no-inline-prop-types": noInlinePropTypes,
+    "no-inline-object-types": noInlineObjectTypes,
     "no-multi-style-objects": noMultiStyleObjects,
     "no-nested-jsx-return": noNestedJSXReturn,
     "no-nondeterministic-render": noNondeterministicRender,
     "no-or-none-component": noOrNoneComponent,
+    "no-redundant-type-annotation": noRedundantTypeAnnotation,
     "no-transition-cssproperties": noTransitionCSSProperties,
     "no-unnecessary-div": noUnnecessaryDiv,
     "no-unnecessary-key": noUnnecessaryKey,

package/package.json

@@ -2,7 +2,7 @@
 	"author": "Alex Kahn",
 	"description": "ESLint plugin for AbsoluteJS",
 	"devDependencies": {
-		"@absolutejs/absolute": "0.16.10",
+		"@absolutejs/absolute": "0.19.0-beta.838",
 		"@types/bun": "1.3.3",
 		"@types/react": "19.2.14",
 		"@typescript-eslint/rule-tester": "8.56.0",
@@ -40,5 +40,5 @@
 		"typecheck": "bun run tsc --noEmit"
 	},
 	"type": "module",
-	"version": "0.7.0"
+	"version": "0.9.0"
 }