@sakuzu/maplibre-gl-draw 1.0.0

package/dist/geometry/split.d.ts

@@ -0,0 +1,68 @@
+import type { AreaCoordinates, Coordinate, MultiPolygonCoordinates } from './types.js';
+/**
+ * Returns the intersection point of two segments on the lng/lat plane.
+ *
+ * Returns null when they do not cross. Parallel segments and collinear segments are
+ * null as well. An interval that overlaps collinearly cannot be expressed by a single
+ * point, so it is not treated as an intersection (the endpoints of the overlap are not
+ * returned either). A touch between endpoints, and a T-shaped touch where an endpoint
+ * lies in the interior of the other, are returned as intersections. A segment of length
+ * 0 has no direction, so it is always null.
+ *
+ * The test is whether the parameter is between 0 and 1 inclusive, with both ends
+ * loosened by the rounding error.
+ *
+ * @param a1 The start of segment A, `[lng, lat]` in degrees
+ * @param a2 The end of segment A, `[lng, lat]` in degrees
+ * @param b1 The start of segment B, `[lng, lat]` in degrees
+ * @param b2 The end of segment B, `[lng, lat]` in degrees
+ * @returns The intersection `[lng, lat]`, taken on segment A. `null` when they do not
+ *   cross, are parallel or collinear, or either has length 0
+ *
+ * @example
+ * ```ts
+ * import { segmentIntersection } from '@sakuzu/maplibre-gl-draw/geometry';
+ *
+ * segmentIntersection([0, 0], [2, 2], [0, 2], [2, 0]); // [1, 1]
+ * segmentIntersection([0, 0], [1, 0], [0, 1], [1, 1]); // null (parallel)
+ * ```
+ */
+export declare function segmentIntersection(a1: Coordinate, a2: Coordinate, b1: Coordinate, b2: Coordinate): Coordinate | null;
+/**
+ * Cuts a polygon with a polyline and returns each resulting part.
+ *
+ * When the line does not pass through the polygon (it does not cross, it stops inside the
+ * polygon, it only touches an edge or a vertex, or it runs only inside a hole), the
+ * original polygon is returned as a single part without splitting. When the line crosses several times, the result is
+ * divided into one part per spatially connected mass. When only a portion of a
+ * MultiPolygon is cut, the parts that were not cut are returned as separate parts as
+ * well.
+ *
+ * Each part is MultiPolygon coordinates with the orientations and the degeneracies
+ * tidied up (a part with a hole comes with its inner ring). An empty array is returned
+ * for an input that has no area.
+ *
+ * A stretch where the line runs collinear with the outline is not treated as a crossing,
+ * and positions closer than 1e-9 degrees (about 0.1 mm) count as the same position.
+ *
+ * @param area The Polygon or MultiPolygon coordinates to cut, in degrees
+ * @param line The cutting polyline `[lng, lat][]` in degrees. Fewer than 2 positions cut
+ *   nothing
+ * @returns The normalized MultiPolygon coordinates of each part. A single element (the
+ *   input normalized) when it is not split. An empty array when the input has no area
+ * @throws {@link GeometryError} when the boolean operation engine fails even after the
+ *   retry on the 1e-9 degree grid
+ *
+ * @example
+ * ```ts
+ * import { splitArea } from '@sakuzu/maplibre-gl-draw/geometry';
+ *
+ * const square: [number, number][][] = [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]];
+ * const parts = splitArea(square, [[0.5, -1], [0.5, 2]]);
+ * parts.length; // 2: the halves west and east of longitude 0.5
+ * if (parts.length === 1) {
+ *   // Not split: the line does not cross the polygon
+ * }
+ * ```
+ */
+export declare function splitArea(area: AreaCoordinates, line: Coordinate[]): MultiPolygonCoordinates[];

package/dist/geometry/split.js

