@versatiles/svg-renderer 2.2.1 → 2.4.0

package/dist/index.d.ts

@@ -2738,6 +2738,12 @@ declare class Feature implements Feature$1 {
      * clipped edges along the tile border are not part of the outline.
      */
     readonly outline?: Geometry;
+    /**
+     * For each line of the geometry, how far along the line in its tile it starts, in pixels
+     * — where the line was clipped to its tile, which cut off its start. A dash pattern
+     * starts where the line in the tile does.
+     */
+    readonly lineStarts?: number[];
     constructor(opt: {
         type: 'LineString' | 'Point' | 'Polygon';
         id?: unknown;
@@ -2745,6 +2751,7 @@ declare class Feature implements Feature$1 {
         patterns?: Patterns;
         geometry: Geometry;
         outline?: Geometry;
+        lineStarts?: number[];
     });
     getBbox(): Bbox;
     doesOverlap(bbox: Bbox): boolean;
@@ -2771,6 +2778,18 @@ interface Padding {
     left?: number;
 }
 
+/**
+ * The dashes of a line with `line-dasharray`, shared by every backend, as MapLibre GL JS
+ * draws them (`line_sdf.vertex.glsl`, `LineAtlas`).
+ */
+/** A dash pattern in pixels. */
+interface LineDash {
+    /** The lengths of dashes and gaps in turn, starting with a dash: an even number of them. */
+    lengths: number[];
+    /** How far into the pattern a line starts. */
+    offset: number;
+}
+
 /**
  * A drawing surface the render pipeline paints a map onto. It only describes *how* to
  * draw; how the result is handed back is up to the backend, because those differ in
@@ -2887,14 +2906,15 @@ interface LineStyle {
     blur: number;
     cap: 'butt' | 'round' | 'square';
     color: Color;
-    dasharray?: number[];
+    /** `line-dasharray`, in pixels (see `dashPattern`). */
+    dash?: LineDash;
     join: 'bevel' | 'miter' | 'round';
     miterLimit: number;
     offset: number;
     opacity: number;
     translate: [number, number];
     width: number;
-    /** `line-pattern`: drawn instead of `color` and `dasharray`. */
+    /** `line-pattern`: drawn instead of `color` and `dash`. */
     pattern?: LinePattern;
 }
 /**
@@ -3048,11 +3068,19 @@ interface FetchResponse {
     arrayBuffer(): Promise<ArrayBuffer>;
     json(): Promise<unknown>;
 }
+/**
+ * The part of `fetch`'s `RequestInit` the renderer passes. It sends request headers only
+ * to read part of a file: a `Range` header for a PMTiles archive.
+ */
+interface FetchRequestInit {
+    headers?: Record<string, string>;
+}
 /**
  * Loads a URL, like `fetch`: the renderer loads tiles, sprites, TileJSON documents and GeoJSON data through it. It is called
- * with the URL only, and should resolve to a `Response`.
+ * with the URL, and for part of a file with request headers as well, and should resolve to
+ * a `Response`.
  */
-type FetchFunction = (url: string) => Promise<FetchResponse>;
+type FetchFunction = (url: string, init?: FetchRequestInit) => Promise<FetchResponse>;
 
 /** Options for {@link SVGMapRenderer}: what stays the same for every view of the map. */
 interface SVGMapRendererOptions {
@@ -3063,7 +3091,9 @@ interface SVGMapRendererOptions {
      * (`url: '.../tiles.json'`), which is fetched once, like the sprite, with
      * {@link SVGMapRendererOptions.fetch}. As in MapLibre GL JS, `tiles`, `minzoom`,
      * `maxzoom` and the like come from the document unless the style sets them, and
-     * relative tile URLs are resolved against the document's URL. A GeoJSON source's `data`
+     * relative tile URLs are resolved against the document's URL. A PMTiles archive
+     * (`url: 'pmtiles://https://.../tiles.pmtiles'`) is read as with the `pmtiles` protocol in
+     * MapLibre GL JS, which needs no setup here. A GeoJSON source's `data`
      * may be a URL too. A source whose TileJSON or GeoJSON cannot be loaded is left out, and
      * the next render tries again.
      */
@@ -3110,6 +3140,9 @@ interface SVGMapRendererOptions {
      * Loads tiles, sprites, TileJSON documents and GeoJSON data, like `fetch`, which is the default. Pass your own to send
      * headers, go through a proxy, or keep tiles in a cache on disk.
      *
+     * It is called with the URL only, except to read part of a file, a PMTiles archive: then
+     * also with `{ headers: { Range: 'bytes=…' } }`, which it should pass on.
+     *
      * It must return a real `Response`, and its status matters: a 404 or 204 means the
      * server has no such tile, which is remembered (see {@link SVGMapRendererOptions.tileCacheSize}); any other
      * error status, or a rejected promise, counts as failed, and the next render tries
@@ -3219,7 +3252,7 @@ declare class SVGMapRenderer {
      */
     renderSVG(view?: ViewOptions): Promise<string>;
     /**
-     * Forgets the fetched tiles, sprite, TileJSON documents and GeoJSON data, so the next render fetches them again, e.g.
+     * Forgets the fetched tiles, sprite, TileJSON documents, PMTiles directories and GeoJSON data, so the next render fetches them again, e.g.
      * after they were updated on the server, or to free their memory.
      */
     clearCache(): void;
@@ -3310,4 +3343,4 @@ interface RenderToSVGOptions extends Omit<SVGMapRendererOptions, 'tileCacheSize'
 declare function renderToSVG(options: RenderToSVGOptions): Promise<string>;
 
 export { SVGMapRenderer, renderToSVG };
-export type { FetchFunction, FetchResponse, GlobalState, RenderToSVGOptions, SVGMapRendererOptions, ViewOptions };
+export type { FetchFunction, FetchRequestInit, FetchResponse, GlobalState, RenderToSVGOptions, SVGMapRendererOptions, ViewOptions };