chart2txt 0.5.2 → 0.7.0

package/dist/constants.js

@@ -1,42 +1,311 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_SETTINGS = exports.DEFAULT_ASPECT_CATEGORIES = exports.DEFAULT_ASPECTS = exports.ZODIAC_SIGNS = void 0;
-exports.ZODIAC_SIGNS = [
-    'Aries',
-    'Taurus',
-    'Gemini',
-    'Cancer',
-    'Leo',
-    'Virgo',
-    'Libra',
-    'Scorpio',
-    'Sagittarius',
-    'Capricorn',
-    'Aquarius',
-    'Pisces',
+exports.DEFAULT_SETTINGS = exports.DEFAULT_ASPECT_STRENGTH_THRESHOLDS = exports.WIDE_ASPECTS = exports.TIGHT_ASPECTS = exports.MODERN_ASPECTS = exports.TRADITIONAL_ASPECTS = exports.SIMPLE_WIDE_ORBS = exports.SIMPLE_TIGHT_ORBS = exports.SIMPLE_MODERN_ORBS = exports.SIMPLE_TRADITIONAL_ORBS = exports.DEFAULT_ASPECTS = exports.ZODIAC_SIGNS = exports.ZODIAC_SIGN_DATA = void 0;
+const types_1 = require("./types");
+exports.ZODIAC_SIGN_DATA = [
+    {
+        name: 'Aries',
+        element: 'Fire',
+        modality: 'Cardinal',
+        polarity: 'Masculine',
+        ruler: 'Mars',
+    },
+    {
+        name: 'Taurus',
+        element: 'Earth',
+        modality: 'Fixed',
+        polarity: 'Feminine',
+        ruler: 'Venus',
+    },
+    {
+        name: 'Gemini',
+        element: 'Air',
+        modality: 'Mutable',
+        polarity: 'Masculine',
+        ruler: 'Mercury',
+    },
+    {
+        name: 'Cancer',
+        element: 'Water',
+        modality: 'Cardinal',
+        polarity: 'Feminine',
+        ruler: 'Moon',
+    },
+    {
+        name: 'Leo',
+        element: 'Fire',
+        modality: 'Fixed',
+        polarity: 'Masculine',
+        ruler: 'Sun',
+    },
+    {
+        name: 'Virgo',
+        element: 'Earth',
+        modality: 'Mutable',
+        polarity: 'Feminine',
+        ruler: 'Mercury',
+    },
+    {
+        name: 'Libra',
+        element: 'Air',
+        modality: 'Fixed',
+        polarity: 'Masculine',
+        ruler: 'Venus',
+    },
+    {
+        name: 'Scorpio',
+        element: 'Water',
+        modality: 'Fixed',
+        polarity: 'Feminine',
+        ruler: 'Mars',
+    },
+    {
+        name: 'Sagittarius',
+        element: 'Fire',
+        modality: 'Mutable',
+        polarity: 'Masculine',
+        ruler: 'Jupiter',
+    },
+    {
+        name: 'Capricorn',
+        element: 'Earth',
+        modality: 'Cardinal',
+        polarity: 'Feminine',
+        ruler: 'Saturn',
+    },
+    {
+        name: 'Aquarius',
+        element: 'Air',
+        modality: 'Fixed',
+        polarity: 'Masculine',
+        ruler: 'Saturn',
+    },
+    {
+        name: 'Pisces',
+        element: 'Water',
+        modality: 'Mutable',
+        polarity: 'Feminine',
+        ruler: 'Jupiter',
+    },
 ];
+exports.ZODIAC_SIGNS = exports.ZODIAC_SIGN_DATA.map((s) => s.name);
 exports.DEFAULT_ASPECTS = [
-    { name: 'conjunction', angle: 0, orb: 5 }, // Max orb for this aspect to be considered
-    { name: 'opposition', angle: 180, orb: 5 },
-    { name: 'trine', angle: 120, orb: 5 },
-    { name: 'square', angle: 90, orb: 5 },
-    { name: 'sextile', angle: 60, orb: 3 },
+    {
+        name: 'conjunction',
+        angle: 0,
+        orb: 5,
+        classification: types_1.AspectClassification.Major,
+    },
+    {
+        name: 'opposition',
+        angle: 180,
+        orb: 5,
+        classification: types_1.AspectClassification.Major,
+    },
+    {
+        name: 'trine',
+        angle: 120,
+        orb: 5,
+        classification: types_1.AspectClassification.Major,
+    },
+    {
+        name: 'square',
+        angle: 90,
+        orb: 5,
+        classification: types_1.AspectClassification.Major,
+    },
+    {
+        name: 'sextile',
+        angle: 60,
+        orb: 3,
+        classification: types_1.AspectClassification.Minor,
+    },
+    {
+        name: 'quincunx',
+        angle: 150,
+        orb: 2,
+        classification: types_1.AspectClassification.Minor,
+    },
 ];
-exports.DEFAULT_ASPECT_CATEGORIES = [
-    { name: 'MAJOR', maxOrb: 2 }, // Orb < 2°
-    { name: 'MODERATE', minOrb: 2, maxOrb: 4 }, // Orb 2-4°
+// Simple Orb Presets - generous orbs for detection, classification handled separately
+exports.SIMPLE_TRADITIONAL_ORBS = [
+    {
+        name: 'conjunction',
+        angle: 0,
+        orb: 10,
+        classification: types_1.AspectClassification.Major,
+    },
+    {
+        name: 'opposition',
+        angle: 180,
+        orb: 10,
+        classification: types_1.AspectClassification.Major,
+    },
+    {
+        name: 'trine',
+        angle: 120,
+        orb: 8,
+        classification: types_1.AspectClassification.Major,
+    },
+    {
+        name: 'square',
+        angle: 90,
+        orb: 8,
+        classification: types_1.AspectClassification.Major,
+    },
+    {
+        name: 'sextile',
+        angle: 60,
+        orb: 6,
+        classification: types_1.AspectClassification.Minor,
+    },
+    {
+        name: 'quincunx',
+        angle: 150,
+        orb: 4,
+        classification: types_1.AspectClassification.Minor,
+    },
 ];
+exports.SIMPLE_MODERN_ORBS = [
+    {
+        name: 'conjunction',
+        angle: 0,
+        orb: 8,
+        classification: types_1.AspectClassification.Major,
+    },
+    {
+        name: 'opposition',
+        angle: 180,
+        orb: 8,
+        classification: types_1.AspectClassification.Major,
+    },
+    {
+        name: 'trine',
+        angle: 120,
+        orb: 6,
+        classification: types_1.AspectClassification.Major,
+    },
+    {
+        name: 'square',
+        angle: 90,
+        orb: 6,
+        classification: types_1.AspectClassification.Major,
+    },
+    {
+        name: 'sextile',
+        angle: 60,
+        orb: 4,
+        classification: types_1.AspectClassification.Minor,
+    },
+    {
+        name: 'quincunx',
+        angle: 150,
+        orb: 3,
+        classification: types_1.AspectClassification.Minor,
+    },
+];
+exports.SIMPLE_TIGHT_ORBS = [
+    {
+        name: 'conjunction',
+        angle: 0,
+        orb: 4,
+        classification: types_1.AspectClassification.Major,
+    },
+    {
+        name: 'opposition',
+        angle: 180,
+        orb: 4,
+        classification: types_1.AspectClassification.Major,
+    },
+    {
+        name: 'trine',
+        angle: 120,
+        orb: 3,
+        classification: types_1.AspectClassification.Major,
+    },
+    {
+        name: 'square',
+        angle: 90,
+        orb: 3,
+        classification: types_1.AspectClassification.Major,
+    },
+    {
+        name: 'sextile',
+        angle: 60,
+        orb: 2,
+        classification: types_1.AspectClassification.Minor,
+    },
+    {
+        name: 'quincunx',
+        angle: 150,
+        orb: 1,
+        classification: types_1.AspectClassification.Minor,
+    },
+];
+exports.SIMPLE_WIDE_ORBS = [
+    {
+        name: 'conjunction',
+        angle: 0,
+        orb: 12,
+        classification: types_1.AspectClassification.Major,
+    },
+    {
+        name: 'opposition',
+        angle: 180,
+        orb: 12,
+        classification: types_1.AspectClassification.Major,
+    },
+    {
+        name: 'trine',
+        angle: 120,
+        orb: 10,
+        classification: types_1.AspectClassification.Major,
+    },
+    {
+        name: 'square',
+        angle: 90,
+        orb: 10,
+        classification: types_1.AspectClassification.Major,
+    },
+    {
+        name: 'sextile',
+        angle: 60,
+        orb: 8,
+        classification: types_1.AspectClassification.Minor,
+    },
+    {
+        name: 'quincunx',
+        angle: 150,
+        orb: 6,
+        classification: types_1.AspectClassification.Minor,
+    },
+    {
+        name: 'semi-sextile',
+        angle: 30,
+        orb: 4,
+        classification: types_1.AspectClassification.Minor,
+    },
+];
+// Legacy aliases for backwards compatibility
+exports.TRADITIONAL_ASPECTS = exports.SIMPLE_TRADITIONAL_ORBS;
+// Legacy aliases for backwards compatibility
+exports.MODERN_ASPECTS = exports.SIMPLE_MODERN_ORBS;
+exports.TIGHT_ASPECTS = exports.SIMPLE_TIGHT_ORBS;
+exports.WIDE_ASPECTS = exports.SIMPLE_WIDE_ORBS;
+// Default aspect strength thresholds
+exports.DEFAULT_ASPECT_STRENGTH_THRESHOLDS = {
+    tight: 2.0, // Aspects with orb <= 2° are classified as tight
+    moderate: 4.0, // Aspects with orb 2-4° are moderate, >4° are wide
+};
 exports.DEFAULT_SETTINGS = {
-    // sign settings
-    includeSignDegree: true, // For planets list: "Sun: 8° Cancer" vs "Sun: Cancer"
-    // house settings
-    houseSystemName: 'whole_sign',
-    includeHouseDegree: false, // New format shows "House X", not degree in house for planets list
-    // point settings
-    includeAscendant: true, // Legacy, ASC/MC now have dedicated [ANGLES] section
-    // orb + aspect settings
+    // Analysis settings
     aspectDefinitions: exports.DEFAULT_ASPECTS,
-    aspectCategories: exports.DEFAULT_ASPECT_CATEGORIES,
     skipOutOfSignAspects: true,
-    dateFormat: 'MM/DD/YYYY', // As per example output
+    includeAspectPatterns: false,
+    includeSignDistributions: true,
+    // Grouping settings
+    aspectStrengthThresholds: exports.DEFAULT_ASPECT_STRENGTH_THRESHOLDS,
+    // Formatting settings
+    houseSystemName: 'whole_sign',
+    dateFormat: 'MM/DD/YYYY',
 };

package/dist/core/analysis.d.ts

@@ -0,0 +1,6 @@
+import { ChartData, MultiChartData, AstrologicalReport, PartialSettings } from '../types';
+/**
+ * Analyzes single or multiple chart data and returns a structured report
+ * containing all detected astrological configurations without any formatting.
+ */
+export declare function analyzeCharts(data: ChartData | MultiChartData, partialSettings?: PartialSettings): AstrologicalReport;

package/dist/core/analysis.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeCharts = analyzeCharts;
+const types_1 = require("../types");
+const ChartSettings_1 = require("../config/ChartSettings");
+const validation_1 = require("../utils/validation");
+const aspects_1 = require("./aspects");
+const aspectPatterns_1 = require("./aspectPatterns");
+const stelliums_1 = require("./stelliums");
+const formatting_1 = require("../utils/formatting");
+const signDistributions_1 = require("./signDistributions");
+const dispositors_1 = require("./dispositors");
+const houseCalculations_1 = require("../utils/houseCalculations");
+// Helper functions
+function getAllPointsFromChart(chartData) {
+    const allPoints = [...chartData.planets];
+    if (chartData.ascendant !== undefined) {
+        allPoints.push({ name: 'Ascendant', degree: chartData.ascendant });
+    }
+    if (chartData.midheaven !== undefined) {
+        allPoints.push({ name: 'Midheaven', degree: chartData.midheaven });
+    }
+    return allPoints;
+}
+function getPointsForPatternDetection(chartData) {
+    // Exclude angles and nodes from pattern detection
+    const excludedNames = ['Ascendant', 'Midheaven', 'North Node', 'South Node'];
+    return chartData.planets.filter((point) => !excludedNames.includes(point.name));
+}
+function getUnionedPoints(charts, forPatternDetection = false) {
+    return charts.flatMap((chart) => {
+        const points = forPatternDetection
+            ? getPointsForPatternDetection(chart)
+            : getAllPointsFromChart(chart);
+        return points.map((p) => [p, chart.name]);
+    });
+}
+function getChartNamesFromPattern(pattern) {
+    const chartNames = new Set();
+    const planetsToVisit = [];
+    const addPlanet = (p) => {
+        if (p)
+            planetsToVisit.push(p);
+    };
+    switch (pattern.type) {
+        case 'T-Square':
+            addPlanet(pattern.apex);
+            pattern.opposition.forEach(addPlanet);
+            break;
+        case 'Grand Trine':
+            pattern.planets.forEach(addPlanet);
+            break;
+        case 'Grand Cross':
+            pattern.planets.forEach(addPlanet);
+            break;
+        case 'Yod':
+            addPlanet(pattern.apex);
+            pattern.base.forEach(addPlanet);
+            break;
+        case 'Mystic Rectangle':
+            pattern.oppositions.flat().forEach(addPlanet);
+            break;
+        case 'Kite':
+            pattern.grandTrine.forEach(addPlanet);
+            addPlanet(pattern.opposition);
+            break;
+    }
+    planetsToVisit.forEach((p) => {
+        if (p.chartName) {
+            chartNames.add(p.chartName);
+        }
+    });
+    return chartNames;
+}
+function countUniqueCharts(pattern) {
+    return getChartNamesFromPattern(pattern).size;
+}
+function patternInvolvesChart(pattern, chartName) {
+    return getChartNamesFromPattern(pattern).has(chartName);
+}
+function filterPatternsByChartCount(patterns, minCharts, maxCharts = Infinity) {
+    return patterns.filter((pattern) => {
+        const count = countUniqueCharts(pattern);
+        return count >= minCharts && count <= maxCharts;
+    });
+}
+function filterPatternsByChartInvolvement(patterns, requiredChartNames) {
+    return patterns.filter((pattern) => {
+        return requiredChartNames.some((chartName) => patternInvolvesChart(pattern, chartName));
+    });
+}
+/**
+ * Analyzes single or multiple chart data and returns a structured report
+ * containing all detected astrological configurations without any formatting.
+ */
+function analyzeCharts(data, partialSettings = {}) {
+    const validationError = (0, validation_1.validateInputData)(data);
+    if (validationError) {
+        throw new Error(`Invalid chart data: ${validationError}`);
+    }
+    const settings = new ChartSettings_1.ChartSettings(partialSettings);
+    const rawCharts = (0, types_1.isMultiChartData)(data) ? data : [data];
+    const nonTransitCharts = rawCharts.filter((c) => c.chartType !== 'transit');
+    const transitChart = rawCharts.find((c) => c.chartType === 'transit');
+    const allCharts = [
+        ...nonTransitCharts,
+        ...(transitChart ? [transitChart] : []),
+    ];
+    // === Unified Aspect Calculation ===
+    const allAspects = [];
+    const allUnionedPointsForPatterns = getUnionedPoints(allCharts, true);
+    // 1. Individual chart aspects
+    for (const chart of allCharts) {
+        const points = getUnionedPoints([chart]);
+        const aspects = (0, aspects_1.calculateAspects)(settings.resolvedAspectDefinitions, points, settings.skipOutOfSignAspects);
+        allAspects.push(...aspects);
+    }
+    // 2. Pairwise aspects (Synastry, Natal-Transit, etc.)
+    for (let i = 0; i < allCharts.length; i++) {
+        for (let j = i + 1; j < allCharts.length; j++) {
+            const chart1 = allCharts[i];
+            const chart2 = allCharts[j];
+            // Get unioned points from both charts for multi-chart analysis
+            const unionedPoints = [
+                ...getUnionedPoints([chart1]),
+                ...getUnionedPoints([chart2]),
+            ];
+            const aspects = (0, aspects_1.calculateMultichartAspects)(settings.resolvedAspectDefinitions, unionedPoints, settings.skipOutOfSignAspects);
+            allAspects.push(...aspects);
+        }
+    }
+    // === Unified Pattern Detection ===
+    const allPatterns = settings.includeAspectPatterns
+        ? (0, aspectPatterns_1.detectAspectPatterns)(allUnionedPointsForPatterns, allAspects)
+        : [];
+    // === Analysis Structuring ===
+    const chartAnalyses = [];
+    const pairwiseAnalyses = [];
+    const transitAnalyses = [];
+    let globalAnalysis;
+    let globalTransitAnalysis;
+    // Tier 1: Individual Chart Analysis
+    for (const chart of allCharts) {
+        const individualAspects = allAspects.filter((a) => a.p1ChartName === chart.name && a.p2ChartName === chart.name);
+        const individualPatterns = filterPatternsByChartCount(allPatterns, 1, 1).filter((p) => patternInvolvesChart(p, chart.name));
+        const stelliums = settings.includeAspectPatterns
+            ? (0, stelliums_1.detectStelliums)(getPointsForPatternDetection(chart), chart.houseCusps)
+            : [];
+        chartAnalyses.push({
+            chart: chart,
+            placements: {
+                planets: (0, formatting_1.getPlanetPositions)(chart.planets, chart.houseCusps),
+            },
+            aspects: individualAspects,
+            patterns: individualPatterns,
+            stelliums: stelliums,
+            signDistributions: settings.includeSignDistributions
+                ? (0, signDistributions_1.calculateSignDistributions)(chart.planets, chart.ascendant)
+                : { elements: {}, modalities: {}, polarities: {} },
+            dispositors: chart.chartType !== 'transit'
+                ? (0, dispositors_1.calculateDispositors)(chart.planets)
+                : {},
+        });
+    }
+    // Tier 2: Pairwise Synastry Analysis (non-transit charts)
+    if (nonTransitCharts.length >= 2) {
+        for (let i = 0; i < nonTransitCharts.length; i++) {
+            for (let j = i + 1; j < nonTransitCharts.length; j++) {
+                const chart1 = nonTransitCharts[i];
+                const chart2 = nonTransitCharts[j];
+                const synastryAspects = allAspects.filter((a) => (a.p1ChartName === chart1.name && a.p2ChartName === chart2.name) ||
+                    (a.p1ChartName === chart2.name && a.p2ChartName === chart1.name));
+                const compositePatterns = filterPatternsByChartCount(allPatterns, 2, 2).filter((p) => patternInvolvesChart(p, chart1.name) &&
+                    patternInvolvesChart(p, chart2.name));
+                pairwiseAnalyses.push({
+                    chart1: chart1,
+                    chart2: chart2,
+                    synastryAspects: synastryAspects,
+                    compositePatterns: compositePatterns,
+                    houseOverlays: (0, houseCalculations_1.calculateHouseOverlays)(chart1, chart2),
+                });
+            }
+        }
+    }
+    // Tier 3: Global Analysis (3+ non-transit charts)
+    if (nonTransitCharts.length > 2) {
+        const globalPatterns = filterPatternsByChartCount(allPatterns, 3).filter((p) => {
+            // Ensure no transit charts are involved
+            const involvedCharts = getChartNamesFromPattern(p);
+            return !involvedCharts.has(transitChart?.name || 'TRANSIT_PLACEHOLDER');
+        });
+        if (globalPatterns.length > 0) {
+            globalAnalysis = {
+                charts: nonTransitCharts,
+                patterns: globalPatterns,
+            };
+        }
+    }
+    // Tier 4: Transit Analysis
+    if (transitChart) {
+        for (const natalChart of nonTransitCharts) {
+            const transitAspects = allAspects.filter((a) => (a.p1ChartName === natalChart.name &&
+                a.p2ChartName === transitChart.name) ||
+                (a.p1ChartName === transitChart.name &&
+                    a.p2ChartName === natalChart.name));
+            const transitPatterns = filterPatternsByChartCount(allPatterns, 2, 2).filter((p) => patternInvolvesChart(p, natalChart.name) &&
+                patternInvolvesChart(p, transitChart.name));
+            transitAnalyses.push({
+                natalChart: natalChart,
+                transitChart: transitChart,
+                aspects: transitAspects,
+                patterns: transitPatterns,
+            });
+        }
+        // Tier 5: Global Transit Analysis (if there are natal charts)
+        if (nonTransitCharts.length > 0) {
+            const globalTransitPatterns = filterPatternsByChartInvolvement(allPatterns, [transitChart.name]).filter((p) => countUniqueCharts(p) >= 3); // Must involve transit + at least two other charts
+            if (globalTransitPatterns.length > 0) {
+                globalTransitAnalysis = {
+                    charts: allCharts,
+                    patterns: globalTransitPatterns,
+                };
+            }
+        }
+    }
+    const report = {
+        settings: settings,
+        chartAnalyses,
+        pairwiseAnalyses,
+        globalAnalysis,
+        transitAnalyses,
+        globalTransitAnalysis,
+    };
+    return report;
+}

package/dist/core/aspectPatterns.d.ts

@@ -0,0 +1,10 @@
+import { AspectData, AspectPattern, UnionedPoint } from '../types';
+/**
+ * Main function to detect aspect patterns (excluding stelliums which are handled separately)
+ * This function works with both single-chart and multi-chart scenarios
+ * @param planets Array of planets to analyze
+ * @param aspects Pre-calculated aspects between planets
+ * @param houseCusps Optional house cusps for single-chart reference
+ * @param planetChartMap Optional mapping from planet name to chart name for multichart ownership context
+ */
+export declare function detectAspectPatterns(unionedPoints: UnionedPoint[], aspects: AspectData[], houseCusps?: number[]): AspectPattern[];