chart2txt 0.5.2 → 0.7.0

package/dist/core/stelliums.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectStelliums = detectStelliums;
+exports.formatStellium = formatStellium;
+const astrology_1 = require("./astrology");
+const houseCalculations_1 = require("../utils/houseCalculations");
+const formatting_1 = require("../utils/formatting");
+/**
+ * Convert Point to PlanetPosition
+ */
+function pointToPlanetPosition(point, houseCusps) {
+    const sign = (0, astrology_1.getDegreeSign)(point.degree);
+    const house = houseCusps
+        ? (0, houseCalculations_1.getHouseForPoint)(point.degree, houseCusps) || undefined
+        : undefined;
+    return {
+        name: point.name,
+        degree: point.degree,
+        sign,
+        house,
+    };
+}
+/**
+ * Detect Stellium patterns (3+ planets in same sign or adjacent houses)
+ * This function requires house information and is specific to single-chart analysis
+ */
+function detectStelliums(planets, houseCusps, minPlanets = 3) {
+    const patterns = [];
+    // Group by sign
+    const signGroups = new Map();
+    planets.forEach((planet) => {
+        const sign = (0, astrology_1.getDegreeSign)(planet.degree);
+        if (!signGroups.has(sign)) {
+            signGroups.set(sign, []);
+        }
+        signGroups.get(sign).push(planet);
+    });
+    // Check sign-based stelliums
+    signGroups.forEach((planetsInSign, sign) => {
+        if (planetsInSign.length >= minPlanets) {
+            const planetPositions = planetsInSign.map((p) => pointToPlanetPosition(p, houseCusps));
+            const houses = planetPositions
+                .map((p) => p.house)
+                .filter((h) => h !== undefined);
+            const degrees = planetsInSign.map((p) => p.degree);
+            const span = Math.max(...degrees) - Math.min(...degrees);
+            patterns.push({
+                type: 'Stellium',
+                planets: planetPositions,
+                sign,
+                houses: [...new Set(houses)].sort(),
+                span,
+            });
+        }
+    });
+    // Check house-based stelliums (if house cusps available)
+    if (houseCusps) {
+        const houseGroups = new Map();
+        planets.forEach((planet) => {
+            const house = (0, houseCalculations_1.getHouseForPoint)(planet.degree, houseCusps);
+            if (house) {
+                if (!houseGroups.has(house)) {
+                    houseGroups.set(house, []);
+                }
+                houseGroups.get(house).push(planet);
+            }
+        });
+        houseGroups.forEach((planetsInHouse, house) => {
+            if (planetsInHouse.length >= minPlanets) {
+                const planetPositions = planetsInHouse.map((p) => pointToPlanetPosition(p, houseCusps));
+                const degrees = planetsInHouse.map((p) => p.degree);
+                const span = Math.max(...degrees) - Math.min(...degrees);
+                // Only add if not already covered by sign stellium
+                const existingSignStellium = patterns.find((p) => p.type === 'Stellium' &&
+                    p.planets.some((planet) => planetPositions.some((pp) => pp.name === planet.name)));
+                if (!existingSignStellium) {
+                    patterns.push({
+                        type: 'Stellium',
+                        planets: planetPositions,
+                        houses: [house],
+                        span,
+                    });
+                }
+            }
+        });
+    }
+    return patterns;
+}
+/**
+ * Format a Stellium pattern for display in compact format
+ */
+function formatStellium(pattern) {
+    const planetNames = pattern.planets.map((p) => p.name).join(', ');
+    let location = '';
+    if (pattern.sign) {
+        location = pattern.sign;
+    }
+    if (pattern.houses && pattern.houses.length > 0) {
+        const houseStr = pattern.houses.length === 1
+            ? `${(0, formatting_1.getOrdinal)(pattern.houses[0])} House`
+            : pattern.houses.map((h) => `${(0, formatting_1.getOrdinal)(h)} House`).join('-');
+        location += location ? ` (${houseStr})` : houseStr;
+    }
+    const locationStr = location ? ` in ${location}` : '';
+    return [
+        `Stellium (${pattern.span.toFixed(1)}°): ${planetNames}${locationStr}`,
+    ];
+}

package/dist/formatters/text/sections/angles.js

