ts-maps 0.3.2 → 0.3.4

package/dist/core-map/geo/polygonClip.d.ts

@@ -0,0 +1,75 @@
+/** Everything covered by either. */
+export declare function union(subject: MultiPolygon, clip: MultiPolygon): MultiPolygon;
+/** Only what both cover. */
+export declare function intersection(subject: MultiPolygon, clip: MultiPolygon): MultiPolygon;
+/** What `subject` covers and `clip` does not — the shape of a territory steal. */
+export declare function difference(subject: MultiPolygon, clip: MultiPolygon): MultiPolygon;
+/** Covered by one but not both. */
+export declare function xor(subject: MultiPolygon, clip: MultiPolygon): MultiPolygon;
+/** Do these overlap at all? Cheaper than measuring the intersection. */
+export declare function intersects(subject: MultiPolygon, clip: MultiPolygon): boolean;
+/** Is a `[lng, lat]` position inside this multipolygon? */
+export declare function contains(multi: MultiPolygon, point: Position): boolean;
+declare const INTERSECTION: 0;
+declare const UNION: 1;
+declare const DIFFERENCE: 2;
+declare const XOR: 3;
+// Boolean operations on polygons: union, intersection, difference, xor.
+//
+// A territory game runs on these. Finishing a lap unions the new loop into
+// whatever the player already held; running through a rival's ground subtracts
+// it from theirs. Both operations happen constantly and on shapes that share
+// edges — two territories that grew against each other are exactly coincident
+// along the border between them — so the naive clippers are not an option.
+// Greiner–Hormann, for instance, is short and readable and falls apart on the
+// shared-edge case, which here is not an edge case but the normal one.
+//
+// This is the Martínez–Rueda–Feito sweep-line algorithm, which handles
+// coincident edges, self-touching contours and holes as part of its design
+// rather than as patches. The sweep is faithful to the paper. Assembling the
+// output contours afterwards is done differently: rather than tracking
+// exterior/interior depth inside the sweep, result edges are walked into rings
+// and nesting is worked out by containment at the end. That is a slower step
+// and a far easier one to reason about — and being able to reason about it
+// matters when it decides who owns what.
+export type Position = number[];
+export type Ring = Position[];
+export type Polygon = Ring[];
+export type MultiPolygon = Polygon[];
+declare type Operation = typeof INTERSECTION | typeof UNION | typeof DIFFERENCE | typeof XOR;
+declare class SweepEvent {
+  point: Position;
+  left: boolean;
+  otherEvent: SweepEvent;
+  isSubject: boolean;
+  type: number;
+  inOut: boolean;
+  otherInOut: boolean;
+  inResult: boolean;
+  contourId: number;
+  constructor(point: Position, left: boolean, otherEvent: SweepEvent | null, isSubject: boolean, type?: unknown);
+  isBelow(p: Position): boolean;
+  isAbove(p: Position): boolean;
+  isVertical(): boolean;
+}
+/** A binary heap, so the queue can take the events division produces. */
+declare class EventQueue {
+  get length(): number;
+  push(event: SweepEvent): void;
+  pop(): SweepEvent | undefined;
+}
+/**
+ * The sweep line status: segments currently crossed, ordered bottom to top.
+ *
+ * A sorted array rather than a balanced tree. Insertion is linear, which makes
+ * the sweep quadratic in the worst case — acceptable here, where the shapes are
+ * territories with hundreds of vertices rather than coastlines with millions,
+ * and worth it for a structure whose behaviour is obvious when a result looks
+ * wrong.
+ */
+declare class SweepStatus {
+  insert(event: SweepEvent): number;
+  remove(event: SweepEvent): void;
+  indexOf(event: SweepEvent): number;
+  at(index: number): SweepEvent | null;
+}

package/dist/core-map/geo/validate.d.ts

