@sakuzu/maplibre-gl-draw 1.0.0

package/dist/extension/feature-handler.d.ts

@@ -0,0 +1,182 @@
+/**
+ * The feature handler contract of an extension
+ *
+ * The shape an extension implements to add a custom feature type: its renderer, its hit
+ * testing, its box selection, its bounding boxes, its resize and its snapping candidates, all
+ * registered at once with `registerFeatureHandler`. It is types only and sits low in the layer
+ * order, so the view, snapping and operations layers read it without reaching up into api.
+ */
+import type { BoxSelectionStrategy } from '../dispatcher/hit-test/box-strategy.js';
+import type { HitTestStrategy } from '../dispatcher/hit-test/strategies/index.js';
+import type { ResizeState } from '../operations/resize.js';
+import type { HandleType } from '../shared/config/constants.js';
+import type { BoundingBox, Coordinate, Feature } from '../shared/types/model.js';
+import type { BoundingBoxCoords } from '../shared/types/selection-box.js';
+import type { SnapCandidate, SnapProviderContext } from '../snapping/types.js';
+import type { HandleInfo } from '../view/ui/handles.js';
+import type { PointFrameExtent } from '../view/ui/selection-ui/index.js';
+import type { CustomFeatureRenderer } from './renderers.js';
+/**
+ * Custom resize result
+ *
+ * The result of the resize computation for a custom feature.
+ * Used when processing different from the standard resize (changing scale) is needed.
+ */
+export interface CustomResizeResult {
+    /** The new coordinates */
+    coordinates: Coordinate;
+    /** The new width (in pixels, optional) */
+    width?: number;
+    /** The new height (in pixels, optional) */
+    height?: number;
+}
+/**
+ * The type of a custom resize computation function
+ */
+export type CustomResizeCalculator = (handle: HandleType, state: ResizeState, currentLngLat: {
+    lng: number;
+    lat: number;
+}, feature: Feature) => CustomResizeResult | null;
+/**
+ * A custom feature type: how its features are drawn, hit, selected, resized and snapped to
+ *
+ * Register it with `draw.registerFeatureHandler(handler)`, usually from `onInstall` of a
+ * {@link Plugin}. The registration belongs to that draw instance, and the returned function
+ * removes it. Features of the type are ordinary features in the Store (`type` is the name of
+ * the handler), so they are saved, exported, grouped and stacked like the built-in types;
+ * GeoJSON export writes the type in `maplibre-gl-draw:featureType` so that it comes back.
+ *
+ * `type`, `renderer` and `hitTest` are required. The rest have fallbacks: box selection and
+ * the bounding box use the coordinates, and without `getSelectionBoundingBox` no selection UI
+ * is drawn.
+ *
+ * @example
+ * ```ts
+ * import type { CustomFeatureHandler, Feature } from '@sakuzu/maplibre-gl-draw';
+ *
+ * // A "marker" type: one coordinate, drawn as a square, hit within the tolerance
+ * const distanceTo = (feature: Feature, [lng, lat]: [number, number]) => {
+ *   const [x, y] = feature.coordinates as [number, number];
+ *   return Math.hypot(x - lng, y - lat);
+ * };
+ *
+ * const markerHandler: CustomFeatureHandler = {
+ *   type: 'marker',
+ *   renderer: markerRenderer, // see CustomFeatureRenderer
+ *   hitTest: {
+ *     geometryType: 'marker',
+ *     test: (feature, coordinate, tolerance) => distanceTo(feature, coordinate) <= tolerance,
+ *     distance: (feature, coordinate) => distanceTo(feature, coordinate),
+ *   },
+ * };
+ *
+ * const unregister = draw.registerFeatureHandler(markerHandler);
+ * draw.addFeature({ type: 'marker', coordinates: [139.767, 35.681] });
+ * ```
+ */
+export interface CustomFeatureHandler {
+    /** The feature type name */
+    readonly type: string;
+    /** The custom renderer */
+    readonly renderer: CustomFeatureRenderer;
+    /** The custom hit testing strategy */
+    readonly hitTest: HitTestStrategy;
+    /** The custom box selection strategy (when omitted, a coordinate-based fallback is used) */
+    readonly boxSelection?: BoxSelectionStrategy;
+    /**
+     * The resize strategy (applied when computeCustomResize returns null)
+     * - 'scale': changes the scale property (as an Image does)
+     * - 'coordinates': changes the coordinates directly (the same as Polygon and LineString)
+     * - when omitted: a generic check (decided by the presence of the scale property)
+     */
+    readonly resizeStrategy?: 'scale' | 'coordinates';
+    /**
+     * Bounding box computation
+     *
+     * Used for viewport filtering in SpatialIndex.
+     * When omitted, a simple bounding box is computed from the coordinates.
+     *
+     * @param feature The target feature
+     * @param tileSize The tile size (512 by default)
+     */
+    getBoundingBox?(feature: Feature, tileSize: number): BoundingBox;
+    /**
+     * The additional reach for narrowing down candidates (in CSS pixels)
+     *
+     * The first stage of hit testing narrows down candidates with a radius equivalent to
+     * clickTolerance, so when the hitTest strategy of this type treats a wider area as a hit
+     * (icons and the like), the candidate is dropped before the precise test is reached.
+     * Registering "how far from the center a hit can occur" here widens the candidate search
+     * radius by that much.
+     *
+     * The test itself is still decided by the hitTest strategy as before (only the number of
+     * candidates increases slightly). A value that changes with zoom or with settings is
+     * registered as a function (it is evaluated on every query).
+     */
+    readonly candidateReachPx?: number | (() => number);
+    /**
+     * The half width and half height of the selection box of a zero-area point (in CSS pixels)
+     *
+     * A point keeps its zero area and is treated with the "point appearance" (box only, no resize
+     * or rotation handles, move inside the box). This function only decides the dimensions of that
+     * box (the special treatment of zero area itself does not change).
+     *
+     * When it is omitted, or returns null, the default 12px square is used.
+     *
+     * @param feature The target feature
+     */
+    getPointFrameExtent?(feature: Feature): PointFrameExtent | null;
+    /**
+     * Bounding box computation for the selection UI
+     *
+     * Used for the visual feedback of the selected state (bounding box, handles).
+     * Returns an OBB (Oriented Bounding Box) that takes rotation into account.
+     * When omitted, no selection UI is drawn.
+     *
+     * @param feature The target feature
+     * @param tileSize The tile size (512 by default)
+     */
+    getSelectionBoundingBox?(feature: Feature, tileSize: number): BoundingBoxCoords;
+    /**
+     * Returns additional resize handles
+     *
+     * Returns the handles to display in addition to the standard four corner handles.
+     * When omitted, only the four corner handles are shown.
+     * Called only for a single selection.
+     *
+     * @param feature The target feature
+     * @param bbox The bounding box for the selection UI
+     */
+    getAdditionalResizeHandles?(feature: Feature, bbox: BoundingBoxCoords): HandleInfo[];
+    /**
+     * Custom resize computation
+     *
+     * Provides custom resize logic such as edge-midpoint handles.
+     * Returning null applies the standard resize (changing scale).
+     *
+     * @param handle The type of the handle being operated
+     * @param state The state of the resize operation
+     * @param currentLngLat The current mouse coordinate
+     * @param feature The target feature
+     */
+    computeCustomResize?(handle: HandleType, state: ResizeState, currentLngLat: {
+        lng: number;
+        lat: number;
+    }, feature: Feature): CustomResizeResult | null;
+    /**
+     * Returns the snapping candidates
+     *
+     * An extension point that lets a custom type provide its own vertices and edges as snapping
+     * targets. The built-in vertex provider calls this when there is a registration for the type
+     * of the target feature (when it is called, the standard enumeration of the vertices and edges
+     * of that feature is not performed).
+     *
+     * The returned candidates may be either point candidates that have a coordinate
+     * (kind: 'vertex' and the like) or segment candidates that have two endpoints (kind: 'edge').
+     * The nearest point on a segment candidate is computed by SnapService.
+     *
+     * @param feature The target feature
+     * @param ctx The snapping context (includes the cursor position, the tolerance and exclusions)
+     */
+    getSnapTargets?(feature: Feature, ctx: SnapProviderContext): SnapCandidate[];
+}