@@ -0,0 +1,430 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Splitting by a line
+ *
+ * Cuts a polygon with a polyline and divides it into several parts. The body is a
+ * planar arrangement.
+ *
+ *   1. Find every intersection of the outline of the polygon and the cutting line, and
+ *      chop the segments at the intersections (noding)
+ *   2. Assemble the chopped segments as a planar graph and drop the dead ends (dangles)
+ *   3. Extract the minimal cycles (faces) of the graph
+ *   4. Take the intersection of each cycle and the original polygon, and make it a part
+ *
+ * Because the intersection with the original polygon is taken in step 4, the holes (the
+ * inner rings) are restored automatically. A cycle itself is a simple ring with no
+ * holes, and a cycle that lies inside a hole has an empty intersection and is dropped.
+ *
+ * The measure of dropping the dead ends is what realizes "a line that does not pass
+ * through does not split". A line that breaks off inside the polygon always has an end
+ * of degree 1, so it disappears without contributing to a cycle.
+ *
+ * The limitations are the same as those of the whole geometry module (crossing the ±180
+ * degree meridian and the vicinity of the poles are out of scope). In addition, when
+ * the cutting line has an interval that overlaps the outline of the polygon collinearly,
+ * that overlap is not treated as an intersection (because a collinear overlap cannot be
+ * expressed by a single point).
+ */
+import { intersection, normalizeArea } from './boolean.js';
+import { signedRingArea } from './simplify.js';
+/**
+ * The error allowed in the parameter of a segment
+ *
+ * In a T-shaped touch where an endpoint lies on the other segment, the parameter can
+ * fall slightly outside 0 / 1 because of the rounding error. That much is allowed.
+ */
+const PARAMETER_EPSILON = 1e-12;
+/**
+ * The step of the quantization that identifies a node (degrees)
+ *
+ * 1e-9 degrees is roughly 0.1mm at the equator. An intersection uses the same value on
+ * the outline side and on the line side, so the two match exactly, but in a T-shaped
+ * touch that passes over a vertex the computed intersection differs from the original
+ * vertex by the least significant digit alone. A key rounded by this step makes them
+ * count as the same node.
+ */
+const NODE_QUANTUM = 1e-9;
+/**
+ * Returns the intersection point of two segments on the lng/lat plane.
+ *
+ * Returns null when they do not cross. Parallel segments and collinear segments are
+ * null as well. An interval that overlaps collinearly cannot be expressed by a single
+ * point, so it is not treated as an intersection (the endpoints of the overlap are not
+ * returned either). A touch between endpoints, and a T-shaped touch where an endpoint
+ * lies in the interior of the other, are returned as intersections. A segment of length
+ * 0 has no direction, so it is always null.
+ *
+ * The test is whether the parameter is between 0 and 1 inclusive, with both ends
+ * loosened by the rounding error.
+ *
+ * @param a1 The start of segment A, `[lng, lat]` in degrees
+ * @param a2 The end of segment A, `[lng, lat]` in degrees
+ * @param b1 The start of segment B, `[lng, lat]` in degrees
+ * @param b2 The end of segment B, `[lng, lat]` in degrees
+ * @returns The intersection `[lng, lat]`, taken on segment A. `null` when they do not
+ *   cross, are parallel or collinear, or either has length 0
+ *
+ * @example
+ * ```ts
+ * import { segmentIntersection } from '@sakuzu/maplibre-gl-draw/geometry';
+ *
+ * segmentIntersection([0, 0], [2, 2], [0, 2], [2, 0]); // [1, 1]
+ * segmentIntersection([0, 0], [1, 0], [0, 1], [1, 1]); // null (parallel)
+ * ```
+ */
+export function segmentIntersection(a1, a2, b1, b2) {
+    const ax = a2[0] - a1[0];
+    const ay = a2[1] - a1[1];
+    const bx = b2[0] - b1[0];
+    const by = b2[1] - b1[1];
+    // When the cross product is 0, the two segments are parallel (collinear included) or
+    // one of them is degenerate
+    const denominator = ax * by - ay * bx;
+    if (denominator === 0)
+        return null;
+    const dx = b1[0] - a1[0];
+    const dy = b1[1] - a1[1];
+    const t = (dx * by - dy * bx) / denominator;
+    const u = (dx * ay - dy * ax) / denominator;
+    if (t < -PARAMETER_EPSILON || t > 1 + PARAMETER_EPSILON)
+        return null;
+    if (u < -PARAMETER_EPSILON || u > 1 + PARAMETER_EPSILON)
+        return null;
+    // Pull what fell outside because of the error back onto the segment
+    const clamped = Math.min(1, Math.max(0, t));
+    return [a1[0] + clamped * ax, a1[1] + clamped * ay];
+}
+/**
+ * Cuts a polygon with a polyline and returns each resulting part.
+ *
+ * When the line does not pass through the polygon (it does not cross, it stops inside the
+ * polygon, it only touches an edge or a vertex, or it runs only inside a hole), the
+ * original polygon is returned as a single part without splitting. When the line crosses several times, the result is
+ * divided into one part per spatially connected mass. When only a portion of a
+ * MultiPolygon is cut, the parts that were not cut are returned as separate parts as
+ * well.
+ *
+ * Each part is MultiPolygon coordinates with the orientations and the degeneracies
+ * tidied up (a part with a hole comes with its inner ring). An empty array is returned
+ * for an input that has no area.
+ *
+ * A stretch where the line runs collinear with the outline is not treated as a crossing,
+ * and positions closer than 1e-9 degrees (about 0.1 mm) count as the same position.
+ *
+ * @param area The Polygon or MultiPolygon coordinates to cut, in degrees
+ * @param line The cutting polyline `[lng, lat][]` in degrees. Fewer than 2 positions cut
+ *   nothing
+ * @returns The normalized MultiPolygon coordinates of each part. A single element (the
+ *   input normalized) when it is not split. An empty array when the input has no area
+ * @throws {@link GeometryError} when the boolean operation engine fails even after the
+ *   retry on the 1e-9 degree grid
+ *
+ * @example
+ * ```ts
+ * import { splitArea } from '@sakuzu/maplibre-gl-draw/geometry';
+ *
+ * const square: [number, number][][] = [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]];
+ * const parts = splitArea(square, [[0.5, -1], [0.5, 2]]);
+ * parts.length; // 2: the halves west and east of longitude 0.5
+ * if (parts.length === 1) {
+ *   // Not split: the line does not cross the polygon
+ * }
+ * ```
+ */
+export function splitArea(area, line) {
+    const normalized = normalizeArea(area);
+    if (normalized.length === 0)
+        return [];
+    if (line.length < 2)
+        return [normalized];
+    const arrangement = buildArrangement(normalized, line);
+    if (arrangement === null)
+        return [normalized];
+    const parts = [];
+    for (const face of extractFaces(arrangement)) {
+        // A cycle is a simple ring with no holes. The intersection with the original
+        // polygon drops the holes and the outside
+        const part = intersection([face], normalized);
+        if (part.length > 0)
+            parts.push(part);
+    }
+    // If only one mass comes out, the line has not divided the polygon
+    return parts.length > 1 ? parts : [normalized];
+}
+/** The key that identifies a node */
+function nodeKey(coordinate) {
+    return `${Math.round(coordinate[0] / NODE_QUANTUM)},${Math.round(coordinate[1] / NODE_QUANTUM)}`;
+}
+/** Pushes only the segments whose length is not 0 */
+function pushSegment(segments, a, b) {
+    if (a[0] === b[0] && a[1] === b[1])
+        return;
+    segments.push({ a, b });
+}
+/**
+ * Expands every ring of the polygon into segments
+ *
+ * A ring that is not closed is treated as closed as well.
+ */
+function ringSegments(area) {
+    const segments = [];
+    for (const polygon of area) {
+        for (const ring of polygon) {
+            if (ring.length < 3)
+                continue;
+            for (let i = 0; i + 1 < ring.length; i++) {
+                pushSegment(segments, ring[i], ring[i + 1]);
+            }
+            pushSegment(segments, ring[ring.length - 1], ring[0]);
+        }
+    }
+    return segments;
+}
+/** Expands a polyline into segments */
+function lineSegments(line) {
+    const segments = [];
+    for (let i = 0; i + 1 < line.length; i++) {
+        pushSegment(segments, line[i], line[i + 1]);
+    }
+    return segments;
+}
+/**
+ * Divides a segment at the points that chop it, making a coordinate sequence from end
+ * to end
+ *
+ * The points are ordered by the distance from the start point, and both ends as well as
+ * duplicates at the same position are dropped.
+ */
+function chainOf(segment, cuts) {
+    if (cuts.length === 0)
+        return [segment.a, segment.b];
+    const startKey = nodeKey(segment.a);
+    const endKey = nodeKey(segment.b);
+    const seen = new Set([startKey, endKey]);
+    const inner = [];
+    for (const cut of cuts) {
+        const key = nodeKey(cut);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const dx = cut[0] - segment.a[0];
+        const dy = cut[1] - segment.a[1];
+        inner.push({ coordinate: cut, distance: dx * dx + dy * dy });
+    }
+    inner.sort((left, right) => left.distance - right.distance);
+    return [segment.a, ...inner.map((entry) => entry.coordinate), segment.b];
+}
+/**
+ * Assembles the noded planar graph and drops the dangles
+ *
+ * The outlines of the polygon do not cross one another (normalizeArea guarantees this),
+ * so only "line x outline" and "line x line" are examined for intersections.
+ *
+ * @returns The graph when an edge of the cutting line remains. null when none remains
+ *   (no passing through)
+ */
+function buildArrangement(area, line) {
+    const ringSegs = ringSegments(area);
+    const lineSegs = lineSegments(line);
+    if (ringSegs.length === 0 || lineSegs.length === 0)
+        return null;
+    const ringCuts = ringSegs.map(() => []);
+    const lineCuts = lineSegs.map(() => []);
+    for (let i = 0; i < lineSegs.length; i++) {
+        for (let j = 0; j < ringSegs.length; j++) {
+            const point = segmentIntersection(lineSegs[i].a, lineSegs[i].b, ringSegs[j].a, ringSegs[j].b);
+            if (point === null)
+                continue;
+            lineCuts[i].push(point);
+            ringCuts[j].push(point);
+        }
+        // A self-intersection of the line can also form a cycle, so make it a node
+        for (let k = i + 1; k < lineSegs.length; k++) {
+            const point = segmentIntersection(lineSegs[i].a, lineSegs[i].b, lineSegs[k].a, lineSegs[k].b);
+            if (point === null)
+                continue;
+            lineCuts[i].push(point);
+            lineCuts[k].push(point);
+        }
+    }
+    const nodes = [];
+    const nodeIds = new Map();
+    const edges = [];
+    const edgeIds = new Map();
+    const adjacency = [];
+    const idOf = (coordinate) => {
+        const key = nodeKey(coordinate);
+        const existing = nodeIds.get(key);
+        if (existing !== undefined)
+            return existing;
+        const id = nodes.length;
+        nodes.push(coordinate);
+        nodeIds.set(key, id);
+        adjacency.push([]);
+        return id;
+    };
+    const addEdge = (a, b, fromLine) => {
+        var _a, _b;
+        // An edge whose ends fell onto the same node by the quantization has no length
+        if (a === b)
+            return;
+        const key = a < b ? `${a}-${b}` : `${b}-${a}`;
+        const existing = edgeIds.get(key);
+        if (existing !== undefined) {
+            // A line that overlaps the outline is not a "cutting edge"
+            (_a = edges[existing]).fromLine || (_a.fromLine = fromLine);
+            (_b = edges[existing]).fromRing || (_b.fromRing = !fromLine);
+            return;
+        }
+        const id = edges.length;
+        edges.push({ a, b, fromLine, fromRing: !fromLine, removed: false });
+        edgeIds.set(key, id);
+        adjacency[a].push(id);
+        adjacency[b].push(id);
+    };
+    const addChain = (segments, cuts, fromLine) => {
+        for (let i = 0; i < segments.length; i++) {
+            const chain = chainOf(segments[i], cuts[i]);
+            let previous = idOf(chain[0]);
+            for (let j = 1; j < chain.length; j++) {
+                const current = idOf(chain[j]);
+                addEdge(previous, current, fromLine);
+                previous = current;
+            }
+        }
+    };
+    // Insert the outlines first so that the representative coordinate of a node is
+    // aligned with the original vertex
+    addChain(ringSegs, ringCuts, false);
+    addChain(lineSegs, lineCuts, true);
+    const arrangement = { nodes, edges, adjacency };
+    removeDangles(arrangement);
+    const hasCut = edges.some((edge) => !edge.removed && edge.fromLine && !edge.fromRing);
+    return hasCut ? arrangement : null;
+}
+/**
+ * Drops the dead-end edges
+ *
+ * Erasing the nodes of degree 1 and their edges is repeated until nothing more is
+ * erased. A line that sticks out beyond the polygon and a line that breaks off inside
+ * the polygon stop contributing to a cycle this way.
+ */
+function removeDangles(arrangement) {
+    const { edges, adjacency } = arrangement;
+    const degree = adjacency.map((edgeIds) => edgeIds.length);
+    const queue = [];
+    for (let node = 0; node < degree.length; node++) {
+        if (degree[node] <= 1)
+            queue.push(node);
+    }
+    while (queue.length > 0) {
+        const node = queue.pop();
+        if (degree[node] > 1)
+            continue;
+        for (const edgeId of adjacency[node]) {
+            const edge = edges[edgeId];
+            if (edge.removed)
+                continue;
+            edge.removed = true;
+            degree[node]--;
+            const other = edge.a === node ? edge.b : edge.a;
+            degree[other]--;
+            if (degree[other] <= 1)
+                queue.push(other);
+        }
+    }
+}
+/** The key of a directed edge (the edge ID and the direction) */
+function directedKey(edgeId, forward) {
+    return forward ? `${edgeId}+` : `${edgeId}-`;
+}
+/**
+ * Extracts the minimal cycles (faces)
+ *
+ * Traversing every directed edge once each yields, per connected component, the "inner
+ * faces (counter-clockwise)" and the "outer boundary (clockwise)". Only the cycles
+ * whose area is positive are returned.
+ */
+function extractFaces(arrangement) {
+    const { edges } = arrangement;
+    const visited = new Set();
+    const faces = [];
+    for (let edgeId = 0; edgeId < edges.length; edgeId++) {
+        if (edges[edgeId].removed)
+            continue;
+        for (const forward of [true, false]) {
+            if (visited.has(directedKey(edgeId, forward)))
+                continue;
+            const ring = traceFace(arrangement, edgeId, forward, visited);
+            if (ring !== null && signedRingArea(ring) > 0)
+                faces.push(ring);
+        }
+    }
+    return faces;
+}
+/**
+ * Traces one minimal cycle from a directed edge
+ *
+ * At each node, it proceeds to "the edge nearest in the clockwise direction from the
+ * direction it came in". Under this rule the inner faces close counter-clockwise.
+ */
+function traceFace(arrangement, startEdge, startForward, visited) {
+    const { nodes, edges } = arrangement;
+    const ring = [];
+    let edgeId = startEdge;
+    let forward = startForward;
+    // A directed edge is used only once each, so it closes within this count for certain
+    for (let step = 0; step <= edges.length * 2; step++) {
+        const key = directedKey(edgeId, forward);
+        if (visited.has(key))
+            break;
+        visited.add(key);
+        const edge = edges[edgeId];
+        const from = forward ? edge.a : edge.b;
+        const to = forward ? edge.b : edge.a;
+        ring.push(nodes[from]);
+        const next = nextDirectedEdge(arrangement, to, from);
+        if (next === null)
+            return null;
+        edgeId = next.edgeId;
+        forward = next.forward;
+    }
+    if (ring.length < 3)
+        return null;
+    ring.push(ring[0]);
+    return ring;
+}
+/**
+ * Chooses the next directed edge
+ *
+ * Taking the reverse of the edge it came in on (the direction looking from at toward
+ * previous) as the base, it chooses the edge nearest in the clockwise direction. After
+ * the dangle removal the degree is 2 or more, so a candidate other than going back
+ * always exists.
+ */
+function nextDirectedEdge(arrangement, at, previous) {
+    const { nodes, edges, adjacency } = arrangement;
+    const base = Math.atan2(nodes[previous][1] - nodes[at][1], nodes[previous][0] - nodes[at][0]);
+    let bestEdge = -1;
+    let bestForward = true;
+    let bestDifference = Number.POSITIVE_INFINITY;
+    for (const edgeId of adjacency[at]) {
+        const edge = edges[edgeId];
+        if (edge.removed)
+            continue;
+        const other = edge.a === at ? edge.b : edge.a;
+        const angle = Math.atan2(nodes[other][1] - nodes[at][1], nodes[other][0] - nodes[at][0]);
+        // The clockwise angle difference from the base (0 means going back, so make it the
+        // last candidate)
+        let difference = base - angle;
+        while (difference <= 0)
+            difference += Math.PI * 2;
+        if (difference < bestDifference) {
+            bestDifference = difference;
+            bestEdge = edgeId;
+            bestForward = edge.a === at;
+        }
+    }
+    return bestEdge < 0 ? null : { edgeId: bestEdge, forward: bestForward };
+}

