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

package/dist/types/polylabel.d.ts

@@ -0,0 +1,17 @@
+/** Default budget for one search: point-to-segment distance tests. */
+export declare const DEFAULT_POLE_SEARCH_SEGMENT_TESTS = 5000000;
+/** Remaining work, in point-to-segment distance tests, shared by the searches that use it. */
+export type PoleSearchBudget = {
+    segmentTests: number;
+};
+/**
+ * Returns the point inside a polygon farthest from its outline, to within `precision` in the
+ * polygon's units. `polygon` is GeoJSON-style: an outer ring followed by hole rings. Coordinates
+ * must be planar.
+ *
+ * The search spends at most `budget.segmentTests` point-to-segment distance tests and deducts
+ * what it spends, so one budget can bound several searches. When the budget runs out the best
+ * point found so far is returned. Returns null for a polygon without vertices, with a non-finite
+ * coordinate, or when the budget cannot pay for the first scored point.
+ */
+export declare function getPoleOfInaccessibility(polygon: number[][][], precision: number, budget?: PoleSearchBudget): [number, number] | null;

package/dist/types/raster-color-extension.d.ts

@@ -0,0 +1,146 @@
+/**
+ * @license
+ * Portions of this file are adapted from MapLibre GL JS v6.13.0,
+ * src/shaders/glsl/raster.fragment.glsl,
+ * under these licenses (see also THIRD-PARTY-NOTICES.md):
+ *
+ * Copyright (c) 2023, MapLibre contributors
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ *     * Redistributions of source code must retain the above copyright notice,
+ *       this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright notice,
+ *       this list of conditions and the following disclaimer in the documentation
+ *       and/or other materials provided with the distribution.
+ *     * Neither the name of MapLibre GL JS nor the names of its contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * MapLibre GL JS contains code from mapbox-gl-js v1.13 and earlier, licensed under a
+ * BSD-3-Clause license:
+ *
+ * Copyright (c) 2020, Mapbox
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * * Neither the name of Mapbox GL JS nor the names of its contributors
+ *   may be used to endorse or promote products derived from this software
+ *   without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+import { LayerExtension } from '@deck.gl/core';
+import type { CompositeLayer, Layer } from '@deck.gl/core';
+/** The style values of a raster layer's color adjustments, as evaluated from its paint. */
+export type RasterColorAdjustments = {
+    /** `raster-brightness-min`, 0 to 1. */
+    brightnessMin: number;
+    /** `raster-brightness-max`, 0 to 1. */
+    brightnessMax: number;
+    /** `raster-saturation`, -1 to 1. */
+    saturation: number;
+    /** `raster-contrast`, -1 to 1. */
+    contrast: number;
+    /** `raster-hue-rotate`, in degrees. */
+    hueRotate: number;
+};
+/** The style specification's defaults, which leave colors unchanged. */
+export declare const DEFAULT_RASTER_COLOR_ADJUSTMENTS: RasterColorAdjustments;
+/** The shader uniforms of a set of color adjustments, computed as MapLibre GL JS does. */
+export type RasterColorUniforms = {
+    brightnessLow: number;
+    brightnessHigh: number;
+    saturationFactor: number;
+    contrastFactor: number;
+    spinWeights: [number, number, number];
+};
+/** Converts color adjustments to shader uniforms, with MapLibre GL JS's `raster` program math. */
+export declare function getRasterColorUniforms(adjustments: RasterColorAdjustments): RasterColorUniforms;
+/** Whether a set of color adjustments changes any color. */
+export declare function hasRasterColorAdjustments(adjustments: RasterColorAdjustments): boolean;
+/** The blending of layers using `RasterColorExtension`, whose shader outputs premultiplied colors. */
+export declare const RASTER_COLOR_BLEND_PARAMETERS: {
+    readonly blendColorOperation: "add";
+    readonly blendColorSrcFactor: "one";
+    readonly blendColorDstFactor: "one-minus-src-alpha";
+    readonly blendAlphaOperation: "add";
+    readonly blendAlphaSrcFactor: "one";
+    readonly blendAlphaDstFactor: "one-minus-src-alpha";
+};
+type RasterColorExtensionProps = {
+    /** The color adjustments of the raster style layer. */
+    rasterColorAdjustments?: RasterColorAdjustments;
+};
+/**
+ * Applies a raster style layer's `raster-brightness-min`, `raster-brightness-max`,
+ * `raster-saturation`, `raster-contrast` and `raster-hue-rotate` to a `BitmapLayer`, with the
+ * formulas of MapLibre GL JS's raster shader. WebGL only.
+ *
+ * The adjusted colors are premultiplied, so the layer must blend with
+ * `RASTER_COLOR_BLEND_PARAMETERS` exactly where the shader runs. Added to a composite layer, the
+ * extension passes them to its sublayers as `rasterColorBlendParameters`, decided by the same
+ * device check as the shader; on WebGPU they are `null` and the sublayers keep their blending.
+ */
+export declare class RasterColorExtension extends LayerExtension {
+    static extensionName: string;
+    static defaultProps: {
+        rasterColorAdjustments: {
+            type: string;
+            value: RasterColorAdjustments;
+            compare: number;
+        };
+    };
+    getShaders(this: Layer<RasterColorExtensionProps>): {
+        modules?: undefined;
+        inject?: undefined;
+    } | {
+        modules: {
+            readonly name: "rasterColor";
+            readonly fs: "layout(std140) uniform rasterColorUniforms {\n  float brightnessLow;\n  float brightnessHigh;\n  float saturationFactor;\n  float contrastFactor;\n  vec3 spinWeights;\n} rasterColor;\n\n// MapLibre GL JS's raster fragment shader, applied to an unpremultiplied color.\nvec3 rasterColor_adjust(vec3 color) {\n  vec3 rgb = vec3(\n    dot(color, rasterColor.spinWeights.xyz),\n    dot(color, rasterColor.spinWeights.zxy),\n    dot(color, rasterColor.spinWeights.yzx)\n  );\n  float average = (color.r + color.g + color.b) / 3.0;\n  rgb += (average - rgb) * rasterColor.saturationFactor;\n  rgb = (rgb - 0.5) * rasterColor.contrastFactor + 0.5;\n  return mix(vec3(rasterColor.brightnessLow), vec3(rasterColor.brightnessHigh), rgb);\n}\n";
+            readonly uniformTypes: {
+                readonly brightnessLow: "f32";
+                readonly brightnessHigh: "f32";
+                readonly saturationFactor: "f32";
+                readonly contrastFactor: "f32";
+                readonly spinWeights: "vec3<f32>";
+            };
+        }[];
+        inject: {
+            'fs:DECKGL_FILTER_COLOR': string;
+        };
+    };
+    getSubLayerProps(this: CompositeLayer<RasterColorExtensionProps>, extension: this): any;
+    draw(this: Layer<RasterColorExtensionProps>): void;
+}
+export {};

