@tak-ps/cloudtak 13.42.0 → 13.44.0

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

@@ -23,7 +23,8 @@ export declare enum WorkerMessageType {
     Profile_Update = "cloudtak:profile:update",
     Sync_Start = "cloudtak:sync:start",
     Sync_Complete = "cloudtak:sync:complete",
-    Sync_Update = "cloudtak:sync:update"
+    Sync_Update = "cloudtak:sync:update",
+    Iconset_Change = "cloudtak:iconset:change"
 }
 export type WorkerMessage = {
     type: WorkerMessageType;

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

@@ -1,11 +1,10 @@
 import { type DBIcon } from '../database.ts';
 export interface IconHydrateResult {
-    /** Iconsets that were added or refreshed during the diff. */
-    changed: string[];
+    added: string[];
+    /** Iconsets refetched because the remote `version`/`updated` differs. */
+    updated: 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>;
@@ -20,24 +19,22 @@ export default class Icon {
     static list(iconsetUid: string): Promise<DBIcon[]>;
     /**
      * 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.
+     * iconsets that are new or whose `version`/`updated` differs. Concurrent
+     * calls coalesce onto the in-flight diff.
      */
-    static hydrate(opts: {
-        token: string;
-        force?: boolean;
-    }): Promise<IconHydrateResult>;
+    static hydrate(): 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;
+    static addIconset(uid: string, opts?: {
         force?: boolean;
     }): Promise<boolean>;
+    /**
+     * Fetch a single `<iconsetUid>:<path>` icon directly from the API.
+     * Used as the network fallback when an icon isn't cached in Dexie yet
+     * (e.g. an overlay referencing an iconset that hasn't synced). Returns
+     * undefined when the icon can't be retrieved.
+     */
+    static fetchRemote(id: string): Promise<Blob | undefined>;
 }

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

@@ -139,6 +139,7 @@ export declare const useMapStore: import("pinia").StoreDefinition<"cloudtak", {
     reconcileOverlays: () => Promise<void>;
     updateIconRotation: (enabled: boolean) => void;
     updateDistanceUnit: (unit: string) => void;
+    updateBackground: () => void;
     updateAttribution: () => Promise<void>;
     /**
      * Determine if the feature is from the CoT store or a clicked VT feature

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

@@ -1,22 +1,23 @@
 import type { Map as MapLibreMap } from 'maplibre-gl';
-import { type DBIconset } from '../../database.ts';
 export default class IconManager {
-    private cache;
     private map;
-    private loggedMissingImageIds;
+    private inflight;
     private loggedErrors;
-    private inflightImage;
     private fallbackBitmap;
-    private requestedIconsetImageIds;
+    /**
+     * Image ids registered with the generic fallback bitmap (or recolored
+     * from one) because the real icon couldn't be loaded at resolve time.
+     * These are retried once the owning iconset lands in Dexie.
+     */
+    private fallbackIds;
     constructor(map: MapLibreMap);
     private logWarnOnce;
     private logErrorOnce;
-    static from(uid: string): Promise<DBIconset | undefined>;
     /**
-     * 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.
+     * MapLibre style sprite descriptor. Iconset icons are served on demand
+     * from Dexie via the missing style image resolver; 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
@@ -34,34 +35,41 @@ export default class IconManager {
      */
     static registerSpriteProtocol(): void;
     /**
-     * Hydrate the local Dexie icon cache from the API.
+     * Missing style image resolver entry point. MapLibre awaits the returned
+     * promise before rendering the requesting tile, so the image must be
+     * registered by the time it settles.
      *
-     * This method also handles main-thread concerns like purging stale MapLibre
-     * images when the local Dexie cache changes.
+     * Must never reject: a rejected resolver promise fails the whole image
+     * batch for the tile, so failures are logged and the id is left
+     * unresolved (MapLibre then fires the legacy `styleimagemissing` event
+     * and renders the feature without an icon).
      */
-    hydrate(opts?: {
-        force?: boolean;
-    }): Promise<void>;
+    resolve(id: string): Promise<void>;
+    private resolveImage;
     /**
-     * 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.
+     * Resolve an `<iconsetUid>:<path>` image id from Dexie, falling back to
+     * fetching the single icon from the API (for iconsets that haven't been
+     * hydrated locally) and finally to a generic point icon.
      */
-    addIconset(uid: string, opts?: {
-        force?: boolean;
-    }): Promise<void>;
-    removeIconset(uid: string): Promise<void>;
-    deleteIconset(uid: string): Promise<void>;
-    private applyHydrateResult;
-    private purgeMapImagesForIconset;
-    onStyleImageMissing(e: {
-        id: string;
-    }): Promise<void>;
+    private loadIconsetImage;
+    private addImage;
     /**
-     * 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.
+     * Remove all MapLibre images belonging to the given iconsets (including
+     * colored variants, whose ids share the `<uid>:` prefix). MapLibre
+     * re-requests removed images through the missing style image resolver
+     * the next time a feature needs them, so purging is all that's required
+     * to pick up refreshed Dexie content.
      */
-    private loadIconsetImage;
+    purgeIconsets(uids: string[]): void;
+    /**
+     * Retry fallback placeholder images belonging to the given iconsets.
+     * Used when an iconset is cached in Dexie for the first time: icons that
+     * already resolved successfully (via the network fallback) are identical
+     * to the newly cached rows and are left untouched - only ids stuck on
+     * the generic fallback bitmap are dropped so they re-resolve.
+     */
+    purgeFallbacks(uids: string[]): void;
+    deleteIconset(uid: string): Promise<void>;
     /**
      * Decode an iconset blob into an `ImageBitmap`.
      *
@@ -80,18 +88,11 @@ export default class IconManager {
      * set explicitly before rasterizing.
      */
     private decodeSvgBlob;
-    private reloadIconsetImages;
-    private reloadRequestedIconsetImage;
-    private removeRequestedImagesForIconset;
     private getFallbackBitmap;
     /**
-     * Get or create a colored version of an icon
-     */
-    getColoredIcon(iconId: string, color: string): string;
-    /**
-     * Create a colored version of an icon and add it to the map
+     * Register a recolored copy of an already-registered base image.
      */
-    private createColoredIcon;
+    private addColoredImage;
     /**
      * Replace white/light pixels with the target color
      */

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

@@ -52,6 +52,28 @@ export default class AtlasSync {
     event(event: SyncEvent): Promise<void>;
     destroy(): void;
     private runFullSync;
+    /**
+     * Hydrate the Dexie icon cache (iconset metadata, icon blobs and built-in
+     * sprites) from the API. All bulk icon hydration flows through here; the
+     * main thread only loads individual images into MapLibre on demand via
+     * the missing style image resolver (see stores/modules/icons.ts).
+     */
+    syncIcons(): Promise<void>;
+    /**
+     * Refresh a single iconset in Dexie. Used by the UI after mutating an
+     * iconset (icon create/update/delete) since the server does not yet
+     * broadcast iconset sync events.
+     */
+    syncIconset(uid: string): Promise<void>;
+    /**
+     * Tell the main thread how Dexie iconset content changed. `purge` lists
+     * iconsets whose icon blobs are actually different (version bump, removal
+     * or explicit mutation) so their MapLibre images must be dropped and
+     * re-resolved on demand. `added` lists iconsets cached for the first time
+     * - their content matches what the network fallback already served, so
+     * only fallback placeholder images need repair.
+     */
+    private notifyIconsetChange;
     private flush;
     private syncEvent;
     /**

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@tak-ps/cloudtak",
     "type": "module",
-    "version": "13.42.0",
+    "version": "13.44.0",
     "types": "dist/types/plugin.d.ts",
     "files": [
         "dist/types"
@@ -84,7 +84,7 @@
         "hls.js": "^1.6.5",
         "imask": "^6.0.0",
         "jsonata": "^2.0.4",
-        "maplibre-gl": "v6.0.0-20",
+        "maplibre-gl": "v6.0.0-21",
         "milsymbol": "^3.0.2",
         "openapi-fetch": "^0.17.0",
         "phone": "^3.1.59",