@swisseph/node 1.0.6 → 1.2.0

package/README.md

@@ -42,7 +42,7 @@ npm install --global windows-build-tools
 
 ```typescript
 import {
-  julianDay,
+  dateToJulianDay,
   calculatePosition,
   calculateHouses,
   Planet,
@@ -51,8 +51,9 @@ import {
 
 // No setup required! Ephemeris files are bundled and auto-loaded.
 
-// Calculate planetary position
-const jd = julianDay(2007, 3, 3);
+// Calculate planetary position using Date object
+const date = new Date('2007-03-03T00:00:00Z');
+const jd = dateToJulianDay(date);
 const sun = calculatePosition(jd, Planet.Sun);
 console.log(`Sun: ${sun.longitude}°`);
 
@@ -67,10 +68,28 @@ console.log(`MC: ${houses.mc}°`);
 ### Date & Time
 
 ```typescript
+// Convert JavaScript Date to Julian day (recommended)
+dateToJulianDay(date, calendarType?)
+
+// Convert date components to Julian day
 julianDay(year, month, day, hour?, calendarType?)
+
+// Convert Julian day back to date
 julianDayToDate(jd, calendarType?)
 ```
 
+**Examples:**
+```typescript
+// Using Date object (easiest)
+const jd = dateToJulianDay(new Date('1990-05-15T14:30:00Z'));
+
+// Using date components
+const jd2 = julianDay(1990, 5, 15, 14.5);  // Same result
+
+// Current time
+const now = dateToJulianDay(new Date());
+```
+
 ### Planetary Positions
 
 ```typescript
