@typescriptify/sweph 1.0.0

package/tests/modern/eclipses.test.ts

@@ -0,0 +1,81 @@
+import { describe, it, before, after } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { near, LONDON } from '../helpers';
+import { SwissEph } from '../../src/SwissEph';
+import { SE_MARS } from '../../src/constants';
+
+describe('Eclipses (modern)', () => {
+  let swe: SwissEph;
+
+  before(() => { swe = new SwissEph(); });
+  after(() => { swe.close(); });
+
+  describe('Solar eclipse — 2024 Apr 8', () => {
+    const eclJd = SwissEph.julianDay(2024, 4, 1, 0);
+
+    it('should find the eclipse', () => {
+      const ecl = swe.solarEclipseGlobal(eclJd);
+      assert.ok(ecl.maximum > eclJd);
+    });
+
+    it('should occur on Apr 8', () => {
+      const ecl = swe.solarEclipseGlobal(eclJd);
+      const d = SwissEph.fromJulianDay(ecl.maximum);
+      assert.strictEqual(d.month, 4);
+      assert.strictEqual(d.day, 8);
+    });
+
+    it('central path should be near lon -104', () => {
+      const ecl = swe.solarEclipseGlobal(eclJd);
+      const where = swe.solarEclipseWhere(ecl.maximum);
+      near(where.geopos.longitude, -104, 20);
+    });
+
+    it('solarEclipseHow should return attributes', () => {
+      const ecl = swe.solarEclipseGlobal(eclJd);
+      const how = swe.solarEclipseHow(ecl.maximum, { longitude: -104, latitude: 25 });
+      assert.ok(typeof how.type === 'number');
+      assert.ok(typeof how.attributes.magnitude === 'number');
+    });
+
+    it('solarEclipseLocal should find eclipse', () => {
+      const ecl = swe.solarEclipseLocal(eclJd, { longitude: -104, latitude: 25 });
+      assert.ok(ecl.maximum > eclJd);
+    });
+  });
+
+  describe('Lunar eclipse — 2025 Mar 14', () => {
+    const lunJd = SwissEph.julianDay(2025, 3, 1, 0);
+
+    it('should find the eclipse', () => {
+      const lun = swe.lunarEclipseGlobal(lunJd);
+      assert.ok(lun.maximum > lunJd);
+    });
+
+    it('should occur on Mar 14', () => {
+      const lun = swe.lunarEclipseGlobal(lunJd);
+      const d = SwissEph.fromJulianDay(lun.maximum);
+      assert.strictEqual(d.month, 3);
+      assert.strictEqual(d.day, 14);
+    });
+
+    it('umbral magnitude should be ~1.176', () => {
+      const lun = swe.lunarEclipseGlobal(lunJd);
+      const how = swe.lunarEclipseHow(lun.maximum);
+      near(how.umbraMagnitude, 1.176, 0.05);
+    });
+
+    it('lunarEclipseLocal should return', () => {
+      const lun = swe.lunarEclipseLocal(lunJd, LONDON);
+      assert.ok(typeof lun.maximum === 'number');
+    });
+  });
+
+  describe('Occultation', () => {
+    it('should search for Mars occultation', () => {
+      const start = SwissEph.julianDay(2024, 1, 1, 0);
+      const r = swe.occultationGlobal(start, SE_MARS);
+      assert.ok(typeof r.type === 'number');
+    });
+  });
+});

package/tests/modern/errors.test.ts

@@ -0,0 +1,71 @@
+import { describe, it, before, after } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { J2000 } from '../helpers';
+import { SwissEph, SwissEphError } from '../../src/SwissEph';
+
+describe('Error Handling (modern)', () => {
+  let swe: SwissEph;
+
+  before(() => { swe = new SwissEph(); });
+  after(() => { swe.close(); });
+
+  describe('SwissEphError', () => {
+    it('should be thrown for bad planet ID', () => {
+      assert.throws(
+        () => swe.calc(J2000, 999),
+        (err: any) => err.name === 'SwissEphError',
+      );
+    });
+
+    it('should be an instance of Error', () => {
+      try {
+        swe.calc(J2000, 999);
+        assert.fail('Should have thrown');
+      } catch (e: any) {
+        assert.ok(e instanceof SwissEphError);
+        assert.ok(e instanceof Error);
+        assert.strictEqual(e.name, 'SwissEphError');
+      }
+    });
+
+    it('should have a message', () => {
+      try {
+        swe.calc(J2000, 999);
+        assert.fail('Should have thrown');
+      } catch (e: any) {
+        assert.ok(e.message.length > 0);
+      }
+    });
+  });
+
+  describe('Invalid star name', () => {
+    it('should throw for nonexistent star', () => {
+      assert.throws(
+        () => swe.fixedStarMagnitude('ZZZNOTASTAR'),
+        (err: any) => err.name === 'SwissEphError',
+      );
+    });
+  });
+
+  describe('Constructor options', () => {
+    it('should create with default options', () => {
+      const s = new SwissEph();
+      assert.ok(s);
+      s.close();
+    });
+
+    it('should accept timeMode et', () => {
+      const s = new SwissEph({ timeMode: 'et' });
+      // ET calc should still work
+      const sun = s.calc(J2000, 0);
+      assert.ok(sun.longitude > 0);
+      s.close();
+    });
+
+    it('should accept topo option', () => {
+      const s = new SwissEph({ topo: { longitude: -0.1278, latitude: 51.5074 } });
+      assert.ok(s);
+      s.close();
+    });
+  });
+});

