ts-maps 0.2.6 → 0.3.0

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

@@ -0,0 +1,24 @@
+// Returns the unique ID of an object, assigning it one if it doesn't have it.
+export declare function stamp(obj: any): number;
+export declare function setLastId(id: number): void;
+// Returns a function which executes `fn` no more than one time per given amount of `time`.
+export declare function throttle< T extends (...args: any[]) => any >(fn: T, time: number, context?: any): (...args: Parameters < T>) => void;
+// Returns the number `num` modulo `range` so it lies within `range[0]` and `range[1]`.
+export declare function wrapNum(x: number, range: [number, number] | number[], includeMax?: boolean): number;
+// Always returns false.
+export declare function falseFn(..._args: any[]): false;
+// Returns the number `num` rounded with specified `precision` (default 6 decimal places).
+export declare function formatNum(num: number, precision?: number | false): number;
+// Trims and splits the string on whitespace and returns the array of parts.
+export declare function splitWords(str: string): string[];
+// Merges the given properties to the `options` of the `obj`, returning the resulting options.
+export declare function setOptions< T extends { options?: Record<string, any> } >(obj: T, options?: Record<string, any>): Record<string, any>;
+// Simple templating facility: `'Hello {a}, {b}'` + `{a: 'foo', b: 'bar'}` -> `'Hello foo, bar'`.
+export declare function template(str: string, data: Record<string, any>): string;
+// No-op function.
+export declare function noop(): void;
+/**
+ * Various utility functions, used internally.
+ * @defaultValue 0
+ */
+export declare let lastId: number;

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

@@ -0,0 +1,7 @@
+import * as Util from './Util';
+export type { EventHandler, EventListener } from './Events';
+export { default as Browser } from './Browser';
+export { Class } from './Class';
+export { Evented } from './Events';
+export { Handler } from './Handler';
+export { Util };

package/dist/core-map/dom/Animation.d.ts

@@ -0,0 +1,50 @@
+import { Evented } from '../core/Events';
+import type { EasingFunction } from './easing';
+export type { EasingFunction } from './easing';
+export declare interface AnimationFrame {
+  progress: number
+  t: number
+  dt: number
+}
+export declare interface AnimationOptions {
+  duration: number
+  easing?: EasingFunction
+  onStart?: () => void
+  onFrame: (frame: AnimationFrame) => void
+  onEnd?: (completed: boolean) => void
+}
+/**
+ * Unified animation engine for the camera (center / zoom / bearing / pitch /
+ * padding). Single-timeline, easing-driven. The caller is responsible for
+ * interpolating the actual properties inside `onFrame` — `Animation` only
+ * provides the `t` value. That keeps it composable: multi-axis gestures can
+ * drive bearing/pitch/zoom in concert by constructing the right `onFrame`
+ * closure without the engine needing to know about maps.
+ *
+ * Only one `run()` can be active at a time. Calling `run()` on a running
+ * animation cancels the previous one (fires its `onEnd(false)`) before
+ * starting fresh.
+ *
+ * Events fired (in addition to the callback hooks):
+ *   `start`   — before the first `onFrame`
+ *   `frame`   — every tick, with `{ progress, t, dt }`
+ *   `end`     — on completion or cancellation, with `{ completed }`
+ */
+export declare class Animation extends Evented {
+  _opts?: AnimationOptions;
+  _easing: EasingFunction;
+  _startTime: number;
+  _lastTime: number;
+  _duration: number;
+  _animId?: number;
+  _running: boolean;
+  _pendingStart: boolean;
+  constructor();
+  run(opts: AnimationOptions): void;
+  cancel(): void;
+  stop(): void;
+  isRunning(): boolean;
+  _tick(timestamp: number): void;
+  _emitFrame(progress: number, t: number, dt: number): void;
+  _finish(completed: boolean): void;
+}

package/dist/core-map/dom/DomEvent.DoubleTap.d.ts

@@ -0,0 +1,6 @@
+export declare function addDoubleTapListener(obj: any, handler: EventListener): DoubleTapHandlers;
+export declare function removeDoubleTapListener(obj: any, handlers: DoubleTapHandlers): void;
+export declare interface DoubleTapHandlers {
+  dblclick: EventListener
+  simDblclick: (ev: Event) => void
+}

package/dist/core-map/dom/DomEvent.PointerEvents.d.ts

