@sakuzu/maplibre-gl-draw 1.0.0

package/dist/operations/layer-operations.js

@@ -0,0 +1,350 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Deletes the group if it has become empty (the standard behavior of canvas tools).
+ * Called at the end of each path that moves or removes a feature out of a group.
+ */
+function deleteGroupIfEmpty(store, groupId) {
+    const group = store.getGroup(groupId);
+    if (group && group.featureIds.length === 0) {
+        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) {
+    const feature = store.getFeature(featureId);
+    if (!feature?.groupId)
+        return;
+    const group = store.getGroup(feature.groupId);
+    if (!group)
+        return;
+    // Find the layer the group belongs to
+    let layerId = null;
+    for (const layer of store.getAllLayers()) {
+        if (layer.order.includes(group.id)) {
+            layerId = layer.id;
+            break;
+        }
+    }
+    store.transact(() => {
+        // Remove the feature from the group
+        const newFeatureIds = group.featureIds.filter((id) => id !== featureId);
+        store.updateGroup(group.id, { featureIds: newFeatureIds });
+        // Remove the groupId from the feature
+        store.updateFeature(featureId, { groupId: undefined });
+        // Add the feature to the order of the layer (right after the group)
+        if (layerId) {
+            const layer = store.getLayer(layerId);
+            if (layer) {
+                const groupIndex = layer.order.indexOf(group.id);
+                const newOrder = [...layer.order];
+                newOrder.splice(groupIndex + 1, 0, featureId);
+                store.updateLayer(layerId, { order: newOrder });
+            }
+        }
+        // Delete the group when it has become empty (after the feature has been moved out
+        // directly under the layer)
+        deleteGroupIfEmpty(store, group.id);
+    });
+}
+/**
+ * Groups the selected features
+ *
+ * @returns The group ID, or null when grouping was not possible
+ *
+ * @internal
+ */
+export function groupSelection(store, generateFeatureId, autoNameGenerator) {
+    const selection = store.getSelection();
+    // Do nothing when it is not a feature selection
+    if (selection.type !== 'feature')
+        return null;
+    const selectedIds = selection.ids;
+    // Condition 1: two or more features are selected
+    const features = selectedIds
+        .map((id) => store.getFeature(id))
+        .filter((f) => f !== undefined);
+    if (features.length < 2)
+        return null;
+    // Condition 2: they all belong to the same layer
+    const layerIds = new Set(features.map((f) => f.layerId));
+    if (layerIds.size !== 1)
+        return null;
+    const layerId = features[0].layerId;
+    // Condition 3: they do not yet belong to a group that actually exists.
+    // When the groupId is a stale value that points to a deleted group, it is regarded as
+    // belonging to nothing and regrouping is allowed (createGroup overwrites the groupId of the
+    // members with the new value, so it is repaired automatically here).
+    if (features.some((f) => f.groupId !== undefined && store.getGroup(f.groupId) !== undefined)) {
+        return null;
+    }
+    // Create the group
+    const groupId = generateFeatureId();
+    const groupName = autoNameGenerator.generateGroupName();
+    const group = {
+        id: groupId,
+        name: groupName,
+        featureIds: [...selectedIds],
+        locked: false,
+        visible: true,
+    };
+    store.transact(() => {
+        // Remove the feature IDs from the order of the layer and add the group ID
+        const layer = store.getLayer(layerId);
+        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];
+                    break;
+                }
+            }
+            // Build the new order (insert the group at the position of the frontmost selected feature)
+            const newOrder = [];
+            for (const id of layer.order) {
+                if (selectedIds.includes(id)) {
+                    // Insert the group at the position of the frontmost selected feature
+                    if (id === frontmostSelectedId) {
+                        newOrder.push(groupId);
+                    }
+                    // The selected features are excluded from the order
+                }
+                else {
+                    newOrder.push(id);
+                }
+            }
+            // Even when not a single selected feature is included in order (for example when they
+            // are missing from order because of stale data), the group is appended at the tail so
+            // that it is not left out of order.
+            if (frontmostSelectedId === null) {
+                newOrder.push(groupId);
+            }
+            store.updateLayer(layerId, { order: newOrder });
+        }
+        // Create the group
+        store.createGroup(group);
+    });
+    return groupId;
+}
+/**
+ * Dissolves a group (outside a transaction, a pure mutation).
+ * It removes the group from the order, expands its member features into the same position,
+ * and then deletes the group itself. The caller must wrap it in store.transact.
+ */
+function dissolveGroup(store, groupId) {
+    const group = store.getGroup(groupId);
+    if (!group)
+        return;
+    // Identify the layer the group belongs to
+    let targetLayerId = null;
+    for (const layer of store.getAllLayers()) {
+        if (layer.order.includes(groupId)) {
+            targetLayerId = layer.id;
+            break;
+        }
+    }
+    if (!targetLayerId)
+        return;
+    // Remove the group ID from the order of the layer and expand the feature IDs into the same
+    // position
+    const layer = store.getLayer(targetLayerId);
+    if (layer) {
+        const groupIndex = layer.order.indexOf(groupId);
+        const newOrder = [...layer.order];
+        newOrder.splice(groupIndex, 1, ...group.featureIds);
+        store.updateLayer(targetLayerId, { order: 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).
+ *
+ * - When a group is selected -> that group is dissolved (its children are expanded into the
+ *   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).
+ *   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.
+ *
+ * @internal
+ */
+export function ungroupSelection(store) {
+    const selection = store.getSelection();
+    if (selection.ids.length === 0)
+        return;
+    // A group selection -> dissolve
+    if (selection.type === 'group') {
+        store.transact(() => {
+            for (const groupId of selection.ids) {
+                dissolveGroup(store, groupId);
+            }
+        });
+        return;
+    }
+    // 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;
+        store.transact(() => {
+            for (const id of memberIds) {
+                removeFeatureFromGroup(store, id);
+            }
+        });
+    }
+}

package/dist/operations/resize.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Resize operation
+ *
+ * The operation that resizes features. It computes in Web Mercator (see mercator-plane.ts),
+ * 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 { HandleType } from '../shared/config/constants.js';
+import type { BoundingBoxCoords } from '../shared/types/selection-box.js';
+import type { Feature, FeatureCoordinates } from '../store/types.js';
+/**
+ * A custom resize computation of a feature type
+ */
+export type ResizeCalculator = (handle: HandleType, state: ResizeState, currentLngLat: {
+    lng: number;
+    lat: number;
+}, feature: Feature) => CustomResizeResult | null;
+/**
+ * The extension points the resize reads from the draw instance
+ *
+ * The draw instance's selection extension registry satisfies it.
+ */
+export interface ResizeExtensions {
+    getResizeStrategy(type: string): 'scale' | 'coordinates' | undefined;
+    getCustomResizeCalculator(type: string): ResizeCalculator | undefined;
+}
+/**
+ * The result of the resize
+ */
+export interface ResizeResult {
+    coordinates: FeatureCoordinates;
+    /** The new scale value of a feature that has a scale property */
+    scale?: number;
+    /** The new radius for a Circle (meters) */
+    radiusMeters?: number;
+    /** The width (pixels) - for a custom resize */
+    width?: number;
+    /** The height (pixels) - for a custom resize */
+    height?: number;
+}
+/**
+ * The state of a resize drag, captured when the drag starts.
+ */
+export interface ResizeState {
+    /** The handle being dragged */
+    handle: HandleType;
+    /** The pointer position at the start, in degrees */
+    startLngLat: {
+        lng: number;
+        lat: number;
+    };
+    /** The selection box at the start, corners in degrees */
+    startBbox: BoundingBoxCoords;
+    /** The coordinates of each feature at the start, by feature id */
+    initialCoordinates: Map<string, FeatureCoordinates>;
+    /** The scale of a feature that has a scale property, at the start */
+    initialScales: Map<string, number>;
+    /** The radius of a Circle at the start (meters) */
+    initialRadiusMeters: Map<string, number>;
+    /** The width at the start (pixels) - for a custom resize */
+    initialWidth: Map<string, number>;
+    /** The height at the start (pixels) - for a custom resize */
+    initialHeight: Map<string, number>;
+    /**
+     * The extent of the bounding box (Web Mercator world units, 1 = the width of the world)
+     * below which it is not stretched along that axis. The caller converts a screen distance
+     * at the current zoom. 0 when omitted (only a box of no extent is left alone)
+     */
+    minAxisExtent?: number;
+}

package/dist/operations/resize.js

@@ -0,0 +1,252 @@
+// 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 { getCircleRadius, getImageProperties } from '../shared/utils/property.js';
+/**
+ * Decides whether a feature has a scale property
+ *
+ * For features that have a scale property (Text, Image, custom features and so on)
+ */
+function hasScaleProperty(feature, extensions) {
+    // Get resizeStrategy from the draw instance's registry
+    const strategy = extensions?.getResizeStrategy(feature.type);
+    if (strategy === 'scale') {
+        return true;
+    }
+    if (strategy === 'coordinates') {
+        return false;
+    }
+    // The built-in types of the core
+    if (feature.type === 'Image') {
+        return true;
+    }
+    // Generic check (decided by the presence of a scale property)
+    return (feature.properties !== null &&
+        typeof feature.properties === 'object' &&
+        'scale' in feature.properties);
+}
+/**
+ * Gets the value of the scale property of a feature
+ */
+function getFeatureScale(feature) {
+    if (feature.type === 'Image') {
+        const props = getImageProperties(feature);
+        return props.scale ?? 1;
+    }
+    const props = feature.properties;
+    return typeof props.scale === 'number' ? props.scale : 1;
+}
+/**
+ * Gets the anchor (the fixed point) from the handle position
+ */
+function getAnchorFromHandle(handle, bbox) {
+    switch (handle) {
+        case 'resize-nw':
+            return { anchor: bbox.bottomRight, scaleX: -1, scaleY: 1 };
+        case 'resize-n':
+            return {
+                anchor: [(bbox.bottomLeft[0] + bbox.bottomRight[0]) / 2, bbox.bottomLeft[1]],
+                scaleX: 0,
+                scaleY: 1,
+            };
+        case 'resize-ne':
+            return { anchor: bbox.bottomLeft, scaleX: 1, scaleY: 1 };
+        case 'resize-e':
+            return {
+                anchor: [
+                    (bbox.topLeft[0] + bbox.bottomLeft[0]) / 2,
+                    (bbox.topLeft[1] + bbox.bottomLeft[1]) / 2,
+                ],
+                scaleX: 1,
+                scaleY: 0,
+            };
+        case 'resize-se':
+            return { anchor: bbox.topLeft, scaleX: 1, scaleY: -1 };
+        case 'resize-s':
+            return {
+                anchor: [(bbox.topLeft[0] + bbox.topRight[0]) / 2, bbox.topLeft[1]],
+                scaleX: 0,
+                scaleY: -1,
+            };
+        case 'resize-sw':
+            return { anchor: bbox.topRight, scaleX: -1, scaleY: -1 };
+        case 'resize-w':
+            return {
+                anchor: [
+                    (bbox.topRight[0] + bbox.bottomRight[0]) / 2,
+                    (bbox.topRight[1] + bbox.bottomRight[1]) / 2,
+                ],
+                scaleX: -1,
+                scaleY: 0,
+            };
+        default:
+            return { anchor: bbox.center, scaleX: 1, scaleY: 1 };
+    }
+}
+/**
+ * Scales a coordinate in the transform plane around an anchor given in the plane
+ */
+function scaleCoordinate(coord, anchor, scaleX, scaleY) {
+    const [x, y] = toPlane(coord);
+    return fromPlane(anchor[0] + (x - anchor[0]) * scaleX, anchor[1] + (y - anchor[1]) * scaleY);
+}
+/**
+ * Scales an array of coordinates
+ *
+ * It uses a common traversal that does not depend on the nesting depth, so Multi
+ * geometries (a MultiPolygon is nested 4 levels deep) can be transformed as they
+ * are.
+ */
+function scaleCoordinates(coords, anchor, scaleX, scaleY) {
+    return mapCoordinatesDeep(coords, (coord) => scaleCoordinate(coord, anchor, scaleX, scaleY));
+}
+/**
+ * The distance between 2 points of the transform plane
+ */
+function planeDistance(a, b) {
+    return Math.hypot(a[0] - b[0], a[1] - b[1]);
+}
+/**
+ * Computes the resize
+ *
+ * @param extensions The draw instance's extension points (custom resize calculators)
+ *
+ * @internal
+ */
+export function computeResize(state, currentLngLat, features, extensions) {
+    const { handle, startLngLat, startBbox } = state;
+    const { anchor: anchorLngLat, scaleX: scaleDirectionX, scaleY: scaleDirectionY, } = getAnchorFromHandle(handle, startBbox);
+    const anchor = toPlane(anchorLngLat);
+    const start = toPlane([startLngLat.lng, startLngLat.lat]);
+    const current = toPlane([currentLngLat.lng, currentLngLat.lat]);
+    // Compute the scale from the distance to the anchor (this handles rotation)
+    const startDistance = planeDistance(start, anchor);
+    const currentDistance = planeDistance(current, anchor);
+    // Compute the scale from the rate of change of the distance
+    // Note: for a small feature (Text and so on) startDistance becomes a very small value, so
+    // only a distance of exactly zero is left alone
+    let uniformScale = 1;
+    if (startDistance > 0) {
+        uniformScale = currentDistance / startDistance;
+    }
+    // Limit the minimum scale
+    uniformScale = Math.max(uniformScale, 0.1);
+    // The scale along the axes (for non-rotated features)
+    // Compute the amount of movement
+    const dx = current[0] - start[0];
+    const dy = current[1] - start[1];
+    // The size of the bounding box (valid only when it is not rotated). A box thinner than the
+    // caller's minimum extent (a screen distance) is not stretched along that axis, because the
+    // division would turn a pixel of pointer movement into a huge scale
+    const topLeft = toPlane(startBbox.topLeft);
+    const bboxWidth = Math.abs(toPlane(startBbox.topRight)[0] - topLeft[0]);
+    const bboxHeight = Math.abs(topLeft[1] - toPlane(startBbox.bottomLeft)[1]);
+    const minExtent = Math.max(0, state.minAxisExtent ?? 0);
+    let scaleX = 1;
+    let scaleY = 1;
+    if (scaleDirectionX !== 0 && bboxWidth > minExtent) {
+        scaleX = 1 + (scaleDirectionX * dx) / bboxWidth;
+    }
+    if (scaleDirectionY !== 0 && bboxHeight > minExtent) {
+        scaleY = 1 + (scaleDirectionY * dy) / bboxHeight;
+    }
+    // Limit the minimum scale
+    scaleX = Math.max(scaleX, 0.1);
+    scaleY = Math.max(scaleY, 0.1);
+    // Compute the new coordinates of each feature
+    const result = new Map();
+    for (const feature of features) {
+        const initialCoords = state.initialCoordinates.get(feature.id);
+        if (!initialCoords)
+            continue;
+        // Use the custom resize calculator first if there is one
+        const customCalculator = extensions?.getCustomResizeCalculator(feature.type);
+        if (customCalculator) {
+            const customResult = customCalculator(handle, state, currentLngLat, feature);
+            if (customResult) {
+                result.set(feature.id, {
+                    coordinates: customResult.coordinates,
+                    width: customResult.width,
+                    height: customResult.height,
+                });
+                continue;
+            }
+        }
+        // Which features scale by property was decided when the resize started (initialScales)
+        if (state.initialScales.has(feature.id)) {
+            // For a feature that has a scale property:
+            // with the anchor as the fixed point, scale the center coordinate too and change scale
+            const initialScale = state.initialScales.get(feature.id) ?? 1;
+            const newScale = initialScale * uniformScale;
+            const newCoords = scaleCoordinates(initialCoords, anchor, uniformScale, uniformScale);
+            result.set(feature.id, {
+                coordinates: newCoords,
+                scale: newScale,
+            });
+        }
+        else if (feature.type === 'Circle') {
+            // For a Circle: scale the center coordinate and scale the radius too
+            const initialRadius = state.initialRadiusMeters.get(feature.id) ?? 0;
+            const newRadius = initialRadius * uniformScale;
+            const newCoords = scaleCoordinates(initialCoords, anchor, uniformScale, uniformScale);
+            result.set(feature.id, {
+                coordinates: newCoords,
+                radiusMeters: newRadius,
+            });
+        }
+        else {
+            // For Point, LineString, Polygon and Freehand: change only the coordinates
+            const newCoords = scaleCoordinates(initialCoords, anchor, scaleX, scaleY);
+            result.set(feature.id, { coordinates: newCoords });
+        }
+    }
+    return result;
+}
+/**
+ * Starts the resize operation
+ *
+ * @param extensions The draw instance's extension points (resize strategies of custom types)
+ * @param minAxisExtent The extent of the bounding box (Web Mercator world units) below which
+ *   it is not stretched along that axis; the caller converts a screen distance at its zoom
+ *
+ * @internal
+ */
+export function startResize(handle, startLngLat, bbox, features, extensions, minAxisExtent = 0) {
+    const initialCoordinates = new Map();
+    const initialScales = new Map();
+    const initialRadiusMeters = new Map();
+    const initialWidth = new Map();
+    const initialHeight = new Map();
+    for (const feature of features) {
+        initialCoordinates.set(feature.id, JSON.parse(JSON.stringify(feature.coordinates)));
+        // For a feature that has a scale property, store the initial scale
+        if (hasScaleProperty(feature, extensions)) {
+            initialScales.set(feature.id, getFeatureScale(feature));
+        }
+        // For a Circle, store the initial radius
+        if (feature.type === 'Circle') {
+            const radiusMeters = getCircleRadius(feature);
+            initialRadiusMeters.set(feature.id, radiusMeters ?? 0);
+        }
+        // For a feature that has width / height properties (Note and so on), store the initial size
+        const props = feature.properties;
+        if (typeof props.width === 'number') {
+            initialWidth.set(feature.id, props.width);
+        }
+        if (typeof props.height === 'number') {
+            initialHeight.set(feature.id, props.height);
+        }
+    }
+    return {
+        handle,
+        startLngLat,
+        startBbox: bbox,
+        initialCoordinates,
+        initialScales,
+        initialRadiusMeters,
+        initialWidth,
+        initialHeight,
+        minAxisExtent,
+    };
+}

package/dist/operations/rotate.d.ts

@@ -0,0 +1,17 @@
+import type { FeatureCoordinates } from '../store/types.js';
+/**
+ * The extension points the rotation reads from the draw instance
+ *
+ * The draw instance's selection extension registry satisfies it.
+ */
+export interface RotateExtensions {
+    getResizeStrategy(type: string): 'scale' | 'coordinates' | undefined;
+}
+/**
+ * The result of the rotation
+ */
+export interface RotateResult {
+    coordinates: FeatureCoordinates;
+    /** The new rotation value of a feature that has a rotation property (degrees) */
+    rotation?: number;
+}