@tak-ps/cloudtak 12.127.3 → 12.129.0

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

@@ -1,7 +1,13 @@
 import Dexie, { type EntityTable } from 'dexie';
 import type { Feature, GroupChannel, Mission, MissionRole, MissionChange, MissionLog, Contact, Server } from '../types.ts';
 export interface DBIcon {
+    /** Maplibre image id, e.g. "<iconsetUid>:<icon-path-without-extension>" */
     name: string;
+    iconset: string;
+    path: string;
+    type2525b: string | null;
+    updated: string;
+    data: Blob;
 }
 export interface DBFeature {
     id: string;
@@ -164,9 +170,19 @@ export interface DBCache {
     key: string;
     updated: number;
 }
+export interface DBSprite {
+    /** Sprite id, e.g. 'default' */
+    id: string;
+    updated: number;
+    /** MapLibre sprite layout JSON */
+    json: Record<string, unknown>;
+    /** Spritesheet PNG */
+    image: Blob;
+}
 export type DatabaseType = Dexie & {
     icon: EntityTable<DBIcon, 'name'>;
     iconset: EntityTable<DBIconset, 'uid'>;
+    sprite: EntityTable<DBSprite, 'id'>;
     group: EntityTable<GroupChannel, 'name'>;
     video: EntityTable<DBVideo, 'id'>;
     filter: EntityTable<DBFilter, 'id'>;

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

@@ -1,4 +1,39 @@
+import { type DBIcon } from './database.ts';
+export interface IconHydrateResult {
+    /** Iconsets that were added or refreshed during the diff. */
+    changed: string[];
+    /** Iconsets that were removed locally because they no longer exist remotely. */
+    removed: string[];
+    /** True when the diff was skipped because the local cache was fresh. */
+    skipped: boolean;
+}
 export default class Icon {
     static has(icon: string): Promise<boolean>;
-    static populate(icons: string[]): Promise<void>;
+    static get(icon: string): Promise<DBIcon | undefined>;
+    /**
+     * Diff the server iconset list against Dexie and refetch icons for any
+     * iconsets that are new or whose `version`/`updated` differs.
+     *
+     * Behaviour:
+     *  - When Dexie already has data and was refreshed recently the call
+     *    returns immediately (`skipped: true`) and the diff runs in the
+     *    background; the next call will see the updated cache marker.
+     *  - When `force` is true the diff always runs inline.
+     */
+    static hydrate(opts: {
+        token: string;
+        force?: boolean;
+    }): Promise<IconHydrateResult>;
+    /**
+     * Ensure a single iconset is present in Dexie. Returns true if Dexie was
+     * actually updated so the caller can purge stale map images.
+     */
+    static addIconset(uid: string, opts: {
+        token: string;
+    }): 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/overlay.d.ts

@@ -13,6 +13,7 @@ export default class Overlay {
     }>;
     _error?: Error;
     _loaded: boolean;
+    loading: boolean;
     id: number;
     name: string;
     active: boolean;

package/dist/types/src/components/CloudTAK/Menu/Basemaps/TypeSelectorBase.vue.d.ts

@@ -12,9 +12,9 @@ type __VLS_ModelProps = {
     'editing': EditingBasemap;
 };
 type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
-declare var __VLS_77: {};
+declare var __VLS_96: {};
 type __VLS_Slots = {} & {
-    advanced?: (props: typeof __VLS_77) => any;
+    advanced?: (props: typeof __VLS_96) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "change-type": () => any;

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

@@ -1,24 +1,68 @@
 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 '../../base/database.ts';
 export default class IconManager {
     private cache;
     private map;
+    private worker;
     private loggedMissingImageIds;
     private loggedErrors;
-    constructor(map: MapLibreMap);
+    private inflightImage;
+    private fallbackBitmap;
+    constructor(map: MapLibreMap, worker: Comlink.Remote<Atlas>);
     private logWarnOnce;
     private logErrorOnce;
     static from(uid: string): Promise<DBIconset | undefined>;
-    addIconset(uid: string): Promise<void>;
-    removeIconset(uid: string): Promise<void>;
-    static sprites(): Promise<Array<{
+    /**
+     * MapLibre style sprite descriptor. The custom iconset spritesheets are no
+     * longer loaded here; icons are served on demand from Dexie via
+     * `onStyleImageMissing`. Only the small built-in `default` sprite is loaded
+     * up-front because it provides the CoT-type fallbacks.
+     *
+     * The default sprite itself is also served from the Dexie cache via the
+     * `cloudtak-sprite://` protocol (see `registerSpriteProtocol`) so it
+     * survives offline reloads instead of re-downloading on every page load.
+     */
+    static defaultSprite(): Array<{
         id: string;
         url: string;
-    }>>;
-    updateImages(): Promise<void>;
+    }>;
+    /**
+     * Register the global MapLibre protocol that resolves
+     * `cloudtak-sprite://<id>(@2x)?.(json|png)` requests against the Dexie
+     * `sprite` table, falling back to the API and persisting the response so
+     * subsequent loads are served from disk.
+     */
+    static registerSpriteProtocol(): void;
+    /**
+     * 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.
+     */
+    hydrate(opts?: {
+        force?: boolean;
+    }): Promise<void>;
+    /**
+     * Ensure a single iconset is present in Dexie. Used by overlays that
+     * reference a specific iconset so it is available even if the user-wide
+     * hydrate hasn't completed yet.
+     */
+    addIconset(uid: string): Promise<void>;
+    removeIconset(uid: string): Promise<void>;
+    private applyHydrateResult;
+    private purgeMapImagesForIconset;
     onStyleImageMissing(e: {
         id: string;
     }): Promise<void>;
+    /**
+     * Resolve an `<iconsetUid>:<path>` image id from Dexie and register it with
+     * MapLibre. Falls back to a generic point icon when the icon isn't cached.
+     */
+    private loadIconsetImage;
+    private getFallbackBitmap;
     /**
      * Get or create a colored version of an icon
      */

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

@@ -0,0 +1,12 @@
+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): Promise<boolean>;
+    removeIconset(uid: string): Promise<boolean>;
+}

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

@@ -3,6 +3,7 @@ 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;
@@ -11,6 +12,7 @@ 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": "12.127.3",
+    "version": "12.129.0",
     "types": "dist/types/plugin.d.ts",
     "files": [
         "dist/types"
@@ -112,4 +112,4 @@
         "> 1%",
         "last 2 versions"
     ]
-}
+}