@@ -0,0 +1,4 @@
+export declare function enablePointerDetection(el: Element): void;
+export declare function disablePointerDetection(el: Element): void;
+export declare function getPointers(): PointerEvent[];
+export declare function cleanupPointers(): void;

package/dist/core-map/dom/DomEvent.d.ts

@@ -0,0 +1,15 @@
+import { Point } from '../geometry/Point';
+import * as PointerEvents from './DomEvent.PointerEvents';
+export declare function on(this: any, obj: any, types: any, fn?: any, context?: any): any;
+export declare function off(this: any, obj: any, types?: any, fn?: any, context?: any): any;
+export declare function stopPropagation(this: any, e: any): any;
+export declare function disableScrollPropagation(this: any, el: any): any;
+export declare function disableClickPropagation(this: any, el: any): any;
+export declare function preventDefault(this: any, e: any): any;
+export declare function stop(this: any, e: any): any;
+export declare function getPropagationPath(ev: any): any[];
+export declare function getPointerPosition(e: any, container?: HTMLElement): Point;
+export declare function getWheelPxFactor(): number;
+export declare function getWheelDelta(e: any): number;
+export declare function isExternalTarget(el: Element, e: any): boolean;
+export { PointerEvents };

package/dist/core-map/dom/DomUtil.d.ts

@@ -0,0 +1,22 @@
+import { Point } from '../geometry/Point';
+export declare function get(id: string | HTMLElement): HTMLElement | null;
+export declare function create< K extends keyof HTMLElementTagNameMap >(tagName: K, className?: string, container?: HTMLElement | null): HTMLElementTagNameMap[K];
+export declare function create(tagName: string, className?: string, container?: HTMLElement | null): HTMLElement;
+export declare function toFront(el: Element): void;
+export declare function toBack(el: Element): void;
+export declare function setTransform(el: HTMLElement, offset?: Point | null, scale?: number, rotation?: number, pitch?: number): void;
+export declare function setPosition(el: HTMLElement, point: Point, rotation?: number, pitch?: number): void;
+export declare function getPosition(el: HTMLElement): Point;
+export declare function disableTextSelection(): void;
+export declare function enableTextSelection(): void;
+export declare function disableImageDrag(): void;
+export declare function enableImageDrag(): void;
+export declare function preventOutline(element: HTMLElement): void;
+export declare function restoreOutline(): void;
+export declare function getSizedParentNode(element: HTMLElement): HTMLElement;
+export declare function getScale(element: HTMLElement): ScaleInfo;
+export declare interface ScaleInfo {
+  x: number
+  y: number
+  boundingClientRect: DOMRect
+}

package/dist/core-map/dom/Draggable.d.ts

@@ -0,0 +1,26 @@
+import { Evented } from '../core/Events';
+import { Point } from '../geometry/Point';
+import * as DomUtil from './DomUtil';
+export declare class Draggable extends Evented {
+  static _dragging: Draggable | false;
+  _element: HTMLElement;
+  _dragStartTarget: HTMLElement;
+  _preventOutline?: boolean;
+  _enabled?: boolean;
+  _moved?: boolean;
+  _moving?: boolean;
+  _startPoint?: Point;
+  _startPos?: Point;
+  _newPos?: Point;
+  _lastEvent?: PointerEvent;
+  _lastTarget?: HTMLElement | null;
+  _parentScale?: DomUtil.ScaleInfo;
+  initialize(element: HTMLElement, dragStartTarget?: HTMLElement, preventOutline?: boolean, options?: any): void;
+  enable(): this;
+  disable(): this;
+  _onDown(e: PointerEvent): void;
+  _onMove(e: PointerEvent): void;
+  _updatePosition(): void;
+  _onUp(): void;
+  finishDrag(noInertia?: boolean): void;
+}

package/dist/core-map/dom/PosAnimation.d.ts

@@ -0,0 +1,19 @@
+import { Evented } from '../core/Events';
+import type { Point } from '../geometry/Point';
+export declare class PosAnimation extends Evented {
+  _el?: HTMLElement;
+  _inProgress?: boolean;
+  _duration?: number;
+  _easeOutPower?: number;
+  _startPos?: Point;
+  _offset?: Point;
+  _startTime?: number;
+  _animId?: number;
+  run(el: HTMLElement, newPos: Point, duration?: number, easeLinearity?: number): void;
+  stop(): void;
+  _animate(): void;
+  _step(round?: boolean): void;
+  _runFrame(progress: number, round?: boolean): void;
+  _complete(): void;
+  _easeOut(t: number): number;
+}

