chart2txt 0.5.2 → 0.6.0

package/dist/core/signDistributions.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeSignDistributions = analyzeSignDistributions;
+exports.formatElementDistribution = formatElementDistribution;
+exports.formatModalityDistribution = formatModalityDistribution;
+exports.formatPolarityDistribution = formatPolarityDistribution;
+const astrology_1 = require("./astrology");
+// Sign classifications
+const SIGN_ELEMENTS = {
+    Aries: 'Fire',
+    Leo: 'Fire',
+    Sagittarius: 'Fire',
+    Taurus: 'Earth',
+    Virgo: 'Earth',
+    Capricorn: 'Earth',
+    Gemini: 'Air',
+    Libra: 'Air',
+    Aquarius: 'Air',
+    Cancer: 'Water',
+    Scorpio: 'Water',
+    Pisces: 'Water',
+};
+const SIGN_MODALITIES = {
+    Aries: 'Cardinal',
+    Cancer: 'Cardinal',
+    Libra: 'Cardinal',
+    Capricorn: 'Cardinal',
+    Taurus: 'Fixed',
+    Leo: 'Fixed',
+    Scorpio: 'Fixed',
+    Aquarius: 'Fixed',
+    Gemini: 'Mutable',
+    Virgo: 'Mutable',
+    Sagittarius: 'Mutable',
+    Pisces: 'Mutable',
+};
+const SIGN_POLARITIES = {
+    Aries: 'Masculine',
+    Gemini: 'Masculine',
+    Leo: 'Masculine',
+    Libra: 'Masculine',
+    Sagittarius: 'Masculine',
+    Aquarius: 'Masculine',
+    Taurus: 'Feminine',
+    Cancer: 'Feminine',
+    Virgo: 'Feminine',
+    Scorpio: 'Feminine',
+    Capricorn: 'Feminine',
+    Pisces: 'Feminine',
+};
+/**
+ * Analyzes the distribution of planets across elements, modalities, and polarities
+ * @param planets Array of planet points
+ * @param includeAscendant Optional ascendant degree to include in analysis
+ * @returns Sign distribution analysis
+ */
+function analyzeSignDistributions(planets, includeAscendant) {
+    const elements = {
+        Fire: [],
+        Earth: [],
+        Air: [],
+        Water: [],
+    };
+    const modalities = {
+        Cardinal: 0,
+        Fixed: 0,
+        Mutable: 0,
+    };
+    const polarities = {
+        Masculine: 0,
+        Feminine: 0,
+    };
+    // Process planets
+    planets.forEach((planet) => {
+        const sign = (0, astrology_1.getDegreeSign)(planet.degree);
+        const element = SIGN_ELEMENTS[sign];
+        const modality = SIGN_MODALITIES[sign];
+        const polarity = SIGN_POLARITIES[sign];
+        if (element) {
+            elements[element].push(planet.name);
+        }
+        if (modality) {
+            modalities[modality]++;
+        }
+        if (polarity) {
+            polarities[polarity]++;
+        }
+    });
+    // Process ascendant if provided
+    if (includeAscendant !== undefined) {
+        const ascSign = (0, astrology_1.getDegreeSign)(includeAscendant);
+        const ascElement = SIGN_ELEMENTS[ascSign];
+        const ascModality = SIGN_MODALITIES[ascSign];
+        const ascPolarity = SIGN_POLARITIES[ascSign];
+        if (ascElement) {
+            elements[ascElement].push('Ascendant');
+        }
+        if (ascModality) {
+            modalities[ascModality]++;
+        }
+        if (ascPolarity) {
+            polarities[ascPolarity]++;
+        }
+    }
+    return { elements, modalities, polarities };
+}
+/**
+ * Formats element distribution for display
+ * @param elements Element distribution data
+ * @returns Array of formatted strings
+ */
+function formatElementDistribution(elements) {
+    const output = [];
+    Object.entries(elements).forEach(([element, planets]) => {
+        if (planets.length > 0) {
+            const planetList = planets.join(', ');
+            output.push(`${element}: ${planets.length} (${planetList})`);
+        }
+    });
+    return output;
+}
+/**
+ * Formats modality distribution for display
+ * @param modalities Modality distribution data
+ * @returns Array of formatted strings
+ */
+function formatModalityDistribution(modalities) {
+    const output = [];
+    Object.entries(modalities).forEach(([modality, count]) => {
+        if (count > 0) {
+            output.push(`${modality}: ${count}`);
+        }
+    });
+    return output;
+}
+/**
+ * Formats polarity distribution for display
+ * @param polarities Polarity distribution data
+ * @returns Array of formatted strings
+ */
+function formatPolarityDistribution(polarities) {
+    const output = [];
+    if (polarities['Masculine'] > 0) {
+        output.push(`Masculine (Active): ${polarities['Masculine']}`);
+    }
+    if (polarities['Feminine'] > 0) {
+        output.push(`Feminine (Receptive): ${polarities['Feminine']}`);
+    }
+    return output;
+}

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,7 @@
+import { AspectPattern } from '../../../types';
+/**
+ * Generates the [ASPECT PATTERNS] section of the chart output.
+ * @param patterns Array of detected aspect patterns
+ * @returns An array of strings for the output.
+ */
+export declare function generateAspectPatternsOutput(patterns: AspectPattern[]): string[];

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

