@leapfrog/interactive-canvas 2.0.25-beta-13 → 2.0.25-beta-15

package/dist/abstract-interactive-canvas.d.ts

@@ -340,8 +340,10 @@ export declare abstract class AbstractInteractiveCanvas implements IInteractiveC
      * @inheritDoc
      */
     cloneObject(sourceObject: FabricObject, objectData: CanvasObjectData): Promise<void>;
+    private redrawScheduled;
     /**
      * Redraw the canvas.
+     * Uses requestAnimationFrame to batch multiple redraw calls into a single render.
      */
     redraw(): void;
     syncObjectList(): void;

package/dist/interactive-canvas.d.ts

@@ -20,7 +20,6 @@ export declare class InteractiveCanvas extends AbstractInteractiveCanvas {
      */
     redo(): Promise<void>;
     private onFabricSelectionChanged;
-    private enterTextSelectionModeIfRequired;
     private onTextEditing;
     private onDoubleClick;
 }

package/dist/interactive-canvas.es.js

@@ -232,9 +232,15 @@ class ResizeCanvasLayoutFunction {
         const targetHeight = increase.withSize(increase.width, baseDimensions.height + increase.height);
         if (currentDimensions.height !== targetHeight.height) {
             canvas.setDimensions(targetHeight);
+            canvas.getObjectsInternal().forEach((object) => {
+                var _a;
+                const canvasObj = canvas.getObjectsByTypeInternal(object.type).find(o => o.getId() === object.getId());
+                if (canvasObj && (((_a = canvasObj.isPinToBottom) === null || _a === void 0 ? void 0 : _a.call(canvasObj)) || object.top > currentDimensions.heightPx * 0.5)) {
+                    object.setCoords();
+                }
+            });
+            canvas.redraw();
         }
-        canvas.getObjectsInternal().forEach((object) => object.setCoords());
-        canvas.redraw();
     }
 }
 
@@ -252,38 +258,6 @@ class RepositionBackgroundsLayoutFunction {
     }
 }
 