package/tests/modern/heliacal.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, before, after } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { J2000, LONDON } from '../helpers';
+import { SwissEph } from '../../src/SwissEph';
+import { SE_HELIACAL_RISING } from '../../src/constants';
+
+describe('Heliacal (modern)', () => {
+  let swe: SwissEph;
+
+  before(() => {
+    swe = new SwissEph({ topo: LONDON });
+  });
+  after(() => { swe.close(); });
+
+  describe('heliacalEvent', () => {
+    it('Venus heliacal rising should return result', () => {
+      const r = swe.heliacalEvent(J2000, LONDON, 'Venus', SE_HELIACAL_RISING);
+      assert.ok(typeof r.startVisible === 'number');
+      assert.ok(typeof r.bestVisible === 'number');
+      assert.ok(typeof r.endVisible === 'number');
+    });
+  });
+
+  describe('visualLimitMagnitude', () => {
+    it('should return limiting magnitude for Venus', () => {
+      const r = swe.visualLimitMagnitude(J2000, LONDON, 'Venus');
+      assert.ok(typeof r.limitingMagnitude === 'number');
+    });
+  });
+});

package/tests/modern/houses.test.ts

@@ -0,0 +1,87 @@
+import { describe, it, before, after } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { near, J2000, LONDON } from '../helpers';
+import { SwissEph } from '../../src/SwissEph';
+import { SE_SUN } from '../../src/constants';
+
+describe('Houses (modern)', () => {
+  let swe: SwissEph;
+
+  before(() => { swe = new SwissEph(); });
+  after(() => { swe.close(); });
+
+  describe('houses (Placidus, London, J2000)', () => {
+    it('ascendant should be ~24.03', () => {
+      const h = swe.houses(J2000, LONDON, 'P');
+      near(h.ascendant, 24.03, 0.5);
+    });
+
+    it('MC should be ~279.50', () => {
+      const h = swe.houses(J2000, LONDON, 'P');
+      near(h.mc, 279.50, 0.5);
+    });
+
+    it('cusps should have 37 elements', () => {
+      const h = swe.houses(J2000, LONDON, 'P');
+      assert.strictEqual(h.cusps.length, 37);
+    });
+
+    it('cusp[1] should equal ascendant', () => {
+      const h = swe.houses(J2000, LONDON, 'P');
+      near(h.cusps[1], h.ascendant, 0.001);
+    });
+
+    it('should have vertex', () => {
+      const h = swe.houses(J2000, LONDON, 'P');
+      assert.ok(h.vertex >= 0 && h.vertex < 360);
+    });
+  });
+
+  describe('housesFromArmc', () => {
+    it('should match houses result', () => {
+      const h = swe.houses(J2000, LONDON, 'P');
+      const h2 = swe.housesFromArmc(h.armc, LONDON.latitude, 23.44, 'P');
+      near(h2.ascendant, h.ascendant, 0.5);
+    });
+  });
+
+  describe('housePosition', () => {
+    it('Sun should be in house ~10.05', () => {
+      const h = swe.houses(J2000, LONDON, 'P');
+      const sun = swe.calc(J2000, SE_SUN);
+      const pos = swe.housePosition(h.armc, LONDON.latitude, 23.44, 'P',
+        sun.longitude, sun.latitude);
+      near(pos, 10.05, 0.2);
+    });
+
+    it('should return value between 1 and 12', () => {
+      const h = swe.houses(J2000, LONDON, 'P');
+      const sun = swe.calc(J2000, SE_SUN);
+      const pos = swe.housePosition(h.armc, LONDON.latitude, 23.44, 'P',
+        sun.longitude, sun.latitude);
+      assert.ok(pos >= 1 && pos <= 13);
+    });
+  });
+
+  describe('houseName', () => {
+    it('should return name containing Placidus for P', () => {
+      assert.ok(swe.houseName('P').toLowerCase().includes('placidus'));
+    });
+
+    it('should return Koch for K', () => {
+      assert.ok(swe.houseName('K').toLowerCase().includes('koch'));
+    });
+  });
+
+  describe('All house systems', () => {
+    const systems = ['P', 'K', 'E', 'W', 'C', 'R', 'T', 'B', 'M', 'O'];
+
+    for (const sys of systems) {
+      it(`System ${sys} should produce valid result`, () => {
+        const h = swe.houses(J2000, LONDON, sys);
+        assert.ok(h.ascendant >= 0 && h.ascendant < 360);
+        assert.ok(h.mc >= 0 && h.mc < 360);
+      });
+    }
+  });
+});

