ts-maps 0.3.1 → 0.3.3

package/dist/core-map/mvt/DecodedTile.d.ts

@@ -0,0 +1,20 @@
+import type { GeoJSONFeature, VectorTileProperties } from './VectorTileFeature';
+import type { Point } from '../geometry/Point';
+export declare interface DecodedFeature {
+  id?: number
+  type: 1 | 2 | 3
+  extent: number
+  properties: VectorTileProperties
+  loadGeometry: () => Point[][]
+  bbox: () => [number, number, number, number]
+  toGeoJSON: (x: number, y: number, z: number) => GeoJSONFeature
+}
+export declare interface DecodedLayer {
+  name?: string
+  extent: number
+  length: number
+  feature: (i: number) => DecodedFeature
+}
+export declare interface DecodedTile {
+  layers: Record<string, DecodedLayer>
+}

package/dist/core-map/mvt/FlatTile.d.ts

@@ -0,0 +1,25 @@
+import { Point } from '../geometry/Point';
+import type { FlatLayer, FlatTile as FlatTileData } from '../workers/decodeMvtFlat';
+import type { GeoJSONFeature, VectorTileProperties } from './VectorTileFeature';
+export declare class FlatTileFeature {
+  id?: number;
+  type: 1 | 2 | 3;
+  extent: number;
+  constructor(layer: FlatLayer, index: number);
+  get properties(): VectorTileProperties;
+  loadGeometry(): Point[][];
+  bbox(): [number, number, number, number];
+  toGeoJSON(x: number, y: number, z: number): GeoJSONFeature;
+}
+export declare class FlatTileLayer {
+  name: string;
+  version: number;
+  extent: number;
+  length: number;
+  constructor(data: FlatLayer);
+  feature(i: number): FlatTileFeature;
+}
+export declare class FlatTile {
+  layers: Record<string, FlatTileLayer>;
+  constructor(data: FlatTileData);
+}

package/dist/core-map/mvt/VectorTileFeature.d.ts

@@ -1,5 +1,13 @@
 import { Point } from '../geometry/Point';
 import type { Pbf } from '../proto/Pbf';
+/**
+ * Project tile-local rings to WGS84 and wrap them as a GeoJSON feature.
+ *
+ * Shared rather than duplicated: tiles decoded in a worker arrive as flat
+ * typed arrays and are wrapped by `FlatTile`, which has the same job to do
+ * here and must produce byte-identical output.
+ */
+export declare function geometryToGeoJSON(type: number, rings: Point[][], extent: number, x: number, y: number, z: number, properties: VectorTileProperties, id?: number): GeoJSONFeature;
 // MVT GeomType enum values (tile.proto).
 export declare const MVT_GEOM_UNKNOWN: number;
 export declare const MVT_GEOM_POINT: number;

package/dist/core-map/services/index.js

