gnss-js 0.1.2 → 1.0.1

package/dist/chunk-W4YMQKWH.js

@@ -0,0 +1,622 @@
+// src/rinex/format.ts
+function padL(s, w) {
+  return s.length >= w ? s.slice(0, w) : s + " ".repeat(w - s.length);
+}
+function padR(s, w) {
+  return s.length >= w ? s.slice(0, w) : " ".repeat(w - s.length) + s;
+}
+function fmtF(val, width, dec) {
+  return padR(val.toFixed(dec), width);
+}
+function hdrLine(content, label) {
+  return padL(content, 60) + padL(label, 20);
+}
+
+// src/rinex/warnings.ts
+var EMPTY_WARNINGS = {
+  items: [],
+  errorCount: 0,
+  warningCount: 0,
+  infoCount: 0
+};
+var MAX_EXAMPLES = 3;
+var WarningAccumulator = class {
+  items = /* @__PURE__ */ new Map();
+  // Epoch-level state
+  prevEpochTime = null;
+  epochTimes = /* @__PURE__ */ new Set();
+  intervalMs = null;
+  flagCounts = /* @__PURE__ */ new Map();
+  seenPrns = /* @__PURE__ */ new Set();
+  /* ── Header checks ──────────────────────────────────────────── */
+  checkHeader(header) {
+    const pos = header.approxPosition;
+    if (!pos || pos[0] === 0 && pos[1] === 0 && pos[2] === 0) {
+      this.add(
+        "MISSING_POSITION",
+        "warning",
+        "Missing or zero approximate position (APPROX POSITION XYZ)"
+      );
+    }
+    if (!header.antType) {
+      this.add(
+        "MISSING_ANT_TYPE",
+        "info",
+        "Missing antenna type (ANT # / TYPE)"
+      );
+    }
+    if (!header.receiverType) {
+      this.add(
+        "MISSING_REC_TYPE",
+        "info",
+        "Missing receiver type (REC # / TYPE / VERS)"
+      );
+    }
+    if (!header.markerName) {
+      this.add("MISSING_MARKER", "info", "Missing marker name (MARKER NAME)");
+    }
+    if (header.interval == null) {
+      this.add("MISSING_INTERVAL", "info", "No observation interval in header");
+    }
+    if (Object.keys(header.obsTypes).length === 0) {
+      this.add(
+        "NO_OBS_TYPES",
+        "error",
+        "No observation types defined in header"
+      );
+    }
+  }
+  setInterval(intervalMs) {
+    this.intervalMs = intervalMs;
+  }
+  /* ── Epoch checks ───────────────────────────────────────────── */
+  onEpoch(time, flag) {
+    if (flag !== 0) {
+      this.flagCounts.set(flag, (this.flagCounts.get(flag) ?? 0) + 1);
+    }
+    if (flag !== 0) return;
+    if (this.epochTimes.has(time)) {
+      const d = new Date(time);
+      this.add(
+        "DUPLICATE_EPOCH",
+        "warning",
+        "Duplicate epoch timestamps",
+        d.toISOString().replace("T", " ").replace(".000Z", "")
+      );
+    }
+    this.epochTimes.add(time);
+    if (this.prevEpochTime !== null && time < this.prevEpochTime) {
+      const d = new Date(time);
+      this.add(
+        "OUT_OF_ORDER",
+        "warning",
+        "Epochs not in chronological order",
+        d.toISOString().replace("T", " ").replace(".000Z", "")
+      );
+    }
+    if (this.prevEpochTime !== null) {
+      const gap = time - this.prevEpochTime;
+      const threshold = this.intervalMs ? this.intervalMs * 10 : 36e5;
+      if (gap > threshold && gap > 0) {
+        const gapMin = (gap / 6e4).toFixed(1);
+        this.add(
+          "LARGE_GAP",
+          "info",
+          "Large time gaps between epochs",
+          `${gapMin} min gap at ${new Date(this.prevEpochTime).toISOString().slice(11, 19)}`
+        );
+      }
+    }
+    this.prevEpochTime = time;
+  }
+  /* ── PRN checks ─────────────────────────────────────────────── */
+  onPrn(prn) {
+    if (this.seenPrns.has(prn)) return;
+    this.seenPrns.add(prn);
+    const sys = prn[0];
+    const num = parseInt(prn.slice(1), 10);
+    if (!sys || isNaN(num)) {
+      this.add("INVALID_PRN", "warning", "Invalid PRN format", prn);
+      return;
+    }
+    const ranges = {
+      G: [1, 32],
+      R: [1, 27],
+      E: [1, 50],
+      C: [1, 63],
+      J: [1, 10],
+      I: [1, 14],
+      S: [20, 59]
+    };
+    const range = ranges[sys];
+    if (!range) {
+      this.add(
+        "UNKNOWN_SYSTEM",
+        "info",
+        "Unknown satellite system letter",
+        prn
+      );
+    } else if (num < range[0] || num > range[1]) {
+      this.add(
+        "PRN_OUT_OF_RANGE",
+        "info",
+        `PRN number outside expected range`,
+        `${prn} (expected ${sys}${String(range[0]).padStart(2, "0")}-${sys}${String(range[1]).padStart(2, "0")})`
+      );
+    }
+  }
+  /* ── Finalize ───────────────────────────────────────────────── */
+  finalize() {
+    for (const [flag, count] of this.flagCounts) {
+      const labels = {
+        1: "Receiver clock reset",
+        2: "Moving antenna event",
+        3: "Header information follows",
+        4: "External event",
+        5: "Cycle slip records",
+        6: "Power failure recovery"
+      };
+      const label = labels[flag] ?? `Flag ${flag}`;
+      this.add(
+        `EPOCH_FLAG_${flag}`,
+        "info",
+        `${label} events (flag ${flag})`,
+        `${count} epoch(s)`
+      );
+    }
+    const items = [...this.items.values()];
+    const order = { error: 0, warning: 1, info: 2 };
+    items.sort((a, b) => (order[a.severity] ?? 9) - (order[b.severity] ?? 9));
+    return {
+      items,
+      errorCount: items.filter((w) => w.severity === "error").length,
+      warningCount: items.filter((w) => w.severity === "warning").length,
+      infoCount: items.filter((w) => w.severity === "info").length
+    };
+  }
+  /* ── Internal ───────────────────────────────────────────────── */
+  add(code, severity, message, example) {
+    let w = this.items.get(code);
+    if (!w) {
+      w = { code, severity, message, count: 0 };
+      this.items.set(code, w);
+    }
+    w.count++;
+    if (example) {
+      if (!w.examples) w.examples = [];
+      if (w.examples.length < MAX_EXAMPLES) w.examples.push(example);
+    }
+  }
+};
+
+// src/rinex/nav.ts
+var DATA_LINES = {
+  G: 7,
+  E: 7,
+  C: 7,
+  J: 7,
+  // Keplerian
+  R: 3,
+  // GLONASS state vector
+  S: 3,
+  I: 7
+  // SBAS / NavIC
+};
+var R4_MSG_LINES = {
+  // EPH types we parse (same Keplerian/state-vector layout as RINEX 3)
+  LNAV: 8,
+  INAV: 8,
+  FNAV: 8,
+  D1: 8,
+  D2: 8,
+  SBAS: 4,
+  FDMA: 5,
+  // RINEX 4 adds orbit-4 (status flags) vs 3 in RINEX 3
+  // EPH types we skip (different field layout)
+  CNAV: 9,
+  CNV1: 10,
+  CNV2: 10,
+  CNV3: 9,
+  L1NV: 8,
+  L1OC: 9,
+  L3OC: 9,
+  // Non-EPH records
+  STO: 2,
+  EOP: 3,
+  ION: 3
+};
+var SUPPORTED_EPH_MSGS = /* @__PURE__ */ new Set([
+  "LNAV",
+  "INAV",
+  "FNAV",
+  "D1",
+  "D2",
+  "SBAS",
+  "FDMA"
+]);
+function parseFloat19(s) {
+  return parseFloat(s.trim().replace(/[dD]/g, "E"));
+}
+function parseNavEpochV3(line) {
+  const prn = line.substring(0, 3).trim();
+  const yr = parseInt(line.substring(3, 8));
+  const mo = parseInt(line.substring(8, 11));
+  const dy = parseInt(line.substring(11, 14));
+  const hr = parseInt(line.substring(14, 17));
+  const mn = parseInt(line.substring(17, 20));
+  const sc = parseInt(line.substring(20, 23));
+  const date = new Date(Date.UTC(yr, mo - 1, dy, hr, mn, sc));
+  const values = [];
+  for (let i = 0; i < 3; i++) {
+    const start = 23 + i * 19;
+    if (start < line.length) {
+      values.push(parseFloat19(line.substring(start, start + 19)));
+    }
+  }
+  return { prn, date, values };
+}
+function parseNavEpochV2(line, defaultSys) {
+  const prnNum = parseInt(line.substring(0, 2));
+  const yr = parseInt(line.substring(2, 5));
+  const mo = parseInt(line.substring(5, 8));
+  const dy = parseInt(line.substring(8, 11));
+  const hr = parseInt(line.substring(11, 14));
+  const mn = parseInt(line.substring(14, 17));
+  const sc = parseFloat(line.substring(17, 22));
+  const fullYr = yr < 80 ? 2e3 + yr : 1900 + yr;
+  const date = new Date(Date.UTC(fullYr, mo - 1, dy, hr, mn, Math.floor(sc)));
+  const prn = `${defaultSys}${String(prnNum).padStart(2, "0")}`;
+  const values = [];
+  for (let i = 0; i < 3; i++) {
+    const start = 22 + i * 19;
+    if (start < line.length) {
+      values.push(parseFloat19(line.substring(start, start + 19)));
+    }
+  }
+  return { prn, date, values };
+}
+function parseDataLine(line, colOffset = 4) {
+  const values = [];
+  for (let i = 0; i < 4; i++) {
+    const start = colOffset + i * 19;
+    if (start >= line.length) break;
+    const s = line.substring(start, start + 19).trim();
+    if (s.length > 0) {
+      const v = parseFloat19(s);
+      values.push(Number.isFinite(v) ? v : 0);
+    }
+  }
+  return values;
+}
+function buildKeplerEphemeris(sys, prn, date, epochVals, data) {
+  const d = [];
+  for (const line of data) {
+    for (let i = 0; i < 4; i++) d.push(line[i] ?? 0);
+  }
+  return {
+    system: sys,
+    prn,
+    tocDate: date,
+    toc: date.getTime() / 1e3 % (7 * 86400),
+    // seconds of week approx
+    af0: epochVals[0] ?? 0,
+    af1: epochVals[1] ?? 0,
+    af2: epochVals[2] ?? 0,
+    iode: d[0] ?? 0,
+    crs: d[1] ?? 0,
+    deltaN: d[2] ?? 0,
+    m0: d[3] ?? 0,
+    cuc: d[4] ?? 0,
+    e: d[5] ?? 0,
+    cus: d[6] ?? 0,
+    sqrtA: d[7] ?? 0,
+    toe: d[8] ?? 0,
+    cic: d[9] ?? 0,
+    omega0: d[10] ?? 0,
+    cis: d[11] ?? 0,
+    i0: d[12] ?? 0,
+    crc: d[13] ?? 0,
+    omega: d[14] ?? 0,
+    omegaDot: d[15] ?? 0,
+    idot: d[16] ?? 0,
+    // d[17] = codes on L2 (GPS) or data sources (GAL)
+    week: d[18] ?? 0,
+    // d[19] = L2P flag (GPS) or spare
+    // d[20] = SV accuracy (URA index for GPS, SISA for GAL)
+    svHealth: d[21] ?? 0,
+    tgd: d[22] ?? 0
+    // d[23] = BGD (GAL) or IODC (GPS)
+  };
+}
+function buildStateVectorEphemeris(sys, prn, date, epochVals, data) {
+  const d = data.flat();
+  return {
+    system: sys,
+    prn,
+    tocDate: date,
+    tauN: epochVals[0] ?? 0,
+    gammaN: epochVals[1] ?? 0,
+    messageFrameTime: epochVals[2] ?? 0,
+    x: d[0] ?? 0,
+    xDot: d[1] ?? 0,
+    xAcc: d[2] ?? 0,
+    health: d[3] ?? 0,
+    y: d[4] ?? 0,
+    yDot: d[5] ?? 0,
+    yAcc: d[6] ?? 0,
+    freqNum: d[7] ?? 0,
+    z: d[8] ?? 0,
+    zDot: d[9] ?? 0,
+    zAcc: d[10] ?? 0
+  };
+}
+function parseNavFile(text) {
+  const lines = text.split("\n");
+  const header = {
+    version: 0,
+    type: "",
+    leapSeconds: null,
+    ionoCorrections: {}
+  };
+  const ephemerides = [];
+  let inHeader = true;
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const label = line.substring(60).trim();
+    if (label === "END OF HEADER") {
+      inHeader = false;
+      i++;
+      break;
+    }
+    if (label === "RINEX VERSION / TYPE") {
+      header.version = parseFloat(line.substring(0, 9));
+      header.type = line.substring(20, 40).trim();
+    } else if (label === "LEAP SECONDS") {
+      header.leapSeconds = parseInt(line.substring(0, 6));
+    } else if (label === "IONOSPHERIC CORR") {
+      const corrType = line.substring(0, 4).trim();
+      const vals = [];
+      for (let j = 0; j < 4; j++) {
+        const s = line.substring(5 + j * 12, 5 + (j + 1) * 12).trim();
+        if (s) vals.push(parseFloat19(s));
+      }
+      header.ionoCorrections[corrType] = vals;
+    } else if (label === "ION ALPHA") {
+      const vals = [];
+      for (let j = 0; j < 4; j++) {
+        const s = line.substring(2 + j * 12, 2 + (j + 1) * 12).trim();
+        if (s) vals.push(parseFloat19(s));
+      }
+      header.ionoCorrections["GPSA"] = vals;
+    } else if (label === "ION BETA") {
+      const vals = [];
+      for (let j = 0; j < 4; j++) {
+        const s = line.substring(2 + j * 12, 2 + (j + 1) * 12).trim();
+        if (s) vals.push(parseFloat19(s));
+      }
+      header.ionoCorrections["GPSB"] = vals;
+    }
+    i++;
+  }
+  if (inHeader) return { header, ephemerides };
+  const isV2 = header.version > 0 && header.version < 3;
+  let defaultSys = "G";
+  if (isV2) {
+    const ht = header.type.toUpperCase();
+    if (ht.includes("GLONASS")) defaultSys = "R";
+    else if (ht.includes("GEO")) defaultSys = "S";
+    else if (ht.includes("GALILEO")) defaultSys = "E";
+    else if (ht.includes("BEIDOU") || ht.includes("BDS")) defaultSys = "C";
+  }
+  const isV4 = header.version >= 4;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.trim().length === 0) {
+      i++;
+      continue;
+    }
+    if (isV4 && line.charAt(0) === ">") {
+      const parts = line.substring(2).trim().split(/\s+/);
+      const recType = parts[0] ?? "";
+      const msgType = parts[2] ?? recType;
+      if (recType !== "EPH" || !SUPPORTED_EPH_MSGS.has(msgType)) {
+        const totalLines = R4_MSG_LINES[msgType] ?? 2;
+        i += totalLines + 1;
+        continue;
+      }
+      const numDataLines2 = (R4_MSG_LINES[msgType] ?? 8) - 1;
+      i++;
+      if (i >= lines.length) break;
+      const epochLine = lines[i];
+      const sys2 = epochLine.charAt(0);
+      const parsed = parseNavEpochV3(epochLine);
+      const prn2 = `${sys2}${parsed.prn.substring(1)}`;
+      const dataLines2 = [];
+      for (let j = 0; j < numDataLines2; j++) {
+        i++;
+        if (i >= lines.length) break;
+        dataLines2.push(parseDataLine(lines[i], 4));
+      }
+      if (dataLines2.length === numDataLines2) {
+        if (sys2 === "R" || sys2 === "S") {
+          ephemerides.push(
+            buildStateVectorEphemeris(
+              sys2,
+              prn2,
+              parsed.date,
+              parsed.values,
+              dataLines2
+            )
+          );
+        } else if (sys2 === "G" || sys2 === "E" || sys2 === "C" || sys2 === "J" || sys2 === "I") {
+          ephemerides.push(
+            buildKeplerEphemeris(
+              sys2,
+              prn2,
+              parsed.date,
+              parsed.values,
+              dataLines2
+            )
+          );
+        }
+      }
+      i++;
+      continue;
+    }
+    let sys;
+    let prn;
+    let date;
+    let epochVals;
+    if (isV2) {
+      const parsed = parseNavEpochV2(line, defaultSys);
+      sys = defaultSys;
+      prn = parsed.prn;
+      date = parsed.date;
+      epochVals = parsed.values;
+    } else {
+      sys = line.charAt(0);
+      const parsed = parseNavEpochV3(line);
+      prn = `${sys}${parsed.prn.substring(1)}`;
+      date = parsed.date;
+      epochVals = parsed.values;
+    }
+    const numDataLines = DATA_LINES[sys];
+    if (numDataLines == null) {
+      i++;
+      continue;
+    }
+    const dataLines = [];
+    for (let j = 0; j < numDataLines; j++) {
+      i++;
+      if (i >= lines.length) break;
+      dataLines.push(parseDataLine(lines[i], isV2 ? 3 : 4));
+    }
+    if (dataLines.length === numDataLines) {
+      if (sys === "R" || sys === "S") {
+        ephemerides.push(
+          buildStateVectorEphemeris(sys, prn, date, epochVals, dataLines)
+        );
+      } else if (sys === "G" || sys === "E" || sys === "C" || sys === "J" || sys === "I") {
+        ephemerides.push(
+          buildKeplerEphemeris(sys, prn, date, epochVals, dataLines)
+        );
+      }
+    }
+    i++;
+  }
+  return { header, ephemerides };
+}
+
+// src/rinex/nav-writer.ts
+function fmtD(val) {
+  if (val === 0) return " 0.000000000000E+00";
+  const sign = val < 0 ? "-" : " ";
+  const abs = Math.abs(val);
+  const exp = Math.floor(Math.log10(abs));
+  const mantissa = abs / 10 ** exp;
+  const mStr = mantissa.toFixed(12);
+  const expSign = exp >= 0 ? "+" : "-";
+  const expStr = String(Math.abs(exp)).padStart(2, "0");
+  return `${sign}${mStr}E${expSign}${expStr}`;
+}
+function fmtEpoch(d) {
+  const Y = padR(String(d.getUTCFullYear()), 4);
+  const M = padR(String(d.getUTCMonth() + 1), 3);
+  const D = padR(String(d.getUTCDate()), 3);
+  const h = padR(String(d.getUTCHours()), 3);
+  const m = padR(String(d.getUTCMinutes()), 3);
+  const s = padR(String(d.getUTCSeconds()), 3);
+  return `${Y}${M}${D}${h}${m}${s}`;
+}
+function isKepler(eph) {
+  return "af0" in eph;
+}
+function writeHeader(nav) {
+  const lines = [];
+  lines.push(
+    hdrLine(
+      padL("     3.04", 9) + "           " + padL("NAVIGATION DATA", 20) + padL("M", 20),
+      "RINEX VERSION / TYPE"
+    )
+  );
+  const now = /* @__PURE__ */ new Date();
+  const dateStr = now.getUTCFullYear().toString() + String(now.getUTCMonth() + 1).padStart(2, "0") + String(now.getUTCDate()).padStart(2, "0") + " " + String(now.getUTCHours()).padStart(2, "0") + String(now.getUTCMinutes()).padStart(2, "0") + String(now.getUTCSeconds()).padStart(2, "0") + " UTC";
+  lines.push(
+    hdrLine(
+      padL("GNSSCalc", 20) + padL("", 20) + padL(dateStr, 20),
+      "PGM / RUN BY / DATE"
+    )
+  );
+  const ionoOrder = ["GPSA", "GPSB", "GAL", "BDSA", "BDSB"];
+  for (const key of ionoOrder) {
+    const vals = nav.header.ionoCorrections[key];
+    if (!vals) continue;
+    const valStr = vals.map((v) => fmtD(v)).join("");
+    lines.push(hdrLine(padL(key, 5) + valStr, "IONOSPHERIC CORR"));
+  }
+  for (const key of Object.keys(nav.header.ionoCorrections)) {
+    if (ionoOrder.includes(key)) continue;
+    const vals = nav.header.ionoCorrections[key];
+    if (!vals) continue;
+    const valStr = vals.map((v) => fmtD(v)).join("");
+    lines.push(hdrLine(padL(key, 5) + valStr, "IONOSPHERIC CORR"));
+  }
+  if (nav.header.leapSeconds != null) {
+    lines.push(
+      hdrLine(padR(String(nav.header.leapSeconds), 6), "LEAP SECONDS")
+    );
+  }
+  lines.push(hdrLine("", "END OF HEADER"));
+  return lines.join("\n") + "\n";
+}
+function orbitLine(values) {
+  return "    " + values.map(fmtD).join("");
+}
+function writeKeplerRecord(eph) {
+  const lines = [];
+  lines.push(
+    `${padL(eph.prn, 3)} ${fmtEpoch(eph.tocDate)}${fmtD(eph.af0)}${fmtD(eph.af1)}${fmtD(eph.af2)}`
+  );
+  lines.push(orbitLine([eph.iode, eph.crs, eph.deltaN, eph.m0]));
+  lines.push(orbitLine([eph.cuc, eph.e, eph.cus, eph.sqrtA]));
+  lines.push(orbitLine([eph.toe, eph.cic, eph.omega0, eph.cis]));
+  lines.push(orbitLine([eph.i0, eph.crc, eph.omega, eph.omegaDot]));
+  lines.push(orbitLine([eph.idot, 0, eph.week, 0]));
+  lines.push(orbitLine([0, eph.svHealth, eph.tgd, 0]));
+  lines.push(orbitLine([eph.toe, 0, 0, 0]));
+  return lines.join("\n");
+}
+function writeGlonassRecord(eph) {
+  const lines = [];
+  lines.push(
+    `${padL(eph.prn, 3)} ${fmtEpoch(eph.tocDate)}${fmtD(-eph.tauN)}${fmtD(eph.gammaN)}${fmtD(eph.messageFrameTime)}`
+  );
+  lines.push(orbitLine([eph.x, eph.xDot, eph.xAcc, eph.health]));
+  lines.push(orbitLine([eph.y, eph.yDot, eph.yAcc, eph.freqNum]));
+  lines.push(orbitLine([eph.z, eph.zDot, eph.zAcc, 0]));
+  return lines.join("\n");
+}
+function writeRinexNav(nav) {
+  const header = writeHeader(nav);
+  const sorted = [...nav.ephemerides].sort((a, b) => {
+    const prnCmp = a.prn.localeCompare(b.prn);
+    if (prnCmp !== 0) return prnCmp;
+    return a.tocDate.getTime() - b.tocDate.getTime();
+  });
+  const records = sorted.map(
+    (eph) => isKepler(eph) ? writeKeplerRecord(eph) : writeGlonassRecord(eph)
+  );
+  return header + records.join("\n") + "\n";
+}
+
+export {
+  padL,
+  padR,
+  fmtF,
+  hdrLine,
+  EMPTY_WARNINGS,
+  WarningAccumulator,
+  parseNavFile,
+  writeRinexNav
+};