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

package/dist/types/line-placement.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Label anchors along lines, for `symbol-placement: line` and `line-center`. The placement follows
+ * MapLibre GL JS (`getAnchors`, `getCenterAnchor` and `checkMaxAngle` in its symbol code): labels
+ * repeat every `symbol-spacing` pixels where the line is long enough for them, and a placement is
+ * skipped where the line bends more than `text-max-angle` within the label.
+ *
+ * Lines are given in pixels, with y pointing down. An anchor is returned as the segment it lies
+ * on and its position along that segment, so the caller can interpolate the anchor in its own
+ * coordinates.
+ */
+/** An anchor on a line: `t` along the segment from `line[segment]` to `line[segment + 1]`. */
+export type LineAnchor = {
+    segment: number;
+    t: number;
+    /** The direction of the segment, in degrees counter-clockwise from the +x axis on screen. */
+    angle: number;
+};
+export type LineAnchorOptions = {
+    /** `line` repeats labels along the line; `line-center` places one at its middle. */
+    placement: 'line' | 'line-center';
+    /** `symbol-spacing`: pixels between two labels of a line. */
+    spacing: number;
+    /** `text-max-angle`: the largest bend, in degrees, within any window of the label. */
+    maxAngle: number;
+    /** The label's length along the line, in pixels. */
+    labelLength: number;
+    /** `text-size` in pixels; the bend window is 3/5 of it, as in MapLibre. */
+    textSize: number;
+    /**
+     * Whether the symbol has text. As in MapLibre, a symbol with only an icon has no bend window:
+     * the line may bend any amount under it. With `line` placement it must still fit on the line.
+     * Default: true.
+     */
+    hasText?: boolean;
+    /**
+     * Whether the line continues in a neighbouring tile. MapLibre then starts the first label half
+     * a spacing in, so labels line up across tile edges, and does not fall back to the middle.
+     */
+    isContinued: boolean;
+    /**
+     * Work the placement may spend, in steps along the line and vertices checked for bends. It is
+     * drawn down as the placement runs; once it is spent, no further anchors are placed. Tile
+     * geometry is untrusted, so callers share one budget across a tile.
+     */
+    budget?: LineAnchorBudget;
+};
+/** Remaining placement work; see `LineAnchorOptions.budget`. */
+export type LineAnchorBudget = {
+    steps: number;
+};
+/** Work one feature's line labels may spend, unless the tile's budget has less left. */
+export declare const DEFAULT_LINE_ANCHOR_STEPS = 100000;
+/**
+ * The least distance, in pixels, between two labels of a line beyond the label's own length. It
+ * only matters for a `symbol-spacing` far below any label's length: with a spacing of 1, a short
+ * or empty label would otherwise be placed at every pixel of the line.
+ */
+export declare const MIN_LABEL_GAP = 16;
+/**
+ * Label anchors along a line in pixels. `line` repeats labels every `spacing` pixels, starting
+ * where MapLibre starts them; `line-center` places one at the middle of the line by length. Either
+ * skips a placement where the label does not fit on the line or where the line bends more than
+ * `maxAngle` within the label.
+ */
+export declare function getLineAnchors(line: number[][], options: LineAnchorOptions): LineAnchor[];
+/** A line to merge: its label text, or none, and its vertices. */
+export type MergeableLine = {
+    text: string | null | undefined;
+    line: number[][];
+};
+/**
+ * Joins lines with the same label text whose ends meet exactly, as MapLibre GL JS's `mergeLines`
+ * does before it places labels along lines. Vector tiles split a street or river into many short
+ * features (one per block, bridge or name change), and a label longer than each piece fits on
+ * none of them; MapLibre places it on the joined line.
+ *
+ * Returns one entry per input line: the joined line at the line that started each chain (whose
+ * feature the labels belong to, as in MapLibre), `null` for a line merged into a chain started by
+ * another, and the line unchanged when nothing joins it. Lines without text or vertices are
+ * never merged. The work is linear in the number of vertices.
+ */
+export declare function mergeLines(lines: MergeableLine[]): (number[][] | null)[];
+/**
+ * The angle at which a label along a line is drawn: the line's direction, turned by 180 degrees
+ * when `keepUpright` is set and the text would otherwise read upside down on a map rotated by
+ * `bearing` degrees.
+ */
+export declare function getUprightAngle(angle: number, bearing: number, keepUpright: boolean): number;
+/**
+ * The parts of `line` inside `[minX, minY, maxX, maxY]`, clipped segment by segment
+ * (Liang-Barsky). A line that leaves the box and comes back gives one part per stay inside.
+ */
+export declare function clipLine(line: number[][], box: number[]): number[][][];

