ts-maps 0.2.7 → 0.3.0

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

@@ -0,0 +1,59 @@
+import { AttributionControl, Control, LayersControl, 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';
+export type { CircleOptions as WebGLCircleOptions, GLContextOptions, LineOptions as WebGLLineOptions, Mat4 } from './renderer/webgl/index';
+/**
+* ts - maps — a modern TypeScript interactive map library.
+*
+* Portions of this codebase were derived from the open - source Leaflet
+* project (BSD - 2-Clause, © Vladimir Agafonkin and contributors). The
+* module layout and public API shape follow its design. See CREDITS.md
+* for details; all identifiers and classnames here are part of ts - maps.
+*/
+export declare const version: string;
+export declare const map: Factory < ConstructorParameters < typeof TsMap>, TsMap>;
+export declare const marker: Factory < ConstructorParameters < typeof Marker>, Marker>;
+export declare const icon: Factory < ConstructorParameters < typeof Icon>, Icon>;
+export declare const divIcon: Factory < ConstructorParameters < typeof DivIcon>, DivIcon>;
+export declare const layerGroup: Factory < ConstructorParameters < typeof LayerGroup>, LayerGroup>;
+export declare const featureGroup: Factory < ConstructorParameters < typeof FeatureGroup>, FeatureGroup>;
+export declare const geoJSON: Factory < ConstructorParameters < typeof GeoJSON>, GeoJSON>;
+export declare const geoJson: typeof geoJSON;
+export declare const gridLayer: Factory < ConstructorParameters < typeof GridLayer>, GridLayer>;
+export declare const tileLayer: Factory < ConstructorParameters < typeof TileLayer>, TileLayer> & { wms: Factory < ConstructorParameters < typeof WMSTileLayer>, WMSTileLayer> };
+export declare const vectorTileLayer: Factory < ConstructorParameters < typeof VectorTileMapLayer>, VectorTileMapLayer>;
+export declare const heatmapLayer: Factory < ConstructorParameters < typeof HeatmapLayer>, HeatmapLayer>;
+export declare const rasterDEMLayer: Factory < ConstructorParameters < typeof RasterDEMLayer>, RasterDEMLayer>;
+export declare const imageOverlay: Factory < ConstructorParameters < typeof ImageOverlay>, ImageOverlay>;
+export declare const videoOverlay: Factory < ConstructorParameters < typeof VideoOverlay>, VideoOverlay>;
+export declare const svgOverlay: Factory < ConstructorParameters < typeof SVGOverlay>, SVGOverlay>;
+export declare const popup: Factory < ConstructorParameters < typeof Popup>, Popup>;
+export declare const tooltip: Factory < ConstructorParameters < typeof Tooltip>, Tooltip>;
+export declare const polyline: Factory < ConstructorParameters < typeof Polyline>, Polyline>;
+export declare const polygon: Factory < ConstructorParameters < typeof Polygon>, Polygon>;
+export declare const rectangle: Factory < ConstructorParameters < typeof Rectangle>, Rectangle>;
+export declare const circle: Factory < ConstructorParameters < typeof Circle>, Circle>;
+export declare const circleMarker: Factory < ConstructorParameters < typeof CircleMarker>, CircleMarker>;
+export declare const control: Factory < ConstructorParameters < typeof Control>, Control> & {
+  zoom: Factory < ConstructorParameters < typeof ZoomControl>, ZoomControl>
+  layers: Factory < ConstructorParameters < typeof LayersControl>, LayersControl>
+  attribution: Factory < ConstructorParameters < typeof AttributionControl>, AttributionControl>
+  scale: Factory < ConstructorParameters < typeof ScaleControl>, ScaleControl>
+};
+// Default namespace object grouping all public exports.
+declare const tsMap: Record<string, unknown>;
+// Factory helper: turns a constructor into a callable function.
+declare type Factory<A extends any[], T> = (..._args: A) => T;
+export * from './control/index';
+export * from './core/index';
+export * from './dom/index';
+export * from './geometry/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 default tsMap;

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

@@ -0,0 +1,24 @@
+import { Bounds } from '../geometry/Bounds';
+import { Layer } from './Layer';
+import type { Point } from '../geometry/Point';
+export declare class BlanketOverlay extends Layer {
+  _container?: HTMLElement;
+  _bounds?: Bounds;
+  _center?: any;
+  _zoom?: number;
+  initialize(options?: any): void;
+  onAdd(_map?: any): void;
+  onRemove(_map?: any): void;
+  getEvents(): Record<string, any>;
+  _onAnimZoom(ev: any): void;
+  _onZoom(): void;
+  _updateTransform(center: any, zoom: number): void;
+  _onMoveEnd(ev?: any): void;
+  _reset(): void;
+  _initContainer(): void;
+  _destroyContainer(): void;
+  _resizeContainer(): Point;
+  _onZoomEnd(): void;
+  _onViewReset(): void;
+  _onSettled(_ev?: any): void;
+}

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

@@ -0,0 +1,40 @@
+import { LatLng } from '../geo/LatLng';
+import { Layer } from './Layer';
+import { Point } from '../geometry/Point';
+export declare class DivOverlay extends Layer {
+  _latlng?: LatLng;
+  _source?: any;
+  _content?: any;
+  _container?: HTMLElement;
+  _contentNode?: HTMLElement;
+  _removeTimeout?: ReturnType<typeof setTimeout>;
+  _containerWidth?: number;
+  _containerHeight?: number;
+  _containerLeft?: number;
+  _containerBottom?: number;
+  _autopanning?: boolean;
+  initialize(options?: any, source?: any): void;
+  openOn(map?: any): this;
+  close(): this;
+  toggle(layer?: any): this;
+  onAdd(map: any): void;
+  onRemove(map: any): void;
+  getLatLng(): LatLng | undefined;
+  setLatLng(latlng: any): this;
+  getContent(): any;
+  setContent(content: any): this;
+  getElement(): HTMLElement | undefined;
+  update(): void;
+  getEvents(): Record<string, any>;
+  isOpen(): boolean;
+  bringToFront(): this;
+  bringToBack(): this;
+  _prepareOpen(latlng?: LatLng): boolean;
+  _updateContent(): void;
+  _updatePosition(): void;
+  _getAnchor(): Point | number[];
+  _initLayout(): void;
+  _updateLayout(): void;
+  _adjustPan(): void;
+  _animateZoom(_e: any): void;
+}

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

@@ -0,0 +1,11 @@
+import { LatLngBounds } from '../geo/LatLngBounds';
+import { LayerGroup } from './LayerGroup';
+import type { Layer } from './Layer';
+export declare class FeatureGroup extends LayerGroup {
+  addLayer(layer: Layer): this;
+  removeLayer(layer: Layer | number): this;
+  setStyle(style: any): this;
+  bringToFront(): this;
+  bringToBack(): this;
+  getBounds(): LatLngBounds;
+}

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

@@ -0,0 +1,17 @@
+import { FeatureGroup } from './FeatureGroup';
+import { LatLng } from '../geo/LatLng';
+export declare class GeoJSON extends FeatureGroup {
+  initialize(geojson?: any, options?: any): void;
+  addData(geojson: any): this;
+  resetStyle(layer?: any): this;
+  setStyle(style: any): this;
+  _setLayerStyle(layer: any, style: any): void;
+  static geometryToLayer(geojson: any, options?: any): any;
+  static _pointToLayer(pointToLayerFn: any, geojson: any, latlng: LatLng, options?: any): any;
+  static coordsToLatLng(coords: number[]): LatLng;
+  static coordsToLatLngs(coords: any[], levelsDeep?: number, _coordsToLatLng?: (c: number[]) => LatLng): any[];
+  static latLngToCoords(latlng: any, precision?: number | false): number[];
+  static latLngsToCoords(latlngs: any[], levelsDeep?: number, close?: boolean, precision?: number | false): any[];
+  static getFeature(layer: any, newGeometry: any): any;
+  static asFeature(geojson: any): any;
+}

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

@@ -0,0 +1,54 @@
+// GeoJSON clustering source — an in-house, zero-dependency TypeScript port of
+// the classic supercluster algorithm (https://github.com/mapbox/supercluster,
+// BSD-3-Clause). The implementation is independent; credit to the upstream
+// project for the original approach.
+//
+// The algorithm pre-projects each input point to a unit-square web-mercator
+// coordinate, indexes it in a static KD-tree, and iteratively collapses
+// neighbouring points into clusters at each integer zoom. Query time is
+// O(log N) per bbox via the KD-tree.
+// ---------------------------------------------------------------------------
+// Public types
+// ---------------------------------------------------------------------------
+export declare interface ClusterOptions {
+  radius?: number
+  maxZoom?: number
+  minZoom?: number
+  minPoints?: number
+  extent?: number
+  nodeSize?: number
+  log?: boolean
+  reduce?: (acc: Record<string, unknown>, props: Record<string, unknown>) => void
+  map?: (props: Record<string, unknown>) => Record<string, unknown>
+}
+export declare interface ClusterPoint {
+  type: 'Feature'
+  geometry: { type: 'Point', coordinates: [number, number] }
+  properties: Record<string, unknown>
+  id?: number
+}
+// ---------------------------------------------------------------------------
+// KDBush — a static 2-D spatial index tuned for sort-once / query-many.
+// ---------------------------------------------------------------------------
+export declare class KDBush {
+  readonly nodeSize: number;
+  readonly points: Float64Array;
+  readonly ids: Uint32Array;
+  constructor(numItems: number, nodeSize?: number);
+  add(x: number, y: number): number;
+  finish(): this;
+  range(minX: number, minY: number, maxX: number, maxY: number): number[];
+  within(qx: number, qy: number, r: number): number[];
+}
+// ---------------------------------------------------------------------------
+// GeoJSONClusterSource
+// ---------------------------------------------------------------------------
+export declare class GeoJSONClusterSource {
+  constructor(opts?: ClusterOptions);
+  load(features: ClusterPoint[]): this;
+  getClusters(bbox: [number, number, number, number], zoom: number): ClusterPoint[];
+  getChildren(clusterId: number): ClusterPoint[];
+  getLeaves(clusterId: number, limit?: number, offset?: number): ClusterPoint[];
+  getClusterExpansionZoom(clusterId: number): number;
+  getTile(z: number, x: number, y: number): { features: ClusterPoint[] } | null;
+}

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

@@ -0,0 +1,40 @@
+import { Layer } from './Layer';
+export declare interface HeatmapPoint {
+  lat: number
+  lng: number
+  weight?: number
+}
+export declare interface HeatmapLayerOptions {
+  data?: HeatmapPoint[]
+  radius?: number
+  blur?: number
+  max?: number
+  gradient?: Record<number, string>
+  minOpacity?: number
+  pane?: string
+  attribution?: string
+}
+// Density-field heatmap rendered on a full-viewport canvas inside the
+// overlay pane. Each point draws a Gaussian intensity splat; the
+// accumulated alpha channel is then mapped through a colour ramp.
+export declare class HeatmapLayer extends Layer {
+  _canvas?: HTMLCanvasElement;
+  _ctx?: CanvasRenderingContext2D;
+  _data: HeatmapPoint[];
+  _frame?: number;
+  _gradientTexture?: Uint8ClampedArray;
+  _redrawScheduled: boolean;
+  initialize(options?: HeatmapLayerOptions): void;
+  setData(points: HeatmapPoint[]): this;
+  addPoint(p: HeatmapPoint): this;
+  clearData(): this;
+  setOptions(opts: Partial<HeatmapLayerOptions>): this;
+  redraw(): this;
+  onAdd(_map: any): void;
+  onRemove(_map: any): void;
+  getEvents(): Record<string, any>;
+  _resize(): void;
+  _draw(): void;
+  _intensityBlob(radius: number, innerRadius: number, blur: number): HTMLCanvasElement;
+  _colourRamp(): Uint8ClampedArray;
+}

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

@@ -0,0 +1,27 @@
+import { LatLngBounds } from '../geo/LatLngBounds';
+import { Layer } from './Layer';
+export declare class ImageOverlay extends Layer {
+  _url: any;
+  _bounds: LatLngBounds;
+  _image?: HTMLImageElement | HTMLVideoElement | SVGElement | any;
+  initialize(url: any, bounds: any, options?: any): void;
+  onAdd(): void;
+  onRemove(): void;
+  setOpacity(opacity: number): this;
+  setStyle(styleOpts: any): this;
+  bringToFront(): this;
+  bringToBack(): this;
+  setUrl(url: string): this;
+  setBounds(bounds: any): this;
+  getEvents(): Record<string, any>;
+  setZIndex(value: number): this;
+  getBounds(): LatLngBounds;
+  getElement(): any;
+  _initImage(): void;
+  _animateZoom(e: any): void;
+  _reset(): void;
+  _updateOpacity(): void;
+  _updateZIndex(): void;
+  _overlayOnError(): void;
+  getCenter(): any;
+}

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

@@ -0,0 +1,18 @@
+import { Evented } from '../core/Events';
+export declare class Layer extends Evented {
+  _map?: any;
+  _mapToAdd?: any;
+  _zoomAnimated?: boolean;
+  getEvents(): Record<string, any>;
+  onAdd(_map: any): void;
+  onRemove(_map: any): void;
+  beforeAdd(_map: any): void;
+  addTo(map: any): this;
+  remove(): this;
+  removeFrom(obj: any): this;
+  getPane(name?: string): HTMLElement;
+  addInteractiveTarget(targetEl: any): this;
+  removeInteractiveTarget(targetEl: any): this;
+  getAttribution(): string | null | undefined;
+  _layerAdd(e: any): void;
+}

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

@@ -0,0 +1,16 @@
+import { Layer } from './Layer';
+export declare class LayerGroup extends Layer {
+  _layers: Record<number | string, Layer>;
+  initialize(layers?: Layer[], options?: any): void;
+  addLayer(layer: Layer): this;
+  removeLayer(layer: Layer | number): this;
+  hasLayer(layer: Layer | number): boolean;
+  clearLayers(): this;
+  onAdd(map: any): void;
+  onRemove(map: any): void;
+  eachLayer(method: (layer: Layer) => void, context?: any): this;
+  getLayer(id: number): Layer | undefined;
+  getLayers(): Layer[];
+  setZIndex(zIndex: number): this;
+  getLayerId(layer: Layer): number;
+}

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

@@ -0,0 +1,18 @@
+import { DivOverlay } from './DivOverlay';
+import { Point } from '../geometry/Point';
+export declare class Popup extends DivOverlay {
+  _wrapper?: HTMLElement;
+  _tipContainer?: HTMLElement;
+  _tip?: HTMLElement;
+  _closeButton?: HTMLAnchorElement;
+  _resizeObserver?: ResizeObserver;
+  openOn(map?: any): this;
+  onAdd(map: any): void;
+  onRemove(map: any): void;
+  getEvents(): Record<string, any>;
+  _initLayout(): void;
+  _updateLayout(): void;
+  _animateZoom(e: any): void;
+  _adjustPan(): void;
+  _getAnchor(): Point;
+}

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

@@ -0,0 +1,4 @@
+import { ImageOverlay } from './ImageOverlay';
+export declare class SVGOverlay extends ImageOverlay {
+  _initImage(): void;
+}

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

@@ -0,0 +1,15 @@
+import { DivOverlay } from './DivOverlay';
+import { Point } from '../geometry/Point';
+export declare class Tooltip extends DivOverlay {
+  onAdd(map: any): void;
+  onRemove(map: any): void;
+  getEvents(): Record<string, any>;
+  _initLayout(): void;
+  _updateLayout(): void;
+  _adjustPan(): void;
+  _setPosition(pos: Point): void;
+  _updatePosition(): void;
+  setOpacity(opacity: number): void;
+  _animateZoom(e: any): void;
+  _getAnchor(): Point;
+}

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

@@ -0,0 +1,4 @@
+import { ImageOverlay } from './ImageOverlay';
+export declare class VideoOverlay extends ImageOverlay {
+  _initImage(): void;
+}

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

@@ -0,0 +1,18 @@
+export type { ClusterOptions, ClusterPoint } from './GeoJSONClusterSource';
+export type { HeatmapLayerOptions, HeatmapPoint } from './HeatmapLayer';
+export { BlanketOverlay } from './BlanketOverlay';
+export { DivOverlay } from './DivOverlay';
+export { FeatureGroup } from './FeatureGroup';
+export { GeoJSON } from './GeoJSON';
+export { GeoJSONClusterSource, KDBush } from './GeoJSONClusterSource';
+export { HeatmapLayer } from './HeatmapLayer';
+export { ImageOverlay } from './ImageOverlay';
+export { Layer } from './Layer';
+export { LayerGroup } from './LayerGroup';
+export { Popup } from './Popup';
+export { SVGOverlay } from './SVGOverlay';
+export { Tooltip } from './Tooltip';
+export { VideoOverlay } from './VideoOverlay';
+export * from './marker/index';
+export * from './tile/index';
+export * from './vector/index';

package/dist/core-map/layer/marker/DefaultIcon.d.ts

@@ -0,0 +1,7 @@
+import { Icon } from './Icon';
+export declare class DefaultIcon extends Icon {
+  static imagePath?: string;
+  _getIconUrl(name: string): string;
+  _stripUrl(path: string): string | null;
+  _detectIconPath(): string;
+}

package/dist/core-map/layer/marker/DivIcon.d.ts

@@ -0,0 +1,5 @@
+import { Icon } from './Icon';
+export declare class DivIcon extends Icon {
+  createIcon(oldIcon?: HTMLElement): HTMLElement;
+  createShadow(): HTMLElement | null;
+}

package/dist/core-map/layer/marker/Icon.d.ts

@@ -0,0 +1,10 @@
+import { Class } from '../../core/Class';
+export declare class Icon extends Class {
+  initialize(options?: any): void;
+  createIcon(oldIcon?: HTMLElement): HTMLElement | null;
+  createShadow(oldIcon?: HTMLElement): HTMLElement | null;
+  _createIcon(name: string, oldIcon?: HTMLElement | null): HTMLElement | null;
+  _setIconStyles(img: HTMLElement, name: string): void;
+  _createImg(src: string, el?: HTMLImageElement | null): HTMLImageElement;
+  _getIconUrl(name: string): string;
+}

package/dist/core-map/layer/marker/Marker.Drag.d.ts

@@ -0,0 +1,17 @@
+import { Draggable } from '../../dom/Draggable';
+import { Handler } from '../../core/Handler';
+export declare class MarkerDrag extends Handler {
+  _marker: any;
+  _draggable?: Draggable;
+  _oldLatLng?: any;
+  _panRequest?: number;
+  initialize(marker: any): void;
+  addHooks(): void;
+  removeHooks(): void;
+  moved(): boolean | undefined;
+  _adjustPan(e: any): void;
+  _onDragStart(): void;
+  _onPreDrag(e: any): void;
+  _onDrag(e: any): void;
+  _onDragEnd(e: any): void;
+}

package/dist/core-map/layer/marker/Marker.d.ts

@@ -0,0 +1,37 @@
+import { LatLng } from '../../geo/LatLng';
+import { Layer } from '../Layer';
+import { MarkerDrag } from './Marker.Drag';
+import { Point } from '../../geometry/Point';
+export declare class Marker extends Layer {
+  _latlng: LatLng;
+  _icon?: HTMLElement | null;
+  _shadow?: HTMLElement | null;
+  _zIndex?: number;
+  _popup?: any;
+  dragging?: MarkerDrag;
+  initialize(latlng: any, options?: any): void;
+  onAdd(map: any): void;
+  onRemove(map: any): void;
+  getEvents(): Record<string, any>;
+  getLatLng(): LatLng;
+  setLatLng(latlng: any): this;
+  setZIndexOffset(offset: number): this;
+  getIcon(): any;
+  setIcon(icon: any): this;
+  getElement(): HTMLElement | null | undefined;
+  update(): this;
+  _initIcon(): void;
+  _removeIcon(): void;
+  _removeShadow(): void;
+  _setPos(pos: Point): void;
+  _updateZIndex(offset: number): void;
+  _animateZoom(opt: any): void;
+  _initInteraction(): void;
+  setOpacity(opacity: number): this;
+  _updateOpacity(): void;
+  _bringToFront(): void;
+  _resetZIndex(): void;
+  _panOnFocus(): void;
+  _getPopupAnchor(): any;
+  _getTooltipAnchor(): any;
+}

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

@@ -0,0 +1,5 @@
+export { DefaultIcon } from './DefaultIcon';
+export { DivIcon } from './DivIcon';
+export { Icon } from './Icon';
+export { Marker } from './Marker';
+export { MarkerDrag } from './Marker.Drag';

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

@@ -0,0 +1,88 @@
+import { Bounds } from '../../geometry/Bounds';
+import { LatLngBounds } from '../../geo/LatLngBounds';
+import { Layer } from '../Layer';
+import { Point } from '../../geometry/Point';
+declare interface TileEntry {
+  el: HTMLElement
+  coords: Point & { z: number }
+  current: boolean
+  loaded?: number
+  active?: boolean
+  retain?: boolean
+}
+declare interface Level {
+  el: HTMLElement
+  origin: Point
+  zoom: number
+}
+// Generic class for handling a tiled grid of HTML elements.
+export declare class GridLayer extends Layer {
+  _container?: HTMLElement;
+  _levels: Record<string | number, Level>;
+  _tiles: Record<string, TileEntry>;
+  _level?: Level;
+  _tileZoom?: number;
+  _fadeFrame?: number;
+  _pruneTimeout?: ReturnType<typeof setTimeout>;
+  _noPrune?: boolean;
+  _loading?: boolean;
+  _globalTileRange?: Bounds;
+  _wrapX?: [number, number] | false;
+  _wrapY?: [number, number] | false;
+  _tileSize?: Point;
+  _onMove?: (...args: any[]) => void;
+  _abortLoading?(): void;
+  initialize(options?: any): void;
+  onAdd(_map?: any): void;
+  beforeAdd(map: any): void;
+  onRemove(map: any): void;
+  bringToFront(): this;
+  bringToBack(): this;
+  getContainer(): HTMLElement | undefined;
+  setOpacity(opacity: number): this;
+  setZIndex(zIndex: number): this;
+  isLoading(): boolean | undefined;
+  redraw(): this;
+  getEvents(): Record<string, any>;
+  createTile(_coords?: any, _done?: any): HTMLElement;
+  getTileSize(): Point;
+  _updateZIndex(): void;
+  _setAutoZIndex(compare: (a: number, b: number) => number): void;
+  _updateOpacity(): void;
+  _onOpaqueTile(_tile?: TileEntry): void;
+  _initContainer(): void;
+  _updateLevels(): Level | undefined;
+  _onUpdateLevel(_z: number): void;
+  _onRemoveLevel(_z: number): void;
+  _onCreateLevel(_level: Level): void;
+  _pruneTiles(): void;
+  _removeTilesAtZoom(zoom: number): void;
+  _removeAllTiles(): void;
+  _invalidateAll(): void;
+  _retainParent(x: number, y: number, z: number, minZoom: number): boolean;
+  _retainChildren(x: number, y: number, z: number, maxZoom: number): void;
+  _resetView(e?: any): void;
+  _animateZoom(e: any): void;
+  _clampZoom(zoom: number): number;
+  _setView(center: any, zoom: number, noPrune?: boolean, noUpdate?: boolean): void;
+  _setZoomTransforms(center: any, zoom: number): void;
+  _setZoomTransform(level: Level, center: any, zoom: number): void;
+  _resetGrid(): void;
+  _onMoveEnd(): void;
+  _getTiledPixelBounds(center: any): Bounds;
+  _update(center?: any): void;
+  _isValidTile(coords: Point & { z: number }): boolean;
+  _keyToBounds(key: string): LatLngBounds;
+  _tileCoordsToNwSe(coords: Point & { z: number }): [any, any];
+  _tileCoordsToBounds(coords: Point & { z: number }): LatLngBounds;
+  _tileCoordsToKey(coords: Point & { z: number }): string;
+  _keyToTileCoords(key: string): Point & { z: number };
+  _removeTile(key: string): void;
+  _initTile(tile: HTMLElement): void;
+  _addTile(coords: Point & { z: number }, container: DocumentFragment): void;
+  _tileReady(coords: Point & { z: number }, err?: any, tile?: HTMLElement): void;
+  _getTilePos(coords: Point & { z: number }): Point;
+  _wrapCoords(coords: Point & { z: number }): Point & { z: number };
+  _pxBoundsToTileRange(bounds: Bounds): Bounds;
+  _noTilesToLoad(): boolean;
+}

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

@@ -0,0 +1,46 @@
+import { decodeMapboxRGB, decodeTerrariumRGB } from '../../geo/elevation';
+import { TileLayer } from './TileLayer';
+import type { DEMEncoding } from '../../geo/elevation';
+import type { Point } from '../../geometry/Point';
+// Re-exports preserve the historical `RasterDEMLayer` surface. New code
+// should import these directly from `core-map/geo/elevation`.
+export type { DEMEncoding };
+/**
+ * Mapbox-style alias: the `hillshade` style-spec layer type resolves to
+ * this class. Exposed so callers who speak the style spec can write
+ * `new HillshadeLayer(url, { encoding, exaggeration, shadowColor, accentColor })`
+ * without having to know it's the same runtime as `raster-dem`.
+ */
+export declare const HillshadeLayer: typeof RasterDEMLayer;
+export declare interface RasterDEMLayerOptions {
+  url: string
+  subdomains?: string | string[]
+  encoding?: DEMEncoding
+  tileSize?: number
+  minZoom?: number
+  maxZoom?: number
+  exaggeration?: number
+  azimuth?: number
+  altitude?: number
+  accentColor?: string
+  shadowColor?: string
+  opacity?: number
+  attribution?: string
+  pane?: string
+  crossOrigin?: boolean | string
+}
+export type HillshadeLayerOptions = RasterDEMLayerOptions;
+// Fetches RGB-encoded terrain tiles and shades them with a simple
+// Lambertian light model. Decoding and shading both run on the main
+// thread for now; the worker path is a future optimisation.
+//
+// This class backs both the raster-dem source type and the `hillshade`
+// style-spec layer type — `HillshadeLayer` below is an alias that
+// matches Mapbox GL JS's naming.
+export declare class RasterDEMLayer extends TileLayer {
+  _encoding: DEMEncoding;
+  initialize(url: string, options?: RasterDEMLayerOptions): void;
+  createTile(coords: Point & { z: number }, done: (err: any, tile: HTMLElement) => void): HTMLElement;
+  _shadeInto(img: HTMLImageElement, out: HTMLCanvasElement): void;
+}
+export { decodeMapboxRGB, decodeTerrariumRGB };

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

@@ -0,0 +1,22 @@
+import { GridLayer } from './GridLayer';
+import { TileCache } from '../../storage/index';
+import type { Point } from '../../geometry/Point';
+export declare class TileLayer extends GridLayer {
+  _url: string;
+  _offlineCache?: TileCache;
+  _activeBlobUrls: Set<string>;
+  initialize(url: string, options?: any): void;
+  setUrl(url: string, noRedraw?: boolean): this;
+  createTile(coords: Point & { z: number }, done: (err: any, tile: HTMLElement) => void): HTMLElement;
+  _resolveThroughCache(tile: HTMLImageElement, url: string): void;
+  getTileUrl(coords: Point & { z: number }): string;
+  _tileOnLoad(done: (err: any, tile: HTMLElement) => void, tile: HTMLElement): void;
+  _tileOnError(done: (err: any, tile: HTMLElement) => void, tile: HTMLImageElement, e: any): void;
+  _onTileRemove(e: any): void;
+  _getZoomForUrl(): number;
+  _getSubdomain(tilePoint: Point): string;
+  _abortLoading(): void;
+  _removeTile(key: string): void;
+  _tileReady(coords: any, err?: any, tile?: HTMLElement): void;
+  _clampZoom(zoom: number): number;
+}