package/dist/extension/feature-handler.js

@@ -0,0 +1,3 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+export {};

package/dist/extension/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The contracts an extension implements
+ *
+ * The types a plugin, a custom feature type or an overlay implements to plug into the
+ * extension points of a draw instance. The registration itself is on the instance
+ * (`registerFeatureHandler`, `addOverlayRenderer` and so on).
+ */
+export type { CustomFeatureHandler, CustomResizeCalculator, CustomResizeResult, } from './feature-handler.js';
+export type { CustomFeatureRenderer, CustomOverlayRenderer, CustomRendererDrawContext, LayerAwareOverlayRenderer, } from './renderers.js';

package/dist/extension/index.js

@@ -0,0 +1,3 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+export {};

package/dist/extension/renderers.d.ts

@@ -0,0 +1,208 @@
+/**
+ * The renderer contracts of an extension
+ *
+ * The shapes an extension implements to draw with the WebGL context of a draw instance: the
+ * renderer of a custom feature type and the overlay renderers. They are types only and sit low
+ * in the layer order, so the view and snapping layers read them without reaching up into api.
+ */
+import type { Map as MapLibreMap, ProjectionData } from 'maplibre-gl';
+import type { SDFLineRenderer } from '../view/renderers/line/sdf-line.js';
+import type { PointShapeRenderer } from '../view/renderers/point/point-shape.js';
+import type { FillShaderManager } from '../view/renderers/polygon/fill.js';
+import type { TerrainContext } from '../view/terrain/context.js';
+/**
+ * Rendering context for custom renderers
+ *
+ * Provides the shader data and offset information needed when using QuadShader and the like.
+ * It also holds references to the shared renderers, which makes high-quality rendering possible.
+ */
+export interface CustomRendererDrawContext {
+    /** Shader data (vertexShaderPrelude, define, variantName) */
+    shaderData: {
+        vertexShaderPrelude: string;
+        define: string;
+        variantName: string;
+    };
+    /** Viewport center coordinate [lng, lat] */
+    centerLngLat: [number, number];
+    /** The mainMatrix converted into an array */
+    mainMatrixArray: number[];
+    /**
+     * The resolved rendering scale factor (the conversion factor from CSS pixels to device pixels)
+     *
+     * It is the value of `pixelRatio` in Options when one has been injected, and otherwise the
+     * `window.devicePixelRatio` read in that frame. Renderers on the extension side use this
+     * instead of reading `window.devicePixelRatio` directly.
+     */
+    pixelRatio: number;
+    /**
+     * The terrain state of the draw instance being drawn
+     *
+     * A renderer that owns a `ProjectionUniformManager` or a `QuadShader` passes it with
+     * `setTerrain(context.terrain)` before drawing, and the anchor functions (`projectAnchor`,
+     * `anchorElevationMeters`, `anchorGhostOpacity`, `drawQuadSurfaceOnTerrain` and so on) take
+     * it as their first argument. It is valid for this draw call only; a renderer shared between
+     * draw instances must not keep it.
+     */
+    terrain: TerrainContext;
+    /**
+     * The opacity of the layer being drawn, from 0 to 1 (`Layer.opacity`)
+     *
+     * Core multiplies it into everything it draws for the layer, and a renderer multiplies it
+     * into its own alpha, so that what it draws fades with the layer. It is the opacity of the
+     * layer of the feature for a {@link CustomFeatureRenderer} and a feature companion, and 1 for
+     * an overlay (which does not belong to a layer). The shared renderers of this context do not
+     * apply it by themselves. It changes nothing about hit testing: a feature in a layer at
+     * opacity 0 can still be selected.
+     */
+    opacity: number;
+    /** SDF line rendering (high-quality line rendering, anti-aliasing, dashes and so on) */
+    sdfLineRenderer: SDFLineRenderer;
+    /** Polygon fill rendering */
+    fillShaderManager: FillShaderManager;
+    /** Point shape rendering */
+    pointShapeRenderer: PointShapeRenderer;
+}
+/**
+ * Draws the features of a custom feature type with the WebGL context of the map
+ *
+ * It is the `renderer` of a {@link CustomFeatureHandler}. `onAdd` runs when the draw layer is
+ * added to the map (create the WebGL resources there), `draw` runs for each visible feature of
+ * the type in stacking order on every frame, and `onRemove` runs when the layer is removed. The
+ * shared renderers of the context draw lines, fills and point shapes the same way the built-in
+ * types are drawn, terrain included.
+ *
+ * @example
+ * ```ts
+ * import type { CustomFeatureRenderer, PointStyle } from '@sakuzu/maplibre-gl-draw';
+ *
+ * const markerStyle: PointStyle = {
+ *   shape: 'square',
+ *   size: 14,
+ *   fillColor: [0, 0.4, 1, 1],
+ *   fillOpacity: 1,
+ *   strokeColor: [1, 1, 1, 1],
+ *   strokeWidth: 2,
+ *   strokeOpacity: 1,
+ * };
+ *
+ * const markerRenderer: CustomFeatureRenderer = {
+ *   name: 'marker',
+ *   onAdd() {}, // nothing to create: the shared point renderer does the drawing
+ *   draw(feature, _projectionData, zoom, context) {
+ *     const coordinate = feature.coordinates as [number, number];
+ *     // Fade with the layer: the opacity of the layer is multiplied into the alpha
+ *     const style = {
+ *       ...markerStyle,
+ *       fillOpacity: markerStyle.fillOpacity * context.opacity,
+ *       strokeOpacity: markerStyle.strokeOpacity * context.opacity,
+ *     };
+ *     context.pointShapeRenderer.draw(coordinate, style, zoom, feature.id);
+ *   },
+ *   onRemove() {},
+ * };
+ * ```
+ */
+export interface CustomFeatureRenderer {
+    /** Renderer name (for debugging) */
+    readonly name: string;
+    /**
+     * Initializes the WebGL resources
+     */
+    onAdd(gl: WebGL2RenderingContext, map: MapLibreMap): void;
+    /**
+     * Draws a feature
+     *
+     * @param feature The feature to draw
+     * @param projectionData MapLibre's ProjectionData
+     * @param zoom The current zoom level
+     * @param context The rendering context (shader data, offset information, and the opacity of
+     *   the layer of the feature, which the renderer multiplies into its own alpha)
+     */
+    draw(feature: {
+        id: string;
+        type: string;
+        coordinates: unknown;
+        properties: Record<string, unknown>;
+        style?: unknown;
+    }, projectionData: ProjectionData, zoom: number, context: CustomRendererDrawContext): void;
+    /**
+     * Releases the WebGL resources
+     */
+    onRemove(): void;
+}
+/**
+ * Custom renderer
+ *
+ * Responsible for overlay rendering (independent of features).
+ */
+export interface CustomOverlayRenderer {
+    /** Renderer name (for debugging) */
+    readonly name: string;
+    /**
+     * The priority in the draw order
+     * - 'background': drawn behind the features
+     * - 'foreground': drawn in front of the features (behind the selection UI)
+     * - 'overlay': drawn in front of the selection UI
+     */
+    readonly order: 'background' | 'foreground' | 'overlay';
+    /**
+     * Initializes the WebGL resources
+     */
+    onAdd(gl: WebGL2RenderingContext, map: MapLibreMap): void;
+    /**
+     * Draws
+     *
+     * @param projectionData MapLibre's ProjectionData
+     * @param zoom The current zoom level
+     * @param context The rendering context (shared renderers, shader data and so on)
+     */
+    draw(projectionData: ProjectionData, zoom: number, context: CustomRendererDrawContext): void;
+    /**
+     * Releases the WebGL resources
+     */
+    onRemove(): void;
+    /**
+     * Whether the renderer still has work that later frames finish on their own and that will
+     * change what it draws (resources it prepares over several frames, say). Optional: a renderer
+     * without it has none
+     *
+     * `MapLibreGLDraw.hasPendingWork` asks every overlay renderer, so a host that waits for a
+     * complete picture waits for this renderer too. A renderer that returns true requests the
+     * repaints that finish the work itself. With `timeSlicing: false` in the rendering settings,
+     * a renderer should finish in the frame what it would otherwise spread over frames.
+     */
+    hasPendingWork?(): boolean;
+}
+/**
+ * Layer-aware overlay renderer
+ *
+ * An extension of CustomOverlayRenderer that supports rendering per layer.
+ * Used for rendering that follows the layer order, such as Tentative.
+ */
+export interface LayerAwareOverlayRenderer extends CustomOverlayRenderer {
+    /**
+     * Performs the rendering that corresponds to the given layer (lines and fills only)
+     *
+     * Called in the per-layer rendering loop, after the features of each layer have been drawn.
+     * When this method exists, it is used instead of draw().
+     * Vertices are drawn in the foreground, so they are not drawn here.
+     *
+     * @param layerId The ID of the target layer
+     * @param projectionData MapLibre's ProjectionData
+     * @param zoom The current zoom level
+     * @param context The rendering context
+     */
+    drawForLayer(layerId: string, projectionData: ProjectionData, zoom: number, context: CustomRendererDrawContext): void;
+    /**
+     * Draws the vertices in the foreground
+     *
+     * Called after the selection UI, it draws the vertices of all layers in the foreground at once.
+     * This is needed so that the vertices stay visible even while drawing on a layer that is behind.
+     *
+     * @param projectionData MapLibre's ProjectionData
+     * @param zoom The current zoom level
+     * @param context The rendering context
+     */
+    drawVertices?(projectionData: ProjectionData, zoom: number, context: CustomRendererDrawContext): void;
+}

