@naniteninja/profile-comparison-lib 1.0.24 → 1.0.26

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

@@ -2428,6 +2428,11 @@ class ProfileComparisonLibComponent {
         const idB = this.getLinkNodeId(b);
         return idA < idB ? `${idA}|${idB}` : `${idB}|${idA}`;
     }
+    getRuntimeLinkStrength(link) {
+        return link.kind === 'cross'
+            ? link.strength * 1.7
+            : link.strength * 1.12;
+    }
     selectLinksWithCaps(candidates, maxPerNode, minPerNode = 0) {
         if (!candidates.length || maxPerNode <= 0)
             return [];
@@ -2660,8 +2665,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,6 +2684,37 @@ 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 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));
+        const sharedRawMin = Math.max(globalMinX, dividerLeft + laneGap);
+        const sharedRawMax = Math.min(globalMaxX, dividerRight - laneGap);
+        const sharedRawWidth = Math.max(0, sharedRawMax - sharedRawMin);
+        const sharedTighten = Math.max(12, Math.min(34, sharedRawWidth * 0.22));
+        const sharedMinWidth = Math.max(44, Math.min(84, maxHalfShared * 1.05));
+        let p1BoundsMinX = globalMinX;
+        let p1BoundsMaxX = Math.min(globalMaxX, dividerLeft - laneGap);
+        let sharedBoundsMinX = Math.max(globalMinX, sharedRawMin + sharedTighten);
+        let sharedBoundsMaxX = Math.min(globalMaxX, sharedRawMax - sharedTighten);
+        let p2BoundsMinX = Math.max(globalMinX, dividerRight + laneGap);
+        let p2BoundsMaxX = globalMaxX;
+        if (p1BoundsMaxX < p1BoundsMinX)
+            p1BoundsMaxX = p1BoundsMinX;
+        if (p2BoundsMinX > p2BoundsMaxX)
+            p2BoundsMinX = p2BoundsMaxX;
+        if (sharedBoundsMaxX - sharedBoundsMinX < sharedMinWidth) {
+            const centerX = Math.max(globalMinX, Math.min(globalMaxX, zoneShared));
+            const fallbackHalfWidth = sharedMinWidth / 2;
+            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) {
@@ -2758,7 +2792,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));
@@ -2782,57 +2816,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;
+                minX = p2BoundsMinX;
+                maxX = p2BoundsMaxX;
             }
             else {
-                // Shared chips should align directly under the centered Shared title.
-                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);
-            }
-            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)));
@@ -2844,8 +2848,8 @@ class ProfileComparisonLibComponent {
         };
         const crossCandidates = [];
         const intraCandidates = [];
-        const MIN_DIST = 62;
-        const SPAN = 92;
+        const MIN_DIST = 34;
+        const SPAN = 72;
         for (let i = 0; i < nodes.length; i++) {
             for (let j = i + 1; j < nodes.length; j++) {
                 if (!this.canLinkNodes(nodes[i], nodes[j]))
@@ -2879,9 +2883,9 @@ class ProfileComparisonLibComponent {
                         kind: 'intra',
                         source: groupNodes[i],
                         target: groupNodes[j],
-                        strength: 0.08 + normSim * 0.2,
+                        strength: 0.12 + normSim * 0.24,
                         similarity,
-                        distance: 50 + (1 - normSim) * 42,
+                        distance: 34 + (1 - normSim) * 46,
                     });
                 }
             }
@@ -2974,20 +2978,56 @@ 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;
             });
         };
+        const linkRecords = links
+            .map(link => {
+            const source = typeof link.source === 'object' ? link.source : nodeById.get(String(link.source));
+            const target = typeof link.target === 'object' ? link.target : nodeById.get(String(link.target));
+            if (!source || !target)
+                return null;
+            return {
+                source,
+                target,
+                similarity: Number(link.similarity ?? link.strength ?? 0.5),
+                kind: link.kind,
+            };
+        })
+            .filter((record) => !!record);
+        const maxLinkSimilarity = Math.max(0.001, ...linkRecords.map(record => Math.max(0, record.similarity)));
+        const MIN_PAIR_DISTANCE = 34;
+        const MAX_PAIR_DISTANCE = 88;
+        const similarityAttractionForce = (alpha) => {
+            linkRecords.forEach(record => {
+                const dx = (record.target.x ?? 0) - (record.source.x ?? 0);
+                const dy = (record.target.y ?? 0) - (record.source.y ?? 0);
+                const dist = Math.sqrt(dx * dx + dy * dy) || 1;
+                const normalizedSimilarity = Math.max(0, Math.min(1, record.similarity / maxLinkSimilarity));
+                const targetDistance = MIN_PAIR_DISTANCE + (MAX_PAIR_DISTANCE - MIN_PAIR_DISTANCE) * (1 - normalizedSimilarity);
+                if (dist <= targetDistance)
+                    return;
+                const pullGap = dist - targetDistance;
+                const pullBase = record.kind === 'cross' ? 0.9 : 0.82;
+                const pullFactor = pullBase * alpha * (pullGap / dist);
+                record.source.vx = (record.source.vx ?? 0) + dx * pullFactor;
+                record.source.vy = (record.source.vy ?? 0) + dy * pullFactor;
+                record.target.vx = (record.target.vx ?? 0) - dx * pullFactor;
+                record.target.vy = (record.target.vy ?? 0) - dy * pullFactor;
+            });
+        };
         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 => this.getRuntimeLinkStrength(d)))
                 .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));