@@ -0,0 +1,54 @@
+import type { MultiPolygon, Ring } from './polygonClip';
+/**
+ * Check a ring is something that can be claimed.
+ *
+ * Throws rather than returning a flag, because every caller's correct response
+ * to unusable geometry is to stop, and a boolean invites carrying on.
+ */
+export declare function validateRing(ring: Ring): void;
+/**
+ * Make a ring's longitudes continuous.
+ *
+ * A run crossing the antimeridian is recorded as longitudes that jump from
+ * 179.99 to -179.99, and every consumer of that ring — area, the clipper,
+ * anything measuring an edge — reads the jump as a segment spanning the globe.
+ * Carrying the winding forward instead produces longitudes outside the usual
+ * range but geometry that means what the runner did.
+ *
+ * A ring not near the antimeridian is returned untouched, so this costs a scan
+ * and nothing else in the overwhelmingly common case.
+ */
+export declare function unwrapRing(ring: Ring): Ring;
+/**
+ * Split a self-crossing ring into the simple loops it is made of.
+ *
+ * Walking the ring and cutting it at each crossing is what separates a figure
+ * of eight into its two lobes. The crossing point is computed once and used as
+ * a vertex of both loops, which is the reason to do it this way rather than by
+ * unioning the shape with itself: the sweep would compute that point twice,
+ * from two different pairs of segments, and at GPS precision the two answers
+ * differ in the last bits — enough for a lobe to be dropped.
+ */
+export declare function splitSelfIntersecting(ring: Ring): Ring[];
+/**
+ * Resolve a ring that crosses itself into polygons that do not.
+ *
+ * A figure of eight has a signed area of nearly zero — its lobes have opposite
+ * winding and cancel — so measuring it directly says the runner enclosed
+ * nothing. Both lobes were run around, so both should count.
+ */
+export declare function resolveSelfIntersections(ring: Ring): MultiPolygon;
+/** Does any pair of non-adjacent segments in this ring cross? */
+export declare function selfIntersects(ring: Ring): boolean;
+/**
+ * Everything above, in the order a claim needs it.
+ *
+ * Validate, then unwrap, then resolve — each step assumes the previous one has
+ * run, and repairing geometry that has not been checked is how a NaN ends up
+ * inside a polygon instead of inside an error message.
+ */
+export declare function prepareClaim(ring: Ring): MultiPolygon;
+/** Thrown for geometry that cannot be repaired into a claim. */
+export declare class InvalidGeometryError extends Error {
+  constructor(message: string);
+}

package/dist/core-map/index.d.ts

@@ -1,7 +1,8 @@
-import { AttributionControl, Control, LayersControl, LocateControl, ScaleControl, ZoomControl } from './control/index';
+import { AttributionControl, Control, FullscreenControl, GeocoderControl, LayersControl, LocateControl, NavigationControl, ScaleControl, ZoomControl } from './control/index';
 import { Circle, CircleMarker, DivIcon, FeatureGroup, GeoJSON, GridLayer, HeatmapLayer, RasterDEMLayer, Icon, ImageOverlay, LayerGroup, Marker, Polygon, Polyline, Popup, Rectangle, SVGOverlay, TileLayer, Tooltip, VectorTileMapLayer, VideoOverlay, WMSTileLayer } from './layer/index';
 import { TsMap } from './map/index';
 import * as services from './services/index';