package/dist/extension/renderers.js

@@ -0,0 +1,3 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+export {};

package/dist/geometry/angle.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Coordinate generation from a bearing
+ *
+ * Computes a point from a center, a distance and a bearing on the lng/lat plane. The
+ * snapping guides rely on it. Circles and buffers use the geodesic direct problem
+ * (destinationPoint in distance.ts) instead.
+ *
+ * It is not the geodesic direct problem. The distance is laid out on the lng/lat plane
+ * scaled at the latitude of the center (an equirectangular approximation: the longitude
+ * displacement is divided by cos of the center latitude), so the point drifts from the true
+ * geodesic position as the distance and the latitude grow. Measured with the haversine
+ * distance back to the center, the radius error at latitude 60 degrees is about ±0.05% for
+ * 10 km, ±0.5% (±530 m) for 100 km and -5.6% to +4.9% for 1000 km, and it diverges near
+ * the poles (-20% to +14% for 1 km at latitude 89.99 degrees). Along a bearing of 90 or 270
+ * degrees the point stays on the parallel of the center, which the snapping guides rely on.
+ */
+import type { Coordinate } from './types.js';
+/**
+ * Returns the position at a distance and bearing from a center, laid out on the lng/lat
+ * plane.
+ *
+ * This is a planar approximation, not the geodesic direct problem: the longitude
+ * displacement is divided by `cos(lat)` of the center, so a bearing of 90 or 270 degrees
+ * stays exactly on the parallel of the center. The haversine distance from the center to
+ * the result differs from `radiusMeters` by about ±0.2% at latitude 35 degrees for 100 km
+ * and ±0.5% at latitude 60 degrees for 100 km, and the error diverges near the poles. It is
+ * exact enough at the scale of an edit; where the distance must hold, use
+ * {@link destinationPoint}.
+ *
+ * The longitude of the result is not wrapped into [-180, 180]. No input is rejected: a
+ * center at latitude ±90 degrees gives a non-finite longitude, and non-finite arguments
+ * give non-finite coordinates.
+ *
+ * @param center The center `[lng, lat]` in degrees
+ * @param radiusMeters The distance from the center in meters
+ * @param angleDegrees The bearing in degrees, clockwise with north as 0
+ * @returns The position `[lng, lat]` in degrees
+ *
+ * @example
+ * ```ts
+ * import { getPointAtAngle } from '@sakuzu/maplibre-gl-draw/geometry';
+ *
+ * // 1 km due east of Tokyo Station, on the same parallel
+ * getPointAtAngle([139.767, 35.681], 1000, 90); // [139.77807..., 35.681]
+ * ```
+ */
+export declare function getPointAtAngle(center: Coordinate, radiusMeters: number, angleDegrees: number): Coordinate;

