@tangram.gl/basemap-layers 0.0.0-stage → 0.0.0

package/dist/types/mvt-label-layer.d.ts

@@ -0,0 +1,923 @@
+import { CompositeLayer } from '@deck.gl/core';
+import type { DefaultProps, Layer, LayerContext, UpdateParameters, Viewport } from '@deck.gl/core';
+import { LabelPlacement, type PlacementLayer, type PlacementSymbol, type SymbolPlacementRules } from "./label-placement.js";
+import type { LabelTextJustify } from "./label-text-layer.js";
+import { SharedTextureSet } from "./shared-texture.js";
+import { type CompiledStyleProperty } from "./style-expression.js";
+import type { ResolvedSpriteIcon, SpriteAtlas } from "./sprite.js";
+import { GlobeLineAngleExtension } from "./globe-line-angle-extension.js";
+import type { GlyphStore } from "./glyph-store.js";
+import { type LabelLine, type LineGlyphs } from "./line-glyphs.js";
+import type { WrapBudget } from "./text-layout.js";
+import { type PoleSearchBudget } from "./polylabel.js";
+import type { LabelFont, LabelFontFamily } from "./text-font.js";
+import { type LineAnchorBudget } from "./line-placement.js";
+type GeometryType = 'Point' | 'MultiPoint' | 'LineString' | 'MultiLineString' | 'Polygon' | 'MultiPolygon' | string;
+type FeatureGeometry = {
+    type: GeometryType;
+    coordinates: any;
+};
+type FeatureLike = {
+    geometry: FeatureGeometry;
+    properties?: Record<string, any>;
+};
+type LabelRow = {
+    position: number[];
+    /** For labels along a line: the line's direction, in degrees counter-clockwise from east. */
+    angle?: number;
+    /** For labels along a line: the line, along which their glyphs are placed (see `getLineGlyphs`). */
+    line?: RowLine;
+    /**
+     * With `text-variable-anchor`, a point label has a row per anchor, in order, one after the other
+     * in `labelData`: the index of this row's anchor (0, the default, for the first row, which also
+     * draws the icon) and the number of anchors.
+     */
+    textAnchorIndex?: number;
+    textAnchorCount?: number;
+};
+/**
+ * The line a row's label is placed along: its vertices in pixels at the placement zoom (shared by
+ * every row on the line), where the anchor lies on it, and that zoom.
+ */
+type RowLine = LabelLine & {
+    zoom: number;
+};
+type StyleLayerLike = {
+    layout?: Record<string, any>;
+    paint?: Record<string, any>;
+};
+type LabelConfig = {
+    labels?: boolean;
+};
+/**
+ * Props accepted by {@link MVTLabelLayer}.
+ */
+export type MVTLabelLayerProps = {
+    /** Decoded vector-tile features or a feature-collection-like object. */
+    data?: {
+        features?: FeatureLike[];
+    } | FeatureLike[];
+    /** Label rendering enablement for the current basemap mode. */
+    config: LabelConfig;
+    /** Style layer that contributes label rules. */
+    styleLayer?: StyleLayerLike;
+    /** Zoom level used to evaluate style expressions. */
+    zoom?: number;
+    /** Text fill color. */
+    textColor?: number[];
+    /**
+     * `[min, max)`: this layer's band in its style. `BasemapLayer` gives each symbol style layer its
+     * own band, rising with style order; labels are placed from the highest band down (see
+     * `LabelPlacement`).
+     */
+    collisionPriorityRange?: [number, number];
+    /** Text size units forwarded to `TextLayer`. */
+    labelSizeUnits?: 'pixels' | 'meters' | 'common';
+    /**
+     * Overrides the font derived from the style layer's `text-font`: a CSS family list, or a
+     * function from the `text-font` names to a family list or {@link LabelFont} fields.
+     */
+    fontFamily?: LabelFontFamily | null;
+    /**
+     * The glyphs of the style's `glyphs` URL, which labels are drawn with, as in MapLibre GL JS. A
+     * tile's labels are placed once the glyphs of their text have loaded. Without it, labels are
+     * drawn with the browser's fonts that `text-font` maps to.
+     */
+    glyphs?: GlyphStore | null;
+    /** Enables billboard rendering in the text sublayer. */
+    billboard?: boolean;
+    /** When `true`, renders the source geometries for debugging. */
+    renderGeometry?: boolean;
+    /** Additional extension instances passed through to the text sublayer. */
+    extensions?: any[];
+    /** Active basemap mode. */
+    mode?: 'map' | 'globe';
+    /**
+     * The placement shared with the other label layers of the map, which decides which labels and
+     * icons are drawn (see {@link LabelPlacement}). Label layers without one share one per deck.
+     */
+    labelPlacement?: LabelPlacement | null;
+    /**
+     * Sprites loaded for the style; `icon-image` names resolve against them. `null` while they are
+     * loading: no icons are drawn, and text is placed as if each symbol had its icon, so labels do
+     * not change placement rules when the sprites arrive.
+     */
+    spriteAtlases?: SpriteAtlas[] | null;
+    /** Load options for the sprite atlas images, so they use the same fetch as the style. */
+    iconLoadOptions?: Record<string, unknown> | null;
+    /**
+     * The tile's own bounding box, as deck.gl's `TileLayer` reports it. In longitude/latitude (globe
+     * tiles), polygon labels outside it are dropped, so a polygon in two tiles' buffers is labelled
+     * by one tile. Tile-local coordinates always use the tile's `[0, 1)` square.
+     */
+    tileBoundingBox?: {
+        west: number;
+        south: number;
+        east: number;
+        north: number;
+    } | null;
+    /** The tile's zoom level, at which labels along lines are spaced. Default: the integer `zoom`. */
+    tileZoom?: number | null;
+    /** The tile's size in pixels at its own zoom. Default: 512. */
+    tileSize?: number | null;
+    /**
+     * The label features of several tiles, labelled together in one layer instead of `data`: each
+     * tile's anchors are placed as for a layer of its own (`tileBoundingBox`, `tileZoom` and
+     * `tileSize` per tile), then drawn in longitude/latitude. Pass the same array while the tiles do
+     * not change; a tile keeps its anchors while its features, and the inputs they depend on, do not
+     * change. See {@link LabelTile}.
+     */
+    tiles?: LabelTile[] | null;
+};
+/** The label features of one tile, for {@link MVTLabelLayerProps.tiles}. */
+export type LabelTile = {
+    /** The tile's index, which places tile-local coordinates in the world. */
+    index: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** The tile's features of the style layer. */
+    features: FeatureLike[];
+    tileBoundingBox?: {
+        west: number;
+        south: number;
+        east: number;
+        north: number;
+    } | null;
+    tileZoom?: number | null;
+    tileSize?: number | null;
+    /** Returned as `info.tile` when a label of the tile is picked. */
+    tile?: unknown;
+};
+/** The anchors of one tile of a {@link MVTLabelLayerProps.tiles} layer. */
+type TileRows = {
+    features: FeatureLike[];
+    anchorKey: string;
+    /** The text and font the glyphs were loaded for (see `getGlyphKey`). */
+    glyphKey: string;
+    /** The tile the rows report when picked (see `LabelTile.tile`). */
+    tile: unknown;
+    rows: LabelRow[];
+    /** The font stacks of the rows' text, which the layer retains in its glyph store. */
+    fontStacks: ReadonlySet<string>;
+    /**
+     * The glyph store's `generation` when it refused to retain a font stack of the tile's text, whose
+     * labels are then left out of the rows; the rows are placed again once it has changed.
+     */
+    refusedGeneration?: number;
+};
+/**
+ * The rows of every tile of `tiles`, from `tileRows`, without those of a tile whose anchor lies in
+ * a deeper tile of the set: while a tile's children load, the tile is drawn in their place, and
+ * where a child has loaded, the child's labels replace the parent's. `geographic` says whether the
+ * rows are in longitude/latitude; otherwise they are already converted, see `getTileRowsInWorld`.
+ */
+export declare function combineTileRows(tiles: LabelTile[], tileRows: LabelRow[][]): LabelRow[];
+/** What placement needs of a label layer's rows that does not change with the view. */
+type PlacementGeometry = {
+    key: unknown[];
+    rules: SymbolPlacementRules;
+    /**
+     * Indices into `labelData`, in placement order. A label with variable anchors is placed from its
+     * first row, and its other rows follow it (see `LabelRow.textAnchorIndex`).
+     */
+    order: number[];
+    textBoxes: Float64Array;
+    /** Each row's `text-offset` in pixels, `x, y`, which its text box includes. */
+    textOffsets: Float64Array;
+    iconBoxes: Float64Array;
+    textPadding: number;
+    /** See `getPlacementCommons`. */
+    commons?: {
+        kind: string;
+        positions: Float64Array;
+    };
+};
+/** A label anchor with variable anchors: the anchor, and its offset in ems of `text-size`. */
+export type TextAnchorOffset = {
+    anchor: string;
+    offset: [number, number];
+};
+/**
+ * The offset of text at `anchor`, in ems, from `text-radial-offset` (`radial`) or from the size of
+ * `text-offset`, as MapLibre GL JS's `evaluateVariableOffset`: away from the anchor point, in the
+ * anchor's direction, with the vertical baseline shift.
+ */
+export declare function getVariableAnchorOffset(anchor: string, offset: number[], radial: boolean): [number, number];
+type MVTLabelLayerState = {
+    /** The placement this layer registered with, and its own when it has none from its props. */
+    placement?: LabelPlacement | null;
+    /**
+     * What the placement holds for this layer. deck.gl makes a new layer instance at each render
+     * and hands it the same state, so the placement holds this object, which points at the
+     * current instance.
+     */
+    placementHandle?: PlacementLayer & {
+        layer: MVTLabelLayer;
+    };
+    /** The deck whose shared placement this layer uses, without a `labelPlacement` prop. */
+    sharedPlacementKey?: object | null;
+    /** The shared placement of `sharedPlacementKey`. */
+    sharedPlacement?: LabelPlacement | null;
+    /** The first of this layer's placement slots, one per row in `getRows` order. */
+    placementSlotBase?: number;
+    /** Changes with every update, so a placement made before it is made again. */
+    placementRevision?: number;
+    /**
+     * Changes whenever the rows change, and with them the slot of each symbol, so that the placement
+     * places them at once (see `PlacementLayer.getPlacementSlotRevision`).
+     */
+    placementSlotRevision?: number;
+    /** The rows `placementSlotRevision` was counted for. */
+    placementSlotRows?: LabelRow[];
+    /** See `getPlacementGeometry`. */
+    placementGeometry?: PlacementGeometry;
+    placementRowBoxes?: {
+        key: unknown[];
+        boxes: WeakMap<LabelRow, Float64Array>;
+    };
+    placementCommons?: {
+        kind: string;
+        positions: WeakMap<LabelRow, number[]>;
+    };
+    /** The slot accessor of `getRows` from `placementSlotBase` (see `getPlacementSlotAccessor`). */
+    placementSlots?: {
+        rows: LabelRow[];
+        base: number;
+        accessor: (row: LabelRow) => number;
+    };
+    /** Flattened label rows generated from the current tile data. */
+    labelData?: LabelRow[];
+    /** `labelData` in reverse, the order every text and icon sublayer holds it in (see `getRows`). */
+    textRows?: {
+        source: LabelRow[];
+        rows: LabelRow[];
+    };
+    /** The non-data inputs `labelData` was computed with; a change recomputes it. */
+    anchorKey?: string;
+    /** The text and font `labelData`'s glyphs were loaded for (see `getGlyphKey`). */
+    glyphKey?: string;
+    /** The map bearing, in `BEARING_STEP` steps, that upright line labels were turned for. */
+    bearingStep?: number;
+    /** 1 while the layer waits for glyphs of the labels' text to load (see `hasLabelGlyphs`). */
+    glyphLoads?: number;
+    /** The glyph store the layer waits on while `glyphLoads` is 1. */
+    glyphLoadStore?: unknown;
+    /**
+     * The glyph store's `generation` when it refused a font stack of `labelData`'s text, for a
+     * layer of one tile's `data` (see `TileRows.refusedGeneration`).
+     */
+    refusedGeneration?: number;
+    /** The CSS font of labels along lines last seen loading; see `isLineTextFontLoading`. */
+    loadingFont?: string;
+    /**
+     * Each row's glyphs along its line, with what they were placed for, by the id of the view they
+     * were placed in, the first view placed in first (see `getLineGlyphs`).
+     */
+    lineGlyphs?: Map<string, WeakMap<LabelRow, {
+        key: string;
+        placements: RowGlyphPlacements | null;
+    }>>;
+    /** The halos of the label rows: one entry per distinct halo, and each row's entry index. */
+    halos?: LabelHalos;
+    /** The `labelData` and style inputs `halos` was computed with; a change recomputes it. */
+    haloKey?: [LabelRow[] | undefined, string];
+    /**
+     * Label text for the current text update trigger and label rows, per feature, and the wrap
+     * budget left for them. deck.gl reads each label's text several times per update; the cache
+     * keeps every read the same once the budget runs out, and wraps each label once.
+     */
+    labelText?: {
+        /** The text trigger, the rows and the font the text was wrapped for. */
+        key: [string, LabelRow[] | undefined, string];
+        budget: WrapBudget;
+        labels: WeakMap<FeatureLike, string | undefined>;
+        /** Per label row, whether it has text (see `getRowsWithText`). */
+        rowsWithText?: boolean[];
+    };
+    /** The sprite textures of the icon layers, shared with other label layers. */
+    iconTextures?: SharedTextureSet;
+    /**
+     * Style property values by compiled property, for the zoom step they were evaluated at, by
+     * feature (see `evaluateStyleProperty`).
+     */
+    styleValues?: WeakMap<CompiledStyleProperty, {
+        zoom: number;
+        values: WeakMap<FeatureLike, unknown>;
+    }>;
+    /** In a `tiles` layer: each tile's anchors, by tile index, and the tiles they were combined for. */
+    tileRows?: Map<string, TileRows>;
+    rowTiles?: LabelTile[];
+};
+/** A label halo as deck.gl `TextLayer` draws it: an SDF outline color, width and blur. */
+export type LabelHalo = {
+    /** Halo color, RGBA with alpha in 0-255. */
+    outlineColor: number[];
+    /** `TextLayer` `outlineWidth` (see {@link getOutlineWidth}). */
+    outlineWidth: number;
+    /** `TextHaloBlurExtension` `textHaloBlurGamma` (see {@link getHaloBlurGamma}). */
+    outlineBlur: number;
+};
+type LabelHalos = {
+    /** Distinct halos, `null` for labels without one. */
+    halos: (LabelHalo | null)[];
+    /** For each label row, its index in `halos`. */
+    rowHalos: number[];
+};
+/**
+ * Font atlas settings for label text. Glyphs are drawn as signed distance fields, so `TextLayer`
+ * can outline them for `text-halo-*`. The distance field reaches as far as the widest halo:
+ * MapLibre caps `text-halo-width` at a quarter of the text size, 16 pixels of a 64-pixel glyph.
+ * `TextLayer` outlines no further out than `(0.75 - smoothing) * radius` pixels, 15.6 here, and
+ * its halo edge fades over another `smoothing * radius` pixels, which the `buffer` keeps.
+ * `TextLayer` draws the glyph edge at a fixed distance value, so a `cutoff` below the default 0.25
+ * moves the drawn edge `(0.25 - cutoff) * radius` pixels outward, and the halo with it. At 0.24,
+ * small text matches the stroke weight of a plain bitmap atlas more closely.
+ */
+declare const LABEL_FONT_SETTINGS: {
+    sdf: boolean;
+    fontSize: number;
+    buffer: number;
+    radius: number;
+    cutoff: number;
+    smoothing: number;
+};
+/**
+ * Most halos one label layer draws, each with its own text sublayer. Labels without a halo get
+ * one more sublayer, and with more than one sublayer, another places the labels. Each sublayer
+ * holds every label row (see `renderLayers`), so the cap bounds the work per tile when every
+ * feature has its own halo.
+ */
+export declare const MAX_HALO_SUBLAYERS = 8;
+/**
+ * Converts a `text-halo-width`, in pixels, to `TextLayer`'s `outlineWidth` for text of `textSize`
+ * pixels, in an atlas of `fontSize` pixels per em. An atlas pixel is `textSize / fontSize` screen pixels, so the same halo needs a wider
+ * outline on smaller text. As in MapLibre, the halo is at most a quarter of the text size.
+ */
+export declare function getOutlineWidth(haloWidth: number, textSize: number, fontSize?: number): number;
+/**
+ * A row's glyphs along its line: `dx, dy, angle, mode` per character (see `LineGlyphPlacement`),
+ * and the path its collision circles follow, `x, y` pixels from the anchor, or null when the text
+ * does not fit on the line unturned. Text that must turn but does not fit turned keeps the unturned
+ * path, with every glyph hidden.
+ */
+type RowLineGlyphs = {
+    glyphs: Float32Array;
+    path: number[] | null;
+};
+/**
+ * A row's glyphs along its line at one zoom step, both ways round: `layout` is the unturned
+ * placement (null when the text does not fit on the line), from which `getLineGlyphs` decides which
+ * way the label reads; `turned` is null when `text-keep-upright` never turns it.
+ */
+type RowGlyphPlacements = {
+    count: number;
+    layout: LineGlyphs | null;
+    unturned: RowLineGlyphs;
+    turned: RowLineGlyphs | null;
+};
+/**
+ * Work done placing glyphs along lines, for benchmarks: rows placed, cached placements reused and
+ * collision paths taken to the screen.
+ */
+export declare const LINE_GLYPH_STATS: {
+    rows: number;
+    cacheHits: number;
+    placementPaths: number;
+};
+/** The estimated length of `text` in ems: about square for wide characters, narrower for others. */
+export declare function getTextLengthEms(text: string): number;
+/**
+ * Turns `offset`, `[x, y]` in pixels with y pointing down, by `angle` degrees counter-clockwise,
+ * as deck.gl's `IconLayer` turns an icon by its `getAngle`.
+ */
+export declare function rotatePixelOffset([x, y]: number[], angle: number): [number, number];
+/**
+ * What the line placements of one tile and style layer share: how label text is measured, in ems,
+ * and the anchors placed so far per label text (see `isNearSameText`).
+ */
+type LinePlacementContext = {
+    measureText: (text: string) => number;
+    placed: Map<string, number[][]>;
+};
+/** The rows whose `part` (text or icon) is drawn by the same sublayers, with the same collision. */
+type SymbolPartGroup = {
+    /** Appended to the ids of the group's sublayers. */
+    idSuffix: string;
+    /** Per row, whether the row is in the group; `null` when every row is. */
+    rows: boolean[] | null;
+};
+/**
+ * Renders label text for decoded vector-tile features, with optional geometry
+ * passthrough for debugging.
+ */
+export declare class MVTLabelLayer extends CompositeLayer<MVTLabelLayerProps> {
+    /** Deck.gl layer name. */
+    static layerName: string;
+    /** Default props for {@link MVTLabelLayer}. */
+    static defaultProps: DefaultProps<MVTLabelLayerProps>;
+    /** Current label-row state. */
+    state: MVTLabelLayerState;
+    /** Not loaded while the glyphs of its labels load: their tiles are not labelled yet. */
+    get isLoaded(): boolean;
+    /** The tile whose anchors are being placed, in a `tiles` layer; see `getTileProps`. */
+    private placingTile;
+    /** The tile props that anchors are placed with: the tile being placed, or this layer's. */
+    getTileProps(): Pick<MVTLabelLayerProps, 'tileBoundingBox' | 'tileZoom' | 'tileSize'>;
+    /** A picked label of a `tiles` layer reports its tile. */
+    getPickingInfo(params: any): any;
+    /**
+     * The image name `icon-image` gives a feature, with its tokens resolved: empty for none. While the
+     * sprites load, an `["image", ...]` expression still names its image, which is not available yet.
+     */
+    getIconImageName(feature: FeatureLike): string;
+    /**
+     * Resolves `icon-image` for a feature against the loaded sprites. Legacy `{token}` names are
+     * resolved as in `text-field`. Returns `null`, and warns once per name, when no sprite has it.
+     */
+    getIcon(feature: FeatureLike): ResolvedSpriteIcon | null;
+    /** On-screen icon height in pixels: the image's CSS-pixel height scaled by `icon-size`. */
+    getIconSize(feature: FeatureLike): number;
+    /**
+     * Icon color: `icon-color` for SDF images, white otherwise (deck.gl draws unmasked icons in
+     * their own colors), with `icon-opacity` as alpha.
+     */
+    getIconColor(feature: FeatureLike): number[];
+    /**
+     * Icon pixel offset: `icon-anchor` places that edge or corner of the icon on the point, and
+     * `icon-offset` shifts it by pixels scaled with `icon-size`, as in MapLibre.
+     */
+    getIconPixelOffset(feature: FeatureLike): [number, number];
+    /**
+     * Text pixel offset from `text-offset`, which is in ems of `text-size`, or from a non-zero
+     * `text-radial-offset`, which MapLibre GL JS takes instead, in the direction of `text-anchor`.
+     * A layer with variable anchors takes its offset from its anchor at placement, which MapLibre
+     * does only for point labels, so its line labels have none.
+     */
+    getLabelPixelOffset(feature: FeatureLike): [number, number];
+    /**
+     * The anchors a point label tries, in order, with their offsets in ems, from
+     * `text-variable-anchor-offset`, or from `text-variable-anchor` with `text-radial-offset` (when
+     * the layer sets it) or `text-offset`, as MapLibre GL JS's `getTextVariableAnchorOffset`; `null`
+     * without variable anchors or along lines.
+     */
+    getTextAnchors(feature: FeatureLike, placement?: string): TextAnchorOffset[] | null;
+    /** The variable anchor a row's label is drawn at (see `LabelRow.textAnchorIndex`), or `null`. */
+    getRowTextAnchor(row: LabelRow): TextAnchorOffset | null;
+    /** The `text-anchor` a row's label is drawn at: its variable anchor, or the feature's. */
+    getRowAnchor(row: LabelRow): string;
+    /** A row's text pixel offset: its variable anchor's, or the feature's (`getLabelPixelOffset`). */
+    getRowPixelOffset(row: LabelRow): [number, number];
+    /** `text-padding` at the stepped zoom, in pixels. */
+    getTextPadding(): number;
+    /**
+     * Update trigger for accessors that read `propertyNames`: the properties' style values, plus the
+     * stepped zoom when any of them depends on zoom. A value edited in place, or a new zoom step for a
+     * zoom-dependent value, re-evaluates the accessor; other zoom changes do not.
+     */
+    getStyleUpdateTrigger(...propertyNames: string[]): string;
+    /** Update triggers for the icon accessors (see `getStyleUpdateTrigger`). */
+    getIconUpdateTriggers(): Record<string, string>;
+    /**
+     * One `IconLayer` per sprite that this layer's icons come from. Each holds every label row, so
+     * an icon has the same row index, and so the same placement slot, as its own label. Rows whose
+     * icon is in another sprite, or in none, draw nothing.
+     *
+     * `icon-image` is evaluated once per row. Each sprite's layer evaluates the other style
+     * properties only for its own rows and gives every other row constants, so the style evaluation
+     * across all layers is linear in the rows. The instance count is rows times the sprites a tile
+     * uses (twice that when the rules differ), and only the style's `sprite` list adds sprites: tile
+     * data cannot.
+     */
+    renderIconLayers(icons?: (ResolvedSpriteIcon | null)[]): any[];
+    /**
+     * The label rows in the order every text and icon sublayer holds them: `labelData` in reverse.
+     * A symbol's placement slot follows its index here, so an icon and its label share it; every
+     * per-row array that these sublayers index (row icons, rows with text) is in this order.
+     * Placement walks `labelData`, in feature order (see `getPlacementSymbols`).
+     */
+    getRows(): LabelRow[];
+    /**
+     * Per label row, whether it has text (see `getLabel`). The result is kept with the label text
+     * cache, so it is evaluated once per text update trigger and label rows, not on every render.
+     */
+    getRowsWithText(): boolean[];
+    /**
+     * The texture of a sprite's image, shared by the icon layers of every label layer, or its URL
+     * while it is not decoded. deck.gl would otherwise upload the image for each icon layer.
+     */
+    getIconAtlas(atlas: SpriteAtlas): unknown;
+    /** Releases the sprite textures that the icon layers no longer draw from. */
+    retainIconAtlases(atlases: Set<SpriteAtlas>): void;
+    /**
+     * Each label row's icon, resolved against the loaded sprites (see `getIcon`), or all `null`
+     * while the layer has no `icon-image` or no sprites.
+     */
+    getRowIcons(): (ResolvedSpriteIcon | null)[];
+    /**
+     * The groups of rows each part is drawn by: one group of every row, since placement decides per
+     * symbol which parts draw (see `LabelPlacement`).
+     */
+    getSymbolPartGroups(_part: 'text' | 'icon', _hasOtherPart: () => boolean[]): SymbolPartGroup[];
+    /** Returns a compiled `layout` or `paint` property of the style layer, if it sets one. */
+    private getStyleProperty;
+    /**
+     * Evaluates a style property for a feature at the stepped zoom (`getZoomBucket`). The value is
+     * kept for the feature until the zoom step or the property changes: a `tiles` layer makes its
+     * rows again whenever a tile is shown or hidden, and the rows of the other tiles keep their
+     * features, so their values are not evaluated again.
+     */
+    private evaluateStyleProperty;
+    /**
+     * The CSS font of this layer's labels, from `text-font` at the stepped zoom, or the style
+     * spec's default font when the layer does not set it, with the `fontFamily` override applied.
+     * `TextLayer` takes one font per layer, so a data-driven `text-font` is evaluated for the first
+     * label feature only.
+     */
+    getFont(): LabelFont;
+    /**
+     * The `text-font` stack of a feature's label as glyph URLs name it, its fonts joined by commas:
+     * of the first label row's feature when none is given, as `getFont`.
+     */
+    getFontStack(feature?: FeatureLike): string;
+    /** `TextLayer`'s font atlas settings: of the style's glyphs, or of the browser's fonts. */
+    getFontSettings(): typeof LABEL_FONT_SETTINGS;
+    /** The advance of a character in ems, in the font or glyphs the labels are drawn with. */
+    getCharacterMeasurer(): (character: string) => number;
+    /**
+     * `TextLayer`'s font props: the style's glyphs of the layer's font stack, drawn by their own
+     * font renderer into an atlas of their own, or the CSS font.
+     */
+    getFontProps(font?: LabelFont): Record<string, unknown>;
+    /**
+     * What the label text is drawn with: the font stack of the style's glyph store, or the CSS font.
+     * A new store for the same URL may hold other glyphs, so text is measured again with it.
+     */
+    getFontKey(): string;
+    /**
+     * The inputs that choose the glyphs of the label text: the glyph store, as a new one for the same
+     * URL has none of the old one's glyphs loaded, the style's glyphs, and `text-field`,
+     * `text-transform` and `text-font`, with the stepped zoom when any of them depends on zoom.
+     * Point anchors do not depend on them, so rows kept for unchanged anchors check their glyphs
+     * again when this changes: a zoom step can change the text to another glyph range or font stack.
+     */
+    getGlyphKey(): string;
+    /**
+     * `features` without those whose label text is in a font stack of `refused` (see
+     * `hasLabelGlyphs`). Their rows are left out rather than drawn without glyphs: `TextLayer` would
+     * draw their characters into the font atlas as empty cells, and keep drawing them so once the
+     * store retains the font stack and its glyphs load.
+     */
+    withoutRefusedLabels(features: FeatureLike[], refused: ReadonlySet<string>): FeatureLike[];
+    /**
+     * Whether the glyphs of the label text of `features` have loaded, with the style's glyphs. When
+     * they have not, they are requested, and the layer updates once they have, as MapLibre GL JS
+     * places a tile's symbols once their glyphs have loaded.
+     *
+     * The layer retains the font stack of each feature's text in the store, before it loads any,
+     * and adds it to `fontStacks`: loading the glyphs of some font stacks then cannot drop those of
+     * others that the layer draws or waits for. A feature whose font stack the store will not
+     * retain (see `GlyphStore.retain`) is not waited for: its label is left undrawn, as that of a
+     * glyph range that fails to load, so that the labels of the other features settle. Its font
+     * stack is added to `refused`, and its row left out (see `withoutRefusedLabels`).
+     */
+    hasLabelGlyphs(features: FeatureLike[], fontStacks: Set<string>, refused?: Set<string>): boolean;
+    /**
+     * Extracts the visible label text for a decoded feature. Legacy `{token}` placeholders are
+     * resolved only in literal and zoom-function values, as in the style specification.
+     * Applies `text-transform` and Arabic shaping, balanced `text-max-width` wrapping for point
+     * labels, and the reordering of right-to-left text into the order it is drawn.
+     */
+    getLabel(feature: FeatureLike): string | undefined;
+    /**
+     * The label text of a feature as `getLabel` returns it, whatever its `text-size` at the map's
+     * zoom. Labels along lines are placed at the tile's zoom, where the text may be visible.
+     */
+    getLabelText(feature: FeatureLike): string | undefined;
+    /**
+     * A feature's label text, with `text-transform` and Arabic shaping applied, before wrapping and
+     * in logical order: its code points are those whose glyphs are drawn.
+     */
+    getUnwrappedLabelText(feature: FeatureLike): string | undefined;
+    /**
+     * `text-letter-spacing` of a feature's label `text`, in ems. As in MapLibre, text in a cursive
+     * script is not letter-spaced.
+     */
+    getLetterSpacing(feature: FeatureLike, text: string): number;
+    /**
+     * `text-justify` of a feature's label. MapLibre centers the lines of labels along lines.
+     */
+    getTextJustify(feature: FeatureLike): LabelTextJustify;
+    /**
+     * Returns the font size for a decoded feature label.
+     */
+    getLabelSize(feature: FeatureLike): number;
+    /**
+     * The font size a label's collision box is laid out at, as MapLibre GL JS lays it out: `text-size`
+     * at the zoom after the tile's, the integer zoom (its `layoutTextSize`). Where `text-size`
+     * changes with zoom, the box is that size and not the one drawn: at z3.6, a size that grows with
+     * zoom collides at its z4 size.
+     */
+    getCollisionLabelSize(feature: FeatureLike): number;
+    /**
+     * Returns the text color for a decoded feature label, from `text-color` and `text-opacity`.
+     * Falls back to the `textColor` prop, then to the style spec's default black, when the style
+     * layer does not set `text-color`.
+     */
+    getLabelColor(feature: FeatureLike): number[];
+    /**
+     * Returns the halo of a decoded feature label from `text-halo-color`, `text-halo-width` and
+     * `text-halo-blur`, or `null` when it has none: a width of 0 (the default) or a transparent color
+     * (the default). The color is faded by the same `text-opacity` as the text, so a hidden or faded
+     * label leaves no halo. Like the width, the blur is rounded to 0.25 px.
+     */
+    getLabelHalo(feature: FeatureLike): LabelHalo | null;
+    /**
+     * Groups the label rows by halo. `TextLayer` takes one outline color, width and blur per layer,
+     * so each distinct halo is drawn by its own text sublayer. At most `MAX_HALO_SUBLAYERS` halos are
+     * kept, the most common ones; labels with any other halo are drawn with the most common halo.
+     * Labels without a halo are not counted in the cap and never get one: a hidden label stays
+     * hidden. Kept halos are ordered by their first label, so sublayer ids stay stable.
+     */
+    getLabelHalos(rows: LabelRow[]): LabelHalos;
+    /**
+     * What the label text takes from `text-size`: a size of 0 hides the label (see `getLabel`). A size
+     * that depends on zoom but not on the feature re-evaluates the text only when it reaches or leaves
+     * 0, not at every zoom step, since the text and its wrapping do not depend on the size otherwise.
+     */
+    getLabelSizeTextTrigger(): string;
+    /** Update triggers for the text accessors (see `getStyleUpdateTrigger`). */
+    getLabelUpdateTriggers(): Record<string, string>;
+    /**
+     * The layer's `symbol-placement` at the stepped zoom. It is not data-driven, so it is evaluated
+     * once per style layer rather than per feature.
+     */
+    getSymbolPlacement(): string;
+    /**
+     * Line height in ems. It is not data-driven in the spec, so one value per style layer and
+     * zoom step is exact.
+     */
+    getLineHeight(): number;
+    /**
+     * The tile's own extent in feature coordinates: the `[0, 1)` square for tile-local coordinates,
+     * the tile's longitude/latitude box for globe tiles, or null when it is not known.
+     */
+    getTileBounds(geographic: boolean): number[] | null;
+    /**
+     * Extracts candidate label anchor positions from a feature geometry. Points are labelled where
+     * they are. Lines are labelled at the middle vertex of their first part here; with
+     * `symbol-placement: line` or `line-center`, `getLabelData` places them along the line instead
+     * (see `getLineLabelPlacements`). With `symbol-placement: point`, each polygon of a feature is
+     * labelled at its pole of inaccessibility, as in MapLibre, if that point lies in this tile;
+     * polygons are not labelled along their outline. `geographic` says whether coordinates are
+     * longitude/latitude (globe tiles) or tile-local. `budget` bounds the polygon searches; pass one
+     * budget for all features of a tile.
+     */
+    getLabelAnchors(feature: FeatureLike, geographic?: boolean, placement?: string, budget?: PoleSearchBudget): number[][];
+    /**
+     * The zoom at which labels along lines are placed, and the tile's size in pixels there. As in
+     * MapLibre, placement uses the tile's own zoom, so labels stay put while the map zooms within a
+     * tile; an overzoomed tile is placed at the integer map zoom. A tile's own zoom is the map zoom
+     * at which it is drawn `tileSize` pixels wide: one less than its tile zoom for 256 px tiles.
+     */
+    getLinePlacementScale(): {
+        zoom: number;
+        tileZoom: number;
+        tileSize: number;
+    };
+    /**
+     * Measures the text of labels along lines, in ems, with the font `TextLayer` draws it in. Without
+     * a canvas, or while that font is still loading (the browser would measure a fallback font), the
+     * length is estimated from the character count instead (`getTextLengthEms`), and the layer
+     * updates, placing the labels again, once the font has loaded.
+     */
+    getLineTextMeasurer(): (text: string) => number;
+    /**
+     * Whether the label font is still loading in the document. The first time it is seen loading,
+     * a load is requested, and the layer updates when it is done.
+     */
+    isLineTextFontLoading(font?: LabelFont): boolean;
+    /**
+     * Label anchors along the lines of a `LineString` or `MultiLineString` feature, for
+     * `symbol-placement: line` or `line-center`, with the direction of the line at each. Lines are
+     * measured in pixels at the tile's zoom (see `getLinePlacementScale`), where `symbol-spacing`,
+     * `text-max-angle` and the label's `text-letter-spacing` are evaluated. As in MapLibre, the label's length, the window its bends
+     * are summed in and the first label's offset come from `text-size` at zoom 18, the same for
+     * every tile; where that size is 0, the size at the tile's zoom is used. The text is measured by
+     * `context.measureText`. Anchors outside the tile's own extent are left to the neighbouring tile.
+     * With `line` placement, lines are clipped to the tile's extent first, as in MapLibre, and a
+     * label is dropped within half a `symbol-spacing` of an earlier label with the same text on the
+     * tile (`context.placed`); `line-center` measures the whole line. Each feature draws on the
+     * shared `budget`, at most `DEFAULT_LINE_ANCHOR_STEPS` of it.
+     */
+    getLineLabelPlacements(feature: FeatureLike, geographic: boolean, placement: string, budget?: LineAnchorBudget, context?: LinePlacementContext): {
+        position: number[];
+        angle: number;
+        line: RowLine;
+    }[];
+    /** What the line placements of one tile and style layer share; see `getLineLabelPlacements`. */
+    getLinePlacementContext(): LinePlacementContext;
+    /**
+     * For `symbol-placement: line`, the line features with the same label text whose ends meet,
+     * joined as MapLibre does (see `mergeLines`): per feature, the feature with the joined line to
+     * place labels along, `null` for a feature joined into another, or `undefined` to place the
+     * feature as it is. As in MapLibre, a `MultiLineString` joins by its first line only, and a
+     * feature joined into another is dropped whole, with any other lines it has: MapLibre's
+     * `mergeLines` takes each feature's `geometry[0]` and keeps the feature of the chain it joins.
+     */
+    getMergedLines(features: FeatureLike[]): (FeatureLike | null | undefined)[];
+    /**
+     * Label rows for every anchor of `features`: `symbol-placement` is evaluated once, and one
+     * search budget is shared by all polygons of the tile. With `line` or `line-center` placement,
+     * line features get rows along their lines, each with the line's direction.
+     */
+    getLabelData(features: FeatureLike[], geographic: boolean): LabelRow[];
+    /**
+     * The inputs besides the tile data that the anchors depend on: `symbol-placement`, the
+     * coordinate mode, the tile's extent and, for globe tiles, the search precision's zoom. Labels
+     * along lines also depend on the placement scale and on the style values that size and space
+     * them.
+     */
+    getAnchorKey(geographic: boolean): string;
+    /**
+     * The map bearing in `BEARING_STEP` steps, against which upright line labels are turned. Globe
+     * labels are billboards, drawn in screen space, so their bearing is 0.
+     */
+    getBearingStep(viewport?: {
+        bearing?: number;
+        projectionMode?: number;
+    } | undefined): number;
+    /**
+     * Labels along lines turn upright as the map rotates (`text-keep-upright`), so a layer of them
+     * updates when the bearing crosses a `BEARING_STEP`.
+     */
+    shouldUpdateState(params: UpdateParameters<this>): boolean;
+    /**
+     * Whether the text or icons of this layer turn with the lines they are placed along (see
+     * `getLineLabelProps` and `getIconAngleProps`). Only then do they depend on the bearing. Text
+     * needs a `text-field`, and icons an `icon-image` and loaded sprites.
+     */
+    turnsWithLines(): boolean;
+    /**
+     * Text layer props for labels along lines: each label is turned to its line, upright when
+     * `text-keep-upright` is set (the default). On a flat map they are drawn in the map plane, as
+     * MapLibre does with the `auto` `text-rotation-alignment` and `text-pitch-alignment` of line
+     * placement; on a globe they stay billboards, turned in screen space.
+     */
+    getLineLabelProps(): Record<string, unknown>;
+    /**
+     * Whether the glyphs of this layer's labels along lines are each placed on the line, as MapLibre
+     * draws them: text turned to lines on a flat map (where it is drawn in the map plane), sized in
+     * pixels, on WebGL. Otherwise labels are drawn straight, turned to their anchor's segment. On a
+     * globe, labels are billboards turned on screen, and stay straight.
+     */
+    curvesLineText(viewport?: any): boolean;
+    /** The zoom glyphs along lines are placed at: the viewport's, in `LINE_GLYPH_ZOOM_STEPS`. */
+    getGlyphZoom(viewport?: any): number;
+    /**
+     * The style inputs of glyphs along lines, besides the row's text and line: the style values,
+     * and the revision of the label font's advances (`getCharacterWidthsRevision`).
+     */
+    getLineGlyphStyleKey(): string;
+    /** The style values glyphs along lines are placed by. */
+    getLineGlyphStyleTrigger(): string;
+    /**
+     * The revision of the label font's advances, read when called: it changes once the font has
+     * loaded with other advances (`forgetCharacterWidths`), maybe as another layer found, without
+     * this layer updating.
+     */
+    getLineGlyphWidthsRevision(): () => number;
+    /**
+     * The text sublayers' `getLineGlyphs` and `getLineGlyphKey` (see `LabelTextLayer`), null when the
+     * layer draws its text straight, and the update trigger of the glyphs: the style. The glyphs also
+     * change with the view's zoom and bearing steps, and with the label font's advances, which the
+     * character layers check when they draw: placement reads the advances' revision anew, so the
+     * glyphs drawn follow the glyphs placed without this layer updating.
+     */
+    getLineGlyphProps(): {
+        getLineGlyphs: ((row: LabelRow, viewport: any) => Float32Array | null) | null;
+        getLineGlyphKey: ((viewport: any) => string) | null;
+        trigger: string;
+    };
+    /**
+     * Where each glyph of `row`'s label is drawn along its line at `viewport`'s zoom, as MapLibre GL
+     * JS's `placeGlyphsAlongLine`: each advance centre on the line, turned to the segment it lands on,
+     * the whole label turned around to read upright at `bearingStep` (from its first and last glyph,
+     * placed unturned). Null for a row drawn straight: not along a line, or multi-line text. The
+     * placements are cached per row for the zoom step and style, both ways round, so that every text
+     * sublayer and the placement share them, and a bearing step only checks which way each reads.
+     * Each view keeps its own, so that views at different zooms, as a main map and a minimap, do not
+     * place the glyphs again in turn.
+     */
+    getLineGlyphs(row: LabelRow, viewport: any, bearingStep: number, styleKey: string): RowLineGlyphs | null;
+    /**
+     * `row`'s glyphs placed along its line at `zoom` (see `getLineGlyphs`): unturned, and turned to
+     * read the other way when `text-keep-upright` may turn the label (null otherwise).
+     */
+    placeRowGlyphs(row: LabelRow, line: RowLine, feature: FeatureLike, text: string, zoom: number): RowGlyphPlacements;
+    /**
+     * The extensions that keep billboards along lines on their lines on a globe. A globe draws them
+     * in screen space, at angles taken from north up, so the shader turns them by the direction the
+     * view draws the line in, at every frame, and upright with `keepUpright`: there the bearing
+     * alone does not tell which way they read. A flat map draws them in the map plane. The shader
+     * keeps an angle upright only when it is the line's direction: icons turned by `icon-rotate` are
+     * kept upright from north up, by their angles. Text keeps its `text-offset` on its side of the
+     * line as it turns around.
+     */
+    getLineAngleExtensions(turnsWithLine: boolean, keepUpright: 'text-keep-upright' | 'icon-keep-upright', isLineDirection?: boolean): GlobeLineAngleExtension[];
+    /**
+     * Icon layer props that turn icons, and the angle each row's icon is turned by, counter-clockwise
+     * in degrees as deck.gl takes it (null when no icon turns). Icons along lines whose rotation is
+     * aligned to the map (`icon-rotation-alignment: map`, or `auto`) are turned to the line's
+     * direction, upright when `icon-keep-upright` is set (default false) as for text. Every icon then
+     * adds `icon-rotate`, clockwise. Icons aligned to the map are drawn flat on a flat map, so they
+     * turn with its bearing; the others are billboards, turned on screen. On a globe, icons stay
+     * billboards.
+     */
+    getIconAngleProps(): {
+        props: Record<string, unknown>;
+        getAngle: ((row: LabelRow) => number) | null;
+        extensions: GlobeLineAngleExtension[];
+    };
+    /**
+     * Forgets a font load in flight, so that its completion does not update a finalized layer, and
+     * releases the shared sprite textures.
+     */
+    finalizeState(context: LayerContext): void;
+    /**
+     * Recomputes label anchor rows when the source tile data, or an input the anchors depend on,
+     * changes.
+     */
+    updateState({ oldProps, changeFlags }: UpdateParameters<this>): void;
+    /** The rows of a layer of one tile's `data`. */
+    updateDataRows(data: NonNullable<MVTLabelLayerProps['data']>, geographic: boolean, dataChanged: boolean): void;
+    /**
+     * The rows of a `tiles` layer: each tile's anchors, placed as in a layer of the tile alone and
+     * kept while its features and anchor inputs do not change, in longitude/latitude, combined by
+     * `combineTileRows`. Tile-local anchors outside the tile's square are left out, as the tile's
+     * own layer clips them; on a globe, tiles keep the rows they have.
+     */
+    updateTileRows(tiles: LabelTile[], geographic: boolean): void;
+    /**
+     * Gives back the font stacks the layer retains in its glyph store other than `fontStacks`, those
+     * of the rows it keeps and of the tiles that wait for glyphs (see `GlyphStore.retain`).
+     */
+    retainGlyphs(fontStacks: ReadonlySet<string>, refused: boolean): void;
+    /**
+     * Renders the optional debug geometry and the text labels.
+     */
+    /** The placement this layer's labels take part in: its prop's, or its deck's shared one. */
+    getLabelPlacement(): LabelPlacement;
+    /** Registers with the placement, for the current rows. */
+    updatePlacement(): void;
+    /** Sublayer props that draw a part (0: text, 1: icons) where placement placed it. */
+    getPlacementProps(part: 0 | 1): Record<string, unknown>;
+    /**
+     * Each row's slot, by row: `TextLayer` does not hand its character layer the row's index in
+     * `data`, so the slot is found from the row itself.
+     */
+    getPlacementSlotAccessor(): ((row: LabelRow) => number) | number;
+    getPlacementOrder(): number;
+    getPlacementRevision(): number;
+    getPlacementSlotRevision(): number;
+    getPlacementSlotCount(): number;
+    /**
+     * `PlacementLayer.isDrawnIn`: whether deck.gl draws this layer in `viewport`, as its layers pass
+     * decides: the layer and its parents are visible, and each parent's `filterSubLayer` keeps it.
+     */
+    isDrawnIn(viewport: Viewport): boolean;
+    /**
+     * `PlacementLayer.getPlacementRoot`: the deck layer this layer is drawn under, and the deck's
+     * layers in draw order, so that the labels of a layer drawn over another (as a second
+     * `BasemapLayer`) are placed first.
+     */
+    getPlacementRoot(): {
+        root: Layer;
+        layers: readonly Layer[];
+    } | null;
+    /**
+     * What placement needs of each row that does not change with the view, kept until the rows, the
+     * label text, the sprites, the style's layout values, the font's measured widths or the zoom
+     * step change: the rules, the placement order, and per row (in `labelData` order) its text box
+     * (`x1, y1, w, h` in pixels from the anchor, before padding; `w` NaN without text) and its icon
+     * box (`x1, y1, x2, y2` padded, before any turn; `x1` NaN without an icon).
+     */
+    getPlacementGeometry(): PlacementGeometry | null;
+    /** `PlacementLayer.getPlacementSymbols`: this layer's symbols, in MapLibre's order. */
+    getPlacementSymbols(viewport: any, slotBase: number, out: PlacementSymbol[]): SymbolPlacementRules | null;
+    /**
+     * The common-space position of each `labelData` row (in longitude/latitude), for the kind of
+     * viewport: a globe's or a map's, which do not change with the view. Kept per row.
+     */
+    getPlacementCommons(viewport: any, geometry: PlacementGeometry): Float64Array;
+    /**
+     * Whether a common-space point on a globe's surface is beyond its horizon in `viewport`, as
+     * `GlobeHorizonExtension` tests it.
+     */
+    getHorizonTest(viewport: any): (x: number, y: number, z: number) => boolean;
+    /** Whether a longitude/latitude lies beyond the horizon of a globe viewport. */
+    isBeyondHorizon(viewport: any, position: number[]): boolean;
+    renderLayers(): any;
+}
+export {};