package/dist/types/shared-texture.d.ts

@@ -0,0 +1,34 @@
+import type { Device, Texture } from '@luma.gl/core';
+/** Options of a `SharedTextureSet`. Sets with different options share no textures. */
+export type SharedTextureOptions = {
+    /**
+     * Most mip levels of a texture, the full image included: 1 for none. Default: the full chain.
+     * Fewer levels keep a minified texture sharper, at the cost of aliasing beyond the last level.
+     */
+    maxMipLevels?: number;
+};
+/**
+ * The textures one layer uses, shared with every other layer that uses the same image on the
+ * same device. deck.gl creates a texture, and uploads the image, for each layer that is handed an
+ * image: every label sublayer of every tile would upload the same font atlas and sprite sheet. A
+ * shared texture is created on first use and destroyed when its last user releases it.
+ */
+export declare class SharedTextureSet {
+    private device;
+    private images;
+    /** The options, as given at construction: they are part of the cache key. */
+    readonly options: Readonly<SharedTextureOptions>;
+    private optionsKey;
+    constructor(device: Device, { maxMipLevels }?: SharedTextureOptions);
+    /** The textures shared by the sets with this set's options on its device. */
+    private getTextures;
+    /** Returns the shared texture of `image`, which this set uses until `retainOnly` drops it. */
+    get(image: object): Texture;
+    /** Releases the textures of every image this set uses that is not in `images`. */
+    retainOnly(images: Iterable<object>): void;
+    /** Releases every texture this set uses. */
+    releaseAll(): void;
+    private release;
+}
+/** The number of shared textures alive on a device, for tests. */
+export declare function getSharedTextureCount(device: Device): number;

