@naniteninja/profile-comparison-lib 1.0.23 → 1.0.25

package/fesm2022/naniteninja-profile-comparison-lib.mjs

@@ -2660,8 +2660,6 @@ class ProfileComparisonLibComponent {
         const horizontalPadding = this.chipPaddingXPx * 2;
         const getHalfWidth = (label) => (label.length * approxCharWidth + horizontalPadding) / 2;
         const EDGE_PADDING = 20;
-        const getNodeMinX = (label) => getHalfWidth(label) + EDGE_PADDING;
-        const getNodeMaxX = (label) => containerWidth - getHalfWidth(label) - EDGE_PADDING;
         const maxHalfP1 = p1Items.length ? Math.max(...p1Items.map(getHalfWidth)) : chipHalfH;
         const maxHalfShared = shared.length ? Math.max(...shared.map(getHalfWidth)) : chipHalfH;
         const maxHalfP2 = p2Items.length ? Math.max(...p2Items.map(getHalfWidth)) : chipHalfH;
@@ -2681,7 +2679,32 @@ class ProfileComparisonLibComponent {
         const minCenterY = startY + chipHalfH;
         const verticalSpan = Math.max(0, maxY - minCenterY);
         const centerGuard = Math.max(12, Math.min(26, (zoneP2 - zoneP1) * 0.12));
-        const sharedBand = Math.max(12, Math.min(22, (zoneP2 - zoneP1) * 0.09));
+        const maxHalfAny = Math.max(maxHalfP1, maxHalfShared, maxHalfP2, chipHalfH);
+        const globalMinX = maxHalfAny + EDGE_PADDING;
+        const globalMaxX = containerWidth - maxHalfAny - EDGE_PADDING;
+        const dividerLeft = (zoneP1 + zoneShared) / 2;
+        const dividerRight = (zoneShared + zoneP2) / 2;
+        const laneGap = Math.max(4, Math.min(16, centerGuard * 0.45));
+        let p1BoundsMinX = globalMinX;
+        let p1BoundsMaxX = Math.min(globalMaxX, dividerLeft - laneGap);
+        let sharedBoundsMinX = Math.max(globalMinX, dividerLeft + laneGap);
+        let sharedBoundsMaxX = Math.min(globalMaxX, dividerRight - laneGap);
+        let p2BoundsMinX = Math.max(globalMinX, dividerRight + laneGap);
+        let p2BoundsMaxX = globalMaxX;
+        if (p1BoundsMaxX < p1BoundsMinX)
+            p1BoundsMaxX = p1BoundsMinX;
+        if (p2BoundsMinX > p2BoundsMaxX)
+            p2BoundsMinX = p2BoundsMaxX;
+        if (sharedBoundsMaxX < sharedBoundsMinX) {
+            const centerX = Math.max(globalMinX, Math.min(globalMaxX, zoneShared));
+            const fallbackHalfWidth = Math.max(6, Math.min(20, Math.max(0, p2BoundsMinX - p1BoundsMaxX) * 0.25));
+            sharedBoundsMinX = Math.max(globalMinX, centerX - fallbackHalfWidth);
+            sharedBoundsMaxX = Math.min(globalMaxX, centerX + fallbackHalfWidth);
+            if (sharedBoundsMaxX < sharedBoundsMinX) {
+                sharedBoundsMinX = centerX;
+                sharedBoundsMaxX = centerX;
+            }
+        }
         // --- Scan matrix for max similarity to normalize spring distances ---
         let matrixMax = 0;
         if (this.matrixData?.rows) {
@@ -2759,7 +2782,7 @@ class ProfileComparisonLibComponent {
             return nodes.filter(n => n.group === 'p1' || n.group === 'p2');
         };
         const ySimilarityFloor = Math.max(0.18, springThreshold - 0.06);
-        for (let pass = 0; pass < 3; pass++) {
+        for (let pass = 0; pass < 6; pass++) {
             const snapshotY = new Map();
             nodes.forEach(node => {
                 snapshotY.set(node.id, node.targetY ?? (minCenterY + verticalSpan * 0.5));
@@ -2783,60 +2806,27 @@ class ProfileComparisonLibComponent {
                     return;
                 const semanticY = weightedY / totalWeight;
                 const currentY = snapshotY.get(node.id) ?? semanticY;
-                const blend = node.group === 'shared' ? 0.72 : 0.62;
+                const blend = node.group === 'shared' ? 0.84 : 0.78;
                 node.targetY = Math.max(minCenterY, Math.min(maxY, currentY + (semanticY - currentY) * blend));
             });
         }
-        const groupCounts = {
-            p1: p1Items.length,
-            shared: shared.length,
-            p2: p2Items.length,
-        };
-        const fullVerticalSpan = Math.max(rowGap, maxY - minCenterY);
         const buildNodeBounds = (node) => {
-            const halfW = getHalfWidth(node.label);
-            const globalMinX = getNodeMinX(node.label);
-            const globalMaxX = getNodeMaxX(node.label);
-            const leftLimit = zoneShared - halfW - centerGuard;
-            const rightLimit = zoneShared + halfW + centerGuard;
             let minX = globalMinX;
             let maxX = globalMaxX;
             if (node.group === 'p1') {
-                maxX = Math.min(globalMaxX, leftLimit);
-                if (maxX < minX)
-                    maxX = minX;
+                minX = p1BoundsMinX;
+                maxX = p1BoundsMaxX;
             }
             else if (node.group === 'p2') {
-                minX = Math.max(globalMinX, rightLimit);
-                if (minX > maxX)
-                    minX = maxX;
-            }
-            else {
-                minX = Math.max(globalMinX, zoneShared - sharedBand);
-                maxX = Math.min(globalMaxX, zoneShared + sharedBand);
-                if (minX > maxX) {
-                    const centerX = Math.max(globalMinX, Math.min(globalMaxX, zoneShared));
-                    minX = centerX;
-                    maxX = centerX;
-                }
-            }
-            const baseY = node.targetY ?? (minCenterY + fullVerticalSpan * 0.5);
-            const groupCount = groupCounts[node.group];
-            let ySlack = rowGap * 2.2;
-            if (node.group === 'shared') {
-                ySlack = Math.max(rowGap * 4.2, fullVerticalSpan * 0.58);
+                minX = p2BoundsMinX;
+                maxX = p2BoundsMaxX;
             }
             else {
-                const laneSpan = groupCount > 1 ? fullVerticalSpan / (groupCount - 1) : fullVerticalSpan;
-                ySlack = Math.min(fullVerticalSpan, Math.max(rowGap * 2.4, laneSpan * 0.95));
-            }
-            let minY = Math.max(minCenterY, baseY - ySlack);
-            let maxYForNode = Math.min(maxY, baseY + ySlack);
-            if (minY > maxYForNode) {
-                minY = minCenterY;
-                maxYForNode = maxY;
+                minX = sharedBoundsMinX;
+                maxX = sharedBoundsMaxX;
             }
-            return { minX, maxX, minY, maxY: maxYForNode };
+            // Y should be column-wide so any chip can travel vertically within its lane.
+            return { minX, maxX, minY: minCenterY, maxY };
         };
         const nodeBounds = new Map();
         nodes.forEach(node => nodeBounds.set(node.id, buildNodeBounds(node)));
@@ -2978,20 +2968,21 @@ class ProfileComparisonLibComponent {
                     return;
                 const targetY = weightedY / totalWeight;
                 const dy = targetY - (node.y ?? targetY);
+                const sparseNeighbors = neighbors.length <= 2;
                 const alignStrength = node.group === 'shared'
-                    ? (neighbors.length <= 2 ? 0.62 : 0.52)
-                    : 0.36;
+                    ? (sparseNeighbors ? 0.95 : 0.8)
+                    : (sparseNeighbors ? 0.82 : 0.68);
                 node.vy = (node.vy ?? 0) + dy * alignStrength * alpha;
             });
         };
         this.ngZone.runOutsideAngular(() => {
             const sim = forceSimulation(nodes)
-                .alphaDecay(0.02)
+                .alphaDecay(0.014)
                 .stop()
                 .force('link', forceLink(links)
                 .id(d => d.id)
                 .distance(d => d.distance)
-                .strength(d => d.kind === 'cross' ? d.strength * 0.9 : d.strength * 0.65))
+                .strength(d => d.kind === 'cross' ? d.strength * 1.45 : d.strength * 0.86))
                 .force('collide', forceCollide((d) => {
                 const baseRadius = getHalfWidth(d.label) * 0.55 + ProfileComparisonLibComponent.CHIP_COLLISION_BORDER_PADDING;
                 return Math.min(58, Math.max(ProfileComparisonLibComponent.CHIP_RADIUS + 8, baseRadius));
@@ -3000,7 +2991,7 @@ class ProfileComparisonLibComponent {
                 .iterations(2))
                 .force('xBound', forceX(d => d.targetX ?? zoneShared)
                 .strength(d => d.group === 'shared' ? 1.15 : 0.85))
-                .force('yTargetSeed', forceY(d => d.targetY ?? minCenterY).strength(0.34))
+                .force('yTargetSeed', forceY(d => d.targetY ?? minCenterY).strength(0.1))
                 .force('crossAlign', crossAlignForce);
             for (let i = 0; i < 420 && sim.alpha() > 0.0035; i++) {
                 sim.tick();
@@ -3008,21 +2999,6 @@ class ProfileComparisonLibComponent {
                     clampNodeToBounds(n);
                 });
             }
-            const enforceGroupStack = (group) => {
-                const groupNodes = nodes
-                    .filter(n => n.group === group)
-                    .sort((a, b) => (a.y ?? minCenterY) - (b.y ?? minCenterY));
-                for (let i = 1; i < groupNodes.length; i++) {
-                    const prevY = groupNodes[i - 1].y ?? minCenterY;
-                    const minAllowed = prevY + rowGap * 0.92;
-                    if ((groupNodes[i].y ?? minCenterY) < minAllowed) {
-                        groupNodes[i].y = minAllowed;
-                    }
-                }
-            };
-            enforceGroupStack('p1');
-            enforceGroupStack('shared');
-            enforceGroupStack('p2');
             nodes.forEach(n => {
                 clampNodeToBounds(n);
                 n.originalFx = n.x;
@@ -3679,12 +3655,8 @@ class ProfileComparisonLibComponent {
         const maxY = bounds?.maxY ?? fallbackMaxY;
         const clampedX = Math.max(minX, Math.min(maxX, relX));
         const clampedY = Math.max(minY, Math.min(maxY, relY));
-        const anchorX = this.draggedNode.originalFx ?? clampedX;
-        const anchorY = this.draggedNode.originalFy ?? clampedY;
-        const xElasticity = this.draggedNode.group === 'shared' ? 0.62 : 0.72;
-        const yElasticity = this.draggedNode.group === 'shared' ? 0.58 : 0.68;
-        this.draggedNode.fx = anchorX + (clampedX - anchorX) * xElasticity;
-        this.draggedNode.fy = anchorY + (clampedY - anchorY) * yElasticity;
+        this.draggedNode.fx = clampedX;
+        this.draggedNode.fy = clampedY;
         // Keep active force simulation running
         this.simulation.alpha(0.3).restart();
     }