@eaprelsky/nocturna-wheel 4.0.1 → 4.0.3

package/dist/nocturna-wheel.bundle.js

@@ -293,7 +293,7 @@
     /**
      * IconData.js
      * Auto-generated module containing inline SVG icons as data URLs
-     * Generated at: 2025-11-27T18:13:39.810Z
+     * Generated at: 2025-12-21T15:10:29.834Z
      * 
      * This file is automatically generated by the build process.
      * Do not edit manually - changes will be overwritten.
@@ -2337,41 +2337,26 @@
                 // Offset needed to place Ascendant (house 1 cusp) at 0 degrees (top side)
                 ascendantAlignmentOffset = (360 - ascendantLon) % 360;
             }
-            
-            // Create array of houses with their rotated angles and original indices
-            const housesWithAngles = [];
+
+            // Render house numbers at the CENTER of each house sector.
+            // If house cusp data is available, compute the midpoint between cusp[i] and cusp[i+1] (with proper 0/360 wrap).
+            // Otherwise, fall back to equal 30° houses.
             for (let i = 0; i < 12; i++) {
-                let baseAngle;
+                const houseNumber = i + 1;
+
+                let midAngle;
                 if (this.houseData && this.houseData.length >= 12) {
-                    baseAngle = this.getHouseLongitude(this.houseData[i]);
+                    const startLon = this.getHouseLongitude(this.houseData[i]);
+                    const endLon = this.getHouseLongitude(this.houseData[(i + 1) % 12]);
+                    const arc = (endLon - startLon + 360) % 360; // always move forward through the zodiac
+                    const midLon = (startLon + arc / 2) % 360;
+                    midAngle = (midLon + ascendantAlignmentOffset + rotationAngle) % 360;
                 } else {
-                    baseAngle = i * 30; // Default if no data
+                    // Equal houses: center of each 30° segment
+                    midAngle = (i * 30 + 15 + rotationAngle) % 360;
                 }
-                const rotatedAngle = (baseAngle + ascendantAlignmentOffset + rotationAngle) % 360;
                 
-                housesWithAngles.push({
-                    originalIndex: i,
-                    baseAngle: baseAngle,
-                    rotatedAngle: rotatedAngle
-                });
-            }
-            
-            // Sort by rotated angle to determine visual order
-            housesWithAngles.sort((a, b) => a.rotatedAngle - b.rotatedAngle);
-            
-            // Find which house is Ascendant (originally index 0) after rotation
-            const ascendantVisualIndex = housesWithAngles.findIndex(h => h.originalIndex === 0);
-            
-            // Render houses with correct numbering based on visual position
-            housesWithAngles.forEach((house, visualIndex) => {
-                const houseAngle = house.rotatedAngle;
-                
-                // Calculate house number based on position relative to Ascendant
-                // Counter-clockwise from Ascendant
-                const houseNumber = ((visualIndex - ascendantVisualIndex + 12) % 12) + 1;
-                
-                // Offset text from house line clockwise
-                const angle = (houseAngle + 15) % 360; // Place in middle of house segment, apply modulo
+                const angle = midAngle;
                 
                 // Calculate position for house number
                 const point = this.svgUtils.pointOnCircle(this.centerX, this.centerY, this.numberRadius, angle);
@@ -2412,7 +2397,7 @@
                 
                 parentGroup.appendChild(text);
                 elements.push(text);
-            });
+            }
             
             return elements;
         }
@@ -2765,6 +2750,16 @@
      */
 
     class PlanetPositionCalculator {
+        static _normalizeAngle(angle) {
+            return ((angle % 360) + 360) % 360;
+        }
+
+        static _getAngle(position) {
+            return position && position.adjustedLongitude !== undefined
+                ? position.adjustedLongitude
+                : position.longitude;
+        }
+
         /**
          * Calculate position for a planet on a circle
          * @param {Object} params - Position parameters
@@ -2849,7 +2844,8 @@
                 centerX,
                 centerY,
                 baseRadius,
-                iconSize = 24
+                iconSize = 24,
+                maxIterations = 5
             } = options;
             
             if (!positions || positions.length <= 1) {
@@ -2863,72 +2859,51 @@
             
             console.log(`PlanetPositionCalculator: Adjusting overlaps for ${positions.length} positions`);
             
-            // Make a copy to not modify originals
-            const adjustedPositions = [...positions];
+            // Make a copy to not modify originals (also ensures we can add fields safely)
+            const adjustedPositions = positions.map(p => ({ ...p }));
             
             // The minimum angular distance needed to prevent overlap at base radius
-            // Add safety factor to ensure visual separation
-            const minAngularDistance = (minDistance / baseRadius) * (180 / Math.PI) * 1.3; // 30% extra spacing
+            // minDistance already includes the desired spacing (iconSize * 1.5)
+            const minAngularDistance = (minDistance / baseRadius) * (180 / Math.PI);
             console.log(`PlanetPositionCalculator: Minimum angular distance: ${minAngularDistance.toFixed(2)}°`);
-            
-            // Sort positions by longitude for overlap detection
-            const sortedPositionIndices = adjustedPositions
-                .map((pos, idx) => ({ pos, idx }))
-                .sort((a, b) => a.pos.longitude - b.pos.longitude);
-            
-            const sortedPositions = sortedPositionIndices.map(item => ({
-                ...adjustedPositions[item.idx],
-                originalIndex: item.idx
-            }));
-            
-            // Find clusters of planets that are too close angularly
-            const clusters = this._findOverlappingClusters(sortedPositions, minAngularDistance);
-            console.log(`PlanetPositionCalculator: Found ${clusters.length} clusters of overlapping positions`);
-            clusters.forEach((cluster, i) => {
-                console.log(`PlanetPositionCalculator: Cluster ${i+1} has ${cluster.length} positions`);
-            });
-            
-            // Process each cluster
-            clusters.forEach((cluster, clusterIndex) => {
-                console.log(`PlanetPositionCalculator: Processing cluster ${clusterIndex+1}`);
-                
-                if (cluster.length <= 1) {
-                    // Single planet - just place at exact base radius with no angle change
-                    const planet = cluster[0];
-                    console.log(`PlanetPositionCalculator: Single position in cluster, keeping at original longitude ${planet.longitude.toFixed(2)}°`);
-                    this._setExactPosition(planet, planet.longitude, baseRadius, centerX, centerY, iconSize);
-                } else {
-                    // Handle cluster with multiple planets - distribute by angle
-                    console.log(`PlanetPositionCalculator: Distributing ${cluster.length} positions in cluster`);
-                    this._distributeClusterByAngle(cluster, baseRadius, minAngularDistance, centerX, centerY, iconSize);
-                    
-                    // Log the distributions
-                    cluster.forEach((pos, i) => {
-                        console.log(`PlanetPositionCalculator: Position ${i+1} in cluster ${clusterIndex+1} adjusted from ${pos.longitude.toFixed(2)}° to ${pos.adjustedLongitude.toFixed(2)}°`);
-                    });
+
+            // Initialize adjustedLongitude for all positions
+            adjustedPositions.forEach(pos => {
+                if (pos.adjustedLongitude === undefined) {
+                    pos.adjustedLongitude = pos.longitude;
                 }
+                this._setExactPosition(pos, this._getAngle(pos), baseRadius, centerX, centerY, iconSize);
             });
-            
-            // Copy adjusted positions back to the original array order
-            sortedPositions.forEach(pos => {
-                const origIndex = pos.originalIndex;
-                
-                // Only copy if we have valid data
-                if (origIndex !== undefined && origIndex >= 0 && origIndex < adjustedPositions.length) {
-                    adjustedPositions[origIndex].x = pos.x;
-                    adjustedPositions[origIndex].y = pos.y;
-                    adjustedPositions[origIndex].iconX = pos.iconX;
-                    adjustedPositions[origIndex].iconY = pos.iconY;
-                    adjustedPositions[origIndex].iconCenterX = pos.iconCenterX;
-                    adjustedPositions[origIndex].iconCenterY = pos.iconCenterY;
-                    
-                    // Also add any adjusted longitude for reference
-                    if (pos.adjustedLongitude !== undefined) {
-                        adjustedPositions[origIndex].adjustedLongitude = pos.adjustedLongitude;
-                    }
+
+            // Iteratively resolve overlaps. This avoids "new overlaps" created after distributing a cluster.
+            for (let iteration = 0; iteration < maxIterations; iteration++) {
+                // Sort by current (possibly adjusted) angle for overlap detection
+                const sortedPositions = [...adjustedPositions].sort(
+                    (a, b) => this._getAngle(a) - this._getAngle(b)
+                );
+
+                // Find clusters of planets that are too close angularly
+                const clusters = this._findOverlappingClusters(sortedPositions, minAngularDistance);
+                console.log(`PlanetPositionCalculator: Iteration ${iteration + 1}/${maxIterations}, clusters: ${clusters.length}`);
+
+                // No overlaps -> done
+                const hasRealClusters = clusters.some(c => c.length > 1);
+                if (!hasRealClusters) {
+                    break;
                 }
-            });
-            
+
+                // Process each cluster
+                clusters.forEach(cluster => {
+                    if (cluster.length <= 1) {
+                        const planet = cluster[0];
+                        this._setExactPosition(planet, this._getAngle(planet), baseRadius, centerX, centerY, iconSize);
+                        return;
+                    }
+
+                    this._distributeClusterByPush(cluster, baseRadius, minAngularDistance, centerX, centerY, iconSize);
+                });
+            }
+
             return adjustedPositions;
         }
         
@@ -2958,7 +2933,9 @@
                 const currPosition = sortedPositions[i];
                 
                 // Check angular distance, considering wrap-around at 360°
-                let angleDiff = currPosition.longitude - prevPosition.longitude;
+                const prevAngle = this._getAngle(prevPosition);
+                const currAngle = this._getAngle(currPosition);
+                let angleDiff = currAngle - prevAngle;
                 if (angleDiff < 0) angleDiff += 360;
                 
                 if (angleDiff < minAngularDistance) {
@@ -2982,7 +2959,9 @@
             const lastPlanet = sortedPositions[posCount - 1];
             const firstPlanetOriginal = sortedPositions[0];
             
-            let wrapDiff = (firstPlanetOriginal.longitude + 360) - lastPlanet.longitude;
+            const lastAngle = this._getAngle(lastPlanet);
+            const firstAngle = this._getAngle(firstPlanetOriginal);
+            let wrapDiff = (firstAngle + 360) - lastAngle;
             if (wrapDiff < 0) wrapDiff += 360;
             
             if (wrapDiff < minAngularDistance) {
@@ -3006,7 +2985,8 @@
         }
         
         /**
-         * Distribute positions in a cluster by adjusting only their angles
+         * Distribute positions in a cluster using a "push-apart" algorithm.
+         * This keeps adjustments as small as possible while ensuring minimum spacing.
          * @private
          * @param {Array} positions - Array of positions in the cluster
          * @param {number} radius - The exact radius to place all positions
@@ -3015,49 +2995,62 @@
          * @param {number} centerY - Y coordinate of center
          * @param {number} iconSize - Size of the icon
          */
-        static _distributeClusterByAngle(positions, radius, minAngularDistance, centerX, centerY, iconSize) {
+        static _distributeClusterByPush(positions, radius, minAngularDistance, centerX, centerY, iconSize) {
             const n = positions.length;
-            
-            // If only one planet, keep its original position
-            if (n === 1) {
-                this._setExactPosition(positions[0], positions[0].longitude, radius, centerX, centerY, iconSize);
+            if (n <= 1) {
+                const p = positions[0];
+                this._setExactPosition(p, this._getAngle(p), radius, centerX, centerY, iconSize);
                 return;
             }
-            
-            // Sort positions by their original longitude to maintain order
-            positions.sort((a, b) => a.longitude - b.longitude);
-            
-            // Calculate central angle and total span
-            const firstPos = positions[0].longitude;
-            const lastPos = positions[n-1].longitude;
-            let totalArc = lastPos - firstPos;
-            
-            // Handle wrap-around case (e.g., positions at 350° and 10°)
-            if (totalArc < 0 || totalArc > 180) {
-                totalArc = (360 + lastPos - firstPos) % 360;
+
+            // Unwrap angles if cluster spans the 0°/360° boundary
+            const baseAngles = positions.map(p => this._getAngle(p));
+            const min = Math.min(...baseAngles);
+            const max = Math.max(...baseAngles);
+            const unwrappedAngles = (max - min > 180)
+                ? baseAngles.map(a => (a < 180 ? a + 360 : a))
+                : baseAngles;
+
+            // Sort by unwrapped angle
+            const items = positions
+                .map((p, idx) => ({ p, orig: unwrappedAngles[idx] }))
+                .sort((a, b) => a.orig - b.orig);
+
+            const origAngles = items.map(it => it.orig);
+            let adjusted = [...origAngles];
+
+            // Forward pass: enforce minimum distance
+            for (let i = 1; i < n; i++) {
+                const minAllowed = adjusted[i - 1] + minAngularDistance;
+                if (adjusted[i] < minAllowed) {
+                    adjusted[i] = minAllowed;
+                }
             }
-            
-            // Calculate the center of the cluster (weighted average of all positions)
-            let sumAngles = 0;
-            for (let i = 0; i < n; i++) {
-                sumAngles += positions[i].longitude;
+
+            // Shift the whole cluster to keep it centered around the original mean angle
+            const origCenter = origAngles.reduce((s, a) => s + a, 0) / n;
+            const adjustedCenter = adjusted.reduce((s, a) => s + a, 0) / n;
+            const shift = origCenter - adjustedCenter;
+            adjusted = adjusted.map(a => a + shift);
+
+            // Re-enforce constraints after shifting
+            for (let i = 1; i < n; i++) {
+                const minAllowed = adjusted[i - 1] + minAngularDistance;
+                if (adjusted[i] < minAllowed) {
+                    adjusted[i] = minAllowed;
+                }
             }
-            let centerAngle = (sumAngles / n) % 360;
-            
-            // Determine minimum arc needed for n planets with minimum spacing
-            // Add extra spacing factor to ensure planets don't overlap
-            const minRequiredArc = (n - 1) * minAngularDistance * 1.2; // 20% extra spacing
-            
-            // Always use at least the minimum required arc
-            const spanToUse = Math.max(minRequiredArc, totalArc);
-            
-            // Calculate start angle (center - half of span)
-            const startAngle = (centerAngle - spanToUse/2 + 360) % 360;
-            
-            // Distribute planets evenly from the start angle
+            for (let i = n - 2; i >= 0; i--) {
+                const maxAllowed = adjusted[i + 1] - minAngularDistance;
+                if (adjusted[i] > maxAllowed) {
+                    adjusted[i] = maxAllowed;
+                }
+            }
+
+            // Apply results
             for (let i = 0; i < n; i++) {
-                const angle = (startAngle + i * (spanToUse / (n-1))) % 360;
-                this._setExactPosition(positions[i], angle, radius, centerX, centerY, iconSize);
+                const angle = this._normalizeAngle(adjusted[i]);
+                this._setExactPosition(items[i].p, angle, radius, centerX, centerY, iconSize);
             }
         }
         
@@ -3134,7 +3127,8 @@
             // Define parameters for collision detection and distribution
             const iconSize = 24;
             const baseRadius = planets[0].iconRadius; // Use the iconRadius from the first planet
-            const minDistance = iconSize * 1.2;
+            // Minimum distance = icon diameter + half diameter (0.5 * iconSize spacing between icons)
+            const minDistance = iconSize * 1.5;
             
             // Prepare planets array in format expected by PlanetPositionCalculator
             const positions = planets.map((planet, index) => ({
@@ -3256,7 +3250,7 @@
                 this.symbolRenderer.addPlanetTooltip(planetGroup, planet);
                 
                 // Render connector if needed
-                const connector = this.symbolRenderer.renderConnector(planetGroup, planet, iconSize);
+                const connector = this.symbolRenderer.renderConnector(planetGroup, planet, iconSize, 0.9);
                 if (connector) {
                     planetGroup.appendChild(connector);
                 }
@@ -3316,7 +3310,8 @@
             // Define parameters for collision detection and distribution
             const iconSize = 18; // Smaller size for secondary planets
             const baseRadius = planets[0].iconRadius; // Use the iconRadius from the first planet
-            const minDistance = iconSize * 1.1; // Slightly tighter packing
+            // Minimum distance = icon diameter + half diameter (0.5 * iconSize spacing between icons)
+            const minDistance = iconSize * 1.5;
             
             // Prepare planets array in format expected by PlanetPositionCalculator
             const positions = planets.map((planet, index) => ({
@@ -3437,7 +3432,7 @@
                 this.symbolRenderer.addPlanetTooltip(planetGroup, planet);
                 
                 // Render connector if needed
-                const connector = this.symbolRenderer.renderConnector(planetGroup, planet, iconSize);
+                const connector = this.symbolRenderer.renderConnector(planetGroup, planet, iconSize, 0.9);
                 if (connector) {
                     planetGroup.appendChild(connector);
                 }
@@ -5476,8 +5471,13 @@
             const centerY = this.chart.config.svg.center.y;
             const c3Radius = this.chart.config.radius.innermost;     // C3
             
-            // Only draw the innermost circle if secondary planets are enabled
-            if (this.chart.config.planetSettings.secondaryEnabled !== false) {
+            // Only draw the innermost circle if secondary planets are enabled AND we actually have secondary data
+            const hasSecondaryPlanetsData =
+                this.chart?.secondaryPlanets &&
+                typeof this.chart.secondaryPlanets === 'object' &&
+                Object.keys(this.chart.secondaryPlanets).length > 0;
+            
+            if (this.chart.config.planetSettings.secondaryEnabled !== false && hasSecondaryPlanetsData) {
                 this.drawInnermostCircle(zodiacGroup, this.svgUtils, centerX, centerY, c3Radius);
             }