+import * as styles from './styles/index';
 export type { CircleOptions as WebGLCircleOptions, GLContextOptions, LineOptions as WebGLLineOptions, Mat4 } from './renderer/webgl/index';
 /**
 * ts - maps — a modern TypeScript interactive map library.
@@ -41,6 +42,9 @@ export declare const control: Factory < ConstructorParameters < typeof Control>,
   attribution: Factory < ConstructorParameters < typeof AttributionControl>, AttributionControl>
   scale: Factory < ConstructorParameters < typeof ScaleControl>, ScaleControl>
   locate: Factory < ConstructorParameters < typeof LocateControl>, LocateControl>
+  geocoder: Factory < ConstructorParameters < typeof GeocoderControl>, GeocoderControl>
+  navigation: Factory < ConstructorParameters < typeof NavigationControl>, NavigationControl>
+  fullscreen: Factory < ConstructorParameters < typeof FullscreenControl>, FullscreenControl>
 };
 // Default namespace object grouping all public exports.
 declare const tsMap: Record<string, unknown>;
@@ -50,11 +54,12 @@ export * from './control/index';
 export * from './core/index';
 export * from './dom/index';
 export * from './geometry/index';
+export * from './game/index';
 export * from './geo/index';
 export * from './layer/index';
 export * from './map/index';
 export * from './storage/index';
 export { earcut, flatten, deviation } from './geometry/earcut';
 export { WebGLTileRenderer, WebGLUnsupportedError } from './renderer/webgl/index';
-export { services };
+export { services, styles };
 export default tsMap;

package/dist/core-map/layer/GeoJSONTileSource.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Adapts a `GeoJSONClusterSource` to the same tile shape.
+ *
+ * The cluster source already answers per tile, but in GeoJSON coordinates — it
+ * was built to feed markers, not a renderer. This projects its points into
+ * tile-local extent space so clustered data can be painted by ordinary style
+ * layers, with `point_count` available to expressions exactly as in Mapbox.
+ */
+export declare function clusterTileSource(cluster: { getTile: (z: number, x: number, y: number) => { features: Array<{ geometry: { coordinates: [number, number] }, properties: Record<string, unknown>, id?: number }> } | null }, layerName?: string): { getTile: (z: number, x: number, y: number) => { layers: Record<string, LocalLayer> } | null };
+export declare interface GeoJSONTileSourceOptions {
+  layerName?: string
+  buffer?: number
+  maxZoom?: number
+}
+declare interface IndexedFeature {
+  type: 1 | 2 | 3
+  id?: number | string
+  properties: Record<string, unknown>
+  rings: Ring[]
+  bbox: [number, number, number, number]
+}
+declare type Ring = Array<{ x: number, y: number }>;
+/** A decoded-tile-shaped feature, duck-typed to `VectorTileFeature`. */
+declare class LocalFeature {
+  type: 1 | 2 | 3;
+  id?: number | string;
+  properties: Record<string, unknown>;
+  extent: number;
+  _rings: Ring[];
+  constructor(source: IndexedFeature, rings: Ring[]);
+  loadGeometry(): Ring[];
+  bbox(): [number, number, number, number];
+}
+declare class LocalLayer {
+  name: string;
+  extent: number;
+  length: number;
+  _features: LocalFeature[];
+  constructor(name: string, features: LocalFeature[]);
+  feature(index: number): LocalFeature;
+}
+export declare class GeoJSONTileSource {
+  _features: IndexedFeature[];
+  _layerName: string;
+  _buffer: number;
+  constructor(data?: unknown, options?: GeoJSONTileSourceOptions);
+  setData(data: unknown): this;
+  get length(): number;
+  getTile(z: number, x: number, y: number): { layers: Record<string, LocalLayer> } | null;
+}

package/dist/core-map/layer/RunTrailLayer.d.ts

@@ -0,0 +1,35 @@
+import { Layer } from './Layer';
+import type { Position } from '../geo/polygonClip';
+export declare function runTrailLayer(options?: RunTrailLayerOptions): RunTrailLayer;
+export declare interface RunTrailLayerOptions {
+  color?: string
+  weight?: number
+  opacity?: number
+  showPotential?: boolean
+  potentialOpacity?: number
+  showHead?: boolean
+  pulse?: boolean
+  pane?: string
+  attribution?: string
+}
+export declare class RunTrailLayer extends Layer {
+  _canvas?: HTMLCanvasElement;
+  _ctx?: CanvasRenderingContext2D | null;
+  _track: Position[];
+  _frame?: number;
+  _ratio: number;
+  initialize(options?: RunTrailLayerOptions): void;
+  setTrack(track: Position[]): this;
+  addPoint(position: Position): this;
+  clear(): this;
+  get track(): Position[];
+  redraw(): this;
+  onAdd(_map: any): void;
+  onRemove(_map: any): void;
+  getEvents(): Record<string, any>;
+  _pixelRatio(): number;
+  _resize(): void;
+  _draw(): void;
+  _drawPotential(ctx: CanvasRenderingContext2D, points: Array<{ x: number, y: number }>, color: string, alpha: number): void;
+  _drawHead(ctx: CanvasRenderingContext2D, point: { x: number, y: number }, color: string, pulse: boolean): void;
+}

