ts-maps 0.2.7 → 0.3.0

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

@@ -0,0 +1,145 @@
+import { GlyphAtlas } from '../../symbols/GlyphAtlas';
+import { GridLayer } from './GridLayer';
+import { IconAtlas } from '../../symbols/IconAtlas';
+import { RTree } from '../../geometry/RTree';
+import { TileCache } from '../../storage/index';
+import { VectorTile } from '../../mvt/VectorTile';
+import { VectorTileFeature } from '../../mvt/VectorTileFeature';
+import { WebGLTileRenderer } from '../../renderer/webgl/WebGLTileRenderer';
+import type { CompiledExpression } from '../../style-spec/expressions/index';
+import type { Point } from '../../geometry/Point';
+// ---------------------------------------------------------------------------
+// Public types
+// ---------------------------------------------------------------------------
+export declare interface VectorTileMapLayerOptions {
+  url: string
+  subdomains?: string | string[]
+  minZoom?: number
+  maxZoom?: number
+  maxNativeZoom?: number
+  tileSize?: number
+  attribution?: string
+  pane?: string
+  className?: string
+  crossOrigin?: boolean | string
+  layers?: VectorTileStyleLayer[]
+  sources?: Record<string, unknown>
+  glyphAtlas?: GlyphAtlas
+  iconAtlas?: IconAtlas
+  offlineCache?: TileCache | boolean
+  renderer?: 'canvas2d' | 'webgl'
+}
+export declare interface VectorTileStyleLayer {
+  id: string
+  type: 'fill' | 'fill-extrusion' | 'line' | 'circle' | 'symbol'
+  sourceLayer: string
+  minzoom?: number
+  maxzoom?: number
+  filter?: unknown
+  paint?: VectorTilePaintProperties
+  layout?: VectorTileLayoutProperties
+  _compiledFilter?: CompiledExpression | false | null
+}
+export declare interface VectorTilePaintProperties {
+  'fill-color'?: string
+  'fill-opacity'?: number
+  'fill-outline-color'?: string
+  'line-color'?: string
+  'line-width'?: number
+  'line-opacity'?: number
+  'line-dasharray'?: number[] | unknown
+  'line-cap'?: 'butt' | 'round' | 'square'
+  'line-join'?: 'miter' | 'round' | 'bevel'
+  'line-gradient'?: unknown
+  'circle-color'?: string
+  'circle-radius'?: number
+  'circle-opacity'?: number
+  'circle-stroke-color'?: string
+  'circle-stroke-width'?: number
+  'fill-extrusion-color'?: string
+  'fill-extrusion-opacity'?: number
+  'fill-extrusion-height'?: number | unknown
+  'fill-extrusion-base'?: number | unknown
+  'text-color'?: string
+  'text-halo-color'?: string
+  'text-halo-width'?: number
+  'icon-opacity'?: number
+}
+export declare interface VectorTileLayoutProperties {
+  visibility?: 'visible' | 'none'
+  'text-field'?: string | unknown
+  'text-size'?: number
+  'text-font'?: string | string[]
+  'text-italic'?: boolean
+  'text-bold'?: boolean
+  'icon-image'?: string | unknown
+  'icon-size'?: number
+  'icon-rotate'?: number
+  'symbol-placement'?: 'point'
+  'symbol-priority'?: number
+}
+export declare interface QueryRenderedFeature {
+  feature: VectorTileFeature
+  layer: VectorTileStyleLayer
+  tile: { x: number, y: number, z: number }
+}
+export declare interface QueryRenderedFeaturesOptions {
+  point?: [number, number] | Point
+  bbox?: [[number, number], [number, number]]
+  layers?: string[]
+}
+export declare interface QuerySourceFeature {
+  feature: VectorTileFeature
+  sourceLayer: string
+  tile: { x: number, y: number, z: number }
+}
+// Each R-tree entry holds enough info to recover the originating feature
+// cheaply during the precise-geometry pass.
+declare interface RTreeItem {
+  featureIndex: number
+  sourceLayerName: string
+  bbox: BBox
+}
+// Internal bookkeeping: alongside each Canvas we track the decoded tile so
+// `queryRenderedFeatures` can re-project hit-tests to tile-local coords.
+declare interface DecodedTileEntry {
+  canvas: HTMLCanvasElement
+  tile: VectorTile | null
+  coords: { x: number, y: number, z: number }
+  abort: AbortController
+  index: RTree<RTreeItem> | null
+  gl: WebGLTileRenderer | null
+}
+// ---------------------------------------------------------------------------
+// Class
+// ---------------------------------------------------------------------------
+export declare class VectorTileMapLayer extends GridLayer {
+  _styleLayers: VectorTileStyleLayer[];
+  _decodedTiles: Map<HTMLCanvasElement, DecodedTileEntry>;
+  _featureStateLookup?: (src: string, srcLayer: string, id: number | string) => Record<string, unknown>;
+  _sourceId?: string;
+  _glyphAtlas?: GlyphAtlas;
+  _iconAtlas?: IconAtlas;
+  _offlineCache?: TileCache;
+  _webglFallbackWarned?: boolean;
+  initialize(options?: VectorTileMapLayerOptions): void;
+  getGlyphAtlas(): GlyphAtlas;
+  getIconAtlas(): IconAtlas;
+  setFeatureStateLookup(fn: (src: string, srcLayer: string, id: number | string) => Record<string, unknown>): this;
+  setSourceId(id: string): this;
+  _repaintDecodedTiles(): void;
+  setStyleLayers(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[];
+  createTile(coords: Point & { z: number }, done: (err: any, tile: HTMLElement) => void): HTMLElement;
+  onRemove(map: any): void;
+  _removeTile(key: string): void;
+  getTileUrl(coords: Point & { z: number }): string;
+  _getZoomForUrl(z: number): number;
+  _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;
+}

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

@@ -0,0 +1,12 @@
+import { TileLayer } from './TileLayer';
+import type { Point } from '../../geometry/Point';
+export declare class WMSTileLayer extends TileLayer {
+  wmsParams: Record<string, any>;
+  _crs?: any;
+  _wmsVersion?: number;
+  defaultWmsParams: Record<string, any>;
+  initialize(url: string, options?: any): void;
+  onAdd(map: any): void;
+  getTileUrl(coords: Point & { z: number }): string;
+  setParams(params: Record<string, any>, noRedraw?: boolean): this;
+}

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

@@ -0,0 +1,15 @@
+export type { DEMEncoding, HillshadeLayerOptions, RasterDEMLayerOptions } from './RasterDEMLayer';
+export type {
+  QueryRenderedFeature,
+  QueryRenderedFeaturesOptions,
+  QuerySourceFeature,
+  VectorTileLayoutProperties,
+  VectorTileMapLayerOptions,
+  VectorTilePaintProperties,
+  VectorTileStyleLayer,
+} from './VectorTileMapLayer';
+export { GridLayer } from './GridLayer';
+export { decodeMapboxRGB, decodeTerrariumRGB, HillshadeLayer, RasterDEMLayer } from './RasterDEMLayer';
+export { TileLayer } from './TileLayer';
+export { VectorTileMapLayer } from './VectorTileMapLayer';
+export { WMSTileLayer } from './WMSTileLayer';

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

@@ -0,0 +1,17 @@
+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;
+// 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).
+export declare function composeTileUrl(template: string, data: TileUrlData): string;
+export declare interface TileUrlData {
+  x: number
+  y: number
+  z: number
+  s: string
+  r: string
+  '-y'?: number
+  [key: string]: any
+}

package/dist/core-map/layer/vector/Canvas.d.ts

@@ -0,0 +1,52 @@
+import { Bounds } from '../../geometry/Bounds';
+import { Renderer } from './Renderer';
+declare interface Order {
+  layer: any
+  prev: Order | null
+  next: Order | null
+}
+// Canvas renderer for vector layers.
+export declare class Canvas extends Renderer {
+  _ctx?: CanvasRenderingContext2D;
+  _ctxScale?: number;
+  _redrawRequest?: number | null;
+  _redrawBounds?: Bounds | null;
+  _drawFirst?: Order | null;
+  _drawLast?: Order | null;
+  _drawing?: boolean;
+  _postponeUpdatePaths?: boolean;
+  _hoveredLayer?: any;
+  _pointerHoverThrottled?: boolean;
+  _pointerHoverThrottleTimeout?: ReturnType<typeof setTimeout>;
+  getEvents(): Record<string, any>;
+  _onViewPreReset(): void;
+  onAdd(map: any): void;
+  onRemove(): void;
+  _initContainer(): void;
+  _destroyContainer(): void;
+  _resizeContainer(): any;
+  _updatePaths(): void;
+  _update(): void;
+  _reset(): void;
+  _initPath(layer: any): void;
+  _addPath(layer: any): void;
+  _removePath(layer: any): void;
+  _updatePath(layer: any): void;
+  _updateStyle(layer: any): void;
+  _updateDashArray(layer: any): void;
+  _requestRedraw(layer: any): void;
+  _extendRedrawBounds(layer: any): void;
+  _redraw(): void;
+  _clear(): void;
+  _draw(): void;
+  _updatePoly(layer: any, closed?: boolean): void;
+  _updateCircle(layer: any): void;
+  _fillStroke(ctx: CanvasRenderingContext2D, layer: any): void;
+  _onClick(e: any): void;
+  _onPointerMove(e: any): void;
+  _handlePointerOut(e: any): void;
+  _handlePointerHover(e: any, point: any): void;
+  _fireEvent(layers: any[] | false, e: any, type?: string): void;
+  _bringToFront(layer: any): void;
+  _bringToBack(layer: any): void;
+}

package/dist/core-map/layer/vector/Circle.d.ts

@@ -0,0 +1,7 @@
+import { CircleMarker } from './CircleMarker';
+import { LatLngBounds } from '../../geo/LatLngBounds';
+export declare class Circle extends CircleMarker {
+  initialize(latlng: any, options?: any): void;
+  getBounds(): LatLngBounds;
+  _project(): void;
+}

package/dist/core-map/layer/vector/CircleMarker.d.ts

@@ -0,0 +1,22 @@
+import { LatLng } from '../../geo/LatLng';
+import { Path } from './Path';
+import type { Point } from '../../geometry/Point';
+export declare class CircleMarker extends Path {
+  _latlng: LatLng;
+  _radius: number;
+  _point?: Point;
+  _pxRadius?: number;
+  _pxRadiusY?: number;
+  initialize(latlng: any, options?: any): void;
+  setLatLng(latlng: any): this;
+  getLatLng(): LatLng;
+  setRadius(radius: number): this;
+  getRadius(): number;
+  setStyle(options?: any): this;
+  _project(): void;
+  _updateBounds(): void;
+  _update(): void;
+  _updatePath(): void;
+  _empty(): boolean;
+  _containsPoint(p: Point): boolean;
+}

package/dist/core-map/layer/vector/Path.d.ts

@@ -0,0 +1,20 @@
+import { Layer } from '../Layer';
+export declare class Path extends Layer {
+  _renderer?: any;
+  _path?: any;
+  _pxBounds?: any;
+  _parts?: any[];
+  beforeAdd(map: any): void;
+  onAdd(): void;
+  onRemove(): void;
+  redraw(): this;
+  setStyle(style: any): this;
+  bringToFront(): this;
+  bringToBack(): this;
+  getElement(): any;
+  _reset(): void;
+  _clickTolerance(): number;
+  _project(): void;
+  _update(): void;
+  _updateBounds(): void;
+}

package/dist/core-map/layer/vector/Polygon.d.ts

@@ -0,0 +1,13 @@
+import { LatLng } from '../../geo/LatLng';
+import { Point } from '../../geometry/Point';
+import { Polyline } from './Polyline';
+export declare class Polygon extends Polyline {
+  isEmpty(): boolean;
+  getCenter(): LatLng;
+  _convertLatLngs(latlngs: any[]): any[];
+  _setLatLngs(latlngs: any[]): void;
+  _defaultShape(): any[];
+  _clipPoints(): void;
+  _updatePath(): void;
+  _containsPoint(p: Point): boolean;
+}

package/dist/core-map/layer/vector/Polyline.d.ts

@@ -0,0 +1,30 @@
+import { Bounds } from '../../geometry/Bounds';
+import { LatLng } from '../../geo/LatLng';
+import { LatLngBounds } from '../../geo/LatLngBounds';
+import { Path } from './Path';
+import { Point } from '../../geometry/Point';
+export declare class Polyline extends Path {
+  _latlngs: any[];
+  _bounds: LatLngBounds;
+  _rings: Point[][];
+  _rawPxBounds?: Bounds;
+  initialize(latlngs: any[], options?: any): void;
+  getLatLngs(): any[];
+  setLatLngs(latlngs: any[]): this;
+  isEmpty(): boolean;
+  closestLayerPoint(p: Point): (Point & { distance?: number }) | null;
+  getCenter(): LatLng;
+  getBounds(): LatLngBounds;
+  addLatLng(latlng: any, latlngs?: any[]): this;
+  _setLatLngs(latlngs: any[]): void;
+  _defaultShape(): any[];
+  _convertLatLngs(latlngs: any[]): any[];
+  _project(): void;
+  _updateBounds(): void;
+  _projectLatlngs(latlngs: any[], result: Point[][], projectedBounds: Bounds): void;
+  _clipPoints(): void;
+  _simplifyPoints(): void;
+  _update(): void;
+  _updatePath(): void;
+  _containsPoint(p: Point, closed?: boolean): boolean;
+}

package/dist/core-map/layer/vector/Rectangle.d.ts

@@ -0,0 +1,6 @@
+import { Polygon } from './Polygon';
+export declare class Rectangle extends Polygon {
+  initialize(latLngBounds: any, options?: any): void;
+  setBounds(latLngBounds: any): this;
+  _boundsToLatLngs(latLngBounds: any): any[];
+}

package/dist/core-map/layer/vector/Renderer.d.ts

@@ -0,0 +1,12 @@
+import { BlanketOverlay } from '../BlanketOverlay';
+export declare class Renderer extends BlanketOverlay {
+  _layers: Record<number, any>;
+  initialize(options?: any): void;
+  onAdd(map?: any): void;
+  onRemove(map?: any): void;
+  _onZoomEnd(): void;
+  _updatePaths(): void;
+  _onViewReset(): void;
+  _onSettled(_ev?: any): void;
+  _update(): void;
+}

package/dist/core-map/layer/vector/Renderer.getRenderer.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core-map/layer/vector/SVG.d.ts

@@ -0,0 +1,21 @@
+import { Renderer } from './Renderer';
+export declare class SVG extends Renderer {
+  _rootGroup?: SVGGElement;
+  _svgSize?: any;
+  _initContainer(): void;
+  _destroyContainer(): void;
+  _resizeContainer(): any;
+  _update(): void;
+  _initPath(layer: any): void;
+  _addPath(layer: any): void;
+  _removePath(layer: any): void;
+  _updatePath(layer: any): void;
+  _updateStyle(layer: any): void;
+  _updatePoly(layer: any, closed?: boolean): void;
+  _updateCircle(layer: any): void;
+  _setPath(layer: any, path: string): void;
+  _bringToFront(layer: any): void;
+  _bringToBack(layer: any): void;
+  static create(name: string): SVGElement;
+  static pointsToPath(rings: any[], closed?: boolean): string;
+}

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

@@ -0,0 +1,10 @@
+import './Renderer.getRenderer';
+export { Canvas } from './Canvas';
+export { Circle } from './Circle';
+export { CircleMarker } from './CircleMarker';
+export { Path } from './Path';
+export { Polygon } from './Polygon';
+export { Polyline } from './Polyline';
+export { Rectangle } from './Rectangle';
+export { Renderer } from './Renderer';
+export { SVG } from './SVG';