ts-maps 0.2.6 → 0.3.0

package/dist/core-map/proto/Pbf.d.ts

@@ -0,0 +1,84 @@
+// Protobuf decoder — in-house, zero-dep.
+// Inspired by the wire-format descriptions in mapbox/pbf (BSD-3-Clause);
+// this implementation is an independent TypeScript rewrite.
+//
+// Implements the subset of the protobuf wire format needed to read
+// Mapbox Vector Tiles v2 (plus symmetric write support for fixtures
+// and debug tooling). Groups (wire types 3 and 4) are not supported.
+// See https://protobuf.dev/programming-guides/encoding/ for details.
+// Wire types, per the protobuf spec.
+export declare const PBF_VARINT: number;
+export declare const PBF_FIXED64: number;
+export declare const PBF_BYTES: number;
+export declare const PBF_FIXED32: number;
+// eslint-disable-next-line no-unused-vars
+export type PbfReadFieldFn<T> = (tag: number, result: T, pbf: Pbf) => void;
+// eslint-disable-next-line no-unused-vars
+export type PbfWriteFn<V> = (value: V, pbf: Pbf) => void;
+export declare class Pbf {
+  buf: Uint8Array;
+  pos: number;
+  type: number;
+  length: number;
+  constructor(buf?: Uint8Array | ArrayBuffer);
+  readFields<T>(readField: PbfReadFieldFn<T>, result: T, end?: number): T;
+  readMessage<T>(readField: PbfReadFieldFn<T>, result: T): T;
+  readFixed32(): number;
+  readSFixed32(): number;
+  readFixed64(): number;
+  readSFixed64(): number;
+  readFloat(): number;
+  readDouble(): number;
+  readVarint(isSigned?: boolean): number;
+  readVarint64(): number;
+  readSVarint(): number;
+  readBoolean(): boolean;
+  readString(): string;
+  readBytes(): Uint8Array;
+  readPackedVarint(arr?: number[], isSigned?: boolean): number[];
+  readPackedSVarint(arr?: number[]): number[];
+  readPackedBoolean(arr?: boolean[]): boolean[];
+  readPackedFloat(arr?: number[]): number[];
+  readPackedDouble(arr?: number[]): number[];
+  readPackedFixed32(arr?: number[]): number[];
+  readPackedSFixed32(arr?: number[]): number[];
+  readPackedFixed64(arr?: number[]): number[];
+  readPackedSFixed64(arr?: number[]): number[];
+  skip(val: number): void;
+  writeTag(tag: number, type: number): void;
+  realloc(min: number): void;
+  finish(): Uint8Array;
+  destroy(): void;
+  writeVarint(val: number): void;
+  writeSVarint(val: number): void;
+  writeBoolean(val: boolean): void;
+  writeString(str: string): void;
+  writeFloat(val: number): void;
+  writeDouble(val: number): void;
+  writeBytes(bytes: Uint8Array): void;
+  writeRawFixed32(val: number): void;
+  writeRawSFixed32(val: number): void;
+  writeRawFixed64(val: number): void;
+  writeRawSFixed64(val: number): void;
+  writeMessage<V>(tag: number, fn: PbfWriteFn<V>, value: V): void;
+  writePackedVarint(tag: number, arr: number[]): void;
+  writePackedSVarint(tag: number, arr: number[]): void;
+  writePackedBoolean(tag: number, arr: boolean[]): void;
+  writePackedFloat(tag: number, arr: number[]): void;
+  writePackedDouble(tag: number, arr: number[]): void;
+  writePackedFixed32(tag: number, arr: number[]): void;
+  writePackedSFixed32(tag: number, arr: number[]): void;
+  writePackedFixed64(tag: number, arr: number[]): void;
+  writePackedSFixed64(tag: number, arr: number[]): void;
+  writeBytesField(tag: number, buffer: Uint8Array): void;
+  writeFixed32(tag: number, val: number): void;
+  writeSFixed32(tag: number, val: number): void;
+  writeFixed64(tag: number, val: number): void;
+  writeSFixed64(tag: number, val: number): void;
+  writeVarintField(tag: number, val: number): void;
+  writeSVarintField(tag: number, val: number): void;
+  writeStringField(tag: number, str: string): void;
+  writeFloatField(tag: number, val: number): void;
+  writeDoubleField(tag: number, val: number): void;
+  writeBooleanField(tag: number, val: boolean): void;
+}

