@sakuzu/maplibre-gl-draw 1.0.0

package/dist/shared/math/angle.js

@@ -0,0 +1,34 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { toRadians } from './distance.js';
+// The actual generation of a coordinate from a bearing lives in the geometry module (single
+// implementation)
+export { getPointAtAngle } from '../../geometry/index.js';
+/**
+ * Computes the angle between two points (the bearing as seen from the center)
+ *
+ * The planar inverse of {@link getPointAtAngle}: the longitude difference is scaled by cos of
+ * the center latitude. It is not the great-circle bearing, so a point placed with
+ * destinationPoint (circles, buffers and the radius handle) must take its bearing from
+ * initialBearingDegrees in the geometry module instead.
+ *
+ * @param center Center coordinate
+ * @param point Coordinate of the target point
+ * @returns Angle (degrees, clockwise with north as 0, 0-360)
+ */
+export function getAngleFromCenter(center, point) {
+    const [lng1, lat1] = center;
+    const [lng2, lat2] = point;
+    // Latitude correction
+    const latRad = toRadians(lat1);
+    const dLng = (lng2 - lng1) * Math.cos(latRad);
+    const dLat = lat2 - lat1;
+    // Compute the angle with atan2 (clockwise with north as 0 degrees)
+    // atan2 takes east as positive, so convert it to be based on north
+    let angle = Math.atan2(dLng, dLat) * (180 / Math.PI);
+    // Normalize into the range 0-360
+    if (angle < 0) {
+        angle += 360;
+    }
+    return angle;
+}

package/dist/shared/math/circle.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Circle rendering utilities
+ *
+ * Functions for rendering a circle by approximating it with a polygon (64 vertices).
+ */
+export { generateCirclePolygon } from '../../geometry/index.js';

package/dist/shared/math/circle.js

@@ -0,0 +1,10 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Circle rendering utilities
+ *
+ * Functions for rendering a circle by approximating it with a polygon (64 vertices).
+ */
+// The actual generation of a geodesic circle lives in the geometry module (single
+// implementation)
+export { generateCirclePolygon } from '../../geometry/index.js';

package/dist/shared/math/constants.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Geographic and rendering constants
+ *
+ * Earth-related constants, rendering parameters, and default style values.
+ */
+/**
+ * Earth-related constants
+ */
+export declare const EARTH: {
+    /** Circumference of the Earth (meters) */
+    readonly CIRCUMFERENCE_METERS: 40075016.686;
+    /** Number of meters per degree */
+    readonly METERS_PER_DEGREE: number;
+    /** Factor that converts radians to degrees */
+    readonly DEGREES_PER_RADIAN: number;
+    /** Factor that converts degrees to radians */
+    readonly RADIANS_PER_DEGREE: number;
+};
+/**
+ * Default tile size
+ */
+export declare const DEFAULT_TILE_SIZE = 512;
+/**
+ * Default rendering parameters
+ */
+export declare const RENDERING_DEFAULTS: {
+    /** Number of segments of a circle */
+    readonly CIRCLE_SEGMENTS: 32;
+    /** Miter limit (handling of line corners) */
+    readonly MITER_LIMIT: 4;
+    /** Viewport expansion factor */
+    readonly VIEWPORT_EXPANSION_FACTOR: 0.2;
+};
+/**
+ * Presets of dash patterns
+ */
+export declare const DASH_PATTERNS: {
+    /** Dashed pattern: 10px dash, 5px gap */
+    readonly DASHED: readonly [number, number];
+    /** Dotted pattern: 2px dot, 4px gap */
+    readonly DOTTED: readonly [number, number];
+    /** Solid line (empty array) */
+    readonly SOLID: readonly number[];
+};
+/**
+ * Gets the dash pattern from a LineStyle
+ */
+export declare function getDashPattern(lineStyle: 'solid' | 'dashed' | 'dotted'): readonly number[];

package/dist/shared/math/constants.js

