jyotish-calc 1.1.0

package/README.md

@@ -0,0 +1,140 @@
+
+# Jyotish Calculations
+
+A comprehensive JavaScript library for Vedic Astrology (Jyotish) calculations and interpretations.
+
+## Overview
+
+This package provides tools and utilities for performing various Vedic Astrology calculations, including planetary positions, nakshatras (lunar mansions), rashis (zodiac signs), bhavas (houses), planetary periods (dashas), divisional charts (vargas), and planetary strengths (shadbala). It leverages the Swiss Ephemeris for precise astronomical calculations.
+
+## Installation
+
+```bash
+npm install jyotish-calc
+```
+
+## Features
+
+- **Graha Calculations**: Calculate positions and aspects of the nine planets (grahas)
+- **Nakshatra Determinations**: Calculate and interpret the 27 lunar mansions
+- **Rashi Calculations**: Determine zodiac sign positions and interpretations
+- **Bhava Analysis**: House system calculations and interpretations
+- **Dasha Systems**: Full support for 7 dasha systems (Vimshottari, Ashtottari, Yogini, etc.) with 5-level sub-periods
+- **Divisional Charts (Vargas)**: Precise calculations for all 21 divisional charts (D1-D60)
+- **Shadbala & Bhavabala**: Comprehensive 6-fold planetary strength and house strength calculations
+
+## Project Structure
+
+```
+jyotish
+├── index.js            # Main entry point
+├── package.json        # Package configuration
+└── src
+   ├── bhavas           # House calculations
+   ├── dashas           # Dasha periods (Vimshottari, Jaimini, etc.)
+   ├── grahas           # Planetary calculations
+   ├── nakshatras       # Lunar mansion calculations
+   ├── rashis           # Zodiac sign calculations
+   ├── strengths        # Shadbala and Bhavabala
+   ├── vargas           # Divisional charts (D1-D60)
+   └── utils            # Helper utilities
+```
+
+## Usage
+
+### Basic Planetary Positions
+
+```javascript
+const jyotish = require('jyotish-calc');
+
+const date = new Date('1990-01-01T12:00:00Z');
+const location = {
+  latitude: 28.6139,  // Delhi, India
+  longitude: 77.2090,
+  altitude: 0
+};
+
+// Calculate planet positions
+const planetPositions = jyotish.grahas.calculatePositions(date, location);
+console.log(planetPositions);
+```
+
+### Dasha Calculations
+
+Calculate planetary periods for any of the 7 supported systems (Vimshottari, Ashtottari, Yogini, Kalachakra, Chara, Sthira, Narayana).
+
+```javascript
+const { dashas } = require('jyotish-calc');
+
+const moonLongitude = 280.5; // Capricorn 10.5 degrees
+const birthDate = '1990-01-01';
+
+// Calculate Vimshottari Dasha
+const vimshottari = dashas.getDashas(moonLongitude, 'Vimshottari', birthDate);
+console.log(vimshottari);
+
+// Get dashas running on a specific date
+const currentDasha = dashas.getDashasForDate(moonLongitude, 'Vimshottari', birthDate, '2025-01-01');
+/* Output:
+{
+  mahadasha: { lord: 'Jupiter', end: '2026-05-12' },
+  antardasha: { lord: 'Saturn', end: '2024-11-20' },
+  pratyantardasha: { lord: 'Mercury', end: '2025-03-25' },
+  ...
+}
+*/
+```
+
+### Divisional Charts (Vargas)
+
+Calculate any of the 21 standard divisional charts (D1, D2, D3, D4, D7, D9, D10, D12, D16, D20, D24, D27, D30, D40, D45, D60).
+
+```javascript
+const { vargas } = require('jyotish-calc');
+
+const sunLongitude = 45.5; // Taurus 15.5 degrees
+
+// Calculate single varga (e.g. Navamsha D9)
+const navamsha = vargas.calculateVarga(sunLongitude, 'D9');
+console.log(navamsha.sign); // "Taurus"
+
+// Calculate full varga chart for all planets
+const planetLongitudes = { Sun: 45.5, Moon: 120.3, /* ... */ };
+const navamshaChart = vargas.calculateVargaChart(planetLongitudes, 'D9');
+```
+
+### Shadbala & Bhavabala (Strengths)
+
+Calculate the comprehensive six-fold strength (Shadbala) of planets and house strengths (Bhavabala).
+
+```javascript
+const { strengths } = require('jyotish-calc');
+
+// Planet positions: [[signIndex, degree], ...] for Sun(0) to Saturn(6)
+// Sign Index: 0=Aries, 1=Taurus, ... 11=Pisces
+const positions = [
+    [0, 15],   // Sun in Aries 15°
+    [1, 20],   // Moon in Taurus 20°
+    // ... Mars, Mercury, Jupiter, Venus, Saturn
+];
+const ascendant = 0; // Aries
+const jd = 2451545; // Julian Day Number
+
+// Calculate complete Shadbala
+const result = strengths.calculateShadbala(positions, ascendant, jd, 28.6, 77.2);
+
+console.log(result.strength); // Array of relative strength ratios (1.0 = minimum requirement)
+console.log(result.total);    // Array of total virupas (points)
+
+// Calculate House Strengths (Bhavabala)
+const bhavaStrength = strengths.calculateBhavaBala(positions, ascendant, jd, 28.6, 77.2);
+console.log(bhavaStrength.total);
+```
+
+## Dependencies
+
+- [swisseph-v2](https://www.npmjs.com/package/swisseph-v2): v1.0.4 - Swiss Ephemeris library for astronomical calculations
+
+## License
+
+ISC

package/index.js

@@ -0,0 +1,17 @@
+const grahas = require('./src/grahas/index');
+const nakshatras = require('./src/nakshatras/index');
+const rashis = require('./src/rashis/index');
+const utils = require('./src/utils/index');
+const dashas = require('./src/dashas/index');
+const vargas = require('./src/vargas/index');
+const strengths = require('./src/strengths/index');
+
+module.exports = {
+    grahas,
+    nakshatras,
+    rashis,
+    utils,
+    dashas,
+    vargas,
+    strengths
+}

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "jyotish-calc",
+  "version": "1.1.0",
+  "description": "Comprehensive Vedic Astrology library with Planet Positions, Dashas, Vargas (Divisional Charts), and Shadbala (Strengths)",
+  "main": "index.js",
+  "scripts": {
+    "test": "jest",
+    "test:unit": "jest --watch"
+  },
+  "repository": {
+    "type": "git"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "swisseph-v2": "^1.0.4"
+  },
+  "devDependencies": {
+    "jest": "^26.0.1"
+  }
+}