@@ -0,0 +1,175 @@
+"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) {
+    const degInSign = Math.floor((0, astrology_1.getDegreeInSign)(planet.degree));
+    const houseStr = planet.house ? ` (${(0, formatting_1.getOrdinal)(planet.house)} house)` : '';
+    return `${planet.name} ${degInSign}° ${planet.sign}${houseStr}`;
+}
+/**
+ * Format a T-Square pattern
+ */
+function formatTSquare(pattern) {
+    if (pattern.type !== 'T-Square')
+        return [];
+    const output = ['T-Square:'];
+    output.push(`  - Apex: ${formatPlanetPosition(pattern.apex)}`);
+    output.push(`  - Opposition: ${formatPlanetPosition(pattern.opposition[0])} - ${formatPlanetPosition(pattern.opposition[1])}`);
+    output.push(`  - Mode: ${pattern.mode}`);
+    output.push(`  - Average orb: ${pattern.averageOrb.toFixed(1)}°`);
+    output.push('');
+    return output;
+}
+/**
+ * Format a Grand Trine pattern
+ */
+function formatGrandTrine(pattern) {
+    if (pattern.type !== 'Grand Trine')
+        return [];
+    const output = ['Grand Trine:'];
+    pattern.planets.forEach((planet, index) => {
+        output.push(`  - Planet ${index + 1}: ${formatPlanetPosition(planet)}`);
+    });
+    output.push(`  - Element: ${pattern.element}`);
+    output.push(`  - Average orb: ${pattern.averageOrb.toFixed(1)}°`);
+    output.push('');
+    return output;
+}
+/**
+ * Format a Stellium pattern
+ */
+function formatStellium(pattern) {
+    if (pattern.type !== 'Stellium')
+        return [];
+    const output = ['Stellium:'];
+    const planetNames = pattern.planets.map((p) => p.name).join(', ');
+    output.push(`  - Planets: ${planetNames}`);
+    if (pattern.sign) {
+        output.push(`  - Sign: ${pattern.sign}`);
+    }
+    if (pattern.houses.length > 0) {
+        const houseStr = pattern.houses.length === 1
+            ? `${(0, formatting_1.getOrdinal)(pattern.houses[0])}`
+            : pattern.houses.map((h) => (0, formatting_1.getOrdinal)(h)).join('-');
+        output.push(`  - Houses: ${houseStr}`);
+    }
+    output.push(`  - Span: ${pattern.span.toFixed(1)}°`);
+    output.push('');
+    return output;
+}
+/**
+ * Format a Grand Cross pattern
+ */
+function formatGrandCross(pattern) {
+    if (pattern.type !== 'Grand Cross')
+        return [];
+    const output = ['Grand Cross:'];
+    pattern.planets.forEach((planet, index) => {
+        output.push(`  - Planet ${index + 1}: ${formatPlanetPosition(planet)}`);
+    });
+    output.push(`  - Mode: ${pattern.mode}`);
+    output.push(`  - Average orb: ${pattern.averageOrb.toFixed(1)}°`);
+    output.push('');
+    return output;
+}
+/**
+ * Format a Yod pattern
+ */
+function formatYod(pattern) {
+    if (pattern.type !== 'Yod')
+        return [];
+    const output = ['Yod:'];
+    output.push(`  - Apex: ${formatPlanetPosition(pattern.apex)}`);
+    output.push(`  - Base planet 1: ${formatPlanetPosition(pattern.base[0])}`);
+    output.push(`  - Base planet 2: ${formatPlanetPosition(pattern.base[1])}`);
+    output.push(`  - Average orb: ${pattern.averageOrb.toFixed(1)}°`);
+    output.push('');
+    return output;
+}
+/**
+ * Format a Mystic Rectangle pattern
+ */
+function formatMysticRectangle(pattern) {
+    if (pattern.type !== 'Mystic Rectangle')
+        return [];
+    const output = ['Mystic Rectangle:'];
+    output.push(`  - Opposition 1: ${formatPlanetPosition(pattern.oppositions[0][0])} - ${formatPlanetPosition(pattern.oppositions[0][1])}`);
+    output.push(`  - Opposition 2: ${formatPlanetPosition(pattern.oppositions[1][0])} - ${formatPlanetPosition(pattern.oppositions[1][1])}`);
+    output.push(`  - Average orb: ${pattern.averageOrb.toFixed(1)}°`);
+    output.push('');
+    return output;
+}
+/**
+ * Format a Kite pattern
+ */
+function formatKite(pattern) {
+    if (pattern.type !== 'Kite')
+        return [];
+    const output = ['Kite:'];
+    const grandTrineStr = pattern.grandTrine.map((p) => p.name).join(', ');
+    output.push(`  - Grand Trine planets: ${grandTrineStr}`);
+    output.push(`  - Opposition planet: ${formatPlanetPosition(pattern.opposition)}`);
+    output.push(`  - Average orb: ${pattern.averageOrb.toFixed(1)}°`);
+    output.push('');
+    return output;
+}
+/**
+ * Generates the [ASPECT PATTERNS] section of the chart output.
+ * @param patterns Array of detected aspect patterns
+ * @returns An array of strings for the output.
+ */
+function generateAspectPatternsOutput(patterns) {
+    const output = ['[ASPECT PATTERNS]'];
+    if (patterns.length === 0) {
+        output.push('No aspect patterns detected.');
+        return output;
+    }
+    // Sort patterns by type for consistent output
+    const sortOrder = [
+        'T-Square',
+        'Grand Trine',
+        'Grand Cross',
+        'Stellium',
+        'Yod',
+        'Mystic Rectangle',
+        'Kite',
+    ];
+    const sortedPatterns = patterns.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));
+                break;
+            case 'Grand Trine':
+                output.push(...formatGrandTrine(pattern));
+                break;
+            case 'Stellium':
+                output.push(...formatStellium(pattern));
+                break;
+            case 'Grand Cross':
+                output.push(...formatGrandCross(pattern));
+                break;
+            case 'Yod':
+                output.push(...formatYod(pattern));
+                break;
+            case 'Mystic Rectangle':
+                output.push(...formatMysticRectangle(pattern));
+                break;
+            case 'Kite':
+                output.push(...formatKite(pattern));
+                break;
+        }
+    });
+    // Remove trailing empty line
+    if (output[output.length - 1] === '') {
+        output.pop();
+    }
+    return output;
+}

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