package/dist/core-map/layer/TerritoryLayer.d.ts

@@ -0,0 +1,62 @@
+import { Layer } from './Layer';
+import type { CaptureResult, TerritoryStore } from '../game/TerritoryStore';
+import type { MultiPolygon, Position } from '../geo/polygonClip';
+export declare function territoryLayer(options?: TerritoryLayerOptions): TerritoryLayer;
+export declare interface TerritoryStyle {
+  color?: string
+  fillOpacity?: number
+  weight?: number
+  glow?: boolean
+  hatch?: boolean
+  label?: boolean
+}
+export declare interface TerritoryLayerOptions {
+  store?: TerritoryStore
+  styles?: Record<string, TerritoryStyle>
+  defaultStyle?: TerritoryStyle
+  self?: string
+  captureDuration?: number
+  labelMinZoom?: number
+  units?: 'metric' | 'imperial'
+  pane?: string
+  attribution?: string
+}
+declare interface CaptureAnimation {
+  owner: string
+  ring: Position[]
+  start: number
+  duration: number
+}
+export declare class TerritoryLayer extends Layer {
+  _canvas?: HTMLCanvasElement;
+  _ctx?: CanvasRenderingContext2D | null;
+  _store?: TerritoryStore;
+  _manual: Map<string, MultiPolygon>;
+  _animations: CaptureAnimation[];
+  _frame?: number;
+  _assigned: Map<string, string>;
+  _ratio: number;
+  _onStoreChange?: () => void;
+  _onStoreCapture?: (result: CaptureResult) => void;
+  initialize(options?: TerritoryLayerOptions): void;
+  setStore(store: TerritoryStore): this;
+  setTerritory(owner: string, territory: MultiPolygon): this;
+  setOwnerStyle(owner: string, style: TerritoryStyle): this;
+  animateCapture(result: { owner: string, ring: Position[] }): this;
+  colorFor(owner: string): string;
+  redraw(): this;
+  onAdd(_map: any): void;
+  onRemove(_map: any): void;
+  getEvents(): Record<string, any>;
+  ownerAtContainerPoint(point: { x: number, y: number }): string | null;
+  _detachStore(): void;
+  _pixelRatio(): number;
+  _resize(): void;
+  _territories(): Array<[string, MultiPolygon]>;
+  _draw(): void;
+  _styleFor(owner: string): Required<TerritoryStyle>;
+  _drawTerritory(ctx: CanvasRenderingContext2D, owner: string, territory: MultiPolygon, project: (p: Position) => { x: number, y: number }): void;
+  _drawHatch(ctx: CanvasRenderingContext2D, color: string): void;
+  _drawLabels(ctx: CanvasRenderingContext2D, territory: MultiPolygon, color: string, project: (p: Position) => { x: number, y: number }): void;
+  _drawCaptures(ctx: CanvasRenderingContext2D, project: (p: Position) => { x: number, y: number }): void;
+}

package/dist/core-map/layer/index.d.ts

@@ -1,11 +1,17 @@
+export type { GeoJSONTileSourceOptions } from './GeoJSONTileSource';
 export type { ClusterOptions, ClusterPoint } from './GeoJSONClusterSource';
 export type { HeatmapLayerOptions, HeatmapPoint } from './HeatmapLayer';
+export type { TerritoryLayerOptions, TerritoryStyle } from './TerritoryLayer';
+export type { RunTrailLayerOptions } from './RunTrailLayer';
 export { BlanketOverlay } from './BlanketOverlay';
 export { DivOverlay } from './DivOverlay';
 export { FeatureGroup } from './FeatureGroup';
 export { GeoJSON } from './GeoJSON';
 export { GeoJSONClusterSource, KDBush } from './GeoJSONClusterSource';
+export { GeoJSONTileSource } from './GeoJSONTileSource';
 export { HeatmapLayer } from './HeatmapLayer';