package/dist/core-map/dom/easing.d.ts

@@ -0,0 +1,41 @@
+export declare function linear(t: number): number;
+export declare function easeInQuad(t: number): number;
+export declare function easeOutQuad(t: number): number;
+export declare function easeInOutQuad(t: number): number;
+export declare function easeInCubic(t: number): number;
+export declare function easeOutCubic(t: number): number;
+export declare function easeInOutCubic(t: number): number;
+export declare function easeInQuart(t: number): number;
+export declare function easeOutQuart(t: number): number;
+export declare function easeInOutQuart(t: number): number;
+/**
+ * `easeOutBack` overshoots slightly past 1 before settling — useful for tiny
+ * button-like pops. Do **not** use this as a camera-easing default because
+ * the overshoot translates into a brief zoom past the target, which looks
+ * glitchy on map moves.
+ */
+export declare function easeOutBack(t: number): number;
+/**
+ * Returns an easing function that evaluates a cubic Bezier curve with the
+ * given control points at `t`. The endpoints are fixed at `(0, 0)` and
+ * `(1, 1)`; `(x1, y1)` and `(x2, y2)` are the two inner control points.
+ *
+ * This is the same parameterization as CSS `cubic-bezier(x1, y1, x2, y2)`,
+ * so `cubicBezier(0.25, 0.1, 0.25, 1)` reproduces the CSS `ease` curve.
+ *
+ * Newton-Raphson is used to find the Bezier parameter `s` that matches the
+ * requested `x = t`. We cap iteration to 10 with an epsilon of 1e-5, which
+ * is plenty for frame-rate-driven animation.
+ */
+export declare function cubicBezier(x1: number, y1: number, x2: number, y2: number): EasingFunction;
+/**
+ * Zero-dependency easing functions. Every function takes `t` in `[0, 1]` and
+ * returns a value in `[0, 1]` (the `easeOutBack` variant can temporarily
+ * overshoot past `1`, by design — it's the "spring-tap" feel used in button
+ * micro-animations, not the default for camera moves).
+ *
+ * The default camera easing is `easeInOutCubic`, which matches what most
+ * slippy-map libraries (Leaflet, Mapbox GL JS's `easeTo`) feel like out of
+ * the box.
+ */
+export type EasingFunction = (_t: number) => number;

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

@@ -0,0 +1,8 @@
+import * as DomEvent from './DomEvent';
+import * as DomUtil from './DomUtil';
+export type { AnimationFrame, AnimationOptions, EasingFunction } from './Animation';
+export { PosAnimation } from './PosAnimation';
+export { Animation } from './Animation';
+export * as easing from './easing';
+export { DomEvent, DomUtil };
+export { Draggable } from './Draggable';

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

@@ -0,0 +1,18 @@
+import { LatLngBounds } from './LatLngBounds';
+export declare function toLatLng(a: LatLngLike | null | undefined, b?: number, c?: number): LatLng;
+export type LatLngTuple = [number, number] | [number, number, number];
+export type LatLngLike = LatLng | LatLngTuple | { lat: number, lng?: number, lon?: number, alt?: number } | number;
+// Represents a geographical point (latitude, longitude, optional altitude).
+export declare class LatLng {
+  lat: number;
+  lng: number;
+  alt?: number;
+  constructor(lat: LatLngLike | number, lng?: number, alt?: number);
+  static validate(lat: any, lng?: any, _alt?: any): boolean;
+  equals(obj: LatLngLike, maxMargin?: number): boolean;
+  toString(precision?: number): string;
+  distanceTo(other: LatLngLike): number;
+  wrap(): LatLng;
+  toBounds(sizeInMeters: number): LatLngBounds;
+  clone(): LatLng;
+}

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