@@ -24,15 +24,15 @@ p2IsTransit = false) {
         });
         if (categoryAspects.length > 0) {
             aspectsFoundInAnyCategory = true;
-            let orbRangeStr = `orb < ${category.maxOrb.toFixed(1)}°`;
+            let orbRangeStr = `orb under ${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
+                        : `orb over ${category.minOrb.toFixed(1)}° & under ${category.maxOrb.toFixed(1)}°`; // Fallback for unusual category def
             }
-            output.push(`[${category.name.toUpperCase()}: ${orbRangeStr}]`);
+            output.push(`[${category.name}: ${orbRangeStr}]`);
             categoryAspects.sort((a, b) => a.orb - b.orb); // Sort by orb tightness
             categoryAspects.forEach((asp) => {
                 const p1NameStr = p1ChartName
@@ -50,7 +50,10 @@ p2IsTransit = false) {
                     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)}°`);
+                const applicationStr = asp.application && asp.application !== 'exact'
+                    ? ` (${asp.application})`
+                    : '';
+                output.push(`${p1NameStr} ${asp.aspectType} ${p2NameStr}: ${asp.orb.toFixed(1)}°${applicationStr}`);
             });
         }
     });

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,7 @@
+import { Point } from '../../../types';
+/**
+ * Generates the [DISPOSITOR TREE] section of the chart output.
+ * @param planets Array of planet points.
+ * @returns An array of strings for the output.
+ */
+export declare function generateDispositorsOutput(planets: Point[]): string[];

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDispositorsOutput = generateDispositorsOutput;
+const dispositors_1 = require("../../../core/dispositors");
+/**
+ * Generates the [DISPOSITOR TREE] section of the chart output.
+ * @param planets Array of planet points.
+ * @returns An array of strings for the output.
+ */
+function generateDispositorsOutput(planets) {
+    const output = ['[DISPOSITOR TREE]'];
+    if (planets.length === 0) {
+        output.push('No planets available for dispositor analysis.');
+        return output;
+    }
+    const analysis = (0, dispositors_1.analyzeDispositors)(planets);
+    const formattedAnalysis = (0, dispositors_1.formatDispositorAnalysis)(analysis);
+    output.push(...formattedAnalysis);
+    return output;
+}

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

