@tak-ps/cloudtak 12.54.0

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

@@ -0,0 +1,134 @@
+import type Atlas from './atlas.ts';
+import COT from '../base/cot.ts';
+import type { GeoJSONSourceDiff } from 'maplibre-gl';
+import type { Polygon } from 'geojson';
+import type { InputFeature, Feature } from '../types.ts';
+type NestedArray = {
+    path: string;
+    count: number;
+    paths: Array<NestedArray>;
+};
+export default class AtlasDatabase {
+    atlas: Atlas;
+    cots: Map<string, COT>;
+    mission?: string;
+    pendingCreate: Map<string, COT>;
+    pendingUpdate: Map<string, COT>;
+    pendingHidden: Set<string>;
+    pendingUnhide: Set<string>;
+    pendingDelete: Set<string>;
+    subscriptionPending: Map<string, string>;
+    constructor(atlas: Atlas);
+    makeActiveMission(guid?: string): Promise<void>;
+    /**
+     * Only Called by non-Mission CoTs, caller is responsible for creating Filters
+     */
+    hide(id: string): Promise<void>;
+    /**
+     * Only Called by non-Mission CoTs, caller is responsible for removing Filters
+     */
+    unhide(id: string): Promise<void>;
+    init(): Promise<void>;
+    /**
+     * Return a Set of coordinates within the given Map bounds
+     * so that vertex snapping can take place when editing
+     */
+    snapping(bboxarr: [number, number][]): Promise<Set<[number, number]>>;
+    /**
+     * Generate a GeoJSONDiff on existing COT Features
+     */
+    diff(): Promise<GeoJSONSourceDiff>;
+    /**
+     * Iterate over all CoTs and delete toTs that match the filter pattern
+     * @param filter - JSONata filter expression to match CoTs against
+     */
+    filterRemove(filter: string, opts?: {
+        mission?: boolean;
+        skipNetwork?: boolean;
+    }): Promise<void>;
+    /**
+     * Iterate over cot messages and return list of CoTs that match filter pattern
+     */
+    filter(filter: string, opts?: {
+        limit?: number;
+        mission?: boolean;
+    }): Promise<Set<COT>>;
+    filterDelete(filter: string, opts?: {
+        mission?: boolean;
+    }): Promise<void>;
+    paths(store?: Map<string, COT>): Promise<Array<NestedArray>>;
+    /**
+     * Return CoTs touching a given polygon
+     *
+     * @param poly - GeoJSON Polygon to test CoTs against
+     */
+    touching(poly: Polygon): Promise<Set<COT>>;
+    /**
+     * Load Archived CoTs
+     */
+    loadArchive(): Promise<void>;
+    /**
+     * Remove a given CoT from the store
+     *
+     * @param id - UID of the CoT to remove
+     * @param opts - Options
+     * @param opts.mission      - If true, search Mission Stores for the CoT
+     * @param opts.skipNetwork  - If an archived CoT, don't delete from the server
+     */
+    remove(id: string, opts?: {
+        mission?: boolean;
+        skipNetwork?: boolean;
+    }): Promise<void>;
+    /**
+     * Empty the store
+     *
+     * @param opts - Options
+     * @param opts.ignoreArchived   - Don't delete archived features
+     * @param opts.skipNetwork      - Don't delete archived features from the server
+     */
+    clear(opts?: {
+        ignoreArchived: boolean;
+        skipNetwork: boolean;
+    }): Promise<void>;
+    /**
+     * Called everytime a Mission Task message is received
+     *
+     * @param task - GeoJSON Feature representing the Mission Task
+     */
+    subChange(task: Feature): Promise<void>;
+    /**
+     * Add or Update a CoT GeoJSON to the store and modify props to meet MapLibre style requirements
+     *
+     * @param feat - GeoJSON Feature to create/update in Store
+     *
+     * @param opts - Optional Options
+     * @param opts.skipSave - Don't save the COT to the Profile Feature Database
+     * @param opts.skipBroadcast - Don't broadcast the COT on the internal message bus to the UI
+     * @param opts.authored - If the COT is authored, append creator information if the CoT is new & potentially add it to a mission
+     */
+    add(feature: InputFeature, opts?: {
+        skipSave?: boolean;
+        skipBroadcast?: boolean;
+        authored?: boolean;
+    }): Promise<COT>;
+    /**
+     * Return a CoT by ID if it exists
+     *
+     * @param id - ID of the CoT to return
+     * @param opts - Options
+     * @param opts.mission - If true, search Mission Stores for the CoT
+     */
+    get(id: string, opts?: {
+        mission?: boolean;
+    }): Promise<COT | undefined>;
+    /**
+     * Returns if the CoT is present in the store given the ID
+     */
+    has(id: string): boolean;
+    groups(store?: Map<string, COT>): Array<string>;
+    pathFeatures(path?: string, store?: Map<string, COT>): Set<COT>;
+    markers(store?: Map<string, COT>): Array<string>;
+    markerFeatures(marker: string, store?: Map<string, COT>): Set<COT>;
+    contacts(group?: string, store?: Map<string, COT>): Set<COT>;
+}
+export {};

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