@@ -2996,29 +3036,15 @@ 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('crossAlign', crossAlignForce);
+                .force('yTargetSeed', forceY(d => d.targetY ?? minCenterY).strength(0.1))
+                .force('crossAlign', crossAlignForce)
+                .force('similarityAttraction', similarityAttractionForce);
             for (let i = 0; i < 420 && sim.alpha() > 0.0035; i++) {
                 sim.tick();
                 nodes.forEach(n => {
                     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;
@@ -3028,8 +3054,8 @@ class ProfileComparisonLibComponent {
             sim.force('yTargetSeed', null);
             sim.force('crossAlign', null);
             sim.force('xTarget', forceX(d => d.originalFx ?? d.x ?? 0)
-                .strength(d => d.group === 'shared' ? 0.16 : 0.075));
-            sim.force('yTarget', forceY(d => d.originalFy ?? d.y ?? 0).strength(0.085));
+                .strength(d => d.group === 'shared' ? 0.12 : 0.045));
+            sim.force('yTarget', forceY(d => d.originalFy ?? d.y ?? 0).strength(0.045));
             this.simulation = sim;
             this.ngZone.run(() => {
                 this.forceNodes = [...nodes];
@@ -3459,85 +3485,19 @@ class ProfileComparisonLibComponent {
         }
     }
     /**
-     * Installs (or removes) a custom d3 force that pulls every linked node toward
-     * the anchor, stopping at an orbit radius scaled by similarity:
-     *   highest-sim → MIN_ORBIT (touches anchor), lowest-sim → MAX_ORBIT.
-     *
-     * While active, the xTarget/yTarget restoring forces are muted so they don't
-     * fight the attraction. They are restored the moment attraction is cleared.
+     * Anchor interaction should only affect highlighting/energy.
+     * Similarity attraction is always-on via the base simulation forces.
      */
     updateAttractionForce(anchorNode) {
         if (!this.simulation)
             return;
-        if (!anchorNode) {
-            this.simulation.force('attraction', null);
-            // Restore restoring forces so nodes spring back home
-            const xT = this.simulation.force('xTarget');
-            if (xT)
-                xT.strength(0.1);
-            const yT = this.simulation.force('yTarget');
-            if (yT)
-                yT.strength(0.1);
-            const col = this.simulation.force('collide');
-            if (col)
-                col.strength(1.0);
+        this.simulation.force('attraction', null);
+        if (anchorNode) {
+            this.simulation.alpha(0.24).restart();
+        }
+        else if (!this.isDragging) {
             this.simulation.alphaTarget(0);
-            this.simulation.alpha(0.6).restart();
-            return;
         }
-        // Collect connected node IDs and their similarity values
-        const linkSim = new Map();
-        this.forceLinks.forEach(link => {
-            const srcId = typeof link.source === 'object' ? link.source.id : link.source;
-            const tgtId = typeof link.target === 'object' ? link.target.id : link.target;
-            const sim = Number(link.similarity ?? link.strength ?? 0.5);
-            if (srcId === anchorNode.id)
-                linkSim.set(String(tgtId), sim);
-            if (tgtId === anchorNode.id)
-                linkSim.set(String(srcId), sim);
-        });
-        const simValues = Array.from(linkSim.values());
-        const maxSim = simValues.length ? Math.max(...simValues) : 1;
-        // Closest chip (highest sim) touches the anchor (36px ≈ one chip height).
-        // Others are spread tightly between 36–80px.
-        const MIN_ORBIT = 36; // px — highest-sim chip: touching
-        const MAX_ORBIT = 80; // px — lowest-sim chip: still very close
-        const PULL = 0.5; // strong pull — overcomes any residual forces
-        // Mute the forces that would fight the pull while attraction is active
-        const xT = this.simulation.force('xTarget');
-        if (xT)
-            xT.strength(0);
-        const yT = this.simulation.force('yTarget');
-        if (yT)
-            yT.strength(0);
-        const col = this.simulation.force('collide');
-        if (col)
-            col.strength(0.35); // keep slight chip separation while still allowing orbiting
-        const attractionForce = (alpha) => {
-            const ax = anchorNode.x ?? 0;
-            const ay = anchorNode.y ?? 0;
-            this.forceNodes.forEach(n => {
-                if (n.id === anchorNode.id)
-                    return;
-                const sim = linkSim.get(n.id);
-                if (sim === undefined)
-                    return; // not connected — leave untouched
-                const normalizedSim = maxSim > 0 ? sim / maxSim : 0;
-                const orbitDist = MIN_ORBIT + (MAX_ORBIT - MIN_ORBIT) * (1 - normalizedSim);
-                const dx = ax - (n.x ?? 0);
-                const dy = ay - (n.y ?? 0);
-                const dist = Math.sqrt(dx * dx + dy * dy) || 1;
-                if (dist > orbitDist) {
-                    // Pull toward orbit boundary — proportional to gap remaining
-                    const factor = PULL * alpha * (dist - orbitDist) / dist;
-                    n.vx = (n.vx ?? 0) + dx * factor;
-                    n.vy = (n.vy ?? 0) + dy * factor;
-                }
-            });
-        };
-        this.simulation.force('attraction', attractionForce);
-        // alphaTarget 0.3 keeps alpha high so attraction stays strong indefinitely
-        this.simulation.alphaTarget(0.3).restart();
     }
     isNodeConnected(node) {
         if (!this.activeNode)
@@ -3629,21 +3589,21 @@ class ProfileComparisonLibComponent {
         if (this.simulation) {
             const linkForce = this.simulation.force('link');
             if (linkForce)
-                linkForce.strength((d) => d.strength * 0.6);
+                linkForce.strength((d) => this.getRuntimeLinkStrength(d));
             const collideForce = this.simulation.force('collide');
             if (collideForce)
                 collideForce.strength(1.0);
             const xTarget = this.simulation.force('xTarget');
             if (xTarget)
-                xTarget.strength(0.08);
+                xTarget.strength((d) => d.group === 'shared' ? 0.12 : 0.05);
             const yTarget = this.simulation.force('yTarget');
             if (yTarget)
-                yTarget.strength(0.08);
+                yTarget.strength(0.05);
         }
         // Pull connected chips toward the dragged node
         this.updateAttractionForce(node);
         // Wake up the simulation target to keep it highly active during drag
-        this.simulation.alphaTarget(0.3).restart();
+        this.simulation.alphaTarget(0.28).restart();
     }
     onDocumentDragMove(event) {
         if (!this.isDragging || !this.draggedNode)
@@ -3675,12 +3635,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();
     }
@@ -3690,27 +3646,25 @@ class ProfileComparisonLibComponent {
         // Release the node. Clear fx and fy so it is no longer pinned to the mouse
         this.draggedNode.fx = undefined;
         this.draggedNode.fy = undefined;
-        // Remove attraction so connected chips return home
+        // Keep baseline similarity attraction and restoring forces active after drag release.
         this.simulation.force('attraction', null);
-        // Set other forces to 0 so all chips glide directly to their starting coordinates
         if (this.simulation) {
             const linkForce = this.simulation.force('link');
             if (linkForce)
-                linkForce.strength(0);
+                linkForce.strength((d) => this.getRuntimeLinkStrength(d));
             const collideForce = this.simulation.force('collide');
             if (collideForce)
-                collideForce.strength(0.92);
-            // Pull nodes smoothly and slowly back to their exact starting points
+                collideForce.strength(1.0);
             const xTarget = this.simulation.force('xTarget');
             if (xTarget)
-                xTarget.strength(0.13);
+                xTarget.strength((d) => d.group === 'shared' ? 0.12 : 0.045);
             const yTarget = this.simulation.force('yTarget');
             if (yTarget)
-                yTarget.strength(0.13);
+                yTarget.strength(0.045);
         }
         // Cool down simulation targets
         this.simulation.alphaTarget(0);
-        this.simulation.alpha(0.6).restart();
+        this.simulation.alpha(0.4).restart();
         this.draggedNode = null;
         this.isDragging = false;
     }