gnss-js 1.1.0 → 1.3.0

package/dist/positioning.js

@@ -0,0 +1,206 @@
+import {
+  computeDop,
+  computeSatPosition,
+  ecefToAzEl
+} from "./chunk-ZCNXERQ2.js";
+import "./chunk-HVXYFUCB.js";
+import "./chunk-37QNKGTC.js";
+import "./chunk-6FAL6P4G.js";
+import "./chunk-LEEU5OIO.js";
+import {
+  C_LIGHT
+} from "./chunk-W5WKEV7U.js";
+
+// src/positioning/index.ts
+var GM_GPS = 3986005e8;
+var F_REL = -4442807633e-19;
+function satClockCorrection(eph, tMs) {
+  if (eph.system === "R" || eph.system === "S") {
+    const dt2 = (tMs - eph.tocDate.getTime()) / 1e3;
+    return eph.tauN + eph.gammaN * dt2;
+  }
+  const k = eph;
+  const dt = (tMs - k.tocDate.getTime()) / 1e3;
+  const poly = k.af0 + k.af1 * dt + k.af2 * dt * dt;
+  const a = k.sqrtA * k.sqrtA;
+  const n = Math.sqrt(GM_GPS / (a * a * a)) + k.deltaN;
+  const tk = dt;
+  const Mk = k.m0 + n * tk;
+  let Ek = Mk;
+  for (let i = 0; i < 8; i++) {
+    Ek = Mk + k.e * Math.sin(Ek);
+  }
+  const rel = F_REL * k.e * k.sqrtA * Math.sin(Ek);
+  return poly + rel;
+}
+function ionoFree(p1, p2, f1, f2) {
+  const g = f1 * f1 / (f1 * f1 - f2 * f2);
+  return g * p1 - (g - 1) * p2;
+}
+function tropoDelay(elevationRad) {
+  const sinEl = Math.sin(elevationRad);
+  return 2.47 / (sinEl + 0.0121);
+}
+function sagnac(pos, travelTimeS) {
+  const OMEGA_E = 72921151467e-15;
+  const theta = OMEGA_E * travelTimeS;
+  const c = Math.cos(theta);
+  const s = Math.sin(theta);
+  return [pos.x * c + pos.y * s, -pos.x * s + pos.y * c, pos.z];
+}
+function solveLinear(A, b) {
+  const n = b.length;
+  const M = A.map((row, i) => [...row, b[i]]);
+  for (let col = 0; col < n; col++) {
+    let pivot = col;
+    for (let r = col + 1; r < n; r++) {
+      if (Math.abs(M[r][col]) > Math.abs(M[pivot][col])) pivot = r;
+    }
+    if (Math.abs(M[pivot][col]) < 1e-12) return null;
+    [M[col], M[pivot]] = [M[pivot], M[col]];
+    for (let r = 0; r < n; r++) {
+      if (r === col) continue;
+      const f = M[r][col] / M[col][col];
+      for (let c = col; c <= n; c++) M[r][c] -= f * M[col][c];
+    }
+  }
+  return M.map((row, i) => row[n] / M[i][i]);
+}
+function solveSpp(pseudoranges, ephemerides, timeMs, opts = {}) {
+  const {
+    elevationMaskDeg = 10,
+    troposphere = true,
+    maxIterations = 15,
+    convergenceM = 1e-4
+  } = opts;
+  const all = [...pseudoranges.keys()].filter((p) => ephemerides.has(p));
+  const minSats = (list) => 3 + new Set(list.map((p) => p[0])).size;
+  if (all.length < minSats(all)) return null;
+  const gaussNewton = (prns) => {
+    const systems = [...new Set(prns.map((p) => p[0]))].sort();
+    const dim = 3 + systems.length;
+    const sysIndex = new Map(systems.map((s, i) => [s, 3 + i]));
+    let x2 = 0;
+    let y2 = 0;
+    let z2 = 0;
+    const clock2 = new Map(systems.map((s) => [s, 0]));
+    const residuals2 = {};
+    let iterations2 = 0;
+    let converged2 = false;
+    for (let iter = 0; iter < maxIterations; iter++) {
+      iterations2 = iter + 1;
+      const HtH = Array.from(
+        { length: dim },
+        () => new Array(dim).fill(0)
+      );
+      const Htv = new Array(dim).fill(0);
+      let rows = 0;
+      for (const k of Object.keys(residuals2)) delete residuals2[k];
+      for (const prn of prns) {
+        const psr = pseudoranges.get(prn);
+        const eph = ephemerides.get(prn);
+        const sys = prn[0];
+        const clk = clock2.get(sys);
+        const tTx = timeMs - psr / C_LIGHT * 1e3;
+        const sat = computeSatPosition(eph, tTx);
+        if (!Number.isFinite(sat.x)) continue;
+        const dts = satClockCorrection(eph, tTx);
+        const travel = Math.hypot(sat.x - x2, sat.y - y2, sat.z - z2) / C_LIGHT;
+        const [sx, sy, sz] = sagnac(sat, travel);
+        const rho = Math.hypot(sx - x2, sy - y2, sz - z2);
+        const ux = (x2 - sx) / rho;
+        const uy = (y2 - sy) / rho;
+        const uz = (z2 - sz) / rho;
+        let elev = Math.PI / 2;
+        let weight = 1;
+        const positionSane = x2 * x2 + y2 * y2 + z2 * z2 > 1e12;
+        if (positionSane) {
+          const azel = ecefToAzEl(x2, y2, z2, sx, sy, sz);
+          elev = azel.el;
+          if (iter >= 2 && elev < elevationMaskDeg * Math.PI / 180) continue;
+          const sinEl = Math.max(Math.sin(elev), 0.1);
+          weight = sinEl * sinEl;
+        }
+        const tropo = troposphere && positionSane ? tropoDelay(elev) : 0;
+        const predicted = rho + clk - C_LIGHT * dts + tropo;
+        const v = psr - predicted;
+        const h = new Array(dim).fill(0);
+        h[0] = ux;
+        h[1] = uy;
+        h[2] = uz;
+        h[sysIndex.get(sys)] = 1;
+        for (let i = 0; i < dim; i++) {
+          for (let j = 0; j < dim; j++) HtH[i][j] += weight * h[i] * h[j];
+          Htv[i] += weight * h[i] * v;
+        }
+        residuals2[prn] = v;
+        rows++;
+      }
+      if (rows < dim) return null;
+      const dx = solveLinear(HtH, Htv);
+      if (!dx) return null;
+      x2 += dx[0];
+      y2 += dx[1];
+      z2 += dx[2];
+      for (const s of systems)
+        clock2.set(s, clock2.get(s) + dx[sysIndex.get(s)]);
+      if (Math.hypot(dx[0], dx[1], dx[2]) < convergenceM) {
+        converged2 = true;
+        break;
+      }
+    }
+    return { x: x2, y: y2, z: z2, clock: clock2, residuals: residuals2, iterations: iterations2, converged: converged2 };
+  };
+  const REJECT_THRESHOLD_M = 50;
+  let candidates = all;
+  const rejected = [];
+  let inner = null;
+  for (let round = 0; round <= all.length; round++) {
+    inner = gaussNewton(candidates);
+    if (!inner) return null;
+    const vals = Object.entries(inner.residuals);
+    let worst = null;
+    let worstAbs = REJECT_THRESHOLD_M;
+    for (const [prn, v] of vals) {
+      if (Math.abs(v) > worstAbs) {
+        worstAbs = Math.abs(v);
+        worst = prn;
+      }
+    }
+    if (!worst) break;
+    const remaining = candidates.filter((p) => p !== worst);
+    if (remaining.length < minSats(remaining)) break;
+    rejected.push(worst);
+    candidates = remaining;
+  }
+  if (!inner) return null;
+  const { x, y, z, clock, residuals, iterations, converged } = inner;
+  const used = [];
+  const azels = [];
+  for (const prn of candidates) {
+    if (!(prn in residuals)) continue;
+    const eph = ephemerides.get(prn);
+    const sat = computeSatPosition(eph, timeMs);
+    if (!Number.isFinite(sat.x)) continue;
+    const azel = ecefToAzEl(x, y, z, sat.x, sat.y, sat.z);
+    if (azel.el >= elevationMaskDeg * Math.PI / 180) {
+      used.push(prn);
+      azels.push(azel);
+    }
+  }
+  return {
+    position: [x, y, z],
+    clockBias: Object.fromEntries(clock),
+    usedSatellites: used,
+    rejectedSatellites: rejected,
+    residuals,
+    dop: computeDop(azels),
+    iterations,
+    converged
+  };
+}
+export {
+  ionoFree,
+  satClockCorrection,
+  solveSpp
+};