package/tests/modern/orbital.test.ts

@@ -0,0 +1,79 @@
+import { describe, it, before, after } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { near, J2000 } from '../helpers';
+import { SwissEph } from '../../src/SwissEph';
+import { SE_MARS, SE_EARTH } from '../../src/constants';
+
+describe('Orbital Elements (modern)', () => {
+  let swe: SwissEph;
+
+  before(() => { swe = new SwissEph(); });
+  after(() => { swe.close(); });
+
+  describe('nodesApsides', () => {
+    it('Mars ascending node should be valid', () => {
+      const r = swe.nodesApsides(J2000, SE_MARS);
+      assert.ok(r.ascendingNode.longitude > 0);
+    });
+
+    it('Mars perihelion should be valid', () => {
+      const r = swe.nodesApsides(J2000, SE_MARS);
+      assert.ok(r.perihelion.longitude > 0);
+    });
+
+    it('Mars descending node should differ from ascending', () => {
+      const r = swe.nodesApsides(J2000, SE_MARS);
+      assert.ok(Math.abs(r.ascendingNode.longitude - r.descendingNode.longitude) > 90);
+    });
+  });
+
+  describe('orbitalElements', () => {
+    it('Mars semi-axis should be ~1.5237 AU', () => {
+      const r = swe.orbitalElements(J2000, SE_MARS);
+      near(r.semiAxis, 1.5237, 0.01);
+    });
+
+    it('Mars eccentricity should be ~0.0933', () => {
+      const r = swe.orbitalElements(J2000, SE_MARS);
+      near(r.eccentricity, 0.0933, 0.01);
+    });
+
+    it('Mars inclination should be ~1.85 deg', () => {
+      const r = swe.orbitalElements(J2000, SE_MARS);
+      near(r.inclination, 1.85, 0.2);
+    });
+
+    it('Mars tropical period should be positive', () => {
+      const r = swe.orbitalElements(J2000, SE_MARS);
+      assert.ok(r.tropicalPeriod > 0, `period=${r.tropicalPeriod}`);
+    });
+
+    it('Earth semi-axis should be ~1.0 AU', () => {
+      const r = swe.orbitalElements(J2000, SE_EARTH);
+      near(r.semiAxis, 1.0, 0.01);
+    });
+
+    it('Earth eccentricity should be ~0.0167', () => {
+      const r = swe.orbitalElements(J2000, SE_EARTH);
+      near(r.eccentricity, 0.0167, 0.01);
+    });
+  });
+
+  describe('orbitDistances', () => {
+    it('Mars dmin should be ~0.37 AU', () => {
+      const r = swe.orbitDistances(J2000, SE_MARS);
+      near(r.min, 0.37, 0.1);
+    });
+
+    it('Mars dmax should be ~2.68 AU', () => {
+      const r = swe.orbitDistances(J2000, SE_MARS);
+      near(r.max, 2.68, 0.1);
+    });
+
+    it('dmin < dtrue < dmax', () => {
+      const r = swe.orbitDistances(J2000, SE_MARS);
+      assert.ok(r.min < r.true);
+      assert.ok(r.true < r.max);
+    });
+  });
+});

package/tests/modern/phenomena.test.ts