package/dist/core-map/renderer/webgl/GLContext.d.ts

@@ -0,0 +1,22 @@
+export declare interface GLContextOptions {
+  alpha?: boolean
+  premultipliedAlpha?: boolean
+  antialias?: boolean
+}
+// Thin wrapper around a WebGL2 rendering context. Centralises program
+// compilation + buffer creation + viewport resizing so the higher-level
+// renderer stays focused on draw orchestration. When WebGL2 is unavailable,
+// the constructor throws a typed error so callers can fall back cleanly.
+export declare class WebGLUnsupportedError extends Error {
+  constructor(message?: string);
+}
+export declare class GLContext {
+  gl: WebGL2RenderingContext;
+  canvas: HTMLCanvasElement;
+  constructor(canvas: HTMLCanvasElement, opts?: GLContextOptions);
+  compileProgram(vertSrc: string, fragSrc: string): WebGLProgram;
+  _compileShader(type: GLenum, src: string): WebGLShader;
+  createBuffer(data: ArrayBufferView, usage?: number): WebGLBuffer;
+  resize(width: number, height: number): void;
+  clear(r: number, g: number, b: number, a: number): void;
+}

package/dist/core-map/renderer/webgl/WebGLTileRenderer.d.ts

@@ -0,0 +1,86 @@
+import { GLContext } from './GLContext';
+export declare interface LineOptions {
+  width: number
+  color: RGBA
+  cap?: 'butt' | 'round' | 'square'
+  join?: 'miter' | 'round' | 'bevel'
+}
+export declare interface CircleOptions {
+  radius: number
+  color: RGBA
+  strokeColor?: RGBA
+  strokeWidth?: number
+}
+declare interface FillProgram {
+  program: WebGLProgram
+  u_matrix: WebGLUniformLocation | null
+  u_color: WebGLUniformLocation | null
+  a_position: number
+}
+declare interface LineProgram {
+  program: WebGLProgram
+  u_matrix: WebGLUniformLocation | null
+  u_color: WebGLUniformLocation | null
+  u_width: WebGLUniformLocation | null
+  a_position: number
+  a_normal: number
+  a_progress: number
+}
+declare interface CircleProgram {
+  program: WebGLProgram
+  u_matrix: WebGLUniformLocation | null
+  u_color: WebGLUniformLocation | null
+  u_stroke_color: WebGLUniformLocation | null
+  u_stroke_width: WebGLUniformLocation | null
+  u_radius: WebGLUniformLocation | null
+  a_center: number
+  a_offset: number
+}
+declare interface FillExtrusionProgram {
+  program: WebGLProgram
+  u_matrix: WebGLUniformLocation | null
+  u_color: WebGLUniformLocation | null
+  u_opacity: WebGLUniformLocation | null
+  a_position: number
+  a_normal: number
+}
+declare interface SkyProgram {
+  program: WebGLProgram
+  u_sky_color: WebGLUniformLocation | null
+  u_horizon_color: WebGLUniformLocation | null
+  u_pitch_t: WebGLUniformLocation | null
+  u_horizon_blend: WebGLUniformLocation | null
+  a_position: number
+}
+export declare interface FillExtrusionFootprint {
+  rings: Array<Array<{ x: number, y: number }>>
+}
+declare type RGBA = [number, number, number, number];
+export declare class WebGLTileRenderer {
+  ctx: GLContext;
+  _projection: Float32Array;
+  _fill: FillProgram;
+  _line: LineProgram;
+  _circle: CircleProgram;
+  _fillExtrusion: FillExtrusionProgram | null;
+  _sky: SkyProgram | null;
+  _buffers: WebGLBuffer[];
+  constructor(canvas: HTMLCanvasElement);
+  setProjectionMatrix(m: Float32Array): void;
+  clear(): void;
+  destroy(): void;
+  drawFill(triangles: Float32Array, color: RGBA): void;
+  drawLine(linestrip: Float32Array, options: LineOptions): void;
+  drawCircles(centers: Float32Array, options: CircleOptions): void;
+  drawFillExtrusion(footprints: FillExtrusionFootprint[], heights: number[], base: number[] | number, color: RGBA, opacity: number, projectionMatrix?: Float32Array): number;
+  drawSky(skyColor: RGBA, horizonColor: RGBA, pitchT: number, horizonBlend: number): void;
+  drawTerrain(positions: Float32Array, indices: Uint32Array, color: RGBA, opacity: number, projectionMatrix?: Float32Array): number;
+  _drawCirclesInstanced(prog: CircleProgram, centers: Float32Array): void;
+  _drawCirclesBatched(prog: CircleProgram, centers: Float32Array): void;
+  _buildFillProgram(): FillProgram;
+  _buildLineProgram(): LineProgram;
+  _buildCircleProgram(): CircleProgram;
+  _buildFillExtrusionProgram(): FillExtrusionProgram;
+  _buildSkyProgram(): SkyProgram;
+  _disposeBuffer(buf: WebGLBuffer): void;
+}

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

