vue-cot 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 @belblue
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,69 @@
+# vue-cot
+
+A focused Vue 3 library for **Cursor on Target (CoT)** — the XML messaging protocol used
+by NATO/US tactical systems such as ATAK, WinTAK and TAK Server.
+
+> **Status:** feature-complete **v0.1**. A well-scoped, self-contained library — not a
+> work in progress. Actively maintained.
+
+Related packages (`@vue-tactical/map`, `@vue-tactical/symbols`, `@vue-tactical/coords`)
+would be interesting to build but are **not currently planned** — open an issue if you'd
+like to collaborate. PRs welcome.
+
+## What it does
+
+`vue-cot` connects to a live CoT stream over a WebSocket, parses each tactical message
+into typed objects, and keeps a reactive store of entities (units, vehicles, sensors)
+that updates and expires itself in real time — ready to render in any Vue 3 app.
+
+```
+WebSocket stream  ->  connection layer  ->  parse CoT XML  ->  reactive entity store  ->  your Vue app
+   (CoT XML)          reconnect/keepalive    XML -> typed         Map<uid, Entity> + TTL     list / detail
+```
+
+## Features
+
+- `useWebSocket` / `useReconnectingWebSocket` — WebSocket lifecycle with exponential
+  backoff + jitter.
+- `useTakConnection` — application-level keepalive (ping/zombie detection) and
+  newline-delimited CoT framing.
+- `useCoTStream` — parses framed CoT into typed `CoTEvent` objects.
+- `useEntityStore` — reactive `Map<uid, Entity>` with single-`rAF` TTL expiry and derived
+  projections.
+- `parseCoT` / `serializeCoT` — pure, fully-typed, unit-tested CoT XML parser/serialiser.
+
+## Install
+
+```bash
+npm install vue-cot vue
+```
+
+`vue` (3.5+) is a peer dependency.
+
+## Usage
+
+```ts
+import { useCoTStream, useEntityStore } from 'vue-cot'
+
+const { upsert, list, count } = useEntityStore()
+const { status, reconnect } = useCoTStream('wss://your-tak-server:8087', {
+  onEvent: upsert,
+})
+// `list` is a reactive array of live entities; `status` reflects the connection.
+```
+
+## Not in scope for v1
+
+mTLS client certificates, a Web Worker parser, the CoT Protobuf variant, TAK Server
+federation, mission packages, and map/symbology rendering. These may come in later
+releases if there's demand — file an issue.
+
+## Links
+
+- Repository & issues: https://github.com/belblue/vue-cot
+- Contributing: issues and PRs welcome; safe fixes and dependency updates get merged,
+  larger changes are best discussed in an issue first.
+
+## License
+
+[MIT](./LICENSE)

package/dist/index.cjs