package/dist/types/sort-key.d.ts

@@ -0,0 +1,10 @@
+import type { ResolvedBasemapStyleLayer as BasemapStyleLayer } from "./style-resolver.js";
+/**
+ * A tile's features of a style layer in the order of their sort key (`circle-sort-key`,
+ * `line-sort-key`), ascending, as MapLibre GL JS orders a bucket: features with a higher key draw
+ * over those with a lower one, and features with the same key keep their tile order. Without a
+ * per-feature key, the features are returned as they are. The sorted array is reused while the
+ * features, the key and (for a key that depends on zoom) the style zoom are unchanged, so deck.gl
+ * does not re-tessellate the features at every zoom step.
+ */
+export declare function sortFeaturesByKey(features: any[], styleLayer: BasemapStyleLayer, propertyName: 'circle-sort-key' | 'line-sort-key', zoom: number): any[];

package/dist/types/sprite.d.ts

@@ -0,0 +1,82 @@
+import type { BasemapLoadOptions } from "./style-resolver.js";
+/** One image in a style sprite, as listed in the sprite's JSON index. */
+export type SpriteImage = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Device pixels per CSS pixel of the image. Default 1. */
+    pixelRatio?: number;
+    /** `true` for signed-distance-field images, which are tinted with `icon-color`. */
+    sdf?: boolean;
+};
+/** A deck.gl `IconLayer` mapping entry for one sprite image. */
+export type SpriteIconMappingEntry = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** `true` for SDF images: deck.gl tints masked icons with `getColor`. */
+    mask: boolean;
+    /** Device pixels per CSS pixel; `icon-size` scales `height / pixelRatio`. */
+    pixelRatio: number;
+};
+/** A loaded sprite: the atlas image and its deck.gl icon mapping. */
+export type SpriteAtlas = {
+    /**
+     * Sprite id. `'default'` for a style whose `sprite` is a single URL; otherwise the id from the
+     * style's sprite array, which prefixes its image names as `id:name`.
+     */
+    id: string;
+    /**
+     * The atlas image, decoded once and shared by every icon layer, or its URL where
+     * `createImageBitmap` is unavailable (each `IconLayer` then loads the URL itself).
+     */
+    image: ImageBitmap | string;
+    /** Icon mapping keyed by image name, without the `id:` prefix. */
+    mapping: Record<string, SpriteIconMappingEntry>;
+};
+/** A style's `sprite` value: a URL, or the array form with one `{id, url}` per sprite. */
+export type StyleSprite = string | Array<{
+    id: string;
+    url: string;
+}>;
+/** A sprite source after relative URLs are resolved. */
+export type SpriteSource = {
+    id: string;
+    url: string;
+};
+/** Options for {@link loadSpriteAtlases}. */
+export type SpriteLoadOptions = {
+    /** Base URL that relative sprite URLs resolve against, normally the style URL. */
+    baseUrl?: string;
+    /** Device pixel ratio. At 2 or more, the `@2x` sprite is requested first. Default 1. */
+    pixelRatio?: number;
+} & Pick<NonNullable<BasemapLoadOptions>, 'fetch' | 'fetchOptions'>;
+/** Resolves a style's `sprite` value into sprite sources with absolute URLs. */
+export declare function getSpriteSources(sprite: unknown, baseUrl?: string): SpriteSource[];
+/** Converts a sprite JSON index into a deck.gl `IconLayer` mapping. */
+export declare function getSpriteIconMapping(index: Record<string, SpriteImage>): Record<string, SpriteIconMappingEntry>;
+/**
+ * Loads every sprite a style references. A sprite that fails to load is skipped with a warning,
+ * so its icons are not drawn and the rest of the style still renders.
+ */
+export declare function loadSpriteAtlases(sprite: unknown, options?: SpriteLoadOptions): Promise<SpriteAtlas[]>;
+/**
+ * The image names `icon-image` can reference: unprefixed for the `'default'` sprite and `id:name`
+ * for the others. Passed to expression evaluation so `["image", ...]` sees which images exist.
+ */
+export declare function getSpriteImageNames(atlases: readonly SpriteAtlas[] | null | undefined): string[];
+/** An icon resolved against the loaded sprites. */
+export type ResolvedSpriteIcon = {
+    atlas: SpriteAtlas;
+    name: string;
+    entry: SpriteIconMappingEntry;
+};
+/**
+ * Finds the sprite and mapping entry for an `icon-image` name. Names from the `'default'` sprite
+ * are unprefixed; names from other sprites are written `id:name`, as in MapLibre.
+ */
+export declare function resolveSpriteIcon(atlases: readonly SpriteAtlas[] | undefined, iconImage: string): ResolvedSpriteIcon | null;
+/** Warns once per icon name that a style references an image no loaded sprite contains. */
+export declare function warnMissingIcon(iconImage: string): void;

