isard 1.2.0 → 1.4.0

package/dist/basemap/vectortiles.d.ts

@@ -8,19 +8,22 @@
  * 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`.
  */
+import type { ExtrusionLayer, ExtrusionOptions } from '../layers/extrusions.ts';
 import type { Feature, Size } from '../layers/features.ts';
-import type { Layer, RasterLayer } from '../layers/layers.ts';
+import type { FlowLayer, FlowOptions } from '../layers/flow.ts';
+import type { Layer, 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 { RasterOptions } from '../types.ts';
-import type { Camera } from '../wasm/isard.js';
-import type { Priority } from '../workers/basemap.worker.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: {
@@ -32,6 +35,7 @@ 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";
 };
@@ -53,19 +57,6 @@ export declare const styleAttribution: (style: string | Style) => string | undef
 /** 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;
-/** Default size of a basemap worker pool: cores - 1, 1 to 4 */
-export declare const defaultWorkerCount: () => number;
-/** Default URL of the basemap worker: in the page's assets folder (`isard/vite`), else next to the module */
-export declare const defaultWorkerUrl: (assetsUrl?: string | URL) => string | URL;
-/** Fetch priority of a raster tile drawn by the workers: 'high' near the center of the view, at the current zoom or
- * coarser; 'low' far from it or finer (prefetch); 'auto' between */
-export declare const tilePriority: (z: number, x: number, y: number, camera: Pick<Camera, "center" | "zoom">) => Priority;
-/** The worker of a vector tile among `count`: always the same one */
-export declare const workerIndex: (vz: number, vx: number, vy: number, count: number) => number;
-/** The worker-side key of a renderer: unique across the `VectorTiles` sharing a pool */
-export declare const rendererKey: (namespace: string, n: number) => string;
-/** What the pool needs of a worker (a `Worker`, or a stand-in in tests) */
-export type PoolWorker = Pick<Worker, 'postMessage' | 'terminate' | 'onmessage' | 'onerror' | 'onmessageerror'>;
 /** 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 */
@@ -109,7 +100,7 @@ export declare class VectorTiles {
     /** 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; returns its key */
+    /** Sends a renderer of these layers to every worker (again under `again`, restyled); returns its key */
     private renderer;
     /**
      * A raster layer drawing the style's fills, lines and circles (or those `layers` keeps, then `extraLayers`, of the
@@ -124,6 +115,82 @@ export declare class VectorTiles {
         maxZoom?: number;
         before?: Parameters<GeoMap['addRaster']>[0]['before'];
     }): RasterLayer;
+    /**
+     * An extrusion layer of the polygons of the style's fill layers that `layers` keeps (by default its buildings: the
+     * fill or fill-extrusion layers of PLAN IGN's `bati_surf` or OpenMapTiles' `building`), raised by the style
+     * given (`height`, `base`, `color`, `ramp`…; the properties of the tiles' features). Its tiles follow the view: at
+     * 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>;
+    /**
+     * 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
+     * `cell` metres (default 4) over a square of `size` metres (default 1200) around the view's center, the flow of the
+     * air round them a potential flow (it goes round the blocks and faster through the narrow streets; no wake behind
+     * them), computed in a worker by the grid module from street level (`minZoom`, default 15) and again when the view
+     * leaves the square's middle. `wind` is the wind far away (east and north, m/s, default a light breeze from the
+     * south-west); `setWind` changes it at once (the flow is linear in it: nothing computed again), from a model's hour
+     * (`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>;
+    };
+    /**
+     * 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`
+     * metres apart (by style layer: 9 in woods, 25 on grass, by default) on a jittered grid, the same trees whenever a
+     * tile comes back; the engine draws them all in one instanced draw, on the relief. A low-poly tree by default (its
+     * `colors`), or your own glTF (`url`, `data`, about 10 metres high, standing on its origin). Dense around the
+     * view's center, fewer and fewer away from it (as the camera moves too), at most `maxInstances` drawn (default
+     * 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;
+    /**
+     * 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
+     * workers cut the vector tiles in view into polygons and lines, which the engine draws on the globe and the relief,
+     * in the style's order, each style layer over its zoom range. Sharp at any zoom
+     * 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
+     * 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;
     /**
      * 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
@@ -135,35 +202,17 @@ export declare class VectorTiles {
         layers?: (layer: StyleLayer) => boolean;
         maxTiles?: number;
     }): 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
+     */
+    private followView;
     /** Stops its workers' work and removes its raster and label layers from the map (those still there) */
     destroy(): void;
 }
 /**
- * A plain style for vector tiles known only by their layers' names (a PMTiles archive's `vector_layers`, an MBTiles'
- * metadata): each layer's polygons filled, its lines and outlines stroked and its points as circles, a color per
- * layer, the `name` of points as labels. `source` is the style's vector source (`url`: TileJSON or `pmtiles://…`, or
- * `tiles`)
+ * 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 basicStyle: (source: {
-    url?: string;
-    tiles?: string[];
-    minzoom?: number;
-    maxzoom?: number;
-}, layers: readonly string[]) => Style;
-/** Options of `GeoMap.addPmtiles` */
-export interface PmtilesOptions {
-    /** What the archive holds (default from its header: raster images or vector tiles) */
-    kind?: 'raster' | 'vector';
-    /** A MapLibre style for vector tiles (its vector source `pmtiles://…`); default `basicStyle` of the archive's layers */
-    style?: Style;
-    opacity?: number;
-    /** Texture size of raster tiles (default 256; 512 for the sharper tiles of a 512 px archive) */
-    size?: number;
-    /** Credits, HTML (default the archive's `attribution` metadata, as text) */
-    attribution?: string;
-    before?: Layer;
-}
-/** A raster loader reading the tiles of a `pmtiles://` archive URL (images of any size, drawn at `size`); undefined
- * for another URL */
-export declare const pmtilesRasterLoader: (url: string, size: number) => RasterOptions["loader"];
+export declare const dashes: (value: Json | undefined, zoom: number) => [number, number, number, number];
 export {};