@@ -0,0 +1,297 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  parseCoT: () => parseCoT,
+  serializeCoT: () => serializeCoT,
+  useCoTStream: () => useCoTStream,
+  useEntityStore: () => useEntityStore,
+  useReconnectingWebSocket: () => useReconnectingWebSocket,
+  useTakConnection: () => useTakConnection,
+  useWebSocket: () => useWebSocket
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/composables/use-cot-stream.ts
+var import_vue3 = require("vue");
+
+// src/protocol/parse.ts
+var import_fast_xml_parser = require("fast-xml-parser");
+var parser = new import_fast_xml_parser.XMLParser({
+  ignoreAttributes: false,
+  attributeNamePrefix: ""
+});
+function parseCoT(xml) {
+  const raw = parser.parse(xml);
+  const event = raw?.event;
+  if (!event)
+    throw new Error("invalid CoT:missing <event> root");
+  const point = event.point;
+  if (!point)
+    throw new Error("invalid CoT:<event> missing <point>");
+  return {
+    version: String(event.version),
+    uid: String(event.uid),
+    type: String(event.type),
+    time: String(event.time),
+    start: String(event.start),
+    stale: String(event.stale),
+    how: event.how ? String(event.how) : void 0,
+    point: {
+      lat: Number(point.lat),
+      lon: Number(point.lon),
+      hae: Number(point.hae),
+      ce: Number(point.ce),
+      le: Number(point.le)
+    },
+    detail: event.detail ? {
+      contact: event.detail.contact ? { callsign: event.detail.contact.callsign } : void 0
+    } : void 0
+  };
+}
+
+// src/composables/use-tak-connection.ts
+var import_vue2 = require("vue");
+
+// src/composables/use-reconnecting-websocket.ts
+var import_vue = require("vue");
+
+// src/utils/backoff.ts
+function backoffDelay(attempt, options = {}) {
+  const { baseMs = 1e3, maxMs = 15e3 } = options;
+  const exponential = Math.min(baseMs * 2 ** attempt, maxMs);
+  const half = exponential / 2;
+  return half + Math.random() * half;
+}
+
+// src/composables/use-reconnecting-websocket.ts
+function useReconnectingWebSocket(url, options = {}) {
+  const {
+    baseMs = 1e3,
+    maxMs = 15e3,
+    maxAttempts = Number.POSITIVE_INFINITY
+  } = options;
+  const status = (0, import_vue.ref)("closed");
+  const data = (0, import_vue.ref)(null);
+  const attempts = (0, import_vue.ref)(0);
+  let ws = null;
+  let reconnectTimer;
+  let manualClose = false;
+  function connect() {
+    ws = new WebSocket(url);
+    status.value = "connecting";
+    ws.onopen = () => {
+      status.value = "open";
+      attempts.value = 0;
+    };
+    ws.onmessage = (event) => {
+      if (typeof event.data === "string")
+        data.value = event.data;
+    };
+    ws.onerror = () => {
+      console.error("[useReconnectingWebSocket] connection error");
+    };
+    ws.onclose = () => {
+      if (manualClose || attempts.value >= maxAttempts) {
+        status.value = "closed";
+        return;
+      }
+      const delay = backoffDelay(attempts.value, { baseMs, maxMs });
+      attempts.value++;
+      status.value = "reconnecting";
+      reconnectTimer = setTimeout(connect, delay);
+    };
+  }
+  function reconnect() {
+    clearTimeout(reconnectTimer);
+    attempts.value = 0;
+    if (ws) {
+      ws.onclose = null;
+      ws.close();
+    }
+    manualClose = false;
+    connect();
+  }
+  function close() {
+    manualClose = true;
+    clearTimeout(reconnectTimer);
+    ws?.close();
+  }
+  function send(payload) {
+    if (ws && ws.readyState === WebSocket.OPEN)
+      ws.send(payload);
+  }
+  connect();
+  (0, import_vue.onScopeDispose)(close);
+  return { status, data, attempts, reconnect, close, send };
+}
+
+// src/composables/use-tak-connection.ts
+function useTakConnection(url, options = {}) {
+  const connection = useReconnectingWebSocket(url);
+  const { status, data, attempts, close, reconnect, send } = connection;
+  const { pingIntervalMs = 15e3, pingTimeoutMs = 3e4 } = options;
+  let lastSeen = Date.now();
+  (0, import_vue2.watch)(status, (newStatus, oldStatus) => {
+    if (newStatus === "open") {
+      lastSeen = Date.now();
+      options.onConnect?.();
+    } else if (oldStatus === "open") {
+      options.onDisconnect?.();
+    }
+  });
+  (0, import_vue2.watch)(data, () => {
+    lastSeen = Date.now();
+  });
+  let buffer = "";
+  (0, import_vue2.watch)(data, (raw) => {
+    if (raw === null)
+      return;
+    buffer += raw;
+    const frames = buffer.split("\n");
+    buffer = frames.pop() ?? "";
+    for (const frame of frames) {
+      const trimmed = frame.trim();
+      if (trimmed) {
+        options.onMessage?.(trimmed);
+      }
+    }
+  });
+  const pingTimer = setInterval(() => {
+    send("ping");
+    if (Date.now() - lastSeen > pingTimeoutMs)
+      reconnect();
+  }, pingIntervalMs);
+  (0, import_vue2.onScopeDispose)(() => clearInterval(pingTimer));
+  return { status, data, attempts, reconnect, close, send };
+}
+
+// src/composables/use-cot-stream.ts
+function useCoTStream(url, options = {}) {
+  const event = (0, import_vue3.ref)(null);
+  const error = (0, import_vue3.ref)(null);
+  const connection = useTakConnection(url, {
+    ...options,
+    onMessage: (raw) => {
+      try {
+        const parsed = parseCoT(raw);
+        event.value = parsed;
+        error.value = null;
+        options.onEvent?.(parsed);
+        options.onMessage?.(raw);
+      } catch (err) {
+        error.value = err;
+      }
+    }
+  });
+  return { ...connection, event, error };
+}
+
+// src/composables/use-entity-store.ts
+var import_vue4 = require("vue");
+function useEntityStore() {
+  const entities = (0, import_vue4.shallowRef)(/* @__PURE__ */ new Map());
+  function upsert(event) {
+    entities.value.set(event.uid, { ...event, receivedAt: Date.now() });
+    (0, import_vue4.triggerRef)(entities);
+  }
+  let rafId = 0;
+  function sweep() {
+    const now = Date.now();
+    let remove = false;
+    for (const [uid, entity] of entities.value) {
+      if (Date.parse(entity.stale) < now) {
+        entities.value.delete(uid);
+        remove = true;
+      }
+    }
+    if (remove) {
+      (0, import_vue4.triggerRef)(entities);
+    }
+    rafId = requestAnimationFrame(sweep);
+  }
+  rafId = requestAnimationFrame(sweep);
+  (0, import_vue4.onScopeDispose)(() => cancelAnimationFrame(rafId));
+  const list = (0, import_vue4.computed)(() => Array.from(entities.value.values()));
+  const count = (0, import_vue4.computed)(() => entities.value.size);
+  const byAffiliation = (0, import_vue4.computed)(() => {
+    const groups = /* @__PURE__ */ new Map();
+    for (const entity of entities.value.values()) {
+      const affiliation = entity.type.split("-")[1] ?? "unknown";
+      const group = groups.get(affiliation) ?? [];
+      group.push(entity);
+      groups.set(affiliation, group);
+    }
+    return groups;
+  });
+  return { entities, upsert, list, count, byAffiliation };
+}
+
+// src/composables/use-websocket.ts
+var import_vue5 = require("vue");
+function useWebSocket(url) {
+  const status = (0, import_vue5.ref)("closed");
+  const data = (0, import_vue5.ref)(null);
+  const ws = new WebSocket(url);
+  status.value = "connecting";
+  ws.onopen = () => {
+    status.value = "open";
+  };
+  ws.onmessage = (event) => {
+    if (typeof event.data === "string") {
+      data.value = event.data;
+    }
+  };
+  ws.onclose = () => {
+    status.value = "closed";
+  };
+  ws.onerror = () => {
+    console.error("[useWebSocket] connection error");
+  };
+  function send(payload) {
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.send(payload);
+    }
+  }
+  (0, import_vue5.onScopeDispose)(() => {
+    ws.close();
+  });
+  return { status, data, send };
+}
+
+// src/protocol/serialize.ts
+function serializeCoT(event) {
+  const how = event.how ? ` how="${event.how}"` : "";
+  const callsign = event.detail?.contact?.callsign;
+  const detail = callsign ? `<detail><contact callsign="${callsign}"/></detail>` : "";
+  return `<event version="${event.version}" uid="${event.uid}" type="${event.type}" time="${event.time}" start="${event.start}" stale="${event.stale}"${how}><point lat="${event.point.lat}" lon="${event.point.lon}" hae="${event.point.hae}" ce="${event.point.ce}" le="${event.point.le}"/>${detail}</event>`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseCoT,
+  serializeCoT,
+  useCoTStream,
+  useEntityStore,
+  useReconnectingWebSocket,
+  useTakConnection,
+  useWebSocket
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/composables/use-cot-stream.ts","../src/protocol/parse.ts","../src/composables/use-tak-connection.ts","../src/composables/use-reconnecting-websocket.ts","../src/utils/backoff.ts","../src/composables/use-entity-store.ts","../src/composables/use-websocket.ts","../src/protocol/serialize.ts"],"sourcesContent":["export * from './composables/use-cot-stream'\nexport * from './composables/use-entity-store'\nexport * from './composables/use-reconnecting-websocket'\n\nexport * from './composables/use-tak-connection'\nexport * from './composables/use-websocket'\nexport * from './protocol/parse'\nexport * from './protocol/serialize'\nexport * from './protocol/types'\n","import type { CoTEvent } from '../protocol/types'\nimport type { TakConnectionOptions } from './use-tak-connection'\nimport { ref } from 'vue'\nimport { parseCoT } from '../protocol/parse'\nimport { useTakConnection } from './use-tak-connection'\n\nexport type CoTStreamOptions = TakConnectionOptions & {\n  onEvent?: (event: CoTEvent) => void\n}\n\n/**\n * High-level CoT stream: wraps {@link useTakConnection} and parses each framed\n * message into a typed {@link CoTEvent}. Prefer the lossless `onEvent` callback\n * (fired once per parsed frame) to feed a store; the reactive `event` ref only\n * ever holds the most recent message.\n *\n * @param url - WebSocket URL of the CoT feed.\n * @param options - {@link TakConnectionOptions} plus `onEvent(event)`, called\n * for every successfully parsed CoT message.\n * @returns The underlying connection controls plus reactive `event` (latest\n * parsed `CoTEvent` or `null`) and `error` (last parse error or `null`).\n *\n * @example\n * ```ts\n * const store = useEntityStore()\n * useCoTStream(url, { onEvent: (e) => store.upsert(e) })\n * ```\n */\nexport function useCoTStream(url: string, options: CoTStreamOptions = {}) {\n  const event = ref<CoTEvent | null>(null)\n  const error = ref<Error | null>(null)\n\n  const connection = useTakConnection(url, {\n    ...options,\n    onMessage: (raw) => {\n      try {\n        const parsed = parseCoT(raw)\n        event.value = parsed\n        error.value = null\n        options.onEvent?.(parsed)\n        options.onMessage?.(raw)\n      }\n      catch (err) {\n        error.value = err as Error\n      }\n    },\n  })\n\n  return { ...connection, event, error }\n}\n","import type { CoTEvent } from './types'\nimport { XMLParser } from 'fast-xml-parser'\n\nconst parser = new XMLParser({\n  ignoreAttributes: false,\n  attributeNamePrefix: '',\n})\n\n/**\n * Parses a CoT (Cursor on Target) XML string into a typed {@link CoTEvent}.\n * Inverse of {@link serializeCoT}.\n *\n * @param xml - A single CoT XML message (an `<event>` element).\n * @returns The parsed, typed event.\n * @throws If the XML has no `<event>` root or is missing its `<point>`.\n */\nexport function parseCoT(xml: string): CoTEvent {\n  const raw = parser.parse(xml)\n  const event = raw?.event\n  if (!event)\n    throw new Error('invalid CoT:missing <event> root')\n  const point = event.point\n  if (!point)\n    throw new Error('invalid CoT:<event> missing <point>')\n\n  return {\n    version: String(event.version),\n    uid: String(event.uid),\n    type: String(event.type),\n    time: String(event.time),\n    start: String(event.start),\n    stale: String(event.stale),\n    how: event.how ? String(event.how) : undefined,\n    point: {\n      lat: Number(point.lat),\n      lon: Number(point.lon),\n      hae: Number(point.hae),\n      ce: Number(point.ce),\n      le: Number(point.le),\n    },\n    detail: event.detail\n      ? {\n          contact: event.detail.contact\n            ? { callsign: event.detail.contact.callsign }\n            : undefined,\n        }\n      : undefined,\n  }\n}\n","import { onScopeDispose, watch } from 'vue'\nimport { useReconnectingWebSocket } from './use-reconnecting-websocket'\n\nexport interface TakConnectionOptions {\n  pingIntervalMs?: number\n  pingTimeoutMs?: number\n  onConnect?: () => void\n  onMessage?: (cot: string) => void\n  onDisconnect?: () => void\n  onError?: () => void\n}\n\n/**\n * Application-level TAK connection on top of {@link useReconnectingWebSocket}.\n * Adds ping keepalive, zombie-connection detection (forces a reconnect when no\n * traffic is seen within `pingTimeoutMs`) and newline-delimited message framing,\n * so `onMessage` fires once per whole CoT message.\n *\n * @param url - WebSocket URL of the TAK/CoT feed.\n * @param options - Lifecycle hooks (`onConnect`, `onMessage`, `onDisconnect`,\n * `onError`) plus `pingIntervalMs` (default 15000) and `pingTimeoutMs` (default 30000).\n * @returns Reactive `status`, `data`, `attempts` and the `reconnect`, `close`, `send` controls.\n */\nexport function useTakConnection(\n  url: string,\n  options: TakConnectionOptions = {},\n) {\n  const connection = useReconnectingWebSocket(url)\n  const { status, data, attempts, close, reconnect, send } = connection\n  const { pingIntervalMs = 15_000, pingTimeoutMs = 30_000 } = options\n  let lastSeen = Date.now()\n\n  watch(status, (newStatus, oldStatus) => {\n    if (newStatus === 'open') {\n      lastSeen = Date.now()\n      options.onConnect?.()\n    }\n    else if (oldStatus === 'open') {\n      options.onDisconnect?.()\n    }\n  })\n  watch(data, () => {\n    lastSeen = Date.now()\n  })\n\n  let buffer = ''\n  watch(data, (raw) => {\n    if (raw === null)\n      return\n    buffer += raw\n    const frames = buffer.split('\\n')\n    buffer = frames.pop() ?? ''\n    for (const frame of frames) {\n      const trimmed = frame.trim()\n      if (trimmed) {\n        options.onMessage?.(trimmed)\n      }\n    }\n  })\n\n  const pingTimer = setInterval(() => {\n    send('ping')\n    if (Date.now() - lastSeen > pingTimeoutMs)\n      reconnect()\n  }, pingIntervalMs)\n\n  onScopeDispose(() => clearInterval(pingTimer))\n\n  return { status, data, attempts, reconnect, close, send }\n}\n","import type { WebSocketStatus } from './use-websocket'\nimport { onScopeDispose, ref } from 'vue'\nimport { backoffDelay } from '../utils/backoff'\n\nexport type ReconnectingStatus = WebSocketStatus | 'reconnecting'\n\nexport interface ReconnectingOptions {\n  baseMs?: number\n  maxMs?: number\n  maxAttempts?: number\n}\n\n/**\n * Like {@link useWebSocket}, but automatically reconnects with exponential\n * backoff and jitter when the connection drops unexpectedly.\n *\n * @param url - WebSocket URL to connect to.\n * @param options - Backoff tuning: `baseMs` (first delay, default 1000),\n * `maxMs` (delay cap, default 15000) and `maxAttempts` (default unlimited).\n * @returns The reactive `status`, `data` and `attempts`, plus `reconnect()`\n * (force an immediate retry), `close()` (stop for good) and `send()`.\n *\n * @example\n * ```ts\n * const { status, attempts, reconnect } = useReconnectingWebSocket(url, { maxAttempts: 10 })\n * ```\n */\nexport function useReconnectingWebSocket(\n  url: string,\n  options: ReconnectingOptions = {},\n) {\n  const {\n    baseMs = 1000,\n    maxMs = 15_000,\n    maxAttempts = Number.POSITIVE_INFINITY,\n  } = options\n\n  const status = ref<ReconnectingStatus>('closed')\n  const data = ref<string | null>(null)\n  const attempts = ref(0)\n\n  let ws: WebSocket | null = null\n  let reconnectTimer: ReturnType<typeof setTimeout> | undefined\n  let manualClose = false\n\n  function connect() {\n    ws = new WebSocket(url)\n    status.value = 'connecting'\n\n    ws.onopen = () => {\n      status.value = 'open'\n      attempts.value = 0\n    }\n    ws.onmessage = (event: MessageEvent) => {\n      if (typeof event.data === 'string')\n        data.value = event.data\n    }\n    ws.onerror = () => {\n      console.error('[useReconnectingWebSocket] connection error')\n    }\n    ws.onclose = () => {\n      if (manualClose || attempts.value >= maxAttempts) {\n        status.value = 'closed'\n        return\n      }\n      const delay = backoffDelay(attempts.value, { baseMs, maxMs })\n      attempts.value++\n      status.value = 'reconnecting'\n      reconnectTimer = setTimeout(connect, delay)\n    }\n  }\n\n  function reconnect() {\n    clearTimeout(reconnectTimer)\n    attempts.value = 0\n    if (ws) {\n      ws.onclose = null\n      ws.close()\n    }\n    manualClose = false\n    connect()\n  }\n  function close() {\n    manualClose = true\n    clearTimeout(reconnectTimer)\n    ws?.close()\n  }\n\n  function send(payload: string) {\n    if (ws && ws.readyState === WebSocket.OPEN)\n      ws.send(payload)\n  }\n\n  connect()\n  onScopeDispose(close)\n\n  return { status, data, attempts, reconnect, close, send }\n}\n","export interface BackoffOptions {\n  baseMs?: number\n  maxMs?: number\n}\n\n/**\n * Computes an exponential-backoff delay (in milliseconds) for a retry attempt.\n * The delay is `baseMs * 2 ** attempt`, capped at `maxMs`, with jitter added to\n * avoid the thundering-herd problem when many clients reconnect at once.\n *\n * @param attempt - Zero-based retry attempt number.\n * @param options - `baseMs` (default 1000) and `maxMs` (cap, default 15000).\n * @returns The delay to wait before the next attempt, in milliseconds.\n */\nexport function backoffDelay(\n  attempt: number,\n  options: BackoffOptions = {},\n): number {\n  const { baseMs = 1000, maxMs = 15_000 } = options\n  const exponential = Math.min(baseMs * 2 ** attempt, maxMs)\n  const half = exponential / 2\n  return half + Math.random() * half\n}\n","import type { CoTEvent } from '../protocol/types'\nimport { computed, onScopeDispose, shallowRef, triggerRef } from 'vue'\n\nexport type Entity = CoTEvent & { receivedAt: number }\n/**\n * Reactive store of CoT entities keyed by `uid`. Backed by a `shallowRef<Map>`\n * with a single `requestAnimationFrame` loop that sweeps out entities whose\n * `stale` time has passed, so the collection self-expires.\n *\n * @returns `entities` (the reactive `Map<uid, Entity>`), `upsert(event)`\n * (insert or replace, stamping `receivedAt`), `list` (entities as a reactive\n * array), `count` and `byAffiliation` (entities grouped by CoT affiliation).\n *\n * @example\n * ```ts\n * const store = useEntityStore()\n * store.upsert(parseCoT(xml))\n * // store.list.value -> Entity[]\n * ```\n */\nexport function useEntityStore() {\n  const entities = shallowRef(new Map<string, Entity>())\n\n  function upsert(event: CoTEvent) {\n    entities.value.set(event.uid, { ...event, receivedAt: Date.now() })\n    triggerRef(entities)\n  }\n\n  let rafId = 0\n  function sweep() {\n    const now = Date.now()\n    let remove = false\n    for (const [uid, entity] of entities.value) {\n      if (Date.parse(entity.stale) < now) {\n        entities.value.delete(uid)\n        remove = true\n      }\n    }\n    if (remove) {\n      triggerRef(entities)\n    }\n    rafId = requestAnimationFrame(sweep)\n  }\n  rafId = requestAnimationFrame(sweep)\n  onScopeDispose(() => cancelAnimationFrame(rafId))\n\n  const list = computed(() => Array.from(entities.value.values()))\n  const count = computed(() => entities.value.size)\n\n  const byAffiliation = computed(() => {\n    const groups = new Map<string, Entity[]>()\n    for (const entity of entities.value.values()) {\n      const affiliation = entity.type.split('-')[1] ?? 'unknown'\n      const group = groups.get(affiliation) ?? []\n      group.push(entity)\n      groups.set(affiliation, group)\n    }\n    return groups\n  })\n\n  return { entities, upsert, list, count, byAffiliation }\n}\n","import { onScopeDispose, ref } from 'vue'\n\nexport type WebSocketStatus = 'connecting' | 'open' | 'closing' | 'closed'\n\n/**\n * Reactive wrapper around a single browser `WebSocket`. Opens the connection\n * immediately and exposes its live status and last received message. Does not\n * reconnect — see {@link useReconnectingWebSocket} for that.\n *\n * The socket is closed automatically when the surrounding reactive scope is disposed.\n *\n * @param url - WebSocket URL to connect to, e.g. `wss://tak.example/cot`.\n * @returns `status` (reactive connection state), `data` (latest string message\n * or `null`) and `send` (sends a payload only while the socket is open).\n *\n * @example\n * ```ts\n * const { status, data } = useWebSocket('wss://tak.example/cot')\n * ```\n */\nexport function useWebSocket(url: string) {\n  const status = ref<WebSocketStatus>('closed')\n  const data = ref<string | null>(null)\n\n  const ws = new WebSocket(url)\n  status.value = 'connecting'\n\n  ws.onopen = () => {\n    status.value = 'open'\n  }\n  ws.onmessage = (event: MessageEvent) => {\n    if (typeof event.data === 'string') {\n      data.value = event.data\n    }\n  }\n  ws.onclose = () => {\n    status.value = 'closed'\n  }\n  ws.onerror = () => {\n    console.error('[useWebSocket] connection error')\n  }\n\n  function send(payload: string) {\n    if (ws.readyState === WebSocket.OPEN) {\n      ws.send(payload)\n    }\n  }\n\n  onScopeDispose(() => {\n    ws.close()\n  })\n\n  return { status, data, send }\n}\n","import type { CoTEvent } from './types'\n\n/**\n * Serialises a typed {@link CoTEvent} back into a CoT XML string.\n * Inverse of {@link parseCoT}.\n *\n * @param event - The event to serialise.\n * @returns A CoT XML `<event>` string.\n */\nexport function serializeCoT(event: CoTEvent): string {\n  const how = event.how ? ` how=\"${event.how}\"` : ''\n  const callsign = event.detail?.contact?.callsign\n  const detail = callsign\n    ? `<detail><contact callsign=\"${callsign}\"/></detail>`\n    : ''\n\n  return (\n    `<event version=\"${event.version}\" uid=\"${event.uid}\" type=\"${event.type}\" `\n    + `time=\"${event.time}\" start=\"${event.start}\" stale=\"${event.stale}\"${how}>`\n    + `<point lat=\"${event.point.lat}\" lon=\"${event.point.lon}\" hae=\"${event.point.hae}\" `\n    + `ce=\"${event.point.ce}\" le=\"${event.point.le}\"/>${\n      detail\n    }</event>`\n  )\n}\n"],"mappings":"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","names":["import_vue","import_vue","import_vue","import_vue"]}

package/dist/index.d.cts

@@ -0,0 +1,230 @@
+import * as vue from 'vue';
+
+type WebSocketStatus = 'connecting' | 'open' | 'closing' | 'closed';
+/**
+ * Reactive wrapper around a single browser `WebSocket`. Opens the connection
+ * immediately and exposes its live status and last received message. Does not
+ * reconnect — see {@link useReconnectingWebSocket} for that.
+ *
+ * The socket is closed automatically when the surrounding reactive scope is disposed.
+ *
+ * @param url - WebSocket URL to connect to, e.g. `wss://tak.example/cot`.
+ * @returns `status` (reactive connection state), `data` (latest string message
+ * or `null`) and `send` (sends a payload only while the socket is open).
+ *
+ * @example
+ * ```ts
+ * const { status, data } = useWebSocket('wss://tak.example/cot')
+ * ```
+ */
+declare function useWebSocket(url: string): {
+    status: vue.Ref<WebSocketStatus, WebSocketStatus>;
+    data: vue.Ref<string | null, string | null>;
+    send: (payload: string) => void;
+};
+
+type ReconnectingStatus = WebSocketStatus | 'reconnecting';
+interface ReconnectingOptions {
+    baseMs?: number;
+    maxMs?: number;
+    maxAttempts?: number;
+}
+/**
+ * Like {@link useWebSocket}, but automatically reconnects with exponential
+ * backoff and jitter when the connection drops unexpectedly.
+ *
+ * @param url - WebSocket URL to connect to.
+ * @param options - Backoff tuning: `baseMs` (first delay, default 1000),
+ * `maxMs` (delay cap, default 15000) and `maxAttempts` (default unlimited).
+ * @returns The reactive `status`, `data` and `attempts`, plus `reconnect()`
+ * (force an immediate retry), `close()` (stop for good) and `send()`.
+ *
+ * @example
+ * ```ts
+ * const { status, attempts, reconnect } = useReconnectingWebSocket(url, { maxAttempts: 10 })
+ * ```
+ */
+declare function useReconnectingWebSocket(url: string, options?: ReconnectingOptions): {
+    status: vue.Ref<ReconnectingStatus, ReconnectingStatus>;
+    data: vue.Ref<string | null, string | null>;
+    attempts: vue.Ref<number, number>;
+    reconnect: () => void;
+    close: () => void;
+    send: (payload: string) => void;
+};
+
+interface CoTPoint {
+    lat: number;
+    lon: number;
+    hae: number;
+    ce: number;
+    le: number;
+}
+interface CoTContact {
+    callsign?: string;
+    endpoint?: string;
+}
+interface CoTDetail {
+    contact?: CoTContact;
+}
+interface CoTEvent {
+    version: string;
+    uid: string;
+    type: string;
+    time: string;
+    start: string;
+    stale: string;
+    how?: string;
+    point: CoTPoint;
+    detail?: CoTDetail;
+}
+
+interface TakConnectionOptions {
+    pingIntervalMs?: number;
+    pingTimeoutMs?: number;
+    onConnect?: () => void;
+    onMessage?: (cot: string) => void;
+    onDisconnect?: () => void;
+    onError?: () => void;
+}
+/**
+ * Application-level TAK connection on top of {@link useReconnectingWebSocket}.
+ * Adds ping keepalive, zombie-connection detection (forces a reconnect when no
+ * traffic is seen within `pingTimeoutMs`) and newline-delimited message framing,
+ * so `onMessage` fires once per whole CoT message.
+ *
+ * @param url - WebSocket URL of the TAK/CoT feed.
+ * @param options - Lifecycle hooks (`onConnect`, `onMessage`, `onDisconnect`,
+ * `onError`) plus `pingIntervalMs` (default 15000) and `pingTimeoutMs` (default 30000).
+ * @returns Reactive `status`, `data`, `attempts` and the `reconnect`, `close`, `send` controls.
+ */
+declare function useTakConnection(url: string, options?: TakConnectionOptions): {
+    status: vue.Ref<ReconnectingStatus, ReconnectingStatus>;
+    data: vue.Ref<string | null, string | null>;
+    attempts: vue.Ref<number, number>;
+    reconnect: () => void;
+    close: () => void;
+    send: (payload: string) => void;
+};
+
+type CoTStreamOptions = TakConnectionOptions & {
+    onEvent?: (event: CoTEvent) => void;
+};
+/**
+ * High-level CoT stream: wraps {@link useTakConnection} and parses each framed
+ * message into a typed {@link CoTEvent}. Prefer the lossless `onEvent` callback
+ * (fired once per parsed frame) to feed a store; the reactive `event` ref only
+ * ever holds the most recent message.
+ *
+ * @param url - WebSocket URL of the CoT feed.
+ * @param options - {@link TakConnectionOptions} plus `onEvent(event)`, called
+ * for every successfully parsed CoT message.
+ * @returns The underlying connection controls plus reactive `event` (latest
+ * parsed `CoTEvent` or `null`) and `error` (last parse error or `null`).
+ *
+ * @example
+ * ```ts
+ * const store = useEntityStore()
+ * useCoTStream(url, { onEvent: (e) => store.upsert(e) })
+ * ```
+ */
+declare function useCoTStream(url: string, options?: CoTStreamOptions): {
+    event: vue.Ref<{
+        version: string;
+        uid: string;
+        type: string;
+        time: string;
+        start: string;
+        stale: string;
+        how?: string | undefined;
+        point: {
+            lat: number;
+            lon: number;
+            hae: number;
+            ce: number;
+            le: number;
+        };
+        detail?: {
+            contact?: {
+                callsign?: string | undefined;
+                endpoint?: string | undefined;
+            } | undefined;
+        } | undefined;
+    } | null, CoTEvent | {
+        version: string;
+        uid: string;
+        type: string;
+        time: string;
+        start: string;
+        stale: string;
+        how?: string | undefined;
+        point: {
+            lat: number;
+            lon: number;
+            hae: number;
+            ce: number;
+            le: number;
+        };
+        detail?: {
+            contact?: {
+                callsign?: string | undefined;
+                endpoint?: string | undefined;
+            } | undefined;
+        } | undefined;
+    } | null>;
+    error: vue.Ref<Error | null, Error | null>;
+    status: vue.Ref<ReconnectingStatus, ReconnectingStatus>;
+    data: vue.Ref<string | null, string | null>;
+    attempts: vue.Ref<number, number>;
+    reconnect: () => void;
+    close: () => void;
+    send: (payload: string) => void;
+};
+
+type Entity = CoTEvent & {
+    receivedAt: number;
+};
+/**
+ * Reactive store of CoT entities keyed by `uid`. Backed by a `shallowRef<Map>`
+ * with a single `requestAnimationFrame` loop that sweeps out entities whose
+ * `stale` time has passed, so the collection self-expires.
+ *
+ * @returns `entities` (the reactive `Map<uid, Entity>`), `upsert(event)`
+ * (insert or replace, stamping `receivedAt`), `list` (entities as a reactive
+ * array), `count` and `byAffiliation` (entities grouped by CoT affiliation).
+ *
+ * @example
+ * ```ts
+ * const store = useEntityStore()
+ * store.upsert(parseCoT(xml))
+ * // store.list.value -> Entity[]
+ * ```
+ */
+declare function useEntityStore(): {
+    entities: vue.ShallowRef<Map<string, Entity>, Map<string, Entity>>;
+    upsert: (event: CoTEvent) => void;
+    list: vue.ComputedRef<Entity[]>;
+    count: vue.ComputedRef<number>;
+    byAffiliation: vue.ComputedRef<Map<string, Entity[]>>;
+};
+
+/**
+ * Parses a CoT (Cursor on Target) XML string into a typed {@link CoTEvent}.
+ * Inverse of {@link serializeCoT}.
+ *
+ * @param xml - A single CoT XML message (an `<event>` element).
+ * @returns The parsed, typed event.
+ * @throws If the XML has no `<event>` root or is missing its `<point>`.
+ */
+declare function parseCoT(xml: string): CoTEvent;
+
+/**
+ * Serialises a typed {@link CoTEvent} back into a CoT XML string.
+ * Inverse of {@link parseCoT}.
+ *
+ * @param event - The event to serialise.
+ * @returns A CoT XML `<event>` string.
+ */
+declare function serializeCoT(event: CoTEvent): string;
+
+export { type CoTContact, type CoTDetail, type CoTEvent, type CoTPoint, type CoTStreamOptions, type Entity, type ReconnectingOptions, type ReconnectingStatus, type TakConnectionOptions, type WebSocketStatus, parseCoT, serializeCoT, useCoTStream, useEntityStore, useReconnectingWebSocket, useTakConnection, useWebSocket };

package/dist/index.d.ts

@@ -0,0 +1,230 @@
+import * as vue from 'vue';
+
+type WebSocketStatus = 'connecting' | 'open' | 'closing' | 'closed';
+/**
+ * Reactive wrapper around a single browser `WebSocket`. Opens the connection
+ * immediately and exposes its live status and last received message. Does not
+ * reconnect — see {@link useReconnectingWebSocket} for that.
+ *
+ * The socket is closed automatically when the surrounding reactive scope is disposed.
+ *
+ * @param url - WebSocket URL to connect to, e.g. `wss://tak.example/cot`.
+ * @returns `status` (reactive connection state), `data` (latest string message
+ * or `null`) and `send` (sends a payload only while the socket is open).
+ *
+ * @example
+ * ```ts
+ * const { status, data } = useWebSocket('wss://tak.example/cot')
+ * ```
+ */
+declare function useWebSocket(url: string): {
+    status: vue.Ref<WebSocketStatus, WebSocketStatus>;
+    data: vue.Ref<string | null, string | null>;
+    send: (payload: string) => void;
+};
+
+type ReconnectingStatus = WebSocketStatus | 'reconnecting';
+interface ReconnectingOptions {
+    baseMs?: number;
+    maxMs?: number;
+    maxAttempts?: number;
+}
+/**
+ * Like {@link useWebSocket}, but automatically reconnects with exponential
+ * backoff and jitter when the connection drops unexpectedly.
+ *
+ * @param url - WebSocket URL to connect to.
+ * @param options - Backoff tuning: `baseMs` (first delay, default 1000),
+ * `maxMs` (delay cap, default 15000) and `maxAttempts` (default unlimited).
+ * @returns The reactive `status`, `data` and `attempts`, plus `reconnect()`
+ * (force an immediate retry), `close()` (stop for good) and `send()`.
+ *
+ * @example
+ * ```ts
+ * const { status, attempts, reconnect } = useReconnectingWebSocket(url, { maxAttempts: 10 })
+ * ```
+ */
+declare function useReconnectingWebSocket(url: string, options?: ReconnectingOptions): {
+    status: vue.Ref<ReconnectingStatus, ReconnectingStatus>;
+    data: vue.Ref<string | null, string | null>;
+    attempts: vue.Ref<number, number>;
+    reconnect: () => void;
+    close: () => void;
+    send: (payload: string) => void;
+};
+
+interface CoTPoint {
+    lat: number;
+    lon: number;
+    hae: number;
+    ce: number;
+    le: number;
+}
+interface CoTContact {
+    callsign?: string;
+    endpoint?: string;
+}
+interface CoTDetail {
+    contact?: CoTContact;
+}
+interface CoTEvent {
+    version: string;
+    uid: string;
+    type: string;
+    time: string;
+    start: string;
+    stale: string;
+    how?: string;
+    point: CoTPoint;
+    detail?: CoTDetail;
+}
+
+interface TakConnectionOptions {
+    pingIntervalMs?: number;
+    pingTimeoutMs?: number;
+    onConnect?: () => void;
+    onMessage?: (cot: string) => void;
+    onDisconnect?: () => void;
+    onError?: () => void;
+}
+/**
+ * Application-level TAK connection on top of {@link useReconnectingWebSocket}.
+ * Adds ping keepalive, zombie-connection detection (forces a reconnect when no
+ * traffic is seen within `pingTimeoutMs`) and newline-delimited message framing,
+ * so `onMessage` fires once per whole CoT message.
+ *
+ * @param url - WebSocket URL of the TAK/CoT feed.
+ * @param options - Lifecycle hooks (`onConnect`, `onMessage`, `onDisconnect`,
+ * `onError`) plus `pingIntervalMs` (default 15000) and `pingTimeoutMs` (default 30000).
+ * @returns Reactive `status`, `data`, `attempts` and the `reconnect`, `close`, `send` controls.
+ */
+declare function useTakConnection(url: string, options?: TakConnectionOptions): {
+    status: vue.Ref<ReconnectingStatus, ReconnectingStatus>;
+    data: vue.Ref<string | null, string | null>;
+    attempts: vue.Ref<number, number>;
+    reconnect: () => void;
+    close: () => void;
+    send: (payload: string) => void;
+};
+
+type CoTStreamOptions = TakConnectionOptions & {
+    onEvent?: (event: CoTEvent) => void;
+};
+/**
+ * High-level CoT stream: wraps {@link useTakConnection} and parses each framed
+ * message into a typed {@link CoTEvent}. Prefer the lossless `onEvent` callback
+ * (fired once per parsed frame) to feed a store; the reactive `event` ref only
+ * ever holds the most recent message.
+ *
+ * @param url - WebSocket URL of the CoT feed.
+ * @param options - {@link TakConnectionOptions} plus `onEvent(event)`, called
+ * for every successfully parsed CoT message.
+ * @returns The underlying connection controls plus reactive `event` (latest
+ * parsed `CoTEvent` or `null`) and `error` (last parse error or `null`).
+ *
+ * @example
+ * ```ts
+ * const store = useEntityStore()
+ * useCoTStream(url, { onEvent: (e) => store.upsert(e) })
+ * ```
+ */
+declare function useCoTStream(url: string, options?: CoTStreamOptions): {
+    event: vue.Ref<{
+        version: string;
+        uid: string;
+        type: string;
+        time: string;
+        start: string;
+        stale: string;
+        how?: string | undefined;
+        point: {
+            lat: number;
+            lon: number;
+            hae: number;
+            ce: number;
+            le: number;
+        };
+        detail?: {
+            contact?: {
+                callsign?: string | undefined;
+                endpoint?: string | undefined;
+            } | undefined;
+        } | undefined;
+    } | null, CoTEvent | {
+        version: string;
+        uid: string;
+        type: string;
+        time: string;
+        start: string;
+        stale: string;
+        how?: string | undefined;
+        point: {
+            lat: number;
+            lon: number;
+            hae: number;
+            ce: number;
+            le: number;
+        };
+        detail?: {
+            contact?: {
+                callsign?: string | undefined;
+                endpoint?: string | undefined;
+            } | undefined;
+        } | undefined;
+    } | null>;
+    error: vue.Ref<Error | null, Error | null>;
+    status: vue.Ref<ReconnectingStatus, ReconnectingStatus>;
+    data: vue.Ref<string | null, string | null>;
+    attempts: vue.Ref<number, number>;
+    reconnect: () => void;
+    close: () => void;
+    send: (payload: string) => void;
+};
+
+type Entity = CoTEvent & {
+    receivedAt: number;
+};
+/**
+ * Reactive store of CoT entities keyed by `uid`. Backed by a `shallowRef<Map>`
+ * with a single `requestAnimationFrame` loop that sweeps out entities whose
+ * `stale` time has passed, so the collection self-expires.
+ *
+ * @returns `entities` (the reactive `Map<uid, Entity>`), `upsert(event)`
+ * (insert or replace, stamping `receivedAt`), `list` (entities as a reactive
+ * array), `count` and `byAffiliation` (entities grouped by CoT affiliation).
+ *
+ * @example
+ * ```ts
+ * const store = useEntityStore()
+ * store.upsert(parseCoT(xml))
+ * // store.list.value -> Entity[]
+ * ```
+ */
+declare function useEntityStore(): {
+    entities: vue.ShallowRef<Map<string, Entity>, Map<string, Entity>>;
+    upsert: (event: CoTEvent) => void;
+    list: vue.ComputedRef<Entity[]>;
+    count: vue.ComputedRef<number>;
+    byAffiliation: vue.ComputedRef<Map<string, Entity[]>>;
+};
+
+/**
+ * Parses a CoT (Cursor on Target) XML string into a typed {@link CoTEvent}.
+ * Inverse of {@link serializeCoT}.
+ *
+ * @param xml - A single CoT XML message (an `<event>` element).
+ * @returns The parsed, typed event.
+ * @throws If the XML has no `<event>` root or is missing its `<point>`.
+ */
+declare function parseCoT(xml: string): CoTEvent;
+
+/**
+ * Serialises a typed {@link CoTEvent} back into a CoT XML string.
+ * Inverse of {@link parseCoT}.
+ *
+ * @param event - The event to serialise.
+ * @returns A CoT XML `<event>` string.
+ */
+declare function serializeCoT(event: CoTEvent): string;
+
+export { type CoTContact, type CoTDetail, type CoTEvent, type CoTPoint, type CoTStreamOptions, type Entity, type ReconnectingOptions, type ReconnectingStatus, type TakConnectionOptions, type WebSocketStatus, parseCoT, serializeCoT, useCoTStream, useEntityStore, useReconnectingWebSocket, useTakConnection, useWebSocket };

package/dist/index.js

@@ -0,0 +1,264 @@
+// src/composables/use-cot-stream.ts
+import { ref as ref2 } from "vue";
+
+// src/protocol/parse.ts
+import { XMLParser } from "fast-xml-parser";
+var parser = new XMLParser({
+  ignoreAttributes: false,
+  attributeNamePrefix: ""
+});
+function parseCoT(xml) {
+  const raw = parser.parse(xml);
+  const event = raw?.event;
+  if (!event)
+    throw new Error("invalid CoT:missing <event> root");
+  const point = event.point;
+  if (!point)
+    throw new Error("invalid CoT:<event> missing <point>");
+  return {
+    version: String(event.version),
+    uid: String(event.uid),
+    type: String(event.type),
+    time: String(event.time),
+    start: String(event.start),
+    stale: String(event.stale),
+    how: event.how ? String(event.how) : void 0,
+    point: {
+      lat: Number(point.lat),
+      lon: Number(point.lon),
+      hae: Number(point.hae),
+      ce: Number(point.ce),
+      le: Number(point.le)
+    },
+    detail: event.detail ? {
+      contact: event.detail.contact ? { callsign: event.detail.contact.callsign } : void 0
+    } : void 0
+  };
+}
+
+// src/composables/use-tak-connection.ts
+import { onScopeDispose as onScopeDispose2, watch } from "vue";
+
+// src/composables/use-reconnecting-websocket.ts
+import { onScopeDispose, ref } from "vue";
+
+// src/utils/backoff.ts
+function backoffDelay(attempt, options = {}) {
+  const { baseMs = 1e3, maxMs = 15e3 } = options;
+  const exponential = Math.min(baseMs * 2 ** attempt, maxMs);
+  const half = exponential / 2;
+  return half + Math.random() * half;
+}
+
+// src/composables/use-reconnecting-websocket.ts
+function useReconnectingWebSocket(url, options = {}) {
+  const {
+    baseMs = 1e3,
+    maxMs = 15e3,
+    maxAttempts = Number.POSITIVE_INFINITY
+  } = options;
+  const status = ref("closed");
+  const data = ref(null);
+  const attempts = ref(0);
+  let ws = null;
+  let reconnectTimer;
+  let manualClose = false;
+  function connect() {
+    ws = new WebSocket(url);
+    status.value = "connecting";
+    ws.onopen = () => {
+      status.value = "open";
+      attempts.value = 0;
+    };
+    ws.onmessage = (event) => {
+      if (typeof event.data === "string")
+        data.value = event.data;
+    };
+    ws.onerror = () => {
+      console.error("[useReconnectingWebSocket] connection error");
+    };
+    ws.onclose = () => {
+      if (manualClose || attempts.value >= maxAttempts) {
+        status.value = "closed";
+        return;
+      }
+      const delay = backoffDelay(attempts.value, { baseMs, maxMs });
+      attempts.value++;
+      status.value = "reconnecting";
+      reconnectTimer = setTimeout(connect, delay);
+    };
+  }
+  function reconnect() {
+    clearTimeout(reconnectTimer);
+    attempts.value = 0;
+    if (ws) {
+      ws.onclose = null;
+      ws.close();
+    }
+    manualClose = false;
+    connect();
+  }
+  function close() {
+    manualClose = true;
+    clearTimeout(reconnectTimer);
+    ws?.close();
+  }
+  function send(payload) {
+    if (ws && ws.readyState === WebSocket.OPEN)
+      ws.send(payload);
+  }
+  connect();
+  onScopeDispose(close);
+  return { status, data, attempts, reconnect, close, send };
+}
+
+// src/composables/use-tak-connection.ts
+function useTakConnection(url, options = {}) {
+  const connection = useReconnectingWebSocket(url);
+  const { status, data, attempts, close, reconnect, send } = connection;
+  const { pingIntervalMs = 15e3, pingTimeoutMs = 3e4 } = options;
+  let lastSeen = Date.now();
+  watch(status, (newStatus, oldStatus) => {
+    if (newStatus === "open") {
+      lastSeen = Date.now();
+      options.onConnect?.();
+    } else if (oldStatus === "open") {
+      options.onDisconnect?.();
+    }
+  });
+  watch(data, () => {
+    lastSeen = Date.now();
+  });
+  let buffer = "";
+  watch(data, (raw) => {
+    if (raw === null)
+      return;
+    buffer += raw;
+    const frames = buffer.split("\n");
+    buffer = frames.pop() ?? "";
+    for (const frame of frames) {
+      const trimmed = frame.trim();
+      if (trimmed) {
+        options.onMessage?.(trimmed);
+      }
+    }
+  });
+  const pingTimer = setInterval(() => {
+    send("ping");
+    if (Date.now() - lastSeen > pingTimeoutMs)
+      reconnect();
+  }, pingIntervalMs);
+  onScopeDispose2(() => clearInterval(pingTimer));
+  return { status, data, attempts, reconnect, close, send };
+}
+
+// src/composables/use-cot-stream.ts
+function useCoTStream(url, options = {}) {
+  const event = ref2(null);
+  const error = ref2(null);
+  const connection = useTakConnection(url, {
+    ...options,
+    onMessage: (raw) => {
+      try {
+        const parsed = parseCoT(raw);
+        event.value = parsed;
+        error.value = null;
+        options.onEvent?.(parsed);
+        options.onMessage?.(raw);
+      } catch (err) {
+        error.value = err;
+      }
+    }
+  });
+  return { ...connection, event, error };
+}
+
+// src/composables/use-entity-store.ts
+import { computed, onScopeDispose as onScopeDispose3, shallowRef, triggerRef } from "vue";
+function useEntityStore() {
+  const entities = shallowRef(/* @__PURE__ */ new Map());
+  function upsert(event) {
+    entities.value.set(event.uid, { ...event, receivedAt: Date.now() });
+    triggerRef(entities);
+  }
+  let rafId = 0;
+  function sweep() {
+    const now = Date.now();
+    let remove = false;
+    for (const [uid, entity] of entities.value) {
+      if (Date.parse(entity.stale) < now) {
+        entities.value.delete(uid);
+        remove = true;
+      }
+    }
+    if (remove) {
+      triggerRef(entities);
+    }
+    rafId = requestAnimationFrame(sweep);
+  }
+  rafId = requestAnimationFrame(sweep);
+  onScopeDispose3(() => cancelAnimationFrame(rafId));
+  const list = computed(() => Array.from(entities.value.values()));
+  const count = computed(() => entities.value.size);
+  const byAffiliation = computed(() => {
+    const groups = /* @__PURE__ */ new Map();
+    for (const entity of entities.value.values()) {
+      const affiliation = entity.type.split("-")[1] ?? "unknown";
+      const group = groups.get(affiliation) ?? [];
+      group.push(entity);
+      groups.set(affiliation, group);
+    }
+    return groups;
+  });
+  return { entities, upsert, list, count, byAffiliation };
+}
+
+// src/composables/use-websocket.ts
+import { onScopeDispose as onScopeDispose4, ref as ref3 } from "vue";
+function useWebSocket(url) {
+  const status = ref3("closed");
+  const data = ref3(null);
+  const ws = new WebSocket(url);
+  status.value = "connecting";
+  ws.onopen = () => {
+    status.value = "open";
+  };
+  ws.onmessage = (event) => {
+    if (typeof event.data === "string") {
+      data.value = event.data;
+    }
+  };
+  ws.onclose = () => {
+    status.value = "closed";
+  };
+  ws.onerror = () => {
+    console.error("[useWebSocket] connection error");
+  };
+  function send(payload) {
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.send(payload);
+    }
+  }
+  onScopeDispose4(() => {
+    ws.close();
+  });
+  return { status, data, send };
+}
+
+// src/protocol/serialize.ts
+function serializeCoT(event) {
+  const how = event.how ? ` how="${event.how}"` : "";
+  const callsign = event.detail?.contact?.callsign;
+  const detail = callsign ? `<detail><contact callsign="${callsign}"/></detail>` : "";
+  return `<event version="${event.version}" uid="${event.uid}" type="${event.type}" time="${event.time}" start="${event.start}" stale="${event.stale}"${how}><point lat="${event.point.lat}" lon="${event.point.lon}" hae="${event.point.hae}" ce="${event.point.ce}" le="${event.point.le}"/>${detail}</event>`;
+}
+export {
+  parseCoT,
+  serializeCoT,
+  useCoTStream,
+  useEntityStore,
+  useReconnectingWebSocket,
+  useTakConnection,
+  useWebSocket
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/composables/use-cot-stream.ts","../src/protocol/parse.ts","../src/composables/use-tak-connection.ts","../src/composables/use-reconnecting-websocket.ts","../src/utils/backoff.ts","../src/composables/use-entity-store.ts","../src/composables/use-websocket.ts","../src/protocol/serialize.ts"],"sourcesContent":["import type { CoTEvent } from '../protocol/types'\nimport type { TakConnectionOptions } from './use-tak-connection'\nimport { ref } from 'vue'\nimport { parseCoT } from '../protocol/parse'\nimport { useTakConnection } from './use-tak-connection'\n\nexport type CoTStreamOptions = TakConnectionOptions & {\n  onEvent?: (event: CoTEvent) => void\n}\n\n/**\n * High-level CoT stream: wraps {@link useTakConnection} and parses each framed\n * message into a typed {@link CoTEvent}. Prefer the lossless `onEvent` callback\n * (fired once per parsed frame) to feed a store; the reactive `event` ref only\n * ever holds the most recent message.\n *\n * @param url - WebSocket URL of the CoT feed.\n * @param options - {@link TakConnectionOptions} plus `onEvent(event)`, called\n * for every successfully parsed CoT message.\n * @returns The underlying connection controls plus reactive `event` (latest\n * parsed `CoTEvent` or `null`) and `error` (last parse error or `null`).\n *\n * @example\n * ```ts\n * const store = useEntityStore()\n * useCoTStream(url, { onEvent: (e) => store.upsert(e) })\n * ```\n */\nexport function useCoTStream(url: string, options: CoTStreamOptions = {}) {\n  const event = ref<CoTEvent | null>(null)\n  const error = ref<Error | null>(null)\n\n  const connection = useTakConnection(url, {\n    ...options,\n    onMessage: (raw) => {\n      try {\n        const parsed = parseCoT(raw)\n        event.value = parsed\n        error.value = null\n        options.onEvent?.(parsed)\n        options.onMessage?.(raw)\n      }\n      catch (err) {\n        error.value = err as Error\n      }\n    },\n  })\n\n  return { ...connection, event, error }\n}\n","import type { CoTEvent } from './types'\nimport { XMLParser } from 'fast-xml-parser'\n\nconst parser = new XMLParser({\n  ignoreAttributes: false,\n  attributeNamePrefix: '',\n})\n\n/**\n * Parses a CoT (Cursor on Target) XML string into a typed {@link CoTEvent}.\n * Inverse of {@link serializeCoT}.\n *\n * @param xml - A single CoT XML message (an `<event>` element).\n * @returns The parsed, typed event.\n * @throws If the XML has no `<event>` root or is missing its `<point>`.\n */\nexport function parseCoT(xml: string): CoTEvent {\n  const raw = parser.parse(xml)\n  const event = raw?.event\n  if (!event)\n    throw new Error('invalid CoT:missing <event> root')\n  const point = event.point\n  if (!point)\n    throw new Error('invalid CoT:<event> missing <point>')\n\n  return {\n    version: String(event.version),\n    uid: String(event.uid),\n    type: String(event.type),\n    time: String(event.time),\n    start: String(event.start),\n    stale: String(event.stale),\n    how: event.how ? String(event.how) : undefined,\n    point: {\n      lat: Number(point.lat),\n      lon: Number(point.lon),\n      hae: Number(point.hae),\n      ce: Number(point.ce),\n      le: Number(point.le),\n    },\n    detail: event.detail\n      ? {\n          contact: event.detail.contact\n            ? { callsign: event.detail.contact.callsign }\n            : undefined,\n        }\n      : undefined,\n  }\n}\n","import { onScopeDispose, watch } from 'vue'\nimport { useReconnectingWebSocket } from './use-reconnecting-websocket'\n\nexport interface TakConnectionOptions {\n  pingIntervalMs?: number\n  pingTimeoutMs?: number\n  onConnect?: () => void\n  onMessage?: (cot: string) => void\n  onDisconnect?: () => void\n  onError?: () => void\n}\n\n/**\n * Application-level TAK connection on top of {@link useReconnectingWebSocket}.\n * Adds ping keepalive, zombie-connection detection (forces a reconnect when no\n * traffic is seen within `pingTimeoutMs`) and newline-delimited message framing,\n * so `onMessage` fires once per whole CoT message.\n *\n * @param url - WebSocket URL of the TAK/CoT feed.\n * @param options - Lifecycle hooks (`onConnect`, `onMessage`, `onDisconnect`,\n * `onError`) plus `pingIntervalMs` (default 15000) and `pingTimeoutMs` (default 30000).\n * @returns Reactive `status`, `data`, `attempts` and the `reconnect`, `close`, `send` controls.\n */\nexport function useTakConnection(\n  url: string,\n  options: TakConnectionOptions = {},\n) {\n  const connection = useReconnectingWebSocket(url)\n  const { status, data, attempts, close, reconnect, send } = connection\n  const { pingIntervalMs = 15_000, pingTimeoutMs = 30_000 } = options\n  let lastSeen = Date.now()\n\n  watch(status, (newStatus, oldStatus) => {\n    if (newStatus === 'open') {\n      lastSeen = Date.now()\n      options.onConnect?.()\n    }\n    else if (oldStatus === 'open') {\n      options.onDisconnect?.()\n    }\n  })\n  watch(data, () => {\n    lastSeen = Date.now()\n  })\n\n  let buffer = ''\n  watch(data, (raw) => {\n    if (raw === null)\n      return\n    buffer += raw\n    const frames = buffer.split('\\n')\n    buffer = frames.pop() ?? ''\n    for (const frame of frames) {\n      const trimmed = frame.trim()\n      if (trimmed) {\n        options.onMessage?.(trimmed)\n      }\n    }\n  })\n\n  const pingTimer = setInterval(() => {\n    send('ping')\n    if (Date.now() - lastSeen > pingTimeoutMs)\n      reconnect()\n  }, pingIntervalMs)\n\n  onScopeDispose(() => clearInterval(pingTimer))\n\n  return { status, data, attempts, reconnect, close, send }\n}\n","import type { WebSocketStatus } from './use-websocket'\nimport { onScopeDispose, ref } from 'vue'\nimport { backoffDelay } from '../utils/backoff'\n\nexport type ReconnectingStatus = WebSocketStatus | 'reconnecting'\n\nexport interface ReconnectingOptions {\n  baseMs?: number\n  maxMs?: number\n  maxAttempts?: number\n}\n\n/**\n * Like {@link useWebSocket}, but automatically reconnects with exponential\n * backoff and jitter when the connection drops unexpectedly.\n *\n * @param url - WebSocket URL to connect to.\n * @param options - Backoff tuning: `baseMs` (first delay, default 1000),\n * `maxMs` (delay cap, default 15000) and `maxAttempts` (default unlimited).\n * @returns The reactive `status`, `data` and `attempts`, plus `reconnect()`\n * (force an immediate retry), `close()` (stop for good) and `send()`.\n *\n * @example\n * ```ts\n * const { status, attempts, reconnect } = useReconnectingWebSocket(url, { maxAttempts: 10 })\n * ```\n */\nexport function useReconnectingWebSocket(\n  url: string,\n  options: ReconnectingOptions = {},\n) {\n  const {\n    baseMs = 1000,\n    maxMs = 15_000,\n    maxAttempts = Number.POSITIVE_INFINITY,\n  } = options\n\n  const status = ref<ReconnectingStatus>('closed')\n  const data = ref<string | null>(null)\n  const attempts = ref(0)\n\n  let ws: WebSocket | null = null\n  let reconnectTimer: ReturnType<typeof setTimeout> | undefined\n  let manualClose = false\n\n  function connect() {\n    ws = new WebSocket(url)\n    status.value = 'connecting'\n\n    ws.onopen = () => {\n      status.value = 'open'\n      attempts.value = 0\n    }\n    ws.onmessage = (event: MessageEvent) => {\n      if (typeof event.data === 'string')\n        data.value = event.data\n    }\n    ws.onerror = () => {\n      console.error('[useReconnectingWebSocket] connection error')\n    }\n    ws.onclose = () => {\n      if (manualClose || attempts.value >= maxAttempts) {\n        status.value = 'closed'\n        return\n      }\n      const delay = backoffDelay(attempts.value, { baseMs, maxMs })\n      attempts.value++\n      status.value = 'reconnecting'\n      reconnectTimer = setTimeout(connect, delay)\n    }\n  }\n\n  function reconnect() {\n    clearTimeout(reconnectTimer)\n    attempts.value = 0\n    if (ws) {\n      ws.onclose = null\n      ws.close()\n    }\n    manualClose = false\n    connect()\n  }\n  function close() {\n    manualClose = true\n    clearTimeout(reconnectTimer)\n    ws?.close()\n  }\n\n  function send(payload: string) {\n    if (ws && ws.readyState === WebSocket.OPEN)\n      ws.send(payload)\n  }\n\n  connect()\n  onScopeDispose(close)\n\n  return { status, data, attempts, reconnect, close, send }\n}\n","export interface BackoffOptions {\n  baseMs?: number\n  maxMs?: number\n}\n\n/**\n * Computes an exponential-backoff delay (in milliseconds) for a retry attempt.\n * The delay is `baseMs * 2 ** attempt`, capped at `maxMs`, with jitter added to\n * avoid the thundering-herd problem when many clients reconnect at once.\n *\n * @param attempt - Zero-based retry attempt number.\n * @param options - `baseMs` (default 1000) and `maxMs` (cap, default 15000).\n * @returns The delay to wait before the next attempt, in milliseconds.\n */\nexport function backoffDelay(\n  attempt: number,\n  options: BackoffOptions = {},\n): number {\n  const { baseMs = 1000, maxMs = 15_000 } = options\n  const exponential = Math.min(baseMs * 2 ** attempt, maxMs)\n  const half = exponential / 2\n  return half + Math.random() * half\n}\n","import type { CoTEvent } from '../protocol/types'\nimport { computed, onScopeDispose, shallowRef, triggerRef } from 'vue'\n\nexport type Entity = CoTEvent & { receivedAt: number }\n/**\n * Reactive store of CoT entities keyed by `uid`. Backed by a `shallowRef<Map>`\n * with a single `requestAnimationFrame` loop that sweeps out entities whose\n * `stale` time has passed, so the collection self-expires.\n *\n * @returns `entities` (the reactive `Map<uid, Entity>`), `upsert(event)`\n * (insert or replace, stamping `receivedAt`), `list` (entities as a reactive\n * array), `count` and `byAffiliation` (entities grouped by CoT affiliation).\n *\n * @example\n * ```ts\n * const store = useEntityStore()\n * store.upsert(parseCoT(xml))\n * // store.list.value -> Entity[]\n * ```\n */\nexport function useEntityStore() {\n  const entities = shallowRef(new Map<string, Entity>())\n\n  function upsert(event: CoTEvent) {\n    entities.value.set(event.uid, { ...event, receivedAt: Date.now() })\n    triggerRef(entities)\n  }\n\n  let rafId = 0\n  function sweep() {\n    const now = Date.now()\n    let remove = false\n    for (const [uid, entity] of entities.value) {\n      if (Date.parse(entity.stale) < now) {\n        entities.value.delete(uid)\n        remove = true\n      }\n    }\n    if (remove) {\n      triggerRef(entities)\n    }\n    rafId = requestAnimationFrame(sweep)\n  }\n  rafId = requestAnimationFrame(sweep)\n  onScopeDispose(() => cancelAnimationFrame(rafId))\n\n  const list = computed(() => Array.from(entities.value.values()))\n  const count = computed(() => entities.value.size)\n\n  const byAffiliation = computed(() => {\n    const groups = new Map<string, Entity[]>()\n    for (const entity of entities.value.values()) {\n      const affiliation = entity.type.split('-')[1] ?? 'unknown'\n      const group = groups.get(affiliation) ?? []\n      group.push(entity)\n      groups.set(affiliation, group)\n    }\n    return groups\n  })\n\n  return { entities, upsert, list, count, byAffiliation }\n}\n","import { onScopeDispose, ref } from 'vue'\n\nexport type WebSocketStatus = 'connecting' | 'open' | 'closing' | 'closed'\n\n/**\n * Reactive wrapper around a single browser `WebSocket`. Opens the connection\n * immediately and exposes its live status and last received message. Does not\n * reconnect — see {@link useReconnectingWebSocket} for that.\n *\n * The socket is closed automatically when the surrounding reactive scope is disposed.\n *\n * @param url - WebSocket URL to connect to, e.g. `wss://tak.example/cot`.\n * @returns `status` (reactive connection state), `data` (latest string message\n * or `null`) and `send` (sends a payload only while the socket is open).\n *\n * @example\n * ```ts\n * const { status, data } = useWebSocket('wss://tak.example/cot')\n * ```\n */\nexport function useWebSocket(url: string) {\n  const status = ref<WebSocketStatus>('closed')\n  const data = ref<string | null>(null)\n\n  const ws = new WebSocket(url)\n  status.value = 'connecting'\n\n  ws.onopen = () => {\n    status.value = 'open'\n  }\n  ws.onmessage = (event: MessageEvent) => {\n    if (typeof event.data === 'string') {\n      data.value = event.data\n    }\n  }\n  ws.onclose = () => {\n    status.value = 'closed'\n  }\n  ws.onerror = () => {\n    console.error('[useWebSocket] connection error')\n  }\n\n  function send(payload: string) {\n    if (ws.readyState === WebSocket.OPEN) {\n      ws.send(payload)\n    }\n  }\n\n  onScopeDispose(() => {\n    ws.close()\n  })\n\n  return { status, data, send }\n}\n","import type { CoTEvent } from './types'\n\n/**\n * Serialises a typed {@link CoTEvent} back into a CoT XML string.\n * Inverse of {@link parseCoT}.\n *\n * @param event - The event to serialise.\n * @returns A CoT XML `<event>` string.\n */\nexport function serializeCoT(event: CoTEvent): string {\n  const how = event.how ? ` how=\"${event.how}\"` : ''\n  const callsign = event.detail?.contact?.callsign\n  const detail = callsign\n    ? `<detail><contact callsign=\"${callsign}\"/></detail>`\n    : ''\n\n  return (\n    `<event version=\"${event.version}\" uid=\"${event.uid}\" type=\"${event.type}\" `\n    + `time=\"${event.time}\" start=\"${event.start}\" stale=\"${event.stale}\"${how}>`\n    + `<point lat=\"${event.point.lat}\" lon=\"${event.point.lon}\" hae=\"${event.point.hae}\" `\n    + `ce=\"${event.point.ce}\" le=\"${event.point.le}\"/>${\n      detail\n    }</event>`\n  )\n}\n"],"mappings":"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","names":["ref","onScopeDispose","onScopeDispose","ref","onScopeDispose","onScopeDispose","ref"]}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "vue-cot",
+  "type": "module",
+  "version": "0.1.0",
+  "description": "Vue 3 composables and parser for Cursor on Target (CoT) tactical messaging",
+  "license": "MIT",
+  "homepage": "https://github.com/belblue/vue-cot#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/belblue/vue-cot.git",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/belblue/vue-cot/issues"
+  },
+  "keywords": [
+    "vue",
+    "vue3",
+    "composables",
+    "cursor-on-target",
+    "cot",
+    "tak",
+    "atak",
+    "wintak",
+    "tak-server",
+    "tactical",
+    "situational-awareness",
+    "geospatial",
+    "websocket",
+    "real-time",
+    "xml-parser"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "vue": "^3.5.0"
+  },
+  "dependencies": {
+    "fast-xml-parser": "^5.9.3"
+  },
+  "devDependencies": {
+    "happy-dom": "^20.10.6",
+    "tsup": "^8.5.1",
+    "vitest": "^4.1.9",
+    "vue": "^3.5.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts"
+}