package/dist/geometry/angle.js

@@ -0,0 +1,44 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { EARTH_RADIUS_METERS, toRadians } from './units.js';
+/**
+ * Returns the position at a distance and bearing from a center, laid out on the lng/lat
+ * plane.
+ *
+ * This is a planar approximation, not the geodesic direct problem: the longitude
+ * displacement is divided by `cos(lat)` of the center, so a bearing of 90 or 270 degrees
+ * stays exactly on the parallel of the center. The haversine distance from the center to
+ * the result differs from `radiusMeters` by about ±0.2% at latitude 35 degrees for 100 km
+ * and ±0.5% at latitude 60 degrees for 100 km, and the error diverges near the poles. It is
+ * exact enough at the scale of an edit; where the distance must hold, use
+ * {@link destinationPoint}.
+ *
+ * The longitude of the result is not wrapped into [-180, 180]. No input is rejected: a
+ * center at latitude ±90 degrees gives a non-finite longitude, and non-finite arguments
+ * give non-finite coordinates.
+ *
+ * @param center The center `[lng, lat]` in degrees
+ * @param radiusMeters The distance from the center in meters
+ * @param angleDegrees The bearing in degrees, clockwise with north as 0
+ * @returns The position `[lng, lat]` in degrees
+ *
+ * @example
+ * ```ts
+ * import { getPointAtAngle } from '@sakuzu/maplibre-gl-draw/geometry';
+ *
+ * // 1 km due east of Tokyo Station, on the same parallel
+ * getPointAtAngle([139.767, 35.681], 1000, 90); // [139.77807..., 35.681]
+ * ```
+ */
+export function getPointAtAngle(center, radiusMeters, angleDegrees) {
+    const earthRadius = EARTH_RADIUS_METERS;
+    const [lng, lat] = center;
+    // Convert the angle to radians (clockwise with north as 0)
+    const angleRad = toRadians(angleDegrees);
+    // Compute the latitude displacement (northward is positive)
+    const dLat = (radiusMeters / earthRadius) * Math.cos(angleRad) * (180 / Math.PI);
+    // Compute the longitude displacement (with the correction for latitude)
+    const latRad = toRadians(lat);
+    const dLng = ((radiusMeters / earthRadius) * Math.sin(angleRad) * (180 / Math.PI)) / Math.cos(latRad);
+    return [lng + dLng, lat + dLat];
+}

