@orbat-mapper/tactical-draw-adapter-maplibre 0.3.22 → 0.4.0

package/dist/index.d.mts

@@ -1,8 +1,115 @@
-import { BaseMapAdapter, EditPointerDriver, FeatureGroup, IconResource, LayerId, MapCursor, NativeEventEntry, PickHandler, PickOptions, PixelCoordinate, StyleOptions } from "@orbat-mapper/tactical-draw";
 import * as maplibregl from "maplibre-gl";
-import { DataDrivenPropertyValueSpecification } from "maplibre-gl";
+import { CustomLayerInterface, CustomRenderMethodInput, DataDrivenPropertyValueSpecification, Map as Map$1 } from "maplibre-gl";
+import { BaseMapAdapter, EditPointerDriver, FeatureGroup, IconResource, LayerId, MapCursor, NativeEventEntry, PickHandler, PickOptions, PinFootprint, PinPresentationCapability, PinPresentationStatusEvent, PinRender, PixelCoordinate, StyleOptions } from "@orbat-mapper/tactical-draw";
 import { Feature, Position } from "geojson";
 
+//#region src/pin-atlas.d.ts
+interface AtlasEntry {
+  page: number;
+  uv: [number, number, number, number];
+}
+/** Paged shelves avoid one texture per symbol and do not reorder draw instances. */
+declare class PinAtlas {
+  readonly size: number;
+  readonly entries: Map<string, AtlasEntry>;
+  readonly pages: HTMLCanvasElement[];
+  private x;
+  private y;
+  private rowHeight;
+  constructor(size?: number);
+  add(resource: IconResource, scale: number, image: CanvasImageSource): void;
+}
+//#endregion
+//#region src/pin-resources.d.ts
+interface PinResourceSnapshot {
+  atlas: PinAtlas;
+  textures: WebGLTexture[];
+}
+/** One atlas roster per logical layer, shared across ordinary-graphic barriers. */
+declare class PinResources {
+  private map;
+  revision: number;
+  private key;
+  private resources;
+  private pending?;
+  private textures;
+  private context?;
+  private disposed;
+  private needsDepth;
+  private invalidateDepth;
+  private restore;
+  constructor(map: Map$1);
+  setRoster(pins: readonly PinRender[]): void;
+  load(gl: WebGL2RenderingContext): Promise<PinResourceSnapshot | undefined>;
+  dispose(): void;
+}
+//#endregion
+//#region src/pin-layer.d.ts
+/** Batched GPU pin rendering. Adjacent groups only; instance order is paint order. */
+declare class PinLayer implements CustomLayerInterface {
+  readonly id: string;
+  private readonly resources;
+  private readonly onStatus?;
+  readonly type = "custom";
+  readonly renderingMode = "2d";
+  private map;
+  private gl;
+  private program?;
+  private uniforms?;
+  private buffer?;
+  private vao?;
+  private textures;
+  private atlas;
+  private pins;
+  private ranges;
+  private version;
+  private resourceRevision;
+  private needsDepth;
+  private elevationCache;
+  private pendingElevation;
+  private removed;
+  private ready;
+  private dirty;
+  private changedPins;
+  private slices;
+  private origin;
+  private elevations;
+  private projection;
+  private matrix;
+  private frame?;
+  private pickFramebuffer?;
+  private pickTexture?;
+  private pickSize;
+  private status;
+  private refreshTerrain;
+  private elevation;
+  has(id: string): boolean;
+  constructor(id: string, resources: PinResources, onStatus?: ((event: PinPresentationStatusEvent) => void) | undefined);
+  private restoreContext;
+  private onRemoveListeners;
+  onAdd(map: Map$1, context: WebGLRenderingContext | WebGL2RenderingContext): void;
+  /** Uniform locations are fixed once a program is linked; resolved here, not per draw. */
+  private resolveUniforms;
+  private setStatus;
+  getStatus(id?: string): PinPresentationCapability;
+  setPins(pins: readonly PinRender[], changedIndices?: readonly number[]): Promise<void>;
+  private buildPin;
+  private rebuild;
+  render(context: WebGLRenderingContext | WebGL2RenderingContext, input: CustomRenderMethodInput): void;
+  private draw;
+  /** On-demand GPU pick shares the visual shader including alpha and terrain mask. */
+  pick(pixel: PixelCoordinate, tolerance?: number): string | null;
+  /**
+   * Shared Mercator/globe clip-space projection converted to container pixels. Callers
+   * differ in elevation source and in whether/where a screen-mode lift offset applies
+   * — those stay at the call site, as they aren't part of the shared matrix math.
+   */
+  private projectToPixel;
+  footprint(id: string): PinFootprint | null;
+  moveFromPixel(id: string, attachment: PixelCoordinate): number[] | null;
+  onRemove(_map: Map$1, context: WebGLRenderingContext | WebGL2RenderingContext): void;
+}
+//#endregion
 //#region src/text-sizing.d.ts
 type SizeExpression = DataDrivenPropertyValueSpecification<number>;
 interface TextSizing {
@@ -14,6 +121,7 @@ interface TextSizing {
 //#endregion
 //#region src/ml-adapter.d.ts
 interface MapLibreLayerHandle {
+  pinResources?: PinResources;
   sourceId: string;
   /** MapLibre layer ids created for this logical layer (fill, line, circle, symbol) */
   mlLayerIds: string[];
@@ -21,9 +129,20 @@ interface MapLibreLayerHandle {
   groupOrder: string[];
   nextGroupBundleId: number;
   style?: StyleOptions;
+  /**
+   * The flattened pin batch last passed to `pinResources.setRoster`. Producers
+   * memoize `PinRender` identity when nothing changed (mirrored by the
+   * per-bundle `pinSignature` diff below), so an identical batch by reference
+   * means `setRoster`'s own Map-rebuild/sort/stringify would be a no-op —
+   * skip calling it at all rather than pay for that every drag frame.
+   */
+  lastPinBatch?: readonly PinRender[];
 }
 type PaintChannel = "fill" | "fill-pattern" | "line" | "circle" | "icon" | "text";
 interface MapLibreGroupBundle {
+  pinLayer?: PinLayer;
+  pinSignature?: readonly PinRender[];
+  pinResourceRevision?: number;
   readonly sourceId: string;
   readonly paintSurfaces: Map<string, MapLibrePaintSurface>;
   paintOrder: string[];
@@ -87,7 +206,7 @@ declare class MapLibreAdapter extends BaseMapAdapter<MapLibreLayerHandle, MapLib
   private toContinuousLng;
   protected createLayer(layerId: LayerId, style?: StyleOptions): MapLibreLayerHandle;
   protected destroyLayer(handle: MapLibreLayerHandle): void;
-  protected applyFeatureGroups(layerId: LayerId, groups: readonly FeatureGroup[]): void;
+  protected applyFeatureGroups(layerId: LayerId, input: readonly FeatureGroup[]): void;
   private createGroupBundle;
   private destroyGroupBundle;
   private reconcileGroupImageOverlays;
@@ -144,6 +263,25 @@ declare class MapLibreAdapter extends BaseMapAdapter<MapLibreLayerHandle, MapLib
   getZoom(): number | undefined;
   getBearing(): number;
   onPick(layerId: LayerId, handler: PickHandler, opts?: PickOptions): () => void;
+  private readonly pinStatusListeners;
+  private readonly emitPinStatus;
+  onPinPresentationStatusChange(handler: (event: PinPresentationStatusEvent) => void): () => void;
+  /**
+   * Pin layers across this adapter's group bundles.
+   * - With no `handle`: every layer's bundles, in bundle-map (creation)
+   *   order — fine for id-based lookups where only "does one match" matters.
+   * - With `handle`: only that layer's bundles, walked topmost-first (reverse
+   *   paint order) — required for hit-testing, where the first hit must be
+   *   the visually topmost pin.
+   */
+  private pinLayers;
+  /** First non-null/undefined result of `fn` across all pin layers, else null. */
+  private findPinLayer;
+  getPinPresentationCapability(graphicId?: string): PinPresentationCapability;
+  getPinFootprint(id: string): PinFootprint | null;
+  movePinFromPixel(id: string, attachment: PixelCoordinate): Position | null;
+  private pinHit;
+  pickPin(id: string, pixel: PixelCoordinate, tolerance: number): boolean;
   setGlobeMode(enabled: boolean): void;
 }
 //#endregion