@@ -0,0 +1,59 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Geographic and rendering constants
+ *
+ * Earth-related constants, rendering parameters, and default style values.
+ */
+/**
+ * Earth-related constants
+ */
+export const EARTH = {
+    /** Circumference of the Earth (meters) */
+    CIRCUMFERENCE_METERS: 40075016.686,
+    /** Number of meters per degree */
+    METERS_PER_DEGREE: 40075016.686 / 360,
+    /** Factor that converts radians to degrees */
+    DEGREES_PER_RADIAN: 180 / Math.PI,
+    /** Factor that converts degrees to radians */
+    RADIANS_PER_DEGREE: Math.PI / 180,
+};
+/**
+ * Default tile size
+ */
+export const DEFAULT_TILE_SIZE = 512;
+/**
+ * Default rendering parameters
+ */
+export const RENDERING_DEFAULTS = {
+    /** Number of segments of a circle */
+    CIRCLE_SEGMENTS: 32,
+    /** Miter limit (handling of line corners) */
+    MITER_LIMIT: 4.0,
+    /** Viewport expansion factor */
+    VIEWPORT_EXPANSION_FACTOR: 0.2,
+};
+/**
+ * Presets of dash patterns
+ */
+export const DASH_PATTERNS = {
+    /** Dashed pattern: 10px dash, 5px gap */
+    DASHED: [10, 5],
+    /** Dotted pattern: 2px dot, 4px gap */
+    DOTTED: [2, 4],
+    /** Solid line (empty array) */
+    SOLID: [],
+};
+/**
+ * Gets the dash pattern from a LineStyle
+ */
+export function getDashPattern(lineStyle) {
+    switch (lineStyle) {
+        case 'dashed':
+            return [10, 5];
+        case 'dotted':
+            return [2, 4];
+        default:
+            return [];
+    }
+}

package/dist/shared/math/distance.d.ts

@@ -0,0 +1,78 @@
+import type { Coordinate } from '../types/model.js';
+export { haversineDistanceMeters, toDegrees, toRadians } from '../../geometry/index.js';
+/**
+ * Distance between two points (a simple version that returns a distance in degrees from
+ * coordinates in degrees)
+ *
+ * For approximate computation at small scales. Use haversineDistanceMeters when an accurate
+ * distance is required.
+ */
+export declare function euclideanDistance(coord1: Coordinate, coord2: Coordinate): number;
+/**
+ * Computes the midpoint of two points
+ */
+export declare function midpoint(coord1: Coordinate, coord2: Coordinate): Coordinate;
+/**
+ * Conversion from meters to a longitude difference (latitude dependent)
+ */
+export declare function metersToLng(meters: number, latitude: number): number;
+/**
+ * Conversion from meters to a latitude difference
+ */
+export declare function metersToLat(meters: number): number;
+/**
+ * Conversion from a longitude difference to meters
+ */
+export declare function lngToMeters(lngDiff: number, latitude: number): number;
+/**
+ * Computes the shortest distance from a point to a segment
+ */
+export declare function pointToSegmentDistance(point: Coordinate, segmentStart: Coordinate, segmentEnd: Coordinate): number;
+/**
+ * Computes the shortest distance from a point to a polyline (a sequence of segments)
+ */
+export declare function pointToPolylineDistance(point: Coordinate, line: Coordinate[]): number;
+/**
+ * Computes the number of meters per pixel at a zoom level
+ *
+ * @param latitude - Latitude (degrees)
+ * @param zoom - Zoom level
+ * @param tileSize - Tile size (default: 512)
+ * @returns Number of meters per pixel
+ */
+export declare function getMetersPerPixel(latitude: number, zoom: number, tileSize?: number): number;
+/**
+ * Converts meters to degrees in the longitude direction
+ *
+ * @param meters - Number of meters
+ * @param latitude - Latitude (degrees)
+ * @returns Number of degrees in the longitude direction
+ */
+export declare function metersToDegreesLng(meters: number, latitude: number): number;
+/**
+ * Converts meters to degrees in the latitude direction
+ *
+ * @param meters - Number of meters
+ * @returns Number of degrees in the latitude direction
+ */
+export declare function metersToDegreesLat(meters: number): number;
+/**
+ * Converts pixels to degrees in the longitude direction
+ *
+ * @param pixels - Number of pixels
+ * @param latitude - Latitude (degrees)
+ * @param zoom - Zoom level
+ * @param tileSize - Tile size (default: 512)
+ * @returns Number of degrees in the longitude direction
+ */
+export declare function pixelsToDegreesLng(pixels: number, latitude: number, zoom: number, tileSize?: number): number;
+/**
+ * Converts pixels to degrees in the latitude direction
+ *
+ * @param pixels - Number of pixels
+ * @param latitude - Latitude (degrees) - used for the latitude correction
+ * @param zoom - Zoom level
+ * @param tileSize - Tile size (default: 512)
+ * @returns Number of degrees in the latitude direction
+ */
+export declare function pixelsToDegreesLat(pixels: number, latitude: number, zoom: number, tileSize?: number): number;