package/dist/geometry/types.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Type definitions of the geometry module
+ *
+ * GeoJSON-compatible array representations. They match the shape of the coordinates of
+ * a core Feature structurally, so they can be passed through as they are with no
+ * conversion. The geometry module does not depend on external type definitions; the
+ * coordinate types are self-contained in this file alone.
+ */
+/**
+ * A position as `[longitude, latitude]` in degrees (WGS84, the GeoJSON order).
+ *
+ * Longitude comes first. No altitude is carried; the functions of this module read only the
+ * first two elements.
+ */
+export type Coordinate = [number, number];
+/**
+ * The outline of a polygon: a closed coordinate sequence whose first and last positions are
+ * equal.
+ *
+ * The functions of this module accept a ring in either orientation. A ring with fewer than
+ * 3 positions, or with a position that is not finite, cannot bound an area and is dropped
+ * by every function that takes polygons.
+ */
+export type Ring = Coordinate[];
+/**
+ * The coordinates of a Polygon: index 0 is the outer ring and the rest are holes (inner
+ * rings).
+ */
+export type PolygonCoordinates = Ring[];
+/** The coordinates of a MultiPolygon: an array of Polygon coordinates, one per part. */
+export type MultiPolygonCoordinates = PolygonCoordinates[];
+/**
+ * Either Polygon coordinates or MultiPolygon coordinates.
+ *
+ * The functions that take polygons accept both shapes (Ring[] and Ring[][]) and tell them
+ * apart with {@link isMultiPolygonCoordinates}, so the caller does not need to normalize
+ * them. The functions that return polygons always return MultiPolygon coordinates.
+ */
+export type AreaCoordinates = PolygonCoordinates | MultiPolygonCoordinates;
+/**
+ * A bounding box as `[minLng, minLat, maxLng, maxLat]` in degrees.
+ *
+ * A box never crosses the ±180 degree meridian: `minLng <= maxLng` always holds.
+ */
+export type BBox = [number, number, number, number];
+/** A GeoJSON Point geometry without `bbox`. */
+export interface PointGeometry {
+    /** The geometry type */
+    type: 'Point';
+    /** The position `[lng, lat]` */
+    coordinates: Coordinate;
+}
+/** A GeoJSON MultiPoint geometry without `bbox`. */
+export interface MultiPointGeometry {
+    /** The geometry type */
+    type: 'MultiPoint';
+    /** The positions `[lng, lat]` */
+    coordinates: Coordinate[];
+}
+/** A GeoJSON LineString geometry without `bbox`. */
+export interface LineStringGeometry {
+    /** The geometry type */
+    type: 'LineString';
+    /** The vertices `[lng, lat]` in drawing order */
+    coordinates: Coordinate[];
+}
+/** A GeoJSON MultiLineString geometry without `bbox`. */
+export interface MultiLineStringGeometry {
+    /** The geometry type */
+    type: 'MultiLineString';
+    /** The lines, each a vertex sequence `[lng, lat][]` */
+    coordinates: Coordinate[][];
+}
+/** A GeoJSON Polygon geometry without `bbox`. */
+export interface PolygonGeometry {
+    /** The geometry type */
+    type: 'Polygon';
+    /** The outer ring followed by the holes */
+    coordinates: PolygonCoordinates;
+}
+/** A GeoJSON MultiPolygon geometry without `bbox`. */
+export interface MultiPolygonGeometry {
+    /** The geometry type */
+    type: 'MultiPolygon';
+    /** The parts, each an outer ring followed by its holes */
+    coordinates: MultiPolygonCoordinates;
+}
+/**
+ * A whole geometry, as taken by {@link buffer}.
+ *
+ * The GeoJSON Geometry types without `bbox` and without GeometryCollection. The
+ * coordinates of a Point, LineString or Polygon feature have the same shape, so they can
+ * be passed with no conversion.
+ */
+export type GeometryInput = PointGeometry | MultiPointGeometry | LineStringGeometry | MultiLineStringGeometry | PolygonGeometry | MultiPolygonGeometry;

