ts-maps 0.3.2 → 0.3.3

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