@tak-ps/cloudtak 12.54.0

package/README.md

@@ -0,0 +1,34 @@
+# TAK-PS-Stats Web UI
+
+## Project setup
+```
+npm install
+```
+
+### Compiles and hot-reloads for development
+```
+npm run serve
+```
+
+### Compiles and minifies for production
+```
+npm run build
+```
+
+### Lints and fixes files
+```
+npm run lint
+```
+
+### Generated TypeScript Definiton File
+
+The WebUI TypeScript definitions are built directly from the Swagger output of the server.
+With the server running locally on port 5001, run the following
+
+```
+npm run typegen
+```
+
+### Customize configuration
+
+See [Configuration Reference](https://cli.vuejs.org/config/).

package/dist/types/plugin.d.ts

@@ -0,0 +1,99 @@
+import type { App } from 'vue';
+import type { Router, RouteRecordRaw } from 'vue-router';
+import type { Pinia } from 'pinia';
+import type { MenuItemConfig } from './src/stores/modules/menu.ts';
+import { type DBFeature } from './src/base/database.ts';
+import { type Observable } from 'rxjs';
+import mapgl from 'maplibre-gl';
+export type { MenuItemConfig };
+export interface PluginInstance {
+    /**
+     * Called after `install` if the server has the plugin enabled by default
+     * or if the user has opted in to the plugin functionality
+     */
+    enable(): Promise<void>;
+    /**
+     * Called if the user disables the plugin, the plugin must
+     * remove all functionality from the user facing app
+     */
+    disable(): Promise<void>;
+}
+export interface PluginStatic {
+    /**
+     * Hook called on init, note the plugin should not make itself
+     * usable unless enable() is called.
+     */
+    install(app: App, api: PluginAPI): PluginInstance | Promise<PluginInstance>;
+}
+/**
+ * The Main Plugin API for managing CloudTAK UI functions
+ */
+export declare class PluginAPI {
+    /**
+     * The Vue App instance
+     */
+    app: App;
+    /**
+     * The Vue Router instance
+     */
+    router: Router;
+    /**
+     * The Pinia Store instance
+     */
+    pinia: Pinia;
+    /**
+     * @param app The Vue App instance
+     * @param router The Vue Router instance
+     * @param pinia The Pinia Store instance
+     */
+    constructor(app: App, router: Router, pinia: Pinia);
+    /**
+     * Manage the Main Menu
+     */
+    get menu(): {
+        /**
+         * Add a new item to the main menu
+         * @param item The menu item configuration
+         */
+        add: (item: MenuItemConfig) => void;
+        /**
+         * Remove an item from the main menu
+         * @param key The key of the menu item to remove
+         */
+        remove: (key: string) => void;
+    };
+    /**
+     * Manage Application Routes
+     */
+    get routes(): {
+        /**
+         * Add a new route to the application
+         * @param route The route configuration
+         * @param parentName The name of the parent route to add this route to (optional)
+         */
+        add: (route: RouteRecordRaw, parentName?: string) => void;
+    };
+    /**
+     * Map Accessors
+     */
+    get map(): mapgl.Map;
+    /**
+     * Manage Features
+     */
+    get feature(): {
+        /**
+         * List features from the local database
+         * @param opts Filter options
+         */
+        list: (opts?: {
+            filter?: (feature: DBFeature) => boolean;
+        }) => Promise<DBFeature[]>;
+        /**
+         * Stream features from the local database
+         * @param opts Filter options
+         */
+        stream: (opts?: {
+            filter?: (feature: DBFeature) => boolean;
+        }) => Observable<DBFeature[]>;
+    };
+}

package/dist/types/src/App.vue.d.ts

@@ -0,0 +1,5 @@
+import '@tabler/core/dist/js/tabler.min.js';
+import '@tabler/core/dist/css/tabler.min.css';
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/src/base/chatroom-chats.d.ts

@@ -0,0 +1,17 @@
+import type { DBChatroomChat } from './database.ts';
+import type Atlas from '../workers/atlas.ts';
+export default class ChatroomChats {
+    chatroom: string;
+    constructor(chatroom: string);
+    refresh(): Promise<void>;
+    list(opts?: {
+        refresh?: boolean;
+    }): Promise<Array<DBChatroomChat>>;
+    send(message: string, sender: {
+        uid: string;
+        callsign: string;
+    }, worker: Atlas, recipient?: {
+        uid: string;
+        callsign: string;
+    }): Promise<void>;
+}

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

@@ -0,0 +1,47 @@
+import type { DBChatroom } from './database.ts';
+import ChatroomChats from './chatroom-chats.ts';
+import type { ProfileChatroomList, ProfileChatList } from '../types.ts';
+/**
+ * High Level Wrapper around the Profile Chatroom API
+ *
+ * @property {string} name - The name of the chatroom
+ */
+export default class Chatroom {
+    name: string;
+    chats: ChatroomChats;
+    constructor(name: string);
+    /**
+     * Return a Chatroom instance if one already exists in the local DB,
+     */
+    static from(name: string): Promise<Chatroom | undefined>;
+    /**
+     * Loads an existing Chatroom from the local DB and refresh it,
+     *
+     * @param name - The unique identifier for the chatroom
+     * @param opts - Options for loading the chatroom
+     * @param opts.reload - Whether to reload the chatroom from the local DB
+     */
+    static load(name: string, opts?: {
+        reload?: boolean;
+    }): Promise<Chatroom>;
+    static delete(names: string[]): Promise<void>;
+    /**
+     * Reload the Chatroom from the local Database
+     */
+    reload(): Promise<void>;
+    /**
+     * Perform a hard refresh of the Chatroom from the Server
+     */
+    refresh(): Promise<void>;
+    fetch(): Promise<void>;
+    getChats(): Promise<ProfileChatList>;
+    deleteChats(ids: string[]): Promise<void>;
+    /**
+     * List all locally stored chatrooms
+     */
+    static localList(): Promise<Set<{
+        name: string;
+    }>>;
+    static list(filter?: string): Promise<DBChatroom[]>;
+    static sync(): Promise<ProfileChatroomList>;
+}

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

@@ -0,0 +1,94 @@
+import type { Remote } from 'comlink';
+import type Atlas from '../workers/atlas.ts';
+import type { Feature, Subscription } from '../types.ts';
+import type { BBox as GeoJSONBBox, Feature as GeoJSONFeature, Geometry as GeoJSONGeometry } from 'geojson';
+export interface Origin {
+    mode: OriginMode;
+    mode_id?: string;
+}
+export declare enum OriginMode {
+    CONNECTION = "Connection",
+    MISSION = "Mission"
+}
+export declare const RENDERED_PROPERTIES: string[];
+export default class COT {
+    id: string;
+    instance: string;
+    _path: string;
+    _properties: Feature["properties"];
+    _geometry: Feature["geometry"];
+    _remote: BroadcastChannel | null;
+    _atlas: Atlas | Remote<Atlas>;
+    _username?: string;
+    origin: Origin;
+    static load(atlas: Atlas, feat: Feature, origin?: Origin, opts?: {
+        skipSave?: boolean;
+        remote?: boolean;
+    }): Promise<COT>;
+    constructor(atlas: Atlas | Remote<Atlas>, feat: Feature, origin?: Origin, opts?: {
+        skipSave?: boolean;
+        remote?: boolean;
+    });
+    /**
+     * Begin listening for remote updates
+     * This is a seperate function due to the issues outlined in: https://stackoverflow.com/q/70184129
+     */
+    reactivity(): void;
+    set path(path: string);
+    get path(): string;
+    set properties(properties: Feature["properties"]);
+    get properties(): Feature["properties"];
+    set geometry(geometry: Feature["geometry"]);
+    get geometry(): Feature["geometry"];
+    /**
+     * Update the COT and return a boolean as to whether the COT needs to be re-rendered
+     */
+    update(update: {
+        path?: string;
+        properties?: Feature["properties"];
+        geometry?: Feature["geometry"];
+    }, opts?: {
+        skipSave?: boolean;
+    }): Promise<boolean>;
+    /**
+     * Attempt to save the CoT to the database if necessary
+     */
+    save(): Promise<void>;
+    get is_skittle(): boolean;
+    get is_self(): boolean;
+    get is_archivable(): boolean;
+    /**
+     * Determines if the COT type allows editing
+     * But does not determine if a COT is part of a Misison Sync, if the mission allows editing
+     */
+    get is_editable(): boolean;
+    subscription(): Promise<Subscription>;
+    username(): Promise<string>;
+    /**
+     * Returns a proxy that will correctly call the internal update function if changes are made
+     * Warning: Cannot be used with Vue3's reactivity system
+     */
+    as_proxy(): COT;
+    as_feature(opts?: {
+        clone?: boolean;
+    }): Feature;
+    as_rendered(): GeoJSONFeature<GeoJSONGeometry, Record<string, unknown>>;
+    /**
+     * The slimmer we can get the Features, the better
+     * This returns the minium feature we need to actually style the COT in the vector tiles
+     */
+    static as_rendered(input: Feature): GeoJSONFeature<GeoJSONGeometry, Record<string, unknown>>;
+    vectorId(): number;
+    /**
+     * string hash function to convert the COT ID into a number for use as a vector tile feature ID
+     */
+    static vectorId(id: string): number;
+    length(): number;
+    bounds(): GeoJSONBBox;
+    flyTo(): Promise<void>;
+    static style(feat: Feature): Promise<Feature>;
+    /**
+     * Consistent feature manipulation between add & update
+     */
+    static styleProperties(type: string, properties: Feature["properties"]): Promise<Feature["properties"]>;
+}

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

@@ -0,0 +1,115 @@
+import Dexie, { type EntityTable } from 'dexie';
+import type { Feature, Mission, MissionRole } from '../types.ts';
+export interface DBIcon {
+    name: string;
+}
+export interface DBFeature {
+    id: string;
+    path: string;
+    properties: Feature["properties"];
+    geometry: Feature["geometry"];
+}
+export interface DBChatroom {
+    id: string;
+    name: string;
+    created: string;
+    updated: string;
+    last_read: string | null;
+}
+export interface DBChatroomChat {
+    id: string;
+    chatroom: string;
+    sender: string;
+    sender_uid: string;
+    message: string;
+    created: string;
+}
+export interface DBIconset {
+    uid: string;
+    created: string;
+    updated: string;
+    version: number;
+    name: string;
+    username: string | null;
+    default_group: string | null;
+    default_friendly: string | null;
+    default_hostile: string | null;
+    default_neutral: string | null;
+    default_unknown: string | null;
+    skip_resize: boolean;
+}
+export interface DBFilter {
+    id: string;
+    external: string;
+    name: string;
+    source: string;
+    internal: boolean;
+    query: string;
+}
+export declare enum NotificationType {
+    Contact = "Contact",
+    Import = "Import",
+    Alert = "Alert",
+    Medical = "Medical",
+    Mission = "Mission",
+    Chat = "Chat"
+}
+export interface DBNotification {
+    id: string;
+    type: NotificationType;
+    name: string;
+    body: string;
+    url: string;
+    toast: boolean;
+    read: boolean;
+    created: string;
+}
+export interface DBVideo {
+    id: string;
+    created: string;
+    updated: string;
+    lease: number;
+    username: string;
+}
+export interface DBSubscriptionFeature {
+    id: string;
+    path: string;
+    mission: string;
+    properties: Feature["properties"];
+    geometry: Feature["geometry"];
+}
+export interface DBSubscription {
+    guid: string;
+    name: string;
+    meta: Mission;
+    role: MissionRole;
+    token?: string;
+    dirty: boolean;
+    subscribed: boolean;
+}
+export interface DBSubscriptionLog {
+    id: string;
+    dtg?: string;
+    missionNames: string[];
+    created: string;
+    servertime: string;
+    mission: string;
+    content: string;
+    creatorUid: string;
+    contentHashes: unknown[];
+    keywords: string[];
+}
+export type DatabaseType = Dexie & {
+    icon: EntityTable<DBIcon, 'name'>;
+    iconset: EntityTable<DBIconset, 'uid'>;
+    video: EntityTable<DBVideo, 'id'>;
+    filter: EntityTable<DBFilter, 'id'>;
+    feature: EntityTable<DBFeature, 'id'>;
+    chatroom: EntityTable<DBChatroom, 'id'>;
+    chatroom_chats: EntityTable<DBChatroomChat, 'id'>;
+    notification: EntityTable<DBNotification, 'id'>;
+    subscription: EntityTable<DBSubscription, 'guid'>;
+    subscription_log: EntityTable<DBSubscriptionLog, 'id'>;
+    subscription_feature: EntityTable<DBSubscriptionFeature, 'id'>;
+};
+export declare const db: DatabaseType;

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

@@ -0,0 +1,30 @@
+export declare enum WorkerMessageType {
+    Map_FlyTo = "cloudtak:map:flyto",
+    Map_FitBounds = "cloudtak:map:fitbounds",
+    Map_Projection = "cloudtak:map:projection",
+    Profile_Callsign = "cloudtak:profile:callsign",
+    Profile_Display_Zoom = "cloudtak:profile:display:zoom",
+    Profile_Icon_Rotation = "cloudtak:profile:icon:rotation",
+    Profile_Distance_Unit = "cloudtak:profile:distance:unit",
+    Profile_Location_Coordinates = "cloudtak:profile:location:coordinates",
+    Profile_Location_Source = "cloudtak:profile:location:source",
+    Feature_Archived_Added = "cloudtak:feature:archived:added",
+    Feature_Archived_Removed = "cloudtak:feature:archived:removed",
+    Channels_None = "channels:none",
+    Channels_List = "channels:list",
+    Contact_Change = "contact:change",
+    Connection_Open = "connection:open",
+    Connection_Close = "connection:close",
+    Mission_Change_Feature = "mission:change:feature",
+    Mission_Invite = "mission:invite"
+}
+export type WorkerMessage = {
+    type: WorkerMessageType;
+    body?: any;
+};
+export declare enum LocationState {
+    Loading = 0,
+    Disabled = 1,
+    Preset = 2,
+    Live = 3
+}

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

@@ -0,0 +1,41 @@
+import type { Feature } from '../types.ts';
+import jsonata from 'jsonata';
+/**
+ * High Level Wrapper around the Data Filters
+ *
+ * TODO: Once all COTs are in IndexDB, apply the filter on to a new field in the COT
+ * called "filtered": [ <filterid>, ... ] so we don't have to re-evaluate the filter each time
+ *
+ * @property {string} id - The unique identifier for the filter
+ * @property {string} external - The external ID of the filter
+ * @property {string} name - The name of the filter
+ * @property {string} source - The source of the filter
+ * @property {boolean} internal - Whether the filter is internal
+ * @property {string} query - The JSONata query string for the filter
+ */
+export default class Filter {
+    id: string;
+    external: string;
+    name: string;
+    source: string;
+    internal: boolean;
+    query: string;
+    expression: jsonata.Expression;
+    constructor(name: string, external: string, source: string, internal: boolean, query: string);
+    test(feature: Feature): Promise<boolean>;
+    static list(): Promise<Filter[]>;
+    static from(id: string): Promise<Filter | null>;
+    update(body: {
+        name?: string;
+        external?: string;
+        source?: string;
+        internal?: boolean;
+        query?: string;
+    }): Promise<void>;
+    static create(name: string, external: string, source: string, internal: boolean, query: string): Promise<Filter>;
+    delete(): Promise<void>;
+    static delete(id: {
+        id?: string;
+        external?: string;
+    }): Promise<void>;
+}

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

@@ -0,0 +1,11 @@
+import COT from '../base/cot.ts';
+import type Atlas from '../workers/atlas.ts';
+import type { Remote, TransferHandler } from 'comlink';
+import type { Feature } from '../types.ts';
+export declare class CloudTAKTransferHandler {
+    atlas: Atlas | Remote<Atlas>;
+    remote: boolean;
+    constructor(atlas: Atlas | Remote<Atlas>, transferHandlers: Map<string, TransferHandler<unknown, unknown>>, remote: boolean);
+    cots: TransferHandler<Set<COT>, Array<Feature>>;
+    cot: TransferHandler<COT, Feature>;
+}

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

@@ -0,0 +1,4 @@
+export default class Icon {
+    static has(icon: string): Promise<boolean>;
+    static populate(icons: string[]): Promise<void>;
+}

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

@@ -0,0 +1,37 @@
+import { NotificationType } from './database.ts';
+import type { DBNotification } from './database.ts';
+export { NotificationType };
+export default class TAKNotification {
+    id: string;
+    type: NotificationType;
+    name: string;
+    body: string;
+    url: string;
+    created: string;
+    toast: boolean;
+    read: boolean;
+    constructor(id: string, type: NotificationType, name: string, body: string, url: string, opts?: {
+        read?: boolean;
+        toast?: boolean;
+        created?: string;
+    });
+    /**
+     * Return a Notification instance if one already exists in the local DB,
+     */
+    static from(id: string): Promise<TAKNotification | null>;
+    static create(type: NotificationType, name: string, body: string, url: string, toast?: boolean): Promise<TAKNotification>;
+    static update(id: string, opts: {
+        read?: boolean;
+        toast?: boolean;
+    }): Promise<void>;
+    update(opts: {
+        read?: boolean;
+        toast?: boolean;
+    }): Promise<void>;
+    popup(): Promise<void>;
+    static clear(): Promise<void>;
+    static delete(id: string): Promise<void>;
+    delete(): Promise<void>;
+    static count(): Promise<number>;
+    static list(): Promise<DBNotification[]>;
+}

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

@@ -0,0 +1,94 @@
+import type { ProfileOverlay, ProfileOverlay_Create } from '../types.ts';
+import type { LayerSpecification } from 'maplibre-gl';
+/**
+ * @class
+ */
+export default class Overlay {
+    _destroyed: boolean;
+    _internal: boolean;
+    _timer: ReturnType<typeof setInterval> | null;
+    _clickable: Array<{
+        id: string;
+        type: string;
+    }>;
+    _error?: Error;
+    _loaded: boolean;
+    id: number;
+    name: string;
+    active: boolean;
+    username?: string;
+    frequency: number | null;
+    iconset: string | null;
+    created: string;
+    updated: string;
+    pos: number;
+    type: string;
+    opacity: number;
+    visible: boolean;
+    mode: string;
+    mode_id: string | null;
+    actions: ProfileOverlay["actions"];
+    url?: string;
+    styles: Array<LayerSpecification>;
+    token: string | null;
+    static create(body: ProfileOverlay | ProfileOverlay_Create, opts?: {
+        internal?: boolean;
+        skipSave?: boolean;
+        clickable?: Array<{
+            id: string;
+            type: string;
+        }>;
+        before?: string;
+        skipLayers?: boolean;
+    }): Promise<Overlay>;
+    static internal(body: {
+        id: number;
+        type: string;
+        name: string;
+        styles?: Array<LayerSpecification>;
+        clickable?: Array<{
+            id: string;
+            type: string;
+        }>;
+    }): Promise<Overlay>;
+    static load(id: number): Promise<Overlay>;
+    constructor(overlay: ProfileOverlay, opts?: {
+        internal?: boolean;
+    });
+    healthy(): boolean;
+    hasBounds(): boolean;
+    zoomTo(): Promise<void>;
+    addLayers(before?: string): Promise<void>;
+    init(opts?: {
+        clickable?: Array<{
+            id: string;
+            type: string;
+        }>;
+        before?: string;
+        skipLayers?: boolean;
+    }): Promise<void>;
+    remove(): void;
+    replace(overlay: {
+        name?: string;
+        active?: boolean;
+        username?: string;
+        actions?: ProfileOverlay["actions"];
+        type?: string;
+        opacity?: number;
+        visible?: boolean;
+        mode?: string;
+        mode_id?: string;
+        url?: string;
+        token?: string;
+        styles?: Array<LayerSpecification>;
+    }, opts?: {
+        before?: string;
+    }): Promise<void>;
+    delete(): Promise<void>;
+    update(body: {
+        pos?: number;
+        visible?: boolean;
+        opacity?: number;
+    }): Promise<void>;
+    save(): Promise<void>;
+}

package/dist/types/src/base/subscription-feature.d.ts

@@ -0,0 +1,49 @@
+import COT from './cot.ts';
+import Subscription from './subscription.ts';
+import type Atlas from '../workers/atlas.ts';
+import type { BBox } from 'geojson';
+import type { Feature, FeatureCollection } from '../types.ts';
+/**
+ * High Level Wrapper around the Data/Mission Sync API
+ */
+export default class SubscriptionFeature {
+    parent: Subscription;
+    token: string;
+    missiontoken?: string;
+    constructor(parent: Subscription, opts: {
+        token: string;
+        missiontoken?: string;
+    });
+    headers(): Record<string, string>;
+    refresh(): Promise<void>;
+    list(opts?: {
+        refresh: false;
+    }): Promise<Array<Feature>>;
+    collection(raw?: boolean): Promise<FeatureCollection>;
+    bounds(): Promise<BBox>;
+    from(uid: string): Promise<Feature | undefined>;
+    /**
+     * Upsert a feature into the mission.
+     * This will udpate the feature in the local DB, submit it to the TAK Server and
+     * mark the subscription as dirty for a re-render
+     *
+     * @param atlas - The Atlas instance
+     * @param cot - The COT object to upsert
+     * @param opts - Options for updating the feature
+     * @param opts.skipNetwork - If true, the feature will not be updated on the server - IE in response to a Mission Change event
+     */
+    update(atlas: Atlas, cot: COT, opts?: {
+        skipNetwork?: boolean;
+    }): Promise<void>;
+    /**
+     * Delete a feature from the mission.
+     *
+     * @param atlas - The Atlas instance
+     * @param uid - The unique ID of the feature to delete
+     * @param opts - Options for deleting the feature
+     * @param opts.skipNetwork - If true, the feature will not be deleted from the server - IE in response to a Mission Change event
+     */
+    delete(atlas: Atlas, uid: string, opts?: {
+        skipNetwork?: boolean;
+    }): Promise<void>;
+}