vue-hook-optimizer 0.0.80 → 0.0.82

package/dist/index.cjs

@@ -1689,6 +1689,184 @@ function getMermaidText(graph, nodesUsedInTemplate, nodesUsedInStyle = /* @__PUR
 	return mermaidText;
 }
 
+//#endregion
+//#region src/suggest/community.ts
+function buildUndirectedGraph(graph) {
+	const undirected = /* @__PURE__ */ new Map();
+	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);
+		}
+	}
+	return undirected;
+}
+function createSeededRandom(seed) {
+	if (seed === void 0) return Math.random;
+	let state = seed;
+	return () => {
+		state = state * 1103515245 + 12345 & 2147483647;
+		return state / 2147483647;
+	};
+}
+function shuffleArray(array, random = Math.random) {
+	const result = [...array];
+	for (let i = result.length - 1; i > 0; i--) {
+		const j = Math.floor(random() * (i + 1));
+		[result[i], result[j]] = [result[j], result[i]];
+	}
+	return result;
+}
+/**
+* Label Propagation Algorithm for community detection.
+*
+* 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.
+*
+* 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 random = createSeededRandom(options.seed);
+	const undirectedGraph = buildUndirectedGraph(graph);
+	const nodes = Array.from(undirectedGraph.keys());
+	if (nodes.length === 0) return {
+		communities: [],
+		nodeToCommuntiy: /* @__PURE__ */ new Map()
+	};
+	const labels = /* @__PURE__ */ new Map();
+	nodes.forEach((node, index) => {
+		labels.set(node, index);
+	});
+	let changed = true;
+	let iterations = 0;
+	while (changed && iterations < maxIterations) {
+		changed = false;
+		iterations++;
+		const shuffledNodes = shuffleArray(nodes, random);
+		for (const node of shuffledNodes) {
+			const neighbors = undirectedGraph.get(node);
+			if (!neighbors || neighbors.size === 0) continue;
+			const labelCounts = /* @__PURE__ */ new Map();
+			for (const neighbor of neighbors) {
+				const neighborLabel = labels.get(neighbor);
+				labelCounts.set(neighborLabel, (labelCounts.get(neighborLabel) || 0) + 1);
+			}
+			let maxCount = 0;
+			let maxLabels = [];
+			for (const [label, count] of labelCounts) if (count > maxCount) {
+				maxCount = count;
+				maxLabels = [label];
+			} else if (count === maxCount) maxLabels.push(label);
+			const currentLabel = labels.get(node);
+			if (maxLabels.includes(currentLabel)) continue;
+			const newLabel = maxLabels[Math.floor(random() * maxLabels.length)];
+			if (newLabel !== currentLabel) {
+				labels.set(node, newLabel);
+				changed = true;
+			}
+		}
+	}
+	const communityMap = /* @__PURE__ */ new Map();
+	for (const [node, label] of labels) {
+		if (!communityMap.has(label)) communityMap.set(label, /* @__PURE__ */ new Set());
+		communityMap.get(label).add(node);
+	}
+	const communities = [];
+	const nodeToCommuntiy = /* @__PURE__ */ new Map();
+	let communityId = 0;
+	for (const [_, nodeSet] of communityMap) {
+		communities.push({
+			id: communityId,
+			nodes: nodeSet
+		});
+		for (const node of nodeSet) nodeToCommuntiy.set(node, communityId);
+		communityId++;
+	}
+	communities.sort((a, b) => b.nodes.size - a.nodes.size);
+	const reindexedCommunities = [];
+	const newNodeToCommunity = /* @__PURE__ */ new Map();
+	communities.forEach((community, newId) => {
+		reindexedCommunities.push({
+			id: newId,
+			nodes: community.nodes
+		});
+		for (const node of community.nodes) newNodeToCommunity.set(node, newId);
+	});
+	return {
+		communities: reindexedCommunities,
+		nodeToCommuntiy: newNodeToCommunity
+	};
+}
+/**
+* Generate HSL colors for communities.
+* Uses golden ratio to distribute hues evenly.
+*/
+function generateCommunityColors(communityCount) {
+	const colors = [];
+	const goldenRatio = .618033988749895;
+	let hue = .1;
+	for (let i = 0; i < communityCount; i++) {
+		hue = (hue + goldenRatio) % 1;
+		const h = Math.floor(hue * 360);
+		const s = 65 + i % 3 * 10;
+		const l = 45 + i % 2 * 10;
+		colors.push(`hsl(${h}, ${s}%, ${l}%)`);
+	}
+	return colors;
+}
+/**
+* Generate RGBA colors for VS Code decorations.
+* Returns both background (low opacity) and foreground (high opacity) colors.
+*/
+function generateCommunityColorsRGBA(communityCount) {
+	const colors = [];
+	const goldenRatio = .618033988749895;
+	let hue = .1;
+	for (let i = 0; i < communityCount; i++) {
+		hue = (hue + goldenRatio) % 1;
+		const h = hue * 360;
+		const s = .45;
+		const l = .55;
+		const { r, g, b } = hslToRgb(h, s, l);
+		colors.push({
+			background: `rgba(${r}, ${g}, ${b}, 0.15)`,
+			foreground: `rgba(${r}, ${g}, ${b}, 0.9)`,
+			border: `rgba(${r}, ${g}, ${b}, 0.5)`
+		});
+	}
+	return colors;
+}
+function hslToRgb(h, s, l) {
+	h = h / 360;
+	let r, g, b;
+	if (s === 0) r = g = b = l;
+	else {
+		const hue2rgb = (p$1, q$1, t) => {
+			if (t < 0) t += 1;
+			if (t > 1) t -= 1;
+			if (t < 1 / 6) return p$1 + (q$1 - p$1) * 6 * t;
+			if (t < 1 / 2) return q$1;
+			if (t < 2 / 3) return p$1 + (q$1 - p$1) * (2 / 3 - t) * 6;
+			return p$1;
+		};
+		const q = l < .5 ? l * (1 + s) : l + s - l * s;
+		const p = 2 * l - q;
+		r = hue2rgb(p, q, h + 1 / 3);
+		g = hue2rgb(p, q, h);
+		b = hue2rgb(p, q, h - 1 / 3);
+	}
+	return {
+		r: Math.round(r * 255),
+		g: Math.round(g * 255),
+		b: Math.round(b * 255)
+	};
+}
+
 //#endregion
 //#region src/suggest/filter.ts
 /**
@@ -1889,7 +2067,7 @@ let SuggestionType = /* @__PURE__ */ function(SuggestionType$1) {
 	return SuggestionType$1;
 }({});
 function gen(graph, nodesUsedInTemplate, nodesUsedInStyle = /* @__PURE__ */ new Set(), options) {
-	const { ellipsis = true } = options ?? {};
+	const { ellipsis = true, communitySeed } = options ?? {};
 	const usedNodes = new Set([...nodesUsedInTemplate, ...nodesUsedInStyle]);
 	const suggestions = [];
 	const splitedGraph = splitGraph(graph.edges);
@@ -1943,6 +2121,48 @@ function gen(graph, nodesUsedInTemplate, nodesUsedInStyle = /* @__PURE__ */ new
 			nodeInfo: node
 		});
 	});
