pasika 0.10.22 → 0.10.24

package/dist/eslint/pasika/index.js

@@ -59,6 +59,7 @@ import path from "path";
 import ts from "typescript";
 var isPascalCase = (name) => /^[A-Z][A-Za-z0-9]*$/.test(name);
 var isHookCallName = (name) => /^use[A-Z]/.test(name);
+var isHandlerName = (name) => /^handle[A-Z]/.test(name);
 function isExported(node) {
   if (!ts.canHaveModifiers(node)) return false;
   return (ts.getModifiers(node) ?? []).some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword);
@@ -87,35 +88,77 @@ function containsJsx(node) {
   ts.forEachChild(node, visit);
   return found;
 }
-function containsSmartCall(node) {
+function containsDataFetch(node) {
   let found = false;
   const visit = (child) => {
     if (found) return;
-    if (ts.isCallExpression(child)) {
-      const expression = child.expression;
-      let name = "";
-      if (ts.isIdentifier(expression)) {
-        name = expression.text;
-      } else if (ts.isPropertyAccessExpression(expression)) {
-        name = expression.name.text;
-      }
-      if (isHookCallName(name)) {
-        found = true;
-        return;
-      }
+    if (ts.isCallExpression(child) && ts.isIdentifier(child.expression) && child.expression.text === "zodFetch") {
+      found = true;
+      return;
     }
     ts.forEachChild(child, visit);
   };
   ts.forEachChild(node, visit);
   return found;
 }
-function isAsyncFunction(node) {
-  return (ts.getModifiers(node) ?? []).some((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword);
+function isComponentTagName(tagName2) {
+  if (ts.isIdentifier(tagName2)) return isPascalCase(tagName2.text);
+  if (ts.isPropertyAccessExpression(tagName2)) {
+    let root = tagName2.expression;
+    while (ts.isPropertyAccessExpression(root)) root = root.expression;
+    return ts.isIdentifier(root) && isPascalCase(root.text);
+  }
+  return false;
+}
+function containsOwnedHandlerProp(node) {
+  const handlerNames = /* @__PURE__ */ new Set();
+  const collectHandlers = (child) => {
+    if (ts.isVariableDeclaration(child) && ts.isIdentifier(child.name) && isHandlerName(child.name.text) && child.initializer && (ts.isArrowFunction(child.initializer) || ts.isFunctionExpression(child.initializer) || ts.isCallExpression(child.initializer) && ts.isPropertyAccessExpression(child.initializer.expression) && child.initializer.expression.name.text === "useCallback" || ts.isCallExpression(child.initializer) && ts.isIdentifier(child.initializer.expression) && child.initializer.expression.text === "useCallback")) {
+      handlerNames.add(child.name.text);
+    } else if (ts.isFunctionDeclaration(child) && child.name && isHandlerName(child.name.text)) {
+      handlerNames.add(child.name.text);
+    }
+    ts.forEachChild(child, collectHandlers);
+  };
+  ts.forEachChild(node, collectHandlers);
+  if (handlerNames.size === 0) return false;
+  let found = false;
+  const findPassedHandler = (child) => {
+    if (found) return;
+    let attributes;
+    let tagName2;
+    if (ts.isJsxElement(child)) {
+      attributes = child.openingElement.attributes;
+      tagName2 = child.openingElement.tagName;
+    } else if (ts.isJsxSelfClosingElement(child)) {
+      attributes = child.attributes;
+      tagName2 = child.tagName;
+    }
+    if (attributes && tagName2 && isComponentTagName(tagName2)) {
+      for (const property of attributes.properties) {
+        if (!ts.isJsxAttribute(property) || !ts.isIdentifier(property.name) || !/^on[A-Z]/.test(property.name.text)) {
+          continue;
+        }
+        const initializer = property.initializer;
+        if (!initializer || !ts.isJsxExpression(initializer) || !initializer.expression) continue;
+        if (ts.isIdentifier(initializer.expression) && handlerNames.has(initializer.expression.text)) {
+          found = true;
+          return;
+        }
+      }
+    }
+    ts.forEachChild(child, findPassedHandler);
+  };
+  ts.forEachChild(node, findPassedHandler);
+  return found;
+}
+function isSmartComponent(node) {
+  return containsDataFetch(node) || containsOwnedHandlerProp(node);
 }
 function componentFromFunction(node) {
   const name = node.name?.text;
   if (!name || !isPascalCase(name) || !containsJsx(node)) return void 0;
-  return { name, declaration: node, smart: containsSmartCall(node) || isAsyncFunction(node) };
+  return { name, declaration: node, smart: isSmartComponent(node) };
 }
 function componentFromVariable(node) {
   if (!ts.isIdentifier(node.name) || !isPascalCase(node.name.text)) return void 0;
@@ -125,7 +168,7 @@ function componentFromVariable(node) {
   return {
     name: node.name.text,
     declaration: node,
-    smart: containsSmartCall(initializer)
+    smart: isSmartComponent(initializer)
   };
 }
 function parseComponentInfo(text, filename, options) {
@@ -221,6 +264,86 @@ function findSimpleRoot(component, _text, _filename) {
   if (roots.some((root) => root.tagName !== firstTag)) return void 0;
   return roots[0];
 }
+function literalTestIds(attributes) {
+  return attributes.flatMap((candidate) => {
+    if (!ts.isJsxAttribute(candidate) || !ts.isIdentifier(candidate.name) || candidate.name.text !== "data-testid") {
+      return [];
+    }
+    return candidate.initializer && ts.isStringLiteral(candidate.initializer) ? [candidate.initializer.text] : [];
+  });
+}
+function combineTestIdPaths(left, right) {
+  return left.flatMap((leftPath) => right.map((rightPath) => [...leftPath, ...rightPath]));
+}
+function renderedTestIdPathsFromExpression(expression) {
+  let unwrapped = expression;
+  while (ts.isParenthesizedExpression(unwrapped)) unwrapped = unwrapped.expression;
+  if (ts.isConditionalExpression(unwrapped)) {
+    return [
+      ...renderedTestIdPathsFromExpression(unwrapped.whenTrue),
+      ...renderedTestIdPathsFromExpression(unwrapped.whenFalse)
+    ];
+  }
+  if (ts.isJsxSelfClosingElement(unwrapped)) {
+    return [literalTestIds(unwrapped.attributes.properties)];
+  }
+  if (ts.isJsxElement(unwrapped)) {
+    let paths = [literalTestIds(unwrapped.openingElement.attributes.properties)];
+    for (const child of unwrapped.children) {
+      if (ts.isJsxElement(child) || ts.isJsxSelfClosingElement(child) || ts.isJsxFragment(child)) {
+        paths = combineTestIdPaths(paths, renderedTestIdPathsFromExpression(child));
+        continue;
+      }
+      if (ts.isJsxExpression(child) && child.expression) {
+        const childExpression = child.expression;
+        if (ts.isConditionalExpression(childExpression) || ts.isJsxElement(childExpression) || ts.isJsxSelfClosingElement(childExpression) || ts.isJsxFragment(childExpression) || ts.isParenthesizedExpression(childExpression)) {
+          paths = combineTestIdPaths(paths, renderedTestIdPathsFromExpression(childExpression));
+        }
+      }
+    }
+    return paths;
+  }
+  if (ts.isJsxFragment(unwrapped)) {
+    let paths = [[]];
+    for (const child of unwrapped.children) {
+      if (ts.isJsxElement(child) || ts.isJsxSelfClosingElement(child) || ts.isJsxFragment(child)) {
+        paths = combineTestIdPaths(paths, renderedTestIdPathsFromExpression(child));
+        continue;
+      }
+      if (ts.isJsxExpression(child) && child.expression) {
+        const childExpression = child.expression;
+        if (ts.isConditionalExpression(childExpression) || ts.isJsxElement(childExpression) || ts.isJsxSelfClosingElement(childExpression) || ts.isJsxFragment(childExpression) || ts.isParenthesizedExpression(childExpression)) {
+          paths = combineTestIdPaths(paths, renderedTestIdPathsFromExpression(childExpression));
+        }
+      }
+    }
+    return paths;
+  }
+  return [[]];
+}
+function findRenderedTestIdPaths(component) {
+  const declaration = component.declaration;
+  let body;
+  if (ts.isFunctionDeclaration(declaration)) body = declaration.body;
+  else if (declaration.initializer && ts.isArrowFunction(declaration.initializer)) body = declaration.initializer.body;
+  else if (declaration.initializer && ts.isFunctionExpression(declaration.initializer)) {
+    body = declaration.initializer.body;
+  }
+  if (!body) return [];
+  if (!ts.isBlock(body)) return renderedTestIdPathsFromExpression(body);
+  const returns = [];
+  const visit = (node) => {
+    if (node !== body && (ts.isFunctionLike(node) || ts.isClassLike(node))) return;
+    if (ts.isReturnStatement(node)) returns.push(node);
+    ts.forEachChild(node, visit);
+  };
+  visit(body);
+  return returns.flatMap((statement) => {
+    const expression = statement.expression;
+    if (!expression || expression.kind === ts.SyntaxKind.NullKeyword) return [];
+    return renderedTestIdPathsFromExpression(expression);
+  });
+}
 function getTestId(root) {
   const attribute = root.attributes.find(
     (candidate) => ts.isJsxAttribute(candidate) && ts.isIdentifier(candidate.name) && candidate.name.text === "data-testid"
@@ -2150,7 +2273,6 @@ var NEXT_ROUTING_FILES2 = /* @__PURE__ */ new Set([
   "sitemap",
   "twitter-image"
 ]);
-var isPascalCase5 = (value) => /^[A-Z][A-Za-z0-9]*$/.test(value);
 var isKebabCase3 = (value) => /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(value);
 var dataTestIdCaseRule = {
   meta: {
@@ -2170,28 +2292,34 @@ var dataTestIdCaseRule = {
     return {
       Program(node) {
         for (const component of components) {
-          const root = findSimpleRoot(component, text, filename);
-          if (root) {
-            const { value } = getTestId(root);
-            const expected = component.smart ? component.name : toKebabCase(component.name);
-            if (component.smart && value === void 0) {
+          if (component.smart) {
+            const expected2 = component.name;
+            const renderedPaths = findRenderedTestIdPaths(component);
+            const hasStableAnchor = renderedPaths.length > 0 && renderedPaths.every((values) => values.filter((value2) => value2 === expected2).length === 1);
+            if (hasStableAnchor) continue;
+            const hasSingleWrongCasedAnchor = renderedPaths.length > 0 && renderedPaths.every((values) => values.length === 1 && values[0] !== expected2) && new Set(renderedPaths.map((values) => values[0])).size === 1;
+            if (hasSingleWrongCasedAnchor) {
               context.report({
                 node,
-                message: `Smart component "${component.name}" with one outer DOM element must set data-testid="${expected}".`
+                message: `data-testid for smart component "${component.name}" must be PascalCase: expected "${expected2}".`
               });
               continue;
             }
-            if (value === void 0 || value === expected) continue;
-            if (component.smart ? !isPascalCase5(value) || value !== expected : !isKebabCase3(value)) {
-              context.report({
-                node,
-                message: `data-testid for ${component.smart ? "smart" : "dumb"} component "${component.name}" must be ${component.smart ? "PascalCase" : "kebab-case"}: expected "${expected}".`
-              });
-            }
-          } else if (component.smart) {
             context.report({
               node,
-              message: `Smart component "${component.name}" has no single outer element; wrap its content in one outer element with data-testid="${component.name}" instead of rendering multiple roots. See docs/next-codebase-guide/rules/smart-vs-dumb-component-rule.md`
+              message: `Smart component "${component.name}" must expose exactly one stable data-testid="${expected2}" anchor for itself in every rendered result. Place it on the existing DOM surface or on a child component that forwards data-testid instead of adding an artificial wrapper. See docs/next-codebase-guide/rules/smart-vs-dumb-component-rule.md`
+            });
+            continue;
+          }
+          const root = findSimpleRoot(component, text, filename);
+          if (!root) continue;
+          const { value } = getTestId(root);
+          const expected = toKebabCase(component.name);
+          if (value === void 0 || value === expected) continue;
+          if (!isKebabCase3(value)) {
+            context.report({
+              node,
+              message: `data-testid for dumb component "${component.name}" must be kebab-case: expected "${expected}".`
             });
           }
         }
@@ -4794,7 +4922,7 @@ var schemaCasingRule = {
 
 // eslint/rules/component-casing.ts
 import path42 from "path";
-function isPascalCase6(name) {
+function isPascalCase5(name) {
   return /^[A-Z][A-Za-z0-9]*$/.test(name);
 }
 var componentCasingRule = {
@@ -4813,7 +4941,7 @@ var componentCasingRule = {
     return {
       Program(node) {
         for (const declaration of findJsxReturningDeclarations(context.sourceCode.text, filename)) {
-          if (isPascalCase6(declaration.name)) continue;
+          if (isPascalCase5(declaration.name)) continue;
           context.report({
             node,
             loc: { line: declaration.line, column: declaration.column },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pasika",
-  "version": "0.10.22",
+  "version": "0.10.24",
   "description": "Reusable agent setup package",
   "repository": {
     "type": "git",