chart2txt 0.5.2 → 0.7.0

package/dist/core/aspects.js

@@ -2,31 +2,130 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.calculateAspects = calculateAspects;
 exports.calculateMultichartAspects = calculateMultichartAspects;
-function findTightestAspect(aspectDefinitions, planetA, planetB, skipOutOfSignAspects) {
-    let diff = Math.abs(planetA.degree - planetB.degree);
+const astrology_1 = require("./astrology");
+const precision_1 = require("../utils/precision");
+/**
+ * Gets the expected sign difference for a given aspect angle
+ * @param aspectAngle The aspect angle in degrees
+ * @returns The expected sign difference
+ */
+function getExpectedSignDifference(aspectAngle) {
+    // Normalize aspect angle to 0-180 range for sign difference calculation
+    const normalizedAngle = aspectAngle <= 180 ? aspectAngle : 360 - aspectAngle;
+    // Calculate how many 30-degree signs this aspect spans
+    switch (normalizedAngle) {
+        case 0:
+            return 0; // Conjunction: same sign
+        case 30:
+            return 1; // Semi-sextile: 1 sign apart
+        case 60:
+            return 2; // Sextile: 2 signs apart
+        case 90:
+            return 3; // Square: 3 signs apart
+        case 120:
+            return 4; // Trine: 4 signs apart
+        case 150:
+            return 5; // Quincunx: 5 signs apart
+        case 180:
+            return 6; // Opposition: 6 signs apart
+        default:
+            // For non-standard aspects, calculate based on 30-degree segments
+            return Math.round(normalizedAngle / 30);
+    }
+}
+/**
+ * Determines if an aspect is applying or separating based on planet speeds
+ * @param planetA First planet
+ * @param planetB Second planet
+ * @param aspectAngle The aspect angle (0, 60, 90, 120, 180, etc.)
+ * @returns 'applying', 'separating', or 'exact'
+ */
+function determineAspectApplication(planetA, planetB, aspectAngle) {
+    // If either planet doesn't have speed data, we can't determine application
+    if (planetA.speed === undefined || planetB.speed === undefined) {
+        return 'exact';
+    }
+    const speedA = planetA.speed;
+    const speedB = planetB.speed;
+    // Calculate current angular distance (handle wraparound properly)
+    const degreeA = (0, astrology_1.normalizeDegree)(planetA.degree);
+    const degreeB = (0, astrology_1.normalizeDegree)(planetB.degree);
+    let currentDistance = Math.abs(degreeA - degreeB);
+    if (currentDistance > 180) {
+        currentDistance = 360 - currentDistance;
+    }
+    // If very close to exact, consider it exact
+    const orbFromExact = Math.abs(currentDistance - aspectAngle);
+    if ((0, precision_1.isExactAspect)(orbFromExact)) {
+        return 'exact';
+    }
+    // Calculate relative speed (how fast the angle between planets is changing)
+    const relativeSpeed = speedA - speedB;
+    if (relativeSpeed === 0) {
+        return 'exact'; // Planets moving at same speed
+    }
+    // Use a small, consistent time increment (e.g., 0.1 days) rather than degree-based increment
+    const timeIncrement = 0.1; // days
+    // Calculate future positions after the same time period for both planets
+    const futureA = (0, astrology_1.normalizeDegree)(degreeA + speedA * timeIncrement);
+    const futureB = (0, astrology_1.normalizeDegree)(degreeB + speedB * timeIncrement);
+    // Calculate current and future angular distances for this aspect
+    const currentAspectDistance = Math.abs(currentDistance - aspectAngle);
+    let futureSeparation = Math.abs(futureA - futureB);
+    if (futureSeparation > 180) {
+        futureSeparation = 360 - futureSeparation;
+    }
+    const futureAspectDistance = Math.abs(futureSeparation - aspectAngle);
+    // If future distance to exact aspect is smaller, it's applying
+    // If future distance to exact aspect is larger, it's separating
+    const isApplying = futureAspectDistance < currentAspectDistance;
+    return isApplying ? 'applying' : 'separating';
+}
+/**
+ * Finds the tightest aspect between two planets using simple orb detection
+ * @param aspectDefinitions Array of aspect types to check for
+ * @param planetA First planet
+ * @param planetB Second planet
+ * @param skipOutOfSignAspects Whether to skip aspects that cross sign boundaries
+ * @param aspectStrengthThresholds Thresholds for classifying aspect strength
+ * @param p1ChartName Optional chart name for planetA
+ * @param p2ChartName Optional chart name for planetB
+ * @returns The tightest aspect found, or null if none
+ */
+function findTightestAspect(aspectDefinitions, planetA, planetB, skipOutOfSignAspects, p1ChartName, p2ChartName) {
+    const degreeA = (0, precision_1.roundDegrees)((0, astrology_1.normalizeDegree)(planetA.degree));
+    const degreeB = (0, precision_1.roundDegrees)((0, astrology_1.normalizeDegree)(planetB.degree));
+    let diff = Math.abs(degreeA - degreeB);
     if (diff > 180)
         diff = 360 - diff;
     let tightestAspect = null;
     for (const aspectType of aspectDefinitions) {
-        const orb = Math.abs(diff - aspectType.angle);
+        const orb = (0, precision_1.roundDegrees)(Math.abs(diff - aspectType.angle));
         if (skipOutOfSignAspects) {
-            const planetASign = Math.floor(planetA.degree / 30);
-            const planetBSign = Math.floor(planetB.degree / 30);
-            const aspectSignDiff = Math.floor(aspectType.angle / 30);
-            let signDiff = Math.abs(planetASign - planetBSign);
-            if (signDiff > 6)
-                signDiff = 12 - signDiff;
-            if (signDiff !== aspectSignDiff) {
+            const planetASign = Math.floor(degreeA / 30);
+            const planetBSign = Math.floor(degreeB / 30);
+            // Calculate expected sign difference for this aspect
+            const expectedSignDiff = getExpectedSignDifference(aspectType.angle);
+            let actualSignDiff = Math.abs(planetASign - planetBSign);
+            if (actualSignDiff > 6)
+                actualSignDiff = 12 - actualSignDiff;
+            if (actualSignDiff !== expectedSignDiff) {
                 continue;
             }
         }
-        if (orb <= aspectType.orb) {
+        // Use simple orb from aspect definition
+        const maxAllowedOrb = aspectType.orb;
+        if (orb <= maxAllowedOrb) {
             if (!tightestAspect || orb < tightestAspect.orb) {
+                const application = determineAspectApplication(planetA, planetB, aspectType.angle);
                 tightestAspect = {
                     planetA: planetA.name,
                     planetB: planetB.name,
+                    p1ChartName,
+                    p2ChartName,
                     aspectType: aspectType.name,
                     orb,
+                    application,
                 };
             }
         }
@@ -34,20 +133,23 @@ function findTightestAspect(aspectDefinitions, planetA, planetB, skipOutOfSignAs
     return tightestAspect;
 }
 /**
- * Identifies aspects between planets in a single chart.
+ * Unified aspect calculation function that handles both single-chart and multi-chart scenarios
  * @param aspectDefinitions Array of aspect types to check for.
- * @param planets Array of planet points.
+ * @param unionedPlanets Array of UnionedPoint pairs to analyze.
+ * @param skipOutOfSignAspects Whether to skip aspects that cross sign boundaries.
+ * @param aspectStrengthThresholds Thresholds for classifying aspect strength.
+ * @param forceChartType Optional override for chart type determination.
  * @returns Array of found aspects.
  */
-function calculateAspects(aspectDefinitions, planets, skipOutOfSignAspects = true) {
+function calculateAspects(aspectDefinitions, unionedPlanets, skipOutOfSignAspects = true) {
     const aspects = [];
-    if (!planets || planets.length < 2)
+    if (!unionedPlanets || unionedPlanets.length < 2)
         return aspects;
-    for (let i = 0; i < planets.length; i++) {
-        for (let j = i + 1; j < planets.length; j++) {
-            const planetA = planets[i];
-            const planetB = planets[j];
-            const aspect = findTightestAspect(aspectDefinitions, planetA, planetB, skipOutOfSignAspects);
+    for (let i = 0; i < unionedPlanets.length; i++) {
+        for (let j = i + 1; j < unionedPlanets.length; j++) {
+            const [planetA, chartNameA] = unionedPlanets[i];
+            const [planetB, chartNameB] = unionedPlanets[j];
+            const aspect = findTightestAspect(aspectDefinitions, planetA, planetB, skipOutOfSignAspects, chartNameA, chartNameB);
             if (aspect) {
                 aspects.push(aspect);
             }
@@ -56,28 +158,28 @@ function calculateAspects(aspectDefinitions, planets, skipOutOfSignAspects = tru
     return aspects;
 }
 /**
- * Identifies aspects between planets across two charts.
- * PlanetA is always from chart1Planets, PlanetB always from chart2Planets.
- * @param aspectDefinitions Array of aspect types to check for.
- * @param chart1Planets Array of planet points for the first chart.
- * @param chart2Planets Array of planet points for the second chart.
- * @returns Array of found aspects.
+ * Calculates aspects in a multi-chart context (synastry, transits, etc.)
+ * @param aspectDefinitions Array of aspect types to check for
+ * @param unionedPlanets Array of UnionedPoint pairs to analyze
+ * @param skipOutOfSignAspects Whether to skip aspects that cross sign boundaries
+ * @param aspectStrengthThresholds Thresholds for classifying aspect strength
+ * @returns Array of found aspects
  */
-function calculateMultichartAspects(aspectDefinitions, chart1Planets, chart2Planets, skipOutOfSignAspects = true) {
-    const aspects = [];
-    if (!chart1Planets ||
-        !chart2Planets ||
-        chart1Planets.length === 0 ||
-        chart2Planets.length === 0) {
-        return aspects;
-    }
-    for (const p1 of chart1Planets) {
-        for (const p2 of chart2Planets) {
-            const aspect = findTightestAspect(aspectDefinitions, p1, p2, skipOutOfSignAspects);
-            if (aspect) {
-                aspects.push(aspect);
+function calculateMultichartAspects(aspectDefinitions, unionedPlanets, skipOutOfSignAspects = true) {
+    // Filter to only cross-chart aspects
+    const crossChartAspects = [];
+    for (let i = 0; i < unionedPlanets.length; i++) {
+        for (let j = i + 1; j < unionedPlanets.length; j++) {
+            const [planetA, chartNameA] = unionedPlanets[i];
+            const [planetB, chartNameB] = unionedPlanets[j];
+            // Only calculate aspects between planets from different charts
+            if (chartNameA !== chartNameB) {
+                const aspect = findTightestAspect(aspectDefinitions, planetA, planetB, skipOutOfSignAspects, chartNameA, chartNameB);
+                if (aspect) {
+                    crossChartAspects.push(aspect);
+                }
             }
         }
     }
-    return aspects;
+    return crossChartAspects;
 }

package/dist/core/astrology.d.ts

@@ -1,12 +1,18 @@
+/**
+ * Normalizes a degree value to the 0-359.999... range.
+ * @param degree The degree value to normalize.
+ * @returns The normalized degree value.
+ */
+export declare function normalizeDegree(degree: number): number;
 /**
  * Determines the zodiac sign for a given degree.
- * @param degree The absolute degree (0-359.99...).
+ * @param degree The absolute degree (any value, will be normalized).
  * @returns The zodiac sign name.
  */
 export declare function getDegreeSign(degree: number): string;
 /**
  * Calculates the degree within its 30-degree sign (0-29.99...).
- * @param degree The absolute degree (0-359.99...).
+ * @param degree The absolute degree (any value, will be normalized).
  * @returns The degree within the sign.
  */
 export declare function getDegreeInSign(degree: number): number;

package/dist/core/astrology.js

@@ -1,27 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeDegree = normalizeDegree;
 exports.getDegreeSign = getDegreeSign;
 exports.getDegreeInSign = getDegreeInSign;
 const constants_1 = require("../constants");
+/**
+ * Normalizes a degree value to the 0-359.999... range.
+ * @param degree The degree value to normalize.
+ * @returns The normalized degree value.
+ */
+function normalizeDegree(degree) {
+    if (!isFinite(degree)) {
+        throw new Error(`Invalid degree value: ${degree}`);
+    }
+    let normalized = degree % 360;
+    if (normalized < 0) {
+        normalized += 360;
+    }
+    return normalized;
+}
 /**
  * Determines the zodiac sign for a given degree.
- * @param degree The absolute degree (0-359.99...).
+ * @param degree The absolute degree (any value, will be normalized).
  * @returns The zodiac sign name.
  */
 function getDegreeSign(degree) {
-    const signIndex = Math.floor(degree / 30) % 12;
+    const normalizedDegree = normalizeDegree(degree);
+    const signIndex = Math.floor(normalizedDegree / 30);
     if (signIndex < 0 || signIndex >= constants_1.ZODIAC_SIGNS.length) {
-        // This should ideally not happen with degree % 12 logic if degree is positive
-        console.error(`Invalid sign index computed: ${signIndex} for degree ${degree}`);
+        console.error(`Invalid sign index computed: ${signIndex} for normalized degree ${normalizedDegree}`);
         return 'Unknown Sign';
     }
     return constants_1.ZODIAC_SIGNS[signIndex];
 }
 /**
  * Calculates the degree within its 30-degree sign (0-29.99...).
- * @param degree The absolute degree (0-359.99...).
+ * @param degree The absolute degree (any value, will be normalized).
  * @returns The degree within the sign.
  */
 function getDegreeInSign(degree) {
-    return degree % 30;
+    const normalizedDegree = normalizeDegree(degree);
+    return normalizedDegree % 30;
 }

package/dist/core/dignities.d.ts

@@ -0,0 +1,2 @@
+import { PlanetPosition } from '../types';
+export declare function formatPlanetWithDignities(planet: PlanetPosition): string;

package/dist/core/dignities.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatPlanetWithDignities = formatPlanetWithDignities;
+const constants_1 = require("../constants");
+const DIGNITY_MAP = {
+    Sun: {
+        Leo: ['Domicile'],
+        Aries: ['Exaltation'],
+        Aquarius: ['Detriment'],
+        Libra: ['Fall'],
+    },
+    Moon: {
+        Cancer: ['Domicile'],
+        Taurus: ['Exaltation'],
+        Capricorn: ['Detriment'],
+        Scorpio: ['Fall'],
+    },
+    Mercury: {
+        Gemini: ['Domicile'],
+        Virgo: ['Domicile', 'Exaltation'],
+        Pisces: ['Detriment', 'Fall'],
+        Sagittarius: ['Detriment'],
+    },
+    Venus: {
+        Taurus: ['Domicile'],
+        Libra: ['Domicile'],
+        Scorpio: ['Detriment'],
+        Aries: ['Fall'],
+        Virgo: ['Fall'],
+    },
+    Mars: {
+        Aries: ['Domicile'],
+        Scorpio: ['Domicile'],
+        Libra: ['Detriment'],
+        Cancer: ['Fall'],
+    },
+    Jupiter: {
+        Sagittarius: ['Domicile'],
+        Pisces: ['Domicile'],
+        Gemini: ['Detriment'],
+        Virgo: ['Fall'],
+    },
+    Saturn: {
+        Capricorn: ['Domicile'],
+        Aquarius: ['Domicile'],
+        Cancer: ['Detriment'],
+        Leo: ['Fall'],
+    },
+};
+function formatPlanetWithDignities(planet) {
+    const sign = planet.sign;
+    const dignities = DIGNITY_MAP[planet.name];
+    const ruler = constants_1.ZODIAC_SIGN_DATA.find((s) => s.name === sign)?.ruler;
+    const dignityParts = [];
+    if (dignities && dignities[sign]) {
+        dignityParts.push(...dignities[sign]);
+    }
+    let dignityString = dignityParts.join(', ');
+    if (ruler && planet.name !== ruler) {
+        if (dignityString) {
+            dignityString += ` | Ruler: ${ruler}`;
+        }
+        else {
+            dignityString = `Ruler: ${ruler}`;
+        }
+    }
+    if (dignityString) {
+        return `[${dignityString}]`;
+    }
+    return '';
+}

package/dist/core/dispositors.d.ts

@@ -0,0 +1,9 @@
+import { Point } from '../types';
+/**
+ * Calculates the full dispositor chain for each planet in the chart.
+ * @param planets The list of planets in the chart.
+ * @returns A map of each planet to its full dispositor chain string.
+ */
+export declare function calculateDispositors(planets: Point[]): {
+    [key: string]: string;
+};

package/dist/core/dispositors.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateDispositors = calculateDispositors;
+const constants_1 = require("../constants");
+const formatting_1 = require("../utils/formatting");
+/**
+ * Calculates the dispositor for a single planet.
+ * @param planet The planet to find the dispositor for.
+ * @returns The name of the dispositor planet.
+ */
+function getDispositor(planet) {
+    const sign = (0, formatting_1.getSign)(planet.degree);
+    const signData = constants_1.ZODIAC_SIGN_DATA.find((s) => s.name === sign);
+    return signData ? signData.ruler : 'Unknown';
+}
+/**
+ * Calculates the full dispositor chain for each planet in the chart.
+ * @param planets The list of planets in the chart.
+ * @returns A map of each planet to its full dispositor chain string.
+ */
+function calculateDispositors(planets) {
+    const dispositorMap = {};
+    planets.forEach((p) => {
+        dispositorMap[p.name] = getDispositor(p);
+    });
+    const chains = {};
+    planets.forEach((planet) => {
+        const path = [planet.name];
+        let current = planet.name;
+        let chain = `${current}`;
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const nextDispositor = dispositorMap[current];
+            // eslint-disable-next-line no-prototype-builtins
+            if (!nextDispositor || !dispositorMap.hasOwnProperty(nextDispositor)) {
+                // Dispositor is not in the chart, so the chain ends.
+                chain += ` → ${nextDispositor} (not in chart)`;
+                break;
+            }
+            if (nextDispositor === current) {
+                // Planet is its own dispositor (final dispositor).
+                chain += ` → (final)`;
+                break;
+            }
+            if (path.includes(nextDispositor)) {
+                // A loop is detected.
+                chain += ` → ${nextDispositor} (cycle)`;
+                break;
+            }
+            path.push(nextDispositor);
+            chain += ` → ${nextDispositor}`;
+            current = nextDispositor;
+        }
+        chains[planet.name] = chain;
+    });
+    return chains;
+}

package/dist/core/grouping.d.ts

@@ -0,0 +1,9 @@
+import { AspectData, Settings } from '../types';
+/**
+ * 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.
+ */
+export declare function groupAspects(aspects: AspectData[], settings: Settings): Map<string, AspectData[]>;

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

@@ -0,0 +1,21 @@
+import { Point } from '../types';
+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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateSignDistributions = calculateSignDistributions;
+exports.formatElementDistribution = formatElementDistribution;
+exports.formatModalityDistribution = formatModalityDistribution;
+exports.formatPolarityDistribution = formatPolarityDistribution;
+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: [],
+        Air: [],
+        Water: [],
+    };
+    const modalities = {
+        Cardinal: 0,
+        Fixed: 0,
+        Mutable: 0,
+    };
+    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 };
+}
+function formatElementDistribution(elements) {
+    return Object.entries(elements).map(([element, planets]) => {
+        if (planets.length === 0) {
+            return `${element}: 0`;
+        }
+        return `${element}: ${planets.length} (${planets.join(', ')})`;
+    });
+}
+function formatModalityDistribution(modalities) {
+    return Object.entries(modalities).map(([modality, count]) => `${modality}: ${count}`);
+}
+function formatPolarityDistribution(polarities) {
+    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[];