@@ -0,0 +1,41 @@
+import { describe, it, before, after } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { J2000, LONDON } from '../helpers';
+import { SwissEph } from '../../src/SwissEph';
+import { SE_SUN, SE_MARS } from '../../src/constants';
+
+describe('Phenomena (modern)', () => {
+  let swe: SwissEph;
+
+  before(() => { swe = new SwissEph(); });
+  after(() => { swe.close(); });
+
+  describe('phenomena', () => {
+    it('Mars should have phase angle', () => {
+      const r = swe.phenomena(J2000, SE_MARS);
+      assert.ok(r.phaseAngle >= 0 && r.phaseAngle < 180);
+    });
+
+    it('Mars should have elongation', () => {
+      const r = swe.phenomena(J2000, SE_MARS);
+      assert.ok(typeof r.elongation === 'number');
+    });
+
+    it('Mars should have apparent magnitude', () => {
+      const r = swe.phenomena(J2000, SE_MARS);
+      assert.ok(typeof r.apparentMagnitude === 'number');
+    });
+
+    it('Mars should have apparent diameter', () => {
+      const r = swe.phenomena(J2000, SE_MARS);
+      assert.ok(r.apparentDiameter > 0);
+    });
+  });
+
+  describe('gauquelinSector', () => {
+    it('Sun sector should be 1-36', () => {
+      const r = swe.gauquelinSector(J2000, SE_SUN, LONDON);
+      assert.ok(r.sector > 0 && r.sector <= 36, `sector=${r.sector}`);
+    });
+  });
+});

package/tests/modern/rise-set.test.ts

@@ -0,0 +1,60 @@
+import { describe, it, before, after } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { J2000, LONDON } from '../helpers';
+import { SwissEph } from '../../src/SwissEph';
+import { SE_SUN } from '../../src/constants';
+
+describe('Rise/Set/Transit (modern)', () => {
+  let swe: SwissEph;
+
+  before(() => { swe = new SwissEph(); });
+  after(() => { swe.close(); });
+
+  describe('rise', () => {
+    it('Sun rise should be after J2000', () => {
+      const r = swe.rise(J2000, SE_SUN, LONDON);
+      assert.ok(r.jd > J2000);
+    });
+  });
+
+  describe('set', () => {
+    it('Sun set should be after J2000', () => {
+      const r = swe.set(J2000, SE_SUN, LONDON);
+      assert.ok(r.jd > J2000);
+    });
+  });
+
+  describe('transit', () => {
+    it('Sun transit should return JD', () => {
+      const r = swe.transit(J2000, SE_SUN, LONDON);
+      assert.ok(r.jd > 0);
+    });
+  });
+
+  describe('antiTransit', () => {
+    it('Sun anti-transit should return JD', () => {
+      const r = swe.antiTransit(J2000, SE_SUN, LONDON);
+      assert.ok(r.jd > 0);
+    });
+  });
+
+  describe('azalt', () => {
+    it('should compute Sun azimuth and altitude', () => {
+      const sun = swe.calc(J2000, SE_SUN);
+      const az = swe.azalt(J2000, LONDON, sun.longitude, sun.latitude);
+      assert.ok(typeof az.azimuth === 'number');
+      assert.ok(typeof az.trueAltitude === 'number');
+      assert.ok(typeof az.apparentAltitude === 'number');
+    });
+  });
+
+  describe('azaltReverse', () => {
+    it('should reverse azalt', () => {
+      const sun = swe.calc(J2000, SE_SUN);
+      const az = swe.azalt(J2000, LONDON, sun.longitude, sun.latitude);
+      const rev = swe.azaltReverse(J2000, LONDON, az.azimuth, az.apparentAltitude);
+      assert.ok(typeof rev.azimuth === 'number');
+      assert.ok(typeof rev.altitude === 'number');
+    });
+  });
+});

package/tests/modern/statics.test.ts