@@ -1,32 +1,8 @@
 "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");
+const houseCalculations_1 = require("../../../utils/houseCalculations");
 /**
  * Generates the [HOUSE OVERLAYS] section for synastry.
  * @param chart1 The first chart data.
@@ -43,12 +19,12 @@ function generateHouseOverlaysOutput(chart1, chart2, settings) {
         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}`);
+                const houseNumber = (0, houseCalculations_1.getHouseForPoint)(planet.degree, chart2.houseCusps);
+                if (houseNumber) {
+                    output.push(`- ${planet.name}: ${(0, formatting_1.getOrdinal)(houseNumber)}`);
                 }
                 else {
-                    output.push(`${planet.name}: (Could not determine house in ${c2Name})`);
+                    output.push(`- ${planet.name}: (Could not determine house in ${c2Name})`);
                 }
             });
         }
@@ -65,12 +41,12 @@ function generateHouseOverlaysOutput(chart1, chart2, settings) {
         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}`);
+                const houseNumber = (0, houseCalculations_1.getHouseForPoint)(planet.degree, chart1.houseCusps);
+                if (houseNumber) {
+                    output.push(`- ${planet.name}: ${(0, formatting_1.getOrdinal)(houseNumber)}`);
                 }
                 else {
-                    output.push(`${planet.name}: (Could not determine house in ${c1Name})`);
+                    output.push(`- ${planet.name}: (Could not determine house in ${c1Name})`);
                 }
             });
         }

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[];

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateHousesOutput = generateHousesOutput;
+const astrology_1 = require("../../../core/astrology");
+const formatting_1 = require("../../../utils/formatting");
+/**
+ * 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.
+ */
+function generateHousesOutput(houseCusps) {
+    const output = ['[HOUSE CUSPS]'];
+    if (!houseCusps || houseCusps.length !== 12) {
+        output.push('House cusps not available');
+        return output;
+    }
+    // Format houses in two columns: 1-6 and 7-12
+    for (let i = 0; i < 6; i++) {
+        const leftHouseIndex = i;
+        const rightHouseIndex = i + 6;
+        const leftCusp = houseCusps[leftHouseIndex];
+        const rightCusp = houseCusps[rightHouseIndex];
+        const leftSign = (0, astrology_1.getDegreeSign)(leftCusp);
+        const leftDegInSign = Math.floor((0, astrology_1.getDegreeInSign)(leftCusp));
+        const leftHouseLabel = (0, formatting_1.getOrdinal)(leftHouseIndex + 1) + ' house';
+        const rightSign = (0, astrology_1.getDegreeSign)(rightCusp);
+        const rightDegInSign = Math.floor((0, astrology_1.getDegreeInSign)(rightCusp));
+        const rightHouseLabel = (0, formatting_1.getOrdinal)(rightHouseIndex + 1) + ' house';
+        // Pad the left side to align columns
+        const leftPart = `${leftHouseLabel}: ${leftDegInSign}° ${leftSign}`;
+        const paddedLeftPart = leftPart.padEnd(24); // Adjust padding as needed
+        const rightPart = `${rightHouseLabel}: ${rightDegInSign}° ${rightSign}`;
+        output.push(`${paddedLeftPart} ${rightPart}`);
+    }
+    return output;
+}

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