package/src/bhavas/getBhavas.js

@@ -0,0 +1,5 @@
+const calculateLagna = (tt, {lat, lng}, lagna_type) => {
+    let Houses = swisseph.swe_houses_ex(tt, swisseph.SEFLG_SIDEREAL, lat, lng, lagna_type);
+    console.log('Houses', Houses);
+    return Houses.ascendant;
+}

package/src/dashas/ashtottari.js

@@ -0,0 +1,409 @@
+/**
+ * Ashtottari Dasha - 108-year planetary dasha system
+ * Uses 8 planets (excludes Ketu)
+ * Applied under specific conditions based on Rahu placement
+ * 
+ * Supports 5 levels of sub-periods:
+ * 1. Mahadasha (major period)
+ * 2. Antardasha (sub-period)
+ * 3. Pratyantardasha (sub-sub-period)
+ * 4. Sookshmadasha (subtle period)
+ * 5. Pranadasha (breath period)
+ */
+
+const {
+    ASHTOTTARI_PERIODS,
+    ASHTOTTARI_LORDS,
+    ASHTOTTARI_NAKSHATRA_MAPPING,
+    ASHTOTTARI_TOTAL_YEARS,
+    NAKSHATRAS
+} = require('./constants');
+
+const {
+    getNakshatraDetails,
+    addDays,
+    yearsToDays,
+    createDashaPeriod,
+    validateMoonLongitude,
+    validateBirthDate
+} = require('./utils');
+
+/**
+ * Get the Ashtottari dasha lord for a given nakshatra
+ * Ashtottari uses a different nakshatra mapping than Vimshottari
+ * @param {number} nakshatraIndex - Nakshatra index (0-26)
+ * @returns {string} Planet name (lord of the nakshatra in Ashtottari)
+ */
+function getDashaLordFromNakshatra(nakshatraIndex) {
+    const normalizedIndex = ((nakshatraIndex % 27) + 27) % 27;
+
+    // Find which lord rules this nakshatra
+    for (const [lord, nakshatras] of Object.entries(ASHTOTTARI_NAKSHATRA_MAPPING)) {
+        if (nakshatras.includes(normalizedIndex)) {
+            return lord;
+        }
+    }
+
+    // Fallback - calculate based on sequence
+    // Ashtottari nakshatras start from Ardra (5)
+    const offset = (normalizedIndex - 5 + 27) % 27;
+    const lordIndex = Math.floor(offset / 3) % 8;
+    return ASHTOTTARI_LORDS[lordIndex];
+}
+
+/**
+ * Get the index of a lord in the Ashtottari sequence
+ * @param {string} lord - Planet name
+ * @returns {number} Index (0-7)
+ */
+function getLordIndex(lord) {
+    const index = ASHTOTTARI_LORDS.indexOf(lord);
+    if (index === -1) {
+        throw new Error(`Invalid Ashtottari lord: ${lord}. Valid: ${ASHTOTTARI_LORDS.join(', ')}`);
+    }
+    return index;
+}
+
+/**
+ * Check if Ashtottari dasha is applicable for a chart
+ * Traditional conditions for Ashtottari applicability:
+ * - Rahu in kendra/trikona from lagna lord
+ * - Born in Krishna Paksha (waning Moon)
+ * - Night birth with Moon in dark half
+ * 
+ * @param {Object} chartData - Chart data with planet positions and birth details
+ * @returns {Object} { applicable: boolean, reason: string }
+ */
+function isApplicable(chartData) {
+    // Simple check - always return true with note about manual verification
+    // Full implementation would check Rahu's position relative to lagna lord
+
+    if (!chartData) {
+        return {
+            applicable: true,
+            reason: 'No chart data provided - applicability not determined. Ashtottari can be calculated but verify conditions.'
+        };
+    }
+
+    // TODO: Implement full applicability check when chart data structure is defined
+    // Check: Rahu in kendra (1,4,7,10) or trikona (1,5,9) from lagna lord's sign
+
+    return {
+        applicable: true,
+        reason: 'Ashtottari applicability requires manual verification of Rahu placement and lunar phase.'
+    };
+}
+
+/**
+ * Calculate the balance of dasha at birth
+ * @param {number} moonLongitude - Moon's longitude in degrees (0-360)
+ * @returns {Object} { lord, totalYears, remainingYears, consumedYears, consumedFraction }
+ */
+function calculateBalanceAtBirth(moonLongitude) {
+    moonLongitude = validateMoonLongitude(moonLongitude);
+
+    const nakshatraDetails = getNakshatraDetails(moonLongitude);
+    const lord = getDashaLordFromNakshatra(nakshatraDetails.nakshatraIndex);
+    const totalYears = ASHTOTTARI_PERIODS[lord];
+
+    const consumedFraction = nakshatraDetails.consumedFraction;
+    const consumedYears = totalYears * consumedFraction;
+    const remainingYears = totalYears - consumedYears;
+
+    return {
+        lord,
+        nakshatraIndex: nakshatraDetails.nakshatraIndex,
+        nakshatraName: NAKSHATRAS[nakshatraDetails.nakshatraIndex],
+        pada: nakshatraDetails.pada,
+        totalYears,
+        remainingYears,
+        consumedYears,
+        consumedFraction,
+        remainingDays: yearsToDays(remainingYears)
+    };
+}
+
+/**
+ * Calculate all 8 Mahadasha periods starting from birth
+ * @param {Date} birthDate - Date of birth
+ * @param {number} moonLongitude - Moon's longitude in degrees
+ * @returns {Array} Array of 8 mahadasha period objects
+ */
+function calculateMahadashas(birthDate, moonLongitude) {
+    birthDate = validateBirthDate(birthDate);
+    moonLongitude = validateMoonLongitude(moonLongitude);
+
+    const balance = calculateBalanceAtBirth(moonLongitude);
+    const startingLordIndex = getLordIndex(balance.lord);
+
+    const mahadashas = [];
+    let currentDate = new Date(birthDate);
+
+    for (let i = 0; i < 8; i++) {
+        const lordIndex = (startingLordIndex + i) % 8;
+        const lord = ASHTOTTARI_LORDS[lordIndex];
+
+        let periodYears;
+        if (i === 0) {
+            periodYears = balance.remainingYears;
+        } else {
+            periodYears = ASHTOTTARI_PERIODS[lord];
+        }
+
+        const periodDays = yearsToDays(periodYears);
+        const endDate = addDays(currentDate, periodDays);
+
+        const mahaDasha = createDashaPeriod(lord, currentDate, endDate, 1, null);
+        mahaDasha.isFirstPeriod = (i === 0);
+        mahaDasha.fullPeriodYears = ASHTOTTARI_PERIODS[lord];
+        mahaDasha.dashaSystem = 'Ashtottari';
+
+        mahadashas.push(mahaDasha);
+        currentDate = endDate;
+    }
+
+    return mahadashas;
+}
+
+/**
+ * Calculate Antardasha (sub-periods) within a Mahadasha
+ * @param {Object} mahadasha - Mahadasha period object
+ * @returns {Array} Array of 8 antardasha period objects
+ */
+function calculateAntardashas(mahadasha) {
+    const mahaLord = mahadasha.lord;
+    const startingLordIndex = getLordIndex(mahaLord);
+
+    const mahaDurationDays = mahadasha.durationDays;
+    const antardashas = [];
+    let currentDate = new Date(mahadasha.startDate);
+
+    for (let i = 0; i < 8; i++) {
+        const lordIndex = (startingLordIndex + i) % 8;
+        const lord = ASHTOTTARI_LORDS[lordIndex];
+        const lordYears = ASHTOTTARI_PERIODS[lord];
+
+        const antarDays = (mahaDurationDays * lordYears) / ASHTOTTARI_TOTAL_YEARS;
+        const endDate = addDays(currentDate, antarDays);
+
+        const antardasha = createDashaPeriod(lord, currentDate, endDate, 2, mahaLord);
+        antardasha.mahaLord = mahaLord;
+        antardasha.dashaSystem = 'Ashtottari';
+
+        antardashas.push(antardasha);
+        currentDate = endDate;
+    }
+
+    return antardashas;
+}
+
+/**
+ * Calculate Pratyantardasha within an Antardasha
+ * @param {Object} antardasha - Antardasha period object
+ * @returns {Array} Array of 8 pratyantardasha period objects
+ */
+function calculatePratyantardashas(antardasha) {
+    const antarLord = antardasha.lord;
+    const startingLordIndex = getLordIndex(antarLord);
+
+    const antarDurationDays = antardasha.durationDays;
+    const pratyantardashas = [];
+    let currentDate = new Date(antardasha.startDate);
+
+    for (let i = 0; i < 8; i++) {
+        const lordIndex = (startingLordIndex + i) % 8;
+        const lord = ASHTOTTARI_LORDS[lordIndex];
+        const lordYears = ASHTOTTARI_PERIODS[lord];
+
+        const pratyantarDays = (antarDurationDays * lordYears) / ASHTOTTARI_TOTAL_YEARS;
+        const endDate = addDays(currentDate, pratyantarDays);
+
+        const pratyantardasha = createDashaPeriod(lord, currentDate, endDate, 3, antarLord);
+        pratyantardasha.mahaLord = antardasha.mahaLord;
+        pratyantardasha.antarLord = antarLord;
+        pratyantardasha.dashaSystem = 'Ashtottari';
+
+        pratyantardashas.push(pratyantardasha);
+        currentDate = endDate;
+    }
+
+    return pratyantardashas;
+}
+
+/**
+ * Calculate Sookshmadasha within a Pratyantardasha
+ * @param {Object} pratyantardasha - Pratyantardasha period object
+ * @returns {Array} Array of 8 sookshmadasha period objects
+ */
+function calculateSookshmadashas(pratyantardasha) {
+    const pratyantarLord = pratyantardasha.lord;
+    const startingLordIndex = getLordIndex(pratyantarLord);
+
+    const pratyantarDurationDays = pratyantardasha.durationDays;
+    const sookshmadashas = [];
+    let currentDate = new Date(pratyantardasha.startDate);
+
+    for (let i = 0; i < 8; i++) {
+        const lordIndex = (startingLordIndex + i) % 8;
+        const lord = ASHTOTTARI_LORDS[lordIndex];
+        const lordYears = ASHTOTTARI_PERIODS[lord];
+
+        const sookshmaDays = (pratyantarDurationDays * lordYears) / ASHTOTTARI_TOTAL_YEARS;
+        const endDate = addDays(currentDate, sookshmaDays);
+
+        const sookshmadasha = createDashaPeriod(lord, currentDate, endDate, 4, pratyantarLord);
+        sookshmadasha.mahaLord = pratyantardasha.mahaLord;
+        sookshmadasha.antarLord = pratyantardasha.antarLord;
+        sookshmadasha.pratyantarLord = pratyantarLord;
+        sookshmadasha.dashaSystem = 'Ashtottari';
+
+        sookshmadashas.push(sookshmadasha);
+        currentDate = endDate;
+    }
+
+    return sookshmadashas;
+}
+
+/**
+ * Calculate Pranadasha within a Sookshmadasha
+ * @param {Object} sookshmadasha - Sookshmadasha period object
+ * @returns {Array} Array of 8 pranadasha period objects
+ */
+function calculatePranadashas(sookshmadasha) {
+    const sookshmaLord = sookshmadasha.lord;
+    const startingLordIndex = getLordIndex(sookshmaLord);
+
+    const sookshmaDurationDays = sookshmadasha.durationDays;
+    const pranadashas = [];
+    let currentDate = new Date(sookshmadasha.startDate);
+
+    for (let i = 0; i < 8; i++) {
+        const lordIndex = (startingLordIndex + i) % 8;
+        const lord = ASHTOTTARI_LORDS[lordIndex];
+        const lordYears = ASHTOTTARI_PERIODS[lord];
+
+        const pranaDays = (sookshmaDurationDays * lordYears) / ASHTOTTARI_TOTAL_YEARS;
+        const endDate = addDays(currentDate, pranaDays);
+
+        const pranadasha = createDashaPeriod(lord, currentDate, endDate, 5, sookshmaLord);
+        pranadasha.mahaLord = sookshmadasha.mahaLord;
+        pranadasha.antarLord = sookshmadasha.antarLord;
+        pranadasha.pratyantarLord = sookshmadasha.pratyantarLord;
+        pranadasha.sookshmaLord = sookshmaLord;
+        pranadasha.dashaSystem = 'Ashtottari';
+
+        pranadashas.push(pranadasha);
+        currentDate = endDate;
+    }
+
+    return pranadashas;
+}
+
+/**
+ * Get all active dasha periods for a specific date
+ * @param {Date} birthDate - Date of birth
+ * @param {number} moonLongitude - Moon's longitude in degrees
+ * @param {Date} targetDate - Date to find active periods for
+ * @returns {Object} Active periods at all 5 levels
+ */
+function getDashasForDate(birthDate, moonLongitude, targetDate) {
+    birthDate = validateBirthDate(birthDate);
+    targetDate = validateBirthDate(targetDate);
+    moonLongitude = validateMoonLongitude(moonLongitude);
+
+    if (targetDate < birthDate) {
+        throw new Error('Target date cannot be before birth date');
+    }
+
+    const mahadashas = calculateMahadashas(birthDate, moonLongitude);
+    const activeMaha = mahadashas.find(m =>
+        targetDate >= m.startDate && targetDate < m.endDate
+    );
+
+    if (!activeMaha) return null;
+
+    const antardashas = calculateAntardashas(activeMaha);
+    const activeAntar = antardashas.find(a =>
+        targetDate >= a.startDate && targetDate < a.endDate
+    );
+
+    if (!activeAntar) return { mahadasha: activeMaha };
+
+    const pratyantardashas = calculatePratyantardashas(activeAntar);
+    const activePratyantar = pratyantardashas.find(p =>
+        targetDate >= p.startDate && targetDate < p.endDate
+    );
+
+    if (!activePratyantar) return { mahadasha: activeMaha, antardasha: activeAntar };
+
+    const sookshmadashas = calculateSookshmadashas(activePratyantar);
+    const activeSookshma = sookshmadashas.find(s =>
+        targetDate >= s.startDate && targetDate < s.endDate
+    );
+
+    if (!activeSookshma) return {
+        mahadasha: activeMaha,
+        antardasha: activeAntar,
+        pratyantardasha: activePratyantar
+    };
+
+    const pranadashas = calculatePranadashas(activeSookshma);
+    const activePrana = pranadashas.find(pr =>
+        targetDate >= pr.startDate && targetDate < pr.endDate
+    );
+
+    return {
+        mahadasha: activeMaha,
+        antardasha: activeAntar,
+        pratyantardasha: activePratyantar,
+        sookshmadasha: activeSookshma,
+        pranadasha: activePrana || null
+    };
+}
+
+/**
+ * Get a compact string representation of active dashas
+ * @param {Date} birthDate - Date of birth
+ * @param {number} moonLongitude - Moon's longitude in degrees
+ * @param {Date} targetDate - Date to find active periods for
+ * @param {number} levels - Number of levels to include (1-5)
+ * @returns {string} e.g., "Venus-Mars-Jupiter"
+ */
+function getDashaString(birthDate, moonLongitude, targetDate, levels = 3) {
+    const dashas = getDashasForDate(birthDate, moonLongitude, targetDate);
+
+    if (!dashas) return null;
+
+    const parts = [];
+    if (levels >= 1 && dashas.mahadasha) parts.push(dashas.mahadasha.lord);
+    if (levels >= 2 && dashas.antardasha) parts.push(dashas.antardasha.lord);
+    if (levels >= 3 && dashas.pratyantardasha) parts.push(dashas.pratyantardasha.lord);
+    if (levels >= 4 && dashas.sookshmadasha) parts.push(dashas.sookshmadasha.lord);
+    if (levels >= 5 && dashas.pranadasha) parts.push(dashas.pranadasha.lord);
+
+    return parts.join('-');
+}
+
+module.exports = {
+    // Core functions
+    getDashaLordFromNakshatra,
+    getLordIndex,
+    isApplicable,
+    calculateBalanceAtBirth,
+
+    // Period calculations
+    calculateMahadashas,
+    calculateAntardashas,
+    calculatePratyantardashas,
+    calculateSookshmadashas,
+    calculatePranadashas,
+
+    // Query functions
+    getDashasForDate,
+    getDashaString,
+
+    // Constants
+    ASHTOTTARI_PERIODS,
+    ASHTOTTARI_LORDS,
+    ASHTOTTARI_TOTAL_YEARS
+};