@tak-ps/cloudtak 13.3.0 → 13.5.0

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

@@ -1,12 +1,4 @@
-import type { CallbackID, Position, PositionOptions } from '@capacitor/geolocation';
 export declare function isNativePlatform(): boolean;
 export declare function supportsServiceWorker(): boolean;
-export declare function supportsLocationRequests(): boolean;
 export declare function openExternalUrl(url: string | URL): Promise<void>;
 export declare function openSecondaryView(url: string | URL): Promise<void>;
-export declare function writeClipboardText(value: string): Promise<void>;
-export declare function checkNativeLocationPermission(): Promise<PermissionState | 'prompt' | 'unknown'>;
-export declare function requestNativeLocationPermission(): Promise<PermissionState | 'prompt' | 'unknown'>;
-export declare function getCurrentLocation(options?: PositionOptions): Promise<Position>;
-export declare function watchLocation(options: PositionOptions, callback: (position: Position | null, err?: unknown) => void): Promise<CallbackID>;
-export declare function clearLocationWatch(id: CallbackID): Promise<void>;

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

@@ -40,9 +40,4 @@ export default class Icon {
         token: string;
         force?: boolean;
     }): Promise<boolean>;
-    /**
-     * Remove an iconset and all of its icons from Dexie. Returns true when
-     * something was actually removed.
-     */
-    static removeIconset(uid: string): Promise<boolean>;
 }

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

@@ -1,20 +1,42 @@
 import { type Observable } from 'dexie';
 import { type DBIconset } from '../database.ts';
+import type { paths } from '@cloudtak/api-types';
+import type { Iconset } from '../types.ts';
 import BaseInterface from './interface.ts';
 import type { BaseInterface_ListOptions, BaseInterface_FromOptions } from './interface.ts';
+export type Iconset_DeleteOptions = {
+    localOnly?: boolean;
+};
 export type Iconset_ListOptions = BaseInterface_ListOptions & {
-    token?: string;
+    filter?: string;
+    limit?: number;
+    page?: number;
+};
+export type Iconset_Page = {
+    total: number;
+    items: DBIconset[];
 };
 export default class IconsetManager extends BaseInterface {
     static readonly listCacheKey = "iconset";
-    static count(): Promise<number>;
-    static liveCount(): Observable<number>;
+    static count(opts?: Pick<Iconset_ListOptions, 'filter'>): Promise<number>;
+    static liveCount(opts?: Pick<Iconset_ListOptions, 'filter'>): Observable<number>;
     /**
      * Return all locally cached iconsets ordered by name.
      */
     static list(opts?: Iconset_ListOptions): Promise<DBIconset[]>;
-    static liveList(): Observable<DBIconset[]>;
+    static page(opts?: Iconset_ListOptions): Promise<Iconset_Page>;
+    static liveList<T extends Iconset_ListOptions & {
+        paged?: boolean;
+    } = Iconset_ListOptions>(opts?: T): Observable<T extends {
+        paged: true;
+    } ? Iconset_Page : DBIconset[]>;
     static from(uid: string, opts?: BaseInterface_FromOptions): Promise<DBIconset | undefined>;
     static liveFrom(uid: string): Observable<DBIconset | undefined>;
-    static sync(token?: string): Promise<void>;
+    static get(uid: string): Promise<Iconset>;
+    static create(body: paths['/api/iconset']['post']['requestBody']['content']['application/json']): Promise<Iconset>;
+    static update(uid: string, body: paths['/api/iconset/{:iconset}']['patch']['requestBody']['content']['application/json']): Promise<void>;
+    static regenerate(uid: string): Promise<void>;
+    static download(uid: string): Promise<void>;
+    static sync(): Promise<void>;
+    static delete(uid: string, opts?: Iconset_DeleteOptions): Promise<void>;
 }

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

