chart2txt 0.5.2 → 0.6.0

package/dist/core/aspects.js

@@ -2,31 +2,116 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.calculateAspects = calculateAspects;
 exports.calculateMultichartAspects = calculateMultichartAspects;
+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';
+}
 function findTightestAspect(aspectDefinitions, planetA, planetB, skipOutOfSignAspects) {
-    let diff = Math.abs(planetA.degree - planetB.degree);
+    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
+            // 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)
+                actualSignDiff = 12 - actualSignDiff;
+            if (actualSignDiff !== expectedSignDiff) {
                 continue;
             }
         }
         if (orb <= aspectType.orb) {
             if (!tightestAspect || orb < tightestAspect.orb) {
+                const application = determineAspectApplication(planetA, planetB, aspectType.angle);
                 tightestAspect = {
                     planetA: planetA.name,
                     planetB: planetB.name,
                     aspectType: aspectType.name,
                     orb,
+                    application,
                 };
             }
         }

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,27 @@
+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;

package/dist/core/dignities.js

@@ -0,0 +1,136 @@
+"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',
+    },
+    Taurus: {
+        rulers: ['Venus'],
+        exaltation: 'Moon',
+        detriment: 'Mars',
+        fall: 'Uranus',
+    },
+    Gemini: {
+        rulers: ['Mercury'],
+        detriment: 'Jupiter',
+    },
+    Cancer: {
+        rulers: ['Moon'],
+        exaltation: 'Jupiter',
+        detriment: 'Saturn',
+        fall: 'Mars',
+    },
+    Leo: {
+        rulers: ['Sun'],
+        detriment: 'Saturn',
+        fall: 'Neptune',
+    },
+    Virgo: {
+        rulers: ['Mercury'],
+        exaltation: 'Mercury',
+        detriment: 'Jupiter',
+        fall: 'Venus',
+    },
+    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',
+    },
+};
+/**
+ * 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(', ')}]`;
+    }
+    else if (dignities.length > 0 && rulers.length > 0) {
+        dignitiesStr = `[${dignities.join(', ')} | Ruler: ${rulers.join(', ')}]`;
+    }
+    else if (rulers.length > 0) {
+        dignitiesStr = `[Ruler: ${rulers.join(', ')}]`;
+    }
+    return dignitiesStr;
+}

package/dist/core/dispositors.d.ts

@@ -0,0 +1,22 @@
+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
+ */
+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[];

