chart2txt 0.6.0 → 0.7.1

package/dist/core/aspects.d.ts

@@ -1,17 +1,20 @@
-import { Point, Aspect, AspectData } from '../types';
+import { Aspect, AspectData, UnionedPoint } from '../types';
 /**
- * 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.
  */
-export declare function calculateAspects(aspectDefinitions: Aspect[], planets: Point[], skipOutOfSignAspects?: boolean): AspectData[];
+export declare function calculateAspects(aspectDefinitions: Aspect[], unionedPlanets: UnionedPoint[], skipOutOfSignAspects?: boolean): AspectData[];
 /**
- * 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
  */
-export declare function calculateMultichartAspects(aspectDefinitions: Aspect[], chart1Planets: Point[], chart2Planets: Point[], skipOutOfSignAspects?: boolean): AspectData[];
+export declare function calculateMultichartAspects(aspectDefinitions: Aspect[], unionedPlanets: UnionedPoint[], skipOutOfSignAspects?: boolean): AspectData[];

package/dist/core/aspects.js

@@ -81,7 +81,18 @@ function determineAspectApplication(planetA, planetB, aspectAngle) {
     const isApplying = futureAspectDistance < currentAspectDistance;
     return isApplying ? 'applying' : 'separating';
 }
-function findTightestAspect(aspectDefinitions, planetA, planetB, skipOutOfSignAspects) {
+/**
+ * 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);
@@ -94,7 +105,6 @@ function findTightestAspect(aspectDefinitions, planetA, planetB, skipOutOfSignAs
             const planetASign = Math.floor(degreeA / 30);
             const planetBSign = Math.floor(degreeB / 30);
             // Calculate expected sign difference for this aspect
-            // For major aspects: 0° = 0 signs, 60° = 2 signs, 90° = 3 signs, 120° = 4 signs, 180° = 6 signs
             const expectedSignDiff = getExpectedSignDifference(aspectType.angle);
             let actualSignDiff = Math.abs(planetASign - planetBSign);
             if (actualSignDiff > 6)
@@ -103,12 +113,16 @@ function findTightestAspect(aspectDefinitions, planetA, planetB, skipOutOfSignAs
                 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,
@@ -119,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);
             }
@@ -141,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/dignities.d.ts

@@ -1,27 +1,2 @@
-import { Point } from '../types';
-export interface DignityInfo {
-    rulers: string[];
-    exaltation?: string;
-    detriment?: string;
-    fall?: string;
-}
-/**
- * Gets the essential dignities for a planet in a specific sign
- * @param planetName Name of the planet
- * @param sign The zodiac sign
- * @returns Array of dignity descriptions
- */
-export declare function getPlanetDignities(planetName: string, sign: string): string[];
-/**
- * Gets the ruler(s) of a zodiac sign
- * @param sign The zodiac sign
- * @returns Array of ruling planets
- */
-export declare function getSignRulers(sign: string): string[];
-/**
- * Formats planet dignities for display
- * @param planet The planet point
- * @param houseCusps Array of house cusps (optional)
- * @returns Formatted string with dignities
- */
-export declare function formatPlanetWithDignities(planet: Point, houseCusps?: number[]): string;
+import { PlanetPosition } from '../types';
+export declare function formatPlanetWithDignities(planet: PlanetPosition): string;

package/dist/core/dignities.js

@@ -1,136 +1,71 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPlanetDignities = getPlanetDignities;
-exports.getSignRulers = getSignRulers;
 exports.formatPlanetWithDignities = formatPlanetWithDignities;
-const astrology_1 = require("./astrology");
-// Essential dignity mappings
-const SIGN_DIGNITIES = {
-    Aries: {
-        rulers: ['Mars'],
-        exaltation: 'Sun',
-        detriment: 'Venus',
-        fall: 'Saturn',
+const constants_1 = require("../constants");
+const DIGNITY_MAP = {
+    Sun: {
+        Leo: ['Domicile'],
+        Aries: ['Exaltation'],
+        Aquarius: ['Detriment'],
+        Libra: ['Fall'],
     },
-    Taurus: {
-        rulers: ['Venus'],
-        exaltation: 'Moon',
-        detriment: 'Mars',
-        fall: 'Uranus',
+    Moon: {
+        Cancer: ['Domicile'],
+        Taurus: ['Exaltation'],
+        Capricorn: ['Detriment'],
+        Scorpio: ['Fall'],
     },
-    Gemini: {
-        rulers: ['Mercury'],
-        detriment: 'Jupiter',
+    Mercury: {
+        Gemini: ['Domicile'],
+        Virgo: ['Domicile', 'Exaltation'],
+        Pisces: ['Detriment', 'Fall'],
+        Sagittarius: ['Detriment'],
     },
-    Cancer: {
-        rulers: ['Moon'],
-        exaltation: 'Jupiter',
-        detriment: 'Saturn',
-        fall: 'Mars',
+    Venus: {
+        Taurus: ['Domicile'],
+        Libra: ['Domicile'],
+        Scorpio: ['Detriment'],
+        Aries: ['Fall'],
+        Virgo: ['Fall'],
     },
-    Leo: {
-        rulers: ['Sun'],
-        detriment: 'Saturn',
-        fall: 'Neptune',
+    Mars: {
+        Aries: ['Domicile'],
+        Scorpio: ['Domicile'],
+        Libra: ['Detriment'],
+        Cancer: ['Fall'],
     },
-    Virgo: {
-        rulers: ['Mercury'],
-        exaltation: 'Mercury',
-        detriment: 'Jupiter',
-        fall: 'Venus',
+    Jupiter: {
+        Sagittarius: ['Domicile'],
+        Pisces: ['Domicile'],
+        Gemini: ['Detriment'],
+        Virgo: ['Fall'],
     },
-    Libra: {
-        rulers: ['Venus'],
-        exaltation: 'Saturn',
-        detriment: 'Mars',
-        fall: 'Sun',
-    },
-    Scorpio: {
-        rulers: ['Mars'],
-        detriment: 'Venus',
-        fall: 'Moon',
-    },
-    Sagittarius: {
-        rulers: ['Jupiter'],
-        detriment: 'Mercury',
-    },
-    Capricorn: {
-        rulers: ['Saturn'],
-        exaltation: 'Mars',
-        detriment: 'Moon',
-        fall: 'Jupiter',
-    },
-    Aquarius: {
-        rulers: ['Saturn'],
-        detriment: 'Sun',
-        fall: 'Neptune',
-    },
-    Pisces: {
-        rulers: ['Jupiter'],
-        exaltation: 'Venus',
-        detriment: 'Mercury',
-        fall: 'Mercury',
+    Saturn: {
+        Capricorn: ['Domicile'],
+        Aquarius: ['Domicile'],
+        Cancer: ['Detriment'],
+        Leo: ['Fall'],
     },
 };
-/**
- * Gets the essential dignities for a planet in a specific sign
- * @param planetName Name of the planet
- * @param sign The zodiac sign
- * @returns Array of dignity descriptions
- */
-function getPlanetDignities(planetName, sign) {
-    const dignities = [];
-    const normalizedSign = sign.trim();
-    const signInfo = SIGN_DIGNITIES[normalizedSign];
-    if (!signInfo)
-        return dignities;
-    // Check for rulership (domicile)
-    if (signInfo.rulers.includes(planetName)) {
-        dignities.push(`Domicile`);
-    }
-    // Check for exaltation
-    if (signInfo.exaltation === planetName) {
-        dignities.push(`Exaltation`);
-    }
-    // Check for detriment
-    if (signInfo.detriment === planetName) {
-        dignities.push(`Detriment`);
-    }
-    // Check for fall
-    if (signInfo.fall && signInfo.fall === planetName) {
-        dignities.push(`Fall`);
-    }
-    return dignities;
-}
-/**
- * Gets the ruler(s) of a zodiac sign
- * @param sign The zodiac sign
- * @returns Array of ruling planets
- */
-function getSignRulers(sign) {
-    const normalizedSign = sign.trim();
-    const signInfo = SIGN_DIGNITIES[normalizedSign];
-    return signInfo ? signInfo.rulers : [];
-}
-/**
- * Formats planet dignities for display
- * @param planet The planet point
- * @param houseCusps Array of house cusps (optional)
- * @returns Formatted string with dignities
- */
-function formatPlanetWithDignities(planet, houseCusps) {
-    const sign = (0, astrology_1.getDegreeSign)(planet.degree);
-    const dignities = getPlanetDignities(planet.name, sign);
-    const rulers = getSignRulers(sign);
-    let dignitiesStr = '';
-    if (dignities.length > 0 && dignities.includes('Domicile')) {
-        dignitiesStr = `[${dignities.join(', ')}]`;
+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]);
     }
-    else if (dignities.length > 0 && rulers.length > 0) {
-        dignitiesStr = `[${dignities.join(', ')} | Ruler: ${rulers.join(', ')}]`;
+    let dignityString = dignityParts.join(', ');
+    if (ruler && planet.name !== ruler) {
+        if (dignityString) {
+            dignityString += ` | Ruler: ${ruler}`;
+        }
+        else {
+            dignityString = `Ruler: ${ruler}`;
+        }
     }
-    else if (rulers.length > 0) {
-        dignitiesStr = `[Ruler: ${rulers.join(', ')}]`;
+    if (dignityString) {
+        return `[${dignityString}]`;
     }
-    return dignitiesStr;
+    return '';
 }

package/dist/core/dispositors.d.ts

@@ -1,22 +1,10 @@
 import { Point } from '../types';
-export interface DispositorChain {
-    planet: string;
-    disposedBy: string[];
-    disposes: string[];
-}
-export interface DispositorAnalysis {
-    chains: DispositorChain[];
-    finalDispositors: string[];
-}
 /**
- * Builds dispositor chains for all planets
- * @param planets Array of planet points
- * @returns Complete dispositor analysis
+ * Calculates the full dispositor chain for each planet in the chart.
+ * @param planets The list of planets in the chart.
+ * @param mode Controls which dispositor chains to include: true (all), false (none), 'finals' (only final dispositors and cycles).
+ * @returns A map of each planet to its full dispositor chain string, or a summary in 'finals' mode.
  */
-export declare function analyzeDispositors(planets: Point[]): DispositorAnalysis;
-/**
- * Formats the dispositor analysis for display
- * @param analysis The dispositor analysis
- * @returns Array of formatted strings
- */
-export declare function formatDispositorAnalysis(analysis: DispositorAnalysis): string[];
+export declare function calculateDispositors(planets: Point[], mode?: boolean | 'finals'): {
+    [key: string]: string;
+};