isard 1.4.0 → 1.6.0

package/dist/basemap/vectortiles.d.ts

@@ -7,38 +7,24 @@
  *
  * Any subset of the style can be drawn on its own raster layer (`raster({ layers })`), at its own place in the stack:
  * rivers from the basemap's data over a flood layer, for instance, restyled with `extraLayers`.
+ *
+ * The layers other than the raster ones are made in `vectortiles/` (one module each), from what they use of the
+ * instance (`VectorTilesContext`); the style's loading is in `vectortiles/style.ts`.
  */
-import type { ExtrusionLayer, ExtrusionOptions } from '../layers/extrusions.ts';
-import type { Feature, Size } from '../layers/features.ts';
-import type { FlowLayer, FlowOptions } from '../layers/flow.ts';
-import type { Layer, ModelLayer, RasterLayer } from '../layers/layers.ts';
+import type { ExtrusionLayer } from '../layers/extrusions.ts';
+import type { ModelLayer, RasterLayer } from '../layers/layers.ts';
 import type { SymbolLayer } from '../layers/symbols.ts';
 import type { VectorLayer } from '../layers/vectors.ts';
 import type { GeoMap } from '../map.ts';
-import { type TreeColors } from './trees.ts';
-import { type Json, type LabelCandidate, type RasterSource, type Style, type StyleLayer } from './vectorstyle.ts';
-/** OpenFreeMap's styles: OpenStreetMap data in the OpenMapTiles schema, worldwide, free and without a key */
-export declare const OPENFREEMAP_STYLES: {
-    readonly positron: "https://tiles.openfreemap.org/styles/positron";
-    readonly liberty: "https://tiles.openfreemap.org/styles/liberty";
-    readonly bright: "https://tiles.openfreemap.org/styles/bright";
-    readonly dark: "https://tiles.openfreemap.org/styles/dark";
-    readonly fiord: "https://tiles.openfreemap.org/styles/fiord";
-};
-/** PLAN.IGN vector styles of the Géoplateforme (France) */
-export declare const PLAN_STYLES: {
-    readonly standard: "https://data.geopf.fr/annexes/ressources/vectorTiles/styles/PLAN.IGN/standard.json";
-    readonly grey: "https://data.geopf.fr/annexes/ressources/vectorTiles/styles/PLAN.IGN/gris.json";
-};
-/** Vector basemaps by name (see `BasemapName`) */
-export declare const VECTOR_BASEMAPS: {
-    readonly 'osm-positron': "https://tiles.openfreemap.org/styles/positron";
-    readonly 'osm-liberty': "https://tiles.openfreemap.org/styles/liberty";
-    readonly 'osm-bright': "https://tiles.openfreemap.org/styles/bright";
-    readonly 'osm-dark': "https://tiles.openfreemap.org/styles/dark";
-    readonly 'ign-plan-vector': "https://data.geopf.fr/annexes/ressources/vectorTiles/styles/PLAN.IGN/standard.json";
-    readonly 'ign-plan-grey-vector': "https://data.geopf.fr/annexes/ressources/vectorTiles/styles/PLAN.IGN/gris.json";
-};
+import type { LabelCandidate, Style, StyleLayer } from './vectorstyle.ts';
+import { type VectorExtrusionOptions } from './vectortiles/extrusions.ts';
+import { type LabelsOptions, size, tileLabels } from './vectortiles/labels.ts';
+import { type LampsOptions } from './vectortiles/lamps.ts';
+import { type StreetWindLayer, type StreetWindOptions } from './vectortiles/street-wind.ts';
+import { type LoadedStyle, OPENFREEMAP_STYLES, PLAN_STYLES, styleAttribution, VECTOR_BASEMAPS } from './vectortiles/style.ts';
+import { type TreesOptions } from './vectortiles/trees.ts';
+import { dashes, type VectorsOptions } from './vectortiles/vectors.ts';
+export { dashes, OPENFREEMAP_STYLES, PLAN_STYLES, size, styleAttribution, tileLabels, VECTOR_BASEMAPS };
 export interface VectorTilesOptions {
     /** A style URL or object (default OpenFreeMap's Positron) */
     style?: string | Style;
@@ -52,15 +38,6 @@ export interface VectorTilesOptions {
      * IGN's for PLAN.IGN's) */
     attribution?: string;
 }