@@ -11,16 +11,16 @@ const astrology_1 = require("../../../core/astrology");
 function generateAnglesOutput(ascDegree, mcDegree) {
     const output = ['[ANGLES]'];
     if (ascDegree !== undefined) {
-        output.push(`ASC: ${Math.floor((0, astrology_1.getDegreeInSign)(ascDegree))}° ${(0, astrology_1.getDegreeSign)(ascDegree)}`);
+        output.push(`Ascendant: ${Math.floor((0, astrology_1.getDegreeInSign)(ascDegree))}° ${(0, astrology_1.getDegreeSign)(ascDegree)}`);
     }
     else {
-        output.push('ASC: Not available');
+        output.push('Ascendant: Not available');
     }
     if (mcDegree !== undefined) {
-        output.push(`MC: ${Math.floor((0, astrology_1.getDegreeInSign)(mcDegree))}° ${(0, astrology_1.getDegreeSign)(mcDegree)}`);
+        output.push(`Midheaven: ${Math.floor((0, astrology_1.getDegreeInSign)(mcDegree))}° ${(0, astrology_1.getDegreeSign)(mcDegree)}`);
     }
     else {
-        output.push('MC: Not available');
+        output.push('Midheaven: Not available');
     }
     return output;
 }

package/dist/formatters/text/sections/aspectPatterns.d.ts

@@ -0,0 +1,9 @@
+import { AspectPattern } from '../../../types';
+/**
+ * Generates the [ASPECT PATTERNS] section of the chart output.
+ * @param patterns Array of detected aspect patterns
+ * @param customTitle Optional custom title for the section
+ * @param showChartNames Whether to show chart names for planets (false for single charts, true for multi-chart)
+ * @returns An array of strings for the output.
+ */
+export declare function generateAspectPatternsOutput(patterns: AspectPattern[], customTitle?: string, showChartNames?: boolean): string[];