package/dist/core/dispositors.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeDispositors = analyzeDispositors;
+exports.formatDispositorAnalysis = formatDispositorAnalysis;
+const astrology_1 = require("./astrology");
+const dignities_1 = require("./dignities");
+/**
+ * Builds dispositor chains for all planets
+ * @param planets Array of planet points
+ * @returns Complete dispositor analysis
+ */
+function analyzeDispositors(planets) {
+    const dispositorMap = new Map();
+    const disposedByMap = new Map();
+    // Build the dispositor relationships
+    planets.forEach((planet) => {
+        const sign = (0, astrology_1.getDegreeSign)(planet.degree);
+        const rulers = (0, dignities_1.getSignRulers)(sign);
+        dispositorMap.set(planet.name, rulers);
+        rulers.forEach((ruler) => {
+            if (!disposedByMap.has(ruler)) {
+                disposedByMap.set(ruler, []);
+            }
+            disposedByMap.get(ruler).push(planet.name);
+        });
+    });
+    // Find final dispositors - these are the roots of dispositor trees
+    const finalDispositors = [];
+    const planetNames = new Set(planets.map((p) => p.name));
+    planets.forEach((planet) => {
+        const rulers = dispositorMap.get(planet.name) || [];
+        const isRuledBySelf = rulers.includes(planet.name);
+        const isRuledByPlanetNotInChart = rulers.length > 0 && !rulers.some((ruler) => planetNames.has(ruler));
+        // A planet is a final dispositor if:
+        // 1. It rules itself (traditional dignity)
+        // 2. It's ruled by a planet not in the chart
+        if (isRuledBySelf || isRuledByPlanetNotInChart) {
+            finalDispositors.push(planet.name);
+        }
+    });
+    // Build chains
+    const chains = planets.map((planet) => ({
+        planet: planet.name,
+        disposedBy: dispositorMap.get(planet.name) || [],
+        disposes: disposedByMap.get(planet.name) || [],
+    }));
+    return {
+        chains,
+        finalDispositors,
+    };
+}
+/**
+ * Detect cycles in dispositor chains
+ */
+function findDispositorCycles(chains) {
+    const cycles = [];
+    const visited = new Set();
+    const path = new Set();
+    function dfs(planet, currentPath) {
+        if (path.has(planet)) {
+            // Found a cycle
+            const cycleStart = currentPath.indexOf(planet);
+            if (cycleStart !== -1) {
+                const cycle = currentPath.slice(cycleStart);
+                cycle.push(planet); // Complete the cycle
+                if (cycle.length > 2) {
+                    cycles.push(cycle);
+                }
+            }
+            return;
+        }
+        if (visited.has(planet))
+            return;
+        visited.add(planet);
+        path.add(planet);
+        currentPath.push(planet);
+        const chain = chains.find((c) => c.planet === planet);
+        if (chain) {
+            // Follow the dispositor chain (only follow planets in the chart)
+            const inChartRulers = chain.disposedBy.filter((ruler) => chains.some((c) => c.planet === ruler));
+            for (const ruler of inChartRulers) {
+                dfs(ruler, [...currentPath]);
+            }
+        }
+        path.delete(planet);
+        currentPath.pop();
+    }
+    // Start DFS from each planet
+    chains.forEach((chain) => {
+        if (!visited.has(chain.planet)) {
+            dfs(chain.planet, []);
+        }
+    });
+    return cycles;
+}
+/**
+ * Builds the full dispositor chain for a planet
+ * @param planet Starting planet
+ * @param chains All dispositor chains
+ * @param pathSoFar Array to track the current path (prevents infinite loops)
+ * @returns Array of planets in the chain (excluding the starting planet)
+ */
+function buildDispositorChain(planet, chains, pathSoFar = []) {
+    const chain = chains.find((c) => c.planet === planet);
+    if (!chain || chain.disposedBy.length === 0) {
+        return ['(final)'];
+    }
+    // Get the first in-chart ruler
+    const inChartRulers = chain.disposedBy.filter((ruler) => chains.some((c) => c.planet === ruler));
+    if (inChartRulers.length === 0) {
+        return ['(final)'];
+    }
+    const ruler = inChartRulers[0];
+    // If the ruler is the same as the planet (self-ruler), it's final
+    if (ruler === planet) {
+        return ['(final)'];
+    }
+    // If we've seen this ruler in the current path, we have a cycle
+    if (pathSoFar.includes(ruler)) {
+        return ['(cycle)'];
+    }
+    // Continue the chain
+    const newPath = [...pathSoFar, planet];
+    const nextChain = buildDispositorChain(ruler, chains, newPath);
+    // If the next chain ends in (final), this whole chain ends in (final)
+    // If the next chain ends in (cycle), this chain also ends in (cycle)
+    return [ruler, ...nextChain];
+}
+/**
+ * Formats the dispositor analysis for display
+ * @param analysis The dispositor analysis
+ * @returns Array of formatted strings
+ */
+function formatDispositorAnalysis(analysis) {
+    const output = [];
+    // Build and format chains for each planet
+    analysis.chains.forEach((chainInfo) => {
+        const chainRest = buildDispositorChain(chainInfo.planet, analysis.chains);
+        const chainString = chainRest.join(' → ');
+        output.push(`${chainInfo.planet} → ${chainString}`);
+    });
+    return output;
+}

package/dist/core/signDistributions.d.ts

@@ -0,0 +1,31 @@
+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[];