@@ -0,0 +1,27 @@
+import { LatLng } from './LatLng';
+import type { LatLngLike } from './LatLng';
+export declare function toLatLngBounds(a?: any, b?: LatLngLike): LatLngBounds;
+export type LatLngBoundsLike = LatLngBounds | [LatLngLike, LatLngLike] | LatLngLike[];
+// Represents a rectangular geographical area on a map.
+export declare class LatLngBounds {
+  _southWest?: LatLng;
+  _northEast?: LatLng;
+  constructor(corner1?: any, corner2?: LatLngLike);
+  extend(obj: any): this;
+  pad(bufferRatio: number): LatLngBounds;
+  getCenter(): LatLng;
+  getSouthWest(): LatLng;
+  getNorthEast(): LatLng;
+  getNorthWest(): LatLng;
+  getSouthEast(): LatLng;
+  getWest(): number;
+  getSouth(): number;
+  getEast(): number;
+  getNorth(): number;
+  contains(obj: any): boolean;
+  intersects(bounds: LatLngBoundsLike): boolean;
+  overlaps(bounds: LatLngBoundsLike): boolean;
+  toBBoxString(): string;
+  equals(bounds: LatLngBoundsLike | null | undefined, maxMargin?: number): boolean;
+  isValid(): boolean;
+}

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

@@ -0,0 +1,35 @@
+import { type DEMEncoding } from './elevation';
+export declare interface TerrainSourceOptions {
+  demSize?: number
+  encoding?: DEMEncoding
+  meshResolution?: number
+  exaggeration?: number
+}
+export declare interface TileCoord {
+  z: number
+  x: number
+  y: number
+}
+/**
+ * Stores decoded DEM tiles keyed on `"z/x/y"` and serves elevation
+ * queries. Thread-safe with respect to async add/remove — the underlying
+ * Map is the only mutable state.
+ */
+export declare class TerrainSource {
+  _tiles: Map<string, Float32Array>;
+  _opts: Required<TerrainSourceOptions>;
+  constructor(opts?: TerrainSourceOptions);
+  get demSize(): number;
+  get encoding(): DEMEncoding;
+  get meshResolution(): number;
+  get exaggeration(): number;
+  setExaggeration(v: number): void;
+  addTilePixels(coord: TileCoord, pixels: Uint8Array | Uint8ClampedArray): void;
+  addTileElevation(coord: TileCoord, elevation: Float32Array): void;
+  hasTile(coord: TileCoord): boolean;
+  getTile(coord: TileCoord): Float32Array | undefined;
+  deleteTile(coord: TileCoord): void;
+  clear(): void;
+  size(): number;
+  queryElevation(lng: number, lat: number, preferredZoom: number): number | null;
+}

package/dist/core-map/geo/crs/CRS.d.ts

@@ -0,0 +1,23 @@
+import { Bounds } from '../../geometry/Bounds';
+import { LatLng } from '../LatLng';
+import { LatLngBounds } from '../LatLngBounds';
+import type { Point } from '../../geometry/Point';
+import type { Transformation } from '../../geometry/Transformation';
+export declare class CRS {
+  static projection: any;
+  static transformation: Transformation | undefined;
+  static code?: string;
+  static wrapLng?: [number, number];
+  static wrapLat?: [number, number];
+  static infinite: boolean;
+  static latLngToPoint(this: any, latlng: LatLng, zoom: number): Point;
+  static pointToLatLng(this: any, point: Point, zoom: number): LatLng;
+  static project(this: any, latlng: LatLng): Point;
+  static unproject(this: any, point: Point): LatLng;
+  static scale(zoom: number): number;
+  static zoom(scale: number): number;
+  static getProjectedBounds(this: any, zoom: number): Bounds | null;
+  static distance(_a: LatLng, _b: LatLng): number;
+  static wrapLatLng(this: any, latlng: LatLng): LatLng;
+  static wrapLatLngBounds(this: any, bounds: LatLngBounds): LatLngBounds;
+}

package/dist/core-map/geo/crs/EPSG3395.d.ts

@@ -0,0 +1,7 @@
+import { EarthCRS } from './EarthCRS';
+import { Transformation } from '../../geometry/Transformation';
+export declare class EPSG3395 extends EarthCRS {
+  static code: string;
+  static projection: any;
+  static transformation: Transformation;
+}

package/dist/core-map/geo/crs/EPSG3857.d.ts

@@ -0,0 +1,10 @@
+import { EarthCRS } from './EarthCRS';
+import { Transformation } from '../../geometry/Transformation';
+export declare class EPSG3857 extends EarthCRS {
+  static code: string;
+  static projection: any;
+  static transformation: Transformation;
+}
+export declare class EPSG900913 extends EPSG3857 {
+  static code: string;
+}