package/dist/rtcm3.js

@@ -15,9 +15,9 @@ import {
   setRtcm3DebugHandler,
   updateStationMeta,
   updateStreamStats
-} from "./chunk-JDO3LEPC.js";
-import "./chunk-W5WKEV7U.js";
+} from "./chunk-7EEWQ5DU.js";
 import "./chunk-LEEU5OIO.js";
+import "./chunk-W5WKEV7U.js";
 export {
   BitReader,
   RTCM3_MESSAGE_NAMES,

package/dist/time.js

@@ -1,39 +1,43 @@
 import {
   Scale,
-  getBdsTime,
-  getDateFromBdsTime,
   getDateFromDayOfWeek,
   getDateFromDayOfYear,
-  getDateFromGalTime,
-  getDateFromGloN,
-  getDateFromGpsData,
-  getDateFromGpsTime,
   getDateFromHourCode,
   getDateFromJulianDate,
   getDateFromMJD,
   getDateFromMJD2000,
   getDateFromRINEX,
-  getDateFromTai,
   getDateFromTimeOfDay,
+  getDayOfWeek,
+  getDayOfYear,
+  getHourCode,
+  getJulianDate,
+  getMJD,
+  getMJD2000,
+  getRINEX,
+  getTimeOfDay,
+  getWeekOfYear
+} from "./chunk-L5OUUNLT.js";
+import {
+  getBdsTime,
+  getDateFromBdsTime,
+  getDateFromGalTime,
+  getDateFromGloN,
+  getDateFromGpsData,
+  getDateFromGpsTime,
+  getDateFromTai,
   getDateFromTt,
   getDateFromUnixTime,
   getDateFromUtc,
-  getDayOfWeek,
-  getDayOfYear,
   getGalTime,
   getGloN4,
   getGloNA,
   getGpsLeap,
   getGpsTime,
-  getHourCode,
   getHoursFromTimeDifference,
-  getJulianDate,
   getLeap,
-  getMJD,
-  getMJD2000,
   getMinutesFromTimeDifference,
   getNtpTime,
-  getRINEX,
   getSecondsFromTimeDifference,
   getTaiDate,
   getTimeDifference,
@@ -42,15 +46,13 @@ import {
   getTimeDifferenceFromMinutes,
   getTimeDifferenceFromObject,
   getTimeDifferenceFromSeconds,
-  getTimeOfDay,
   getTimeOfWeek,
   getTotalDaysFromTimeDifference,
   getTtDate,
   getUnixTime,
   getUtcDate,
-  getWeekNumber,
-  getWeekOfYear
-} from "./chunk-7NOFXKET.js";
+  getWeekNumber
+} from "./chunk-HVXYFUCB.js";
 import {
   DAYS_MJD2000_MJD,
   DAYS_MJD_JULIAN,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gnss-js",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "Comprehensive GNSS library for JavaScript — time scales, coordinates, RINEX parsing, RTCM3 decoding, orbit computation, and signal analysis",
   "type": "module",
   "sideEffects": false,
@@ -64,6 +64,16 @@
       "types": "./dist/signals.d.ts",
       "import": "./dist/signals.js",
       "require": "./dist/signals.cjs"
+    },
+    "./frames": {
+      "types": "./dist/frames.d.ts",
+      "import": "./dist/frames.js",
+      "require": "./dist/frames.cjs"
+    },
+    "./positioning": {
+      "types": "./dist/positioning.d.ts",
+      "import": "./dist/positioning.js",
+      "require": "./dist/positioning.cjs"
     }
   },
   "main": "./dist/index.cjs",

package/dist/{chunk-JDO3LEPC.js → chunk-7EEWQ5DU.js}

@@ -1,3 +1,8 @@
+import {
+  MILLISECONDS_IN_WEEK,
+  START_BDS_TIME,
+  START_GPS_TIME
+} from "./chunk-LEEU5OIO.js";
 import {
   C_LIGHT,
   FREQ,
@@ -6,11 +11,6 @@ import {
   GLO_F2_BASE,
   GLO_F2_STEP
 } from "./chunk-W5WKEV7U.js";
-import {
-  MILLISECONDS_IN_WEEK,
-  START_BDS_TIME,
-  START_GPS_TIME
-} from "./chunk-LEEU5OIO.js";
 
 // src/rtcm3/decoder.ts
 var debugHandler = null;