@tak-ps/cloudtak 12.54.0 → 12.94.0

package/src/base/database.ts

@@ -1,150 +0,0 @@
-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 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 const db = new Dexie('CloudTAK') as DatabaseType;
-
-db.version(1).stores({
-    icon: 'name',
-    iconset: 'uid, name',
-    filter: 'id, external',
-    video: 'id, username',
-    feature: 'id, path',
-
-    chatroom: 'id',
-    chatroom_chats: 'id, chatroom',
-
-    notification: 'id, type, name, body, url, created, toast, read',
-    subscription: 'guid, name',
-    subscription_log: 'id, [mission+id]',
-    subscription_feature: 'id, mission, [mission+id]',
-});

package/src/base/events.ts

@@ -1,43 +0,0 @@
-export 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,
-    // TODO Strongly type this
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    body?: any
-}
-
-export enum LocationState {
-    Loading,
-    Disabled,
-    Preset,
-    Live
-}

package/src/base/filter.ts

@@ -1,163 +0,0 @@
-import { db } from './database.ts'
-import type { Feature } from '../types.ts';
-import jsonata from 'jsonata';
-import { v4 as randomUUID } from 'uuid';
-
-/**
- * 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
-    ) {
-        this.id = randomUUID();
-
-        this.name = name;
-        this.external = external;
-        this.source = source;
-        this.internal = internal;
-        this.query = query;
-
-        this.expression = jsonata(this.query);
-    }
-
-    async test(feature: Feature): Promise<boolean> {
-        return await this.expression.evaluate(feature);
-    }
-
-    static async list(): Promise<Filter[]> {
-        const filters = await db.filter.toArray();
-
-        return filters.map(f => {
-            const filter = new Filter(
-                f.name,
-                f.external,
-                f.source,
-                f.internal,
-                f.query
-            );
-
-            filter.id = f.id;
-
-            return filter;
-        });
-    }
-
-    static async from(
-        id: string
-    ): Promise<Filter | null> {
-        const exists = await db.filter
-            .get(id)
-
-        if (!exists) return null;
-
-        const filter = new Filter(
-            exists.name,
-            exists.external,
-            exists.source,
-            exists.internal,
-            exists.query
-        );
-
-        filter.id = exists.id;
-
-        return filter;
-    }
-
-    async update(
-        body: {
-            name?: string;
-            external?: string;
-            source?: string;
-            internal?: boolean;
-            query?: string;
-        }
-    ): Promise<void> {
-        if (body.name !== undefined) this.name = body.name;
-        if (body.external !== undefined) this.external = body.external;
-        if (body.source !== undefined) this.source = body.source;
-        if (body.internal !== undefined) this.internal = body.internal;
-        if (body.query !== undefined) this.query = body.query;
-
-        await db.filter.update(this.id, {
-            name: this.name,
-            external: this.external,
-            source: this.source,
-            internal: this.internal,
-            query: this.query,
-        });
-    }
-
-    static async create(
-        name: string,
-        external: string,
-        source: string,
-        internal: boolean,
-        query: string
-    ): Promise<Filter> {
-        const filter = new Filter(
-            name,
-            external,
-            source,
-            internal,
-            query
-        );
-
-        await db.filter.add({
-            id: filter.id,
-            name: filter.name,
-            external: filter.external,
-            source: filter.source,
-            internal: filter.internal,
-            query: filter.query,
-        });
-
-        return filter;
-    }
-
-    async delete(): Promise<void> {
-        await Filter.delete({ id: this.id });
-    }
-
-    static async delete(id: {
-        id?: string;
-        external?: string;
-    }): Promise<void> {
-        if (!id.id && !id.external) {
-            throw new Error('Either id or external must be provided for deletion.');
-        } else if (id.id) {
-            await db.filter
-                .where('id')
-                .equals(id.id)
-                .delete();
-        } else if (id.external) {
-            await db.filter
-                .where('external')
-                .equals(id.external)
-                .delete();
-        }
-    }
-}

package/src/base/handler.ts

@@ -1,67 +0,0 @@
-/*
-* ConnectionStore - Maintain the WebSocket connection with CloudTAK Server
-*/
-
-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 class CloudTAKTransferHandler {
-    atlas: Atlas | Remote<Atlas>;
-    remote: boolean;
-
-    constructor(
-        atlas: Atlas | Remote<Atlas>,
-        transferHandlers: Map<string, TransferHandler<unknown, unknown>>,
-        remote: boolean
-    ) {
-        this.atlas = atlas;
-        this.remote = remote;
-
-        transferHandlers.set("cot", this.cot);
-        transferHandlers.set("cots", this.cots);
-    }
-
-    cots: TransferHandler<Set<COT>, Array<Feature>> = {
-        canHandle: (obj): obj is Set<COT> => {
-            if (!(obj instanceof Set)) return false;
-            for (const val of obj.values()) {
-                if (!(val instanceof COT)) return false;
-            }
-            return true;
-        },
-        serialize: (cots: Set<COT>) => {
-            const feats = [];
-            for (const cot of cots.values()) {
-                feats.push(cot.as_feature());
-            }
-            return [feats, []];
-        },
-        deserialize: (feats) => {
-            const set = new Set<COT>;
-            for (const feat of feats) {
-                set.add(new COT(this.atlas, feat, feat.origin, {
-                    remote: this.remote
-                }));
-            }
-
-            return set;
-        }
-    }
-
-    cot: TransferHandler<COT, Feature> = {
-        canHandle: (obj): obj is COT => {
-            return obj instanceof COT;
-        },
-        serialize: (cot: COT) => {
-            const feat = cot.as_feature();
-            return [feat, []];
-        },
-        deserialize: (feat: Feature): COT => {
-            return new COT(this.atlas, feat, feat.origin, {
-                remote: true
-            });
-        }
-    }
-}