@@ -40,17 +40,17 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 // src/core-map/core/Util.ts
 var exports_Util = {};
 __export(exports_Util, {
-  wrapNum: () => wrapNum,
-  throttle: () => throttle,
-  template: () => template,
-  stamp: () => stamp,
-  splitWords: () => splitWords,
-  setOptions: () => setOptions,
-  setLastId: () => setLastId,
-  noop: () => noop,
-  lastId: () => lastId,
+  falseFn: () => falseFn,
   formatNum: () => formatNum,
-  falseFn: () => falseFn
+  lastId: () => lastId,
+  noop: () => noop,
+  setLastId: () => setLastId,
+  setOptions: () => setOptions,
+  splitWords: () => splitWords,
+  stamp: () => stamp,
+  template: () => template,
+  throttle: () => throttle,
+  wrapNum: () => wrapNum
 });
 function stamp(obj) {
   if (!("_tsmap_id" in obj)) {
@@ -133,26 +133,26 @@ var init_Util = __esm(() => {
 // src/core-map/services/index.ts
 var exports_services = {};
 __export(exports_services, {
-  valhallaMatrix: () => valhallaMatrix,
-  valhallaDirections: () => valhallaDirections,
-  defaultMatrix: () => defaultMatrix,
-  defaultIsochrone: () => defaultIsochrone,
-  defaultGeocoder: () => defaultGeocoder,
-  defaultDirections: () => defaultDirections,
-  ValhallaMatrix: () => ValhallaMatrix,
-  ValhallaIsochrone: () => ValhallaIsochrone,
-  ValhallaDirections: () => ValhallaDirections,
-  PhotonGeocoder: () => PhotonGeocoder,
-  OSRMMatrix: () => OSRMMatrix,
-  OSRMDirections: () => OSRMDirections,
-  NominatimGeocoder: () => NominatimGeocoder,
-  MaptilerGeocoder: () => MaptilerGeocoder,
-  MapboxMatrix: () => MapboxMatrix,
-  MapboxIsochrone: () => MapboxIsochrone,
-  MapboxGeocoder: () => MapboxGeocoder,
-  MapboxDirections: () => MapboxDirections,
+  GoogleDirections: () => GoogleDirections,
   GoogleGeocoder: () => GoogleGeocoder,
-  GoogleDirections: () => GoogleDirections
+  MapboxDirections: () => MapboxDirections,
+  MapboxGeocoder: () => MapboxGeocoder,
+  MapboxIsochrone: () => MapboxIsochrone,
+  MapboxMatrix: () => MapboxMatrix,
+  MaptilerGeocoder: () => MaptilerGeocoder,
+  NominatimGeocoder: () => NominatimGeocoder,
+  OSRMDirections: () => OSRMDirections,
+  OSRMMatrix: () => OSRMMatrix,
+  PhotonGeocoder: () => PhotonGeocoder,
+  ValhallaDirections: () => ValhallaDirections,
+  ValhallaIsochrone: () => ValhallaIsochrone,
+  ValhallaMatrix: () => ValhallaMatrix,
+  defaultDirections: () => defaultDirections,
+  defaultGeocoder: () => defaultGeocoder,
+  defaultIsochrone: () => defaultIsochrone,
+  defaultMatrix: () => defaultMatrix,
+  valhallaDirections: () => valhallaDirections,
+  valhallaMatrix: () => valhallaMatrix
 });
 
 // src/core-map/services/providers/Google.ts
@@ -1207,24 +1207,24 @@ var defaultMatrix = () => new OSRMMatrix;
 var valhallaMatrix = () => new ValhallaMatrix;
 var valhallaDirections = () => new ValhallaDirections;
 export {
-  valhallaMatrix,
-  valhallaDirections,
-  defaultMatrix,
-  defaultIsochrone,
-  defaultGeocoder,
-  defaultDirections,
-  ValhallaMatrix,
-  ValhallaIsochrone,
-  ValhallaDirections,
-  PhotonGeocoder,
-  OSRMMatrix,
-  OSRMDirections,
-  NominatimGeocoder,
-  MaptilerGeocoder,
-  MapboxMatrix,
-  MapboxIsochrone,
-  MapboxGeocoder,
-  MapboxDirections,
+  GoogleDirections,
   GoogleGeocoder,
-  GoogleDirections
+  MapboxDirections,
+  MapboxGeocoder,
+  MapboxIsochrone,
+  MapboxMatrix,
+  MaptilerGeocoder,
+  NominatimGeocoder,
+  OSRMDirections,
+  OSRMMatrix,
+  PhotonGeocoder,
+  ValhallaDirections,
+  ValhallaIsochrone,
+  ValhallaMatrix,
+  defaultDirections,
+  defaultGeocoder,
+  defaultIsochrone,
+  defaultMatrix,
+  valhallaDirections,
+  valhallaMatrix
 };

package/dist/core-map/storage/index.js

@@ -274,10 +274,10 @@ var init_storage = __esm(() => {
 init_storage();
 
 export {
-  saveOfflineRegion,
-  resetDefaultCache,
-  getDefaultCache,
-  computeTileCoords,
+  TileCache,
   cachedFetch,
-  TileCache
+  computeTileCoords,
+  getDefaultCache,
+  resetDefaultCache,
+  saveOfflineRegion
 };

package/dist/core-map/style-spec/expressions/formatted.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Whether these sections are just a string in disguise.
+ *
+ * Most `format` expressions in real styles carry no options at all — they are
+ * written for the newline, or for a conditional the author found easier to
+ * express there. Those take the plain text path, which measures and draws in
+ * one call instead of per section.
+ */
+export declare function isUniform(sections: FormattedSection[]): boolean;
+/** Duck-typed, so a value crossing a module boundary is still recognised. */
+export declare function isFormatted(value: unknown): value is Formatted;
+// Formatted — the value `format` evaluates to.
+//
+// `["format", "Main", {}, " St", { "font-scale": 0.8 }]` is one label whose
+// parts are drawn differently: a road shield's number larger than its prefix,
+// a place name above a smaller subtitle, a unit in a lighter colour. The
+// sections have to survive as structure all the way to the renderer, because
+// the whole point of them is that they are not one uniform run of text.
+//
+// They also have to keep behaving like a string. `text-field` is read in
+// several places that only want to know whether there is any text and how
+// long it is, and a caller reading a feature's label through the query API
+// expects a string. `toString` concatenates, so every one of those paths keeps
+// working and only the drawing code needs to know sections exist.
+export declare interface FormattedSection {
+  text: string
+  scale?: number
+  fontStack?: string[]
+  color?: string
+}
+export declare class Formatted {
+  sections: FormattedSection[];
+  constructor(sections: FormattedSection[]);
+  toString(): string;
+  get uniform(): boolean;
+}

package/dist/core-map/style-spec/expressions/operators/binding.d.ts

@@ -0,0 +1 @@
+export declare function registerBindingOps(): void;

package/dist/core-map/style-spec/expressions/operators/geometry.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Great-circle distance in metres.
+ *
+ * Haversine rather than a planar approximation: a planar one is wrong by
+ * kilometres at high latitude, which is exactly where "is this within 500m"
+ * questions stop being decorative.
+ */
+export declare function haversine(a: Position, b: Position): number;
+/**
+ * Even-odd ray casting, with the boundary counted as inside.
+ *
+ * A point exactly on an edge is a real case — shared borders, snapped data —
+ * and excluding it makes two adjacent polygons disagree about who owns it.
+ */
+export declare function pointInRing(point: Position, ring: Position[]): boolean;
+/** Inside the outer ring and outside every hole. */
+export declare function pointInPolygon(point: Position, polygon: Position[][]): boolean;
+export declare function registerGeometryOps(): void;
+declare type Position = [number, number];

package/dist/core-map/style-spec/expressions/types.d.ts

@@ -8,14 +8,17 @@ export declare interface EvaluationContext {
     type: 1 | 2 | 3
     id?: number | string
     properties: Record<string, unknown>
+    geometry?: () => unknown
   }
   featureState?: Record<string, unknown>
   lineProgress?: number
+  heatmapDensity?: number
   globalProperties?: {
     bearing?: number
     pitch?: number
     zoom: number
   }
+  bindings?: Record<string, unknown>
 }
 // A compiled expression: a closure plus metadata the renderer uses to decide
 // whether it needs to re-evaluate on zoom change, on feature change, or on