ts-maps 0.2.6 → 0.3.0

package/dist/core-map/geo/projection/Projection.Globe.d.ts

@@ -0,0 +1,30 @@
+import { LatLng } from '../LatLng';
+import type { ProjectionLike } from './Projection.LonLat';
+export declare const Globe: GlobeProjection;
+/**
+ * Globe projection — renders tiles on a sphere at low zoom, transitioning
+ * to flat Mercator around zoom 5.5 to match the common convention.
+ *
+ * The 2D `project`/`unproject` pair returns the Mercator projection for
+ * compatibility with the rest of the pipeline (tile loading, pixel math).
+ * The sphere warp is a vertex-shader effect and lives in the renderer —
+ * this module exposes the helpers that shader needs: projection to 3D
+ * world coords on the unit sphere, and a `globeToMercatorMix(zoom)`
+ * easing that selects how much to warp.
+ *
+ * Keep everything zero-dep and pure-math so it composes with the WebGL
+ * renderer without having to import DOM types.
+ */
+export declare interface GlobeVec3 {
+  x: number
+  y: number
+  z: number
+}
+export declare interface GlobeProjection extends ProjectionLike {
+  R: number
+  GLOBE_START_ZOOM: number
+  GLOBE_END_ZOOM: number
+  toSphere: (latlng: any) => GlobeVec3
+  fromSphere: (v: GlobeVec3) => LatLng
+  globeToMercatorMix: (zoom: number) => number
+}

package/dist/core-map/geo/projection/Projection.LonLat.d.ts

@@ -0,0 +1,11 @@
+import { Bounds } from '../../geometry/Bounds';
+import { LatLng } from '../LatLng';
+import { Point } from '../../geometry/Point';
+// Equirectangular (Plate Carree) projection.
+export declare const LonLat: ProjectionLike;
+export declare interface ProjectionLike {
+  bounds: Bounds
+  project: (latlng: any) => Point
+  unproject: (point: any) => LatLng
+  [k: string]: any
+}

package/dist/core-map/geo/projection/Projection.Mercator.d.ts

@@ -0,0 +1,6 @@
+// Elliptical Mercator projection (EPSG:3395).
+export declare const Mercator: MercatorProjection;
+declare interface MercatorProjection extends ProjectionLike {
+  R: number
+  R_MINOR: number
+}

package/dist/core-map/geo/projection/Projection.SphericalMercator.d.ts

@@ -0,0 +1,6 @@
+// Spherical Mercator projection — the most common for online maps (EPSG:3857).
+export declare const SphericalMercator: SphericalMercatorProjection;
+declare interface SphericalMercatorProjection extends ProjectionLike {
+  R: number
+  MAX_LATITUDE: number
+}

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

@@ -0,0 +1,5 @@
+export type { GlobeProjection, GlobeVec3 } from './Projection.Globe';
+export { Globe } from './Projection.Globe';
+export { LonLat } from './Projection.LonLat';
+export { Mercator } from './Projection.Mercator';
+export { SphericalMercator } from './Projection.SphericalMercator';

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

@@ -0,0 +1,21 @@
+/**
+ * Builds a terrain mesh for a single DEM tile. Pure function — no DOM /
+ * WebGL calls. Returns typed arrays ready to feed to
+ * `WebGLTileRenderer.drawTerrain`.
+ */
+export declare function buildTerrainMesh(opts: TerrainMeshOptions): TerrainMesh;
+export declare interface TerrainMeshOptions {
+  elevation: Float32Array
+  demSize: number
+  tileSize?: number
+  resolution?: number
+  exaggeration?: number
+  unitsPerMeter?: number
+}
+export declare interface TerrainMesh {
+  positions: Float32Array
+  indices: Uint32Array
+  vertexCount: number
+  indexCount: number
+  resolution: number
+}

package/dist/core-map/geometry/Bounds.d.ts