package/dist/formatters/text/sections/aspectPatterns.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateAspectPatternsOutput = generateAspectPatternsOutput;
+const astrology_1 = require("../../../core/astrology");
+const formatting_1 = require("../../../utils/formatting");
+/**
+ * Format a planet position for display
+ */
+function formatPlanetPosition(planet, includeHouse = false, showChartNames = true) {
+    const degInSign = Math.floor((0, astrology_1.getDegreeInSign)(planet.degree));
+    const houseStr = includeHouse && planet.house ? ` (${(0, formatting_1.getOrdinal)(planet.house)} house)` : '';
+    const chartPrefix = showChartNames && planet.chartName ? `${planet.chartName}'s ` : '';
+    return `${chartPrefix}${planet.name} ${degInSign}° ${planet.sign}${houseStr}`;
+}
+/**
+ * Format a T-Square pattern in compact format
+ */
+function formatTSquare(pattern, showChartNames = true) {
+    if (pattern.type !== 'T-Square')
+        return [];
+    const apex = formatPlanetPosition(pattern.apex, false, showChartNames);
+    const opp1 = formatPlanetPosition(pattern.opposition[0], false, showChartNames);
+    const opp2 = formatPlanetPosition(pattern.opposition[1], false, showChartNames);
+    return [
+        `T-Square (${pattern.mode}, ${pattern.averageOrb.toFixed(1)}°): ${apex} ← ${opp1} ↔ ${opp2}`,
+    ];
+}
+/**
+ * Format a Grand Trine pattern in compact format
+ */
+function formatGrandTrine(pattern, showChartNames = true) {
+    if (pattern.type !== 'Grand Trine')
+        return [];
+    const planets = pattern.planets
+        .map((p) => formatPlanetPosition(p, false, showChartNames))
+        .join(' △ ');
+    return [
+        `Grand Trine (${pattern.element}, ${pattern.averageOrb.toFixed(1)}°): ${planets}`,
+    ];
+}
+/**
+ * Format a Grand Cross pattern in compact format
+ */
+function formatGrandCross(pattern, showChartNames = true) {
+    if (pattern.type !== 'Grand Cross')
+        return [];
+    const planets = pattern.planets
+        .map((p) => formatPlanetPosition(p, false, showChartNames))
+        .join(' ⨯ ');
+    return [
+        `Grand Cross (${pattern.mode}, ${pattern.averageOrb.toFixed(1)}°): ${planets}`,
+    ];
+}
+/**
+ * Format a Yod pattern in compact format
+ */
+function formatYod(pattern, showChartNames = true) {
+    if (pattern.type !== 'Yod')
+        return [];
+    const apex = formatPlanetPosition(pattern.apex, false, showChartNames);
+    const base1 = formatPlanetPosition(pattern.base[0], false, showChartNames);
+    const base2 = formatPlanetPosition(pattern.base[1], false, showChartNames);
+    return [
+        `Yod (${pattern.averageOrb.toFixed(1)}°): ${apex} ← ${base1} • ${base2}`,
+    ];
+}
+/**
+ * Format a Mystic Rectangle pattern in compact format
+ */
+function formatMysticRectangle(pattern, showChartNames = true) {
+    if (pattern.type !== 'Mystic Rectangle')
+        return [];
+    const opp1_1 = formatPlanetPosition(pattern.oppositions[0][0], false, showChartNames);
+    const opp1_2 = formatPlanetPosition(pattern.oppositions[0][1], false, showChartNames);
+    const opp2_1 = formatPlanetPosition(pattern.oppositions[1][0], false, showChartNames);
+    const opp2_2 = formatPlanetPosition(pattern.oppositions[1][1], false, showChartNames);
+    return [
+        `Mystic Rectangle (${pattern.averageOrb.toFixed(1)}°): ${opp1_1} ↔ ${opp1_2} | ${opp2_1} ↔ ${opp2_2}`,
+    ];
+}
+/**
+ * Format a Kite pattern in compact format
+ */
+function formatKite(pattern, showChartNames = true) {
+    if (pattern.type !== 'Kite')
+        return [];
+    const grandTrineStr = pattern.grandTrine
+        .map((p) => formatPlanetPosition(p, false, showChartNames))
+        .join(' △ ');
+    const oppositionPlanet = formatPlanetPosition(pattern.opposition, false, showChartNames);
+    // Get the element from the first planet's sign for context
+    const element = pattern.grandTrine[0].sign
+        ? getElementFromSign(pattern.grandTrine[0].sign)
+        : '';
+    const elementStr = element ? `${element}, ` : '';
+    return [
+        `Kite (${elementStr}${pattern.averageOrb.toFixed(1)}°): [${grandTrineStr}] ← ${oppositionPlanet}`,
+    ];
+}
+/**
+ * Helper function to get element from sign
+ */
+function getElementFromSign(sign) {
+    const fireSigns = ['Aries', 'Leo', 'Sagittarius'];
+    const earthSigns = ['Taurus', 'Virgo', 'Capricorn'];
+    const airSigns = ['Gemini', 'Libra', 'Aquarius'];
+    const waterSigns = ['Cancer', 'Scorpio', 'Pisces'];
+    if (fireSigns.includes(sign))
+        return 'Fire';
+    if (earthSigns.includes(sign))
+        return 'Earth';
+    if (airSigns.includes(sign))
+        return 'Air';
+    if (waterSigns.includes(sign))
+        return 'Water';
+    return '';
+}
+/**
+ * Check if a Grand Trine is part of any Kite pattern within the same analysis context
+ * Uses exact planet identity matching (chart name + planet name + degree)
+ */
+function isGrandTrinePartOfKite(grandTrine, patterns) {
+    if (grandTrine.type !== 'Grand Trine')
+        return false;
+    return patterns.some((pattern) => {
+        if (pattern.type !== 'Kite')
+            return false;
+        // Create unique identifiers for exact planet identity matching
+        const createPlanetId = (p) => `${p.chartName || ''}-${p.name}-${p.degree}`;
+        const kiteGrandTrinePlanets = pattern.grandTrine.map(createPlanetId);
+        const grandTrinePlanets = grandTrine.planets.map(createPlanetId);
+        // Check if the sets of planets are identical (same planets, same count)
+        return (kiteGrandTrinePlanets.length === grandTrinePlanets.length &&
+            kiteGrandTrinePlanets.every((kp) => grandTrinePlanets.includes(kp)));
+    });
+}
+/**
+ * Generates the [ASPECT PATTERNS] section of the chart output.
+ * @param patterns Array of detected aspect patterns
+ * @param customTitle Optional custom title for the section
+ * @param showChartNames Whether to show chart names for planets (false for single charts, true for multi-chart)
+ * @returns An array of strings for the output.
+ */
+function generateAspectPatternsOutput(patterns, customTitle, showChartNames = true) {
+    const output = [
+        customTitle ? `[ASPECT PATTERNS: ${customTitle}]` : '[ASPECT PATTERNS]',
+    ];
+    if (patterns.length === 0) {
+        output.push('No T-Squares detected.');
+        output.push('No Grand Trines detected.');
+        return output;
+    }
+    // Filter out Grand Trines that are part of Kites to avoid duplication
+    const filteredPatterns = patterns.filter((pattern) => {
+        if (pattern.type === 'Grand Trine') {
+            return !isGrandTrinePartOfKite(pattern, patterns);
+        }
+        return true;
+    });
+    // Sort patterns by type for consistent output
+    const sortOrder = [
+        'T-Square',
+        'Grand Trine',
+        'Grand Cross',
+        'Yod',
+        'Mystic Rectangle',
+        'Kite',
+    ];
+    const sortedPatterns = filteredPatterns.sort((a, b) => {
+        return sortOrder.indexOf(a.type) - sortOrder.indexOf(b.type);
+    });
+    sortedPatterns.forEach((pattern) => {
+        switch (pattern.type) {
+            case 'T-Square':
+                output.push(...formatTSquare(pattern, showChartNames));
+                break;
+            case 'Grand Trine':
+                output.push(...formatGrandTrine(pattern, showChartNames));
+                break;
+            case 'Grand Cross':
+                output.push(...formatGrandCross(pattern, showChartNames));
+                break;
+            case 'Yod':
+                output.push(...formatYod(pattern, showChartNames));
+                break;
+            case 'Mystic Rectangle':
+                output.push(...formatMysticRectangle(pattern, showChartNames));
+                break;
+            case 'Kite':
+                output.push(...formatKite(pattern, showChartNames));
+                break;
+        }
+    });
+    // Remove trailing empty line
+    if (output[output.length - 1] === '') {
+        output.pop();
+    }
+    return output;
+}