@@ -0,0 +1,39 @@
+import type Atlas from './atlas.ts';
+import { LocationState } from '../base/events.ts';
+import type { Group, Server, Profile, Profile_Update, FeaturePropertyCreator } from '../types.ts';
+export type ProfileLocation = {
+    source: LocationState;
+    accuracy: number | undefined;
+    altitude: number | null | undefined;
+    coordinates: number[];
+};
+export default class AtlasProfile {
+    atlas: Atlas;
+    timerSelf: ReturnType<typeof setInterval> | undefined;
+    location: ProfileLocation;
+    channels: Array<Group>;
+    profile: Profile | null;
+    server: Server | null;
+    constructor(atlas: Atlas);
+    init(): Promise<string>;
+    username(): Promise<string>;
+    creator(): Promise<FeaturePropertyCreator>;
+    callsign(): Promise<string>;
+    isSystemAdmin(): Promise<boolean>;
+    isAgencyAdmin(): Promise<boolean>;
+    hasNoConfiguration(): boolean;
+    hasNoChannels(): boolean;
+    destroy(): void;
+    setupTimer(): void;
+    loadServer(): Promise<Server>;
+    load(): Promise<Profile>;
+    updateLocation(): void;
+    setChannel(name: string, active: boolean): Promise<Array<Group>>;
+    setAllChannels(active: boolean): Promise<Array<Group>>;
+    updateChannels(channels: Array<Group>): Promise<Array<Group>>;
+    postChannelStatus(): void;
+    loadChannels(): Promise<Array<Group>>;
+    update(body: Profile_Update): Promise<void>;
+    uid(): string;
+    CoT(coords?: number[], accuracy?: number, altitude?: number | null): Promise<void>;
+}

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

@@ -0,0 +1,13 @@
+import type Atlas from './atlas.ts';
+import type COT from '../base/cot.ts';
+import type { Contact } from '../types.ts';
+export default class AtlasTeam {
+    atlas: Atlas;
+    contacts: Map<string, Contact>;
+    constructor(atlas: Atlas);
+    init(): Promise<void>;
+    set(cot: COT): Promise<Contact>;
+    get(uid: string): Promise<Contact | undefined>;
+    getByCallsign(callsign: string): Promise<Contact | undefined>;
+    load(): Promise<Map<string, Contact>>;
+}

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

@@ -0,0 +1,19 @@
+import type { WorkerMessage } from '../base/events.ts';
+import * as Comlink from 'comlink';
+import AtlasProfile from './atlas-profile.ts';
+import AtlasTeam from './atlas-team.ts';
+import AtlasDatabase from './atlas-database.ts';
+import AtlasConnection from './atlas-connection.ts';
+export default class Atlas {
+    channel: BroadcastChannel;
+    sync: BroadcastChannel;
+    token: string;
+    db: AtlasDatabase & Comlink.ProxyMarked;
+    team: AtlasTeam & Comlink.ProxyMarked;
+    conn: AtlasConnection & Comlink.ProxyMarked;
+    profile: AtlasProfile & Comlink.ProxyMarked;
+    constructor();
+    postMessage(msg: WorkerMessage): Promise<void>;
+    init(authToken: string): Promise<void>;
+    destroy(): void;
+}

package/package.json

