chart2txt 0.6.0 → 0.7.1

package/dist/core/dispositors.js

@@ -1,143 +1,169 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.analyzeDispositors = analyzeDispositors;
-exports.formatDispositorAnalysis = formatDispositorAnalysis;
-const astrology_1 = require("./astrology");
-const dignities_1 = require("./dignities");
+exports.calculateDispositors = calculateDispositors;
+const constants_1 = require("../constants");
+const formatting_1 = require("../utils/formatting");
 /**
- * Builds dispositor chains for all planets
- * @param planets Array of planet points
- * @returns Complete dispositor analysis
+ * Calculates the dispositor for a single planet.
+ * @param planet The planet to find the dispositor for.
+ * @returns The name of the dispositor planet.
  */
-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,
-    };
+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';
 }
 /**
- * Detect cycles in dispositor chains
+ * Analyzes the dispositor graph for a single planet, using memoization to avoid re-computation.
+ * @param startPlanet - The planet to begin the analysis from.
+ * @param dispositorMap - A map of each planet to its direct dispositor.
+ * @param cache - A cache of already computed results to avoid redundant work.
+ * @returns The analysis result for the starting planet.
  */
-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;
+function analyzePlanetChain(startPlanet, dispositorMap, cache) {
+    if (cache[startPlanet]) {
+        return cache[startPlanet];
+    }
+    const path = [startPlanet];
+    let current = startPlanet;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const nextDispositor = dispositorMap[current];
+        if (!nextDispositor || !dispositorMap.hasOwnProperty(nextDispositor)) {
+            // Chain is broken (dispositor not in the chart)
+            const result = {
+                path: [...path, nextDispositor],
+                isCycle: false,
+                isFinal: false,
+                isBroken: true,
+            };
+            return (cache[startPlanet] = result);
         }
-        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]);
-            }
+        if (nextDispositor === current) {
+            // Final dispositor
+            const result = {
+                path,
+                isCycle: false,
+                isFinal: true,
+                isBroken: false,
+            };
+            return (cache[startPlanet] = result);
         }
-        path.delete(planet);
-        currentPath.pop();
-    }
-    // Start DFS from each planet
-    chains.forEach((chain) => {
-        if (!visited.has(chain.planet)) {
-            dfs(chain.planet, []);
+        if (path.includes(nextDispositor)) {
+            // Cycle detected
+            const cycleStartIndex = path.indexOf(nextDispositor);
+            const cyclePath = path.slice(cycleStartIndex);
+            const result = {
+                path: [...path, nextDispositor],
+                isCycle: true,
+                isFinal: false,
+                isBroken: false,
+            };
+            // Cache the result for all members of the cycle
+            cyclePath.forEach((planet) => {
+                cache[planet] = result;
+            });
+            return result;
         }
-    });
-    return cycles;
+        // If we've hit a node that's already been analyzed, we can use its result
+        if (cache[nextDispositor]) {
+            const nestedResult = cache[nextDispositor];
+            const combinedPath = [...path, ...nestedResult.path];
+            const result = { ...nestedResult, path: combinedPath };
+            return (cache[startPlanet] = result);
+        }
+        path.push(nextDispositor);
+        current = nextDispositor;
+    }
 }
 /**
- * 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)
+ * 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.
  */
-function buildDispositorChain(planet, chains, pathSoFar = []) {
-    const chain = chains.find((c) => c.planet === planet);
-    if (!chain || chain.disposedBy.length === 0) {
-        return ['(final)'];
+function calculateDispositors(planets, mode = true) {
+    if (mode === false) {
+        return {};
     }
-    // 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)'];
+    const dispositorMap = {};
+    planets.forEach((p) => {
+        dispositorMap[p.name] = getDispositor(p);
+    });
+    const analysisCache = {};
+    planets.forEach((p) => {
+        if (!analysisCache[p.name]) {
+            analyzePlanetChain(p.name, dispositorMap, analysisCache);
+        }
+    });
+    if (mode === 'finals') {
+        const finalDispositors = new Set();
+        const cycles = new Map();
+        planets.forEach((p) => {
+            if (dispositorMap[p.name] === p.name) {
+                finalDispositors.add(p.name);
+            }
+        });
+        for (const planetName in analysisCache) {
+            const result = analysisCache[planetName];
+            if (result.isCycle) {
+                const lastPlanetInPath = result.path[result.path.length - 1];
+                const cycleStartIndex = result.path.indexOf(lastPlanetInPath);
+                const cyclePlanets = result.path.slice(cycleStartIndex, -1);
+                const canonicalKey = [...new Set(cyclePlanets)].sort().join('|');
+                if (!cycles.has(canonicalKey)) {
+                    cycles.set(canonicalKey, cyclePlanets);
+                }
+            }
+        }
+        const summaryParts = [];
+        if (finalDispositors.size > 0) {
+            summaryParts.push(`Final dispositors: ${[...finalDispositors].sort().join(', ')}`);
+        }
+        if (cycles.size > 0) {
+            const formattedCycles = [...cycles.values()]
+                .map((cycle) => {
+                const uniqueCyclePlanets = [...new Set(cycle)];
+                const startNode = uniqueCyclePlanets.sort()[0];
+                const startIndex = cycle.indexOf(startNode);
+                const reordered = [
+                    ...cycle.slice(startIndex),
+                    ...cycle.slice(0, startIndex),
+                ];
+                return [...reordered, startNode].join(' → ');
+            })
+                .sort();
+            summaryParts.push(`Cycles: ${formattedCycles.join(', ')}`);
+        }
+        if (summaryParts.length === 0) {
+            return { summary: 'No final dispositors or cycles found' };
+        }
+        return { summary: summaryParts.join('; ') };
     }
-    // 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}`);
+    // Default mode: return all chains
+    const chains = {};
+    planets.forEach((p) => {
+        const planetName = p.name;
+        const path = [planetName];
+        let current = planetName;
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const nextDispositor = dispositorMap[current];
+            if (!nextDispositor || !dispositorMap.hasOwnProperty(nextDispositor)) {
+                chains[planetName] = `${path.join(' → ')} → ${nextDispositor} (not in chart)`;
+                break;
+            }
+            if (nextDispositor === current) {
+                chains[planetName] = `${path.join(' → ')} → (final)`;
+                break;
+            }
+            if (path.includes(nextDispositor)) {
+                chains[planetName] = `${path.join(' → ')} → ${nextDispositor} (cycle)`;
+                break;
+            }
+            path.push(nextDispositor);
+            current = nextDispositor;
+        }
     });
-    return output;
+    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

@@ -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,32 @@ 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})`);
+    const parts = Object.entries(elements).map(([element, planets]) => {
+        if (planets.length === 0) {
+            return `${element}: 0`;
         }
+        return `${element}: ${planets.length} (${planets.join(', ')})`;
     });
-    return output;
+    return [parts.join(' | ')];
 }
-/**
- * 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;
+    const parts = Object.entries(modalities).map(([modality, count]) => `${modality}: ${count}`);
+    return [parts.join(' | ')];
 }
-/**
- * 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;
+    const parts = Object.entries(polarities).map(([polarity, count]) => `${polarity}: ${count}`);
+    return [parts.join(' | ')];
 }

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