package/dist/types/style-accessor.d.ts

@@ -0,0 +1,45 @@
+import { type StyleFeature } from "./style-expression.js";
+type StyleLayerLike = {
+    paint?: Record<string, unknown>;
+    layout?: Record<string, unknown>;
+};
+/**
+ * Zoom step at which style values are evaluated. Paint and layout values step every
+ * `STYLE_ZOOM_STEP` zoom levels instead of following the zoom continuously.
+ */
+export declare const STYLE_ZOOM_STEP = 0.25;
+/**
+ * Zoom at which paint and layout values are evaluated: the zoom rounded down to a
+ * `STYLE_ZOOM_STEP`.
+ *
+ * This is a temporary simplification, not MapLibre's behaviour. MapLibre evaluates zoom-dependent
+ * expressions at the integer zooms on either side of the current zoom and interpolates between
+ * them on the GPU, which remains the long-term plan here. Stepping keeps every tile on the same
+ * evaluation zoom, so neighbouring tiles agree at their seams.
+ */
+export declare function getZoomBucket(zoom: number): number;
+/** Zoom at which filters are evaluated: the integer zoom, as the style spec specifies. */
+export declare function getFilterZoom(zoom: number): number;
+/**
+ * A key that changes whenever style evaluation or layer visibility changes: at every
+ * `STYLE_ZOOM_STEP` (which includes every integer zoom, where filters change), and at every
+ * fractional `minzoom`/`maxzoom` in `zoomLimits`. Layer visibility uses the exact zoom, as in
+ * MapLibre, so crossing a fractional limit must regenerate sublayers too.
+ */
+export declare function getStyleZoomKey(zoom: number, zoomLimits: readonly (number | undefined)[]): string;
+/** A deck.gl accessor built from one or more style properties. */
+export type StyleAccessor<T> = {
+    /** A constant when no property depends on feature data, otherwise a per-feature function. */
+    value: T | ((feature: StyleFeature) => T);
+    /** Set to the evaluation zoom (`getZoomBucket`) when a per-feature value also depends on zoom. */
+    updateTrigger?: number;
+};
+/**
+ * Builds a deck.gl accessor from style properties, evaluated at the stepped zoom
+ * (`getZoomBucket`). Feature-independent values become constants. Data-driven values become
+ * per-feature functions, with an update trigger when they also depend on zoom.
+ */
+export declare function getStyleAccessor<T>(styleLayer: StyleLayerLike, propertyNames: string[], zoom: number, combine: (values: any[]) => T): StyleAccessor<T>;
+/** Converts a style color (alpha 0-1 or 0-255) and opacity into a deck.gl RGBA color. */
+export declare function withOpacity(color: number[] | null | undefined, opacity?: number): [number, number, number, number];
+export {};

package/dist/types/style-expression.d.ts

