chart2txt 0.6.0 → 0.7.0

package/dist/core/grouping.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupAspects = groupAspects;
+/**
+ * Provides a default grouping of aspects into "Tight", "Moderate", and "Wide" categories
+ * based on orb thresholds. This is used by the simple chart2txt() function.
+ * @param aspects The raw list of aspects to group.
+ * @param settings The chart settings, containing aspectStrengthThresholds.
+ * @returns A map of category names to aspect data arrays.
+ */
+function groupAspects(aspects, settings) {
+    const grouped = new Map();
+    const thresholds = settings.aspectStrengthThresholds;
+    const tight = [];
+    const moderate = [];
+    const wide = [];
+    aspects.forEach((aspect) => {
+        if (aspect.orb <= thresholds.tight) {
+            tight.push(aspect);
+        }
+        else if (aspect.orb <= thresholds.moderate) {
+            moderate.push(aspect);
+        }
+        else {
+            wide.push(aspect);
+        }
+    });
+    // Sort each category by orb tightness
+    tight.sort((a, b) => a.orb - b.orb);
+    moderate.sort((a, b) => a.orb - b.orb);
+    wide.sort((a, b) => a.orb - b.orb);
+    if (tight.length > 0) {
+        const title = `[TIGHT ASPECTS: orb under ${thresholds.tight.toFixed(1)}°]`;
+        grouped.set(title, tight);
+    }
+    if (moderate.length > 0) {
+        const title = `[MODERATE ASPECTS: orb ${thresholds.tight.toFixed(1)}-${thresholds.moderate.toFixed(1)}°]`;
+        grouped.set(title, moderate);
+    }
+    if (wide.length > 0) {
+        const title = `[WIDE ASPECTS: orb over ${thresholds.moderate.toFixed(1)}°]`;
+        grouped.set(title, wide);
+    }
+    return grouped;
+}

package/dist/core/signDistributions.d.ts

@@ -1,31 +1,21 @@
 import { Point } from '../types';
-export interface SignDistributions {
-    elements: Record<string, string[]>;
-    modalities: Record<string, number>;
-    polarities: Record<string, number>;
-}
-/**
- * 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
- */
-export declare function analyzeSignDistributions(planets: Point[], includeAscendant?: number): SignDistributions;
-/**
- * Formats element distribution for display
- * @param elements Element distribution data
- * @returns Array of formatted strings
- */
-export declare function formatElementDistribution(elements: Record<string, string[]>): string[];
-/**
- * Formats modality distribution for display
- * @param modalities Modality distribution data
- * @returns Array of formatted strings
- */
-export declare function formatModalityDistribution(modalities: Record<string, number>): string[];
-/**
- * Formats polarity distribution for display
- * @param polarities Polarity distribution data
- * @returns Array of formatted strings
- */
-export declare function formatPolarityDistribution(polarities: Record<string, number>): string[];
+export declare function calculateSignDistributions(planets: Point[], ascendant?: number): {
+    elements: {
+        [key: string]: string[];
+    };
+    modalities: {
+        [key: string]: number;
+    };
+    polarities: {
+        [key: string]: number;
+    };
+};
+export declare function formatElementDistribution(elements: {
+    [key: string]: string[];
+}): string[];
+export declare function formatModalityDistribution(modalities: {
+    [key: string]: number;
+}): string[];
+export declare function formatPolarityDistribution(polarities: {
+    [key: string]: number;
+}): string[];

package/dist/core/signDistributions.js

@@ -1,60 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.analyzeSignDistributions = analyzeSignDistributions;
+exports.calculateSignDistributions = calculateSignDistributions;
 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 formatting_1 = require("../utils/formatting");
+const constants_1 = require("../constants");
+function calculateSignDistributions(planets, ascendant) {
+    const points = [...planets];
+    if (ascendant !== undefined) {
+        points.push({ name: 'Ascendant', degree: ascendant });
+    }
     const elements = {
         Fire: [],
         Earth: [],
@@ -66,85 +22,29 @@ function analyzeSignDistributions(planets, includeAscendant) {
         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]++;
+    const polarities = { Masculine: 0, Feminine: 0 };
+    for (const point of points) {
+        const sign = (0, formatting_1.getSign)(point.degree);
+        const signInfo = constants_1.ZODIAC_SIGN_DATA.find((s) => s.name === sign);
+        if (signInfo) {
+            elements[signInfo.element].push(point.name);
+            modalities[signInfo.modality]++;
+            polarities[signInfo.polarity]++;
         }
     }
     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 Object.entries(elements).map(([element, planets]) => {
+        if (planets.length === 0) {
+            return `${element}: 0`;
         }
+        return `${element}: ${planets.length} (${planets.join(', ')})`;
     });
-    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;
+    return Object.entries(modalities).map(([modality, count]) => `${modality}: ${count}`);
 }
-/**
- * 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;
+    return Object.entries(polarities).map(([polarity, count]) => `${polarity}: ${count}`);
 }

package/dist/core/stelliums.d.ts

@@ -0,0 +1,10 @@
+import { Point, Stellium } from '../types';
+/**
+ * Detect Stellium patterns (3+ planets in same sign or adjacent houses)
+ * This function requires house information and is specific to single-chart analysis
+ */
+export declare function detectStelliums(planets: Point[], houseCusps?: number[], minPlanets?: number): Stellium[];
+/**
+ * Format a Stellium pattern for display in compact format
+ */
+export declare function formatStellium(pattern: Stellium): string[];

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/aspectPatterns.d.ts

@@ -2,6 +2,8 @@ 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[]): string[];
+export declare function generateAspectPatternsOutput(patterns: AspectPattern[], customTitle?: string, showChartNames?: boolean): string[];