package/dist/shared/math/distance.js

@@ -0,0 +1,147 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Distance computation utilities
+ */
+import { toRadians } from '../../geometry/index.js';
+import { DEFAULT_TILE_SIZE, EARTH } from './constants.js';
+// The actual angle conversion and geodesic distance live in the geometry module (single
+// implementation)
+export { haversineDistanceMeters, toDegrees, toRadians } from '../../geometry/index.js';
+/**
+ * Distance between two points (a simple version that returns a distance in degrees from
+ * coordinates in degrees)
+ *
+ * For approximate computation at small scales. Use haversineDistanceMeters when an accurate
+ * distance is required.
+ */
+export function euclideanDistance(coord1, coord2) {
+    const [lng1, lat1] = coord1;
+    const [lng2, lat2] = coord2;
+    const dLng = lng2 - lng1;
+    const dLat = lat2 - lat1;
+    return Math.sqrt(dLng * dLng + dLat * dLat);
+}
+/**
+ * Computes the midpoint of two points
+ */
+export function midpoint(coord1, coord2) {
+    return [(coord1[0] + coord2[0]) / 2, (coord1[1] + coord2[1]) / 2];
+}
+/**
+ * Conversion from meters to a longitude difference (latitude dependent)
+ */
+export function metersToLng(meters, latitude) {
+    const earthRadius = 6371000;
+    const latRad = toRadians(latitude);
+    return (meters / (earthRadius * Math.cos(latRad))) * (180 / Math.PI);
+}
+/**
+ * Conversion from meters to a latitude difference
+ */
+export function metersToLat(meters) {
+    const earthRadius = 6371000;
+    return (meters / earthRadius) * (180 / Math.PI);
+}
+/**
+ * Conversion from a longitude difference to meters
+ */
+export function lngToMeters(lngDiff, latitude) {
+    const earthRadius = 6371000;
+    const latRad = toRadians(latitude);
+    return lngDiff * (Math.PI / 180) * earthRadius * Math.cos(latRad);
+}
+/**
+ * Computes the shortest distance from a point to a segment
+ */
+export function pointToSegmentDistance(point, segmentStart, segmentEnd) {
+    const [px, py] = point;
+    const [ax, ay] = segmentStart;
+    const [bx, by] = segmentEnd;
+    const dx = bx - ax;
+    const dy = by - ay;
+    const lengthSquared = dx * dx + dy * dy;
+    if (lengthSquared === 0) {
+        // When the segment is a point
+        return euclideanDistance(point, segmentStart);
+    }
+    // Compute the parameter t (the position of the closest point on the segment)
+    let t = ((px - ax) * dx + (py - ay) * dy) / lengthSquared;
+    t = Math.max(0, Math.min(1, t));
+    // Coordinate of the closest point
+    const closestPoint = [ax + t * dx, ay + t * dy];
+    return euclideanDistance(point, closestPoint);
+}
+/**
+ * Computes the shortest distance from a point to a polyline (a sequence of segments)
+ */
+export function pointToPolylineDistance(point, line) {
+    let minDistance = Number.POSITIVE_INFINITY;
+    for (let i = 0; i < line.length - 1; i++) {
+        const distance = pointToSegmentDistance(point, line[i], line[i + 1]);
+        minDistance = Math.min(minDistance, distance);
+    }
+    return minDistance;
+}
+/**
+ * Computes the number of meters per pixel at a zoom level
+ *
+ * @param latitude - Latitude (degrees)
+ * @param zoom - Zoom level
+ * @param tileSize - Tile size (default: 512)
+ * @returns Number of meters per pixel
+ */
+export function getMetersPerPixel(latitude, zoom, tileSize = DEFAULT_TILE_SIZE) {
+    const latRad = latitude * EARTH.RADIANS_PER_DEGREE;
+    return (EARTH.CIRCUMFERENCE_METERS * Math.cos(latRad)) / (tileSize * 2 ** zoom);
+}
+/**
+ * Converts meters to degrees in the longitude direction
+ *
+ * @param meters - Number of meters
+ * @param latitude - Latitude (degrees)
+ * @returns Number of degrees in the longitude direction
+ */
+export function metersToDegreesLng(meters, latitude) {
+    const latRad = latitude * EARTH.RADIANS_PER_DEGREE;
+    return meters / (EARTH.METERS_PER_DEGREE * Math.cos(latRad));
+}
+/**
+ * Converts meters to degrees in the latitude direction
+ *
+ * @param meters - Number of meters
+ * @returns Number of degrees in the latitude direction
+ */
+export function metersToDegreesLat(meters) {
+    return meters / EARTH.METERS_PER_DEGREE;
+}
+/**
+ * Converts pixels to degrees in the longitude direction
+ *
+ * @param pixels - Number of pixels
+ * @param latitude - Latitude (degrees)
+ * @param zoom - Zoom level
+ * @param tileSize - Tile size (default: 512)
+ * @returns Number of degrees in the longitude direction
+ */
+export function pixelsToDegreesLng(pixels, latitude, zoom, tileSize = DEFAULT_TILE_SIZE) {
+    const latRad = latitude * EARTH.RADIANS_PER_DEGREE;
+    const metersPerPixel = (EARTH.CIRCUMFERENCE_METERS * Math.cos(latRad)) / (tileSize * 2 ** zoom);
+    const meters = pixels * metersPerPixel;
+    return meters / (EARTH.METERS_PER_DEGREE * Math.cos(latRad));
+}
+/**
+ * Converts pixels to degrees in the latitude direction
+ *
+ * @param pixels - Number of pixels
+ * @param latitude - Latitude (degrees) - used for the latitude correction
+ * @param zoom - Zoom level
+ * @param tileSize - Tile size (default: 512)
+ * @returns Number of degrees in the latitude direction
+ */
+export function pixelsToDegreesLat(pixels, latitude, zoom, tileSize = DEFAULT_TILE_SIZE) {
+    const latRad = latitude * EARTH.RADIANS_PER_DEGREE;
+    const metersPerPixel = (EARTH.CIRCUMFERENCE_METERS * Math.cos(latRad)) / (tileSize * 2 ** zoom);
+    const meters = pixels * metersPerPixel;
+    return meters / EARTH.METERS_PER_DEGREE;
+}