+	const communityResult = detectCommunities(graph.edges, { seed: communitySeed });
+	const { communities } = communityResult;
+	const extractableCommunities = communities.filter((community) => {
+		const nodes = Array.from(community.nodes);
+		if (nodes.length < 3 || nodes.length > 15) return false;
+		const hasUsedNode = nodes.some((node) => usedNodes.has(node.label));
+		const hasUnusedNode = nodes.some((node) => !usedNodes.has(node.label));
+		return hasUsedNode && hasUnusedNode;
+	});
+	extractableCommunities.forEach((community) => {
+		const nodes = Array.from(community.nodes);
+		const unusedNodes = nodes.filter((node) => !usedNodes.has(node.label));
+		if (unusedNodes.length >= 2) suggestions.push({
+			type: SuggestionType.info,
+			message: `Nodes [${ellipsis && nodes.length > 10 ? `${nodes.slice(0, 10).map((node) => node.label).join(",")}...(${nodes.length})` : nodes.map((node) => node.label).join(",")}] form a tightly coupled group, consider extracting them into a composable/hook.`,
+			nodeInfo: nodes
+		});
+	});
+	if (communities.length > 3) {
+		const independentCommunities = communities.filter((community) => {
+			const nodes = Array.from(community.nodes);
+			return nodes.length >= 2 && nodes.every((node) => !usedNodes.has(node.label) && !node.info?.used?.size);
+		});
+		if (independentCommunities.length >= 2) {
+			const allNodes = independentCommunities.flatMap((c) => Array.from(c.nodes));
+			suggestions.push({
+				type: SuggestionType.info,
+				message: `Found ${independentCommunities.length} independent variable groups that are not used in template. Consider removing or extracting them.`,
+				nodeInfo: allNodes
+			});
+		}
+	}
+	const largeCommunities = communities.filter((c) => c.nodes.size > 10);
+	largeCommunities.forEach((community) => {
+		const nodes = Array.from(community.nodes);
+		const functionNodes = nodes.filter((n) => n.type === NodeType.fun);
+		if (functionNodes.length > 5) suggestions.push({
+			type: SuggestionType.warning,
+			message: `Community with ${nodes.length} nodes has ${functionNodes.length} functions. This group is complex, consider splitting into smaller composables.`,
+			nodeInfo: nodes
+		});
+	});
 	return suggestions;
 }
 
@@ -2005,7 +2225,10 @@ exports.analyzeSetupScript = analyze$1;
 exports.analyzeStyle = analyze$2;
 exports.analyzeTemplate = analyze$3;
 exports.analyzeTsx = analyze$4;
+exports.detectCommunities = detectCommunities;
 exports.gen = gen;
+exports.generateCommunityColors = generateCommunityColors;
+exports.generateCommunityColorsRGBA = generateCommunityColorsRGBA;
 exports.getMermaidText = getMermaidText;
 exports.getVisData = getVisData;
 Object.defineProperty(exports, 'parse', {