vue-hook-optimizer 0.0.84 → 0.0.85

package/dist/index.d.cts

@@ -20,6 +20,19 @@ declare enum NodeType {
 }
 type RelationType = 'get' | 'set' | 'call';
 //#endregion
+//#region src/analyze/hook.d.ts
+declare function analyzeHook(content: string, lineOffset?: number, framework?: 'vue' | 'react'): {
+  graph: {
+    nodes: Set<TypedNode>;
+    edges: Map<TypedNode, Set<{
+      node: TypedNode;
+      type: RelationType;
+    }>>;
+  };
+  nodesUsedInReturn: Set<string>;
+  hookName: string;
+}[];
+//#endregion
 //#region src/analyze/options.d.ts
 declare function analyze(content: string, lineOffset?: number, jsx?: boolean): {
   graph: {
@@ -172,10 +185,10 @@ declare function getVisData(graph: {
     node: TypedNode;
     type: RelationType;
   }>>;
-}, nodesUsedInTemplate: Set<string>, nodesUsedInStyle?: Set<string>): {
+}, nodesUsedInTemplate: Set<string>, nodesUsedInStyle?: Set<string>, usedLabel?: string): {
   nodes: CustomNode[];
   edges: Edge[];
 };
 //#endregion
-export { type Community, type CommunityResult, type NodeType, type RelationType, Suggestion, SuggestionType, type TypedNode, analyze as analyzeOptions, analyze$1 as analyzeSetupScript, analyze$2 as analyzeStyle, analyze$3 as analyzeTemplate, analyze$4 as analyzeTsx, detectCommunities, gen, generateCommunityColors, generateCommunityColorsRGBA, getMermaidText, getVisData, parse };
+export { type Community, type CommunityResult, type NodeType, type RelationType, Suggestion, SuggestionType, type TypedNode, analyzeHook, analyze as analyzeOptions, analyze$1 as analyzeSetupScript, analyze$2 as analyzeStyle, analyze$3 as analyzeTemplate, analyze$4 as analyzeTsx, detectCommunities, gen, generateCommunityColors, generateCommunityColorsRGBA, getMermaidText, getVisData, parse };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.ts

@@ -20,6 +20,19 @@ declare enum NodeType {
 }
 type RelationType = 'get' | 'set' | 'call';
 //#endregion
+//#region src/analyze/hook.d.ts
+declare function analyzeHook(content: string, lineOffset?: number, framework?: 'vue' | 'react'): {
+  graph: {
+    nodes: Set<TypedNode>;
+    edges: Map<TypedNode, Set<{
+      node: TypedNode;
+      type: RelationType;
+    }>>;
+  };
+  nodesUsedInReturn: Set<string>;
+  hookName: string;
+}[];
+//#endregion
 //#region src/analyze/options.d.ts
 declare function analyze(content: string, lineOffset?: number, jsx?: boolean): {
   graph: {
@@ -172,10 +185,10 @@ declare function getVisData(graph: {
     node: TypedNode;
     type: RelationType;
   }>>;
-}, nodesUsedInTemplate: Set<string>, nodesUsedInStyle?: Set<string>): {
+}, nodesUsedInTemplate: Set<string>, nodesUsedInStyle?: Set<string>, usedLabel?: string): {
   nodes: CustomNode[];
   edges: Edge[];
 };
 //#endregion
-export { type Community, type CommunityResult, type NodeType, type RelationType, Suggestion, SuggestionType, type TypedNode, analyze as analyzeOptions, analyze$1 as analyzeSetupScript, analyze$2 as analyzeStyle, analyze$3 as analyzeTemplate, analyze$4 as analyzeTsx, detectCommunities, gen, generateCommunityColors, generateCommunityColorsRGBA, getMermaidText, getVisData, parse };
+export { type Community, type CommunityResult, type NodeType, type RelationType, Suggestion, SuggestionType, type TypedNode, analyzeHook, analyze as analyzeOptions, analyze$1 as analyzeSetupScript, analyze$2 as analyzeStyle, analyze$3 as analyzeTemplate, analyze$4 as analyzeTsx, detectCommunities, gen, generateCommunityColors, generateCommunityColorsRGBA, getMermaidText, getVisData, parse };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -119,6 +119,408 @@ function getRelationType(path) {
 	return "get";
 }
 