@@ -0,0 +1,9 @@
+export type { GLContextOptions } from './GLContext';
+export type { CircleOptions, LineOptions } from './WebGLTileRenderer';
+export type { Mat4 } from './mat4';
+// Public barrel for the WebGL renderer. Exposes the tile renderer, the
+// GLContext helper, the typed unsupported-error, and the 4x4 matrix utils so
+// callers can construct their own projection matrices.
+export { GLContext, WebGLUnsupportedError } from './GLContext';
+export { WebGLTileRenderer } from './WebGLTileRenderer';
+export * as mat4 from './mat4';

package/dist/core-map/renderer/webgl/mat4.d.ts

@@ -0,0 +1,14 @@
+export declare function identity(out?: Mat4): Mat4;
+// Build an orthographic projection matrix. Column-major to match WebGL.
+export declare function ortho(left: number, right: number, bottom: number, top: number, near: number, far: number, out?: Mat4): Mat4;
+export declare function translate(out: Mat4, a: Mat4, x: number, y: number, z: number): Mat4;
+export declare function scale(out: Mat4, a: Mat4, x: number, y: number, z: number): Mat4;
+export declare function rotateZ(out: Mat4, a: Mat4, rad: number): Mat4;
+export declare function multiply(out: Mat4, a: Mat4, b: Mat4): Mat4;
+// Minimal 4x4 matrix utilities (column-major, GLSL-compatible).
+//
+// Just the operations the WebGL renderer needs: identity, ortho, translate,
+// scale, rotateZ, multiply. A deliberate dependency-free subset; behaviour
+// mirrors the equivalent `gl-matrix` entry points so callers familiar with
+// that library stay oriented.
+export type Mat4 = Float32Array;

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

@@ -0,0 +1,26 @@
+import { NominatimGeocoder } from './providers/Nominatim';
+import { OSRMDirections, OSRMMatrix } from './providers/OSRM';
+import { ValhallaDirections, ValhallaIsochrone, ValhallaMatrix } from './providers/Valhalla';
+import type { DirectionsProvider, GeocoderProvider, IsochroneProvider, MatrixProvider } from './types';
+export declare const defaultGeocoder: () => GeocoderProvider;
+export declare const defaultDirections: () => DirectionsProvider;
+export declare const defaultIsochrone: () => IsochroneProvider;
+// Prefer OSRM's /table (keyless public demo, aligned with the default
+// directions provider) and fall back to Valhalla when callers need it.
+export declare const defaultMatrix: () => MatrixProvider;
+export declare const valhallaMatrix: () => MatrixProvider;
+// Convenience alias: Valhalla can also serve directions. Prefer OSRM by default
+// (faster on its own fleet), but expose Valhalla's as a drop-in alternative.
+export declare const valhallaDirections: () => DirectionsProvider;
+// Services layer — pluggable providers for geocoding, reverse geocoding,
+// directions, isochrones, and travel-time matrices. Defaults are keyless
+// open-source endpoints (Nominatim, OSRM, Valhalla). Key-required providers
+// (Mapbox, Google, MapTiler) are opt-in.
+export * from './types';
+export { GoogleDirections, GoogleGeocoder } from './providers/Google';
+export { MapboxDirections, MapboxGeocoder, MapboxIsochrone, MapboxMatrix } from './providers/Mapbox';
+export { MaptilerGeocoder } from './providers/Maptiler';
+export { NominatimGeocoder } from './providers/Nominatim';
+export { OSRMDirections, OSRMMatrix } from './providers/OSRM';
+export { PhotonGeocoder } from './providers/Photon';
+export { ValhallaDirections, ValhallaIsochrone, ValhallaMatrix } from './providers/Valhalla';