@shapediver/viewer.features.drawing-tools 3.12.16 → 3.12.18

package/dist/business/implementation/managers/interaction/strategies/MobileInteractionStrategy.js

@@ -1,671 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MobileInteractionStrategy = void 0;
-const viewer_1 = require("@shapediver/viewer");
-const viewer_shared_services_1 = require("@shapediver/viewer.shared.services");
-const IInteractionStrategy_1 = require("./IInteractionStrategy");
-/**
- * Mobile-specific interaction strategy using touch gestures
- */
-class MobileInteractionStrategy {
-    constructor(drawingToolsManager, interactionManager, config) {
-        // Touch-specific state
-        this.touchStartTime = 0;
-        this.touchStartPosition = { x: 0, y: 0 };
-        this.isLongPress = false;
-        this.touchHasMoved = false;
-        this.isPotentialInsertion = false;
-        this.isDraggingPoint = false; // Track if we're dragging a point
-        this.lastTapTime = 0;
-        this.tapCount = 0;
-        this.drawingToolsManager = drawingToolsManager;
-        this.interactionManager = interactionManager;
-        this.config = config;
-    }
-    canHandle(event) {
-        // Handle all pointer types on mobile devices (touch, pen, mouse on tablets)
-        // Note: Strategy selection is now done via SystemInfo.isMobile,
-        // so this method is primarily for compatibility
-        return (event.pointerType === "touch" ||
-            event.pointerType === "pen" ||
-            event.pointerType === "mouse");
-    }
-    onPointerDown(event, ray) {
-        if (this.drawingToolsManager.closed) {
-            return { handled: false };
-        }
-        this.touchStartTime = Date.now();
-        this.touchStartPosition = { x: event.clientX, y: event.clientY };
-        this.isLongPress = false;
-        this.longPressPoint = undefined; // Reset long press point
-        this.touchHasMoved = false;
-        this.isPotentialInsertion = false;
-        this.isDraggingPoint = false; // Reset drag state
-        // Start long press detection
-        this.startLongPressDetection(event, ray);
-        // Handle multi-touch for different actions
-        if (this.isMultiTouch(event)) {
-            return this.handleMultiTouch(event, ray);
-        }
-        // Handle insertion immediately in onPointerDown (like desktop strategy)
-        // Only if we're not near an existing point (which would be for dragging)
-        const distances = this.drawingToolsManager.geometryMathManager.checkPointDistances(ray, this.drawingToolsManager.positionArray);
-        const nearPoint = this.findNearestTouchTarget(distances);
-        // IMPORTANT: Check for closing FIRST, before any other logic that might change insertion state
-        // Special case: If we're in insertion mode and touching the first point, close immediately
-        if (nearPoint === 0 &&
-            this.interactionManager.insertionInteractionHandler
-                .insertionActive &&
-            this.canCloseDrawing()) {
-            // Close the drawing immediately when touching the first point
-            this.interactionManager.insertionInteractionHandler.stopInsertion();
-            this.drawingToolsManager.geometryState.closeLoop = true;
-            this.disableMobileContinuousRendering();
-            // Emit GEOMETRY_CHANGED event
-            viewer_shared_services_1.EventEngine.instance.emitEvent(viewer_shared_services_1.EVENTTYPE_DRAWING_TOOLS.GEOMETRY_CHANGED, {
-                viewportId: this.drawingToolsManager.viewport.id,
-                drawingToolId: this.drawingToolsManager.uuid,
-                points: this.drawingToolsManager.geometryState.getPointsData(),
-                temporary: false,
-                fromHistory: false,
-            });
-            this.drawingToolsManager.viewport.render(); // Force immediate render after closing
-            return {
-                handled: true,
-                action: IInteractionStrategy_1.InteractionAction.INSERT_END,
-            };
-        }
-        if (nearPoint === undefined) {
-            // Not near a point, this could be an insertion tap
-            // Check if insertion is allowed before proceeding
-            if (!this.canInsertPoint()) {
-                return {
-                    handled: true,
-                    action: IInteractionStrategy_1.InteractionAction.NONE,
-                };
-            }
-            // Handle insertion finalization (exactly like desktop strategy)
-            if (this.interactionManager.insertionInteractionHandler
-                .insertionActive) {
-                const result = this.interactionManager.insertionInteractionHandler.finalizeInsertion();
-                if (result) {
-                    this.drawingToolsManager.update();
-                    this.disableMobileContinuousRendering();
-                    this.drawingToolsManager.viewport.render(); // Force immediate render after closing
-                    return {
-                        handled: true,
-                        action: IInteractionStrategy_1.InteractionAction.INSERT_END,
-                    };
-                }
-                else {
-                    // Only continue insertion if we can still insert points
-                    if (this.canInsertPoint()) {
-                        this.enableMobileContinuousRendering();
-                        this.interactionManager.insertionInteractionHandler.startInsertion(event);
-                        this.drawingToolsManager.update();
-                        return {
-                            handled: true,
-                            action: IInteractionStrategy_1.InteractionAction.INSERT_START,
-                        };
-                    }
-                    else {
-                        // Can't insert more points, stop insertion
-                        this.disableMobileContinuousRendering();
-                        return {
-                            handled: true,
-                            action: IInteractionStrategy_1.InteractionAction.NONE,
-                        };
-                    }
-                }
-            }
-            // Set last event in manager (important for insertion logic)
-            this.interactionManager.setLastEvent(event);
-            // Check if insertion is already active (need to finalize previous insertion)
-            if (this.interactionManager.insertionInteractionHandler
-                .insertionActive) {
-                const result = this.interactionManager.insertionInteractionHandler.finalizeInsertion();
-                if (result) {
-                    // Drawing was closed
-                    this.disableMobileContinuousRendering();
-                    this.drawingToolsManager.update();
-                    this.drawingToolsManager.viewport.render(); // Force immediate render after closing
-                    return {
-                        handled: true,
-                        action: IInteractionStrategy_1.InteractionAction.INSERT_END,
-                    };
-                }
-                else {
-                    // Only continue insertion if we can still insert points
-                    if (this.canInsertPoint()) {
-                        // Continue with new insertion
-                        this.interactionManager.startInsertion();
-                        this.drawingToolsManager.update();
-                        return {
-                            handled: true,
-                            action: IInteractionStrategy_1.InteractionAction.INSERT_START,
-                        };
-                    }
-                    else {
-                        // Can't insert more points, stop insertion
-                        this.disableMobileContinuousRendering();
-                        return {
-                            handled: true,
-                            action: IInteractionStrategy_1.InteractionAction.NONE,
-                        };
-                    }
-                }
-            }
-            // Start insertion immediately (like desktop strategy) - but only if allowed
-            if (this.canInsertPoint()) {
-                this.isPotentialInsertion = true; // Track that we started an insertion
-                this.enableMobileContinuousRendering();
-                this.interactionManager.startInsertion();
-                return {
-                    handled: true,
-                    action: IInteractionStrategy_1.InteractionAction.INSERT_START,
-                };
-            }
-            else {
-                // Can't insert points, return without action
-                return {
-                    handled: true,
-                    action: IInteractionStrategy_1.InteractionAction.NONE,
-                };
-            }
-        }
-        return this.handleSingleTouch(event, ray);
-    }
-    onPointerMove(event, ray) {
-        if (this.drawingToolsManager.closed) {
-            return { handled: false };
-        }
-        // Handle different move scenarios - check dragging FIRST
-        if (this.isDragging()) {
-            return this.handleTouchDrag(event, ray);
-        }
-        // Cancel long press if moved too far
-        if (this.hasTouchMovedBeyondThreshold(event)) {
-            this.touchHasMoved = true;
-            // If we have a selected point and aren't dragging yet, start dragging
-            if (!this.isDragging() &&
-                this.interactionManager.interactionManagerHelper
-                    .selectedPointIndices.length > 0) {
-                const selectedPoints = this.interactionManager.interactionManagerHelper
-                    .selectedPointIndices;
-                if (selectedPoints.length > 0) {
-                    // Start dragging the selected point(s)
-                    const draggingStarted = this.interactionManager.interactionManagerHelper.startDragging();
-                    if (draggingStarted) {
-                        this.isDraggingPoint = true;
-                        this.enableMobileCameraFreeze();
-                        this.cancelLongPress(); // Cancel long press since we're now dragging
-                        return this.handleTouchDrag(event, ray);
-                    }
-                }
-            }
-            // Cancel insertion if this was a potential insertion and we've started dragging
-            // (indicating user wants to drag, not insert)
-            if (this.isPotentialInsertion &&
-                this.interactionManager.insertionInteractionHandler
-                    .insertionActive) {
-                // Check if we've started dragging - if so, cancel the insertion
-                if (this.isDragging() || this.isDraggingPoint) {
-                    this.interactionManager.insertionInteractionHandler.stopInsertion();
-                    this.disableMobileContinuousRendering();
-                    this.isPotentialInsertion = false;
-                }
-            }
-            this.cancelLongPress();
-        }
-        if (this.interactionManager.insertionInteractionHandler.insertionActive) {
-            return this.handleInsertionMove(event, ray);
-        }
-        // Update cursor for hover feedback
-        this.updateCursor();
-        return this.handleTouchHover(event, ray);
-    }
-    onPointerUp(event, ray) {
-        if (this.drawingToolsManager.closed) {
-            return { handled: false };
-        }
-        this.cancelLongPress();
-        // Clean up drag state
-        if (this.isDraggingPoint) {
-            // Call helper.onUp() to handle closing logic (like desktop)
-            this.interactionManager.interactionManagerHelper.onUp();
-            this.isDraggingPoint = false;
-            this.disableMobileCameraFreeze(); // Remove mobile camera freeze
-            // Camera freeze will be automatically removed by the interaction manager
-        }
-        const touchDuration = Date.now() - this.touchStartTime;
-        const touchDistance = this.getTouchDistance(event);
-        // Determine gesture type
-        if (this.isLongPress) {
-            return this.handleLongPress(event, ray);
-        }
-        if (touchDistance < this.config.touchSettings.tapThreshold) {
-            return this.handleTap(event, ray, touchDuration);
-        }
-        if (this.isDragging()) {
-            return this.handleDragEnd(event, ray);
-        }
-        // Clean up camera freeze if still active from point selection but no drag occurred
-        // (This handles cases where user touches a point but just taps without moving)
-        if (!this.isDraggingPoint) {
-            this.disableMobileCameraFreeze();
-        }
-        return { handled: true, action: IInteractionStrategy_1.InteractionAction.NONE };
-    }
-    onPointerOut() {
-        this.cancelLongPress();
-        // Clean up camera freeze if pointer leaves the area
-        this.disableMobileCameraFreeze();
-        return {
-            handled: true,
-            action: IInteractionStrategy_1.InteractionAction.NONE,
-        };
-    }
-    startLongPressDetection(event, ray) {
-        // Check if we're starting long press on a point
-        const distances = this.drawingToolsManager.geometryMathManager.checkPointDistances(ray, this.drawingToolsManager.positionArray);
-        const nearPoint = this.findNearestTouchTarget(distances);
-        this.longPressPoint = nearPoint; // Store the point for potential deletion
-        this.longPressTimer = window.setTimeout(() => {
-            this.isLongPress = true;
-            this.handleLongPressStart(event, ray);
-        }, this.config.touchSettings.longPressDuration);
-    }
-    cancelLongPress() {
-        if (this.longPressTimer) {
-            clearTimeout(this.longPressTimer);
-            this.longPressTimer = undefined;
-        }
-        this.longPressPoint = undefined; // Reset the long press point
-    }
-    isMultiTouch(event) {
-        // Check if there are multiple active pointers
-        // This would require tracking active pointers
-        return false; // Simplified for now
-    }
-    handleSingleTouch(event, ray) {
-        // Check if touching near a point for potential drag
-        const distances = this.drawingToolsManager.geometryMathManager.checkPointDistances(ray, this.drawingToolsManager.positionArray);
-        // Mobile-specific point selection with larger touch targets
-        const nearPoint = this.findNearestTouchTarget(distances);
-        if (nearPoint !== undefined) {
-            // Check if this is the first point and we can close
-            if (nearPoint === 0 && this.canCloseDrawing()) {
-                // Close the drawing by setting closeLoop and calling update
-                this.drawingToolsManager.geometryState.closeLoop = true;
-                // Emit GEOMETRY_CHANGED event for closing
-                viewer_shared_services_1.EventEngine.instance.emitEvent(viewer_shared_services_1.EVENTTYPE_DRAWING_TOOLS.GEOMETRY_CHANGED, {
-                    viewportId: this.drawingToolsManager.viewport.id,
-                    drawingToolId: this.drawingToolsManager.uuid,
-                    points: this.drawingToolsManager.geometryState.getPointsData(),
-                    temporary: false,
-                    fromHistory: false,
-                });
-                this.disableMobileContinuousRendering();
-                this.disableMobileCameraFreeze(); // Clean up camera freeze since interaction is complete
-                this.drawingToolsManager.viewport.render(); // Force immediate render after closing
-                return {
-                    handled: true,
-                    action: IInteractionStrategy_1.InteractionAction.INSERT_END,
-                };
-            }
-            else {
-                // Not first point or can't close, just select for interaction (drag/delete)
-                // Select the point but don't start dragging yet
-                // This allows taps and long press to still work
-                this.selectPointForInteraction(nearPoint, ray);
-                return {
-                    handled: true,
-                    action: IInteractionStrategy_1.InteractionAction.SELECT,
-                    preventDefault: true,
-                };
-            }
-        }
-        return { handled: true, action: IInteractionStrategy_1.InteractionAction.NONE };
-    }
-    handleMultiTouch(event, ray) {
-        // Handle two-finger gestures for camera control or multi-select
-        return {
-            handled: true,
-            action: IInteractionStrategy_1.InteractionAction.NONE,
-            stopPropagation: true,
-        };
-    }
-    handleTap(event, ray, duration) {
-        const now = Date.now();
-        // Check for double tap
-        if (now - this.lastTapTime <
-            this.config.touchSettings.doubleTapInterval) {
-            this.tapCount++;
-        }
-        else {
-            this.tapCount = 1;
-        }
-        this.lastTapTime = now;
-        if (this.tapCount === 2) {
-            return this.handleDoubleTap(event, ray);
-        }
-        return this.handleSingleTap(event, ray);
-    }
-    handleSingleTap(event, ray) {
-        // Check if we're tapping on an existing point first
-        const distances = this.drawingToolsManager.geometryMathManager.checkPointDistances(ray, this.drawingToolsManager.positionArray);
-        const nearPoint = this.findNearestTouchTarget(distances);
-        // Get selected points from the touch down event
-        const selectedPoints = this.interactionManager.interactionManagerHelper
-            .selectedPointIndices;
-        // If we're in insertion mode and tapped on the first point, close the drawing
-        // Use nearPoint instead of selectedPoints since selectedPoints might be cleared
-        if (nearPoint !== undefined &&
-            nearPoint === 0 &&
-            this.interactionManager.insertionInteractionHandler
-                .insertionActive &&
-            this.canCloseDrawing()) {
-            // Close the drawing by tapping the first point
-            this.interactionManager.insertionInteractionHandler.stopInsertion();
-            this.drawingToolsManager.geometryState.closeLoop = true;
-            this.disableMobileContinuousRendering();
-            // Emit GEOMETRY_CHANGED event instead of calling update directly
-            viewer_shared_services_1.EventEngine.instance.emitEvent(viewer_shared_services_1.EVENTTYPE_DRAWING_TOOLS.GEOMETRY_CHANGED, {
-                viewportId: this.drawingToolsManager.viewport.id,
-                drawingToolId: this.drawingToolsManager.uuid,
-                points: this.drawingToolsManager.geometryState.getPointsData(),
-                temporary: false,
-                fromHistory: false,
-            });
-            this.drawingToolsManager.viewport.render(); // Force immediate render after closing
-            return {
-                handled: true,
-                action: IInteractionStrategy_1.InteractionAction.INSERT_END,
-            };
-        }
-        // Handle insertion finalization (mobile modification of desktop strategy)
-        // On mobile, we need to finalize points but keep insertion active for continuous drawing
-        if (this.interactionManager.insertionInteractionHandler.insertionActive) {
-            const result = this.interactionManager.insertionInteractionHandler.finalizeInsertion();
-            if (result) {
-                // Drawing was completed/closed
-                // Emit GEOMETRY_CHANGED event instead of calling update directly
-                viewer_shared_services_1.EventEngine.instance.emitEvent(viewer_shared_services_1.EVENTTYPE_DRAWING_TOOLS.GEOMETRY_CHANGED, {
-                    viewportId: this.drawingToolsManager.viewport.id,
-                    drawingToolId: this.drawingToolsManager.uuid,
-                    points: this.drawingToolsManager.geometryState.getPointsData(),
-                    temporary: false,
-                    fromHistory: false,
-                });
-                this.disableMobileContinuousRendering();
-                this.drawingToolsManager.viewport.render(); // Force immediate render after closing
-                return {
-                    handled: true,
-                    action: IInteractionStrategy_1.InteractionAction.INSERT_END,
-                };
-            }
-            else {
-                // Point was added but drawing not complete
-                // On mobile: restart insertion immediately to keep continuous drawing
-                if (this.canInsertPoint()) {
-                    try {
-                        this.enableMobileContinuousRendering();
-                        this.interactionManager.insertionInteractionHandler.startInsertion(event);
-                        // Don't call update() here - let GEOMETRY_CHANGED events handle it
-                        return {
-                            handled: true,
-                            action: IInteractionStrategy_1.InteractionAction.NONE, // Avoid triggering action system that might reset state
-                        };
-                    }
-                    catch (error) {
-                        console.warn("Failed to restart insertion:", error);
-                        // Insertion restart failed, continue with fallback
-                    }
-                }
-                else {
-                    // Can't insert more points, stop insertion
-                    this.disableMobileContinuousRendering();
-                    return {
-                        handled: true,
-                        action: IInteractionStrategy_1.InteractionAction.NONE,
-                    };
-                }
-            }
-        }
-        // Start insertion if not active (like desktop strategy) - but only if allowed
-        if (!this.interactionManager.insertionInteractionHandler
-            .insertionActive &&
-            this.canInsertPoint()) {
-            try {
-                this.enableMobileContinuousRendering();
-                this.interactionManager.insertionInteractionHandler.startInsertion(event);
-                this.drawingToolsManager.update();
-                return {
-                    handled: true,
-                    action: IInteractionStrategy_1.InteractionAction.NONE, // Avoid triggering action system that might reset state
-                };
-            }
-            catch (error) {
-                // Insertion failed, return default action
-            }
-        }
-        return { handled: true, action: IInteractionStrategy_1.InteractionAction.SELECT };
-    }
-    handleDoubleTap(event, ray) {
-        // Double tap for special actions like finishing insertion or deleting
-        this.tapCount = 0;
-        const distances = this.drawingToolsManager.geometryMathManager.checkPointDistances(ray, this.drawingToolsManager.positionArray);
-        const nearPoint = this.findNearestTouchTarget(distances);
-        if (nearPoint !== undefined) {
-            // Double tap on point could delete it
-            return this.handlePointDeletion(nearPoint);
-        }
-        // Double tap in empty space could finish current operation
-        if (this.interactionManager.insertionInteractionHandler.insertionActive) {
-            this.interactionManager.stopInsertion();
-            this.disableMobileContinuousRendering();
-            return {
-                handled: true,
-                action: IInteractionStrategy_1.InteractionAction.INSERT_END,
-            };
-        }
-        return { handled: true, action: IInteractionStrategy_1.InteractionAction.NONE };
-    }
-    handleLongPressStart(event, ray) {
-        // Long press could start context menu or multi-select mode
-        // Provide haptic feedback if available and enabled
-        this.triggerHapticFeedback();
-    }
-    handleLongPress(event, ray) {
-        // Long press actions - delete point if on existing point
-        this.triggerHapticFeedback();
-        // Check if we have a stored point from the long press start
-        if (this.longPressPoint !== undefined) {
-            // Delete the point by index directly to avoid ray precision issues
-            this.interactionManager.deletionInteractionHandler.deletePointByIndex(this.longPressPoint);
-            // Reset long press state
-            this.longPressPoint = undefined;
-            this.isLongPress = false;
-            // Remove camera freeze since long press interaction is complete
-            this.disableMobileCameraFreeze();
-            return {
-                handled: true,
-                action: IInteractionStrategy_1.InteractionAction.DELETE,
-                preventDefault: true,
-            };
-        }
-        // If no point to delete, remove camera freeze and return context menu action
-        this.disableMobileCameraFreeze();
-        return { handled: true, action: IInteractionStrategy_1.InteractionAction.CONTEXT_MENU };
-    }
-    triggerHapticFeedback() {
-        if (this.config.touchSettings.enableHapticFeedback &&
-            "vibrate" in navigator) {
-            navigator.vibrate(this.config.touchSettings.hapticPattern);
-        }
-    }
-    handleTouchDrag(event, ray) {
-        // Touch drag for moving points - similar to mouse drag but with touch-specific behavior
-        this.moveDraggedPoints(ray);
-        return {
-            handled: true,
-            action: IInteractionStrategy_1.InteractionAction.DRAG_MOVE,
-            preventDefault: true,
-        };
-    }
-    handleInsertionMove(event, ray) {
-        // Handle moving insertion point on mobile
-        this.interactionManager.insertionInteractionHandler.onMove(ray);
-        return {
-            handled: true,
-            action: IInteractionStrategy_1.InteractionAction.INSERT_MOVE,
-        };
-    }
-    handleTouchHover(event, ray) {
-        // Mobile doesn't have true hover, but we can update visual feedback
-        return { handled: true, action: IInteractionStrategy_1.InteractionAction.HOVER };
-    }
-    handleDragEnd(event, ray) {
-        // End drag operation - the interaction manager will handle cleanup
-        return {
-            handled: true,
-            action: IInteractionStrategy_1.InteractionAction.DRAG_END,
-        };
-    }
-    handlePointDeletion(pointIndex) {
-        // Handle point deletion with confirmation or undo option
-        return {
-            handled: true,
-            action: IInteractionStrategy_1.InteractionAction.DELETE,
-        };
-    }
-    hasTouchMovedBeyondThreshold(event) {
-        const distance = this.getTouchDistance(event);
-        return distance > this.config.touchSettings.tapMovementThreshold;
-    }
-    getTouchDistance(event) {
-        const dx = event.clientX - this.touchStartPosition.x;
-        const dy = event.clientY - this.touchStartPosition.y;
-        return Math.sqrt(dx * dx + dy * dy);
-    }
-    findNearestTouchTarget(distances) {
-        // Find nearest point with larger touch target area for mobile
-        // Use a larger threshold for point selection to make it easier to grab points
-        const touchThreshold = this.config.touchSettings.minTouchTargetSize * 2; // Double the touch target for easier point selection
-        if (distances && distances.length > 0) {
-            // Find the closest point within the mobile touch threshold
-            for (let i = 0; i < distances.length; i++) {
-                if (distances[i] && distances[i].distance < touchThreshold) {
-                    return distances[i].index; // Return the actual point index, not the array index
-                }
-            }
-        }
-        return undefined;
-    }
-    isDragging() {
-        return this.interactionManager.interactionManagerHelper.dragging;
-    }
-    selectPointForInteraction(pointIndex, ray) {
-        const helper = this.interactionManager.interactionManagerHelper;
-        // Just select the point for potential interaction, but don't start dragging
-        const distances = [{ index: pointIndex, distance: 0 }];
-        // Set the hovered point and select it
-        helper.checkHover(distances, ray);
-        helper.selectPoint(distances);
-        // Enable camera freeze immediately when touching a point since user might move it
-        this.enableMobileCameraFreeze();
-        // Don't start dragging here - that will happen on movement
-    }
-    moveDraggedPoints(ray) {
-        const helper = this.interactionManager.interactionManagerHelper;
-        helper.moveSelectedPoints(ray);
-    }
-    updateCursor() {
-        // Mobile devices don't typically show cursor changes, but we can update
-        // for hybrid devices (tablets with mouse support)
-        if (this.interactionManager.interactionManagerHelper.dragging) {
-            document.body.style.cursor = "grabbing";
-        }
-        else if (this.interactionManager.interactionManagerHelper.hoveredPoint !==
-            undefined) {
-            document.body.style.cursor = "pointer";
-        }
-        else {
-            document.body.style.cursor = "default";
-        }
-    }
-    /**
-     * Enable continuous rendering for mobile insertions to ensure immediate visual feedback
-     */
-    enableMobileContinuousRendering() {
-        if (!this.mobileContinuousRenderingFlag) {
-            this.mobileContinuousRenderingFlag =
-                this.drawingToolsManager.viewport.addFlag(viewer_1.FLAG_TYPE.CONTINUOUS_RENDERING);
-        }
-    }
-    /**
-     * Disable continuous rendering for mobile insertions to save performance
-     */
-    disableMobileContinuousRendering() {
-        if (this.mobileContinuousRenderingFlag) {
-            this.drawingToolsManager.viewport.removeFlag(this.mobileContinuousRenderingFlag);
-            this.mobileContinuousRenderingFlag = undefined;
-        }
-    }
-    /**
-     * Check if the drawing can be closed (same logic as InsertionInteractionHandler)
-     */
-    canCloseDrawing() {
-        const geometryState = this.drawingToolsManager.geometryState;
-        const settings = this.drawingToolsManager.settings;
-        const pointCount = geometryState.getPointCount();
-        // For closing, check current point count, not point count - 1
-        const checkNumberOfPointsResult = geometryState.checkNumberOfPoints(pointCount);
-        const canBeClosed = settings.geometry.mode === "lines" &&
-            pointCount > 3 &&
-            checkNumberOfPointsResult;
-        const shouldBeClosed = settings.geometry.close === true &&
-            geometryState.closeLoop === false &&
-            settings.geometry.autoClose === false;
-        return canBeClosed && shouldBeClosed;
-    }
-    /**
-     * Check if insertion should be allowed
-     * Returns false if drawing is closed or max points reached
-     */
-    canInsertPoint() {
-        // Don't allow insertion if drawing tools manager is closed
-        if (this.drawingToolsManager.closed) {
-            return false;
-        }
-        // Don't allow insertion if the loop is already closed
-        if (this.drawingToolsManager.geometryState.closeLoop) {
-            return false;
-        }
-        // Don't allow insertion if we can't add more points (max points reached)
-        if (!this.drawingToolsManager.geometryManager.canAddPoint()) {
-            return false;
-        }
-        return true;
-    }
-    /**
-     * Enable camera freeze for mobile point dragging
-     */
-    enableMobileCameraFreeze() {
-        if (!this.mobileCameraFreezeFlag) {
-            this.mobileCameraFreezeFlag =
-                this.drawingToolsManager.viewport.addFlag(viewer_1.FLAG_TYPE.CAMERA_FREEZE);
-        }
-    }
-    /**
-     * Disable camera freeze for mobile point dragging
-     */
-    disableMobileCameraFreeze() {
-        if (this.mobileCameraFreezeFlag) {
-            this.drawingToolsManager.viewport.removeFlag(this.mobileCameraFreezeFlag);
-            this.mobileCameraFreezeFlag = undefined;
-        }
-    }
-}
-exports.MobileInteractionStrategy = MobileInteractionStrategy;
-//# sourceMappingURL=MobileInteractionStrategy.js.map