package/dist/core-map/geo/crs/EPSG4326.d.ts

@@ -0,0 +1,7 @@
+import { EarthCRS } from './EarthCRS';
+import { Transformation } from '../../geometry/Transformation';
+export declare class EPSG4326 extends EarthCRS {
+  static code: string;
+  static projection: any;
+  static transformation: Transformation;
+}

package/dist/core-map/geo/crs/EarthCRS.d.ts

@@ -0,0 +1,7 @@
+import { CRS } from './CRS';
+import type { LatLng } from '../LatLng';
+export declare class EarthCRS extends CRS {
+  static wrapLng: [number, number];
+  static R: number;
+  static distance(latlng1: LatLng, latlng2: LatLng): number;
+}

package/dist/core-map/geo/crs/SimpleCRS.d.ts

@@ -0,0 +1,11 @@
+import { CRS } from './CRS';
+import { Transformation } from '../../geometry/Transformation';
+import type { LatLng } from '../LatLng';
+export declare class SimpleCRS extends CRS {
+  static projection: any;
+  static transformation: Transformation;
+  static infinite: boolean;
+  static scale(zoom: number): number;
+  static zoom(scale: number): number;
+  static distance(latlng1: LatLng, latlng2: LatLng): number;
+}

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

@@ -0,0 +1,6 @@
+export { CRS } from './CRS';
+export { EarthCRS } from './EarthCRS';
+export { EPSG3395 } from './EPSG3395';
+export { EPSG3857, EPSG900913 } from './EPSG3857';
+export { EPSG4326 } from './EPSG4326';
+export { SimpleCRS } from './SimpleCRS';

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

@@ -0,0 +1,23 @@
+export declare function decodeMapboxRGB(r: number, g: number, b: number): number;
+export declare function decodeTerrariumRGB(r: number, g: number, b: number): number;
+export declare function getElevationDecoder(encoding: DEMEncoding): (r: number, g: number, b: number) => number;
+/**
+ * Decode an entire RGBA pixel buffer into a flat `Float32Array` of elevation
+ * samples in metres. The caller controls the encoding.
+ */
+export declare function decodeElevationGrid(pixels: Uint8Array | Uint8ClampedArray, encoding?: DEMEncoding): Float32Array;
+/**
+ * Bilinearly sample a square elevation grid at the fractional pixel
+ * coordinate `(u, v)`, where `(0, 0)` is the top-left pixel centre and
+ * `(size - 1, size - 1)` is the bottom-right. Out-of-range inputs clamp
+ * to the border (no extrapolation).
+ */
+export declare function sampleElevationBilinear(elev: Float32Array, size: number, u: number, v: number): number;
+// Helpers for reading elevation out of RGB-encoded DEM tiles. Shared
+// between the hillshade-producing `RasterDEMLayer` and the 3D terrain
+// pipeline, which samples per-vertex heights to warp a ground mesh.
+//
+// Two encodings are supported out of the box:
+//   - 'mapbox'    — Mapbox Terrain-RGB / Maxar (elevation = -10000 + (r*65536 + g*256 + b) * 0.1)
+//   - 'terrarium' — Mapzen / AWS Terrarium (elevation = (r*256 + g + b/256) - 32768)
+export type DEMEncoding = 'mapbox' | 'terrarium';

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

@@ -0,0 +1,13 @@
+import * as Projection from './projection/index';
+export type { LatLngLike, LatLngTuple } from './LatLng';
+export type { LatLngBoundsLike } from './LatLngBounds';
+export type { DEMEncoding } from './elevation';
+export type { TerrainMesh, TerrainMeshOptions } from './terrainMesh';
+export type { TerrainSourceOptions, TileCoord } from './TerrainSource';
+export { LatLng, toLatLng } from './LatLng';
+export { LatLngBounds, toLatLngBounds } from './LatLngBounds';
+export { decodeElevationGrid, decodeMapboxRGB, decodeTerrariumRGB, getElevationDecoder, sampleElevationBilinear } from './elevation';
+export { buildTerrainMesh } from './terrainMesh';
+export { TerrainSource } from './TerrainSource';
+export { Projection };
+export * from './crs/index';