@@ -0,0 +1,23 @@
+import { Point } from './Point';
+import type { PointLike } from './Point';
+export declare function toBounds(a?: BoundsLike | PointLike, b?: PointLike): Bounds;
+export type BoundsLike = Bounds | [PointLike, PointLike] | Point[] | PointLike[];
+// Represents a rectangular area in pixel coordinates.
+export declare class Bounds {
+  min: Point;
+  max: Point;
+  constructor(a?: BoundsLike | PointLike, b?: PointLike);
+  extend(obj: any): this;
+  getCenter(round?: boolean): Point;
+  getBottomLeft(): Point;
+  getTopRight(): Point;
+  getTopLeft(): Point;
+  getBottomRight(): Point;
+  getSize(): Point;
+  contains(obj: any): boolean;
+  intersects(bounds: BoundsLike | PointLike): boolean;
+  overlaps(bounds: BoundsLike | PointLike): boolean;
+  isValid(): boolean;
+  pad(bufferRatio: number): Bounds;
+  equals(bounds: BoundsLike | PointLike | null | undefined): boolean;
+}

package/dist/core-map/geometry/LineUtil.d.ts

@@ -0,0 +1,13 @@
+import { LatLng } from '../geo/LatLng';
+import { Point } from './Point';
+import type { Bounds } from './Bounds';
+export declare function simplify(points: Point[], tolerance: number): Point[];
+export declare function pointToSegmentDistance(p: Point, p1: Point, p2: Point): number;
+export declare function closestPointOnSegment(p: Point, p1: Point, p2: Point): Point;
+// Cohen-Sutherland segment clipping.
+export declare function clipSegment(a: Point, b: Point, bounds: Bounds, useLastCode?: boolean, round?: boolean): [Point, Point] | false;
+export declare function _getEdgeIntersection(a: Point, b: Point, code: number, bounds: Bounds, round?: boolean): Point;
+export declare function _getBitCode(p: Point, bounds: Bounds): number;
+export declare function _sqClosestPointOnSegment(p: Point, p1: Point, p2: Point, sqDist?: boolean): Point | number;
+export declare function isFlat(latlngs: any[]): boolean;
+export declare function polylineCenter(latlngs: any[], crs: any): LatLng;

package/dist/core-map/geometry/Point.d.ts

@@ -0,0 +1,35 @@
+// Helper that normalizes any accepted input to a Point. Useful for public API methods
+// that accept coordinate pairs in multiple forms.
+export declare function toPoint(x: PointLike | number[] | null | undefined, y?: number, round?: boolean): Point;
+export type PointTuple = [number, number];
+export type PointLike = Point | PointTuple | { x: number, y: number } | number;
+// Represents a point with `x` and `y` coordinates in pixels.
+export declare class Point {
+  x: number;
+  y: number;
+  constructor(x: PointLike | number[], y?: number, round?: boolean);
+  static validate(x: any, y?: any): boolean;
+  clone(): Point;
+  add(point: PointLike | number[]): Point;
+  _add(point: Point): this;
+  subtract(point: PointLike | number[]): Point;
+  _subtract(point: Point): this;
+  divideBy(num: number): Point;
+  _divideBy(num: number): this;
+  multiplyBy(num: number): Point;
+  _multiplyBy(num: number): this;
+  scaleBy(point: Point): Point;
+  unscaleBy(point: Point): Point;
+  round(): Point;
+  _round(): this;
+  floor(): Point;
+  _floor(): this;
+  ceil(): Point;
+  _ceil(): this;
+  trunc(): Point;
+  _trunc(): this;
+  distanceTo(point: PointLike | number[]): number;
+  equals(point: PointLike | number[]): boolean;
+  contains(point: PointLike | number[]): boolean;
+  toString(): string;
+}

package/dist/core-map/geometry/PolyUtil.d.ts

@@ -0,0 +1,6 @@
+import { LatLng } from '../geo/LatLng';
+import { Point } from './Point';
+import type { Bounds } from './Bounds';
+export declare function clipPolygon(points: Array<Point & { _code?: number }>, bounds: Bounds, round?: boolean): Point[];
+export declare function polygonCenter(latlngs: any[], crs: any): LatLng;
+export declare function centroid(coords: any[]): LatLng;