@@ -0,0 +1,97 @@
+{
+    "name": "@tak-ps/cloudtak",
+    "type": "module",
+    "version": "12.54.0",
+    "types": "dist/types/plugin.d.ts",
+    "files": [
+        "dist/types",
+        "src"
+    ],
+    "engines": {
+        "node": ">= 24"
+    },
+    "scripts": {
+        "serve": "DEV=true vite serve --port 8080",
+        "typegen": "openapi-typescript http://localhost:5001/api/swagger --output src/derived-types.d.ts",
+        "check": "vue-tsc",
+        "build:types": "vue-tsc -p tsconfig.build.json",
+        "build": "vite build",
+        "lint": "eslint ./src/ ./public/ ./plugins/",
+        "test": "exit 0"
+    },
+    "dependencies": {
+        "@react-hookz/deep-equal": "^3.0.3",
+        "@tabler/core": "^1.4.0",
+        "@tabler/icons-vue": "^3.0.0",
+        "@tak-ps/node-cot": "^14.0.0",
+        "@tak-ps/vue-tabler": "^4.2.1",
+        "@turf/area": "^7.2.0",
+        "@turf/bbox": "^7.1.0",
+        "@turf/boolean-point-in-polygon": "^7.3.1",
+        "@turf/boolean-touches": "^7.1.0",
+        "@turf/boolean-within": "^7.1.0",
+        "@turf/destination": "^7.2.0",
+        "@turf/distance": "^7.2.0",
+        "@turf/ellipse": "^7.2.0",
+        "@turf/envelope": "^7.1.0",
+        "@turf/length": "^7.2.0",
+        "@turf/meta": "^7.2.0",
+        "@turf/point-on-feature": "^7.0.0",
+        "@vueuse/core": "^13.0.0",
+        "autosize": "^6.0.1",
+        "comlink": "^4.4.2",
+        "cronstrue": "^3.0.0",
+        "deep-equal": "^2.2.3",
+        "dexie": "^4.2.1",
+        "dropzone": "^6.0.0-beta.2",
+        "floating-vue": "^2.0.0-beta.17",
+        "geo-coordinates-parser": "^1.7.4",
+        "geomagnetism": "^0.2.0",
+        "hls.js": "^1.6.5",
+        "imask": "^6.0.0",
+        "jsonata": "^2.0.4",
+        "maplibre-gl": "^5.15.0",
+        "milsymbol": "^3.0.2",
+        "moment": "^2.29.3",
+        "openapi-fetch": "^0.15.0",
+        "p12-pem": "^1.0.5",
+        "phone": "^3.1.59",
+        "pinia": "^3.0.0",
+        "rxjs": "^7.8.2",
+        "sortablejs": "^1.15.2",
+        "swagger-ui-dist": "^5.30.2",
+        "terra-draw": "^1.22.0",
+        "terra-draw-maplibre-gl-adapter": "^1.1.1",
+        "uuid": "^13.0.0",
+        "vue": "^3.2.31",
+        "vue-component-type-helpers": "^3.0.7",
+        "vue-mention": "^2.0.0-alpha.3",
+        "vue-router": "^4.0.14"
+    },
+    "devDependencies": {
+        "@eslint/js": "^9.18.0",
+        "@testing-library/vue": "^8.1.0",
+        "@types/sortablejs": "^1.15.8",
+        "@types/swagger-ui": "^5.21.1",
+        "@vitejs/plugin-vue": "^6.0.0",
+        "@vitest/ui": "^4.0.0",
+        "@vue/test-utils": "^2.4.6",
+        "@vueuse/rxjs": "^14.1.0",
+        "babel-preset-vite": "^1.1.3",
+        "eslint": "^9.0.0",
+        "eslint-plugin-vue": "^10.0.0",
+        "happy-dom": "^20.0.0",
+        "jsdom": "^27.0.0",
+        "openapi-typescript": "^7.0.0",
+        "sass-embedded": "^1.86.0",
+        "typescript": "^5.7.0",
+        "typescript-eslint": "^8.20.0",
+        "vite": "^7.0.0",
+        "vitest": "^4.0.0",
+        "vue-tsc": "^3.0.0-alpha.10"
+    },
+    "browserslist": [
+        "> 1%",
+        "last 2 versions"
+    ]
+}

package/src/App.vue