@@ -147,7 +166,7 @@ import {
 
 ```typescript
 import {
-  julianDay,
+  dateToJulianDay,
   calculatePosition,
   calculateHouses,
   Planet,
@@ -156,7 +175,8 @@ import {
 } from '@swisseph/node';
 
 // Birth: May 15, 1990, 14:30 UTC, New York (40.7128°N, 74.0060°W)
-const jd = julianDay(1990, 5, 15, 14.5);
+const birthDate = new Date('1990-05-15T14:30:00Z');
+const jd = dateToJulianDay(birthDate);
 
 // Calculate all planet positions
 const planets = [
@@ -220,9 +240,10 @@ close();
 ### Planetary Aspects
 
 ```typescript
-import { julianDay, calculatePosition, Planet, close } from '@swisseph/node';
+import { dateToJulianDay, calculatePosition, Planet, close } from '@swisseph/node';
 
-const jd = julianDay(2025, 6, 15);
+// Calculate for current time
+const jd = dateToJulianDay(new Date());
 
 // Calculate positions
 const sun = calculatePosition(jd, Planet.Sun);

package/binding/swisseph_binding.cc

@@ -249,6 +249,115 @@ Napi::Value Houses(const Napi::CallbackInfo& info) {
   return result;
 }
 
+// Wrapper for swe_set_sid_mode
+Napi::Value SetSidMode(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 1) {
+    Napi::TypeError::New(env, "Expected sid_mode, [t0], [ayan_t0]")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  int32 sid_mode = info[0].As<Napi::Number>().Int32Value();
+  double t0 = info.Length() >= 2 ? info[1].As<Napi::Number>().DoubleValue() : 0.0;
+  double ayan_t0 = info.Length() >= 3 ? info[2].As<Napi::Number>().DoubleValue() : 0.0;
+
+  swe_set_sid_mode(sid_mode, t0, ayan_t0);
+
+  return env.Undefined();
+}
+
+// Wrapper for swe_set_topo
+Napi::Value SetTopo(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 3) {
+    Napi::TypeError::New(env, "Expected geolon, geolat, geoalt")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  double geolon = info[0].As<Napi::Number>().DoubleValue();
+  double geolat = info[1].As<Napi::Number>().DoubleValue();
+  double geoalt = info[2].As<Napi::Number>().DoubleValue();
+
+  swe_set_topo(geolon, geolat, geoalt);
+
+  return env.Undefined();
+}
+
+// Wrapper for swe_get_ayanamsa_ut
+Napi::Value GetAyanamsaUt(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 1) {
+    Napi::TypeError::New(env, "Expected tjd_ut")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  double tjd_ut = info[0].As<Napi::Number>().DoubleValue();
+  double ayanamsa = swe_get_ayanamsa_ut(tjd_ut);
+
+  return Napi::Number::New(env, ayanamsa);
+}
+
+// Wrapper for swe_rise_trans
+Napi::Value RiseTrans(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 4) {
+    Napi::TypeError::New(env, "Expected tjd_ut, ipl, rsmi, geopos (array), [epheflag], [atpress], [attemp]")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  double tjd_ut = info[0].As<Napi::Number>().DoubleValue();
+  int32 ipl = info[1].As<Napi::Number>().Int32Value();
+  int32 rsmi = info[2].As<Napi::Number>().Int32Value();
+
+  // geopos is expected as an array [longitude, latitude, altitude]
+  if (!info[3].IsArray()) {
+    Napi::TypeError::New(env, "geopos must be an array [longitude, latitude, altitude]")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  Napi::Array geoposArray = info[3].As<Napi::Array>();
+  if (geoposArray.Length() < 3) {
+    Napi::TypeError::New(env, "geopos must have 3 elements [longitude, latitude, altitude]")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  double geopos[3];
+  geopos[0] = geoposArray.Get(0u).As<Napi::Number>().DoubleValue();
+  geopos[1] = geoposArray.Get(1u).As<Napi::Number>().DoubleValue();
+  geopos[2] = geoposArray.Get(2u).As<Napi::Number>().DoubleValue();
+
+  int32 epheflag = info.Length() >= 5 ? info[4].As<Napi::Number>().Int32Value() : SEFLG_SWIEPH;
+  double atpress = info.Length() >= 6 ? info[5].As<Napi::Number>().DoubleValue() : 0.0;
+  double attemp = info.Length() >= 7 ? info[6].As<Napi::Number>().DoubleValue() : 0.0;
+
+  double tret;
+  char serr[256];
+
+  // starname is NULL for planets (only used for fixed stars)
+  int32 ret = swe_rise_trans(tjd_ut, ipl, NULL, epheflag, rsmi, geopos, atpress, attemp, &tret, serr);
+
+  if (ret < 0) {
+    Napi::Error::New(env, serr).ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  Napi::Array result = Napi::Array::New(env, 2);
+  result[0u] = Napi::Number::New(env, ret);
+  result[1u] = Napi::Number::New(env, tret);
+
+  return result;
+}
+
 // Initialize the addon
 Napi::Object Init(Napi::Env env, Napi::Object exports) {
   exports.Set("set_ephe_path", Napi::Function::New(env, SetEphePath));
@@ -260,6 +369,10 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
   exports.Set("lun_eclipse_when", Napi::Function::New(env, LunEclipseWhen));
   exports.Set("sol_eclipse_when_glob", Napi::Function::New(env, SolEclipseWhenGlob));
   exports.Set("houses", Napi::Function::New(env, Houses));
+  exports.Set("set_sid_mode", Napi::Function::New(env, SetSidMode));
+  exports.Set("set_topo", Napi::Function::New(env, SetTopo));
+  exports.Set("get_ayanamsa_ut", Napi::Function::New(env, GetAyanamsaUt));
+  exports.Set("rise_trans", Napi::Function::New(env, RiseTrans));
 
   return exports;
 }

package/dist/index.d.ts

@@ -4,7 +4,7 @@
  * This module provides a modern, type-safe API for Swiss Ephemeris astronomical calculations.
  * It wraps the native C library with developer-friendly TypeScript interfaces.
  */
-import { CalendarType, CelestialBody, HouseSystem, CalculationFlagInput, EclipseTypeFlagInput, PlanetaryPosition, HouseData, LunarEclipse, SolarEclipse, ExtendedDateTime } from '@swisseph/core';
+import { CalendarType, CelestialBody, HouseSystem, CalculationFlagInput, EclipseTypeFlagInput, PlanetaryPosition, HouseData, LunarEclipse, SolarEclipse, ExtendedDateTime, RiseTransitSet } from '@swisseph/core';
 /**
  * Set the directory path for ephemeris files
  *
@@ -42,6 +42,29 @@ export declare function setEphemerisPath(path?: string | null): void;
  * console.log(jdWithTime); // 2454163.104166667
  */
 export declare function julianDay(year: number, month: number, day: number, hour?: number, calendarType?: CalendarType): number;
+/**
+ * Calculate Julian day number from a JavaScript Date object
+ *
+ * Convenience function that converts a JavaScript Date to Julian day number.
+ * The Date is interpreted as UTC.
+ *
+ * @param date - JavaScript Date object (interpreted as UTC)
+ * @param calendarType - Calendar system (default: Gregorian)
+ * @returns Julian day number
+ *
+ * @example
+ * // From Date object
+ * const date = new Date('1990-05-15T14:30:00Z');
+ * const jd = dateToJulianDay(date);
+ *
+ * // From timestamp
+ * const now = new Date();
+ * const jdNow = dateToJulianDay(now);
+ *
+ * // Equivalent to julianDay(1990, 5, 15, 14.5)
+ * const jd2 = dateToJulianDay(new Date(Date.UTC(1990, 4, 15, 14, 30)));
+ */
+export declare function dateToJulianDay(date: Date, calendarType?: CalendarType): number;
 /**
  * Convert Julian day number to calendar date
  *
@@ -178,6 +201,173 @@ export declare function findNextSolarEclipse(startJulianDay: number, flags?: Cal
  * console.log(sunName); // "Sun"
  */
 export declare function getCelestialBodyName(body: CelestialBody): string;
+/**
+ * Set the sidereal mode (ayanamsa system) for sidereal calculations
+ *
+ * This function must be called before calculating sidereal positions with
+ * CalculationFlag.Sidereal. Different ayanamsa systems are used in various
+ * traditions of astrology, particularly in Vedic (Jyotish) astrology.
+ *
+ * @param siderealMode - Ayanamsa system to use (e.g., SiderealMode.Lahiri for Vedic)
+ * @param t0 - Reference date (Julian day) for custom ayanamsa (default: 0)
+ * @param ayanT0 - Initial value of ayanamsa in degrees for custom mode (default: 0)
+ *
+ * @example
+ * import { setSiderealMode, SiderealMode, calculatePosition, CalculationFlag, Planet } from '@swisseph/node';
+ *
+ * // Set Lahiri ayanamsa (most common in Vedic astrology)
+ * setSiderealMode(SiderealMode.Lahiri);
+ *
+ * // Calculate sidereal position of Sun
+ * const jd = julianDay(2025, 1, 1);
+ * const sun = calculatePosition(jd, Planet.Sun, CalculationFlag.Sidereal | CalculationFlag.Speed);
+ * console.log(`Sidereal Sun: ${sun.longitude}°`);
+ *
+ * // Set Raman ayanamsa
+ * setSiderealMode(SiderealMode.Raman);
+ *
+ * // Set custom ayanamsa
+ * setSiderealMode(SiderealMode.UserDefined, 2451545.0, 23.85);
+ */
+export declare function setSiderealMode(siderealMode: number, t0?: number, ayanT0?: number): void;
+/**
+ * Set the geographic location for topocentric calculations
+ *
+ * This function must be called before calculating topocentric positions with
+ * CalculationFlag.Topocentric. Topocentric positions account for the observer's
+ * location on Earth, which is particularly important for the Moon due to parallax.
+ *
+ * @param longitude - Geographic longitude in degrees (positive = east, negative = west)
+ * @param latitude - Geographic latitude in degrees (positive = north, negative = south)
+ * @param altitude - Altitude above sea level in meters
+ *
+ * @example
+ * import { setTopocentric, calculatePosition, CalculationFlag, Planet } from '@swisseph/node';
+ *
+ * // Set location to New York City
+ * setTopocentric(-74.0060, 40.7128, 10); // lon, lat, altitude
+ *
+ * // Calculate topocentric Moon position
+ * const jd = julianDay(2025, 1, 1);
+ * const moon = calculatePosition(
+ *   jd,
+ *   Planet.Moon,
+ *   CalculationFlag.Topocentric | CalculationFlag.Speed
+ * );
+ * console.log(`Topocentric Moon: ${moon.longitude}°`);
+ *
+ * // Set location to Mumbai for Vedic calculations
+ * setTopocentric(72.8777, 19.0760, 14);
+ * setSiderealMode(SiderealMode.Lahiri);
+ * const siderealMoon = calculatePosition(
+ *   jd,
+ *   Planet.Moon,
+ *   CalculationFlag.Sidereal | CalculationFlag.Topocentric | CalculationFlag.Speed
+ * );
+ */
+export declare function setTopocentric(longitude: number, latitude: number, altitude: number): void;
+/**
+ * Get the ayanamsa (sidereal offset) value for a given date
+ *
+ * The ayanamsa is the distance between the tropical and sidereal zodiacs.
+ * This function returns the current offset in degrees for the ayanamsa system
+ * that was set with setSiderealMode().
+ *
+ * @param julianDay - Julian day number in Universal Time
+ * @returns Ayanamsa value in degrees
+ *
+ * @example
+ * import { getAyanamsa, setSiderealMode, SiderealMode, julianDay } from '@swisseph/node';
+ *
+ * // Get Lahiri ayanamsa for a date
+ * setSiderealMode(SiderealMode.Lahiri);
+ * const jd = julianDay(2025, 1, 1);
+ * const ayanamsa = getAyanamsa(jd);
+ * console.log(`Lahiri ayanamsa: ${ayanamsa.toFixed(4)}°`);
+ *
+ * // Compare different ayanamsa systems
+ * setSiderealMode(SiderealMode.Raman);
+ * const ramanAyanamsa = getAyanamsa(jd);
+ * console.log(`Raman ayanamsa: ${ramanAyanamsa.toFixed(4)}°`);
+ *
+ * setSiderealMode(SiderealMode.Krishnamurti);
+ * const kpAyanamsa = getAyanamsa(jd);
+ * console.log(`KP ayanamsa: ${kpAyanamsa.toFixed(4)}°`);
+ */
+export declare function getAyanamsa(julianDay: number): number;
+/**
+ * Calculate rise, transit, or set time for a celestial body
+ *
+ * Finds the time when a celestial body rises, transits (culminates), or sets
+ * for a given location. This is essential for calculating almanac data,
+ * planetary hours, and observational astrology.
+ *
+ * @param startJulianDay - Julian day to start search from
+ * @param body - Celestial body to calculate
+ * @param eventType - Type of event (RiseTransitFlag.Rise, Set, UpperTransit, or LowerTransit)
+ * @param longitude - Geographic longitude in degrees (positive = east, negative = west)
+ * @param latitude - Geographic latitude in degrees (positive = north, negative = south)
+ * @param altitude - Altitude above sea level in meters
+ * @param flags - Calculation flags (default: SwissEphemeris)
+ * @param atmosphericPressure - Atmospheric pressure in millibars (default: 0 = standard)
+ * @param atmosphericTemperature - Atmospheric temperature in Celsius (default: 0 = standard)
+ * @returns RiseTransitSet object with time of event
+ *
+ * @example
+ * import {
+ *   calculateRiseTransitSet,
+ *   RiseTransitFlag,
+ *   Planet,
+ *   julianDay,
+ *   julianDayToDate
+ * } from '@swisseph/node';
+ *
+ * // Find sunrise in New York
+ * const jd = julianDay(2025, 1, 1);
+ * const sunrise = calculateRiseTransitSet(
+ *   jd,
+ *   Planet.Sun,
+ *   RiseTransitFlag.Rise,
+ *   -74.0060,  // New York longitude
+ *   40.7128,   // New York latitude
+ *   10         // altitude in meters
+ * );
+ * console.log(`Sunrise: ${julianDayToDate(sunrise.time)}`);
+ *
+ * // Find moonrise
+ * const moonrise = calculateRiseTransitSet(
+ *   jd,
+ *   Planet.Moon,
+ *   RiseTransitFlag.Rise,
+ *   -74.0060,
+ *   40.7128,
+ *   10
+ * );
+ *
+ * // Find Sun's upper transit (noon)
+ * const noon = calculateRiseTransitSet(
+ *   jd,
+ *   Planet.Sun,
+ *   RiseTransitFlag.UpperTransit,
+ *   -74.0060,
+ *   40.7128,
+ *   10
+ * );
+ *
+ * // With atmospheric refraction correction
+ * const preciseRise = calculateRiseTransitSet(
+ *   jd,
+ *   Planet.Sun,
+ *   RiseTransitFlag.Rise,
+ *   -74.0060,
+ *   40.7128,
+ *   10,
+ *   CalculationFlag.SwissEphemeris,
+ *   1013.25,  // standard pressure in millibars
+ *   15        // temperature in Celsius
+ * );
+ */
+export declare function calculateRiseTransitSet(startJulianDay: number, body: CelestialBody, eventType: number, longitude: number, latitude: number, altitude: number, flags?: CalculationFlagInput, atmosphericPressure?: number, atmosphericTemperature?: number): RiseTransitSet;
 /**
  * Close Swiss Ephemeris and free resources
  *

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,YAAY,EAEZ,aAAa,EACb,WAAW,EAEX,oBAAoB,EACpB,oBAAoB,EACpB,iBAAiB,EACjB,SAAS,EACT,YAAY,EACZ,YAAY,EAEZ,gBAAgB,EAQjB,MAAM,gBAAgB,CAAC;AAkCxB;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAU3D;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,IAAI,GAAE,MAAU,EAChB,YAAY,GAAE,YAAqC,GAClD,MAAM,CAER;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAC7B,EAAE,EAAE,MAAM,EACV,YAAY,GAAE,YAAqC,GAClD,gBAAgB,CAGlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,aAAa,EACnB,KAAK,GAAE,oBAAmE,GACzE,iBAAiB,CAenB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,WAAW,GAAE,WAAkC,GAC9C,SAAS,CAmBX;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,oBAAoB,CAClC,cAAc,EAAE,MAAM,EACtB,KAAK,GAAE,oBAAqD,EAC5D,WAAW,GAAE,oBAAwB,EACrC,QAAQ,GAAE,OAAe,GACxB,YAAY,CAwBd;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,oBAAoB,CAClC,cAAc,EAAE,MAAM,EACtB,KAAK,GAAE,oBAAqD,EAC5D,WAAW,GAAE,oBAAwB,EACrC,QAAQ,GAAE,OAAe,GACxB,YAAY,CAwBd;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CAEhE;AAED;;;;;;;;;GASG;AACH,wBAAgB,KAAK,IAAI,IAAI,CAE5B;AAGD,cAAc,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,YAAY,EAEZ,aAAa,EACb,WAAW,EAEX,oBAAoB,EACpB,oBAAoB,EACpB,iBAAiB,EACjB,SAAS,EACT,YAAY,EACZ,YAAY,EAEZ,gBAAgB,EAChB,cAAc,EAQf,MAAM,gBAAgB,CAAC;AAkCxB;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAU3D;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,IAAI,GAAE,MAAU,EAChB,YAAY,GAAE,YAAqC,GAClD,MAAM,CAER;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,IAAI,EACV,YAAY,GAAE,YAAqC,GAClD,MAAM,CAaR;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAC7B,EAAE,EAAE,MAAM,EACV,YAAY,GAAE,YAAqC,GAClD,gBAAgB,CAGlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,aAAa,EACnB,KAAK,GAAE,oBAAmE,GACzE,iBAAiB,CAenB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,WAAW,GAAE,WAAkC,GAC9C,SAAS,CAmBX;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,oBAAoB,CAClC,cAAc,EAAE,MAAM,EACtB,KAAK,GAAE,oBAAqD,EAC5D,WAAW,GAAE,oBAAwB,EACrC,QAAQ,GAAE,OAAe,GACxB,YAAY,CAwBd;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,oBAAoB,CAClC,cAAc,EAAE,MAAM,EACtB,KAAK,GAAE,oBAAqD,EAC5D,WAAW,GAAE,oBAAwB,EACrC,QAAQ,GAAE,OAAe,GACxB,YAAY,CAwBd;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CAEhE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,eAAe,CAC7B,YAAY,EAAE,MAAM,EACpB,EAAE,GAAE,MAAU,EACd,MAAM,GAAE,MAAU,GACjB,IAAI,CAEN;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,cAAc,CAC5B,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,GACf,IAAI,CAEN;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAErD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AACH,wBAAgB,uBAAuB,CACrC,cAAc,EAAE,MAAM,EACtB,IAAI,EAAE,aAAa,EACnB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,KAAK,GAAE,oBAAqD,EAC5D,mBAAmB,GAAE,MAAU,EAC/B,sBAAsB,GAAE,MAAU,GACjC,cAAc,CAqBhB;AAED;;;;;;;;;GASG;AACH,wBAAgB,KAAK,IAAI,IAAI,CAE5B;AAGD,cAAc,gBAAgB,CAAC"}

package/dist/index.js

@@ -44,12 +44,17 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setEphemerisPath = setEphemerisPath;
 exports.julianDay = julianDay;
+exports.dateToJulianDay = dateToJulianDay;
 exports.julianDayToDate = julianDayToDate;
 exports.calculatePosition = calculatePosition;
 exports.calculateHouses = calculateHouses;
 exports.findNextLunarEclipse = findNextLunarEclipse;
 exports.findNextSolarEclipse = findNextSolarEclipse;
 exports.getCelestialBodyName = getCelestialBodyName;
+exports.setSiderealMode = setSiderealMode;
+exports.setTopocentric = setTopocentric;
+exports.getAyanamsa = getAyanamsa;
+exports.calculateRiseTransitSet = calculateRiseTransitSet;
 exports.close = close;
 const core_1 = require("@swisseph/core");
 const path = __importStar(require("path"));
@@ -128,6 +133,40 @@ function setEphemerisPath(path) {
 function julianDay(year, month, day, hour = 0, calendarType = core_1.CalendarType.Gregorian) {
     return binding.julday(year, month, day, hour, calendarType);
 }
+/**
+ * Calculate Julian day number from a JavaScript Date object
+ *
+ * Convenience function that converts a JavaScript Date to Julian day number.
+ * The Date is interpreted as UTC.
+ *
+ * @param date - JavaScript Date object (interpreted as UTC)
+ * @param calendarType - Calendar system (default: Gregorian)
+ * @returns Julian day number
+ *
+ * @example
+ * // From Date object
+ * const date = new Date('1990-05-15T14:30:00Z');
+ * const jd = dateToJulianDay(date);
+ *
+ * // From timestamp
+ * const now = new Date();
+ * const jdNow = dateToJulianDay(now);
+ *
+ * // Equivalent to julianDay(1990, 5, 15, 14.5)
+ * const jd2 = dateToJulianDay(new Date(Date.UTC(1990, 4, 15, 14, 30)));
+ */
+function dateToJulianDay(date, calendarType = core_1.CalendarType.Gregorian) {
+    const year = date.getUTCFullYear();
+    const month = date.getUTCMonth() + 1; // JavaScript months are 0-indexed
+    const day = date.getUTCDate();
+    const hours = date.getUTCHours();
+    const minutes = date.getUTCMinutes();
+    const seconds = date.getUTCSeconds();
+    const milliseconds = date.getUTCMilliseconds();
+    // Convert to decimal hours
+    const decimalHours = hours + minutes / 60 + seconds / 3600 + milliseconds / 3600000;
+    return julianDay(year, month, day, decimalHours, calendarType);
+}
 /**
  * Convert Julian day number to calendar date
  *
@@ -326,6 +365,189 @@ function findNextSolarEclipse(startJulianDay, flags = core_1.CalculationFlag.Swi
 function getCelestialBodyName(body) {
     return binding.get_planet_name(body);
 }
+/**
+ * Set the sidereal mode (ayanamsa system) for sidereal calculations
+ *
+ * This function must be called before calculating sidereal positions with
+ * CalculationFlag.Sidereal. Different ayanamsa systems are used in various
+ * traditions of astrology, particularly in Vedic (Jyotish) astrology.
+ *
+ * @param siderealMode - Ayanamsa system to use (e.g., SiderealMode.Lahiri for Vedic)
+ * @param t0 - Reference date (Julian day) for custom ayanamsa (default: 0)
+ * @param ayanT0 - Initial value of ayanamsa in degrees for custom mode (default: 0)
+ *
+ * @example
+ * import { setSiderealMode, SiderealMode, calculatePosition, CalculationFlag, Planet } from '@swisseph/node';
+ *
+ * // Set Lahiri ayanamsa (most common in Vedic astrology)
+ * setSiderealMode(SiderealMode.Lahiri);
+ *
+ * // Calculate sidereal position of Sun
+ * const jd = julianDay(2025, 1, 1);
+ * const sun = calculatePosition(jd, Planet.Sun, CalculationFlag.Sidereal | CalculationFlag.Speed);
+ * console.log(`Sidereal Sun: ${sun.longitude}°`);
+ *
+ * // Set Raman ayanamsa
+ * setSiderealMode(SiderealMode.Raman);
+ *
+ * // Set custom ayanamsa
+ * setSiderealMode(SiderealMode.UserDefined, 2451545.0, 23.85);
+ */
+function setSiderealMode(siderealMode, t0 = 0, ayanT0 = 0) {
+    binding.set_sid_mode(siderealMode, t0, ayanT0);
+}
+/**
+ * Set the geographic location for topocentric calculations
+ *
+ * This function must be called before calculating topocentric positions with
+ * CalculationFlag.Topocentric. Topocentric positions account for the observer's
+ * location on Earth, which is particularly important for the Moon due to parallax.
+ *
+ * @param longitude - Geographic longitude in degrees (positive = east, negative = west)
+ * @param latitude - Geographic latitude in degrees (positive = north, negative = south)
+ * @param altitude - Altitude above sea level in meters
+ *
+ * @example
+ * import { setTopocentric, calculatePosition, CalculationFlag, Planet } from '@swisseph/node';
+ *
+ * // Set location to New York City
+ * setTopocentric(-74.0060, 40.7128, 10); // lon, lat, altitude
+ *
+ * // Calculate topocentric Moon position
+ * const jd = julianDay(2025, 1, 1);
+ * const moon = calculatePosition(
+ *   jd,
+ *   Planet.Moon,
+ *   CalculationFlag.Topocentric | CalculationFlag.Speed
+ * );
+ * console.log(`Topocentric Moon: ${moon.longitude}°`);
+ *
+ * // Set location to Mumbai for Vedic calculations
+ * setTopocentric(72.8777, 19.0760, 14);
+ * setSiderealMode(SiderealMode.Lahiri);
+ * const siderealMoon = calculatePosition(
+ *   jd,
+ *   Planet.Moon,
+ *   CalculationFlag.Sidereal | CalculationFlag.Topocentric | CalculationFlag.Speed
+ * );
+ */
+function setTopocentric(longitude, latitude, altitude) {
+    binding.set_topo(longitude, latitude, altitude);
+}
+/**
+ * Get the ayanamsa (sidereal offset) value for a given date
+ *
+ * The ayanamsa is the distance between the tropical and sidereal zodiacs.
+ * This function returns the current offset in degrees for the ayanamsa system
+ * that was set with setSiderealMode().
+ *
+ * @param julianDay - Julian day number in Universal Time
+ * @returns Ayanamsa value in degrees
+ *
+ * @example
+ * import { getAyanamsa, setSiderealMode, SiderealMode, julianDay } from '@swisseph/node';
+ *
+ * // Get Lahiri ayanamsa for a date
+ * setSiderealMode(SiderealMode.Lahiri);
+ * const jd = julianDay(2025, 1, 1);
+ * const ayanamsa = getAyanamsa(jd);
+ * console.log(`Lahiri ayanamsa: ${ayanamsa.toFixed(4)}°`);
+ *
+ * // Compare different ayanamsa systems
+ * setSiderealMode(SiderealMode.Raman);
+ * const ramanAyanamsa = getAyanamsa(jd);
+ * console.log(`Raman ayanamsa: ${ramanAyanamsa.toFixed(4)}°`);
+ *
+ * setSiderealMode(SiderealMode.Krishnamurti);
+ * const kpAyanamsa = getAyanamsa(jd);
+ * console.log(`KP ayanamsa: ${kpAyanamsa.toFixed(4)}°`);
+ */
+function getAyanamsa(julianDay) {
+    return binding.get_ayanamsa_ut(julianDay);
+}
+/**
+ * Calculate rise, transit, or set time for a celestial body
+ *
+ * Finds the time when a celestial body rises, transits (culminates), or sets
+ * for a given location. This is essential for calculating almanac data,
+ * planetary hours, and observational astrology.
+ *
+ * @param startJulianDay - Julian day to start search from
+ * @param body - Celestial body to calculate
+ * @param eventType - Type of event (RiseTransitFlag.Rise, Set, UpperTransit, or LowerTransit)
+ * @param longitude - Geographic longitude in degrees (positive = east, negative = west)
+ * @param latitude - Geographic latitude in degrees (positive = north, negative = south)
+ * @param altitude - Altitude above sea level in meters
+ * @param flags - Calculation flags (default: SwissEphemeris)
+ * @param atmosphericPressure - Atmospheric pressure in millibars (default: 0 = standard)
+ * @param atmosphericTemperature - Atmospheric temperature in Celsius (default: 0 = standard)
+ * @returns RiseTransitSet object with time of event
+ *
+ * @example
+ * import {
+ *   calculateRiseTransitSet,
+ *   RiseTransitFlag,
+ *   Planet,
+ *   julianDay,
+ *   julianDayToDate
+ * } from '@swisseph/node';
+ *
+ * // Find sunrise in New York
+ * const jd = julianDay(2025, 1, 1);
+ * const sunrise = calculateRiseTransitSet(
+ *   jd,
+ *   Planet.Sun,
+ *   RiseTransitFlag.Rise,
+ *   -74.0060,  // New York longitude
+ *   40.7128,   // New York latitude
+ *   10         // altitude in meters
+ * );
+ * console.log(`Sunrise: ${julianDayToDate(sunrise.time)}`);
+ *
+ * // Find moonrise
+ * const moonrise = calculateRiseTransitSet(
+ *   jd,
+ *   Planet.Moon,
+ *   RiseTransitFlag.Rise,
+ *   -74.0060,
+ *   40.7128,
+ *   10
+ * );
+ *
+ * // Find Sun's upper transit (noon)
+ * const noon = calculateRiseTransitSet(
+ *   jd,
+ *   Planet.Sun,
+ *   RiseTransitFlag.UpperTransit,
+ *   -74.0060,
+ *   40.7128,
+ *   10
+ * );
+ *
+ * // With atmospheric refraction correction
+ * const preciseRise = calculateRiseTransitSet(
+ *   jd,
+ *   Planet.Sun,
+ *   RiseTransitFlag.Rise,
+ *   -74.0060,
+ *   40.7128,
+ *   10,
+ *   CalculationFlag.SwissEphemeris,
+ *   1013.25,  // standard pressure in millibars
+ *   15        // temperature in Celsius
+ * );
+ */
+function calculateRiseTransitSet(startJulianDay, body, eventType, longitude, latitude, altitude, flags = core_1.CalculationFlag.SwissEphemeris, atmosphericPressure = 0, atmosphericTemperature = 0) {
+    const normalizedFlags = (0, core_1.normalizeFlags)(flags);
+    ensureEphemerisInitialized(normalizedFlags);
+    const geopos = [longitude, latitude, altitude];
+    const result = binding.rise_trans(startJulianDay, body, eventType, geopos, normalizedFlags, atmosphericPressure, atmosphericTemperature);
+    const [retFlag, time] = result;
+    return {
+        time,
+        eventType: retFlag,
+    };
+}
 /**
  * Close Swiss Ephemeris and free resources
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swisseph/node",
-  "version": "1.0.6",
+  "version": "1.2.0",
   "description": "Swiss Ephemeris for Node.js - high precision astronomical calculations with native bindings",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -51,7 +51,7 @@
   "dependencies": {
     "node-addon-api": "^7.1.0",
     "node-gyp-build": "^4.8.4",
-    "@swisseph/core": "1.0.4"
+    "@swisseph/core": "1.1.0"
   },
   "devDependencies": {
     "@types/jest": "^29.5.11",
@@ -71,9 +71,9 @@
     "install": "node-gyp-build",
     "copy:libswe": "mkdir -p libswe && cp ../../native/libswe/* libswe/",
     "prebuild": "node scripts/setup-libswe.js && prebuildify --napi --strip --name swisseph",
-    "build": "node-gyp rebuild && tsc",
+    "build": "node-gyp rebuild && tsc --build",
     "build:native": "node-gyp rebuild",
-    "build:js": "tsc",
+    "build:js": "tsc --build",
     "test": "jest",
     "example": "npm run build && ts-node -P tsconfig.test.json examples/basic-usage.ts",
     "example:chart": "npm run build && ts-node -P tsconfig.test.json examples/birth-chart.ts",