@@ -0,0 +1,99 @@
+import { describe, it } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { near, J2000 } from '../helpers';
+import { SwissEph } from '../../src/SwissEph';
+import { SE_GREG_CAL } from '../../src/constants';
+
+describe('Static Methods (modern)', () => {
+  describe('julianDay', () => {
+    it('J2000 = 2451545.0', () => {
+      assert.strictEqual(SwissEph.julianDay(2000, 1, 1, 12), J2000);
+    });
+
+    it('should handle default hour = 0', () => {
+      const jd = SwissEph.julianDay(2000, 1, 1);
+      assert.strictEqual(jd, J2000 - 0.5);
+    });
+  });
+
+  describe('fromJulianDay', () => {
+    it('should round-trip J2000', () => {
+      const d = SwissEph.fromJulianDay(J2000);
+      assert.strictEqual(d.year, 2000);
+      assert.strictEqual(d.month, 1);
+      assert.strictEqual(d.day, 1);
+      assert.strictEqual(d.hour, 12);
+    });
+  });
+
+  describe('utcToJd', () => {
+    it('should produce JD near J2000', () => {
+      const r = SwissEph.utcToJd(2000, 1, 1, 12, 0, 0);
+      near(r.tjdUt, J2000, 0.001);
+    });
+
+    it('ET should be ahead of UT', () => {
+      const r = SwissEph.utcToJd(2000, 1, 1, 12, 0, 0);
+      assert.ok(r.tjdEt > r.tjdUt);
+    });
+  });
+
+  describe('jdToUtc', () => {
+    it('should convert ET JD to UTC components', () => {
+      const r = SwissEph.utcToJd(2000, 1, 1, 12, 0, 0);
+      const utc = SwissEph.jdToUtc(r.tjdEt);
+      assert.strictEqual(utc.year, 2000);
+      assert.strictEqual(utc.month, 1);
+      assert.strictEqual(utc.day, 1);
+    });
+  });
+
+  describe('jdUtToUtc', () => {
+    it('should convert UT JD to UTC components', () => {
+      const utc = SwissEph.jdUtToUtc(J2000);
+      assert.strictEqual(utc.year, 2000);
+    });
+  });
+
+  describe('dayOfWeek', () => {
+    it('J2000 should be Saturday (5)', () => {
+      assert.strictEqual(SwissEph.dayOfWeek(J2000), 5);
+    });
+  });
+
+  describe('normalizeDegrees', () => {
+    it('370 -> 10', () => {
+      assert.strictEqual(SwissEph.normalizeDegrees(370), 10);
+    });
+
+    it('-10 -> 350', () => {
+      assert.strictEqual(SwissEph.normalizeDegrees(-10), 350);
+    });
+  });
+
+  describe('normalizeRadians', () => {
+    it('should normalize 7 to 0-2pi', () => {
+      const r = SwissEph.normalizeRadians(7);
+      assert.ok(r >= 0 && r < 2 * Math.PI);
+    });
+  });
+
+  describe('degreeMidpoint', () => {
+    it('midpoint of 350,10 -> 0', () => {
+      near(SwissEph.degreeMidpoint(350, 10), 0, 0.01);
+    });
+  });
+
+  describe('coordinateTransform', () => {
+    it('should transform coordinates', () => {
+      const out = SwissEph.coordinateTransform([280.0, -0.5, 1.0], 23.44);
+      assert.ok(out[0] !== 0 || out[1] !== 0);
+    });
+  });
+
+  describe('version', () => {
+    it('should return non-empty string', () => {
+      assert.ok(SwissEph.version().length > 0);
+    });
+  });
+});

package/tests/modern/utilities.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, before, after } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { near, J2000 } from '../helpers';
+import { SwissEph } from '../../src/SwissEph';
+import { SE_SUN, SE_MARS, SE_TRUE_TO_APP } from '../../src/constants';
+
+describe('Utilities (modern)', () => {
+  let swe: SwissEph;
+
+  before(() => { swe = new SwissEph(); });
+  after(() => { swe.close(); });
+
+  describe('deltaT', () => {
+    it('should be positive at J2000', () => {
+      const dt = swe.deltaT(J2000);
+      assert.ok(dt > 0);
+      assert.ok(dt < 0.01);
+    });
+  });
+
+  describe('siderealTime', () => {
+    it('should return 0-24 hours at J2000', () => {
+      const st = swe.siderealTime(J2000);
+      assert.ok(st > 0 && st < 24, `st=${st}`);
+    });
+  });
+
+  describe('timeEquation', () => {
+    it('should return a number', () => {
+      const teq = swe.timeEquation(J2000);
+      assert.ok(typeof teq === 'number');
+    });
+  });
+
+  describe('refraction', () => {
+    it('true-to-apparent should return different value', () => {
+      const ref = swe.refraction(10, 1013.25, 15, SE_TRUE_TO_APP);
+      assert.ok(typeof ref === 'number');
+      assert.ok(ref !== 0);
+    });
+  });
+
+  describe('splitDegrees', () => {
+    it('should split 123.456 correctly', () => {
+      const r = swe.splitDegrees(123.456, 0);
+      assert.strictEqual(r.deg, 123);
+      assert.strictEqual(r.min, 27);
+    });
+  });
+
+  describe('difDeg2n', () => {
+    it('10,350 -> 20', () => {
+      near(swe.difDeg2n(10, 350), 20, 0.001);
+    });
+
+    it('350,10 -> -20', () => {
+      near(swe.difDeg2n(350, 10), -20, 0.001);
+    });
+  });
+
+  describe('getPlanetName', () => {
+    it('should return Sun for SE_SUN', () => {
+      assert.strictEqual(swe.getPlanetName(SE_SUN), 'Sun');
+    });
+
+    it('should return Mars for SE_MARS', () => {
+      assert.strictEqual(swe.getPlanetName(SE_MARS), 'Mars');
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ES2020",
+    "moduleResolution": "node",
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "lib": ["ES2020", "DOM"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}