@sakuzu/maplibre-gl-draw 1.0.0 → 2.0.0

package/dist/operations/layer-operations.js

@@ -10,147 +10,12 @@ function deleteGroupIfEmpty(store, groupId) {
         store.deleteGroup(groupId);
     }
 }
-/**
- * Moves a feature or a group to another layer
- *
- * @internal
- */
-export function moveToLayer(store, itemId, targetLayerId) {
-    const feature = store.getFeature(itemId);
-    const group = store.getGroup(itemId);
-    if (feature) {
-        moveFeatureToLayer(store, feature, itemId, targetLayerId);
-    }
-    else if (group) {
-        moveGroupToLayer(store, group, itemId, targetLayerId);
-    }
-}
-function moveFeatureToLayer(store, feature, itemId, targetLayerId) {
-    const targetLayer = store.getLayer(targetLayerId);
-    if (!targetLayer)
-        return;
-    // Do nothing when it is already in the same layer
-    if (feature.layerId === targetLayerId && !feature.groupId)
-        return;
-    const previousGroupId = feature.groupId;
-    store.transact(() => {
-        // When it belongs to a group, remove it from the group
-        if (feature.groupId) {
-            const currentGroup = store.getGroup(feature.groupId);
-            if (currentGroup) {
-                store.updateGroup(feature.groupId, {
-                    featureIds: currentGroup.featureIds.filter((id) => id !== itemId),
-                });
-            }
-        }
-        else {
-            // When it is a standalone feature, remove it from the original layer
-            const sourceLayer = store.getLayer(feature.layerId);
-            if (sourceLayer) {
-                const sourceOrder = sourceLayer.order.filter((id) => id !== itemId);
-                store.updateLayer(sourceLayer.id, { order: sourceOrder });
-            }
-        }
-        // Add it to the new layer
-        store.updateLayer(targetLayerId, { order: [...targetLayer.order, itemId] });
-        // Update the layerId of the feature and clear its groupId
-        store.updateFeature(itemId, { layerId: targetLayerId, groupId: undefined });
-        // Delete the source group when it has become empty
-        if (previousGroupId) {
-            deleteGroupIfEmpty(store, previousGroupId);
-        }
-    });
-}
-function moveGroupToLayer(store, group, itemId, targetLayerId) {
-    // Find the layer the group belongs to
-    let sourceLayerId = null;
-    for (const layer of store.getAllLayers()) {
-        if (layer.order.includes(itemId)) {
-            sourceLayerId = layer.id;
-            break;
-        }
-    }
-    if (sourceLayerId && sourceLayerId !== targetLayerId) {
-        const sourceLayer = store.getLayer(sourceLayerId);
-        const targetLayer = store.getLayer(targetLayerId);
-        if (sourceLayer && targetLayer) {
-            store.transact(() => {
-                // Remove it from the original layer
-                const sourceOrder = sourceLayer.order.filter((id) => id !== itemId);
-                store.updateLayer(sourceLayerId, { order: sourceOrder });
-                // Add it to the new layer
-                store.updateLayer(targetLayerId, { order: [...targetLayer.order, itemId] });
-                // Update the layerId of the features inside the group
-                for (const featureId of group.featureIds) {
-                    store.updateFeature(featureId, { layerId: targetLayerId });
-                }
-            });
-        }
-    }
-}
-/**
- * Adds a feature to a group
- *
- * @internal
- */
-export function addFeatureToGroup(store, featureId, groupId, index) {
-    const feature = store.getFeature(featureId);
-    const group = store.getGroup(groupId);
-    if (!feature || !group)
-        return;
-    // Do nothing when it is already included in this group
-    if (group.featureIds.includes(featureId))
-        return;
-    // Find the layer the group belongs to
-    let targetLayerId = null;
-    for (const layer of store.getAllLayers()) {
-        if (layer.order.includes(groupId)) {
-            targetLayerId = layer.id;
-            break;
-        }
-    }
-    store.transact(() => {
-        // When the feature already belongs to another group, remove it from that group
-        if (feature.groupId && feature.groupId !== groupId) {
-            const oldGroupId = feature.groupId;
-            const oldGroup = store.getGroup(oldGroupId);
-            if (oldGroup) {
-                store.updateGroup(oldGroupId, {
-                    featureIds: oldGroup.featureIds.filter((id) => id !== featureId),
-                });
-                // Delete the source group when it has become empty
-                deleteGroupIfEmpty(store, oldGroupId);
-            }
-        }
-        // Remove the feature from the order of the layer (when it is included in order on its own)
-        const layer = store.getLayer(feature.layerId);
-        if (layer?.order.includes(featureId)) {
-            const newOrder = layer.order.filter((id) => id !== featureId);
-            store.updateLayer(layer.id, { order: newOrder });
-        }
-        // Add the feature to the group (when an index is given, insert it at that position)
-        const newFeatureIds = [...group.featureIds];
-        if (index !== undefined && index >= 0 && index <= newFeatureIds.length) {
-            newFeatureIds.splice(index, 0, featureId);
-        }
-        else {
-            newFeatureIds.push(featureId);
-        }
-        store.updateGroup(groupId, { featureIds: newFeatureIds });
-        // Set the groupId and the layerId (when needed) on the feature
-        const updates = { groupId };
-        if (targetLayerId && feature.layerId !== targetLayerId) {
-            updates.layerId = targetLayerId;
-        }
-        store.updateFeature(featureId, updates);
-    });
-}
 /**
  * Removes a feature from a group
  *
  * @internal
  */