package/dist/shared/math/globe-subdivision.d.ts

@@ -0,0 +1,62 @@
+/**
+ * The path of an edge on the globe
+ *
+ * maplibre draws its own layers on the globe the way they look on the Mercator plane: an edge
+ * between two vertices is the straight line of the Web Mercator plane, carried onto the sphere
+ * (a parallel stays a parallel, a meridian a meridian). It gets there by cutting the geometry
+ * finely on the plane before projecting it (its subdivision, `SubdivisionGranularitySetting`).
+ * Projecting only the two vertices of an edge would join them with a chord through the sphere.
+ *
+ * These are the pure parts of doing the same: how finely to cut at a zoom, and the cut itself.
+ * The rendering cuts the drawn geometry with them, and hit testing cuts the tested geometry the
+ * same way, so what is drawn and what can be clicked follow the same path.
+ */
+import type { Coordinate } from '../types/model.js';
+/** What is being cut: the fills (and their outlines) or the lines */
+export type GlobeSubdivisionKind = 'fill' | 'line';
+/**
+ * The side of a subdivision cell on the globe, in Mercator world units (1 = the world)
+ *
+ * The tile zoom is the integer part of the zoom, as maplibre picks the tiles it cuts. A cell
+ * is the world divided by the base granularity up to the zoom where a tile reaches its least
+ * granularity, and half a tile (fills) or a tile (lines) beyond. It changes only when the zoom
+ * crosses an integer, so what is cut for it stays valid while zooming within a level.
+ *
+ * @param zoom The zoom of the map
+ * @param kind Fills or lines
+ * @returns The side of a cell (a power of two fraction of the world)
+ */
+export declare function globeSubdivisionGrid(zoom: number, kind: GlobeSubdivisionKind): number;
+/**
+ * The point at `t` along the straight line of the Mercator plane from `a` to `b`
+ *
+ * The longitude moves linearly; the latitude moves linearly in Mercator y, not in degrees.
+ * Latitudes beyond the Mercator limit are clamped to it.
+ */
+export declare function mercatorLerp(a: Coordinate, b: Coordinate, t: number): Coordinate;
+/**
+ * The midpoint of an edge as drawn: halfway across in longitude, on the edge
+ *
+ * An edge is drawn along the straight line of the Mercator plane, so the average of the two
+ * latitudes in degrees lies off a long slanted edge (on the Mercator map as on the globe). The
+ * point returned lies on the drawn edge at the average longitude. An edge along a meridian or
+ * a parallel keeps the plain average, which lies on it already.
+ */
+export declare function mercatorMidpoint(a: Coordinate, b: Coordinate): Coordinate;
+/**
+ * The length of an edge on the Mercator plane, in world units
+ */
+export declare function mercatorEdgeLength(a: Coordinate, b: Coordinate): number;
+/**
+ * Cuts every edge of a path into pieces of at most `grid` along the Mercator plane
+ *
+ * Each edge is cut into equal pieces on the plane, so every point added lies on the edge as it
+ * is drawn. The vertices of the path are kept. A path whose edges are all shorter than `grid`
+ * is returned as it is (the same array).
+ *
+ * @param path The vertices `[lng, lat]` in degrees
+ * @param grid The longest piece, in Mercator world units (0 or less cuts nothing)
+ * @param maxPoints The most points to add over the whole path
+ * @returns The path with the points added
+ */
+export declare function densifyOnMercatorPlane(path: readonly Coordinate[], grid: number, maxPoints?: number): Coordinate[];