package/dist/core-map/geometry/RTree.d.ts

@@ -0,0 +1,35 @@
+export declare interface RTreeNode<T> {
+  bbox: BBox
+  children?: Array<RTreeNode<T>>
+  leaf?: boolean
+  data?: T
+}
+export declare interface RTreeEntry<T> {
+  bbox: BBox
+  data: T
+}
+// Zero-dep R-tree with incremental insertion, bulk-loading (STR), removal, and
+// bbox/point search. Inspired by the public-domain algorithms popularized by
+// rbush (MIT) — this implementation is written fresh in TypeScript and does
+// not reuse any of its code.
+//
+// The tree stores axis-aligned bounding boxes associated with arbitrary data.
+// Non-leaf nodes keep a union bbox over their children; leaf nodes hold the
+// user-provided `data`. Keeping the separation explicit (via `leaf: true`)
+// lets us walk the tree without instanceof checks and keeps the structure
+// compatible with `isolatedDeclarations`.
+export type BBox = [minX: number, minY: number, maxX: number, maxY: number];
+// ---------------------------------------------------------------------------
+// R-tree
+// ---------------------------------------------------------------------------
+export declare class RTree<T> {
+  constructor(opts?: { maxEntries?: number, minEntries?: number });
+  size(): number;
+  clear(): this;
+  insert(bbox: BBox, data: T): this;
+  remove(bbox: BBox, data: T, equalsFn?: (a: T, b: T) => boolean): this;
+  search(bbox: BBox): Array<RTreeEntry<T>>;
+  searchPoint(x: number, y: number): Array<RTreeEntry<T>>;
+  all(): Array<RTreeEntry<T>>;
+  load(items: Array<RTreeEntry<T>>): this;
+}

package/dist/core-map/geometry/Transformation.d.ts

@@ -0,0 +1,12 @@
+import { Point } from './Point';
+export declare function toTransformation(a: number | number[], b?: number, c?: number, d?: number): Transformation;
+export declare class Transformation {
+  _a: number;
+  _b: number;
+  _c: number;
+  _d: number;
+  constructor(a: number | number[], b?: number, c?: number, d?: number);
+  transform(point: Point, scale?: number): Point;
+  _transform(point: Point, scale?: number): Point;
+  untransform(point: Point, scale?: number): Point;
+}

package/dist/core-map/geometry/earcut.d.ts

@@ -0,0 +1,17 @@
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+export declare function earcut(vertices: ArrayLike<number>, holes?: number[], dim?: number): number[];
+// Compute the deviation between the polygon area and the total area of the
+// produced triangulation. `0` means a perfect triangulation; small positive
+// numbers indicate rounding error or degenerate geometry.
+export declare function deviation(data: ArrayLike<number>, holes: number[] | undefined, dim: number, triangles: number[]): number;
+// Flatten a GeoJSON-style polygon (array of rings, each an array of points
+// with `x`/`y`) into the flat buffers earcut consumes. Accepts the legacy
+// `[x, y][][]` encoding as well. Hole indices are start-of-ring offsets
+// expressed in vertex counts (not coordinate counts).
+export declare function flatten(data: number[][][] | Array<Array<{ x: number, y: number }>>): {
+  vertices: number[]
+  holes: number[]
+  dimensions: number
+};

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

@@ -0,0 +1,10 @@
+import * as LineUtil from './LineUtil';
+import * as PolyUtil from './PolyUtil';
+export type { BoundsLike } from './Bounds';
+export type { PointLike, PointTuple } from './Point';
+export type { BBox, RTreeEntry, RTreeNode } from './RTree';
+export { Bounds, toBounds } from './Bounds';
+export { Point, toPoint } from './Point';
+export { RTree } from './RTree';
+export { Transformation, toTransformation } from './Transformation';
+export { LineUtil, PolyUtil };