-/** The credits of a known style: OpenFreeMap's, PLAN.IGN's */
-export declare const styleAttribution: (style: string | Style) => string | undefined;
-/** Text or icon size of a style (a number, legacy stops, or the stops of a zoom expression made by the worker) as a
- * size for the symbol layer */
-export declare const size: (value: Json, fallback?: number) => Size;
-/** The labels of a vector tile: features by style layer (its index in the style), the higher layers first */
-type TileLabels = [layer: number, features: Feature<LabelCandidate>[]][];
-/** A tile's label candidates as features, by style layer */
-export declare const tileLabels: (candidates: readonly LabelCandidate[]) => TileLabels;
 export declare class VectorTiles {
     private readonly map;
     private readonly pool;
@@ -79,28 +56,30 @@ export declare class VectorTiles {
     private readonly layers;
     /** Its first raster layer: the ground its labels follow */
     private ground;
+    /** What its layers made in `vectortiles/` use of it */
+    private readonly context;
     /** The style once loaded, with its source resolved */
-    readonly ready: Promise<{
-        style: Style;
-        tiles: string;
-        maxzoom: number;
-        rasters: Record<string, RasterSource>;
-    }>;
+    readonly ready: Promise<LoadedStyle>;
     /**
      * Its workers are the map's (shared by every `VectorTiles` of the map, a vector tile decoded once for all of them),
      * unless `workers` or `workerUrl` asks for others than the map's: then it has workers of its own
      */
     constructor(map: GeoMap, options?: VectorTilesOptions);
-    private load;
-    /** The fonts of the style's labels, for its glyphs (the first of each `text-font`, as the workers take it) */
-    private static fonts;
     /** The style's sprites (their JSON and their images), loaded once, for the fill patterns and the icons */
     private sprites;
+    /** The style's sprites, kept once all of them came: one that failed is asked for again by the next layer */
     private loadSprites;
+    /** The style's sprites added to the map's icons, once */
+    private spritesAdded;
+    /** The style's sprites among the map's icons (under `iconPrefix`), added once: the labels' icons, the fills'
+     * patterns */
+    private addSprites;
     /** Prefix of the names of its sprites' images among the map's icons */
     private get iconPrefix();
     private request;
-    /** Sends a renderer of these layers to every worker (again under `again`, restyled); returns its key */
+    /** Sends a renderer of these layers to every worker (again under `again`, restyled), with the style's sprites if it
+     * `draws` the tiles into images with patterns (the raster path: the others take their images in the page); returns
+     * its key */
     private renderer;
     /**
      * A raster layer drawing the style's fills, lines and circles (or those `layers` keeps, then `extraLayers`, of the
@@ -122,11 +101,7 @@ export declare class VectorTiles {
      * the source's deepest level, the `maxTiles` nearest to the center, from `minZoom` on (15 by default); the tiles
      * leaving the view are dropped.
      */
-    extrusions<P = Record<string, unknown>>(options?: Omit<ExtrusionOptions<P>, 'data'> & {
-        layers?: (layer: StyleLayer) => boolean;
-        minZoom?: number;
-        maxTiles?: number;
-    }): ExtrusionLayer<P>;
+    extrusions<P = Record<string, unknown>>(options?: VectorExtrusionOptions<P>): ExtrusionLayer<P>;
     /**
      * The wind through the streets around the view, as particles at street level (`height`, default 3 metres) between
      * the style's buildings (`layers`, default its `building` and `bati_surf` layers): their footprints laid on a grid of
@@ -138,17 +113,7 @@ export declare class VectorTiles {
      * (`windAt`) for instance; `computed` resolves once the first square's flow is there. The other options are the flow
      * layer's (`addFlow`)
      */
-    streetWind(options?: Omit<FlowOptions, 'field' | 'fields' | 'time'> & {
-        wind?: [u: number, v: number];
-        size?: number;
-        cell?: number;
-        iterations?: number;
-        layers?: (layer: StyleLayer) => boolean;
-        minZoom?: number;
-    }): FlowLayer & {
-        setWind(wind: [u: number, v: number]): void;
-        computed: Promise<void>;
-    };
+    streetWind(options?: StreetWindOptions): StreetWindLayer;
     /**
      * Trees on the style's woods, forests and grass (or the fill layers `layers` keeps) as 3D models, from street level
      * (`minZoom`, default 15): the workers scatter them over the polygons of the vector tiles around the view, `spacing`
@@ -159,18 +124,15 @@ export declare class VectorTiles {
      * 25000); at most `maxTiles` tiles (default 9) and `maxTrees` trees in each (default 30000). The models load the
      * engine with 3D Tiles.
      */
-    trees(options?: {
-        layers?: (layer: StyleLayer) => boolean;
-        spacing?: number | ((layer: StyleLayer) => number);
-        minZoom?: number;
-        maxTiles?: number;
-        maxTrees?: number;
-        maxInstances?: number;
-        colors?: Partial<TreeColors>;
-        url?: string;
-        data?: ArrayBuffer | ArrayBufferView<ArrayBuffer>;
-        before?: Layer;
-    }): ModelLayer;
+    trees(options?: TreesOptions): ModelLayer;
+    /**
+     * Street lamps along the style's streets (the road line layers, or those `layers` keeps) as 3D models, from street
+     * level (`minZoom`, default 16): the workers place them `spacing` metres apart (default 30) along each street, every
+     * other one on its other side, as far from its middle as its class says; their heads lit at night (`light`). All of
+     * them near the ground under the camera, fewer and fewer away from it, at most `maxInstances` drawn (default 15000).
+     * The models load the engine with 3D Tiles.
+     */
+    lamps(options?: LampsOptions): ModelLayer;
     /**
      * A layer drawing the style's fills, lines and buildings (or those `layers` keeps; backgrounds as fills, the
      * `fill-extrusion` layers raised into buildings by their height and base height) as geometry instead of images: the
@@ -179,18 +141,18 @@ export declare class VectorTiles {
      * and pitch, picked by feature (`pick` gives its properties and style layer), restyled without cutting the tiles
      * again (`setPaintProperty`, `setLayoutProperty`). Its tiles follow the view, while it moves too, coarser far away in a
      * tilted view, and those leaving it stay until the ones replacing them are there; past the source's deepest level,
-     * cut again from its tiles down to level 18 (overzoom: their filters and styles those of their level). The fills' outlines are drawn one
-     * pixel wide, the lines' ends as their `line-cap` says (their joins round), the colors follow the camera's zoom. The
-     * layers drawn with a pattern and the circles are left out (the raster path draws them), as are `line-offset`,
-     * `line-blur` and the translations (`fill-translate`, `line-translate`); `raster` stays the lighter path for heavy
-     * styles and small devices. At night (`setSun`) the line layers `streets` keeps glow (by default those whose id names
+     * cut again from its tiles down to level 18 (overzoom: their styles those of their level; a filter reading the zoom
+     * holds at the whole zoom under the camera's, as MapLibre evaluates it). The fills' outlines are drawn one
+     * pixel wide, the lines' ends as their `line-cap` says, their joins as their `line-join` says (and `line-miter-limit`),
+     * offset by `line-offset`; the colors follow the camera's zoom; the fills', lines' and buildings' patterns from the
+     * style's sprite (the fills' over the relief too; on the globe, their average color there), the circle layers' points
+     * as circles facing the screen, the lines' blur, the fills' and lines' translations. The buildings' roofs (`roofs`)
+     * as their data says (`roof:shape`, `roof:height`; flat without, the default), generated from their outline where
+     * they have none (`'generated'`), or all flat. `raster` stays the lighter path for heavy styles and small devices.
+     * At night (`setSun`) the line layers `streets` keeps glow (by default those whose id names
      * a road, not its casing, a railway, a path or a tunnel).
      */
-    vectors(options?: {
-        layers?: (layer: StyleLayer) => boolean;
-        streets?: (layer: StyleLayer) => boolean;
-        before?: Layer;
-    }): VectorLayer;
+    vectors(options?: VectorsOptions): VectorLayer;
     /**
      * A symbol layer with the labels of the style's symbol layers (or those `layers` keeps), updated as the view
      * moves: the labels of the vector tiles in view, the higher style layers placed first. With a raster layer of
@@ -198,21 +160,12 @@ export declare class VectorTiles {
      * away, with the few labels of a lower zoom, as near the camera it takes the fine ones. Without, the tiles around
      * the center at the zoom of the view. It stays above the layers added after it unless one is moved over it.
      */
-    labels(options?: {
-        layers?: (layer: StyleLayer) => boolean;
-        maxTiles?: number;
-    }): SymbolLayer<LabelCandidate>;
+    labels(options?: LabelsOptions): SymbolLayer<LabelCandidate>;
     /**
      * Makes a layer's tiles follow the view: `update` now and where the camera stops (`moveend`), `moving` every
-     * `VECTOR_MOVE_REFRESH_MS` while it moves; the requests `held` aborted when destroyed
+     * `VECTOR_MOVE_REFRESH_MS` while it moves; the `requests` aborted when destroyed
      */
     private followView;
     /** Stops its workers' work and removes its raster and label layers from the map (those still there) */
     destroy(): void;
 }
-/**
- * A `line-dasharray` as the engine takes it: two dashes and gaps in line widths (an odd count repeated, as the
- * canvas's `setLineDash`; past four, the first four), zeros for a solid line
- */
-export declare const dashes: (value: Json | undefined, zoom: number) => [number, number, number, number];
-export {};