package/dist/shared/math/globe-subdivision.js

@@ -0,0 +1,99 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { fromPlane, toPlane } from './mercator-plane.js';
+/**
+ * maplibre's granularity on the globe: the number of cells along the side of a tile of zoom 0,
+ * halved at each zoom level, and the least it goes down to (`vertical_perspective_projection.ts`)
+ */
+const GRANULARITY = {
+    fill: { base: 128, min: 2 },
+    line: { base: 512, min: 1 },
+};
+/**
+ * The side of a subdivision cell on the globe, in Mercator world units (1 = the world)
+ *
+ * The tile zoom is the integer part of the zoom, as maplibre picks the tiles it cuts. A cell
+ * is the world divided by the base granularity up to the zoom where a tile reaches its least
+ * granularity, and half a tile (fills) or a tile (lines) beyond. It changes only when the zoom
+ * crosses an integer, so what is cut for it stays valid while zooming within a level.
+ *
+ * @param zoom The zoom of the map
+ * @param kind Fills or lines
+ * @returns The side of a cell (a power of two fraction of the world)
+ */
+export function globeSubdivisionGrid(zoom, kind) {
+    const z = Math.min(Math.max(0, Math.floor(Number.isFinite(zoom) ? zoom : 0)), 30);
+    const { base, min } = GRANULARITY[kind];
+    const tiles = 2 ** z;
+    const cells = Math.max(Math.floor(base / tiles), min, 1);
+    return 1 / (tiles * cells);
+}
+/**
+ * The point at `t` along the straight line of the Mercator plane from `a` to `b`
+ *
+ * The longitude moves linearly; the latitude moves linearly in Mercator y, not in degrees.
+ * Latitudes beyond the Mercator limit are clamped to it.
+ */
+export function mercatorLerp(a, b, t) {
+    const [ax, ay] = toPlane(a);
+    const [bx, by] = toPlane(b);
+    return fromPlane(ax + (bx - ax) * t, ay + (by - ay) * t);
+}
+/**
+ * The midpoint of an edge as drawn: halfway across in longitude, on the edge
+ *
+ * An edge is drawn along the straight line of the Mercator plane, so the average of the two
+ * latitudes in degrees lies off a long slanted edge (on the Mercator map as on the globe). The
+ * point returned lies on the drawn edge at the average longitude. An edge along a meridian or
+ * a parallel keeps the plain average, which lies on it already.
+ */
+export function mercatorMidpoint(a, b) {
+    const lng = (a[0] + b[0]) / 2;
+    if (a[0] === b[0] || a[1] === b[1])
+        return [lng, (a[1] + b[1]) / 2];
+    const y = (toPlane(a)[1] + toPlane(b)[1]) / 2;
+    return [lng, fromPlane(0, y)[1]];
+}
+/**
+ * The length of an edge on the Mercator plane, in world units
+ */
+export function mercatorEdgeLength(a, b) {
+    const [ax, ay] = toPlane(a);
+    const [bx, by] = toPlane(b);
+    return Math.hypot(bx - ax, by - ay);
+}
+/**
+ * Cuts every edge of a path into pieces of at most `grid` along the Mercator plane
+ *
+ * Each edge is cut into equal pieces on the plane, so every point added lies on the edge as it
+ * is drawn. The vertices of the path are kept. A path whose edges are all shorter than `grid`
+ * is returned as it is (the same array).
+ *
+ * @param path The vertices `[lng, lat]` in degrees
+ * @param grid The longest piece, in Mercator world units (0 or less cuts nothing)
+ * @param maxPoints The most points to add over the whole path
+ * @returns The path with the points added
+ */
+export function densifyOnMercatorPlane(path, grid, maxPoints = 1 << 16) {
+    if (path.length < 2 || !(grid > 0))
+        return path;
+    let out = null;
+    let budget = maxPoints;
+    for (let i = 1; i < path.length; i++) {
+        const a = path[i - 1];
+        const b = path[i];
+        const [ax, ay] = toPlane(a);
+        const [bx, by] = toPlane(b);
+        const pieces = Math.min(Math.ceil(Math.hypot(bx - ax, by - ay) / grid), budget + 1);
+        if (pieces > 1) {
+            out ?? (out = path.slice(0, i));
+            for (let k = 1; k < pieces; k++) {
+                const t = k / pieces;
+                out.push(fromPlane(ax + (bx - ax) * t, ay + (by - ay) * t));
+            }
+            budget -= pieces - 1;
+        }
+        out?.push(b);
+    }
+    return out ?? path;
+}