-export function removeFeatureFromGroup(store, featureId) {
+export function takeOutOfGroup(store, featureId) {
     const feature = store.getFeature(featureId);
     if (!feature?.groupId)
         return;
@@ -159,8 +24,8 @@ export function removeFeatureFromGroup(store, featureId) {
         return;
     // Find the layer the group belongs to
     let layerId = null;
-    for (const layer of store.getAllLayers()) {
-        if (layer.order.includes(group.id)) {
+    for (const layer of store.listLayers()) {
+        if (layer.items.includes(group.id)) {
             layerId = layer.id;
             break;
         }
@@ -175,10 +40,10 @@ export function removeFeatureFromGroup(store, featureId) {
         if (layerId) {
             const layer = store.getLayer(layerId);
             if (layer) {
-                const groupIndex = layer.order.indexOf(group.id);
-                const newOrder = [...layer.order];
+                const groupIndex = layer.items.indexOf(group.id);
+                const newOrder = [...layer.items];
                 newOrder.splice(groupIndex + 1, 0, featureId);
-                store.updateLayer(layerId, { order: newOrder });
+                store.updateLayer(layerId, { items: newOrder });
             }
         }
         // Delete the group when it has become empty (after the feature has been moved out
@@ -222,6 +87,7 @@ export function groupSelection(store, generateFeatureId, autoNameGenerator) {
     const groupName = autoNameGenerator.generateGroupName();
     const group = {
         id: groupId,
+        layerId,
         name: groupName,
         featureIds: [...selectedIds],
         locked: false,
@@ -233,15 +99,15 @@ export function groupSelection(store, generateFeatureId, autoNameGenerator) {
         if (layer) {
             // Find the frontmost one (the largest index) among the selected features
             let frontmostSelectedId = null;
-            for (let i = layer.order.length - 1; i >= 0; i--) {
-                if (selectedIds.includes(layer.order[i])) {
-                    frontmostSelectedId = layer.order[i];
+            for (let i = layer.items.length - 1; i >= 0; i--) {
+                if (selectedIds.includes(layer.items[i])) {
+                    frontmostSelectedId = layer.items[i];
                     break;
                 }
             }
             // Build the new order (insert the group at the position of the frontmost selected feature)
             const newOrder = [];
-            for (const id of layer.order) {
+            for (const id of layer.items) {
                 if (selectedIds.includes(id)) {
                     // Insert the group at the position of the frontmost selected feature
                     if (id === frontmostSelectedId) {
@@ -259,7 +125,7 @@ export function groupSelection(store, generateFeatureId, autoNameGenerator) {
             if (frontmostSelectedId === null) {
                 newOrder.push(groupId);
             }
-            store.updateLayer(layerId, { order: newOrder });
+            store.updateLayer(layerId, { items: newOrder });
         }
         // Create the group
         store.createGroup(group);
@@ -277,8 +143,8 @@ function dissolveGroup(store, groupId) {
         return;
     // Identify the layer the group belongs to
     let targetLayerId = null;
-    for (const layer of store.getAllLayers()) {
-        if (layer.order.includes(groupId)) {
+    for (const layer of store.listLayers()) {
+        if (layer.items.includes(groupId)) {
             targetLayerId = layer.id;
             break;
         }
@@ -289,25 +155,14 @@ function dissolveGroup(store, groupId) {
     // position
     const layer = store.getLayer(targetLayerId);
     if (layer) {
-        const groupIndex = layer.order.indexOf(groupId);
-        const newOrder = [...layer.order];
+        const groupIndex = layer.items.indexOf(groupId);
+        const newOrder = [...layer.items];
         newOrder.splice(groupIndex, 1, ...group.featureIds);
-        store.updateLayer(targetLayerId, { order: newOrder });
+        store.updateLayer(targetLayerId, { items: newOrder });
     }
     // Delete the group
     store.deleteGroup(groupId);
 }
-/**
- * Dissolves the given group (it does not depend on the selection).
- * For "ungroup that group" in a panel menu and the like.
- *
- * @internal
- */
-export function ungroupGroup(store, groupId) {
-    store.transact(() => {
-        dissolveGroup(store, groupId);
-    });
-}
 /**
  * Takes the selection out of the group structure (following Felt).
  *
@@ -315,36 +170,42 @@ export function ungroupGroup(store, groupId) {
  *   original position)
  * - When a member feature of a group is selected -> only that feature is taken out of the
  *   group (the group is kept; the member is placed right after the group by
- *   removeFeatureFromGroup, and the group is deleted automatically when it becomes empty).
+ *   takeOutOfGroup, and the group is deleted automatically when it becomes empty).
  *   The group is not dissolved as a whole
  * - Otherwise (a feature that is not a member / no selection) -> nothing is done
  *
  * Even with several targets it is gathered into one transaction, making it one undo unit.
  *
+ * @returns Whether a group was dissolved or a feature taken out of its group
  * @internal
  */
 export function ungroupSelection(store) {
     const selection = store.getSelection();
     if (selection.ids.length === 0)
-        return;
+        return false;
     // A group selection -> dissolve
     if (selection.type === 'group') {
+        const groupIds = selection.ids.filter((id) => store.getGroup(id) !== undefined);
+        if (groupIds.length === 0)
+            return false;
         store.transact(() => {
-            for (const groupId of selection.ids) {
+            for (const groupId of groupIds) {
                 dissolveGroup(store, groupId);
             }
         });
-        return;
+        return true;
     }
     // A feature selection -> take only the selected members out of the group (do not dissolve)
     if (selection.type === 'feature') {
         const memberIds = selection.ids.filter((id) => store.getFeature(id)?.groupId !== undefined);
         if (memberIds.length === 0)
-            return;
+            return false;
         store.transact(() => {
             for (const id of memberIds) {
-                removeFeatureFromGroup(store, id);
+                takeOutOfGroup(store, id);
             }
         });
+        return true;
     }
+    return false;
 }

package/dist/operations/resize.d.ts

@@ -5,7 +5,7 @@
  * so a handle follows the pointer on the map at any latitude. The extension points of the
  * draw instance are passed in as an argument ({@link ResizeExtensions}).
  */
-import type { CustomResizeResult } from '../extension/index.js';
+import type { TypeResizeResult } from '../extension/index.js';
 import type { HandleType } from '../shared/config/constants.js';
 import type { BoundingBoxCoords } from '../shared/types/selection-box.js';
 import type { Feature, FeatureCoordinates } from '../store/types.js';
@@ -15,7 +15,7 @@ import type { Feature, FeatureCoordinates } from '../store/types.js';
 export type ResizeCalculator = (handle: HandleType, state: ResizeState, currentLngLat: {
     lng: number;
     lat: number;
-}, feature: Feature) => CustomResizeResult | null;
+}, feature: Feature) => TypeResizeResult | null;
 /**
  * The extension points the resize reads from the draw instance
  *

package/dist/operations/resize.js

@@ -1,7 +1,8 @@
 // SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
 // SPDX-License-Identifier: AGPL-3.0-only
 import { fromPlane, toPlane } from '../shared/math/mercator-plane.js';
-import { mapCoordinatesDeep } from '../shared/utils/coordinates.js';
+import { getDrawProperty, hasDrawProperty } from '../shared/properties.js';
+import { coordinatesOf, mapCoordinatesDeep } from '../shared/utils/coordinates.js';
 import { getCircleRadius, getImageProperties } from '../shared/utils/property.js';
 /**
  * Decides whether a feature has a scale property
@@ -24,7 +25,7 @@ function hasScaleProperty(feature, extensions) {
     // Generic check (decided by the presence of a scale property)
     return (feature.properties !== null &&
         typeof feature.properties === 'object' &&
-        'scale' in feature.properties);
+        hasDrawProperty(feature.properties, 'scale'));
 }
 /**
  * Gets the value of the scale property of a feature
@@ -34,8 +35,7 @@ function getFeatureScale(feature) {
         const props = getImageProperties(feature);
         return props.scale ?? 1;
     }
-    const props = feature.properties;
-    return typeof props.scale === 'number' ? props.scale : 1;
+    return getDrawProperty(feature, 'scale') ?? 1;
 }
 /**
  * Gets the anchor (the fixed point) from the handle position
@@ -219,7 +219,7 @@ export function startResize(handle, startLngLat, bbox, features, extensions, min
     const initialWidth = new Map();
     const initialHeight = new Map();
     for (const feature of features) {
-        initialCoordinates.set(feature.id, JSON.parse(JSON.stringify(feature.coordinates)));
+        initialCoordinates.set(feature.id, JSON.parse(JSON.stringify(coordinatesOf(feature))));
         // For a feature that has a scale property, store the initial scale
         if (hasScaleProperty(feature, extensions)) {
             initialScales.set(feature.id, getFeatureScale(feature));

package/dist/operations/rotate.js

@@ -9,7 +9,8 @@
  * ({@link RotateExtensions}).
  */
 import { fromPlane, toPlane } from '../shared/math/mercator-plane.js';
-import { mapCoordinatesDeep } from '../shared/utils/coordinates.js';
+import { getDrawProperty, hasDrawProperty } from '../shared/properties.js';
+import { coordinatesOf, mapCoordinatesDeep } from '../shared/utils/coordinates.js';
 import { getImageProperties } from '../shared/utils/property.js';
 /**
  * Decides whether a feature has a rotation property
@@ -30,7 +31,7 @@ function hasRotationProperty(feature, extensions) {
     // Also covers features that have a rotation property in properties
     return (feature.properties !== null &&
         typeof feature.properties === 'object' &&
-        'rotation' in feature.properties);
+        hasDrawProperty(feature.properties, 'rotation'));
 }
 /**
  * Gets the value of the rotation property of a feature
@@ -40,8 +41,7 @@ function getFeatureRotation(feature) {
         const props = getImageProperties(feature);
         return props.rotation ?? 0;
     }
-    const props = feature.properties;
-    return typeof props.rotation === 'number' ? props.rotation : 0;
+    return getDrawProperty(feature, 'rotation') ?? 0;
 }
 /**
  * Computes the angle of a point around the center (radians, counterclockwise from east, in
@@ -141,7 +141,7 @@ export function startRotation(startLngLat, bbox, features, extensions) {
     const initialCoordinates = new Map();
     const initialRotations = new Map();
     for (const feature of features) {
-        initialCoordinates.set(feature.id, JSON.parse(JSON.stringify(feature.coordinates)));
+        initialCoordinates.set(feature.id, JSON.parse(JSON.stringify(coordinatesOf(feature))));
         // For a feature that has a rotation property, store the initial rotation angle
         if (hasRotationProperty(feature, extensions)) {
             initialRotations.set(feature.id, getFeatureRotation(feature));

package/dist/operations/selection-operations.d.ts

@@ -1,7 +1,8 @@
 import type { Store } from '../store/store.js';
+import type { VertexSelection } from '../store/types.js';
 /**
  * Deletes what is selected, as one change. The Delete key of the select mode and
- * `draw.deleteSelection()` both run this.
+ * `draw.selection.delete()` both run this.
  *
  * - vertices selected: deletes those vertices
  * - feature: deletes the selected features
@@ -18,3 +19,17 @@ import type { Store } from '../store/store.js';
  *   on, when nothing is selected, or when everything selected is locked
  */
 export declare function deleteSelection(store: Store): boolean;
+/**
+ * Deletes the selected features, groups or layers as one change, leaving the vertex selection
+ * aside (see {@link deleteSelection} for what each selection deletes)
+ *
+ * @returns true when something was deleted; false while read-only or the interaction lock is
+ *   on, when nothing is selected, or when everything selected is locked
+ */
+export declare function deleteSelectedItems(store: Store): boolean;
+/**
+ * Deletes the selected vertices of one feature as one change
+ *
+ * @returns The number of vertices deleted
+ */
+export declare function deleteSelectedVertices(store: Store, selection: VertexSelection): number;

package/dist/operations/selection-operations.js

@@ -4,13 +4,14 @@
  * Selection operations
  *
  * Deletes what is selected. The Delete key of the select mode (modes/) and
- * `draw.deleteSelection()` (api/) both call this, so the two paths delete the same things.
+ * `draw.selection.delete()` (api/) both call this, so the two paths delete the same things.
  */
+import { coordinatesOf, geometryFromCoordinates } from '../shared/utils/coordinates.js';
 import { isFeatureLocked, isGroupLocked } from '../store/lock.js';
 import { deleteVertex as deleteVertexOp, sortVertexRefsForDeletion } from './vertex.js';
 /**
  * Deletes what is selected, as one change. The Delete key of the select mode and
- * `draw.deleteSelection()` both run this.
+ * `draw.selection.delete()` both run this.
  *
  * - vertices selected: deletes those vertices
  * - feature: deletes the selected features
@@ -32,10 +33,22 @@ export function deleteSelection(store) {
     if (store.isReadOnly() || store.isInteractionLocked())
         return false;
     // Delete the vertices when vertices are selected
-    const selectedVertices = store.getSelectedVertices();
-    if (selectedVertices && selectedVertices.vertexIndices.length > 0) {
+    const selectedVertices = store.getVertexSelection();
+    if (selectedVertices && selectedVertices.vertices.length > 0) {
         return deleteSelectedVertices(store, selectedVertices) > 0;
     }
+    return deleteSelectedItems(store);
+}
+/**
+ * Deletes the selected features, groups or layers as one change, leaving the vertex selection
+ * aside (see {@link deleteSelection} for what each selection deletes)
+ *
+ * @returns true when something was deleted; false while read-only or the interaction lock is
+ *   on, when nothing is selected, or when everything selected is locked
+ */
+export function deleteSelectedItems(store) {
+    if (store.isReadOnly() || store.isInteractionLocked())
+        return false;
     const selection = store.getSelection();
     if (selection.ids.length === 0)
         return false;
@@ -57,7 +70,7 @@ export function deleteSelection(store) {
     }
     if (selection.type === 'group') {
         // Locked groups (themselves / the layer they belong to) are not deleted
-        const findLayerOfGroup = (groupId) => store.getAllLayers().find((l) => l.order.includes(groupId));
+        const findLayerOfGroup = (groupId) => store.listLayers().find((l) => l.items.includes(groupId));
         const groupIds = selection.ids.filter((groupId) => {
             const group = store.getGroup(groupId);
             return group !== undefined && !isGroupLocked(group, findLayerOfGroup);
@@ -94,7 +107,7 @@ export function deleteSelection(store) {
             const layer = store.getLayer(layerId);
             return layer !== undefined && !layer.locked && !holdsLockedItem(store, layerId);
         });
-        const deletable = layerIds.slice(0, Math.max(0, store.getAllLayers().length - 1));
+        const deletable = layerIds.slice(0, Math.max(0, store.listLayers().length - 1));
         if (deletable.length === 0)
             return false;
         store.transact(() => {
@@ -114,19 +127,19 @@ function holdsLockedItem(store, layerId) {
     const layer = store.getLayer(layerId);
     if (!layer)
         return false;
-    for (const itemId of layer.order) {
+    for (const itemId of layer.items) {
         const group = store.getGroup(itemId);
         if (group?.locked)
             return true;
     }
-    return store.getAllFeatures().some((f) => f.layerId === layerId && isFeatureLocked(f, store));
+    return store.listFeatures().some((f) => f.layerId === layerId && isFeatureLocked(f, store));
 }
 /**
  * Deletes the selected vertices of one feature as one change
  *
  * @returns The number of vertices deleted
  */
-function deleteSelectedVertices(store, selection) {
+export function deleteSelectedVertices(store, selection) {
     const feature = store.getFeature(selection.featureId);
     if (!feature)
         return 0;
@@ -136,14 +149,14 @@ function deleteSelectedVertices(store, selection) {
     // Within the same part and the same ring, deletion goes in descending index order
     // (avoiding the shift caused by what was already removed. For MultiPoint the part itself
     // disappears, so parts are in descending order too)
-    const sortedRefs = sortVertexRefsForDeletion(selection.vertexIndices);
+    const sortedRefs = sortVertexRefsForDeletion(selection.vertices);
     // deleteVertex does not mutate its input and returns a new coordinate structure
     // (copy-on-write), so no upfront copy is needed. Successive deletions only need the return
     // value fed into the next input
-    let coords = feature.coordinates;
+    let coords = coordinatesOf(feature);
     let deletedCount = 0;
     for (const ref of sortedRefs) {
-        const result = deleteVertexOp({ ...feature, coordinates: coords }, ref);
+        const result = deleteVertexOp({ ...feature, geometry: geometryFromCoordinates(feature.type, coords) }, ref);
         if (result !== null) {
             coords = result;
             deletedCount++;
@@ -151,7 +164,9 @@ function deleteSelectedVertices(store, selection) {
     }
     if (deletedCount > 0) {
         store.transact(() => {
-            store.updateFeature(selection.featureId, { coordinates: coords });
+            store.updateFeature(selection.featureId, {
+                geometry: geometryFromCoordinates(feature.type, coords),
+            });
             store.setSelectedVertices(null);
         });
     }

package/dist/operations/shared-vertex.js

@@ -18,6 +18,7 @@
  * without vertex movement, such as Circle / Image / Freehand, are excluded from the
  * candidates.
  */
+import { coordinatesOf } from '../shared/utils/coordinates.js';
 import { hasVertexRef } from '../shared/utils/vertex-ref.js';
 import { isLocallyHidden } from '../store/local-visibility.js';
 import { isFeatureLocked } from '../store/lock.js';
@@ -44,7 +45,8 @@ const VERTEX_MOVABLE_TYPES = new Set([
  * point would lose track of "which of the first and the last one matched".
  */
 function forEachVertex(feature, visit) {
-    const { type, coordinates } = feature;
+    const { type } = feature;
+    const coordinates = coordinatesOf(feature);
     if (type === 'Point') {
         visit(coordinates, { ring: 0, index: 0 });
         return;
@@ -142,7 +144,7 @@ export function resolveVertexCoordinates(feature, refs) {
  *
  * Features under an effective lock (their own, their group's or their layer's) and
  * hidden features are excluded. The cascade of the shared visible flag is aligned
- * with the test in getOrderedFeatures, and local hiding with the one in
+ * with the test in listFeaturesInOrder, and local hiding with the one in
  * getDisplayFeatures.
  */
 function isFollowCandidate(feature, store) {

package/dist/operations/trace-graph.d.ts

@@ -59,24 +59,6 @@ export interface TraceGraphEndpoint {
  * @param features The features to build from (pass only the visible ones)
  * @param bbox The extent in degrees; only the edges that touch it are taken in
  * @returns The graph. It has no nodes when no edge falls in `bbox`
- *
- * @example
- * ```ts
- * import { buildTraceGraph, findTracePath } from '@sakuzu/maplibre-gl-draw';
- *
- * const graph = buildTraceGraph(draw.getAllFeatures(), {
- *   minX: 139.7,
- *   minY: 35.6,
- *   maxX: 139.8,
- *   maxY: 35.7,
- * });
- * // The boundary vertices between two vertices of the same parcel
- * const between = findTracePath(
- *   graph,
- *   { coordinate: [139.71, 35.61], node: [139.71, 35.61] },
- *   { coordinate: [139.75, 35.65], node: [139.75, 35.65] },
- * );
- * ```
  */
 export declare function buildTraceGraph(features: readonly Feature[], bbox: BoundingBox): TraceGraph;
 /**

package/dist/operations/trace-graph.js

@@ -52,24 +52,6 @@ function nodeKey(coordinate) {
  * @param features The features to build from (pass only the visible ones)
  * @param bbox The extent in degrees; only the edges that touch it are taken in
  * @returns The graph. It has no nodes when no edge falls in `bbox`
- *
- * @example
- * ```ts
- * import { buildTraceGraph, findTracePath } from '@sakuzu/maplibre-gl-draw';
- *
- * const graph = buildTraceGraph(draw.getAllFeatures(), {
- *   minX: 139.7,
- *   minY: 35.6,
- *   maxX: 139.8,
- *   maxY: 35.7,
- * });
- * // The boundary vertices between two vertices of the same parcel
- * const between = findTracePath(
- *   graph,
- *   { coordinate: [139.71, 35.61], node: [139.71, 35.61] },
- *   { coordinate: [139.75, 35.65], node: [139.75, 35.65] },
- * );
- * ```
  */
 export function buildTraceGraph(features, bbox) {
     const nodes = new Map();