klio 1.4.9 → 1.5.1

package/src/astrology/swissephAdapter.js

@@ -0,0 +1,279 @@
+const { loadSwephWasmModule } = require('./swephWasmLoader');
+
+let nativeSwisseph = null;
+try {
+  nativeSwisseph = require('swisseph');
+} catch (error) {
+  nativeSwisseph = null;
+}
+
+const SE_GREG_CAL = nativeSwisseph ? nativeSwisseph.SE_GREG_CAL : 1;
+const SEFLG_SWIEPH = nativeSwisseph ? nativeSwisseph.SEFLG_SWIEPH : 2;
+const SEFLG_SPEED = nativeSwisseph ? nativeSwisseph.SEFLG_SPEED : 256;
+const SEFLG_MOSEPH = nativeSwisseph ? nativeSwisseph.SEFLG_MOSEPH : 4;
+
+let wasmModule = null;
+let wasmGet = null;
+let wasmReadyPromise = null;
+
+const planetCache = new Map();
+const houseCache = new Map();
+
+function ensureReady() {
+  if (nativeSwisseph) {
+    return;
+  }
+  if (!wasmModule || !wasmGet) {
+    throw new Error('Sweph WASM is not initialized. Call initialize() before use.');
+  }
+}
+
+async function initialize() {
+  if (nativeSwisseph) {
+    return;
+  }
+  if (!wasmReadyPromise) {
+    wasmReadyPromise = loadSwephWasmModule().then((moduleInstance) => {
+      wasmModule = moduleInstance;
+      wasmGet = wasmModule.cwrap('get', 'string', [
+        'number', 'number', 'number', 'number', 'number', 'number',
+        'number', 'number', 'number', 'string',
+        'number', 'number', 'number', 'string',
+        'string'
+      ]);
+      return wasmModule;
+    });
+  }
+  await wasmReadyPromise;
+}
+
+function toDms(value) {
+  const absValue = Math.abs(value);
+  let degrees = Math.floor(absValue);
+  let minutesFloat = (absValue - degrees) * 60;
+  let minutes = Math.floor(minutesFloat);
+  let seconds = Math.round((minutesFloat - minutes) * 60);
+
+  if (seconds === 60) {
+    seconds = 0;
+    minutes += 1;
+  }
+  if (minutes === 60) {
+    minutes = 0;
+    degrees += 1;
+  }
+
+  return { degrees, minutes, seconds };
+}
+
+function toLonLatArgs(longitude, latitude) {
+  const lon = toDms(longitude);
+  const lat = toDms(latitude);
+
+  return {
+    lonG: lon.degrees,
+    lonM: lon.minutes,
+    lonS: lon.seconds,
+    lonEW: longitude < 0 ? 'W' : 'E',
+    latG: lat.degrees,
+    latM: lat.minutes,
+    latS: lat.seconds,
+    latNS: latitude < 0 ? 'S' : 'N'
+  };
+}
+
+function swe_julday(year, month, day, hour, gregflag) {
+  if (nativeSwisseph && nativeSwisseph.swe_julday) {
+    return nativeSwisseph.swe_julday(year, month, day, hour, gregflag);
+  }
+  const isGregorian = gregflag === SE_GREG_CAL;
+  let y = year;
+  let m = month;
+  if (m <= 2) {
+    y -= 1;
+    m += 12;
+  }
+  const a = Math.floor(y / 100);
+  const b = isGregorian ? 2 - a + Math.floor(a / 4) : 0;
+  const jd = Math.floor(365.25 * (y + 4716))
+    + Math.floor(30.6001 * (m + 1))
+    + day + b - 1524.5 + hour / 24;
+  return jd;
+}
+
+function swe_revjul(julianDay, gregflag) {
+  if (nativeSwisseph && nativeSwisseph.swe_revjul) {
+    return nativeSwisseph.swe_revjul(julianDay, gregflag);
+  }
+  const isGregorian = gregflag === SE_GREG_CAL;
+  const jd = julianDay + 0.5;
+  let z = Math.floor(jd);
+  const f = jd - z;
+  let a = z;
+
+  if (isGregorian) {
+    const alpha = Math.floor((z - 1867216.25) / 36524.25);
+    a = z + 1 + alpha - Math.floor(alpha / 4);
+  }
+
+  const b = a + 1524;
+  const c = Math.floor((b - 122.1) / 365.25);
+  const d = Math.floor(365.25 * c);
+  const e = Math.floor((b - d) / 30.6001);
+
+  const dayWithFraction = b - d - Math.floor(30.6001 * e) + f;
+  const day = Math.floor(dayWithFraction);
+  const dayFraction = dayWithFraction - day;
+
+  let month = e < 14 ? e - 1 : e - 13;
+  let year = month > 2 ? c - 4716 : c - 4715;
+
+  const hour = dayFraction * 24;
+
+  return { year, month, day, hour };
+}
+
+function parseWasmResponse(jsonText) {
+  try {
+    return JSON.parse(jsonText);
+  } catch (error) {
+    return null;
+  }
+}
+
+function getPlanetsForJulianDay(julianDay) {
+  const cacheKey = julianDay.toFixed(8);
+  if (planetCache.has(cacheKey)) {
+    return planetCache.get(cacheKey);
+  }
+
+  const { year, month, day, hour } = swe_revjul(julianDay, SE_GREG_CAL);
+  const hourInt = Math.floor(hour);
+  const minute = Math.floor((hour - hourInt) * 60);
+  const second = Math.round((((hour - hourInt) * 60) - minute) * 60);
+
+  const jsonText = wasmGet(
+    year, month, day, hourInt, minute, second,
+    0, 0, 0, 'E',
+    0, 0, 0, 'N',
+    'K'
+  );
+
+  const parsed = parseWasmResponse(jsonText);
+  if (!parsed || !Array.isArray(parsed.planets)) {
+    return null;
+  }
+
+  planetCache.set(cacheKey, parsed.planets);
+  return parsed.planets;
+}
+
+function getHousesForJulianDay(julianDay, latitude, longitude, houseSystem) {
+  const cacheKey = `${julianDay.toFixed(8)}|${latitude.toFixed(4)}|${longitude.toFixed(4)}|${houseSystem}`;
+  if (houseCache.has(cacheKey)) {
+    return houseCache.get(cacheKey);
+  }
+
+  const { year, month, day, hour } = swe_revjul(julianDay, SE_GREG_CAL);
+  const hourInt = Math.floor(hour);
+  const minute = Math.floor((hour - hourInt) * 60);
+  const second = Math.round((((hour - hourInt) * 60) - minute) * 60);
+  const coords = toLonLatArgs(longitude, latitude);
+  const houseCode = (houseSystem && typeof houseSystem === 'string')
+    ? houseSystem.charAt(0).toUpperCase()
+    : 'K';
+
+  const jsonText = wasmGet(
+    year, month, day, hourInt, minute, second,
+    coords.lonG, coords.lonM, coords.lonS, coords.lonEW,
+    coords.latG, coords.latM, coords.latS, coords.latNS,
+    houseCode
+  );
+
+  const parsed = parseWasmResponse(jsonText);
+  if (!parsed) {
+    return null;
+  }
+
+  const houseArray = new Array(13).fill(0);
+  if (Array.isArray(parsed.house)) {
+    parsed.house.forEach((entry) => {
+      const index = parseInt(entry.name, 10);
+      if (!Number.isNaN(index) && index >= 1 && index <= 12) {
+        houseArray[index] = entry.long;
+      }
+    });
+  }
+
+  const ascmc = new Array(10).fill(0);
+  if (Array.isArray(parsed.ascmc)) {
+    parsed.ascmc.forEach((entry) => {
+      if (entry.name === 'Asc') {
+        ascmc[0] = entry.long;
+      } else if (entry.name === 'MC') {
+        ascmc[1] = entry.long;
+      }
+    });
+  }
+
+  const result = { house: houseArray, ascmc };
+  houseCache.set(cacheKey, result);
+  return result;
+}
+
+function swe_calc_ut(julianDay, planet, flag) {
+  if (nativeSwisseph) {
+    return nativeSwisseph.swe_calc_ut(julianDay, planet, flag);
+  }
+
+  ensureReady();
+  const planets = getPlanetsForJulianDay(julianDay);
+  if (!planets) {
+    return { error: 'Sweph WASM returned invalid data.' };
+  }
+
+  const match = planets.find((entry) => entry.index === planet);
+  if (!match) {
+    return { error: `Planet index ${planet} not found in Sweph WASM data.` };
+  }
+
+  return {
+    longitude: match.long,
+    latitude: match.lat,
+    distance: match.distance,
+    longitudeSpeed: match.speed
+  };
+}
+
+function swe_houses(julianDay, latitude, longitude, houseSystem, callback) {
+  if (nativeSwisseph) {
+    return nativeSwisseph.swe_houses(julianDay, latitude, longitude, houseSystem, callback);
+  }
+
+  ensureReady();
+  const result = getHousesForJulianDay(julianDay, latitude, longitude, houseSystem);
+  if (typeof callback === 'function') {
+    callback(result);
+  }
+  return result;
+}
+
+function swe_set_ephe_path() {
+  if (nativeSwisseph && nativeSwisseph.swe_set_ephe_path) {
+    return nativeSwisseph.swe_set_ephe_path.apply(nativeSwisseph, arguments);
+  }
+  return null;
+}
+
+module.exports = {
+  SE_GREG_CAL,
+  SEFLG_SWIEPH,
+  SEFLG_SPEED,
+  SEFLG_MOSEPH,
+  initialize,
+  swe_set_ephe_path,
+  swe_calc_ut,
+  swe_julday,
+  swe_revjul,
+  swe_houses
+};