pasika 0.10.21 → 0.10.23

package/dist/eslint/pasika/index.js

@@ -59,10 +59,22 @@ 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);
 }
+function namedExportedLocalNames(sourceFile) {
+  const names = /* @__PURE__ */ new Set();
+  for (const statement of sourceFile.statements) {
+    if (!ts.isExportDeclaration(statement) || statement.moduleSpecifier || !statement.exportClause) continue;
+    if (!ts.isNamedExports(statement.exportClause)) continue;
+    for (const element of statement.exportClause.elements) {
+      names.add((element.propertyName ?? element.name).text);
+    }
+  }
+  return names;
+}
 function containsJsx(node) {
   let found = false;
   const visit = (child) => {
@@ -76,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;
@@ -114,22 +168,26 @@ function componentFromVariable(node) {
   return {
     name: node.name.text,
     declaration: node,
-    smart: containsSmartCall(initializer)
+    smart: isSmartComponent(initializer)
   };
 }
 function parseComponentInfo(text, filename, options) {
   const sourceFile = ts.createSourceFile(path.resolve(filename), text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
   const components = [];
+  const namedExports = namedExportedLocalNames(sourceFile);
   for (const statement of sourceFile.statements) {
-    const exported = isExported(statement);
-    if (!exported && !options?.includeNonExported) continue;
+    const statementExported = isExported(statement);
     if (ts.isFunctionDeclaration(statement)) {
+      const name = statement.name?.text;
+      if (!options?.includeNonExported && !statementExported && (!name || !namedExports.has(name))) continue;
       const component = componentFromFunction(statement);
       if (component) components.push(component);
       continue;
     }
     if (ts.isVariableStatement(statement)) {
       for (const declaration of statement.declarationList.declarations) {
+        const name = ts.isIdentifier(declaration.name) ? declaration.name.text : void 0;
+        if (!options?.includeNonExported && !statementExported && (!name || !namedExports.has(name))) continue;
         const component = componentFromVariable(declaration);
         if (component) components.push(component);
       }

package/package.json

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