@@ -0,0 +1,83 @@
+import { Color } from '@maplibre/maplibre-gl-style-spec';
+/** A feature as seen by style expressions: a GeoJSON feature or a numeric-typed tile feature. */
+export type StyleFeature = {
+    type?: number | string;
+    id?: unknown;
+    geometry?: {
+        type: string;
+    };
+    properties?: Record<string, unknown>;
+};
+/** A style property compiled once and evaluated per zoom and feature. */
+export type CompiledStyleProperty = {
+    /** True when the value depends on `["zoom"]`. */
+    isZoomDependent: boolean;
+    /** True when the value depends on feature data (`["get", ...]`, `match`, ...). */
+    isFeatureDependent: boolean;
+    /**
+     * Evaluates the property. Colors are returned as `[r, g, b, a]`, with `a` in 0-1.
+     * `availableImages` lists the loaded sprite image names, which `["image", ...]` checks.
+     */
+    evaluate: (zoom: number, feature?: StyleFeature, availableImages?: string[]) => unknown;
+    /**
+     * Evaluates the property with every global input, such as `heatmapDensity` or `lineProgress`
+     * as well as `zoom`. Colors are returned as in `evaluate`.
+     */
+    evaluateWithGlobals: (globals: Record<string, unknown>, feature?: StyleFeature) => unknown;
+};
+type StyleLayerLike = {
+    paint?: Record<string, unknown>;
+    layout?: Record<string, unknown>;
+};
+type PropertyReference = Record<string, unknown> | null;
+type StyleFilter = (globalProperties: Record<string, unknown>, feature: StyleFeature) => boolean;
+/** Returns whether a style property is a `layout` or a `paint` property. */
+export declare function getStylePropertyType(propertyName: string): 'layout' | 'paint';
+/** Resolves the style-spec reference metadata for a layout or paint property name. */
+export declare function getStylePropertyReference(propertyName: string): PropertyReference;
+/** Returns the style-spec geometry type code (1 point, 2 line, 3 polygon) of a feature. */
+export declare function getStyleGeometryType(feature: StyleFeature): number | undefined;
+/**
+ * Converts a style-spec color to `[r, g, b, a]` with RGB in 0-255 and alpha in 0-1, the shape
+ * `@mapbox/mapbox-gl-style-spec`'s `Color#toArray()` returned. MapLibre's `Color` stores
+ * premultiplied components; its `rgb` getter returns them un-premultiplied in 0-1.
+ */
+export declare function colorToArray(color: Color): [number, number, number, number];
+/**
+ * Returns the style specification's default for a property, in the shape `evaluate` returns:
+ * colors as `[r, g, b, a]`, paddings as `[top, right, bottom, left]`. Undefined for a property
+ * without a default.
+ */
+export declare function getStylePropertyDefault(propertyName: string): unknown;
+/**
+ * Compiles a single property value against its style-spec reference. Returns `null` and logs a
+ * warning once for a value the style spec rejects, so the property is treated as unset, as
+ * MapLibre skips invalid properties.
+ */
+export declare function compileStylePropertyValue(propertyName: string, value: unknown): CompiledStyleProperty | null;
+/**
+ * Returns a compiled `paint` or `layout` property of a style layer, or `null` when the layer
+ * does not set it. Compilation is cached per style layer object and property; the cached entry is
+ * reused only while the layer still holds the same value, so editing a property in place
+ * recompiles it.
+ */
+export declare function getCompiledStyleProperty(styleLayer: StyleLayerLike, propertyName: string): CompiledStyleProperty | null;
+/**
+ * Compiles a style-spec filter into a feature predicate, cached per filter array. The cached
+ * predicate is reused only while the array's contents are unchanged, so a filter edited in place
+ * is recompiled. A filter the style spec rejects logs a warning once and matches no features.
+ */
+export declare function compileStyleFilter(filter: unknown): StyleFilter;
+/** A style's `light`, evaluated at one zoom. Colors are `[r, g, b, a]`, RGB in 0-255. */
+export type EvaluatedStyleLight = {
+    anchor: unknown;
+    position: unknown;
+    color: unknown;
+    intensity: unknown;
+};
+/**
+ * Evaluates a style's `light` at a zoom, property by property. A property the style does not set,
+ * or sets to a value the style spec rejects (logged once), takes the spec's default.
+ */
+export declare function evaluateStyleLight(light: unknown, zoom: number): EvaluatedStyleLight;
+export {};

package/dist/types/style-resolver.d.ts