package/dist/geometry/types.js

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

package/dist/geometry/units.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Unit conversion and geodetic constants
+ *
+ * The spherical-approximation constants and the angle conversions shared across the
+ * whole geometry module.
+ */
+/**
+ * The radius of the sphere every geodesic function of this module uses, in meters.
+ *
+ * The value is the mean Earth radius, 6,371,000 m. Distances, bearings, areas, circles and
+ * buffers all assume this sphere rather than an ellipsoid, so a result differs from an
+ * ellipsoidal computation by up to about 0.5%.
+ */
+export declare const EARTH_RADIUS_METERS = 6371000;
+/**
+ * Converts an angle in degrees to radians.
+ *
+ * @param degrees The angle in degrees
+ * @returns The angle in radians. NaN and infinities pass through unchanged
+ *
+ * @example
+ * ```ts
+ * import { toRadians } from '@sakuzu/maplibre-gl-draw/geometry';
+ *
+ * toRadians(180); // Math.PI
+ * ```
+ */
+export declare function toRadians(degrees: number): number;
+/**
+ * Converts an angle in radians to degrees.
+ *
+ * @param radians The angle in radians
+ * @returns The angle in degrees. NaN and infinities pass through unchanged
+ */
+export declare function toDegrees(radians: number): number;

package/dist/geometry/units.js