package/dist/geometry/bbox.d.ts

@@ -0,0 +1,48 @@
+import type { AreaCoordinates, BBox, Coordinate } from './types.js';
+/**
+ * Computes the bounding box of a coordinate sequence.
+ *
+ * A coordinate whose longitude or latitude is not a finite number is skipped. Crossing the
+ * ±180 degree meridian is not handled: the box spans the plain minimum and maximum
+ * longitudes.
+ *
+ * @param coordinates Positions `[lng, lat]` in degrees
+ * @returns `[minLng, minLat, maxLng, maxLat]` in degrees. `null` when there is not a single
+ *   finite coordinate (an empty array included)
+ *
+ * @example
+ * ```ts
+ * import { coordinatesBBox } from '@sakuzu/maplibre-gl-draw/geometry';
+ *
+ * coordinatesBBox([[139.7, 35.6], [139.8, 35.7]]); // [139.7, 35.6, 139.8, 35.7]
+ * coordinatesBBox([]); // null
+ * ```
+ */
+export declare function coordinatesBBox(coordinates: Coordinate[]): BBox | null;
+/**
+ * Computes the bounding box of Polygon or MultiPolygon coordinates.
+ *
+ * Every position of every ring, holes included, is taken into account; a position that is
+ * not finite is skipped.
+ *
+ * @param coordinates Polygon or MultiPolygon coordinates in degrees
+ * @returns `[minLng, minLat, maxLng, maxLat]` in degrees. `null` when there is not a single
+ *   finite coordinate
+ */
+export declare function boundingBox(coordinates: AreaCoordinates): BBox | null;
+/**
+ * Determines whether two bounding boxes overlap, touching included.
+ *
+ * @param a A box `[minLng, minLat, maxLng, maxLat]`
+ * @param b A box `[minLng, minLat, maxLng, maxLat]`
+ * @returns `true` when the boxes share at least one point, an edge or a corner included
+ */
+export declare function bboxIntersects(a: BBox, b: BBox): boolean;
+/**
+ * Determines whether one bounding box contains another, coincident boundaries included.
+ *
+ * @param outer The containing box `[minLng, minLat, maxLng, maxLat]`
+ * @param inner The contained box `[minLng, minLat, maxLng, maxLat]`
+ * @returns `true` when every point of `inner` lies in `outer`. A box contains itself
+ */
+export declare function bboxContains(outer: BBox, inner: BBox): boolean;