package/dist/shared/math/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Math module
+ *
+ * A module that brings together geographic coordinate computation and pure geometric
+ * computation.
+ */
+export { getAngleFromCenter, getPointAtAngle } from './angle.js';
+export { generateCirclePolygon } from './circle.js';
+export { DASH_PATTERNS, DEFAULT_TILE_SIZE, EARTH, getDashPattern, RENDERING_DEFAULTS, } from './constants.js';
+export { euclideanDistance, getMetersPerPixel, haversineDistanceMeters, lngToMeters, metersToDegreesLat, metersToDegreesLng, metersToLat, metersToLng, midpoint, pixelsToDegreesLat, pixelsToDegreesLng, pointToPolylineDistance, pointToSegmentDistance, toDegrees, toRadians, } from './distance.js';
+export type { OBBCorners } from './intersection.js';
+export { pointInRectangle, rectangleIntersectsCircle, rectangleIntersectsLineString, rectangleIntersectsOBB, rectangleIntersectsPolygon, segmentIntersectsRectangle, segmentIntersectsSegment, } from './intersection.js';
+export type { OBB } from './obb.js';
+export { createOBB, distanceToOBB, getOBBAABB, getOBBCorners, pointInOBB } from './obb.js';
+export { computeRotatedQuadCorners, ecefToWGS84, kmToDegrees, pixelsToDegrees, rotateCoordinateOnSphere, rotateCoordinatesOnSphere, wgs84ToECEF, } from './rotation.js';
+export type { AnchorProjector, CoordinateTransform, LngLat, MercatorCoord, ScreenPoint, } from './transform.js';
+export { applyMarginToBoundingBox, clampCoordinate, clampLatitude, createCoordinateTransform, getAnchorProjector, lngLatToMercator, setAnchorProjector, } from './transform.js';

package/dist/shared/math/index.js