@@ -2,28 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generatePlanetsOutput = generatePlanetsOutput;
 const astrology_1 = require("../../../core/astrology");
-// Helper function to determine which house a point falls into
-// (Copied from houseOverlays.ts - consider moving to a shared util if used in more places)
-function getHouseForPoint(pointDegree, houseCusps) {
-    if (!houseCusps || houseCusps.length !== 12) {
-        return 0; // Indicate failure or inability to calculate
-    }
-    for (let i = 0; i < 12; i++) {
-        const cuspStart = houseCusps[i];
-        const cuspEnd = houseCusps[(i + 1) % 12];
-        if (cuspStart < cuspEnd) {
-            if (pointDegree >= cuspStart && pointDegree < cuspEnd) {
-                return i + 1;
-            }
-        }
-        else {
-            if (pointDegree >= cuspStart || pointDegree < cuspEnd) {
-                return i + 1;
-            }
-        }
-    }
-    return 0; // Should not be reached if cusps cover 360 degrees
-}
+const dignities_1 = require("../../../core/dignities");
+const formatting_1 = require("../../../utils/formatting");
+const houseCalculations_1 = require("../../../utils/houseCalculations");
 /**
  * Generates the [PLANETS] section of the chart output.
  * @param planets Array of planet points.
@@ -36,12 +17,16 @@ function generatePlanetsOutput(planets, houseCusps, settings) {
     planets.forEach((planet) => {
         const sign = (0, astrology_1.getDegreeSign)(planet.degree);
         const degInSign = Math.floor((0, astrology_1.getDegreeInSign)(planet.degree));
-        const retrogradeIndicator = planet.speed !== undefined && planet.speed < 0 ? ' Rx' : '';
+        const retrogradeIndicator = planet.speed !== undefined && planet.speed < 0 ? ' Retrograde' : '';
+        const dignities = (0, dignities_1.formatPlanetWithDignities)(planet, houseCusps);
         let line = `${planet.name}: ${degInSign}° ${sign}${retrogradeIndicator}`;
+        if (dignities) {
+            line += ` ${dignities}`;
+        }
         if (houseCusps && houseCusps.length === 12) {
-            const houseNumber = getHouseForPoint(planet.degree, houseCusps);
-            if (houseNumber > 0) {
-                line += `, House ${houseNumber}`;
+            const houseNumber = (0, houseCalculations_1.getHouseForPoint)(planet.degree, houseCusps);
+            if (houseNumber) {
+                line += `, ${(0, formatting_1.getOrdinal)(houseNumber)} house`;
             }
         }
         output.push(line);

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

@@ -0,0 +1,25 @@
+import { Point } from '../../../types';
+/**
+ * Generates the [ELEMENT DISTRIBUTION] section of the chart output.
+ * @param planets Array of planet points.
+ * @param chartName Optional chart name for the header.
+ * @param ascendant Optional ascendant degree to include in analysis.
+ * @returns An array of strings for the output.
+ */
+export declare function generateElementDistributionOutput(planets: Point[], chartName?: string, ascendant?: number): string[];
+/**
+ * Generates the [MODALITY DISTRIBUTION] section of the chart output.
+ * @param planets Array of planet points.
+ * @param chartName Optional chart name for the header.
+ * @param ascendant Optional ascendant degree to include in analysis.
+ * @returns An array of strings for the output.
+ */
+export declare function generateModalityDistributionOutput(planets: Point[], chartName?: string, ascendant?: number): string[];
+/**
+ * Generates the [POLARITY] section of the chart output.
+ * @param planets Array of planet points.
+ * @param chartName Optional chart name for the header.
+ * @param ascendant Optional ascendant degree to include in analysis.
+ * @returns An array of strings for the output.
+ */
+export declare function generatePolarityOutput(planets: Point[], chartName?: string, ascendant?: number): string[];