@@ -0,0 +1,341 @@
+<template>
+    <div class='page h-100 cloudtak-gradient'>
+        <header
+            v-if='navShown'
+            class='navbar navbar-expand-md d-print-none'
+        >
+            <div class='container-xl'>
+                <div class='col-auto'>
+                    <img
+                        v-if='brandStore'
+                        alt='Agency Logo'
+                        :src='brandStore.login && brandStore.login.logo ? brandStore.login.logo : "/CloudTAKLogo.svg"'
+                        class='cursor-pointer'
+                        draggable='false'
+                        height='50'
+                        width='50'
+                        @click='external("/")'
+                    >
+                </div>
+                <div class='col mx-2'>
+                    <div
+                        class='page-pretitle'
+                        v-text='brandStore.login && brandStore.login.name ? brandStore.login.name : ""'
+                    />
+                    <h2 class='page-title'>
+                        CloudTAK
+                    </h2>
+                </div>
+
+                <div
+                    v-if='user'
+                    class='ms-auto'
+                >
+                    <div class='btn-list'>
+                        <a
+                            class='btn btn-dark'
+                            target='_blank'
+                            rel='noreferrer'
+                            @click='external("/docs")'
+                        >
+                            <IconCode
+                                size='32'
+                                stroke='1'
+                            />Docs
+                        </a>
+                        <div class='dropdown'>
+                            <div
+                                id='userProfileButton'
+                                type='button'
+                                data-bs-toggle='dropdown'
+                                aria-expanded='false'
+                                class='btn btn-dark'
+                            >
+                                <IconUser
+                                    size='32'
+                                    stroke='1'
+                                />
+                            </div>
+                            <ul
+                                class='dropdown-menu'
+                                aria-labelledby='userProfileButton'
+                            >
+                                <div
+                                    class='d-flex dropdown-item cursor-pointer hover'
+                                    @click='external("/connection")'
+                                >
+                                    <IconNetwork
+                                        size='32'
+                                        stroke='1'
+                                    />
+                                    <span class='mx-2'>Connections</span>
+                                </div>
+                                <div
+                                    class='d-flex dropdown-item cursor-pointer hover'
+                                    @click='external("/admin")'
+                                >
+                                    <IconSettings
+                                        size='32'
+                                        stroke='1'
+                                    />
+                                    <span class='mx-2'>Server</span>
+                                    <span class='ms-auto badge border border-red bg-red text-white'>Admin</span>
+                                </div>
+                                <div
+                                    class='d-flex dropdown-item cursor-pointer hover'
+                                    @click='logout'
+                                >
+                                    <IconLogout
+                                        size='32'
+                                        stroke='1'
+                                    />
+                                    <span class='mx-2'>Logout</span>
+                                </div>
+                            </ul>
+                        </div>
+                        <div />
+                    </div>
+                </div>
+            </div>
+        </header>
+
+        <Loading
+            v-if='loading && !route.path.includes("configure") && !route.path.includes("login")'
+        />
+        <router-view
+            v-else
+            :user='user'
+            @err='error = $event'
+            @login='refreshLogin'
+        />
+        <TablerError
+            v-if='error'
+            :err='error'
+            @close='error = undefined'
+        />
+        <LoginModal
+            v-if='login'
+            @close='login = false'
+            @login='login= false'
+        />
+        <MissionInviteModal
+            v-if='inviteMission'
+            :mission='inviteMission'
+            @close='inviteMission = undefined'
+        />
+    </div>
+</template>
+
+<script setup lang='ts'>
+import { ref, computed, onErrorCaptured, onMounted } from 'vue'
+import { useRouter, useRoute } from 'vue-router';
+import type { Login, Server } from './types.ts';
+import { useBrandStore } from './stores/brand.ts';
+import '@tabler/core/dist/js/tabler.min.js';
+import '@tabler/core/dist/css/tabler.min.css';
+import LoginModal from './components/util/LoginModal.vue'
+import {
+    IconCode,
+    IconLogout,
+    IconUser,
+    IconNetwork,
+    IconSettings,
+} from '@tabler/icons-vue';
+import Loading from './components/Loading.vue';
+import {
+    TablerError
+} from '@tak-ps/vue-tabler';
+import { std } from './std.ts';
+import MissionInviteModal from './components/CloudTAK/Menu/Mission/MissionInviteModal.vue';
+import { WorkerMessageType } from './base/events.ts';
+import type { WorkerMessage } from './base/events.ts';
+
+const router = useRouter();
+const route = useRoute();
+const brandStore = useBrandStore();
+
+const loading = ref(true);
+const login = ref(false);
+const inviteMission = ref<{
+    name: string;
+    guid: string;
+    token: string;
+    authorUid: string;
+    tool: string;
+    type: string;
+} | undefined>();
+const mounted = ref(false);
+const user = ref<Login | undefined>();
+const error = ref<Error | undefined>();
+
+const navShown = computed<boolean>(() => {
+    if (!route || !route.name) {
+        return false;
+    } else {
+        return (
+            !String(route.name).startsWith("home")
+            && !["login", "configure"].includes(String(route.name))
+        )
+    }
+});
+
+onErrorCaptured((err) => {
+    if (!(err instanceof Error)) {
+        error.value = new Error(String(err));
+    }
+
+    const e = err as Error;
+
+    if (e.message === '401') {
+        // Popup Modal if reauthenticating vs initial login
+
+        if (route.name !== 'login') {
+            login.value = true;
+        }
+    } else if (String(e) === 'Error: Authentication Required') {
+        routeLogin();
+    } else {
+        error.value = e;
+    }
+});
+
+onMounted(async () => {
+    let status;
+    try {
+        const server = await std('/api/server') as Server;
+        status = server.status;
+    } catch (err) {
+        console.warn('Server Error (Likely the server is in a configured state)', err);
+        status = 'configured';
+    }
+
+    await brandStore.init();
+
+    window.addEventListener('unhandledrejection', (e) => {
+        error.value = e.reason;
+    });
+
+    const channel = new BroadcastChannel('cloudtak');
+    channel.onmessage = (event: MessageEvent<WorkerMessage>) => {
+        const msg = event.data;
+        if (msg && msg.type === WorkerMessageType.Mission_Invite) {
+            inviteMission.value = msg.body;
+        }
+    };
+
+    if (status === 'unconfigured') {
+        delete localStorage.token;
+        router.push("/configure");
+    } else {
+        if (localStorage.token) {
+            await refreshLogin();
+        } else if (route.name !== 'login') {
+            routeLogin();
+        }
+    }
+
+    loading.value = false;
+    mounted.value = true;
+});
+
+function logout() {
+    user.value = undefined;
+    delete localStorage.token;
+
+    window.location.href = '/login';
+}
+
+function external(url: string) {
+    window.location.href = url;
+}
+
+function routeLogin() {
+    router.push(`/login?redirect=${encodeURIComponent(window.location.pathname)}`);
+}
+
+async function refreshLogin() {
+    loading.value = true;
+
+    await getLogin();
+
+    loading.value = false;
+}
+
+async function getLogin() {
+    try {
+        user.value = await std('/api/login') as Login;
+    } catch (err) {
+        console.error(err);
+        user.value = undefined;
+        delete localStorage.token;
+
+        if (route.name !== 'login') {
+            routeLogin();
+        }
+
+        return false;
+    }
+
+    return true;
+}
+</script>
+
+<style lang='scss'>
+$cloudtak-default: #182433;
+$cloudtak-child:  #192f45;
+$cloudtak-yellow: #FFB703;
+$cloudtak-orange: #FF9820;
+$cloudtak-navy: #023047;
+$cloudtak-blue: #07556D;
+
+.cloudtak-gradient {
+    background: radial-gradient(at left top, $cloudtak-blue, $cloudtak-navy);
+}
+
+.btn-primary {
+    background-color: $cloudtak-blue !important;
+}
+
+.bg-accent {
+    background-color: #283547 !important;
+}
+
+.bg-child {
+    background-color: $cloudtak-child !important;
+}
+
+html[data-bs-theme='dark'] .hover:hover {
+    background: #0f172a;
+}
+
+html[data-bs-theme='light'] .hover:hover {
+    background: #f5f5f5;
+}
+
+.hover-button-hidden {
+    visibility: hidden;
+}
+
+.hover-button:hover .hover-button-hidden {
+    visibility: visible;
+}
+
+.border-light {
+    border-radius: 6px;
+    background-color: rgba(0, 0, 0, 0.2);
+}
+
+.hover-button:hover {
+    border-radius: 6px;
+    background-color: rgba(0, 0, 0, 0.2);
+}
+
+.border-dark {
+    background: #0f172a;
+}
+.btn-check:checked + .btn:hover {
+    background-color: var(--tblr-primary) !important;
+    border-color: var(--tblr-primary) !important;
+    color: white !important;
+}
+</style>