vue-hook-optimizer 0.0.82 → 0.0.83

package/dist/index.cjs

@@ -1691,17 +1691,170 @@ function getMermaidText(graph, nodesUsedInTemplate, nodesUsedInStyle = /* @__PUR
 
 //#endregion
 //#region src/suggest/community.ts
-function buildUndirectedGraph(graph) {
-	const undirected = /* @__PURE__ */ new Map();
+const COMMON_PREFIXES = [
+	"handle",
+	"on",
+	"is",
+	"has",
+	"can",
+	"should",
+	"get",
+	"set",
+	"update",
+	"toggle",
+	"reset",
+	"clear",
+	"init",
+	"fetch",
+	"load",
+	"save",
+	"delete",
+	"remove",
+	"add",
+	"create",
+	"show",
+	"hide",
+	"open",
+	"close",
+	"enable",
+	"disable",
+	"validate",
+	"check",
+	"use"
+];
+const COMMON_SUFFIXES = [
+	"change",
+	"changed",
+	"handler",
+	"callback",
+	"listener",
+	"state",
+	"value",
+	"data",
+	"list",
+	"items",
+	"count",
+	"index",
+	"id",
+	"name",
+	"type",
+	"status",
+	"error",
+	"loading",
+	"visible",
+	"disabled",
+	"enabled",
+	"active",
+	"selected",
+	"checked",
+	"open",
+	"closed"
+];
+/**
+* Extract the base/root word from an identifier by removing common prefixes/suffixes.
+* Only removes prefixes at the start and suffixes at the end.
+* e.g., "handleOpenChange" -> ["open"]
+*       "isVisible" -> ["visible"]
+*       "userName" -> ["user", "name"]
+*/
+function extractBaseWords(identifier) {
+	const tokens = identifier.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").toLowerCase().split(/[_\-\s]+/).filter(Boolean);
+	if (tokens.length === 0) return [];
+	if (tokens.length === 1) return tokens;
+	let start = 0;
+	if (COMMON_PREFIXES.includes(tokens[0])) start = 1;
+	let end = tokens.length;
+	if (COMMON_SUFFIXES.includes(tokens[tokens.length - 1])) end = tokens.length - 1;
+	const words = tokens.slice(start, end);
+	if (words.length === 0) return tokens.slice(start > 0 ? start : 0);
+	return words;
+}
+/**
+* Calculate semantic similarity using cached base words.
+* Returns a value between 0 and 1.
+*/
+function calculateSemanticSimilarityCached(labelA, labelB, wordsA, wordsB) {
+	if (labelA === labelB) return 1;
+	const lowerA = labelA.toLowerCase();
+	const lowerB = labelB.toLowerCase();
+	if (lowerA.includes(lowerB) || lowerB.includes(lowerA)) {
+		const shorter = lowerA.length < lowerB.length ? lowerA : lowerB;
+		const longer = lowerA.length < lowerB.length ? lowerB : lowerA;
+		return shorter.length / longer.length;
+	}
+	if (wordsA.length === 0 || wordsB.length === 0) return 0;
+	const setA = new Set(wordsA);
+	const setB = new Set(wordsB);
+	let sharedCount = 0;
+	for (const word of setA) if (setB.has(word)) sharedCount++;
+	if (sharedCount === 0) return 0;
+	return sharedCount / (setA.size + setB.size - sharedCount);
+}
+/**
+* Build a weighted graph that combines structural connections with semantic similarity.
+*
+* Optimized algorithm:
+* 1. Cache extractBaseWords results to avoid repeated computation
+* 2. Build word-to-nodes bucket map, only compare nodes within same bucket
+*    This reduces O(N²) to O(B × K²) where B = number of buckets, K = avg nodes per bucket
+*/
+function buildWeightedGraph(graph, options = {}) {
+	const { semanticWeight = 1, similarityThreshold = .3 } = options;
+	const weighted = /* @__PURE__ */ new Map();
+	const allNodes = /* @__PURE__ */ new Set();
+	const connectedPairs = /* @__PURE__ */ new Set();
 	for (const [node, edges] of graph) {
-		if (!undirected.has(node)) undirected.set(node, /* @__PURE__ */ new Set());
-		for (const edge of edges) {
-			undirected.get(node).add(edge.node);
-			if (!undirected.has(edge.node)) undirected.set(edge.node, /* @__PURE__ */ new Set());
-			undirected.get(edge.node).add(node);
+		allNodes.add(node);
+		for (const edge of edges) allNodes.add(edge.node);
+	}
+	for (const node of allNodes) weighted.set(node, /* @__PURE__ */ new Map());
+	const structuralWeight = .85;
+	for (const [node, edges] of graph) for (const edge of edges) {
+		const currentWeight = weighted.get(node).get(edge.node) || 0;
+		weighted.get(node).set(edge.node, Math.max(currentWeight, structuralWeight));
+		const reverseWeight = weighted.get(edge.node).get(node) || 0;
+		weighted.get(edge.node).set(node, Math.max(reverseWeight, structuralWeight));
+		const pairKey = [node.label, edge.node.label].sort().join("|");
+		connectedPairs.add(pairKey);
+	}
+	if (semanticWeight > 0) {
+		const nodeWordsCache = /* @__PURE__ */ new Map();
+		const wordToBucket = /* @__PURE__ */ new Map();
+		for (const node of allNodes) {
+			const words = extractBaseWords(node.label);
+			nodeWordsCache.set(node, words);
+			for (const word of words) {
+				if (!wordToBucket.has(word)) wordToBucket.set(word, /* @__PURE__ */ new Set());
+				wordToBucket.get(word).add(node);
+			}
+		}
+		const comparedPairs = /* @__PURE__ */ new Set();
+		for (const [_, bucket] of wordToBucket) {
+			if (bucket.size < 2) continue;
+			const bucketNodes = Array.from(bucket);
+			for (let i = 0; i < bucketNodes.length; i++) for (let j = i + 1; j < bucketNodes.length; j++) {
+				const nodeA = bucketNodes[i];
+				const nodeB = bucketNodes[j];
+				const comparedKey = [nodeA.label, nodeB.label].sort().join("|");
+				if (comparedPairs.has(comparedKey)) continue;
+				comparedPairs.add(comparedKey);
+				const wordsA = nodeWordsCache.get(nodeA);
+				const wordsB = nodeWordsCache.get(nodeB);
+				const similarity = calculateSemanticSimilarityCached(nodeA.label, nodeB.label, wordsA, wordsB);
+				if (similarity > similarityThreshold) {
+					const isConnected = connectedPairs.has(comparedKey);
+					const semanticEdgeWeight = similarity * semanticWeight;
+					const currentAB = weighted.get(nodeA).get(nodeB) || 0;
+					const newWeightAB = isConnected ? Math.max(currentAB, semanticEdgeWeight) : currentAB + semanticEdgeWeight;
+					weighted.get(nodeA).set(nodeB, Math.min(newWeightAB, 2));
+					const currentBA = weighted.get(nodeB).get(nodeA) || 0;
+					const newWeightBA = isConnected ? Math.max(currentBA, semanticEdgeWeight) : currentBA + semanticEdgeWeight;
+					weighted.get(nodeB).set(nodeA, Math.min(newWeightBA, 2));
+				}
+			}
 		}
 	}
-	return undirected;
+	return weighted;
 }
 function createSeededRandom(seed) {
 	if (seed === void 0) return Math.random;
@@ -1720,20 +1873,28 @@ function shuffleArray(array, random = Math.random) {
 	return result;
 }
 /**
-* Label Propagation Algorithm for community detection.
+* Label Propagation Algorithm for community detection with semantic awareness.
 *
 * Each node starts with its own unique label. In each iteration,
-* nodes adopt the most frequent label among their neighbors.
-* The algorithm converges when labels no longer change.
+* nodes adopt the most frequent label among their neighbors,
+* weighted by both structural connections and semantic similarity.
+*
+* Semantic similarity considers:
+* - Shared base words (e.g., "open" in "isOpen" and "handleOpenChange")
+* - Substring relationships
+* - Common naming patterns (handler/state pairs)
 *
 * This helps identify groups of nodes that are tightly connected
 * and could potentially be extracted into separate hooks.
 */
 function detectCommunities(graph, options = {}) {
-	const { maxIterations = 100 } = options;
+	const { maxIterations = 100, semanticWeight = 1, similarityThreshold = .3 } = options;
 	const random = createSeededRandom(options.seed);
-	const undirectedGraph = buildUndirectedGraph(graph);
-	const nodes = Array.from(undirectedGraph.keys());
+	const weightedGraph = buildWeightedGraph(graph, {
+		semanticWeight,
+		similarityThreshold
+	});
+	const nodes = Array.from(weightedGraph.keys());
 	if (nodes.length === 0) return {
 		communities: [],
 		nodeToCommuntiy: /* @__PURE__ */ new Map()
@@ -1749,19 +1910,19 @@ function detectCommunities(graph, options = {}) {
 		iterations++;
 		const shuffledNodes = shuffleArray(nodes, random);
 		for (const node of shuffledNodes) {
-			const neighbors = undirectedGraph.get(node);
+			const neighbors = weightedGraph.get(node);
 			if (!neighbors || neighbors.size === 0) continue;
-			const labelCounts = /* @__PURE__ */ new Map();
-			for (const neighbor of neighbors) {
+			const labelWeights = /* @__PURE__ */ new Map();
+			for (const [neighbor, weight] of neighbors) {
 				const neighborLabel = labels.get(neighbor);
-				labelCounts.set(neighborLabel, (labelCounts.get(neighborLabel) || 0) + 1);
+				labelWeights.set(neighborLabel, (labelWeights.get(neighborLabel) || 0) + weight);
 			}
-			let maxCount = 0;
+			let maxWeight = 0;
 			let maxLabels = [];
-			for (const [label, count] of labelCounts) if (count > maxCount) {
-				maxCount = count;
+			for (const [label, weight] of labelWeights) if (weight > maxWeight) {
+				maxWeight = weight;
 				maxLabels = [label];
-			} else if (count === maxCount) maxLabels.push(label);
+			} else if (weight === maxWeight) maxLabels.push(label);
 			const currentLabel = labels.get(node);
 			if (maxLabels.includes(currentLabel)) continue;
 			const newLabel = maxLabels[Math.floor(random() * maxLabels.length)];