pasika 0.10.23 → 0.10.25

package/dist/eslint/pasika/index.d.ts

@@ -196,6 +196,7 @@ declare const pasikaPlugin: {
         "guide-section-shape": _eslint_markdown.MarkdownRuleDefinition;
         "filename-case": eslint.Rule.RuleModule;
         "import-boundaries": eslint.Rule.RuleModule;
+        "import-spacing": eslint.Rule.RuleModule;
         "named-exports": eslint.Rule.RuleModule;
         "support-file-placement": eslint.Rule.RuleModule;
         "support-folder-shape": eslint.Rule.RuleModule;

package/dist/eslint/pasika/index.js

@@ -264,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"
@@ -507,6 +587,50 @@ var importBoundariesRule = {
   }
 };
 
+// eslint/rules/import-spacing.ts
+var MESSAGE = "Consecutive import declarations must not be separated by a blank line. See docs/next-codebase-guide/rules/exports-and-imports-rule.md";
+function hasBlankLine(text) {
+  return /\r?\n[\t ]*\r?\n/u.test(text);
+}
+function removeBlankLines(text) {
+  const newline = text.includes("\r\n") ? "\r\n" : "\n";
+  return text.replace(/(?:\r?\n[\t ]*){2,}/gu, newline);
+}
+var importSpacingRule = {
+  meta: {
+    schema: [],
+    type: "layout",
+    fixable: "whitespace",
+    docs: {
+      description: "Disallow blank lines between consecutive import declarations."
+    }
+  },
+  create(context) {
+    return {
+      Program() {
+        const statements = context.sourceCode.ast.body;
+        for (let index = 1; index < statements.length; index += 1) {
+          const previous = statements[index - 1];
+          const current = statements[index];
+          if (previous?.type !== "ImportDeclaration" || current?.type !== "ImportDeclaration") continue;
+          const previousEnd = previous.range?.[1];
+          const currentStart = current.range?.[0];
+          if (previousEnd === void 0 || currentStart === void 0) continue;
+          const gap = context.sourceCode.text.slice(previousEnd, currentStart);
+          if (!hasBlankLine(gap)) continue;
+          context.report({
+            node: current,
+            message: MESSAGE,
+            fix(fixer) {
+              return fixer.replaceTextRange([previousEnd, currentStart], removeBlankLines(gap));
+            }
+          });
+        }
+      }
+    };
+  }
+};
+
 // eslint/rules/no-mixed-concerns.ts
 var noMixedConcernsRule = {
   meta: {
@@ -2193,7 +2317,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: {
@@ -2213,28 +2336,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}".`
             });
           }
         }
@@ -4837,7 +4966,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 = {
@@ -4856,7 +4985,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 },
@@ -7643,6 +7772,7 @@ var pasikaNextjsAppRules = {
   // Framework-agnostic TypeScript rules.
   "filename-case": filenameCaseRule,
   "import-boundaries": importBoundariesRule,
+  "import-spacing": importSpacingRule,
   "named-exports": namedExportsRule,
   "support-file-placement": supportFilePlacementRule,
   "support-folder-shape": supportFolderShapeRule,

package/package.json

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