+export { TerritoryLayer, territoryLayer } from './TerritoryLayer';
+export { RunTrailLayer, runTrailLayer } from './RunTrailLayer';
 export { ImageOverlay } from './ImageOverlay';
 export { Layer } from './Layer';
 export { LayerGroup } from './LayerGroup';

package/dist/core-map/layer/tile/RasterDEMLayer.d.ts

@@ -19,6 +19,10 @@ export declare interface RasterDEMLayerOptions {
   tileSize?: number
   minZoom?: number
   maxZoom?: number
+  minNativeZoom?: number
+  maxNativeZoom?: number
+  className?: string
+  zIndex?: number
   exaggeration?: number
   azimuth?: number
   altitude?: number

package/dist/core-map/layer/tile/VectorTileMapLayer.d.ts

@@ -1,22 +1,33 @@
+import { CollisionIndex } from '../../symbols/CollisionIndex';
 import { GlyphAtlas } from '../../symbols/GlyphAtlas';
 import { GridLayer } from './GridLayer';
 import { IconAtlas } from '../../symbols/IconAtlas';
 import { RTree } from '../../geometry/RTree';
+import { SymbolOverlay } from '../../symbols/SymbolOverlay';
 import { TileCache } from '../../storage/index';
-import { VectorTile } from '../../mvt/VectorTile';
-import { VectorTileFeature } from '../../mvt/VectorTileFeature';
 import { WebGLTileRenderer } from '../../renderer/webgl/WebGLTileRenderer';
+import { WorkerPool } from '../../workers/WorkerPool';
+import type { BBox } from '../../geometry/RTree';
 import type { CompiledExpression } from '../../style-spec/expressions/index';
+import type { DecodedFeature, DecodedTile } from '../../mvt/DecodedTile';
+import type { GlyphProvider } from '../../symbols/GlyphProvider';
 import type { Point } from '../../geometry/Point';
+/** Drop the shared pool. Tests, and teardown in long-lived hosts. */
+export declare function shutdownDecodePool(): Promise<void>;
 // ---------------------------------------------------------------------------
 // Public types
 // ---------------------------------------------------------------------------
 export declare interface VectorTileMapLayerOptions {
-  url: string
+  url?: string
+  localSource?: { getTile: (z: number, x: number, y: number) => any | null }
+  zoomOffset?: number
   subdomains?: string | string[]
   minZoom?: number
   maxZoom?: number
   maxNativeZoom?: number
+  minNativeZoom?: number
+  sourceMaxZoom?: number
+  workers?: boolean | number
   tileSize?: number
   attribution?: string
   pane?: string
@@ -64,6 +75,9 @@ export declare interface VectorTilePaintProperties {
   'text-halo-color'?: string
   'text-halo-width'?: number
   'icon-opacity'?: number
+  'icon-color'?: string
+  'icon-halo-color'?: string
+  'icon-halo-width'?: number
 }
 export declare interface VectorTileLayoutProperties {
   visibility?: 'visible' | 'none'
@@ -75,11 +89,21 @@ export declare interface VectorTileLayoutProperties {
   'icon-image'?: string | unknown
   'icon-size'?: number
   'icon-rotate'?: number
-  'symbol-placement'?: 'point'
+  'symbol-placement'?: 'point' | 'line' | 'line-center'
+  'symbol-spacing'?: number
+  'symbol-sort-key'?: unknown
   'symbol-priority'?: number
+  'text-allow-overlap'?: unknown
+  'icon-allow-overlap'?: unknown
+  'text-ignore-placement'?: unknown
+  'icon-ignore-placement'?: unknown
+  'text-anchor'?: unknown
+  'text-offset'?: unknown
+  'text-rotate'?: unknown
+  'text-max-angle'?: unknown
 }
 export declare interface QueryRenderedFeature {
-  feature: VectorTileFeature
+  feature: DecodedFeature
   layer: VectorTileStyleLayer
   tile: { x: number, y: number, z: number }
 }
@@ -89,7 +113,7 @@ export declare interface QueryRenderedFeaturesOptions {
   layers?: string[]
 }
 export declare interface QuerySourceFeature {
-  feature: VectorTileFeature
+  feature: DecodedFeature
   sourceLayer: string
   tile: { x: number, y: number, z: number }
 }
@@ -103,19 +127,26 @@ declare interface RTreeItem {
 // Internal bookkeeping: alongside each Canvas we track the decoded tile so
 // `queryRenderedFeatures` can re-project hit-tests to tile-local coords.
 declare interface DecodedTileEntry {
+  sourceKey?: string
+  sourcePending?: boolean
   canvas: HTMLCanvasElement
-  tile: VectorTile | null
+  tile: DecodedTile | null
   coords: { x: number, y: number, z: number }
   abort: AbortController
   index: RTree<RTreeItem> | null
   gl: WebGLTileRenderer | null
 }
-// ---------------------------------------------------------------------------
-// Class
-// ---------------------------------------------------------------------------
+/** Extent coordinates to where they currently are on screen. */
+declare type ProjectPoint = (x: number, y: number) => { x: number, y: number } | null;
 export declare class VectorTileMapLayer extends GridLayer {
   _styleLayers: VectorTileStyleLayer[];
   _decodedTiles: Map<HTMLCanvasElement, DecodedTileEntry>;
+  _workersUsable: boolean;
+  _glyphs?: { source: unknown, provider: GlyphProvider };
+  _sourceCache: Map<string, { tile: DecodedTile, index: RTree<RTreeItem>, refs: number }>;
+  _sourcePending: Map<string, { promise: Promise<{ tile: DecodedTile, index: RTree<RTreeItem> }>, refs: number, abort: AbortController }>;
+  _symbolOverlay?: SymbolOverlay;
+  _symbolHandlers?: Record<string, () => void>;
   _featureStateLookup?: (src: string, srcLayer: string, id: number | string) => Record<string, unknown>;
   _sourceId?: string;
   _glyphAtlas?: GlyphAtlas;
@@ -129,17 +160,34 @@ export declare class VectorTileMapLayer extends GridLayer {
   setSourceId(id: string): this;
   _repaintDecodedTiles(): void;
   setStyleLayers(layers: VectorTileStyleLayer[]): this;
+  updateStyleLayers(layers: VectorTileStyleLayer[]): this;
   getStyleLayer(id: string): VectorTileStyleLayer | undefined;
   queryRenderedFeatures(opts?: QueryRenderedFeaturesOptions): QueryRenderedFeature[];
   queryRenderedFeatures(point: Point, opts?: QueryRenderedFeaturesOptions): QueryRenderedFeature[];
   queryRenderedFeatures(pointOrOpts?: Point | QueryRenderedFeaturesOptions, maybeOpts?: QueryRenderedFeaturesOptions): QueryRenderedFeature[];
   querySourceFeatures(opts?: { sourceLayer?: string, filter?: unknown }): QuerySourceFeature[];
+  _pixelRatio(): number;
   createTile(coords: Point & { z: number }, done: (err: any, tile: HTMLElement) => void): HTMLElement;
+  onAdd(map: any): void;
   onRemove(map: any): void;
   _removeTile(key: string): void;
   getTileUrl(coords: Point & { z: number }): string;
+  _subTile(coords: { x: number, y: number, z: number }): { x: number, y: number, z: number, f: number, sx: number, sy: number };
   _getZoomForUrl(z: number): number;
+  _initSymbolOverlay(): void;
+  _destroySymbolOverlay(): void;
+  _refreshSymbols(): void;
+  _projectTilePoint(coords: { x: number, y: number, z: number }, localX: number, localY: number): { x: number, y: number } | null;
+  _drawSymbols(ctx: CanvasRenderingContext2D, collision: CollisionIndex): void;
+  _drawLocalTile(source: { getTile: (z: number, x: number, y: number) => any | null }, canvas: HTMLCanvasElement, entry: DecodedTileEntry, coords: Point & { z: number }, done: (err: any, tile: HTMLElement) => void): void;
+  _glyphProvider(): GlyphProvider | undefined;
+  _abortLoading(): void;
+  _sourceKey(coords: { x: number, y: number, z: number }): string;
+  _acquireSource(key: string, url: string, entry: DecodedTileEntry): Promise<{ tile: DecodedTile, index: RTree<RTreeItem> }>;
+  _decode(bytes: Uint8Array): Promise<DecodedTile>;
+  _workerPool(): WorkerPool | null;
+  _releaseSource(entry: DecodedTileEntry): void;
   _fetchAndDraw(url: string, canvas: HTMLCanvasElement, entry: DecodedTileEntry, coords: Point & { z: number }, done: (err: any, tile: HTMLElement) => void): Promise<void>;
   _fetchTileBytes(url: string, entry: DecodedTileEntry): Promise<Uint8Array>;
-  _drawTile(canvas: HTMLCanvasElement, tile: VectorTile, coords: Point & { z: number }): void;
+  _drawTile(canvas: HTMLCanvasElement, tile: DecodedTile, coords: Point & { z: number }): void;
 }

package/dist/core-map/layer/tile/urlTemplate.d.ts

@@ -1,7 +1,6 @@
-import type { Point } from '../../geometry/Point';
 // Pick a subdomain for a given tile coord. Stable, so the same tile always
 // resolves to the same subdomain — important for HTTP-cache friendliness.
-export declare function getSubdomain(tilePoint: Point, subdomains: string | string[]): string;
+export declare function getSubdomain(tilePoint: { x: number, y: number }, subdomains: string | string[]): string;
 // Compose a URL from a template and a bag of variables. The template may
 // reference any key provided in `data`; missing keys throw (so typos fail
 // loudly rather than silently producing a broken URL).

package/dist/core-map/map/Map.d.ts

@@ -32,6 +32,8 @@ export declare interface MapOptions {
   maxPitch?: number
   minPitch?: number
   zoomSnap?: number
+  theme?: 'light' | 'dark' | 'auto'
+  style?: any
   zoomDelta?: number
   trackResize?: boolean
   [key: string]: any
@@ -88,6 +90,21 @@ export declare class TsMap extends Evented {
   _pitch: number;
   _container: HTMLElement & { _tsmap_id?: number };
   _containerId?: number;
+  _geoJSONSources?: Record<string, {
+    index: any
+    layer: any
+    clustered: boolean
+    /** A `heatmap` style layer over this source, fed the same data. */
+    heatmap?: any
+    /** The property a simple `["get", k]` weight reads, if that is what it is. */
+    heatmapWeightKey?: string
+  }>;
+  _styleLoadToken?: number;
+  _spriteToken?: number;
+  _glyphSource?: any;
+  _theme?: 'light' | 'dark' | 'auto';
+  _themeQuery?: MediaQueryList;
+  _themeQueryListener?: (event: MediaQueryListEvent) => void;
   _loaded?: boolean;
   _zoom: number;
   _lastCenter?: LatLng | null;
@@ -288,19 +305,27 @@ export declare class TsMap extends Evented {
   _tryAnimatedZoom(center: any, zoom: number, options?: any): boolean;
   _animateZoom(center: LatLng, zoom: number, startAnim?: boolean, noUpdate?: boolean): void;
   _onZoomTransitionEnd(): void;
-  setStyle(style: StyleSpec, opts?: { diff?: boolean, validate?: boolean }): this;
+  setStyle(style: StyleSpec | string, opts?: { diff?: boolean, validate?: boolean }): this;
+  _syncStyleBackground(): void;
+  _styleBackgroundColor(): string | undefined;
+  _initGlyphSource(): void;
+  getGlyphSource(): any;
+  isFontAvailable(textFont: string | string[] | undefined): boolean;
+  _loadSprite(): void;
   getStyle(): StyleSpec | undefined;
   isStyleLoaded(): boolean;
   addSource(sourceId: string, source: SourceSpecification): this;
   getSource(sourceId: string): SourceSpecification | undefined;
   removeSource(sourceId: string): this;
   _makeSourceLayer(sourceId: string, source: SourceSpecification): unknown;
+  setSourceData(sourceId: string, data: unknown): this;
   addStyleLayer(layer: LayerSpecification, before?: string): this;
   removeStyleLayer(id: string): this;
   getStyleLayer(id: string): LayerSpecification | undefined;
   setPaintProperty(layerId: string, name: string, value: unknown): this;
   setLayoutProperty(layerId: string, name: string, value: unknown): this;
   setFilter(layerId: string, filter: unknown): this;
+  _syncStyleLayer(layerId: string): void;
   on(type: any, a?: any, b?: any, c?: any): this;
   off(type?: any, a?: any, b?: any, c?: any): this;
   once(type: any, a?: any, b?: any, c?: any): this;
@@ -325,6 +350,12 @@ export declare class TsMap extends Evented {
   getTerrain(): TerrainOptions | null;
   getTerrainSource(): TerrainSource | undefined;
   setRenderer(name: 'canvas2d' | 'webgl' | 'svg'): this;
+  setTheme(theme: 'light' | 'dark' | 'auto'): this;
+  getTheme(): 'light' | 'dark' | 'auto';
+  _applyTheme(dark: boolean): void;
+  _detachThemeQuery(): void;
+  setProjection(projection: 'mercator' | 'globe'): this;
+  getProjection(): 'mercator' | 'globe';
   getPreferredRenderer(): 'canvas2d' | 'webgl' | 'svg';
   queryTerrainElevation(lngLat: LatLng | { lng: number, lat: number }): number | null;
   toCanvas(): HTMLCanvasElement;

package/dist/core-map/mvt/DecodedTile.d.ts

@@ -0,0 +1,20 @@
+import type { GeoJSONFeature, VectorTileProperties } from './VectorTileFeature';
+import type { Point } from '../geometry/Point';
+export declare interface DecodedFeature {
+  id?: number
+  type: 1 | 2 | 3
+  extent: number
+  properties: VectorTileProperties
+  loadGeometry: () => Point[][]
+  bbox: () => [number, number, number, number]
+  toGeoJSON: (x: number, y: number, z: number) => GeoJSONFeature
+}
+export declare interface DecodedLayer {
+  name?: string
+  extent: number
+  length: number
+  feature: (i: number) => DecodedFeature
+}
+export declare interface DecodedTile {
+  layers: Record<string, DecodedLayer>
+}

package/dist/core-map/mvt/FlatTile.d.ts

@@ -0,0 +1,25 @@
+import { Point } from '../geometry/Point';
+import type { FlatLayer, FlatTile as FlatTileData } from '../workers/decodeMvtFlat';
+import type { GeoJSONFeature, VectorTileProperties } from './VectorTileFeature';
+export declare class FlatTileFeature {
+  id?: number;
+  type: 1 | 2 | 3;
+  extent: number;
+  constructor(layer: FlatLayer, index: number);
+  get properties(): VectorTileProperties;
+  loadGeometry(): Point[][];
+  bbox(): [number, number, number, number];
+  toGeoJSON(x: number, y: number, z: number): GeoJSONFeature;
+}
+export declare class FlatTileLayer {
+  name: string;
+  version: number;
+  extent: number;
+  length: number;
+  constructor(data: FlatLayer);
+  feature(i: number): FlatTileFeature;
+}
+export declare class FlatTile {
+  layers: Record<string, FlatTileLayer>;
+  constructor(data: FlatTileData);
+}

package/dist/core-map/mvt/VectorTileFeature.d.ts

@@ -1,5 +1,13 @@
 import { Point } from '../geometry/Point';
 import type { Pbf } from '../proto/Pbf';
+/**
+ * Project tile-local rings to WGS84 and wrap them as a GeoJSON feature.
+ *
+ * Shared rather than duplicated: tiles decoded in a worker arrive as flat
+ * typed arrays and are wrapped by `FlatTile`, which has the same job to do
+ * here and must produce byte-identical output.
+ */
+export declare function geometryToGeoJSON(type: number, rings: Point[][], extent: number, x: number, y: number, z: number, properties: VectorTileProperties, id?: number): GeoJSONFeature;
 // MVT GeomType enum values (tile.proto).
 export declare const MVT_GEOM_UNKNOWN: number;
 export declare const MVT_GEOM_POINT: number;