@@ -0,0 +1,41 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Unit conversion and geodetic constants
+ *
+ * The spherical-approximation constants and the angle conversions shared across the
+ * whole geometry module.
+ */
+/**
+ * The radius of the sphere every geodesic function of this module uses, in meters.
+ *
+ * The value is the mean Earth radius, 6,371,000 m. Distances, bearings, areas, circles and
+ * buffers all assume this sphere rather than an ellipsoid, so a result differs from an
+ * ellipsoidal computation by up to about 0.5%.
+ */
+export const EARTH_RADIUS_METERS = 6371000;
+/**
+ * Converts an angle in degrees to radians.
+ *
+ * @param degrees The angle in degrees
+ * @returns The angle in radians. NaN and infinities pass through unchanged
+ *
+ * @example
+ * ```ts
+ * import { toRadians } from '@sakuzu/maplibre-gl-draw/geometry';
+ *
+ * toRadians(180); // Math.PI
+ * ```
+ */
+export function toRadians(degrees) {
+    return (degrees * Math.PI) / 180;
+}
+/**
+ * Converts an angle in radians to degrees.
+ *
+ * @param radians The angle in radians
+ * @returns The angle in degrees. NaN and infinities pass through unchanged
+ */
+export function toDegrees(radians) {
+    return (radians * 180) / Math.PI;
+}