package/dist/formatters/text/sections/aspects.d.ts

@@ -1,14 +1,11 @@
 import { AspectData } from '../../../types';
-import { ChartSettings } from '../../../config/ChartSettings';
 /**
- * Generates aspect sections (e.g., [ASPECTS], [PLANET-PLANET ASPECTS], [TRANSIT ASPECTS: Name]).
+ * Generates aspect sections from a pre-grouped map of aspects.
  * @param title The main title for this aspect block (e.g., "[ASPECTS]").
- * @param aspects Array of calculated aspect data.
- * @param settings The chart settings, containing aspect categories.
+ * @param groupedAspects A map of category names to aspect data arrays.
  * @param p1ChartName Optional: Name of the first chart/entity for synastry/transit aspects.
  * @param p2ChartName Optional: Name of the second chart/entity for synastry aspects.
  * @param p2IsTransit Optional: Boolean indicating if p2 represents transiting points.
  * @returns An array of strings for the output.
  */
-export declare function generateAspectsOutput(title: string, aspects: AspectData[], settings: ChartSettings, p1ChartName?: string, p2ChartName?: string, // For synastry, this is the second person's name. For transits, it could be "Current" or the transit chart name.
-p2IsTransit?: boolean): string[];
+export declare function generateAspectsOutput(title: string, groupedAspects?: Map<string, AspectData[]>, p1ChartName?: string, p2ChartName?: string, p2IsTransit?: boolean): string[];

package/dist/formatters/text/sections/aspects.js

@@ -2,63 +2,49 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateAspectsOutput = generateAspectsOutput;
 /**
- * Generates aspect sections (e.g., [ASPECTS], [PLANET-PLANET ASPECTS], [TRANSIT ASPECTS: Name]).
+ * Generates the output for a single aspect line.
+ * @param asp The aspect data.
+ * @param p1ChartName Optional name of the first chart.
+ * @param p2ChartName Optional name of the second chart.
+ * @param p2IsTransit Optional flag if the second chart is for transits.
+ * @returns A formatted string for the aspect.
+ */
+function formatAspectLine(asp, p1ChartName, p2ChartName, p2IsTransit = false) {
+    const p1NameStr = p1ChartName
+        ? `${p1ChartName}'s ${asp.planetA}`
+        : asp.planetA;
+    let p2NameStr = asp.planetB;
+    if (p2IsTransit) {
+        p2NameStr = `transiting ${asp.planetB}`;
+    }
+    else if (p2ChartName) {
+        p2NameStr = `${p2ChartName}'s ${asp.planetB}`;
+    }
+    const applicationStr = asp.application && asp.application !== 'exact'
+        ? ` (${asp.application})`
+        : '';
+    return `${p1NameStr} ${asp.aspectType} ${p2NameStr}: ${asp.orb.toFixed(1)}°${applicationStr}`;
+}
+/**
+ * Generates aspect sections from a pre-grouped map of aspects.
  * @param title The main title for this aspect block (e.g., "[ASPECTS]").
- * @param aspects Array of calculated aspect data.
- * @param settings The chart settings, containing aspect categories.
+ * @param groupedAspects A map of category names to aspect data arrays.
  * @param p1ChartName Optional: Name of the first chart/entity for synastry/transit aspects.
  * @param p2ChartName Optional: Name of the second chart/entity for synastry aspects.
  * @param p2IsTransit Optional: Boolean indicating if p2 represents transiting points.
  * @returns An array of strings for the output.
  */
