vue-hook-optimizer 0.0.58 → 0.0.60

package/dist/index.mjs

@@ -315,6 +315,108 @@ function processSetup(ast, parentScope, parentPath, _spread, _lineOffset = 0) {
       }
     }
   }, parentScope, parentPath);
+  function traverseHooks(node, patentScope) {
+    if (node.type === "ExpressionStatement" && node.expression.type === "CallExpression" && node.expression.callee.type === "Identifier" || node.type === "CallExpression" && node.callee.type === "Identifier") {
+      const hookName = (() => {
+        if (node.type === "ExpressionStatement" && node.expression.type === "CallExpression" && node.expression.callee.type === "Identifier") {
+          return node.expression.callee.name;
+        }
+        if (node.type === "CallExpression" && node.callee.type === "Identifier") {
+          return node.callee.name;
+        }
+      })() || "";
+      if (!hookName) {
+        return;
+      }
+      const hookBinding = patentScope.getBinding(hookName);
+      if (!(hookBinding === void 0 || hookBinding?.scope.block.type === "Program" || parentScope === hookBinding?.scope)) {
+        return;
+      }
+      const expression = node.type === "ExpressionStatement" ? node.expression : node;
+      const watchArgs = /* @__PURE__ */ new Set();
+      if (hookName === "provide") {
+        traverse2(expression, {
+          Identifier(path1) {
+            const binding = path1.scope.getBinding(path1.node.name);
+            if (graph.nodes.has(path1.node.name) && (path1.parent.type !== "MemberExpression" && path1.parent.type !== "OptionalMemberExpression" || path1.parent.object === path1.node) && (binding?.scope.block.type === "Program" || parentScope === binding?.scope)) {
+              const _node = nodeCollection.getNode(path1.node.name);
+              if (_node?.info?.used) {
+                _node?.info?.used?.add(hookName);
+              } else if (_node) {
+                _node.info = {
+                  ..._node?.info,
+                  used: /* @__PURE__ */ new Set([hookName])
+                };
+              }
+            }
+          }
+        }, patentScope, node);
+      } else if (hookName === "watch") {
+        if (expression.arguments[0].type === "Identifier") {
+          const binding = patentScope.getBinding(expression.arguments[0].name);
+          if (graph.nodes.has(expression.arguments[0].name) && (binding?.scope.block.type === "Program" || parentScope === binding?.scope)) {
+            watchArgs.add(expression.arguments[0]);
+          }
+        } else {
+          traverse2(expression.arguments[0], {
+            Identifier(path1) {
+              const binding = path1.scope.getBinding(path1.node.name);
+              if (graph.nodes.has(path1.node.name) && (path1.parent.type !== "MemberExpression" && path1.parent.type !== "OptionalMemberExpression" || path1.parent.object === path1.node) && (binding?.scope.block.type === "Program" || parentScope === binding?.scope)) {
+                watchArgs.add(path1.node);
+              }
+            }
+          }, patentScope, node);
+        }
+      } else if (hookName === "useEffect" && expression.arguments[1].type === "ArrayExpression") {
+        traverse2(expression.arguments[1], {
+          Identifier(path1) {
+            const binding = path1.scope.getBinding(path1.node.name);
+            if (graph.nodes.has(path1.node.name) && (path1.parent.type !== "MemberExpression" && path1.parent.type !== "OptionalMemberExpression" || path1.parent.object === path1.node) && (binding?.scope.block.type === "Program" || parentScope === binding?.scope)) {
+              watchArgs.add(path1.node);
+            }
+          }
+        }, patentScope, node);
+      }
+      expression.arguments.forEach((argNode, index) => {
+        if (hookName === "watch" && index === 0 && argNode.type === "Identifier") {
+          const _node = nodeCollection.getNode(argNode.name);
+          if (_node?.info?.used) {
+            _node?.info?.used?.add(hookName);
+          } else if (_node) {
+            _node.info = {
+              ..._node?.info,
+              used: /* @__PURE__ */ new Set([hookName])
+            };
+          }
+          return;
+        }
+        traverse2(argNode, {
+          Identifier(path1) {
+            const binding = path1.scope.getBinding(path1.node.name);
+            if (graph.nodes.has(path1.node.name) && (path1.parent.type !== "MemberExpression" && path1.parent.type !== "OptionalMemberExpression" || path1.parent.object === path1.node) && (binding?.scope.block.type === "Program" || parentScope === binding?.scope)) {
+              if (["watch", "useEffect"].includes(hookName) && watchArgs.size > 0) {
+                const watchArgsNames = Array.from(watchArgs).map((arg) => arg.name);
+                watchArgs.forEach((watchArg) => {
+                  if (!watchArgsNames.includes(path1.node.name)) {
+                    graph.edges.get(watchArg.name)?.add(path1.node.name);
+                  }
+                });
+              }
+              const _node = nodeCollection.getNode(path1.node.name);
+              if (_node?.info?.used) {
+                _node?.info?.used?.add(hookName);
+              } else if (_node) {
+                _node.info = {
+                  ..._node?.info,
+                  used: /* @__PURE__ */ new Set([hookName])
+                };
+              }
+            }
+          }
+        }, patentScope, node);
+      });
+    }
+  }
   traverse2(ast, {
     FunctionDeclaration(path) {
       const name = path.node.id?.name;
@@ -392,6 +494,9 @@ function processSetup(ast, parentScope, parentPath, _spread, _lineOffset = 0) {
           "ArrowFunctionExpression",
           "FunctionDeclaration"
         ].includes(path.node.init.type) && path.node.id.type === "Identifier") {
+          if (path.node.init.type === "CallExpression" && path.node.init.callee.type === "Identifier" && ["watch", "watchEffect"].includes(path.node.init.callee.name)) {
+            traverseHooks(path.node.init, path.scope);
+          }
           const name = path.node.id?.name;
           if (name && graph.nodes.has(name)) {
             traverse2(path.node.init, {
@@ -468,94 +573,35 @@ function processSetup(ast, parentScope, parentPath, _spread, _lineOffset = 0) {
       }
     },
     ExpressionStatement(path) {
-      if (path.node.expression.type === "CallExpression" && path.node.expression.callee.type === "Identifier") {
-        const hookName = path.node.expression.callee.name;
-        const hookBinding = path.scope.getBinding(hookName);
-        if (!(hookBinding === void 0 || hookBinding?.scope.block.type === "Program" || parentScope === hookBinding?.scope)) {
-          return;
-        }
-        const watchArgs = /* @__PURE__ */ new Set();
-        if (hookName === "provide") {
-          traverse2(path.node.expression, {
-            Identifier(path1) {
-              const binding = path1.scope.getBinding(path1.node.name);
-              if (graph.nodes.has(path1.node.name) && (path1.parent.type !== "MemberExpression" && path1.parent.type !== "OptionalMemberExpression" || path1.parent.object === path1.node) && (binding?.scope.block.type === "Program" || parentScope === binding?.scope)) {
-                const _node = nodeCollection.getNode(path1.node.name);
-                if (_node?.info?.used) {
-                  _node?.info?.used?.add(hookName);
-                } else if (_node) {
-                  _node.info = {
-                    ..._node?.info,
-                    used: /* @__PURE__ */ new Set([hookName])
-                  };
-                }
-              }
-            }
-          }, path.scope, path);
-        } else if (hookName === "watch") {
-          if (path.node.expression.arguments[0].type === "Identifier") {
-            const binding = path.scope.getBinding(path.node.expression.arguments[0].name);
-            if (graph.nodes.has(path.node.expression.arguments[0].name) && (binding?.scope.block.type === "Program" || parentScope === binding?.scope)) {
-              watchArgs.add(path.node.expression.arguments[0]);
-            }
-          } else {
-            traverse2(path.node.expression.arguments[0], {
-              Identifier(path1) {
-                const binding = path1.scope.getBinding(path1.node.name);
-                if (graph.nodes.has(path1.node.name) && (path1.parent.type !== "MemberExpression" && path1.parent.type !== "OptionalMemberExpression" || path1.parent.object === path1.node) && (binding?.scope.block.type === "Program" || parentScope === binding?.scope)) {
-                  watchArgs.add(path1.node);
-                }
-              }
-            }, path.scope, path);
+      if (path.type === "ExpressionStatement" && path.node.expression.type === "CallExpression" && path.node.expression.callee.type === "Identifier") {
+        const name = path.node.expression.callee.name;
+        if (graph.nodes.has(name) && path.scope.block.type === "Program") {
+          const _node = nodeCollection.getNode(name);
+          if (_node?.info?.used) {
+            _node?.info?.used?.add("Call Expression");
+          } else if (_node) {
+            _node.info = {
+              ..._node?.info,
+              used: /* @__PURE__ */ new Set(["Call Expression"])
+            };
           }
-        } else if (hookName === "useEffect" && path.node.expression.arguments[1].type === "ArrayExpression") {
-          traverse2(path.node.expression.arguments[1], {
-            Identifier(path1) {
-              const binding = path1.scope.getBinding(path1.node.name);
-              if (graph.nodes.has(path1.node.name) && (path1.parent.type !== "MemberExpression" && path1.parent.type !== "OptionalMemberExpression" || path1.parent.object === path1.node) && (binding?.scope.block.type === "Program" || parentScope === binding?.scope)) {
-                watchArgs.add(path1.node);
-              }
-            }
-          }, path.scope, path);
+        } else {
+          traverseHooks(path.node.expression, path.scope);
+        }
+      }
+      if (path.type === "ExpressionStatement" && path.node.expression.type === "AssignmentExpression" && path.node.expression.right.type === "CallExpression" && path.node.expression.right.callee.type === "Identifier") {
+        traverseHooks(path.node.expression.right, path.scope);
+      }
+      if (path.type === "ExpressionStatement" && path.node.expression.type === "AssignmentExpression" && path.node.expression.left.type === "Identifier" && graph.nodes.has(path.node.expression.left.name) && path.scope.block.type === "Program") {
+        const _node = nodeCollection.getNode(path.node.expression.left.name);
+        if (_node?.info?.used) {
+          _node?.info?.used?.add("Assignment Expression");
+        } else if (_node) {
+          _node.info = {
+            ..._node?.info,
+            used: /* @__PURE__ */ new Set(["Assignment Expression"])
+          };
         }
-        path.node.expression.arguments.forEach((argNode, index) => {
-          if (hookName === "watch" && index === 0 && argNode.type === "Identifier") {
-            const _node = nodeCollection.getNode(argNode.name);
-            if (_node?.info?.used) {
-              _node?.info?.used?.add(hookName);
-            } else if (_node) {
-              _node.info = {
-                ..._node?.info,
-                used: /* @__PURE__ */ new Set([hookName])
-              };
-            }
-            return;
-          }
-          traverse2(argNode, {
-            Identifier(path1) {
-              const binding = path1.scope.getBinding(path1.node.name);
-              if (graph.nodes.has(path1.node.name) && (path1.parent.type !== "MemberExpression" && path1.parent.type !== "OptionalMemberExpression" || path1.parent.object === path1.node) && (binding?.scope.block.type === "Program" || parentScope === binding?.scope)) {
-                if (["watch", "useEffect"].includes(hookName) && watchArgs.size > 0) {
-                  const watchArgsNames = Array.from(watchArgs).map((arg) => arg.name);
-                  watchArgs.forEach((watchArg) => {
-                    if (!watchArgsNames.includes(path1.node.name)) {
-                      graph.edges.get(watchArg.name)?.add(path1.node.name);
-                    }
-                  });
-                }
-                const _node = nodeCollection.getNode(path1.node.name);
-                if (_node?.info?.used) {
-                  _node?.info?.used?.add(hookName);
-                } else if (_node) {
-                  _node.info = {
-                    ..._node?.info,
-                    used: /* @__PURE__ */ new Set([hookName])
-                  };
-                }
-              }
-            }
-          }, path.scope, path);
-        });
       }
     }
   }, parentScope, parentPath);
@@ -1981,6 +2027,9 @@ function findLinearPaths(graph) {
   const visitedNodes = /* @__PURE__ */ new Set();
   const nodeInDegrees = /* @__PURE__ */ new Map();
   for (const [node, edges] of graph.entries()) {
+    if (!nodeInDegrees.has(node)) {
+      nodeInDegrees.set(node, 0);
+    }
     for (const edge of edges) {
       const inDegree = nodeInDegrees.get(edge) || 0;
       nodeInDegrees.set(edge, inDegree + 1);
@@ -2158,11 +2207,16 @@ function gen(graph, nodesUsedInTemplate, nodesUsedInStyle = /* @__PURE__ */ new
     }
     const paths = findLinearPaths(g);
     paths.forEach((path) => {
-      suggestions.push({
-        type: "warning" /* warning */,
-        message: `Nodes [${path.length > 10 ? `${path.slice(0, 10).map((node) => node.label).join(",")}...(${path.length})` : path.map((node) => node.label).join(",")}] are have function chain calls, perhaps you can refactor it.`,
-        nodeInfo: path
-      });
+      const firstUsedNodeIndex = path.findIndex((node) => usedNodes.has(node.label));
+      const reverseLastNotUsedNodeIndex = path.slice().reverse().findIndex((node) => !usedNodes.has(node.label));
+      const lastNotUsedNodeIndex = reverseLastNotUsedNodeIndex !== -1 ? path.length - 1 - reverseLastNotUsedNodeIndex : -1;
+      if (firstUsedNodeIndex > -1 && firstUsedNodeIndex < lastNotUsedNodeIndex) {
+        suggestions.push({
+          type: "warning" /* warning */,
+          message: `Nodes [${path.length > 10 ? `${path.slice(0, 10).map((node) => node.label).join(",")}...(${path.length})` : path.map((node) => node.label).join(",")}] are have function chain calls, perhaps you can refactor it.`,
+          nodeInfo: path
+        });
+      }
     });
     if (g.size > 5) {
       const ap = findArticulationPoints(g);
@@ -2191,6 +2245,13 @@ function gen(graph, nodesUsedInTemplate, nodesUsedInStyle = /* @__PURE__ */ new
 }
 
 // src/vis.ts
+function filterNodeUserd(used) {
+  const usedArray = Array.from(used || []);
+  return new Set(usedArray.filter((u) => ![
+    "Assignment Expression",
+    "Call Expression"
+  ].includes(u)));
+}
 function getVisData(graph, nodesUsedInTemplate, nodesUsedInStyle = /* @__PURE__ */ new Set()) {
   const usedNodes = /* @__PURE__ */ new Set([...nodesUsedInTemplate, ...nodesUsedInStyle]);
   const nodes = [];
@@ -2201,7 +2262,7 @@ function getVisData(graph, nodesUsedInTemplate, nodesUsedInStyle = /* @__PURE__
       label: node.label,
       shape: node.type === "var" ? "dot" : "diamond",
       group: usedNodes.has(node.label) || node.info?.used?.size ? "used" : "normal",
-      title: `${node.info?.used?.size ? `used by ${Array.from(node.info?.used || [])?.map((i) => `\`${i}\``).join(",")}
+      title: `${filterNodeUserd(node.info?.used).size ? `used by ${Array.from(filterNodeUserd(node.info?.used))?.map((i) => `\`${i}\``).join(",")}
 
 ` : ""}${usedNodes.has(node.label) ? `used in ${[
         nodesUsedInStyle.has(node.label) ? "style" : "",