@tak-ps/cloudtak 12.94.0 → 12.102.0

package/dist/types/plugin.d.ts

@@ -0,0 +1,156 @@
+import type { App } from 'vue';
+import type { Component } from 'vue';
+import type { Router, RouteRecordRaw } from 'vue-router';
+import type { Pinia } from 'pinia';
+import { type PaneConfig } from './src/stores/float.ts';
+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 type { DBFeature };
+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[]>;
+    };
+    /**
+     * Manage Breadcrumb Trails
+     */
+    get breadcrumb(): {
+        /**
+         * Manage live breadcrumb trail recording
+         */
+        live: {
+            /**
+             * Enable live breadcrumb trail recording for a given CoT UID
+             * @param uid The CoT UID to start recording
+             */
+            add: (uid: string) => Promise<void>;
+            /**
+             * Disable live breadcrumb trail recording for a given CoT UID
+             * @param uid The CoT UID to stop recording
+             */
+            remove: (uid: string) => Promise<void>;
+            /**
+             * Returns all CoT UIDs that currently have live breadcrumb recording enabled
+             */
+            list: () => Promise<string[]>;
+        };
+    };
+    /**
+     * Manage Floating Panes on top of the Map View
+     */
+    get float(): {
+        /**
+         * Add a new floating pane
+         * @param opts Floating pane configuration
+         */
+        add: (opts: {
+            uid: string;
+            name?: string;
+            component: Component;
+            actions?: Component;
+            props?: Record<string, unknown>;
+            height?: number;
+            width?: number;
+            x?: number;
+            y?: number;
+        }) => import("./src/stores/float.ts").Pane<PaneConfig>;
+        /**
+         * Remove a floating pane
+         * @param uid The unique identifier of the pane to remove
+         */
+        remove: (uid: string) => void;
+        /**
+         * Check if a floating pane exists
+         * @param uid The unique identifier to check
+         */
+        has: (uid: string) => boolean;
+    };
+}

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

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

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

