@fairfox/polly 0.2.1 → 0.3.1

package/dist/vendor/verify/src/cli.js

@@ -727,10 +727,12 @@ import { Project, SyntaxKind, Node } from "ts-morph";
 
 class HandlerExtractor {
   project;
+  typeGuardCache;
   constructor(tsConfigPath) {
     this.project = new Project({
       tsConfigFilePath: tsConfigPath
     });
+    this.typeGuardCache = new WeakMap;
   }
   extractHandlers() {
     const handlers = [];
@@ -757,7 +759,7 @@ class HandlerExtractor {
         const expression = node.getExpression();
         if (Node.isPropertyAccessExpression(expression)) {
           const methodName = expression.getName();
-          if (methodName === "on") {
+          if (methodName === "on" || methodName === "addEventListener") {
             const handler = this.extractHandler(node, context, filePath);
             if (handler) {
               handlers.push(handler);
@@ -765,6 +767,18 @@ class HandlerExtractor {
           }
         }
       }
+      if (Node.isSwitchStatement(node)) {
+        const switchHandlers = this.extractSwitchCaseHandlers(node, context, filePath);
+        handlers.push(...switchHandlers);
+      }
+      if (Node.isVariableDeclaration(node)) {
+        const mapHandlers = this.extractHandlerMapPattern(node, context, filePath);
+        handlers.push(...mapHandlers);
+      }
+      if (Node.isIfStatement(node)) {
+        const typeGuardHandlers = this.extractTypeGuardHandlers(node, context, filePath);
+        handlers.push(...typeGuardHandlers);
+      }
     });
     return handlers;
   }
@@ -906,6 +920,182 @@ class HandlerExtractor {
     }
     return;
   }
+  extractSwitchCaseHandlers(switchNode, context, filePath) {
+    const handlers = [];
+    try {
+      const expression = switchNode.getExpression();
+      const expressionText = expression.getText();
+      if (!/\.(type|kind|event|action)/.test(expressionText)) {
+        return handlers;
+      }
+      const caseClauses = switchNode.getClauses();
+      for (const clause of caseClauses) {
+        if (Node.isCaseClause(clause)) {
+          const caseExpr = clause.getExpression();
+          let messageType = null;
+          if (Node.isStringLiteral(caseExpr)) {
+            messageType = caseExpr.getLiteralValue();
+          }
+          if (messageType) {
+            const line = clause.getStartLineNumber();
+            handlers.push({
+              messageType,
+              node: context,
+              assignments: [],
+              preconditions: [],
+              postconditions: [],
+              location: { file: filePath, line }
+            });
+          }
+        }
+      }
+    } catch (error) {}
+    return handlers;
+  }
+  extractHandlerMapPattern(varDecl, context, filePath) {
+    const handlers = [];
+    try {
+      const initializer = varDecl.getInitializer();
+      if (!initializer || !Node.isObjectLiteralExpression(initializer)) {
+        return handlers;
+      }
+      const varName = varDecl.getName().toLowerCase();
+      if (!/(handler|listener|callback|event)s?/.test(varName)) {
+        return handlers;
+      }
+      const properties = initializer.getProperties();
+      for (const prop of properties) {
+        if (Node.isPropertyAssignment(prop)) {
+          const nameNode = prop.getNameNode();
+          let messageType = null;
+          if (Node.isStringLiteral(nameNode)) {
+            messageType = nameNode.getLiteralValue();
+          } else if (Node.isIdentifier(nameNode)) {
+            messageType = nameNode.getText();
+          }
+          if (messageType) {
+            const line = prop.getStartLineNumber();
+            handlers.push({
+              messageType,
+              node: context,
+              assignments: [],
+              preconditions: [],
+              postconditions: [],
+              location: { file: filePath, line }
+            });
+          }
+        }
+      }
+    } catch (error) {}
+    return handlers;
+  }
+  extractTypeGuardHandlers(ifNode, context, filePath) {
+    const handlers = [];
+    try {
+      const sourceFile = ifNode.getSourceFile();
+      let typeGuards = this.typeGuardCache.get(sourceFile);
+      if (!typeGuards) {
+        typeGuards = this.findTypePredicateFunctions(sourceFile);
+        this.typeGuardCache.set(sourceFile, typeGuards);
+      }
+      if (typeGuards.size === 0) {
+        return handlers;
+      }
+      let currentIf = ifNode;
+      while (currentIf) {
+        const handler = this.extractHandlerFromIfClause(currentIf, typeGuards, context, filePath);
+        if (handler) {
+          handlers.push(handler);
+        }
+        const elseStatement = currentIf.getElseStatement();
+        if (elseStatement && Node.isIfStatement(elseStatement)) {
+          currentIf = elseStatement;
+        } else {
+          break;
+        }
+      }
+    } catch (error) {}
+    return handlers;
+  }
+  extractHandlerFromIfClause(ifNode, typeGuards, context, filePath) {
+    try {
+      const condition = ifNode.getExpression();
+      if (!Node.isCallExpression(condition)) {
+        return null;
+      }
+      const funcExpr = condition.getExpression();
+      let funcName;
+      if (Node.isIdentifier(funcExpr)) {
+        funcName = funcExpr.getText();
+      }
+      if (!funcName || !typeGuards.has(funcName)) {
+        return null;
+      }
+      const messageType = typeGuards.get(funcName);
+      const line = ifNode.getStartLineNumber();
+      return {
+        messageType,
+        node: context,
+        assignments: [],
+        preconditions: [],
+        postconditions: [],
+        location: { file: filePath, line }
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+  findTypePredicateFunctions(sourceFile) {
+    const typeGuards = new Map;
+    sourceFile.forEachDescendant((node) => {
+      if (Node.isFunctionDeclaration(node) || Node.isFunctionExpression(node) || Node.isArrowFunction(node)) {
+        const returnType = node.getReturnType();
+        const returnTypeText = returnType.getText();
+        if (/is\s+\w+/.test(returnTypeText)) {
+          let functionName;
+          if (Node.isFunctionDeclaration(node)) {
+            functionName = node.getName();
+          } else if (Node.isFunctionExpression(node)) {
+            const parent = node.getParent();
+            if (Node.isVariableDeclaration(parent)) {
+              functionName = parent.getName();
+            }
+          } else if (Node.isArrowFunction(node)) {
+            const parent = node.getParent();
+            if (Node.isVariableDeclaration(parent)) {
+              functionName = parent.getName();
+            }
+          }
+          if (functionName) {
+            let messageType = null;
+            const typeMatch = returnTypeText.match(/is\s+(\w+)/);
+            if (typeMatch) {
+              const typeName = typeMatch[1];
+              messageType = this.extractMessageTypeFromTypeName(typeName);
+            }
+            if (!messageType) {
+              const body = node.getBody();
+              if (body) {
+                const bodyText = body.getText();
+                const typeValueMatch = bodyText.match(/\.type\s*===?\s*['"](\w+)['"]/);
+                if (typeValueMatch) {
+                  messageType = typeValueMatch[1];
+                }
+              }
+            }
+            if (messageType) {
+              typeGuards.set(functionName, messageType);
+            }
+          }
+        }
+      }
+    });
+    return typeGuards;
+  }
+  extractMessageTypeFromTypeName(typeName) {
+    const messageType = typeName.replace(/Message$/, "").replace(/Event$/, "").replace(/Request$/, "").replace(/Command$/, "").replace(/Query$/, "").toLowerCase();
+    return messageType;
+  }
   inferContext(filePath) {
     const path = filePath.toLowerCase();
     if (path.includes("/background/") || path.includes("\\background\\")) {
@@ -926,6 +1116,15 @@ class HandlerExtractor {
     if (path.includes("/offscreen/") || path.includes("\\offscreen\\")) {
       return "offscreen";
     }
+    if (path.includes("/server/") || path.includes("\\server\\") || path.includes("/server.")) {
+      return "server";
+    }
+    if (path.includes("/client/") || path.includes("\\client\\") || path.includes("/client.")) {
+      return "client";
+    }
+    if (path.includes("/worker/") || path.includes("\\worker\\") || path.includes("service-worker")) {
+      return "worker";
+    }
     return "unknown";
   }
 }
@@ -2089,4 +2288,4 @@ Stack trace:`, COLORS.gray));
   process.exit(1);
 });
 
-//# debugId=F6E692DF29A2A67064756E2164756E21
+//# debugId=5E943FE5FB56B58764756E2164756E21