package/src/base/icon.ts

@@ -1,16 +0,0 @@
-import { db } from './database.ts';
-
-export default class Icon {
-    static async has(icon: string): Promise<boolean> {
-        return await db.icon
-            .where("name")
-            .equals(icon)
-            .count() > 0;
-    }
-
-    static async populate(icons: string[]): Promise<void> {
-        await db.icon.bulkPut(
-            icons.map((name) => ({ name })),
-        );
-    }
-}

package/src/base/notification.ts

@@ -1,163 +0,0 @@
-import { db, NotificationType } from './database.ts'
-import type { DBNotification } from './database.ts';
-import { v4 as randomUUID } from 'uuid';
-
-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
-        }
-    ) {
-        this.id = id;
-        this.type = type;
-        this.name = name;
-        this.body = body;
-        this.url = url;
-        this.created = opts?.created || new Date().toISOString();
-        this.toast = opts?.toast || false;
-        this.read = opts?.read || false;
-    }
-
-    /**
-     * Return a Notification instance if one already exists in the local DB,
-     */
-    static async from(
-        id: string
-    ): Promise<TAKNotification | null> {
-        const exists = await db.notification
-            .get(id)
-
-        if (!exists) {
-            return null;
-        }
-
-        return new TAKNotification(
-            exists.id,
-            exists.type,
-            exists.name,
-            exists.body,
-            exists.url,
-            {
-                read: exists.read,
-                toast: exists.toast,
-                created: exists.created
-            }
-        );
-    }
-
-    static async create(
-        type: NotificationType,
-        name: string,
-        body: string,
-        url: string,
-        toast?: boolean
-    ): Promise<TAKNotification> {
-        const id = randomUUID();
-
-        const notification = new TAKNotification(
-            id,
-            type,
-            name,
-            body,
-            url,
-            {
-                created: new Date().toISOString(),
-                toast: toast || false,
-                read: false
-            }
-        );
-
-        await db.notification.add({
-            id: notification.id,
-            type: notification.type,
-            name: notification.name,
-            body: notification.body,
-            url: notification.url,
-            created: notification.created,
-            toast: notification.toast,
-            read: notification.read
-        });
-
-        return notification;
-    }
-
-    static async update(id: string, opts: {
-        read?: boolean,
-        toast?: boolean
-    }): Promise<void> {
-        const n = await TAKNotification.from(id);
-        await n?.update(opts);
-    }
-
-    async update(opts: {
-        read?: boolean
-        toast?: boolean
-    }): Promise<void> {
-        await db.notification.put({
-            id: this.id,
-            type: this.type,
-            name: this.name,
-            body: this.body,
-            url: this.url,
-            created: this.created,
-            toast: opts.toast ?? this.toast,
-            read: opts.read ?? this.read
-        });
-    }
-
-    async popup(): Promise<void> {
-        if ('Notification' in self && Notification && Notification.permission !== 'denied') {
-            const n = new Notification(this.name, {
-                body: this.body
-            });
-
-            n.onclick = (event) => {
-                event.preventDefault(); // prevent the browser from focusing the Notification's tab
-            };
-        }
-    }
-
-    static async clear(): Promise<void> {
-        await db.notification.clear();
-    }
-
-    static async delete(id: string): Promise<void> {
-        await db.notification.delete(id);
-    }
-
-    async delete(): Promise<void> {
-        await db.notification.delete(this.id);
-    }
-
-    static async count(): Promise<number> {
-        const collection = await db.notification.toCollection();
-
-        return await collection
-            .count();
-    }
-
-    static async list(): Promise<DBNotification[]> {
-        const collection = await db.notification.toCollection();
-
-        return await collection
-            .sortBy('created');
-    }
-}