@tak-ps/cloudtak 13.30.0 → 13.31.0

package/dist/types/plugin.d.ts

@@ -121,6 +121,25 @@ export declare class PluginAPI {
             filter?: (feature: DBFeature) => boolean;
         }) => Observable<DBFeature[]>;
     };
+    /**
+     * Manage CoT Marti Queries
+     */
+    get cot(): {
+        /**
+         * Fetch the historic CoT points for a given UID from the TAK Server.
+         *
+         * Each point is returned as its own Feature retaining its temporal
+         * attributes so callers can build time-series visualizations.
+         *
+         * @param uid  The CoT UID to fetch history for
+         * @param opts Optional time window constraints
+         */
+        history: (uid: string, opts?: {
+            start?: string;
+            end?: string;
+            secago?: number;
+        }) => Promise<DBFeature[]>;
+    };
     /**
      * Manage Breadcrumb Trails
      */

package/dist/types/src/base/events.d.ts

@@ -19,7 +19,10 @@ export declare enum WorkerMessageType {
     Mission_Invite = "mission:invite",
     Channel_Change = "channel:change",
     Feature_Update = "cloudtak:feature:update",
-    Profile_Update = "cloudtak:profile:update"
+    Profile_Update = "cloudtak:profile:update",
+    Sync_Start = "cloudtak:sync:start",
+    Sync_Complete = "cloudtak:sync:complete",
+    Sync_Update = "cloudtak:sync:update"
 }
 export type WorkerMessage = {
     type: WorkerMessageType;

package/dist/types/src/base/overlay-sync.d.ts

@@ -0,0 +1,17 @@
+import type { ProfileOverlay } from '../types.ts';
+export declare const OVERLAY_LIST_CACHE_KEY = "overlay";
+/**
+ * Apply a single overlay (delivered inline on a sync event) to the local
+ * database - avoids re-listing overlays from the API, which is slow due to
+ * per-overlay existence checks
+ */
+export declare function applyOverlay(overlay: ProfileOverlay): Promise<void>;
+/**
+ * Remove a single overlay from the local database after it was deleted by
+ * another of the user's clients
+ */
+export declare function removeOverlay(id: number): Promise<void>;
+/**
+ * Refresh the local overlay database with the latest overlays from the server
+ */
+export declare function syncOverlays(): Promise<void>;

package/dist/types/src/stores/map.d.ts

@@ -127,6 +127,15 @@ export declare const useMapStore: import("pinia").StoreDefinition<"cloudtak", {
     init: (container: HTMLElement) => Promise<void>;
     submitLocationHttp: (position: Position) => Promise<void>;
     initOverlays: () => Promise<void>;
+    /**
+     * Reconcile the loaded map overlays against the local overlay
+     * database after a sync triggered by another of the user's connected
+     * clients. Adds newly created overlays, removes deleted ones and
+     * applies visibility/opacity changes. Changes are applied to the map
+     * directly (not via Overlay.update/save) so the reconcile does not
+     * PATCH the API and echo the event back to the originating client.
+     */
+    reconcileOverlays: () => Promise<void>;
     updateIconRotation: (enabled: boolean) => void;
     updateDistanceUnit: (unit: string) => void;
     updateAttribution: () => Promise<void>;

package/dist/types/src/workers/atlas-connection.d.ts

@@ -3,6 +3,7 @@ export default class AtlasConnection {
     atlas: Atlas;
     isDestroyed: boolean;
     isOpen: boolean;
+    hasConnected: boolean;
     ws: WebSocket | undefined;
     reconnectAttempts: number;
     version: string;

package/dist/types/src/workers/atlas-database.d.ts

@@ -13,6 +13,7 @@ type NestedArray = {
 export default class AtlasDatabase {
     atlas: Atlas;
     cots: Map<string, COT>;
+    archiveIds: Set<string>;
     mission?: string;
     static normalizePath(path: string): string;
     pendingCreate: Map<string, COT>;
@@ -69,6 +70,14 @@ export default class AtlasDatabase {
     touching(poly: Polygon): Promise<Set<COT>>;
     /**
      * Load Archived CoTs
+     *
+     * Reconciles the local store against the server's archive: features are
+     * added/updated idempotently and archived features that were previously
+     * loaded from the server but no longer exist there (deleted by another
+     * client, possibly while this client was disconnected) are removed
+     * locally. Only ids in `archiveIds` (seen from the server on a prior
+     * load) are prune candidates, so a freshly drawn feature whose PUT is
+     * still in flight is never removed.
      */
     loadArchive(): Promise<void>;
     /**

package/dist/types/src/workers/atlas-sync.d.ts

@@ -0,0 +1,63 @@
+import type Atlas from './atlas.ts';
+export declare enum SyncDataType {
+    Overlay = "overlay",
+    Feature = "feature",
+    Mission = "mission",
+    Basemap = "basemap",
+    Iconset = "iconset",
+    Profile = "profile",
+    Contact = "contact",
+    Chatroom = "chatroom",
+    Group = "group",
+    MissionTemplate = "mission-template",
+    Server = "server"
+}
+export declare enum SyncEventAction {
+    Create = "create",
+    Update = "update",
+    Delete = "delete"
+}
+export type SyncEvent = {
+    type: SyncDataType;
+    action: SyncEventAction;
+    id?: string | number;
+    body?: unknown;
+};
+export default class AtlasSync {
+    atlas: Atlas;
+    started: boolean;
+    isSyncing: boolean;
+    lastSync: number | null;
+    lastErrors: string[];
+    private current;
+    private queue;
+    private timer;
+    private flushing;
+    constructor(atlas: Atlas);
+    /**
+     * Called by the UI once the map has initialized and finished loading,
+     * kicking off the initial full synchronization with the TAK Server
+     */
+    start(): Promise<void>;
+    /**
+     * Perform a full synchronization of all data types. Concurrent calls
+     * coalesce onto the in-flight sync.
+     */
+    fullSync(): Promise<void>;
+    /**
+     * Entry point for sync events received over the WebSocket from
+     * AtlasConnection - queues the event and processes it after a short
+     * debounce so bursts of events result in a single sync per data type
+     */
+    event(event: SyncEvent): Promise<void>;
+    destroy(): void;
+    private runFullSync;
+    private flush;
+    private syncEvent;
+    /**
+     * Fetch a single archived feature by id from the API and apply it to the
+     * local store. If the feature no longer exists (deleted between the event
+     * firing and this fetch) it is removed locally instead.
+     */
+    private syncFeature;
+}

package/dist/types/src/workers/atlas.d.ts

@@ -3,6 +3,7 @@ import * as Comlink from 'comlink';
 import AtlasProfile from './atlas-profile.ts';
 import AtlasDatabase from './atlas-database.ts';
 import AtlasConnection from './atlas-connection.ts';
+import AtlasSync from './atlas-sync.ts';
 export default class Atlas {
     channel: BroadcastChannel;
     token: string;
@@ -11,6 +12,7 @@ export default class Atlas {
     db: AtlasDatabase & Comlink.ProxyMarked;
     conn: AtlasConnection & Comlink.ProxyMarked;
     profile: AtlasProfile & Comlink.ProxyMarked;
+    sync: AtlasSync & Comlink.ProxyMarked;
     constructor();
     postMessage(msg: WorkerMessage): Promise<void>;
     init(authToken: string): Promise<void>;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@tak-ps/cloudtak",
     "type": "module",
-    "version": "13.30.0",
+    "version": "13.31.0",
     "types": "dist/types/plugin.d.ts",
     "files": [
         "dist/types"