+//#endregion
+//#region src/analyze/hook.ts
+const traverse$4 = _traverse.default?.default || _traverse.default || _traverse;
+const watchHooks$1 = [
+	"watch",
+	"watchArray",
+	"watchAtMost",
+	"watchDebounced",
+	"watchDeep",
+	"watchIgnorable",
+	"watchImmediate",
+	"watchOnce",
+	"watchPausable",
+	"watchThrottled",
+	"watchTriggerable",
+	"watchWithFilter"
+];
+const reactEffects = [
+	"useEffect",
+	"useLayoutEffect",
+	"useInsertionEffect",
+	"useMemo",
+	"useCallback"
+];
+const allEffectHooks = [
+	...watchHooks$1,
+	"watchEffect",
+	...reactEffects
+];
+function processHookFunction(functionPath, lineOffset = 0, externalHookName = "", framework = "vue") {
+	const nodeCollection = new NodeCollection(lineOffset);
+	const nodesUsedInReturn = /* @__PURE__ */ new Set();
+	const graph = {
+		nodes: /* @__PURE__ */ new Set(),
+		edges: /* @__PURE__ */ new Map()
+	};
+	const functionNode = functionPath.node;
+	const hookName = externalHookName || (functionNode.type === "FunctionDeclaration" && functionNode.id ? functionNode.id.name : "");
+	const bodyNode = functionNode.body;
+	if (bodyNode.type !== "BlockStatement") return {
+		graph,
+		nodeCollection,
+		nodesUsedInReturn,
+		hookName
+	};
+	const functionScope = functionPath.scope;
+	if (functionNode.params) functionNode.params.forEach((param) => {
+		if (param.type === "Identifier") {
+			graph.nodes.add(param.name);
+			nodeCollection.addNode(param.name, param, { comment: "" });
+			if (!graph.edges.get(param.name)) graph.edges.set(param.name, /* @__PURE__ */ new Set());
+		} else if (param.type === "AssignmentPattern" && param.left.type === "Identifier") {
+			graph.nodes.add(param.left.name);
+			nodeCollection.addNode(param.left.name, param.left, { comment: "" });
+			if (!graph.edges.get(param.left.name)) graph.edges.set(param.left.name, /* @__PURE__ */ new Set());
+		} else if (param.type === "ObjectPattern") param.properties.forEach((prop) => {
+			if (prop.type === "ObjectProperty" && prop.value.type === "Identifier") {
+				graph.nodes.add(prop.value.name);
+				nodeCollection.addNode(prop.value.name, prop.value, { comment: "" });
+				if (!graph.edges.get(prop.value.name)) graph.edges.set(prop.value.name, /* @__PURE__ */ new Set());
+			} else if (prop.type === "RestElement" && prop.argument.type === "Identifier") {
+				graph.nodes.add(prop.argument.name);
+				nodeCollection.addNode(prop.argument.name, prop.argument, { comment: "" });
+				if (!graph.edges.get(prop.argument.name)) graph.edges.set(prop.argument.name, /* @__PURE__ */ new Set());
+			}
+		});
+		else if (param.type === "ArrayPattern") param.elements.forEach((element) => {
+			if (element?.type === "Identifier") {
+				graph.nodes.add(element.name);
+				nodeCollection.addNode(element.name, element, { comment: "" });
+				if (!graph.edges.get(element.name)) graph.edges.set(element.name, /* @__PURE__ */ new Set());
+			}
+		});
+	});
+	traverse$4(bodyNode, {
+		VariableDeclaration(path) {
+			path.node.declarations.forEach((declaration) => {
+				if (declaration.id.type === "Identifier") {
+					const name = declaration.id.name;
+					const binding = path.scope.getBinding(name);
+					if (binding && binding.scope === functionScope) {
+						graph.nodes.add(name);
+						nodeCollection.addNode(name, declaration, { comment: getComment(path.node) });
+						if (!graph.edges.get(name)) graph.edges.set(name, /* @__PURE__ */ new Set());
+					}
+				} else if (declaration.id.type === "ObjectPattern") declaration.id.properties.forEach((property) => {
+					if (property.type === "ObjectProperty" && property.value.type === "Identifier") {
+						const name = property.value.name;
+						const binding = path.scope.getBinding(name);
+						if (binding && binding.scope === functionScope) {
+							graph.nodes.add(name);
+							nodeCollection.addNode(name, property.value, { comment: getComment(property) });
+							if (!graph.edges.get(name)) graph.edges.set(name, /* @__PURE__ */ new Set());
+						}
+					} else if (property.type === "RestElement" && property.argument.type === "Identifier") {
+						const name = property.argument.name;
+						const binding = path.scope.getBinding(name);
+						if (binding && binding.scope === functionScope) {
+							graph.nodes.add(name);
+							nodeCollection.addNode(name, property.argument, { comment: getComment(property) });
+							if (!graph.edges.get(name)) graph.edges.set(name, /* @__PURE__ */ new Set());
+						}
+					}
+				});
+				else if (declaration.id.type === "ArrayPattern") declaration.id.elements.forEach((element) => {
+					if (element?.type === "Identifier") {
+						const name = element.name;
+						const binding = path.scope.getBinding(name);
+						if (binding && binding.scope === functionScope) {
+							graph.nodes.add(name);
+							nodeCollection.addNode(name, element, { comment: getComment(path.node) });
+							if (!graph.edges.get(name)) graph.edges.set(name, /* @__PURE__ */ new Set());
+						}
+					}
+				});
+			});
+		},
+		FunctionDeclaration(path) {
+			const name = path.node.id?.name;
+			if (name) {
+				const binding = path.scope.getBinding(name);
+				if (binding && binding.scope === functionScope) {
+					graph.nodes.add(name);
+					nodeCollection.addNode(name, path.node.id, {
+						isMethod: true,
+						comment: getComment(path.node)
+					});
+					if (!graph.edges.get(name)) graph.edges.set(name, /* @__PURE__ */ new Set());
+				}
+			}
+		}
+	}, functionScope, functionPath);
+	function traverseHooks(node, parentScope) {
+		if (node.type === "ExpressionStatement" && node.expression.type === "CallExpression" && node.expression.callee.type === "Identifier" || node.type === "CallExpression" && node.callee.type === "Identifier") {
+			const hookName$1 = (() => {
+				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$1) return;
+			const hookBinding = parentScope.getBinding(hookName$1);
+			if (!(hookBinding === void 0 || hookBinding?.scope === functionScope)) return;
+			const expression = node.type === "ExpressionStatement" ? node.expression : node;
+			const watchArgs = /* @__PURE__ */ new Set();
+			if (watchHooks$1.includes(hookName$1)) {
+				if (expression.arguments[0]?.type === "Identifier") {
+					const binding = parentScope.getBinding(expression.arguments[0].name);
+					if (binding && graph.nodes.has(expression.arguments[0].name) && binding.scope === functionScope) watchArgs.add(expression.arguments[0]);
+				} else if (expression.arguments[0]) traverse$4(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 === functionScope) watchArgs.add(path1.node);
+				} }, parentScope, node);
+			}
+			expression.arguments.forEach((argNode, index) => {
+				if (watchHooks$1.includes(hookName$1) && index === 0 && argNode.type === "Identifier") {
+					const _node = nodeCollection.getNode(argNode.name);
+					if (_node?.info?.used) _node?.info?.used?.add(hookName$1);
+					else if (_node) _node.info = {
+						..._node?.info,
+						used: new Set([hookName$1])
+					};
+					return;
+				}
+				if (argNode.type === "Identifier") {
+					const binding = parentScope.getBinding(argNode.name);
+					if (binding && graph.nodes.has(argNode.name) && binding.scope === functionScope) {
+						const _node = nodeCollection.getNode(argNode.name);
+						if (_node?.info?.used) _node?.info?.used?.add(hookName$1);
+						else if (_node) _node.info = {
+							..._node?.info,
+							used: new Set([hookName$1])
+						};
+					}
+				} else traverse$4(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 === functionScope) {
+						if ([...watchHooks$1].includes(hookName$1) && 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({
+									label: path1.node.name,
+									type: getRelationType(path1)
+								});
+							});
+						}
+						const _node = nodeCollection.getNode(path1.node.name);
+						if (_node?.info?.used) _node?.info?.used?.add(hookName$1);
+						else if (_node) _node.info = {
+							..._node?.info,
+							used: new Set([hookName$1])
+						};
+					}
+				} }, parentScope, node);
+			});
+		}
+	}
+	traverse$4(bodyNode, {
+		FunctionDeclaration(path) {
+			const name = path.node.id?.name;
+			if (name && graph.nodes.has(name) && path.scope.getBinding(name)?.scope === functionScope) traverse$4(path.node.body, { 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 === functionScope) graph.edges.get(name)?.add({
+					label: path1.node.name,
+					type: getRelationType(path1)
+				});
+			} }, path.scope, path);
+		},
+		VariableDeclarator(path) {
+			if (path.node.init) {
+				if (path.node.id.type === "Identifier") {
+					const name = path.node.id.name;
+					if (name && graph.nodes.has(name) && path.scope.getBinding(name)?.scope === functionScope) {
+						if (path.node.init.type === "CallExpression" && path.node.init.callee.type === "Identifier" && allEffectHooks.includes(path.node.init.callee.name)) traverseHooks(path.node.init, path.scope);
+						traverse$4(path.node.init, { 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 === functionScope) graph.edges.get(name)?.add({
+								label: path1.node.name,
+								type: getRelationType(path1)
+							});
+						} }, path.scope, path);
+					}
+				} else if (path.node.id.type === "ObjectPattern") path.node.id.properties.forEach((property) => {
+					if (property.type === "ObjectProperty" && property.value.type === "Identifier") {
+						const name = property.value.name;
+						const isValidNode = name && graph.nodes.has(name) && path.node.init && path.scope.getBinding(name)?.scope === functionScope;
+						if (isValidNode) traverse$4(path.node.init, { 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 === functionScope) graph.edges.get(name)?.add({
+								label: path1.node.name,
+								type: getRelationType(path1)
+							});
+						} }, path.scope, path);
+					}
+				});
+				else if (path.node.id.type === "ArrayPattern") path.node.id.elements.forEach((element) => {
+					if (element?.type === "Identifier") {
+						const name = element.name;
+						const isValidNode = name && graph.nodes.has(name) && path.node.init && path.scope.getBinding(name)?.scope === functionScope;
+						if (isValidNode) traverse$4(path.node.init, { 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 === functionScope) graph.edges.get(name)?.add({
+								label: path1.node.name,
+								type: getRelationType(path1)
+							});
+						} }, path.scope, path);
+					}
+				});
+			}
+		},
+		ObjectMethod(path) {
+			if (path.node.key.type === "Identifier" && graph.nodes.has(path.node.key.name)) {
+				const name = path.node.key.name;
+				traverse$4(path.node.body, { 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 === functionScope) graph.edges.get(name)?.add({
+						label: path1.node.name,
+						type: getRelationType(path1)
+					});
+				} }, path.scope, path);
+			}
+		},
+		ObjectProperty(path) {
+			if (path.node.key.type === "Identifier" && graph.nodes.has(path.node.key.name)) {
+				const name = path.node.key.name;
+				traverse$4(path.node.value, { Identifier(path1) {
+					if (path1.node.name === name) return;
+					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 === functionScope) graph.edges.get(name)?.add({
+						label: path1.node.name,
+						type: getRelationType(path1)
+					});
+				} }, path.scope, path);
+			}
+		},
+		ExpressionStatement(path) {
+			if (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.getBinding(name)?.scope === functionScope) {
+					const _node = nodeCollection.getNode(name);
+					if (_node?.info?.used) _node?.info?.used?.add("Call Expression");
+					else if (_node) _node.info = {
+						..._node?.info,
+						used: new Set(["Call Expression"])
+					};
+				} else traverseHooks(path.node.expression, path.scope);
+			}
+			if (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);
+		}
+	}, functionScope, functionPath);
+	traverse$4(bodyNode, { ReturnStatement(path) {
+		const fnParent = path.findParent((p) => p.isFunction());
+		if (fnParent && fnParent.node !== functionNode) return;
+		if (path.node.argument?.type === "ObjectExpression") {
+			const returnNode = path.node.argument;
+			traverse$4(returnNode, {
+				ObjectProperty(path3) {
+					if (path3.parent === returnNode) {
+						if (path3.node.key.type === "Identifier" && path3.node.value.type === "Identifier") nodesUsedInReturn.add(path3.node.value.name);
+					}
+				},
+				SpreadElement(path3) {
+					if (path3.node.argument.type === "Identifier") nodesUsedInReturn.add(path3.node.argument.name);
+				}
+			}, path.scope, path);
+		} else if (path.node.argument?.type === "ArrayExpression") path.node.argument.elements.forEach((element) => {
+			if (element?.type === "Identifier") nodesUsedInReturn.add(element.name);
+		});
+		else if (path.node.argument?.type === "Identifier") nodesUsedInReturn.add(path.node.argument.name);
+	} }, functionScope, functionPath);
+	return {
+		graph,
+		nodeCollection,
+		nodesUsedInReturn,
+		hookName
+	};
+}
+function analyzeHook(content, lineOffset = 0, framework = "vue") {
+	const ast = babelParse(content, {
+		sourceType: "module",
+		plugins: ["typescript", "jsx"]
+	});
+	const results = [];
+	function walkCallExpressionChain(node, path, pathSegments) {
+		if (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") try {
+			return path.get(pathSegments.join("."));
+		} catch {
+			return void 0;
+		}
+		if (node.type === "CallExpression") for (let i = 0; i < node.arguments.length; i++) {
+			const arg = node.arguments[i];
+			if (arg.type === "ArrowFunctionExpression" || arg.type === "FunctionExpression") try {
+				return path.get([
+					...pathSegments,
+					"arguments",
+					i
+				].join("."));
+			} catch {}
+			else if (arg.type === "CallExpression") {
+				const result = walkCallExpressionChain(arg, path, [
+					...pathSegments,
+					"arguments",
+					i
+				]);
+				if (result) return result;
+			}
+		}
+		return void 0;
+	}
+	function extractHookFromDeclarator(decl, varPath) {
+		const init = decl.init;
+		const hookName = decl.id.type === "Identifier" ? decl.id.name : "";
+		if (!init) return;
+		const funcPath = walkCallExpressionChain(init, varPath, ["init"]);
+		if (funcPath) results.push(processHookFunction(funcPath, lineOffset, hookName, framework));
+	}
+	traverse$4(ast, {
+		ExportDefaultDeclaration(path) {
+			const declaration = path.node.declaration;
+			if (declaration.type === "FunctionDeclaration" && declaration.id?.name.startsWith("use")) {
+				const funcPath = path.get("declaration");
+				results.push(processHookFunction(funcPath, lineOffset, "", framework));
+			}
+		},
+		ExportNamedDeclaration(path) {
+			const declaration = path.node.declaration;
+			if (declaration?.type === "FunctionDeclaration" && declaration.id?.name.startsWith("use")) {
+				const funcPath = path.get("declaration");
+				results.push(processHookFunction(funcPath, lineOffset, "", framework));
+			} else if (declaration?.type === "VariableDeclaration") declaration.declarations.forEach((decl) => {
+				if (decl.id.type === "Identifier" && decl.id.name.startsWith("use")) {
+					const varPath = path.get("declaration.declarations").find((p) => {
+						const node = p.node;
+						const nodeId = node.id;
+						return nodeId.type === "Identifier" && nodeId.name === decl.id.name;
+					});
+					if (varPath) extractHookFromDeclarator(decl, varPath);
+				}
+			});
+		},
+		FunctionDeclaration(path) {
+			if (path.node.id?.name.startsWith("use") && path.parent.type === "Program") results.push(processHookFunction(path, lineOffset, "", framework));
+		},
+		VariableDeclaration(path) {
+			if (path.parent.type === "Program") path.node.declarations.forEach((decl) => {
+				if (decl.id.type === "Identifier" && decl.id.name.startsWith("use")) {
+					const declName = decl.id.name;
+					const varPath = path.get("declarations").find((p) => {
+						const node = p.node;
+						const nodeId = node.id;
+						return nodeId.type === "Identifier" && nodeId.name === declName;
+					});
+					if (varPath) extractHookFromDeclarator(decl, varPath);
+				}
+			});
+		}
+	});
+	return results.map((result) => ({
+		graph: result.nodeCollection.map(result.graph),
+		nodesUsedInReturn: result.nodesUsedInReturn,
+		hookName: result.hookName
+	}));
+}
+
 //#endregion
 //#region src/analyze/setupScript.ts
 const traverse$3 = _traverse.default?.default || _traverse.default || _traverse;