@@ -54,14 +54,14 @@ export default class BaseInterface {
     /**
      * Generates a new item, attempt to save it via the API and save it to the database
      */
-    static generate(): Promise<unknown>;
+    static generate(data: unknown): Promise<unknown>;
     /**
      * Updates an item in the database by its unique identifier and attempts to update it via the API
      *
      * @param id - The unique identifier of the item to update
      * @param data - The data to update the item with
      */
-    static update(): Promise<void>;
+    static update(id: string, data: unknown): Promise<void>;
     /**
      * Deletes an item from the database by its unique identifier and attempts to delete it via the API
      *

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

@@ -0,0 +1,101 @@
+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;
+    loading: 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;
+    encoding: 'mapbox' | 'terrarium' | 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 & {
+        encoding?: 'mapbox' | 'terrarium' | null;
+    }, 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;
+    moveBefore(overlay?: Overlay): void;
+    replace(overlay: {
+        name?: string;
+        active?: boolean;
+        username?: string;
+        actions?: ProfileOverlay["actions"];
+        type?: string;
+        opacity?: number;
+        visible?: boolean;
+        mode?: string;
+        mode_id?: string;
+        encoding?: 'mapbox' | 'terrarium' | null;
+        url?: string;
+        token?: string;
+        styles?: Array<LayerSpecification>;
+    }, opts?: {
+        before?: string;
+    }): Promise<void>;
+    delete(): Promise<void>;
+    update(body: {
+        pos?: number;
+        visible?: boolean;
+        opacity?: number;
+        encoding?: 'mapbox' | 'terrarium' | null;
+    }): Promise<void>;
+    save(): Promise<void>;
+}

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

@@ -1,100 +1,70 @@
-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;
+import { type Observable } from 'dexie';
+import { type DBOverlay } from '../database.ts';
+import type { paths } from '@cloudtak/api-types';
+import type { ProfileOverlay } from '../types.ts';
+import BaseInterface from './interface.ts';
+import Overlay from './overlay-class.ts';
+import type { BaseInterface_ListOptions, BaseInterface_FromOptions } from './interface.ts';
+export type Overlay_DeleteOptions = {
+    localOnly?: boolean;
+};
+export type Overlay_ListOptions = BaseInterface_ListOptions & {
+    active?: boolean;
+    filter?: string;
+    limit?: number;
+    localFirst?: boolean;
+    mode?: string;
+    modeId?: string | null;
+    page?: number;
+    visible?: boolean;
+};
+export type Overlay_Page = {
+    total: number;
+    items: DBOverlay[];
+};
+export type Overlay_CreateLoadedOptions = NonNullable<Parameters<typeof Overlay.create>[1]> & {
+    position?: 'default' | 'prepend';
+};
+export default class OverlayManager extends BaseInterface {
+    static readonly listCacheKey = "overlay";
+    static readonly loaded: Overlay[];
+    static listLoaded(): Overlay[];
+    static clearLoaded(): void;
+    static loadedFrom(id: string | number): Overlay | undefined;
+    static loadedByName(name: string): Overlay | undefined;
+    static loadedByMode(mode: string, modeId: string): Overlay | undefined;
+    static loadedBeforeId(): string | undefined;
+    static addLoaded(overlay: Overlay): void;
+    static prependLoaded(overlay: Overlay): void;
+    static appendLoaded(...overlays: Overlay[]): void;
+    static createLoaded(body: Parameters<typeof Overlay.create>[0], opts?: Overlay_CreateLoadedOptions): Promise<Overlay>;
+    static reorderLoaded(orderedIds: number[], movedId: string | number): Promise<void>;
+    static deleteLoaded(idOrOverlay: string | number | Overlay): Promise<void>;
+    static loadedBasemapIds(mode?: string): Set<string>;
+    static loadedProfileUrls(): Set<string>;
+    static queryableOverlayNames(): string[];
+    static clickableLayerMap(): Map<string, {
         type: string;
+        id: string;
     }>;
-    _error?: Error;
-    _loaded: boolean;
-    loading: 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;
-    encoding: 'mapbox' | 'terrarium' | 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 & {
-        encoding?: 'mapbox' | 'terrarium' | null;
-    }, 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;
-        encoding?: 'mapbox' | 'terrarium' | null;
-        url?: string;
-        token?: string;
-        styles?: Array<LayerSpecification>;
-    }, opts?: {
-        before?: string;
-    }): Promise<void>;
-    delete(): Promise<void>;
-    update(body: {
-        pos?: number;
-        visible?: boolean;
-        opacity?: number;
-        encoding?: 'mapbox' | 'terrarium' | null;
-    }): Promise<void>;
-    save(): Promise<void>;
+    static missionOverlays(): Overlay[];
+    static visibleBasemaps(): Overlay[];
+    static count(opts?: Omit<Overlay_ListOptions, 'limit' | 'page' | 'sync'>): Promise<number>;
+    static liveCount(opts?: Omit<Overlay_ListOptions, 'limit' | 'page' | 'sync'>): Observable<number>;
+    static list(opts?: Overlay_ListOptions): Promise<DBOverlay[]>;
+    static page(opts?: Overlay_ListOptions): Promise<Overlay_Page>;
+    static liveList<T extends Overlay_ListOptions & {
+        paged?: boolean;
+    } = Overlay_ListOptions>(opts?: T): Observable<T extends {
+        paged: true;
+    } ? Overlay_Page : DBOverlay[]>;
+    static from(id: string, opts?: BaseInterface_FromOptions): Promise<DBOverlay | undefined>;
+    static liveFrom(id: string): Observable<DBOverlay | undefined>;
+    static get(id: string | number): Promise<ProfileOverlay>;
+    static create(body: paths['/api/profile/overlay']['post']['requestBody']['content']['application/json']): Promise<ProfileOverlay>;
+    static update(id: string, body: paths['/api/profile/overlay/{:overlay}']['patch']['requestBody']['content']['application/json']): Promise<void>;
+    static sync(): Promise<void>;
+    static delete(id: string, opts?: Overlay_DeleteOptions): Promise<void>;
+    private static query;
+    private static overlayId;
 }

package/dist/types/src/components/CloudTAK/Menu/Overlays/TreeCots.vue.d.ts

@@ -1,4 +1,4 @@
-import type Overlay from '../../../../base/overlay.ts';
+import type Overlay from '../../../../base/overlay-class.ts';
 type __VLS_Props = {
     element: Overlay;
 };

package/dist/types/src/components/CloudTAK/Menu/Overlays/TreeMission.vue.d.ts

@@ -1,4 +1,4 @@
-import Overlay from '../../../../base/overlay.ts';
+import Overlay from '../../../../base/overlay-class.ts';
 type __VLS_Props = {
     overlay: Overlay;
 };

package/dist/types/src/components/CloudTAK/ServerStatus.vue.d.ts

@@ -0,0 +1,7 @@
+type __VLS_Props = {
+    version?: boolean;
+    size?: number;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/src/components/CloudTAK/util/CopyField.vue.d.ts

@@ -102,8 +102,8 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
     onDelete?: ((...args: any[]) => any) | undefined;
 }>, {
     stroke: number;
-    size: number;
     mode: string;
+    size: number;
     label: string;
     rows: number;
     hover: boolean;

package/dist/types/src/components/CloudTAK/util/GenericSelect.vue.d.ts

@@ -5,6 +5,7 @@ declare const __VLS_export: <T extends SelectableItem>(__VLS_props: NonNullable<
     props: import("vue").PublicProps & __VLS_PrettifyLocal<{
         disabled?: boolean;
         hover?: boolean;
+        stickyControls?: boolean;
         items: T[];
     }> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;

package/dist/types/src/components/CloudTAK/util/SearchSortFilter.vue.d.ts

@@ -0,0 +1,33 @@
+export interface SearchSortFilterProps {
+    modelValue: string;
+    sort?: string;
+    sortOptions?: string[];
+    activeFilters?: number;
+    placeholder?: string;
+}
+declare var __VLS_32: {}, __VLS_46: {};
+type __VLS_Slots = {} & {
+    filters?: (props: typeof __VLS_32) => any;
+} & {
+    'sort-icon'?: (props: typeof __VLS_46) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<SearchSortFilterProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+    "update:sort": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<SearchSortFilterProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    "onUpdate:sort"?: ((value: string) => any) | undefined;
+}>, {
+    sort: string;
+    placeholder: string;
+    sortOptions: string[];
+    activeFilters: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/src/components/CloudTAK/util/featureCut.d.ts

@@ -1,10 +1,10 @@
 import type { Feature } from 'geojson';
 import type { MapGeoJSONFeature } from 'maplibre-gl';
 import type { useMapStore } from '../../../stores/map.ts';
-import type Overlay from '../../../base/overlay.ts';
+import type Overlay from '../../../base/overlay-class.ts';
 type FeatureLike = Feature | MapGeoJSONFeature;
 type MapStore = ReturnType<typeof useMapStore>;
-export declare function getFeatureOverlay(mapStore: MapStore, feature?: FeatureLike): Overlay | null;
-export declare function canCutOverlayFeature(mapStore: MapStore, feature?: FeatureLike): boolean;
+export declare function getFeatureOverlay(feature?: FeatureLike): Overlay | null;
+export declare function canCutOverlayFeature(feature?: FeatureLike): boolean;
 export declare function cutOverlayFeature(mapStore: MapStore, feature?: FeatureLike): Promise<void>;
 export {};

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

@@ -1,5 +1,5 @@
 import Dexie, { type EntityTable } from 'dexie';
-import type { Feature, GroupChannel, Mission, MissionRole, MissionChange, MissionLog, Contact, Server } from './types.ts';
+import type { Feature, GroupChannel, Mission, MissionRole, MissionChange, MissionLog, Contact, Server, ProfileOverlayList } from './types.ts';
 export interface DBIcon {
     /** Maplibre image id, e.g. "<iconsetUid>:<icon-path-without-extension>" */
     name: string;
@@ -56,6 +56,7 @@ export interface DBIconset {
     default_unknown: string | null;
     skip_resize: boolean;
 }
+export type DBOverlay = ProfileOverlayList["items"][number];
 export interface DBFilter {
     id: string;
     external: string;
@@ -187,6 +188,7 @@ export interface DBSprite {
 export type DatabaseType = Dexie & {
     icon: EntityTable<DBIcon, 'name'>;
     iconset: EntityTable<DBIconset, 'uid'>;
+    overlay: EntityTable<DBOverlay, 'id'>;
     sprite: EntityTable<DBSprite, 'id'>;
     group: EntityTable<GroupChannel, 'name'>;
     video: EntityTable<DBVideo, 'id'>;

package/dist/types/src/router.d.ts

@@ -1,3 +1,3 @@
 import * as VueRouter from 'vue-router';
-declare const router: VueRouter.Router;
+declare const router: VueRouter._RouterClassic;
 export default router;

package/dist/types/src/std.d.ts

@@ -3,6 +3,7 @@ import type { Router } from 'vue-router';
 export declare const serverUrl: string;
 export declare const server: import("openapi-fetch").Client<paths, `${string}/${string}`>;
 export declare function getServer(): Promise<import("openapi-fetch").Client<paths, `${string}/${string}`>>;
+export declare function getRuntimeToken(): Promise<string | undefined>;
 export declare function stdurl(url: string | URL): URL;
 /**
  * Standardize interactions with the backend API
@@ -17,5 +18,11 @@ export declare function std(url: string | URL, opts?: {
     body?: unknown;
     method?: string;
 }): Promise<unknown>;
+export declare function downloadBlob(blob: Blob, response: Response, fallbackName: string): void;
+export declare function downloadUrl(url: string | URL, opts?: {
+    filename?: string;
+    token?: boolean;
+    native?: boolean;
+}): Promise<void>;
 export declare function stdclick($router: Router, event: MouseEvent | KeyboardEvent, path: string): void;
 export declare function humanSeconds(seconds: number): string;

package/dist/types/src/stores/device/camera.d.ts

@@ -0,0 +1,10 @@
+import type { DevicePermissionContext } from './types.ts';
+export declare class CameraPermission {
+    private readonly context;
+    constructor(context: DevicePermissionContext);
+    private static normalizeNativeCameraPermission;
+    static checkNativeCameraPermission(): Promise<PermissionState | 'prompt' | 'unknown'>;
+    static requestNativeCameraPermission(): Promise<PermissionState | 'prompt' | 'unknown'>;
+    refreshStatus(): Promise<void>;
+    request(): Promise<void>;
+}

package/dist/types/src/stores/device/file-system.d.ts

@@ -0,0 +1,7 @@
+import type { DevicePermissionContext } from './types.ts';
+export declare class FileSystemPermission {
+    private readonly context;
+    constructor(context: DevicePermissionContext);
+    refreshStatus(): Promise<void>;
+    request(): Promise<void>;
+}

package/dist/types/src/stores/device/geolocation.d.ts

@@ -0,0 +1,29 @@
+import type { CallbackID, Position, PositionOptions } from '@capacitor/geolocation';
+import type { DevicePermissionContext } from './types.ts';
+export declare class GeolocationPermission {
+    private readonly context;
+    constructor(context: DevicePermissionContext);
+    private watchId;
+    private backgroundWatchId;
+    private locationCallback;
+    private visibilityHandler;
+    private isInBackground;
+    private static normalizeNativeLocationPermission;
+    static supportsLocationRequests(): boolean;
+    static checkNativeLocationPermission(): Promise<PermissionState | 'prompt' | 'unknown'>;
+    static requestNativeLocationPermission(): Promise<PermissionState | 'prompt' | 'unknown'>;
+    static getCurrentLocation(options?: PositionOptions): Promise<Position>;
+    static watchLocation(options: PositionOptions, callback: (position: Position | null, err?: unknown) => void): Promise<CallbackID>;
+    static watchBackgroundLocation(callback: (position: Position | null, err?: unknown) => void): Promise<CallbackID>;
+    static clearLocationWatch(id: CallbackID): Promise<void>;
+    static clearBackgroundLocationWatch(id: CallbackID): Promise<void>;
+    private static backgroundLocationToPosition;
+    stopWatch(): Promise<void>;
+    startWatch(onLocation: (position: Position) => void): Promise<void>;
+    private startForegroundWatch;
+    private startBackgroundWatch;
+    private setupVisibilityListener;
+    refreshStatus(): Promise<void>;
+    request(onGranted?: () => void): Promise<void>;
+    initializeSubscription(onGranted?: () => void): Promise<void>;
+}

package/dist/types/src/stores/device/notification.d.ts

@@ -0,0 +1,18 @@
+import type { DevicePermissionContext } from './types.ts';
+export declare class BrowserNotificationPermission {
+    private readonly context;
+    private static normalizeNotificationPermission;
+    private static normalizeNativeNotificationPermission;
+    private static supportsNotifications;
+    private messagingToken;
+    private tokenListener;
+    constructor(context: DevicePermissionContext);
+    refreshStatus(): Promise<void>;
+    request(): Promise<void>;
+    initializeSubscription(): Promise<void>;
+    getMessagingToken(): string | null;
+    refreshMessagingToken(): Promise<string | null>;
+    deleteMessagingToken(): Promise<void>;
+    private refreshNativeStatus;
+    private initializeNativeMessaging;
+}

package/dist/types/src/stores/device/orientation.d.ts

@@ -0,0 +1,15 @@
+import type { DevicePermissionContext } from './types.ts';
+type DeviceOrientationEventName = 'deviceorientationabsolute' | 'deviceorientation';
+export declare class OrientationPermission {
+    private readonly context;
+    constructor(context: DevicePermissionContext);
+    hasSupport(): boolean;
+    hasPermissionRequest(): boolean;
+    getEventName(): DeviceOrientationEventName;
+    getHeading(event: DeviceOrientationEvent): number | null;
+    addListener(listener: (event: DeviceOrientationEvent) => void): void;
+    removeListener(listener: (event: DeviceOrientationEvent) => void): void;
+    refreshStatus(): Promise<void>;
+    request(): Promise<void>;
+}
+export {};

package/dist/types/src/stores/device/shared.d.ts

@@ -0,0 +1,4 @@
+export declare class PermissionQuery {
+    static hasPermissionQuery(): boolean;
+    static queryPermissionStatus(name: string, warning: string): Promise<PermissionStatus | null>;
+}

package/dist/types/src/stores/device/storage.d.ts

@@ -0,0 +1,7 @@
+import type { DevicePermissionContext } from './types.ts';
+export declare class StoragePermission {
+    private readonly context;
+    constructor(context: DevicePermissionContext);
+    refreshStatus(): Promise<void>;
+    request(): Promise<void>;
+}

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

@@ -0,0 +1,23 @@
+export type BrowserPermissionState = PermissionState | 'unsupported' | 'unknown';
+export type BrowserPermissionType = 'location' | 'notification' | 'orientation' | 'storage' | 'camera' | 'wakeLock' | 'fileSystem';
+export type FileSystemAccessHandle = FileSystemHandle & {
+    queryPermission?: (descriptor?: {
+        mode?: 'read' | 'readwrite';
+    }) => Promise<PermissionState>;
+    requestPermission?: (descriptor?: {
+        mode?: 'read' | 'readwrite';
+    }) => Promise<PermissionState>;
+};
+export type WindowWithFilePicker = Window & {
+    showOpenFilePicker?: (options?: {
+        multiple?: boolean;
+    }) => Promise<FileSystemAccessHandle[]>;
+};
+export interface DevicePermissionContext {
+    permissions: Record<BrowserPermissionType, BrowserPermissionState>;
+    setPermissionStatus: (type: BrowserPermissionType, state: BrowserPermissionState) => void;
+    getWakeLockSentinel: () => WakeLockSentinel | null;
+    setWakeLockSentinel: (sentinel: WakeLockSentinel | null) => void;
+    getFileSystemHandle: () => FileSystemAccessHandle | null;
+    setFileSystemHandle: (handle: FileSystemAccessHandle | null) => void;
+}

package/dist/types/src/stores/device/wake-lock.d.ts

@@ -0,0 +1,10 @@
+import type { DevicePermissionContext } from './types.ts';
+export declare class WakeLockPermission {
+    private readonly context;
+    constructor(context: DevicePermissionContext);
+    refreshStatus(): Promise<void>;
+    request(): Promise<void>;
+    releaseSentinel(): Promise<void>;
+    private isSupported;
+    private isKeptAwake;
+}

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

@@ -0,0 +1,140 @@
+import { CameraPermission } from './device/camera.ts';
+import { FileSystemPermission } from './device/file-system.ts';
+import { GeolocationPermission } from './device/geolocation.ts';
+import { BrowserNotificationPermission } from './device/notification.ts';
+import { OrientationPermission } from './device/orientation.ts';
+import { StoragePermission } from './device/storage.ts';
+import { WakeLockPermission } from './device/wake-lock.ts';
+import type { BrowserPermissionState, BrowserPermissionType } from './device/types.ts';
+export type { BrowserPermissionState, BrowserPermissionType } from './device/types.ts';
+export { CameraPermission } from './device/camera.ts';
+export { FileSystemPermission } from './device/file-system.ts';
+export { GeolocationPermission } from './device/geolocation.ts';
+export { BrowserNotificationPermission } from './device/notification.ts';
+export { OrientationPermission } from './device/orientation.ts';
+export { StoragePermission } from './device/storage.ts';
+export { WakeLockPermission } from './device/wake-lock.ts';
+export declare const useDeviceStore: import("pinia").StoreDefinition<"device", Pick<{
+    permissions: {
+        notification: BrowserPermissionState;
+        orientation: BrowserPermissionState;
+        location: BrowserPermissionState;
+        storage: BrowserPermissionState;
+        camera: BrowserPermissionState;
+        wakeLock: BrowserPermissionState;
+        fileSystem: BrowserPermissionState;
+    };
+    geolocation: import("vue").Raw<GeolocationPermission>;
+    notification: import("vue").Raw<BrowserNotificationPermission>;
+    orientation: import("vue").Raw<OrientationPermission>;
+    storage: import("vue").Raw<StoragePermission>;
+    camera: import("vue").Raw<CameraPermission>;
+    wakeLock: import("vue").Raw<WakeLockPermission>;
+    fileSystem: import("vue").Raw<FileSystemPermission>;
+    setPermissionStatus: (type: BrowserPermissionType, state: BrowserPermissionState) => void;
+    refreshPermissionStatuses: () => Promise<void>;
+    initializePermissionSubscriptions: (onLocationGranted?: () => void) => Promise<void>;
+    hasOrientationSupport: () => boolean;
+    hasOrientationPermissionRequest: () => boolean;
+    getOrientationEventName: () => "deviceorientation" | "deviceorientationabsolute";
+    getOrientationHeading: (event: DeviceOrientationEvent) => number | null;
+    addOrientationListener: (listener: (event: DeviceOrientationEvent) => void) => void;
+    removeOrientationListener: (listener: (event: DeviceOrientationEvent) => void) => void;
+    refreshLocationPermissionStatus: () => Promise<void>;
+    refreshNotificationPermissionStatus: () => Promise<void>;
+    refreshOrientationPermissionStatus: () => Promise<void>;
+    refreshStoragePermissionStatus: () => Promise<void>;
+    refreshCameraPermissionStatus: () => Promise<void>;
+    refreshWakeLockPermissionStatus: () => Promise<void>;
+    refreshFileSystemPermissionStatus: () => Promise<void>;
+    requestLocationPermission: (onGranted?: () => void) => Promise<void>;
+    requestNotificationPermission: () => Promise<void>;
+    requestOrientationPermission: () => Promise<void>;
+    requestStoragePermission: () => Promise<void>;
+    requestCameraPermission: () => Promise<void>;
+    requestWakeLockPermission: () => Promise<void>;
+    requestFileSystemPermission: () => Promise<void>;
+    releaseWakeLockSentinel: () => Promise<void>;
+}, "notification" | "orientation" | "storage" | "permissions" | "camera" | "geolocation" | "wakeLock" | "fileSystem">, Pick<{
+    permissions: {
+        notification: BrowserPermissionState;
+        orientation: BrowserPermissionState;
+        location: BrowserPermissionState;
+        storage: BrowserPermissionState;
+        camera: BrowserPermissionState;
+        wakeLock: BrowserPermissionState;
+        fileSystem: BrowserPermissionState;
+    };
+    geolocation: import("vue").Raw<GeolocationPermission>;
+    notification: import("vue").Raw<BrowserNotificationPermission>;
+    orientation: import("vue").Raw<OrientationPermission>;
+    storage: import("vue").Raw<StoragePermission>;
+    camera: import("vue").Raw<CameraPermission>;
+    wakeLock: import("vue").Raw<WakeLockPermission>;
+    fileSystem: import("vue").Raw<FileSystemPermission>;
+    setPermissionStatus: (type: BrowserPermissionType, state: BrowserPermissionState) => void;
+    refreshPermissionStatuses: () => Promise<void>;
+    initializePermissionSubscriptions: (onLocationGranted?: () => void) => Promise<void>;
+    hasOrientationSupport: () => boolean;
+    hasOrientationPermissionRequest: () => boolean;
+    getOrientationEventName: () => "deviceorientation" | "deviceorientationabsolute";
+    getOrientationHeading: (event: DeviceOrientationEvent) => number | null;
+    addOrientationListener: (listener: (event: DeviceOrientationEvent) => void) => void;
+    removeOrientationListener: (listener: (event: DeviceOrientationEvent) => void) => void;
+    refreshLocationPermissionStatus: () => Promise<void>;
+    refreshNotificationPermissionStatus: () => Promise<void>;
+    refreshOrientationPermissionStatus: () => Promise<void>;
+    refreshStoragePermissionStatus: () => Promise<void>;
+    refreshCameraPermissionStatus: () => Promise<void>;
+    refreshWakeLockPermissionStatus: () => Promise<void>;
+    refreshFileSystemPermissionStatus: () => Promise<void>;
+    requestLocationPermission: (onGranted?: () => void) => Promise<void>;
+    requestNotificationPermission: () => Promise<void>;
+    requestOrientationPermission: () => Promise<void>;
+    requestStoragePermission: () => Promise<void>;
+    requestCameraPermission: () => Promise<void>;
+    requestWakeLockPermission: () => Promise<void>;
+    requestFileSystemPermission: () => Promise<void>;
+    releaseWakeLockSentinel: () => Promise<void>;
+}, never>, Pick<{
+    permissions: {
+        notification: BrowserPermissionState;
+        orientation: BrowserPermissionState;
+        location: BrowserPermissionState;
+        storage: BrowserPermissionState;
+        camera: BrowserPermissionState;
+        wakeLock: BrowserPermissionState;
+        fileSystem: BrowserPermissionState;
+    };
+    geolocation: import("vue").Raw<GeolocationPermission>;
+    notification: import("vue").Raw<BrowserNotificationPermission>;
+    orientation: import("vue").Raw<OrientationPermission>;
+    storage: import("vue").Raw<StoragePermission>;
+    camera: import("vue").Raw<CameraPermission>;
+    wakeLock: import("vue").Raw<WakeLockPermission>;
+    fileSystem: import("vue").Raw<FileSystemPermission>;
+    setPermissionStatus: (type: BrowserPermissionType, state: BrowserPermissionState) => void;
+    refreshPermissionStatuses: () => Promise<void>;
+    initializePermissionSubscriptions: (onLocationGranted?: () => void) => Promise<void>;
+    hasOrientationSupport: () => boolean;
+    hasOrientationPermissionRequest: () => boolean;
+    getOrientationEventName: () => "deviceorientation" | "deviceorientationabsolute";
+    getOrientationHeading: (event: DeviceOrientationEvent) => number | null;
+    addOrientationListener: (listener: (event: DeviceOrientationEvent) => void) => void;
+    removeOrientationListener: (listener: (event: DeviceOrientationEvent) => void) => void;
+    refreshLocationPermissionStatus: () => Promise<void>;
+    refreshNotificationPermissionStatus: () => Promise<void>;
+    refreshOrientationPermissionStatus: () => Promise<void>;
+    refreshStoragePermissionStatus: () => Promise<void>;
+    refreshCameraPermissionStatus: () => Promise<void>;
+    refreshWakeLockPermissionStatus: () => Promise<void>;
+    refreshFileSystemPermissionStatus: () => Promise<void>;
+    requestLocationPermission: (onGranted?: () => void) => Promise<void>;
+    requestNotificationPermission: () => Promise<void>;
+    requestOrientationPermission: () => Promise<void>;
+    requestStoragePermission: () => Promise<void>;
+    requestCameraPermission: () => Promise<void>;
+    requestWakeLockPermission: () => Promise<void>;
+    requestFileSystemPermission: () => Promise<void>;
+    releaseWakeLockSentinel: () => Promise<void>;
+}, "setPermissionStatus" | "refreshPermissionStatuses" | "initializePermissionSubscriptions" | "hasOrientationSupport" | "hasOrientationPermissionRequest" | "getOrientationEventName" | "getOrientationHeading" | "addOrientationListener" | "removeOrientationListener" | "refreshLocationPermissionStatus" | "refreshNotificationPermissionStatus" | "refreshOrientationPermissionStatus" | "refreshStoragePermissionStatus" | "refreshCameraPermissionStatus" | "refreshWakeLockPermissionStatus" | "refreshFileSystemPermissionStatus" | "requestLocationPermission" | "requestNotificationPermission" | "requestOrientationPermission" | "requestStoragePermission" | "requestCameraPermission" | "requestWakeLockPermission" | "requestFileSystemPermission" | "releaseWakeLockSentinel">>;

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

@@ -6,13 +6,12 @@ import * as Comlink from 'comlink';
 import COT from '../base/cot.ts';
 import type { DatabaseType } from '../database.ts';
 import { LocationState } from '../base/events.ts';
-import Overlay from '../base/overlay.ts';
 import Subscription from '../base/subscription.ts';
 import * as mapgl from 'maplibre-gl';
 import type Atlas from '../workers/atlas.ts';
 import type { Feature } from '../types.ts';
 import type { LngLat, Point, MapGeoJSONFeature } from 'maplibre-gl';
-import type { CallbackID } from '@capacitor/geolocation';
+import type { Position } from '@capacitor/geolocation';
 export type TAKNotification = {
     type: string;
     name: string;
@@ -47,7 +46,6 @@ export declare const useMapStore: import("pinia").StoreDefinition<"cloudtak", {
     defaultPointType: string;
     manualLocationMode: boolean;
     isMobileDetected: boolean;
-    gpsWatchId: CallbackID | null;
     tokenExpiry: number | null;
     lastUpdateCOTErrorSignature: string | null;
     toastOffset: {
@@ -85,22 +83,16 @@ export declare const useMapStore: import("pinia").StoreDefinition<"cloudtak", {
         y: number;
         lngLat?: LngLat;
     };
-    overlays: Array<Overlay>;
 }, {
     map: () => mapgl.Map;
     draw: () => DrawTool;
     icons: () => IconManager;
     menu: () => MenuManager;
     bottomBar: () => BottomBarManager;
+    locationCallback: () => (position: Position) => void;
 }, {
     destroy: () => Promise<void>;
-    getOverlayBeforeId: () => string | undefined;
-    addOverlay: (overlay: Overlay) => void;
-    removeOverlay: (overlay: Overlay) => Promise<void>;
     makeActiveMission: (mission?: Subscription) => Promise<void>;
-    getOverlayById(id: number): Overlay | null;
-    getOverlayByName(name: string): Overlay | null;
-    getOverlayByMode(mode: string, mode_id: string): Overlay | null;
     addTerrain: () => Promise<void>;
     removeTerrain: () => void;
     returnHome: () => Promise<void>;
@@ -117,8 +109,7 @@ export declare const useMapStore: import("pinia").StoreDefinition<"cloudtak", {
         reload: boolean;
     }) => Promise<Subscription | null>;
     init: (container: HTMLElement) => Promise<void>;
-    stopGPSWatch: () => Promise<void>;
-    startGPSWatch: () => Promise<void>;
+    submitLocationHttp: (position: Position) => Promise<void>;
     initOverlays: () => Promise<void>;
     updateIconRotation: (enabled: boolean) => void;
     updateDistanceUnit: (unit: string) => void;

package/dist/types/src/stores/modules/icons.d.ts

@@ -1,17 +1,14 @@
 import type { Map as MapLibreMap } from 'maplibre-gl';
-import type * as Comlink from 'comlink';
-import type Atlas from '../../workers/atlas.ts';
 import { type DBIconset } from '../../database.ts';
 export default class IconManager {
     private cache;
     private map;
-    private worker;
     private loggedMissingImageIds;
     private loggedErrors;
     private inflightImage;
     private fallbackBitmap;
     private requestedIconsetImageIds;
-    constructor(map: MapLibreMap, worker: Comlink.Remote<Atlas>);
+    constructor(map: MapLibreMap);
     private logWarnOnce;
     private logErrorOnce;
     static from(uid: string): Promise<DBIconset | undefined>;
@@ -39,9 +36,8 @@ export default class IconManager {
     /**
      * Hydrate the local Dexie icon cache from the API.
      *
-     * The actual network IO and base64 -> Blob decoding runs inside the Atlas
-     * worker (see `AtlasIcons.hydrate`); this method only handles main-thread
-     * concerns like purging stale MapLibre images.
+     * This method also handles main-thread concerns like purging stale MapLibre
+     * images when the local Dexie cache changes.
      */
     hydrate(opts?: {
         force?: boolean;
@@ -55,6 +51,7 @@ export default class IconManager {
         force?: boolean;
     }): Promise<void>;
     removeIconset(uid: string): Promise<void>;
+    deleteIconset(uid: string): Promise<void>;
     private applyHydrateResult;
     private purgeMapImagesForIconset;
     onStyleImageMissing(e: {

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

@@ -3,7 +3,6 @@ import * as Comlink from 'comlink';
 import AtlasProfile from './atlas-profile.ts';
 import AtlasDatabase from './atlas-database.ts';
 import AtlasConnection from './atlas-connection.ts';
-import AtlasIcons from './atlas-icons.ts';
 export default class Atlas {
     channel: BroadcastChannel;
     token: string;
@@ -12,7 +11,6 @@ export default class Atlas {
     db: AtlasDatabase & Comlink.ProxyMarked;
     conn: AtlasConnection & Comlink.ProxyMarked;
     profile: AtlasProfile & Comlink.ProxyMarked;
-    icons: AtlasIcons & 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.3.0",
+    "version": "13.5.0",
     "types": "dist/types/plugin.d.ts",
     "files": [
         "dist/types"
@@ -29,7 +29,11 @@
         "url": "git+https://github.com/dfpc-coe/CloudTAK.git"
     },
     "dependencies": {
+        "@capacitor-community/background-geolocation": "^1.2.26",
+        "@capacitor-community/keep-awake": "^8.0.1",
+        "@capacitor-firebase/messaging": "^8.2.0",
         "@capacitor/browser": "^8.0.1",
+        "@capacitor/camera": "^8.2.0",
         "@capacitor/clipboard": "^8.0.1",
         "@capacitor/core": "^8.3.1",
         "@capacitor/geolocation": "^8.1.0",
@@ -65,6 +69,7 @@
         "cronstrue": "^3.0.0",
         "dexie": "^4.2.1",
         "dropzone": "^6.0.0-beta.2",
+        "firebase": "^12.13.0",
         "floating-vue": "^2.0.0-beta.17",
         "geo-coordinates-parser": "^1.7.4",
         "geomagnetism": "^0.2.0",

package/dist/types/src/stores/modules/permissions.d.ts

@@ -1,37 +0,0 @@
-export type BrowserPermissionState = PermissionState | 'unsupported' | 'unknown';
-export type BrowserPermissionType = 'location' | 'notification' | 'orientation' | 'storage' | 'camera' | 'wakeLock' | 'fileSystem';
-type FileSystemAccessHandle = FileSystemHandle & {
-    queryPermission?: (descriptor?: {
-        mode?: 'read' | 'readwrite';
-    }) => Promise<PermissionState>;
-    requestPermission?: (descriptor?: {
-        mode?: 'read' | 'readwrite';
-    }) => Promise<PermissionState>;
-};
-export declare const usePermissionStore: import("pinia").StoreDefinition<"permissions", {
-    permissions: Record<BrowserPermissionType, BrowserPermissionState>;
-    _wakeLockSentinel?: WakeLockSentinel | null;
-    _fileSystemHandle?: FileSystemAccessHandle | null;
-}, {}, {
-    hasOrientationSupport: () => boolean;
-    hasOrientationPermissionRequest: () => boolean;
-    setPermissionStatus: (type: BrowserPermissionType, state: BrowserPermissionState) => void;
-    refreshLocationPermissionStatus: () => Promise<void>;
-    refreshNotificationPermissionStatus: () => Promise<void>;
-    refreshOrientationPermissionStatus: () => Promise<void>;
-    refreshStoragePermissionStatus: () => Promise<void>;
-    refreshCameraPermissionStatus: () => Promise<void>;
-    refreshWakeLockPermissionStatus: () => Promise<void>;
-    refreshFileSystemPermissionStatus: () => Promise<void>;
-    refreshPermissionStatuses: () => Promise<void>;
-    requestLocationPermission: (onGranted?: () => void) => Promise<void>;
-    requestNotificationPermission: () => Promise<void>;
-    requestOrientationPermission: () => Promise<void>;
-    requestStoragePermission: () => Promise<void>;
-    requestCameraPermission: () => Promise<void>;
-    requestWakeLockPermission: () => Promise<void>;
-    requestFileSystemPermission: () => Promise<void>;
-    initializePermissionSubscriptions: (onLocationGranted?: () => void) => Promise<void>;
-    releaseWakeLockSentinel: () => Promise<void>;
-}>;
-export {};

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

@@ -1,14 +0,0 @@
-import { type IconHydrateResult } from '../base/icon.ts';
-import type Atlas from './atlas.ts';
-export type { IconHydrateResult };
-export default class AtlasIcons {
-    atlas: Atlas;
-    constructor(atlas: Atlas);
-    hydrate(opts?: {
-        force?: boolean;
-    }): Promise<IconHydrateResult>;
-    addIconset(uid: string, opts?: {
-        force?: boolean;
-    }): Promise<boolean>;
-    removeIconset(uid: string): Promise<boolean>;
-}