-function generateAspectsOutput(title, aspects, settings, p1ChartName, p2ChartName, // For synastry, this is the second person's name. For transits, it could be "Current" or the transit chart name.
-p2IsTransit = false) {
+function generateAspectsOutput(title, groupedAspects, p1ChartName, p2ChartName, p2IsTransit = false) {
     const output = [title];
-    let aspectsFoundInAnyCategory = false;
-    settings.aspectCategories.forEach((category) => {
-        const categoryAspects = aspects.filter((asp) => {
-            const orb = asp.orb;
-            const minOrbCheck = category.minOrb === undefined ? true : orb > category.minOrb;
-            const maxOrbCheck = orb <= category.maxOrb;
-            return minOrbCheck && maxOrbCheck;
-        });
-        if (categoryAspects.length > 0) {
-            aspectsFoundInAnyCategory = true;
-            let orbRangeStr = `orb < ${category.maxOrb.toFixed(1)}°`;
-            if (category.minOrb !== undefined) {
-                // Ensure minOrb is less than maxOrb for sensible range string
-                orbRangeStr =
-                    category.minOrb < category.maxOrb
-                        ? `orb ${category.minOrb.toFixed(1)}-${category.maxOrb.toFixed(1)}°`
-                        : `orb > ${category.minOrb.toFixed(1)}° & < ${category.maxOrb.toFixed(1)}°`; // Fallback for unusual category def
-            }
-            output.push(`[${category.name.toUpperCase()}: ${orbRangeStr}]`);
-            categoryAspects.sort((a, b) => a.orb - b.orb); // Sort by orb tightness
-            categoryAspects.forEach((asp) => {
-                const p1NameStr = p1ChartName
-                    ? `${p1ChartName}'s ${asp.planetA}`
-                    : asp.planetA;
-                let p2NameStr = asp.planetB;
-                if (p2IsTransit) {
-                    // For "Transit Aspects: Alice", p1 is Alice, p2 is the transiting planet.
-                    // Example: "Alice's Mercury opposition transiting Neptune: 0.3°" - here p2ChartName is not used for the planet itself.
-                    p2NameStr = `transiting ${asp.planetB}`;
-                }
-                else if (p2ChartName) {
-                    // For "Synastry: Alice-Bob", "Planet-Planet Aspects"
-                    // Example: "Alice's Mercury opposition Bob's Neptune: 0.3°"
-                    p2NameStr = `${p2ChartName}'s ${asp.planetB}`;
-                }
-                // If neither p2IsTransit nor p2ChartName, it's a natal chart aspect, e.g. "Venus opposition Pluto: 1.2°"
-                output.push(`${p1NameStr} ${asp.aspectType} ${p2NameStr}: ${asp.orb.toFixed(1)}°`);
-            });
-        }
-    });
-    if (!aspectsFoundInAnyCategory && aspects.length > 0) {
-        output.push('No aspects within defined categories.');
-    }
-    else if (aspects.length === 0) {
+    if (!groupedAspects || groupedAspects.size === 0) {
         output.push('None');
+        return output;
     }
+    groupedAspects.forEach((categoryAspects, categoryName) => {
+        output.push(categoryName); // The category name is the pre-formatted key from the map
+        categoryAspects.forEach((asp) => {
+            output.push(formatAspectLine(asp, p1ChartName, p2ChartName, p2IsTransit));
+        });
+    });
     return output;
 }

package/dist/formatters/text/sections/birthdata.js

@@ -16,6 +16,6 @@ function generateBirthdataOutput(location, timestamp, settings, sectionTitle = '
     const dateStr = (0, datetime_1.formatDateCustom)(timestamp, settings.dateFormat);
     const timeStr = (0, datetime_1.formatTime)(timestamp);
     return [
-        `${sectionTitle} ${location || 'Unknown Location'}, ${dateStr}, ${timeStr}`,
+        `${sectionTitle} ${location || 'Unknown Location'} | ${dateStr} | ${timeStr}`,
     ];
 }

package/dist/formatters/text/sections/dispositors.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Generates the [DISPOSITOR TREE] section of the chart output.
+ * @param dispositors A map of planet names to their full dispositor chain string.
+ * @returns An array of strings for the output.
+ */
+export declare function generateDispositorsOutput(dispositors: {
+    [key: string]: string;
+}): string[];

package/dist/formatters/text/sections/dispositors.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDispositorsOutput = generateDispositorsOutput;
+/**
+ * Generates the [DISPOSITOR TREE] section of the chart output.
+ * @param dispositors A map of planet names to their full dispositor chain string.
+ * @returns An array of strings for the output.
+ */
+function generateDispositorsOutput(dispositors) {
+    const output = ['[DISPOSITOR TREE]'];
+    if (Object.keys(dispositors).length === 0) {
+        output.push('No dispositor data available.');
+        return output;
+    }
+    for (const planet in dispositors) {
+        output.push(dispositors[planet]);
+    }
+    return output;
+}

package/dist/formatters/text/sections/houseOverlays.d.ts

@@ -1,10 +1,15 @@
-import { ChartData } from '../../../types';
-import { ChartSettings } from '../../../config/ChartSettings';
 /**
  * Generates the [HOUSE OVERLAYS] section for synastry.
- * @param chart1 The first chart data.
- * @param chart2 The second chart data.
- * @param settings The chart settings, containing the house system calculator.
+ * @param overlays The pre-calculated house overlay data.
+ * @param chart1Name The name of the first chart.
+ * @param chart2Name The name of the second chart.
  * @returns An array of strings for the output.
  */
-export declare function generateHouseOverlaysOutput(chart1: ChartData, chart2: ChartData, settings: ChartSettings): string[];
+export declare function generateHouseOverlaysOutput(overlays: {
+    chart1InChart2Houses: {
+        [key: string]: number;
+    };
+    chart2InChart1Houses: {
+        [key: string]: number;
+    };
+}, chart1Name: string, chart2Name: string): string[];

package/dist/formatters/text/sections/houseOverlays.js

@@ -1,85 +1,54 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateHouseOverlaysOutput = generateHouseOverlaysOutput;
-// Helper function to determine which house a point falls into
-function getHouseForPoint(pointDegree, houseCusps) {
-    if (!houseCusps || houseCusps.length !== 12) {
-        // console.error("Invalid or missing houseCusps array for getHouseForPoint.");
-        return 0; // Indicate failure or inability to calculate
-    }
-    for (let i = 0; i < 12; i++) {
-        const cuspStart = houseCusps[i]; // Cusp of current house (e.g., for House 1, i=0, cuspStart = Cusp 1)
-        const cuspEnd = houseCusps[(i + 1) % 12]; // Cusp of next house (e.g., for House 1, cuspEnd = Cusp 2)
-        // Check if the point degree falls between cuspStart and cuspEnd
-        if (cuspStart < cuspEnd) {
-            // Normal case: e.g., Cusp1=10, Cusp2=40. Point is between 10 and 40.
-            if (pointDegree >= cuspStart && pointDegree < cuspEnd) {
-                return i + 1; // House number is i+1 (cusps are 0-indexed, houses 1-indexed)
-            }
-        }
-        else {
-            // Wrap-around case: e.g., Cusp12=330, Cusp1=20. Point is >=330 OR <20.
-            if (pointDegree >= cuspStart || pointDegree < cuspEnd) {
-                return i + 1; // House number is i+1
-            }
-        }
-    }
-    // console.warn(`Point ${pointDegree} did not fall into any house with cusps: ${houseCusps.join(', ')}.`);
-    return 0; // Should ideally not be reached if cusps correctly cover 360 degrees
-}
+const formatting_1 = require("../../../utils/formatting");
 /**
  * Generates the [HOUSE OVERLAYS] section for synastry.
- * @param chart1 The first chart data.
- * @param chart2 The second chart data.
- * @param settings The chart settings, containing the house system calculator.
+ * @param overlays The pre-calculated house overlay data.
+ * @param chart1Name The name of the first chart.
+ * @param chart2Name The name of the second chart.
  * @returns An array of strings for the output.
  */
-function generateHouseOverlaysOutput(chart1, chart2, settings) {
+function generateHouseOverlaysOutput(overlays, chart1Name, chart2Name) {
     const output = ['[HOUSE OVERLAYS]'];
-    const c1Name = chart1.name;
-    const c2Name = chart2.name;
-    // Chart 1's planets in Chart 2's houses
-    if (chart2.houseCusps && chart2.houseCusps.length === 12) {
-        output.push(`${c1Name}'s planets in ${c2Name}'s houses:`);
-        if (chart1.planets && chart1.planets.length > 0) {
-            chart1.planets.forEach((planet) => {
-                const houseNumber = getHouseForPoint(planet.degree, chart2.houseCusps);
-                if (houseNumber > 0) {
-                    output.push(`${planet.name}: House ${houseNumber}`);
-                }
-                else {
-                    output.push(`${planet.name}: (Could not determine house in ${c2Name})`);
-                }
-            });
-        }
-        else {
-            output.push('(No planets listed for overlay)');
-        }
+    output.push(`${chart1Name}'s planets in ${chart2Name}'s houses:`);
+    if (Object.keys(overlays.chart1InChart2Houses).length > 0) {
+        output.push(formatHouseOverlayCompact(overlays.chart1InChart2Houses));
     }
     else {
-        output.push(`${c1Name}'s planets in ${c2Name}'s houses: (${c2Name} house cusps not available)`);
+        output.push(`(${chart2Name} house cusps not available)`);
     }
-    output.push(''); // Blank line between the two overlay sections
-    // Chart 2's planets in Chart 1's houses
-    if (chart1.houseCusps && chart1.houseCusps.length === 12) {
-        output.push(`${c2Name}'s planets in ${c1Name}'s houses:`);
-        if (chart2.planets && chart2.planets.length > 0) {
-            chart2.planets.forEach((planet) => {
-                const houseNumber = getHouseForPoint(planet.degree, chart1.houseCusps);
-                if (houseNumber > 0) {
-                    output.push(`${planet.name}: House ${houseNumber}`);
-                }
-                else {
-                    output.push(`${planet.name}: (Could not determine house in ${c1Name})`);
-                }
-            });
-        }
-        else {
-            output.push('(No planets listed for overlay)');
-        }
+    output.push(`${chart2Name}'s planets in ${chart1Name}'s houses:`);
+    if (Object.keys(overlays.chart2InChart1Houses).length > 0) {
+        output.push(formatHouseOverlayCompact(overlays.chart2InChart1Houses));
     }
     else {
-        output.push(`${c2Name}'s planets in ${c1Name}'s houses: (${c1Name} house cusps not available)`);
+        output.push(`(${chart1Name} house cusps not available)`);
     }
     return output;
 }
+/**
+ * Formats house overlays in a compact format, grouping by house.
+ * @param overlays Object mapping planet names to house numbers.
+ * @returns A compact string representation.
+ */
+function formatHouseOverlayCompact(overlays) {
+    // Group planets by house
+    const houseGroups = {};
+    for (const planet in overlays) {
+        const house = overlays[planet];
+        if (!houseGroups[house]) {
+            houseGroups[house] = [];
+        }
+        houseGroups[house].push(planet);
+    }
+    // Sort houses numerically and format
+    const sortedHouses = Object.keys(houseGroups)
+        .map(Number)
+        .sort((a, b) => a - b);
+    const houseStrings = sortedHouses.map((house) => {
+        const planets = houseGroups[house].join(', ');
+        return `${(0, formatting_1.getOrdinal)(house)}: ${planets}`;
+    });
+    return houseStrings.join(' | ');
+}

package/dist/formatters/text/sections/houses.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Generates the [HOUSE CUSPS] section of the chart output.
+ * @param houseCusps Array of 12 house cusp degrees (0-360), or undefined if not available.
+ * @returns An array of strings for the output.
+ */
+export declare function generateHousesOutput(houseCusps?: number[]): string[];