@@ -0,0 +1,49 @@
+import type { DBChatroom } from './database.ts';
+import ChatroomChats from './chatroom-chats.ts';
+import { type Observable } from 'dexie';
+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);
+    static liveUnreadCount(): Observable<number>;
+    /**
+     * 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/config.d.ts

@@ -0,0 +1,17 @@
+import { type Subscription } from 'dexie';
+import type { paths } from '../derived-types.js';
+export type FullConfig = paths['/api/config']['get']['responses']['200']['content']['application/json'];
+export default class Config<K extends keyof FullConfig = keyof FullConfig> {
+    key: K;
+    value: FullConfig[K];
+    _sub?: Subscription;
+    constructor(key: K, value: FullConfig[K]);
+    subscribe(): void;
+    subscribed(): boolean;
+    destroy(): void;
+    static get<K extends keyof FullConfig>(key: K): Promise<Config<K> | undefined>;
+    static list(keys: (keyof FullConfig)[], opts?: {
+        defaults?: Partial<FullConfig>;
+    }): Promise<Partial<FullConfig>>;
+    static refresh(keys: (keyof FullConfig)[]): Promise<Partial<FullConfig>>;
+}

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

@@ -0,0 +1,14 @@
+import { type Observable } from 'dexie';
+import type { Contact } from '../types.ts';
+export default class ContactManager {
+    static liveCount(): Observable<number>;
+    static liveList(filter?: string): Observable<Contact[]>;
+    static list(opts?: {
+        token?: string;
+        filter?: string;
+    }): Promise<Contact[]>;
+    static get(uid: string): Promise<Contact | undefined>;
+    static getByCallsign(callsign: string): Promise<Contact | undefined>;
+    static put(contact: Contact): Promise<void>;
+    static sync(token?: string): Promise<Contact[]>;
+}

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

@@ -0,0 +1,95 @@
+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: boolean;
+    _liveQuerySubscription: {
+        unsubscribe: () => void;
+    } | null;
+    static selfUid: string | null;
+    _username?: string;
+    origin: Origin;
+    static load(feat: Feature, origin?: Origin, opts?: {
+        skipSave?: boolean;
+        remote?: boolean;
+    }): Promise<COT>;
+    constructor(feat: Feature, origin?: Origin, opts?: {
+        skipSave?: boolean;
+        remote?: boolean;
+    });
+    /**
+     * Begin listening for remote updates via a DexieDB live query
+     * 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,192 @@
+import Dexie, { type EntityTable } from 'dexie';
+import type { Feature, GroupChannel, Mission, MissionRole, MissionChange, MissionLog, Contact, Server } from '../types.ts';
+export interface DBIcon {
+    name: string;
+}
+export interface DBFeature {
+    id: string;
+    path: string;
+    properties: Feature["properties"];
+    geometry: Feature["geometry"];
+}
+export interface DBBreadcrumb {
+    id: string;
+    uid: string;
+    path: string;
+    callsign: string;
+    color?: string;
+    coordinates: number[][];
+    live: boolean;
+}
+export interface DBChatroom {
+    id: string;
+    name: string;
+    created: string;
+    updated: string;
+    unread?: number;
+    last_read: string | null;
+}
+export interface DBChatroomChat {
+    id: string;
+    chatroom: string;
+    sender: string;
+    sender_uid: string;
+    message: string;
+    created: string;
+    unread?: boolean;
+}
+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 DBSubscriptionContent {
+    uid: string;
+    mission: string;
+    timestamp: string;
+    creatorUid?: string;
+    keywords: string[];
+    name: string;
+    hash: string;
+    submissionTime: string;
+    size: number;
+    mimeType?: string;
+    submitter?: string;
+    expiration: number;
+}
+export interface DBSubscriptionChanges extends MissionChange {
+    id?: number;
+    mission: string;
+}
+export interface DBSubscriptionChat {
+    id: string;
+    mission: string;
+    chatroom: string;
+    sender: string;
+    sender_uid: string;
+    message: string;
+    created: string;
+    unread: boolean;
+}
+export interface DBSubscription {
+    guid: string;
+    name: string;
+    meta: Mission;
+    role: MissionRole;
+    token?: string;
+    dirty: boolean;
+    subscribed: boolean;
+}
+export interface DBSubscriptionLog extends MissionLog {
+    mission: string;
+    read: boolean;
+}
+export interface DBMissionTemplate {
+    id: string;
+    name: string;
+    icon: string;
+    description: string;
+    created: string;
+    updated: string;
+}
+export interface DBMissionTemplateLog {
+    id: string;
+    template: string;
+    name: string;
+    icon?: string | null;
+    description: string;
+    created: string;
+    updated: string;
+    schema: unknown;
+    keywords: string[];
+}
+export interface DBProfileConfig {
+    key: string;
+    value: unknown;
+}
+export interface DBConfig {
+    key: string;
+    value: unknown;
+}
+export interface DBServer extends Server {
+    _id: string;
+}
+export interface DBCache {
+    key: string;
+    updated: number;
+}
+export type DatabaseType = Dexie & {
+    icon: EntityTable<DBIcon, 'name'>;
+    iconset: EntityTable<DBIconset, 'uid'>;
+    group: EntityTable<GroupChannel, 'name'>;
+    video: EntityTable<DBVideo, 'id'>;
+    filter: EntityTable<DBFilter, 'id'>;
+    feature: EntityTable<DBFeature, 'id'>;
+    breadcrumb: EntityTable<DBBreadcrumb, 'id'>;
+    chatroom: EntityTable<DBChatroom, 'id'>;
+    chatroom_chats: EntityTable<DBChatroomChat, 'id'>;
+    notification: EntityTable<DBNotification, 'id'>;
+    subscription: EntityTable<DBSubscription, 'guid'>;
+    subscription_contents: EntityTable<DBSubscriptionContent, 'uid'>;
+    subscription_changes: EntityTable<DBSubscriptionChanges, 'id'>;
+    server: EntityTable<DBServer, '_id'>;
+    subscription_log: EntityTable<DBSubscriptionLog, 'id'>;
+    subscription_feature: EntityTable<DBSubscriptionFeature, 'id'>;
+    subscription_chat: EntityTable<DBSubscriptionChat, 'id'>;
+    mission_template: EntityTable<DBMissionTemplate, 'id'>;
+    mission_template_log: EntityTable<DBMissionTemplateLog, 'id'>;
+    profile: EntityTable<DBProfileConfig, 'key'>;
+    config: EntityTable<DBConfig, 'key'>;
+    cache: EntityTable<DBCache, 'key'>;
+    contact: EntityTable<Contact, 'uid'>;
+};
+export declare const db: DatabaseType;

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

@@ -0,0 +1,32 @@
+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",
+    Connection_Open = "connection:open",
+    Connection_Close = "connection:close",
+    Mission_Change_Feature = "mission:change:feature",
+    Mission_Invite = "mission:invite",
+    Channel_Change = "channel:change",
+    Feature_Update = "cloudtak:feature:update",
+    Profile_Update = "cloudtak:profile:update"
+}
+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/group.d.ts

@@ -0,0 +1,27 @@
+import { type Observable } from 'dexie';
+import type { Group, GroupChannel } from '../types.ts';
+export default class GroupManager {
+    /**
+     * Merge an array of API Group entries (each with a single direction string)
+     * into GroupChannel entries keyed by name with direction as a string array
+     */
+    static merge(groups: Group[]): GroupChannel[];
+    /**
+     * Explode a GroupChannel (with direction array) back into individual
+     * API Group entries (each with a single direction string)
+     */
+    static explode(channels: GroupChannel[]): Group[];
+    static live(opts?: {
+        active?: boolean;
+        direction?: string;
+    }): Observable<GroupChannel[]>;
+    static list(opts?: {
+        token?: string;
+        active?: boolean;
+        direction?: string;
+    }): Promise<GroupChannel[]>;
+    static get(name: string): Promise<GroupChannel | undefined>;
+    static put(channels: GroupChannel[] | GroupChannel): Promise<void>;
+    static sync(token?: string): Promise<GroupChannel[]>;
+    static update(channels: GroupChannel[], token?: string): Promise<GroupChannel[]>;
+}

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

@@ -0,0 +1,9 @@
+import COT from '../base/cot.ts';
+import type { TransferHandler } from 'comlink';
+import type { Feature } from '../types.ts';
+export declare class CloudTAKTransferHandler {
+    remote: boolean;
+    constructor(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/mission-template-logs.d.ts

@@ -0,0 +1,9 @@
+import type { DBMissionTemplateLog } from './database.ts';
+export default class MissionTemplateLogs {
+    template: string;
+    constructor(template: string);
+    refresh(): Promise<void>;
+    list(opts?: {
+        refresh?: boolean;
+    }): Promise<Array<DBMissionTemplateLog>>;
+}