-class AdvancedLayoutManager extends AbstractLayoutManager {
-    constructor(canvas) {
-        super(canvas);
-        this.key = LayoutManager.ADVANCED;
-        this.pinToBottom = new PinToBottomLayoutFunction();
-        this.redrawAll = new RedrawAllLayoutFunction();
-        this.repositionBorders = new RepositionBordersLayoutFunction();
-        this.repositionCutoffs = new RepositionCutoffsLayoutFunction();
-        this.repositionBackgrounds = new RepositionBackgroundsLayoutFunction();
-        this.resizeCanvas = new ResizeCanvasLayoutFunction();
-    }
-    onCanvasDimensionsChange() {
-        this.pinToBottom.execute(this.canvas);
-        this.repositionCutoffs.execute(this.canvas);
-        this.repositionBorders.execute(this.canvas);
-        this.repositionBackgrounds.execute(this.canvas);
-        this.redrawAll.execute(this.canvas);
-    }
-    onTextChange() {
-        this.resizeCanvas.execute(this.canvas);
-    }
-    onObjectListChange() {
-        this.redrawAll.execute(this.canvas);
-    }
-}
-
-class UpdateObjectDimensionsLayoutFunction {
-    execute(canvas) {
-        canvas.getObjectsInternal().forEach((object) => object.updateDimensions());
-    }
-}
-
 const MIN_MAGNITUDE = 1;
 class StackObjectsLayoutFunction {
     execute(canvas) {
@@ -296,7 +270,6 @@ class StackObjectsLayoutFunction {
         const footerObjects = objects[0];
         const bodyObjects = objects[1];
         const bodyWidth = canvasDimensions.widthPx - canvasMargin.right - canvasMargin.left;
-        canvas.redraw();
         //Make one pass and set the widths of all elements. This will force objects with dynamic heights (like text) to take on their necessary height before trying to lay them out.
         this.applyWidths(allObjects, bodyWidth);
         const bodyRows = this.getRows(bodyObjects);
@@ -383,7 +356,11 @@ class StackObjectsLayoutFunction {
             object.setPosition({
                 width: actualWidth
             });
-            object.updateDimensions();
+        });
+        _(objects).forEach((object) => {
+            if (object.getType() !== ObjectType.VERTICAL_RULE) {
+                object.updateDimensions();
+            }
         });
     }
     adjustCanvasSize(canvas, requiredHeight) {
@@ -444,6 +421,73 @@ class StackObjectsLayoutFunction {
     }
 }
 
+var ObjectType;
+(function (ObjectType) {
+    ObjectType["TEXT"] = "TEXT";
+    ObjectType["BORDER"] = "BORDER";
+    ObjectType["IMAGE"] = "IMAGE";
+    ObjectType["RECTANGLE"] = "RECTANGLE";
+    ObjectType["LIBRARY_IMAGE"] = "LIBRARY_IMAGE";
+    ObjectType["CUTOFF"] = "CUTOFF";
+    ObjectType["VERTICAL_RULE"] = "VERTICAL_RULE";
+    ObjectType["HORIZONTAL_RULE"] = "HORIZONTAL_RULE";
+    ObjectType["RICH_TEXT"] = "RICH_TEXT";
+    ObjectType["BACKGROUND_IMAGE"] = "BACKGROUND_IMAGE";
+})(ObjectType || (ObjectType = {}));
+
+class AdvancedLayoutManager extends AbstractLayoutManager {
+    constructor(canvas) {
+        super(canvas);
+        this.key = LayoutManager.ADVANCED;
+        this.pinToBottom = new PinToBottomLayoutFunction();
+        this.redrawAll = new RedrawAllLayoutFunction();
+        this.repositionBorders = new RepositionBordersLayoutFunction();
+        this.repositionCutoffs = new RepositionCutoffsLayoutFunction();
+        this.repositionBackgrounds = new RepositionBackgroundsLayoutFunction();
+        this.resizeCanvas = new ResizeCanvasLayoutFunction();
+        this.stackObjects = new StackObjectsLayoutFunction();
+        this.dimensionsLayoutScheduled = false;
+    }
+    onCanvasDimensionsChange() {
+        if (this.dimensionsLayoutScheduled) {
+            return;
+        }
+        this.dimensionsLayoutScheduled = true;
+        Promise.resolve().then(() => {
+            this.pinToBottom.execute(this.canvas);
+            this.dimensionChange();
+            this.repositionCutoffs.execute(this.canvas);
+            this.repositionBorders.execute(this.canvas);
+            this.repositionBackgrounds.execute(this.canvas);
+            this.redrawAll.execute(this.canvas);
+            this.dimensionsLayoutScheduled = false;
+        });
+    }
+    onTextChange() {
+        this.resizeCanvas.execute(this.canvas);
+    }
+    onObjectListChange() {
+        this.redrawAll.execute(this.canvas);
+    }
+    dimensionChange() {
+        const canvasMargin = this.canvas.getMargin();
+        const canvasDimensions = this.canvas.getDimensions();
+        const allObjects = this.canvas.getObjectsByTypesInternal(ObjectType.TEXT, ObjectType.RICH_TEXT, 
+        //ObjectType.IMAGE,
+        ObjectType.RECTANGLE, ObjectType.VERTICAL_RULE, ObjectType.HORIZONTAL_RULE);
+        const bodyWidth = canvasDimensions.widthPx - canvasMargin.right - canvasMargin.left;
+        this.canvas.redraw();
+        //Make one pass and set the widths of all elements. This will force objects with dynamic heights (like text) to take on their necessary height before trying to lay them out.
+        this.stackObjects.applyWidths(allObjects, bodyWidth);
+    }
+}
+
+class UpdateObjectDimensionsLayoutFunction {
+    execute(canvas) {
+        canvas.getObjectsInternal().forEach((object) => object.updateDimensions());
+    }
+}
+
 class StandardLayoutManager extends AbstractLayoutManager {
     constructor(canvas) {
         super(canvas);
@@ -456,6 +500,7 @@ class StandardLayoutManager extends AbstractLayoutManager {
         this.repositionBackgrounds = new RepositionBackgroundsLayoutFunction();
         this.stackObjects = new StackObjectsLayoutFunction();
         this.updateObjectDimensions = new UpdateObjectDimensionsLayoutFunction();
+        this.layoutBatchScheduled = false;
     }
     /**
      * @override
@@ -497,12 +542,19 @@ class StandardLayoutManager extends AbstractLayoutManager {
         this.stackAndRedraw();
     }
     stackAndRedraw() {
-        this.stackObjects.execute(this.canvas);
-        this.repositionCutoffs.execute(this.canvas);
-        this.repositionBorders.execute(this.canvas);
-        this.repositionBackgrounds.execute(this.canvas);
-        this.updateObjectDimensions.execute(this.canvas);
-        this.redrawAll.execute(this.canvas);
+        if (this.layoutBatchScheduled) {
+            return;
+        }
+        this.layoutBatchScheduled = true;
+        Promise.resolve().then(() => {
+            this.stackObjects.execute(this.canvas);
+            this.repositionCutoffs.execute(this.canvas);
+            this.repositionBorders.execute(this.canvas);
+            this.repositionBackgrounds.execute(this.canvas);
+            this.updateObjectDimensions.execute(this.canvas);
+            this.redrawAll.execute(this.canvas);
+            this.layoutBatchScheduled = false;
+        });
     }
 }
 
@@ -969,7 +1021,7 @@ class AbstractCanvasObject {
         //no-op
     }
     preventLeavingCanvas() {
-        const overflow = this.getCanvasOverflow();
+        const overflow = this.getCanvasOverflowForBoundaryPrevention();
         if (overflow.hasOverflow) {
             const adjustX = overflow.left || -overflow.right;
             const adjustY = overflow.top || -overflow.bottom;
@@ -995,6 +1047,29 @@ class AbstractCanvasObject {
             hasOverflow: top > 0 || right > 0 || bottom > 0 || left > 0
         };
     }
+    getCanvasOverflowForBoundaryPrevention() {
+        // Use a simpler bounding box calculation for boundary prevention
+        // to avoid issues with decorative elements (like ordered list markers)
+        // extending beyond the main object bounds
+        const bound = this.getSimpleBoundingBox();
+        const canvasDimensions = this.canvas.getDimensions();
+        const top = Math.max(0, 0 - bound.top);
+        const right = Math.max(0, bound.left + bound.width - canvasDimensions.widthPx);
+        const bottom = Math.max(0, bound.top + bound.height - canvasDimensions.heightPx);
+        const left = Math.max(0, 0 - bound.left);
+        return {
+            top: top,
+            right: right,
+            bottom: bottom,
+            left: left,
+            hasOverflow: top > 0 || right > 0 || bottom > 0 || left > 0
+        };
+    }
+    getSimpleBoundingBox() {
+        // Default implementation: use normal bounding box
+        // Subclasses can override this to provide simpler bounds for drag boundary checks
+        return this.getBoundingBox();
+    }
     centerHorizontallyInternal() {
         const canvasWidth = this.canvas.getDimensions().widthPx;
         const objectWidth = this.getDimensions().width.px;
@@ -1042,7 +1117,8 @@ class AbstractCanvasObject {
             mt: options.allowScale,
             mr: options.allowScale,
             mb: options.allowScale,
-            mtr: options.allowRotate
+            mtr: options.allowRotate,
+            // dragControl: options.allowMove // Show drag control when movement is allowed
         });
     }
 }
@@ -1763,32 +1839,32 @@ class RichText extends Image {
     }
 }
 
-var ObjectType;
-(function (ObjectType) {
-    ObjectType["TEXT"] = "TEXT";
-    ObjectType["BORDER"] = "BORDER";
-    ObjectType["IMAGE"] = "IMAGE";
-    ObjectType["RECTANGLE"] = "RECTANGLE";
-    ObjectType["LIBRARY_IMAGE"] = "LIBRARY_IMAGE";
-    ObjectType["CUTOFF"] = "CUTOFF";
-    ObjectType["VERTICAL_RULE"] = "VERTICAL_RULE";
-    ObjectType["HORIZONTAL_RULE"] = "HORIZONTAL_RULE";
-    ObjectType["RICH_TEXT"] = "RICH_TEXT";
-    ObjectType["BACKGROUND_IMAGE"] = "BACKGROUND_IMAGE";
-})(ObjectType || (ObjectType = {}));
-
 class Text extends AbstractCanvasObject {
     constructor(canvas, fabricObject, persistedField) {
         super(ObjectType.TEXT, canvas, fabricObject, persistedField);
+        this.notifyCanvasTimeout = null;
+        this.NOTIFY_DELAY_MS = 150; // Debounce canvas notifications
         this.canvas = canvas;
         this.fontLibrary = canvas.getFontLibrary();
         this.baseComponentHeight = this.fabricObject.height;
         this.text$ = new BehaviorSubject(this.fabricObject.text);
         this.data.userText = this.fabricObject.text;
         this.textSelection$ = new BehaviorSubject(new TextSelection(this.fabricObject, this.fontLibrary));
-        this.fabricObject.set({ strokeWidth: 0 });
+        this.fabricObject.set({
+            strokeWidth: 0,
+            perPixelTargetFind: false, // Disable per-pixel detection for this object
+            padding: 0 // Add padding for larger hover area (Fabric v7 compatibility)
+        });
         this.fabricObject.on("changed", () => this.onTextChange());
         this.fabricObject.on("selection:changed", () => this.onSelectionChange());
+        // Note: Removed containsPoint override to allow Fabric's default bounding box
+        // detection with padding to work properly for hover detection
+        this.fabricObject.on("mousedown", (e) => {
+            var _a;
+            if (!this.fabricObject.isEditing) {
+                (_a = e.e) === null || _a === void 0 ? void 0 : _a.preventDefault();
+            }
+        });
         this.applyBulletListMonkeyPatches();
     }
     /**
@@ -2140,11 +2216,25 @@ class Text extends AbstractCanvasObject {
     getBulletMargin() {
         if (!this.isBulleted())
             return 0;
-        let fontSize = 0;
-        each(this.fabricObject._textLines, (textLine, lineIndex) => {
-            fontSize = Math.max(fontSize, this.fabricObject.getValueOfPropertyAt(lineIndex, 0, "fontSize"));
-        });
-        return fontSize * 0.6;
+        try {
+            let fontSize = 0;
+            each(this.fabricObject._textLines, (textLine, lineIndex) => {
+                const size = this.fabricObject.getValueOfPropertyAt(lineIndex, 0, "fontSize");
+                // Sanity check fontSize
+                if (isFinite(size) && size > 0 && size < 1000) {
+                    fontSize = Math.max(fontSize, size);
+                }
+            });
+            // Additional safety check
+            if (!isFinite(fontSize) || fontSize < 0 || fontSize > 1000) {
+                return 0;
+            }
+            return fontSize * 0.6;
+        }
+        catch (e) {
+            console.warn('Error calculating bullet margin:', e);
+            return 0;
+        }
     }
     /**
      * @override
@@ -2154,10 +2244,35 @@ class Text extends AbstractCanvasObject {
         if (!this.isOrderedList())
             return 0;
         const orderedListMarkerEntities = this.fabricObject._orderedListMarkerEntities;
-        let maxValue = max((orderedListMarkerEntities !== null && orderedListMarkerEntities !== void 0 ? orderedListMarkerEntities : [])
-            .filter((x) => !!x)
-            .map((x) => x.getBoundingRect().width));
-        return maxValue ? (maxValue * 1.2) : 0;
+        try {
+            const widths = (orderedListMarkerEntities !== null && orderedListMarkerEntities !== void 0 ? orderedListMarkerEntities : [])
+                .filter((x) => !!x)
+                .map((x) => {
+                var _a;
+                try {
+                    const rect = x.getBoundingRect();
+                    const width = (_a = rect === null || rect === void 0 ? void 0 : rect.width) !== null && _a !== void 0 ? _a : 0;
+                    // Sanity check: if width is invalid, return 0
+                    if (!isFinite(width) || width < 0 || width > 1000) {
+                        return 0;
+                    }
+                    return width;
+                }
+                catch (e) {
+                    return 0;
+                }
+            });
+            const maxValue = max(widths);
+            // Additional safety: ensure maxValue is a valid number
+            if (!maxValue || !isFinite(maxValue) || maxValue < 0 || maxValue > 1000) {
+                return 0;
+            }
+            return maxValue * 1.2;
+        }
+        catch (e) {
+            console.warn('Error calculating ordered list margin:', e);
+            return 0;
+        }
     }
     /**
      * @override
@@ -2398,6 +2513,7 @@ class Text extends AbstractCanvasObject {
                                     lockMovementY: true,
                                     hasControls: false,
                                     selectable: false,
+                                    // evented: false, // Don't capture mouse events - allows clicks to pass through to textbox
                                     originX: "left",
                                     originY: "top"
                                 });
@@ -2492,7 +2608,7 @@ class Text extends AbstractCanvasObject {
                     text: `${lineNumber}.`
                 });
             }
-            if (method === "fillText" && this.fabricObject.left <= 3) {
+            if (method === "fillText" && this.isOrderedList() && this.fabricObject.left <= 3) {
                 left = left + this.getOrderedListMargin();
             }
             this.fabricObject.dirty = true;
@@ -2504,13 +2620,24 @@ class Text extends AbstractCanvasObject {
      * @inheritDoc
      */
     updateFabricObjectBehavior() {
+        // DON'T call super.updateFabricObjectBehavior() for textboxes
+        // because it locks movement which interferes with text editing in Fabric v7
         super.updateFabricObjectBehavior();
         const profile = this.canvas.getProfile();
         const allowManualPositioning = !this.canvas.getLayoutManager().isEnforcedPositioning;
+        // For textboxes, we keep them moveable but hide all controls except drag control
+        // This allows text editing to work properly while still supporting drag via the icon
         this.fabricObject.set({
+            lockMovementX: false, // Allow dragging
+            lockMovementY: false, // Allow dragging
             lockScalingY: true,
             lockScalingX: this.isPinToBottom(),
-            lockScalingFlip: true
+            lockScalingFlip: true,
+            lockRotation: true,
+            selectable: true,
+            editable: false, // Only enable on double-click
+            hoverCursor: "move", // Show move cursor by default
+            moveCursor: "move",
         });
         this.fabricObject.setControlsVisibility({
             tl: false,
@@ -2520,35 +2647,64 @@ class Text extends AbstractCanvasObject {
             ml: allowManualPositioning && profile.allowScale && !this.isPinToBottom(),
             mt: false,
             mr: allowManualPositioning && profile.allowScale && !this.isPinToBottom(),
-            mb: false
+            mb: false,
+            mtr: false,
         });
         this.redraw();
     }
     onTextChange() {
         this.data.userText = this.fabricObject.text;
         this.text$.next(this.fabricObject.text);
-        if (this.getBoundingBox().width > this.canvas.getDimensions().widthPx) {
-            this.fabricObject.set({ left: 0, width: this.canvas.getDimensions().widthPx });
-            this.redraw();
+        // Only check width bounds if text is close to canvas edge (performance optimization)
+        const currentLeft = this.fabricObject.left || 0;
+        const canvasWidth = this.canvas.getDimensions().widthPx;
+        // Skip expensive getBoundingBox if object is clearly within bounds
+        if (currentLeft + (this.fabricObject.width || 0) > canvasWidth * 0.9) {
+            if (this.getBoundingBox().width > canvasWidth) {
+                this.fabricObject.set({ left: 0, width: canvasWidth });
+                this.redraw();
+            }
         }
     }
     onDelete() {
         this.removeBullets();
     }
     onSelectionChange() {
-        this.updateTextSelection();
+        this.updateTextSelection(false);
     }
     hasTextSelection() {
         return this.canvas.getSelection().isText && this.textSelection$.value.length > 0;
     }
-    updateTextSelection() {
+    updateTextSelection(notifyCanvas = true) {
         if (this.canvas.headless)
             return;
         this.textSelection$.next(new TextSelection(this.fabricObject, this.fontLibrary));
-        this.notifyCanvasOfTextChanges();
+        if (notifyCanvas) {
+            this.notifyCanvasOfTextChanges();
+        }
     }
     notifyCanvasOfTextChanges() {
-        this.canvas.notifyTextChanged();
+        if (this.notifyCanvasTimeout) {
+            clearTimeout(this.notifyCanvasTimeout);
+        }
+        this.notifyCanvasTimeout = setTimeout(() => {
+            this.canvas.notifyTextChanged();
+            this.notifyCanvasTimeout = null;
+        }, this.NOTIFY_DELAY_MS);
+    }
+    /**
+     * @override
+     * Provide a simpler bounding box for drag boundary checks that uses the textbox
+     * dimensions directly instead of getBoundingRect(), which includes ordered list
+     * markers that may extend far beyond the text and cause drag shaking issues.
+     */
+    getSimpleBoundingBox() {
+        return {
+            top: this.fabricObject.top || 0,
+            left: this.fabricObject.left || 0,
+            width: (this.fabricObject.width || 0) * (this.fabricObject.scaleX || 1),
+            height: (this.fabricObject.height || 0) * (this.fabricObject.scaleY || 1)
+        };
     }
 }
 Text.NEW_LINE = "\n";
@@ -2714,6 +2870,7 @@ class AbstractInteractiveCanvas {
         this.devicePixelRatio = devicePixelRatio;
         this.fontLibrary = new FontLibrary();
         this.dimensionChangeRejections$ = new Subject();
+        this.redrawScheduled = false;
         this.IMAGE_CAPTURE_COEFFICIENT = this.calculateImageCaptureCoefficient();
         /**
          * Fabric defaults to only 2 decimal places when saving, which causes havoc on the scaling of large images.
@@ -2735,8 +2892,8 @@ class AbstractInteractiveCanvas {
         //Configure canvas behaviour
         this.fabricCanvas.stateful = true;
         this.fabricCanvas.preserveObjectStacking = true;
-        this.fabricCanvas.perPixelTargetFind = true;
-        this.fabricCanvas.targetFindTolerance = 4;
+        this.fabricCanvas.perPixelTargetFind = false; // Disabled for better hover tolerance in Fabric v7
+        this.fabricCanvas.targetFindTolerance = 0; // Increased for better hover detection in Fabric v7 (was 4)
         this.setBackgroundColor("#FFFFFF");
     }
     /**
@@ -3040,7 +3197,6 @@ class AbstractInteractiveCanvas {
      */
     addImageObject(imageUrl) {
         return __awaiter(this, void 0, void 0, function* () {
-            // Don't let the image be more than half the canvas in size.
             const maxSizeScale = 2;
             const maxWidth = this.dimensions$.value.widthPx / maxSizeScale;
             const options = { crossOrigin: "anonymous" };
@@ -3052,7 +3208,6 @@ class AbstractInteractiveCanvas {
                 if (curWidth > maxWidth) {
                     newScale = maxWidth / curWidth;
                 }
-                // Set image properties and add to the canvas
                 const fabricImage = new this.fabric.Image(image, {
                     id: id,
                     scaleX: newScale,
@@ -3072,7 +3227,6 @@ class AbstractInteractiveCanvas {
                 return object;
             }
             else {
-                // Browser-side logic
                 return yield new Promise((resolve) => {
                     this.fabric.Image.fromURL(imageUrl, options).then((fabricImage) => {
                         const id = this.randomId();
@@ -3124,15 +3278,14 @@ class AbstractInteractiveCanvas {
                 fontFamily: profile.defaultFont,
                 textAlign: profile.defaultTextAlignment,
                 hoverCursor: "move",
-                moveCursor: 'move',
+                moveCursor: "move",
+                editable: false,
+                editingBorderColor: '#2196F3',
                 multiLine: true,
                 lineHeight: profile.defaultLineHeight,
                 charSpacing: profile.defaultCharacterSpacing,
-                perPixelTargetFind: false,
-                targetFindTolerance: 4,
                 splitByGrapheme: true,
-                editable: false, // Only enable on double-click
-                padding: 0,
+                padding: 0, // Increased from 0 for better hover detection in Fabric v7
                 cornerSize: 8,
                 touchCornerSize: 12
             };
@@ -3581,9 +3734,17 @@ class AbstractInteractiveCanvas {
     }
     /**
      * Redraw the canvas.
+     * Uses requestAnimationFrame to batch multiple redraw calls into a single render.
      */
     redraw() {
-        this.fabricCanvas.requestRenderAll();
+        if (this.redrawScheduled) {
+            return;
+        }
+        this.redrawScheduled = true;
+        requestAnimationFrame(() => {
+            this.fabricCanvas.requestRenderAll();
+            this.redrawScheduled = false;
+        });
     }
     syncObjectList() {
         const newObjectList = _(this.fabricCanvas.getObjects())
@@ -3709,7 +3870,6 @@ class AbstractInteractiveCanvas {
      * Update the actual dimensions of the canvas by multiplying the requested dimensions by the current zoom factor.
      */
     updateCanvasDimensions(dims, zoom) {
-        this.fabricCanvas.getWidth();
         const width = dims.widthPx * zoom;
         const height = dims.heightPx * zoom;
         this.fabricCanvas.setZoom(zoom);
@@ -3717,37 +3877,6 @@ class AbstractInteractiveCanvas {
             width,
             height
         });
-        /* if (this.layoutManager$.value instanceof AdvancedLayoutManager) {
-             const scaleFactor = width / oldWidth;
-             this.fabricCanvas.calcOffset();
-             const objects = this.fabricCanvas.getObjects();
-             objects.forEach((obj: any) => {
-                 obj.set({
-                     left: obj.left * scaleFactor,
-                 });
-                 if (obj.type === "textbox" || obj.type === "text") {
-                     obj.set({
-                         scaleX: 1,
-                         scaleY: 1,
-                         width: obj.width * scaleFactor,
-                     });
-                     obj.initDimensions();
-                 } else if (obj.type === "border" || obj.type === "rect") {
-                     obj.set({
-                         width: obj.width * scaleFactor,
-                         scaleX: 1,
-                         strokeUniform: true,
-                         strokeAlign: "inner",
-                     });
-                 } else {
-                     obj.set({
-                         scaleX: obj.scaleX * scaleFactor,
-                     });
-                 }
-                 obj.setCoords();
-             });
-             this.fabricCanvas.requestRenderAll();
-         }*/
     }
     onProfileChanged(profile) {
         this.setMultiSelect(profile.allowMultiSelect);
@@ -3902,7 +4031,6 @@ class InteractiveCanvas extends AbstractInteractiveCanvas {
         this.fabricCanvas.on("selection:created", (event) => this.onFabricSelectionChanged(event));
         this.fabricCanvas.on("selection:cleared", (event) => this.onFabricSelectionChanged(event));
         this.fabricCanvas.on("text:editing:entered", () => this.onTextEditing());
-        this.fabricCanvas.on("text:editing:exited", () => this.onTextEditing());
         this.fabricCanvas.on("text:editing:exited", (event) => {
             this.onTextEditing();
             const target = event.target;
@@ -3911,8 +4039,6 @@ class InteractiveCanvas extends AbstractInteractiveCanvas {
             }
         });
         this.fabricCanvas.on("text:changed", () => this.onTextChange());
-        // Handle double-click on textbox to enter editing mode
-        // @ts-ignore
         this.fabricCanvas.on("mouse:dblclick", (event) => this.onDoubleClick(event));
     }
     /**
@@ -3947,29 +4073,20 @@ class InteractiveCanvas extends AbstractInteractiveCanvas {
             selection.setEvent(event);
         }
         this.selection$.next(selection);
-        this.enterTextSelectionModeIfRequired();
-    }
-    enterTextSelectionModeIfRequired() {
-        var _a, _b;
-        if (!this.profile$.value.enterTextEditImmediatelyOnSelect && !this.layoutManager$.value.enterTextEditImmediatelyOnSelect)
-            return;
-        if (((_b = (_a = this.selection$.value) === null || _a === void 0 ? void 0 : _a.objects[0]) === null || _b === void 0 ? void 0 : _b.getType()) !== ObjectType.TEXT)
-            return;
-        const text = this.selection$.value.objects[0];
-        text.enterEditing();
     }
     onTextEditing() {
         const selected = this.getFieldsByCanvasObject(this.fabricCanvas.getActiveObjects());
         this.selection$.next(new SelectionData(selected));
     }
     onDoubleClick(event) {
+        var _a, _b;
         const target = event.target;
         if (target && (target.type === 'textbox' || target.type === 'i-text')) {
-            if (!target.isEditing) {
+            const targetIText = target;
+            if (!targetIText.isEditing) {
                 target.set({ editable: true, hoverCursor: 'text' });
-                // target.enterEditing();
-                // target.hiddenTextarea?.focus();
-                this.enterTextSelectionModeIfRequired();
+                (_a = targetIText.enterEditing) === null || _a === void 0 ? void 0 : _a.call(targetIText);
+                (_b = targetIText.hiddenTextarea) === null || _b === void 0 ? void 0 : _b.focus();
             }
         }
     }