@@ -0,0 +1,21 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Math module
+ *
+ * A module that brings together geographic coordinate computation and pure geometric
+ * computation.
+ */
+// Angle computation
+export { getAngleFromCenter, getPointAtAngle } from './angle.js';
+// Circle rendering
+export { generateCirclePolygon } from './circle.js';
+// Constants
+export { DASH_PATTERNS, DEFAULT_TILE_SIZE, EARTH, getDashPattern, RENDERING_DEFAULTS, } from './constants.js';
+// Distance computation
+export { euclideanDistance, getMetersPerPixel, haversineDistanceMeters, lngToMeters, metersToDegreesLat, metersToDegreesLng, metersToLat, metersToLng, midpoint, pixelsToDegreesLat, pixelsToDegreesLng, pointToPolylineDistance, pointToSegmentDistance, toDegrees, toRadians, } from './distance.js';
+export { pointInRectangle, rectangleIntersectsCircle, rectangleIntersectsLineString, rectangleIntersectsOBB, rectangleIntersectsPolygon, segmentIntersectsRectangle, segmentIntersectsSegment, } from './intersection.js';
+export { createOBB, distanceToOBB, getOBBAABB, getOBBCorners, pointInOBB } from './obb.js';
+// Rotation computation
+export { computeRotatedQuadCorners, ecefToWGS84, kmToDegrees, pixelsToDegrees, rotateCoordinateOnSphere, rotateCoordinatesOnSphere, wgs84ToECEF, } from './rotation.js';
+export { applyMarginToBoundingBox, clampCoordinate, clampLatitude, createCoordinateTransform, getAnchorProjector, lngLatToMercator, setAnchorProjector, } from './transform.js';

package/dist/shared/math/intersection.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Rectangle Intersection
+ *
+ * Intersection testing algorithms for box selection.
+ * Provides intersection tests between the various geometries and an axis-aligned rectangle
+ * (AABB).
+ */
+import type { BoundingBox, Coordinate } from '../types/model.js';
+/**
+ * Tests whether a point is inside a rectangle
+ */
+export declare function pointInRectangle(point: Coordinate, rect: BoundingBox): boolean;
+/**
+ * Intersection test between two segments
+ *
+ * Uses the CCW (Counter-Clockwise) algorithm.
+ */
+export declare function segmentIntersectsSegment(a1: Coordinate, a2: Coordinate, b1: Coordinate, b2: Coordinate): boolean;
+/**
+ * Tests whether a segment intersects a rectangle
+ */
+export declare function segmentIntersectsRectangle(p1: Coordinate, p2: Coordinate, rect: BoundingBox): boolean;
+/**
+ * Intersection test between a rectangle and a LineString
+ *
+ * Returns true when any vertex of the LineString is inside the rectangle, or when any of its
+ * edges intersects the rectangle.
+ */
+export declare function rectangleIntersectsLineString(rect: BoundingBox, lineString: Coordinate[]): boolean;
+/**
+ * Intersection test between a rectangle and a Polygon
+ *
+ * Returns true when any of the following conditions holds:
+ * 1. Any vertex of the polygon is inside the rectangle
+ * 2. Any vertex of the rectangle is inside the polygon
+ * 3. Any edge of the polygon intersects the rectangle
+ */
+export declare function rectangleIntersectsPolygon(rect: BoundingBox, polygon: Coordinate[][]): boolean;
+/**
+ * Intersection test between a rectangle and a Circle
+ *
+ * Returns true when the center of the circle is inside the rectangle, or when an edge or a
+ * vertex of the rectangle intersects the circle.
+ *
+ * @param rect Selection rectangle (geographic coordinates)
+ * @param center Center of the circle (geographic coordinates)
+ * @param radiusInDegrees Radius of the circle (in degrees)
+ */
+export declare function rectangleIntersectsCircle(rect: BoundingBox, center: Coordinate, radiusInDegrees: number): boolean;
+/**
+ * Type definition of an OBB (Oriented Bounding Box)
+ */
+export interface OBBCorners {
+    /** The 4 vertices of the OBB (counter-clockwise) */
+    corners: Coordinate[];
+}
+/**
+ * Intersection test between an AABB and an OBB (Separating Axis Theorem: SAT)
+ *
+ * @param rect Axis-aligned bounding box (AABB)
+ * @param obb Bounding box that accounts for rotation (OBB)
+ */
+export declare function rectangleIntersectsOBB(rect: BoundingBox, obb: OBBCorners): boolean;