@@ -0,0 +1,94 @@
+/**
+ * A basemap source entry from a style document.
+ */
+export type BasemapSource = {
+    /** Source kind such as `vector` or `raster`. */
+    type?: string;
+    /** Optional TileJSON URL used to resolve the source metadata. */
+    url?: string;
+    /** Inline tile templates for the source. */
+    tiles?: string[];
+    /** Minimum source zoom, when supplied by the style or TileJSON. */
+    minzoom?: number;
+    /** Maximum source zoom, when supplied by the style or TileJSON. */
+    maxzoom?: number;
+    /** Tile size in pixels. */
+    tileSize?: number;
+    /** Additional source properties are preserved verbatim. */
+    [key: string]: unknown;
+};
+/**
+ * A style layer entry used by the basemap runtime.
+ */
+export type BasemapStyleLayer = {
+    /** Unique layer identifier. */
+    id: string;
+    /** Optional concrete style layer type such as `background`, `fill`, `line`, or `raster`. */
+    type?: string;
+    /** Legacy style layer id whose structural render properties are inherited. */
+    ref?: string;
+    /** Referenced source identifier. */
+    source?: string;
+    /** Referenced vector source-layer identifier. */
+    'source-layer'?: string;
+    /** Optional minimum zoom. */
+    minzoom?: number;
+    /** Optional maximum zoom. */
+    maxzoom?: number;
+    /** Optional style-spec filter expression. */
+    filter?: unknown[];
+    /** Paint properties from the source style layer. */
+    paint?: Record<string, unknown>;
+    /** Layout properties from the source style layer. */
+    layout?: Record<string, unknown>;
+    /** Additional layer properties are preserved verbatim. */
+    [key: string]: unknown;
+};
+/** A style layer after legacy `ref` inheritance has been resolved. */
+export type ResolvedBasemapStyleLayer = BasemapStyleLayer & {
+    /** Concrete style layer type after optional `ref` inheritance. */
+    type: string;
+};
+/**
+ * A MapLibre or Mapbox style document consumed by the basemap runtime.
+ */
+export type BasemapStyle = {
+    /** Style-spec version number. */
+    version?: number;
+    /** Optional style metadata bag. */
+    metadata?: Record<string, unknown>;
+    /** Named source definitions used by the style. */
+    sources?: Record<string, BasemapSource>;
+    /** Ordered list of style layers. */
+    layers?: BasemapStyleLayer[];
+    /** Additional style properties are preserved verbatim. */
+    [key: string]: unknown;
+};
+/**
+ * A style document after all sources have been normalized and TileJSON-backed
+ * sources have been resolved.
+ */
+export type ResolvedBasemapStyle = Omit<BasemapStyle, 'sources' | 'layers'> & {
+    /** Fully resolved source definitions. */
+    sources: Record<string, BasemapSource>;
+    /** Style layers copied into a mutable array. */
+    layers: ResolvedBasemapStyleLayer[];
+};
+/**
+ * Load options accepted by {@link resolveBasemapStyle}.
+ */
+export type BasemapLoadOptions = {
+    /** Base URL used to resolve relative source or tile URLs for in-memory styles. */
+    baseUrl?: string;
+    /** Optional custom fetch implementation. */
+    fetch?: typeof fetch;
+    /** Optional init object passed to the selected fetch implementation. */
+    fetchOptions?: RequestInit;
+    /** Additional loader options are accepted for forward compatibility. */
+    [key: string]: unknown;
+} | null;
+/**
+ * Resolves a basemap style input into a style object whose sources contain
+ * directly consumable tile templates and source metadata.
+ */
+export declare function resolveBasemapStyle(style: string | BasemapStyle, loadOptions?: BasemapLoadOptions): Promise<ResolvedBasemapStyle>;

package/dist/types/text-font.d.ts