package/dist/types/map-style-loader.d.ts

@@ -0,0 +1,48 @@
+import type { LoaderContext, LoaderOptions } from '@loaders.gl/loader-utils';
+import type { BasemapLoadOptions, ResolvedBasemapStyle } from "./style-resolver.js";
+/** Namespaced loaders.gl options for {@link MapStyleLoader}. */
+export type MapStyleLoaderOptions = LoaderOptions & {
+    mapStyle?: NonNullable<BasemapLoadOptions>;
+};
+/** loaders.gl-compatible loader that resolves and validates map-style documents. */
+export declare const MapStyleLoader: {
+    readonly dataType: ResolvedBasemapStyle;
+    readonly batchType: never;
+    readonly name: "Map Style";
+    readonly id: "map-style";
+    readonly module: "basemap-layers";
+    readonly version: string;
+    readonly worker: false;
+    readonly extensions: ["json"];
+    readonly mimeTypes: ["application/json", "application/vnd.mapbox.style+json"];
+    readonly text: true;
+    readonly options: {
+        readonly mapStyle: {};
+    };
+    readonly parse: (data: ArrayBuffer | string, options?: MapStyleLoaderOptions, context?: LoaderContext) => Promise<{
+        [x: string]: unknown;
+        sources: Record<string, {
+            [x: string]: unknown;
+            type?: string | undefined;
+            url?: string | undefined;
+            tiles?: string[] | undefined;
+            minzoom?: number | undefined;
+            maxzoom?: number | undefined;
+            tileSize?: number | undefined;
+        }>;
+        layers: {
+            [x: string]: unknown;
+            id: string;
+            type: string;
+            source?: string | undefined;
+            'source-layer'?: string | undefined;
+            minzoom?: number | undefined;
+            maxzoom?: number | undefined;
+            filter?: unknown[] | undefined;
+            paint?: Record<string, unknown> | undefined;
+            layout?: Record<string, unknown> | undefined;
+        }[];
+        version?: number | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }>;
+};