package/dist/geometry/bbox.js

@@ -0,0 +1,83 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Bounding box
+ *
+ * Lightweight tests used as the preliminary check of the predicates. Crossing the
+ * ±180 degree meridian is not handled.
+ */
+import { flattenAreaCoordinates, isFiniteCoordinate } from './coords.js';
+/**
+ * Computes the bounding box of a coordinate sequence.
+ *
+ * A coordinate whose longitude or latitude is not a finite number is skipped. Crossing the
+ * ±180 degree meridian is not handled: the box spans the plain minimum and maximum
+ * longitudes.
+ *
+ * @param coordinates Positions `[lng, lat]` in degrees
+ * @returns `[minLng, minLat, maxLng, maxLat]` in degrees. `null` when there is not a single
+ *   finite coordinate (an empty array included)
+ *
+ * @example
+ * ```ts
+ * import { coordinatesBBox } from '@sakuzu/maplibre-gl-draw/geometry';
+ *
+ * coordinatesBBox([[139.7, 35.6], [139.8, 35.7]]); // [139.7, 35.6, 139.8, 35.7]
+ * coordinatesBBox([]); // null
+ * ```
+ */
+export function coordinatesBBox(coordinates) {
+    let found = false;
+    let minLng = Number.POSITIVE_INFINITY;
+    let minLat = Number.POSITIVE_INFINITY;
+    let maxLng = Number.NEGATIVE_INFINITY;
+    let maxLat = Number.NEGATIVE_INFINITY;
+    for (const coordinate of coordinates) {
+        if (!isFiniteCoordinate(coordinate))
+            continue;
+        found = true;
+        const [lng, lat] = coordinate;
+        if (lng < minLng)
+            minLng = lng;
+        if (lat < minLat)
+            minLat = lat;
+        if (lng > maxLng)
+            maxLng = lng;
+        if (lat > maxLat)
+            maxLat = lat;
+    }
+    return found ? [minLng, minLat, maxLng, maxLat] : null;
+}
+/**
+ * Computes the bounding box of Polygon or MultiPolygon coordinates.
+ *
+ * Every position of every ring, holes included, is taken into account; a position that is
+ * not finite is skipped.
+ *
+ * @param coordinates Polygon or MultiPolygon coordinates in degrees
+ * @returns `[minLng, minLat, maxLng, maxLat]` in degrees. `null` when there is not a single
+ *   finite coordinate
+ */
+export function boundingBox(coordinates) {
+    return coordinatesBBox(flattenAreaCoordinates(coordinates));
+}
+/**
+ * Determines whether two bounding boxes overlap, touching included.
+ *
+ * @param a A box `[minLng, minLat, maxLng, maxLat]`
+ * @param b A box `[minLng, minLat, maxLng, maxLat]`
+ * @returns `true` when the boxes share at least one point, an edge or a corner included
+ */
+export function bboxIntersects(a, b) {
+    return !(a[2] < b[0] || b[2] < a[0] || a[3] < b[1] || b[3] < a[1]);
+}
+/**
+ * Determines whether one bounding box contains another, coincident boundaries included.
+ *
+ * @param outer The containing box `[minLng, minLat, maxLng, maxLat]`
+ * @param inner The contained box `[minLng, minLat, maxLng, maxLat]`
+ * @returns `true` when every point of `inner` lies in `outer`. A box contains itself
+ */
+export function bboxContains(outer, inner) {
+    return (outer[0] <= inner[0] && outer[1] <= inner[1] && outer[2] >= inner[2] && outer[3] >= inner[3]);
+}