@@ -2304,7 +2706,7 @@ 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()) {
+function getVisData(graph, nodesUsedInTemplate, nodesUsedInStyle = /* @__PURE__ */ new Set(), usedLabel) {
 	const usedNodes = new Set([...nodesUsedInTemplate, ...nodesUsedInStyle]);
 	const nodes = [];
 	const edges = [];
@@ -2327,7 +2729,7 @@ function getVisData(graph, nodesUsedInTemplate, nodesUsedInStyle = /* @__PURE__
 			shape: node.type === "var" ? "dot" : "diamond",
 			group: usedNodes.has(node.label) || node.info?.used?.size ? "used" : "normal",
 			size: 20 + 1.6 ** (inDegree * .75 + outDegree * .25),
-			title: `${filterNodeUserd(node.info?.used).size ? `used by ${Array.from(filterNodeUserd(node.info?.used))?.map((i) => `\`${i}\``).join(",")}\n\n` : ""}${usedNodes.has(node.label) ? `used in ${[nodesUsedInStyle.has(node.label) ? "style" : "", nodesUsedInTemplate.has(node.label) ? "template" : ""].filter(Boolean).join(" and ")}\n\n` : ""}${node.info?.comment || ""}`.trim() || void 0,
+			title: `${filterNodeUserd(node.info?.used).size ? `used by ${Array.from(filterNodeUserd(node.info?.used))?.map((i) => `\`${i}\``).join(",")}\n\n` : ""}${usedNodes.has(node.label) ? `used in ${[nodesUsedInStyle.has(node.label) ? "style" : "", nodesUsedInTemplate.has(node.label) ? usedLabel || "template" : ""].filter(Boolean).join(" and ")}\n\n` : ""}${node.info?.comment || ""}`.trim() || void 0,
 			info: node.info
 		});
 	});
@@ -2351,5 +2753,5 @@ function getVisData(graph, nodesUsedInTemplate, nodesUsedInStyle = /* @__PURE__
 }
 
 //#endregion
-export { SuggestionType, analyze as analyzeOptions, analyze$1 as analyzeSetupScript, analyze$2 as analyzeStyle, analyze$3 as analyzeTemplate, analyze$4 as analyzeTsx, detectCommunities, gen, generateCommunityColors, generateCommunityColorsRGBA, getMermaidText, getVisData, parse };
+export { SuggestionType, analyzeHook, analyze as analyzeOptions, analyze$1 as analyzeSetupScript, analyze$2 as analyzeStyle, analyze$3 as analyzeTemplate, analyze$4 as analyzeTsx, detectCommunities, gen, generateCommunityColors, generateCommunityColorsRGBA, getMermaidText, getVisData, parse };
 //# sourceMappingURL=index.js.map