package/dist/types/map-style-schema.d.ts

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+/** Zod schema for a basemap source entry. */
+export declare const BasemapSourceSchema: z.ZodObject<{
+    type: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    tiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    minzoom: z.ZodOptional<z.ZodNumber>;
+    maxzoom: z.ZodOptional<z.ZodNumber>;
+    tileSize: z.ZodOptional<z.ZodNumber>;
+}, z.core.$catchall<z.ZodUnknown>>;
+/** Zod schema for a basemap style layer entry. */
+export declare const BasemapStyleLayerSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodOptional<z.ZodString>;
+    ref: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodString>;
+    'source-layer': z.ZodOptional<z.ZodString>;
+    minzoom: z.ZodOptional<z.ZodNumber>;
+    maxzoom: z.ZodOptional<z.ZodNumber>;
+    filter: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    paint: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    layout: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$catchall<z.ZodUnknown>>;
+/** Zod schema for a MapLibre / Mapbox style document. */
+export declare const BasemapStyleSchema: z.ZodObject<{
+    version: z.ZodOptional<z.ZodNumber>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    sources: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        tiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        minzoom: z.ZodOptional<z.ZodNumber>;
+        maxzoom: z.ZodOptional<z.ZodNumber>;
+        tileSize: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$catchall<z.ZodUnknown>>>>;
+    layers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodOptional<z.ZodString>;
+        ref: z.ZodOptional<z.ZodString>;
+        source: z.ZodOptional<z.ZodString>;
+        'source-layer': z.ZodOptional<z.ZodString>;
+        minzoom: z.ZodOptional<z.ZodNumber>;
+        maxzoom: z.ZodOptional<z.ZodNumber>;
+        filter: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+        paint: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        layout: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$catchall<z.ZodUnknown>>>>;
+}, z.core.$catchall<z.ZodUnknown>>;
+/** Zod schema for a fully resolved basemap style document. */
+export declare const ResolvedBasemapStyleSchema: z.ZodObject<{
+    version: z.ZodOptional<z.ZodNumber>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    sources: z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        tiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        minzoom: z.ZodOptional<z.ZodNumber>;
+        maxzoom: z.ZodOptional<z.ZodNumber>;
+        tileSize: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$catchall<z.ZodUnknown>>>;
+    layers: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        source: z.ZodOptional<z.ZodString>;
+        'source-layer': z.ZodOptional<z.ZodString>;
+        minzoom: z.ZodOptional<z.ZodNumber>;
+        maxzoom: z.ZodOptional<z.ZodNumber>;
+        filter: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+        paint: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        layout: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$catchall<z.ZodUnknown>>>;
+}, z.core.$catchall<z.ZodUnknown>>;

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

@@ -0,0 +1,6 @@
+/** Map-style helpers exported from `@deck.gl-community/basemap-layers/map-style`. */
+export { filterFeatures, findFeaturesStyledByLayer, parseProperties } from "./mapbox-style.js";
+export { BasemapSourceSchema, BasemapStyleLayerSchema, BasemapStyleSchema, ResolvedBasemapStyleSchema } from "./map-style-schema.js";
+export { MapStyleLoader } from "./map-style-loader.js";
+export type { MapStyleLoaderOptions } from "./map-style-loader.js";
+export { resolveBasemapStyle, type BasemapLoadOptions, type BasemapSource, type BasemapStyle, type BasemapStyleLayer, type ResolvedBasemapStyleLayer, type ResolvedBasemapStyle } from "./style-resolver.js";

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

@@ -0,0 +1,40 @@
+type GlobalProperties = {
+    zoom?: number;
+    [key: string]: unknown;
+};
+type GeometryLike = {
+    type: string;
+};
+type FeatureLike = {
+    type?: number | string;
+    geometry?: GeometryLike;
+    properties?: Record<string, unknown>;
+};
+type FilterFeaturesOptions = {
+    features: FeatureLike[];
+    filter: unknown[];
+    globalProperties?: GlobalProperties;
+};
+type FindFeaturesStyledByLayerOptions = {
+    features: Record<string, Record<string, FeatureLike[]>>;
+    layer: {
+        source?: string;
+        'source-layer'?: string;
+        filter?: unknown[];
+    };
+    globalProperties?: GlobalProperties;
+};
+/**
+ * Applies a Mapbox style-spec filter expression to a set of features.
+ */
+export declare function filterFeatures({ features, filter, globalProperties }: FilterFeaturesOptions): FeatureLike[];
+/**
+ * Finds the source-layer features that participate in a particular style layer
+ * and applies the layer's filter expression when present.
+ */
+export declare function findFeaturesStyledByLayer({ features, layer, globalProperties }: FindFeaturesStyledByLayerOptions): FeatureLike[];
+/**
+ * Evaluates paint properties for a style layer at the requested zoom.
+ */
+export declare function parseProperties(layer: Record<string, any>, globalProperties: GlobalProperties): Array<Record<string, unknown>>;
+export { colorToArray } from "./style-expression.js";