@@ -0,0 +1,36 @@
+/**
+ * A label font as CSS: a family list ending with a generic family, a numeric weight and a style.
+ */
+export type LabelFont = {
+    /** CSS `font-family` list, e.g. `"Noto Sans", sans-serif`. */
+    fontFamily: string;
+    /** CSS numeric `font-weight`, 100-900. */
+    fontWeight: number;
+    /** CSS `font-style`. */
+    fontStyle: 'normal' | 'italic';
+};
+/**
+ * Overrides the label font derived from `text-font`. A string is the CSS family list for every
+ * label; the weight and style still come from `text-font`. A function receives the evaluated
+ * `text-font` names and returns a CSS family list, or any of the {@link LabelFont} fields; fields
+ * it leaves out, or a `null` result, keep the mapped values.
+ */
+export type LabelFontFamily = string | ((fontStack: string[]) => string | Partial<LabelFont> | null | undefined);
+/** The style specification's default `text-font`. */
+export declare const DEFAULT_TEXT_FONT: string[];
+/**
+ * Maps a style's `text-font` stack to a CSS font. Each name's trailing weight and style words
+ * (`Regular`, `Bold`, `Semibold Italic`, ...) are stripped to give its family; the families are
+ * listed in stack order and end with a generic family, so labels still draw when none of the
+ * fonts is installed. `TextLayer` takes one weight per layer, so the weight and style come from
+ * the first font of the stack.
+ */
+export declare function getLabelFont(fontStack: string[]): LabelFont;
+/** {@link getLabelFont}, with the caller's {@link LabelFontFamily} override applied. */
+export declare function resolveLabelFont(fontStack: string[], fontFamily?: LabelFontFamily | null): LabelFont;
+/**
+ * `TextLayer`'s `fontWeight` prop for a font. `TextLayer` has no `fontStyle` prop and writes
+ * `fontWeight` in front of the size in the canvas font string, so an italic font puts its style
+ * in front of the weight there (`italic 400`), which is valid CSS font shorthand.
+ */
+export declare function getTextLayerFontWeight(font: LabelFont): number | string;

package/dist/types/text-halo-blur-extension.d.ts

@@ -0,0 +1,55 @@
+import { LayerExtension } from '@deck.gl/core';
+import type { Layer } from '@deck.gl/core';
+/**
+ * Converts a `text-halo-blur`, in pixels, to the signed distance by which `TextLayer`'s halo edge
+ * fades on each side, beyond the edge's own smoothing, for text of `textSize` pixels drawn from a
+ * font atlas of `fontSize` pixels whose distance field reaches `radius` atlas pixels. As in
+ * MapLibre, the fade is `1.19 * blur` screen pixels on each side of the halo edge; an atlas pixel
+ * is `textSize / fontSize` screen pixels and `1 / radius` of the distance field.
+ */
+export declare function getHaloBlurGamma(haloBlur: number, textSize: number, { fontSize, radius }: {
+    fontSize: number;
+    radius: number;
+}): number;
+type TextHaloBlurExtensionProps = {
+    /** Distance by which the halo edge fades on each side, see {@link getHaloBlurGamma}. */
+    textHaloBlurGamma?: number;
+    /**
+     * Whether the fade ends where the distance field does (default), or reaches past it and is cut
+     * at the glyph's quad, as MapLibre GL JS draws its glyphs.
+     */
+    textHaloBlurCapped?: boolean;
+};
+/**
+ * Blurs the halo of a `LabelTextLayer`, as MapLibre GL JS draws `text-halo-blur`: the halo edge
+ * fades over `textHaloBlurGamma` more distance on each side, beyond its own antialiasing of 0.84
+ * device pixels (see `LabelCharactersLayer`), as MapLibre's. Labels that lie on a pitched map fade
+ * over 1 / cos(pitch) times that distance, blur and antialiasing alike, as MapLibre's (see
+ * `getLabelForeshortening`). The glyphs stay as sharp as without the extension. WebGL only; on
+ * WebGPU the halo draws without blur.
+ */
+export declare class TextHaloBlurExtension extends LayerExtension {
+    static extensionName: string;
+    static defaultProps: {
+        textHaloBlurGamma: number;
+        textHaloBlurCapped: boolean;
+    };
+    getShaders(this: Layer<TextHaloBlurExtensionProps>): {
+        modules?: undefined;
+        inject?: undefined;
+    } | {
+        modules: {
+            readonly name: "textHaloBlur";
+            readonly fs: "layout(std140) uniform textHaloBlurUniforms {\n  float gamma;\n  float capped;\n} textHaloBlur;\n";
+            readonly uniformTypes: {
+                readonly gamma: "f32";
+                readonly capped: "f32";
+            };
+        }[];
+        inject: {
+            "alpha = inBorder;": string;
+        };
+    };
+    draw(this: Layer<TextHaloBlurExtensionProps>): void;
+}
+export {};