eslint-plugin-sweepit 0.0.1 → 0.0.2

package/dist/index.cjs

@@ -1470,6 +1470,13 @@ var rule13 = {
 var no_object_props_default = rule13;
 
 // src/rules/no-array-props.ts
+function getTypeName(node) {
+  if (!node) return null;
+  const typedNode = node;
+  if (typedNode.type === "Identifier" && typedNode.name) return typedNode.name;
+  if (typedNode.type === "TSQualifiedName" && typedNode.right?.name) return typedNode.right.name;
+  return null;
+}
 var rule14 = {
   meta: {
     type: "suggestion",
@@ -1486,12 +1493,56 @@ var rule14 = {
     const parserServices = context.sourceCode.parserServices ?? context.parserServices;
     const checker = parserServices?.program?.getTypeChecker();
     const hasTypeInformation = Boolean(checker && parserServices?.esTreeNodeToTSNodeMap);
+    const arrayTypedIdentifiers = /* @__PURE__ */ new Set();
+    const arrayReturningFunctions = /* @__PURE__ */ new Set();
+    const localTypeAliases = /* @__PURE__ */ new Map();
+    function isArrayLikeTypeText(typeText) {
+      return typeText.endsWith("[]") || typeText.startsWith("readonly ") || typeText.startsWith("Array<") || typeText.startsWith("ReadonlyArray<") || typeText.startsWith("[") || typeText.startsWith("readonly [");
+    }
+    function isArrayLikeTypeNode(typeNode, seenAliases) {
+      if (!typeNode) return false;
+      const typedNode = typeNode;
+      if (typedNode.type === "TSArrayType" || typedNode.type === "TSTupleType") return true;
+      if (typedNode.type === "TSParenthesizedType" || typedNode.type === "TSOptionalType") {
+        return isArrayLikeTypeNode(typedNode.typeAnnotation, seenAliases);
+      }
+      if (typedNode.type === "TSTypeOperator") {
+        return isArrayLikeTypeNode(typedNode.typeAnnotation, seenAliases);
+      }
+      if (typedNode.type === "TSUnionType" || typedNode.type === "TSIntersectionType") {
+        return (typedNode.types ?? []).some((entry) => isArrayLikeTypeNode(entry, seenAliases));
+      }
+      if (typedNode.type === "TSTypeReference") {
+        const typeName = getTypeName(typedNode.typeName);
+        if (!typeName) return false;
+        if (typeName === "Array" || typeName === "ReadonlyArray") return true;
+        if (seenAliases.has(typeName)) return false;
+        const aliasType = localTypeAliases.get(typeName);
+        if (!aliasType) return false;
+        const nextSeenAliases = new Set(seenAliases);
+        nextSeenAliases.add(typeName);
+        return isArrayLikeTypeNode(aliasType, nextSeenAliases);
+      }
+      return false;
+    }
+    function expressionHasArrayShapeByAst(expression) {
+      const typedExpression = expression;
+      if (typedExpression.type === "Identifier" && typedExpression.name) {
+        return arrayTypedIdentifiers.has(typedExpression.name);
+      }
+      if (typedExpression.type === "CallExpression" && typedExpression.callee) {
+        const callee = typedExpression.callee;
+        return callee.type === "Identifier" && Boolean(callee.name && arrayReturningFunctions.has(callee.name));
+      }
+      return false;
+    }
     function isDisallowedArrayType(type) {
       if (!type || !checker) return false;
       if (type.isUnionOrIntersection()) {
         return type.types.some((entry) => isDisallowedArrayType(entry));
       }
-      return checker.isArrayType(type) || checker.isTupleType(type);
+      if (checker.isArrayType(type) || checker.isTupleType(type)) return true;
+      return isArrayLikeTypeText(checker.typeToString(type));
     }
     function expressionHasArrayType(expression) {
       if (!hasTypeInformation || !checker || !parserServices?.esTreeNodeToTSNodeMap) return false;
@@ -1500,6 +1551,46 @@ var rule14 = {
       return isDisallowedArrayType(checker.getTypeAtLocation(tsNode));
     }
     return {
+      TSTypeAliasDeclaration(node) {
+        const declaration = node;
+        if (!declaration.id || declaration.id.type !== "Identifier" || !declaration.id.name) return;
+        if (!declaration.typeAnnotation) return;
+        localTypeAliases.set(declaration.id.name, declaration.typeAnnotation);
+      },
+      VariableDeclarator(node) {
+        const declaration = node;
+        if (!declaration.id || declaration.id.type !== "Identifier") return;
+        const id = declaration.id;
+        const variableName = id.name;
+        if (!variableName) return;
+        if (isArrayLikeTypeNode(id.typeAnnotation?.typeAnnotation, /* @__PURE__ */ new Set())) {
+          arrayTypedIdentifiers.add(variableName);
+        }
+        if (declaration.init?.type === "ArrayExpression") {
+          arrayTypedIdentifiers.add(variableName);
+        }
+        if (declaration.init && (declaration.init.type === "ArrowFunctionExpression" || declaration.init.type === "FunctionExpression")) {
+          const functionExpression = declaration.init;
+          if (isArrayLikeTypeNode(functionExpression.returnType?.typeAnnotation, /* @__PURE__ */ new Set())) {
+            arrayReturningFunctions.add(variableName);
+          }
+          if (functionExpression.body?.type === "ArrayExpression") {
+            arrayReturningFunctions.add(variableName);
+          }
+        }
+      },
+      FunctionDeclaration(node) {
+        const declaration = node;
+        if (!declaration.id || declaration.id.type !== "Identifier" || !declaration.id.name) return;
+        const functionName = declaration.id.name;
+        if (isArrayLikeTypeNode(declaration.returnType?.typeAnnotation, /* @__PURE__ */ new Set())) {
+          arrayReturningFunctions.add(functionName);
+        }
+        const firstStatement = declaration.body?.body?.[0];
+        if (firstStatement?.type === "ReturnStatement" && firstStatement.argument?.type === "ArrayExpression") {
+          arrayReturningFunctions.add(functionName);
+        }
+      },
       JSXAttribute(node) {
         const attr = node;
         if (attr.name?.type !== "JSXIdentifier" || !attr.name.name) return;
@@ -1508,7 +1599,8 @@ var rule14 = {
         if (!expression) return;
         const isInlineArray = expression.type === "ArrayExpression";
         const isArrayTyped = expressionHasArrayType(expression);
-        if (!isInlineArray && !isArrayTyped) return;
+        const isArrayShapeByAst = expressionHasArrayShapeByAst(expression);
+        if (!isInlineArray && !isArrayTyped && !isArrayShapeByAst) return;
         context.report({
           node: attr.value,
           messageId: "noArrayProps",

package/dist/index.js

@@ -1433,6 +1433,13 @@ var rule13 = {
 var no_object_props_default = rule13;
 
 // src/rules/no-array-props.ts
+function getTypeName(node) {
+  if (!node) return null;
+  const typedNode = node;
+  if (typedNode.type === "Identifier" && typedNode.name) return typedNode.name;
+  if (typedNode.type === "TSQualifiedName" && typedNode.right?.name) return typedNode.right.name;
+  return null;
+}
 var rule14 = {
   meta: {
     type: "suggestion",
@@ -1449,12 +1456,56 @@ var rule14 = {
     const parserServices = context.sourceCode.parserServices ?? context.parserServices;
     const checker = parserServices?.program?.getTypeChecker();
     const hasTypeInformation = Boolean(checker && parserServices?.esTreeNodeToTSNodeMap);
+    const arrayTypedIdentifiers = /* @__PURE__ */ new Set();
+    const arrayReturningFunctions = /* @__PURE__ */ new Set();
+    const localTypeAliases = /* @__PURE__ */ new Map();
+    function isArrayLikeTypeText(typeText) {
+      return typeText.endsWith("[]") || typeText.startsWith("readonly ") || typeText.startsWith("Array<") || typeText.startsWith("ReadonlyArray<") || typeText.startsWith("[") || typeText.startsWith("readonly [");
+    }
+    function isArrayLikeTypeNode(typeNode, seenAliases) {
+      if (!typeNode) return false;
+      const typedNode = typeNode;
+      if (typedNode.type === "TSArrayType" || typedNode.type === "TSTupleType") return true;
+      if (typedNode.type === "TSParenthesizedType" || typedNode.type === "TSOptionalType") {
+        return isArrayLikeTypeNode(typedNode.typeAnnotation, seenAliases);
+      }
+      if (typedNode.type === "TSTypeOperator") {
+        return isArrayLikeTypeNode(typedNode.typeAnnotation, seenAliases);
+      }
+      if (typedNode.type === "TSUnionType" || typedNode.type === "TSIntersectionType") {
+        return (typedNode.types ?? []).some((entry) => isArrayLikeTypeNode(entry, seenAliases));
+      }
+      if (typedNode.type === "TSTypeReference") {
+        const typeName = getTypeName(typedNode.typeName);
+        if (!typeName) return false;
+        if (typeName === "Array" || typeName === "ReadonlyArray") return true;
+        if (seenAliases.has(typeName)) return false;
+        const aliasType = localTypeAliases.get(typeName);
+        if (!aliasType) return false;
+        const nextSeenAliases = new Set(seenAliases);
+        nextSeenAliases.add(typeName);
+        return isArrayLikeTypeNode(aliasType, nextSeenAliases);
+      }
+      return false;
+    }
+    function expressionHasArrayShapeByAst(expression) {
+      const typedExpression = expression;
+      if (typedExpression.type === "Identifier" && typedExpression.name) {
+        return arrayTypedIdentifiers.has(typedExpression.name);
+      }
+      if (typedExpression.type === "CallExpression" && typedExpression.callee) {
+        const callee = typedExpression.callee;
+        return callee.type === "Identifier" && Boolean(callee.name && arrayReturningFunctions.has(callee.name));
+      }
+      return false;
+    }
     function isDisallowedArrayType(type) {
       if (!type || !checker) return false;
       if (type.isUnionOrIntersection()) {
         return type.types.some((entry) => isDisallowedArrayType(entry));
       }
-      return checker.isArrayType(type) || checker.isTupleType(type);
+      if (checker.isArrayType(type) || checker.isTupleType(type)) return true;
+      return isArrayLikeTypeText(checker.typeToString(type));
     }
     function expressionHasArrayType(expression) {
       if (!hasTypeInformation || !checker || !parserServices?.esTreeNodeToTSNodeMap) return false;
@@ -1463,6 +1514,46 @@ var rule14 = {
       return isDisallowedArrayType(checker.getTypeAtLocation(tsNode));
     }
     return {
+      TSTypeAliasDeclaration(node) {
+        const declaration = node;
+        if (!declaration.id || declaration.id.type !== "Identifier" || !declaration.id.name) return;
+        if (!declaration.typeAnnotation) return;
+        localTypeAliases.set(declaration.id.name, declaration.typeAnnotation);
+      },
+      VariableDeclarator(node) {
+        const declaration = node;
+        if (!declaration.id || declaration.id.type !== "Identifier") return;
+        const id = declaration.id;
+        const variableName = id.name;
+        if (!variableName) return;
+        if (isArrayLikeTypeNode(id.typeAnnotation?.typeAnnotation, /* @__PURE__ */ new Set())) {
+          arrayTypedIdentifiers.add(variableName);
+        }
+        if (declaration.init?.type === "ArrayExpression") {
+          arrayTypedIdentifiers.add(variableName);
+        }
+        if (declaration.init && (declaration.init.type === "ArrowFunctionExpression" || declaration.init.type === "FunctionExpression")) {
+          const functionExpression = declaration.init;
+          if (isArrayLikeTypeNode(functionExpression.returnType?.typeAnnotation, /* @__PURE__ */ new Set())) {
+            arrayReturningFunctions.add(variableName);
+          }
+          if (functionExpression.body?.type === "ArrayExpression") {
+            arrayReturningFunctions.add(variableName);
+          }
+        }
+      },
+      FunctionDeclaration(node) {
+        const declaration = node;
+        if (!declaration.id || declaration.id.type !== "Identifier" || !declaration.id.name) return;
+        const functionName = declaration.id.name;
+        if (isArrayLikeTypeNode(declaration.returnType?.typeAnnotation, /* @__PURE__ */ new Set())) {
+          arrayReturningFunctions.add(functionName);
+        }
+        const firstStatement = declaration.body?.body?.[0];
+        if (firstStatement?.type === "ReturnStatement" && firstStatement.argument?.type === "ArrayExpression") {
+          arrayReturningFunctions.add(functionName);
+        }
+      },
       JSXAttribute(node) {
         const attr = node;
         if (attr.name?.type !== "JSXIdentifier" || !attr.name.name) return;
@@ -1471,7 +1562,8 @@ var rule14 = {
         if (!expression) return;
         const isInlineArray = expression.type === "ArrayExpression";
         const isArrayTyped = expressionHasArrayType(expression);
-        if (!isInlineArray && !isArrayTyped) return;
+        const isArrayShapeByAst = expressionHasArrayShapeByAst(expression);
+        if (!isInlineArray && !isArrayTyped && !isArrayShapeByAst) return;
         context.report({
           node: attr.value,
           messageId: "noArrayProps",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-sweepit",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Opinionated architectural lint rules for Sweepit.",
   "license": "MIT",
   "type": "module",
@@ -41,5 +41,5 @@
     "typescript": "^5.9.2",
     "vitest": "^2.1.3"
   },
-  "gitHead": "4a0400e88020f7a562a8cae4830fc80c036f92a1"
+  "gitHead": "dd608ba9ac91b2eef9f7319d707b44ee352036cc"
 }