@tldraw/editor 4.5.0-canary.034ea85352da → 4.5.0-canary.0d748e7df5db

package/dist-cjs/lib/editor/Editor.js

@@ -3990,6 +3990,9 @@ class Editor extends (_a = import_eventemitter3.default, _getIsShapeHiddenCache_
       if (geometry.isClosed) {
         if (distance <= outerMargin || hitInside && distance <= 0 && distance > -innerMargin) {
           if (geometry.isFilled || isGroup && geometry.children[0].isFilled) {
+            if (geometry.ignoreHit(pointInShapeSpace)) {
+              continue;
+            }
             return inMarginClosestToEdgeHit || shape;
           } else {
             if (this.getShapePageBounds(shape).contains(viewportPageBounds)) continue;
@@ -4985,6 +4988,53 @@ class Editor extends (_a = import_eventemitter3.default, _getIsShapeHiddenCache_
     if (changes) this.updateShapes(changes);
     return this;
   }
+  /**
+   * Shared clustering logic for layout methods. Resolves shapes, optionally filters to
+   * axis-aligned shapes, checks canBeLaidOut, and groups shapes into clusters via arrow bindings.
+   *
+   * @internal
+   */
+  getShapeClusters(shapes, type, opts) {
+    const ids = typeof shapes[0] === "string" ? shapes : shapes.map((s) => s.id);
+    let freshShapes = (0, import_utils.compact)(ids.map((id) => this.getShape(id)));
+    if (opts?.filterAxisAligned) {
+      freshShapes = freshShapes.filter(
+        (s) => this.getShapePageTransform(s)?.rotation() % (import_utils2.PI / 2) === 0
+      );
+    }
+    const clusters = [];
+    const allBounds = [];
+    const visited = /* @__PURE__ */ new Set();
+    for (const shape of freshShapes) {
+      if (visited.has(shape.id)) continue;
+      visited.add(shape.id);
+      const shapePageBounds = this.getShapePageBounds(shape);
+      if (!shapePageBounds) continue;
+      if (!this.getShapeUtil(shape).canBeLaidOut?.(shape, {
+        type,
+        shapes: freshShapes
+      })) {
+        continue;
+      }
+      const shapesMovingTogether = [shape];
+      const boundsOfShapesMovingTogether = [shapePageBounds];
+      this.collectShapesViaArrowBindings({
+        bindings: this.getBindingsToShape(shape.id, "arrow"),
+        initialShapes: freshShapes,
+        resultShapes: shapesMovingTogether,
+        resultBounds: boundsOfShapesMovingTogether,
+        visited
+      });
+      const commonPageBounds = import_Box.Box.Common(boundsOfShapesMovingTogether);
+      if (!commonPageBounds) continue;
+      clusters.push({
+        shapes: shapesMovingTogether,
+        pageBounds: commonPageBounds
+      });
+      allBounds.push(commonPageBounds);
+    }
+    return { clusters, allBounds };
+  }
   /**
    * @internal
    */
@@ -5095,40 +5145,8 @@ class Editor extends (_a = import_eventemitter3.default, _getIsShapeHiddenCache_
    */
   stackShapes(shapes, operation, gap) {
     const _gap = gap ?? this.options.adjacentShapeMargin;
-    const ids = typeof shapes[0] === "string" ? shapes : shapes.map((s) => s.id);
     if (this.getIsReadonly()) return this;
-    const shapesToStackFirstPass = (0, import_utils.compact)(ids.map((id) => this.getShape(id)));
-    const shapeClustersToStack = [];
-    const allBounds = [];
-    const visited = /* @__PURE__ */ new Set();
-    for (const shape of shapesToStackFirstPass) {
-      if (visited.has(shape.id)) continue;
-      visited.add(shape.id);
-      const shapePageBounds = this.getShapePageBounds(shape);
-      if (!shapePageBounds) continue;
-      if (!this.getShapeUtil(shape).canBeLaidOut?.(shape, {
-        type: "stack",
-        shapes: shapesToStackFirstPass
-      })) {
-        continue;
-      }
-      const shapesMovingTogether = [shape];
-      const boundsOfShapesMovingTogether = [shapePageBounds];
-      this.collectShapesViaArrowBindings({
-        bindings: this.getBindingsToShape(shape.id, "arrow"),
-        initialShapes: shapesToStackFirstPass,
-        resultShapes: shapesMovingTogether,
-        resultBounds: boundsOfShapesMovingTogether,
-        visited
-      });
-      const commonPageBounds = import_Box.Box.Common(boundsOfShapesMovingTogether);
-      if (!commonPageBounds) continue;
-      shapeClustersToStack.push({
-        shapes: shapesMovingTogether,
-        pageBounds: commonPageBounds
-      });
-      allBounds.push(commonPageBounds);
-    }
+    const { clusters: shapeClustersToStack } = this.getShapeClusters(shapes, "stack");
     const len = shapeClustersToStack.length;
     if (_gap === 0 && len < 3 || len < 2) return this;
     let val;
@@ -5214,40 +5232,11 @@ class Editor extends (_a = import_eventemitter3.default, _getIsShapeHiddenCache_
   packShapes(shapes, _gap) {
     if (this.getIsReadonly()) return this;
     const gap = _gap ?? this.options.adjacentShapeMargin;
-    const ids = typeof shapes[0] === "string" ? shapes : shapes.map((s) => s.id);
-    const shapesToPackFirstPass = (0, import_utils.compact)(ids.map((id) => this.getShape(id)));
-    const shapeClustersToPack = [];
-    const allBounds = [];
-    const visited = /* @__PURE__ */ new Set();
-    for (const shape of shapesToPackFirstPass) {
-      if (visited.has(shape.id)) continue;
-      visited.add(shape.id);
-      const shapePageBounds = this.getShapePageBounds(shape);
-      if (!shapePageBounds) continue;
-      if (!this.getShapeUtil(shape).canBeLaidOut?.(shape, {
-        type: "pack",
-        shapes: shapesToPackFirstPass
-      })) {
-        continue;
-      }
-      const shapesMovingTogether = [shape];
-      const boundsOfShapesMovingTogether = [shapePageBounds];
-      this.collectShapesViaArrowBindings({
-        bindings: this.getBindingsToShape(shape.id, "arrow"),
-        initialShapes: shapesToPackFirstPass,
-        resultShapes: shapesMovingTogether,
-        resultBounds: boundsOfShapesMovingTogether,
-        visited
-      });
-      const commonPageBounds = import_Box.Box.Common(boundsOfShapesMovingTogether);
-      if (!commonPageBounds) continue;
-      shapeClustersToPack.push({
-        shapes: shapesMovingTogether,
-        pageBounds: commonPageBounds,
-        nextPageBounds: commonPageBounds.clone()
-      });
-      allBounds.push(commonPageBounds);
-    }
+    const { clusters, allBounds } = this.getShapeClusters(shapes, "pack");
+    const shapeClustersToPack = clusters.map((cluster) => ({
+      ...cluster,
+      nextPageBounds: cluster.pageBounds.clone()
+    }));
     if (shapeClustersToPack.length < 2) return this;
     let area = 0;
     for (const { pageBounds } of shapeClustersToPack) {
@@ -5331,39 +5320,7 @@ class Editor extends (_a = import_eventemitter3.default, _getIsShapeHiddenCache_
    */
   alignShapes(shapes, operation) {
     if (this.getIsReadonly()) return this;
-    const ids = typeof shapes[0] === "string" ? shapes : shapes.map((s) => s.id);
-    const shapesToAlignFirstPass = (0, import_utils.compact)(ids.map((id) => this.getShape(id)));
-    const shapeClustersToAlign = [];
-    const allBounds = [];
-    const visited = /* @__PURE__ */ new Set();
-    for (const shape of shapesToAlignFirstPass) {
-      if (visited.has(shape.id)) continue;
-      visited.add(shape.id);
-      const shapePageBounds = this.getShapePageBounds(shape);
-      if (!shapePageBounds) continue;
-      if (!this.getShapeUtil(shape).canBeLaidOut?.(shape, {
-        type: "align",
-        shapes: shapesToAlignFirstPass
-      })) {
-        continue;
-      }
-      const shapesMovingTogether = [shape];
-      const boundsOfShapesMovingTogether = [shapePageBounds];
-      this.collectShapesViaArrowBindings({
-        bindings: this.getBindingsToShape(shape.id, "arrow"),
-        initialShapes: shapesToAlignFirstPass,
-        resultShapes: shapesMovingTogether,
-        resultBounds: boundsOfShapesMovingTogether,
-        visited
-      });
-      const commonPageBounds = import_Box.Box.Common(boundsOfShapesMovingTogether);
-      if (!commonPageBounds) continue;
-      shapeClustersToAlign.push({
-        shapes: shapesMovingTogether,
-        pageBounds: commonPageBounds
-      });
-      allBounds.push(commonPageBounds);
-    }
+    const { clusters: shapeClustersToAlign, allBounds } = this.getShapeClusters(shapes, "align");
     if (shapeClustersToAlign.length < 2) return this;
     const commonBounds = import_Box.Box.Common(allBounds);
     const changes = [];
@@ -5425,39 +5382,7 @@ class Editor extends (_a = import_eventemitter3.default, _getIsShapeHiddenCache_
    */
   distributeShapes(shapes, operation) {
     if (this.getIsReadonly()) return this;
-    const ids = typeof shapes[0] === "string" ? shapes : shapes.map((s) => s.id);
-    const shapesToDistributeFirstPass = (0, import_utils.compact)(ids.map((id) => this.getShape(id)));
-    const shapeClustersToDistribute = [];
-    const allBounds = [];
-    const visited = /* @__PURE__ */ new Set();
-    for (const shape of shapesToDistributeFirstPass) {
-      if (visited.has(shape.id)) continue;
-      visited.add(shape.id);
-      const shapePageBounds = this.getShapePageBounds(shape);
-      if (!shapePageBounds) continue;
-      if (!this.getShapeUtil(shape).canBeLaidOut?.(shape, {
-        type: "distribute",
-        shapes: shapesToDistributeFirstPass
-      })) {
-        continue;
-      }
-      const shapesMovingTogether = [shape];
-      const boundsOfShapesMovingTogether = [shapePageBounds];
-      this.collectShapesViaArrowBindings({
-        bindings: this.getBindingsToShape(shape.id, "arrow"),
-        initialShapes: shapesToDistributeFirstPass,
-        resultShapes: shapesMovingTogether,
-        resultBounds: boundsOfShapesMovingTogether,
-        visited
-      });
-      const commonPageBounds = import_Box.Box.Common(boundsOfShapesMovingTogether);
-      if (!commonPageBounds) continue;
-      shapeClustersToDistribute.push({
-        shapes: shapesMovingTogether,
-        pageBounds: commonPageBounds
-      });
-      allBounds.push(commonPageBounds);
-    }
+    const { clusters: shapeClustersToDistribute } = this.getShapeClusters(shapes, "distribute");
     if (shapeClustersToDistribute.length < 3) return this;
     let val;
     let min;
@@ -5479,6 +5404,7 @@ class Editor extends (_a = import_eventemitter3.default, _getIsShapeHiddenCache_
     const last2 = shapeClustersToDistribute.sort((a, b) => b.pageBounds[max] - a.pageBounds[max])[0];
     if (first === last2) {
       const excludedShapeIds = new Set(first.shapes.map((s) => s.id));
+      const ids = typeof shapes[0] === "string" ? shapes : shapes.map((s) => s.id);
       return this.distributeShapes(
         ids.filter((id) => !excludedShapeIds.has(id)),
         operation
@@ -5531,41 +5457,12 @@ class Editor extends (_a = import_eventemitter3.default, _getIsShapeHiddenCache_
    * @public
    */
   stretchShapes(shapes, operation) {
-    const ids = typeof shapes[0] === "string" ? shapes : shapes.map((s) => s.id);
     if (this.getIsReadonly()) return this;
-    const shapesToStretchFirstPass = (0, import_utils.compact)(ids.map((id) => this.getShape(id))).filter(
-      (s) => this.getShapePageTransform(s)?.rotation() % (import_utils2.PI / 2) === 0
+    const { clusters: shapeClustersToStretch, allBounds } = this.getShapeClusters(
+      shapes,
+      "stretch",
+      { filterAxisAligned: true }
     );
-    const shapeClustersToStretch = [];
-    const allBounds = [];
-    const visited = /* @__PURE__ */ new Set();
-    for (const shape of shapesToStretchFirstPass) {
-      if (visited.has(shape.id)) continue;
-      visited.add(shape.id);
-      const shapePageBounds = this.getShapePageBounds(shape);
-      if (!shapePageBounds) continue;
-      const shapesMovingTogether = [shape];
-      const boundsOfShapesMovingTogether = [shapePageBounds];
-      if (!this.getShapeUtil(shape).canBeLaidOut?.(shape, {
-        type: "stretch"
-      })) {
-        continue;
-      }
-      this.collectShapesViaArrowBindings({
-        bindings: this.getBindingsToShape(shape.id, "arrow"),
-        initialShapes: shapesToStretchFirstPass,
-        resultShapes: shapesMovingTogether,
-        resultBounds: boundsOfShapesMovingTogether,
-        visited
-      });
-      const commonPageBounds = import_Box.Box.Common(boundsOfShapesMovingTogether);
-      if (!commonPageBounds) continue;
-      shapeClustersToStretch.push({
-        shapes: shapesMovingTogether,
-        pageBounds: commonPageBounds
-      });
-      allBounds.push(commonPageBounds);
-    }
     if (shapeClustersToStretch.length < 2) return this;
     const commonBounds = import_Box.Box.Common(allBounds);
     let val;
@@ -5591,7 +5488,7 @@ class Editor extends (_a = import_eventemitter3.default, _getIsShapeHiddenCache_
         for (const shape of shapes2) {
           const shapeLocalOffset = localOffset.clone();
           const parentTransform = this.getShapeParentTransform(shape);
-          if (parentTransform) localOffset.rot(-parentTransform.rotation());
+          if (parentTransform) shapeLocalOffset.rot(-parentTransform.rotation());
           shapeLocalOffset.add(shape);
           const changes = this.getChangesToTranslateShape(shape, shapeLocalOffset);
           this.updateShape(changes);
@@ -5606,6 +5503,62 @@ class Editor extends (_a = import_eventemitter3.default, _getIsShapeHiddenCache_
     });
     return this;
   }
+  /**
+   * Resize and reposition a set of shapes so that their combined page bounds matches the given
+   * target bounds.
+   *
+   * @example
+   * ```ts
+   * editor.resizeToBounds([box1, box2], { x: 0, y: 0, w: 500, h: 500 })
+   * editor.resizeToBounds(editor.getSelectedShapeIds(), new Box(0, 0, 500, 500))
+   * ```
+   *
+   * @param shapes - The shapes (or shape ids) to resize.
+   * @param bounds - The target bounding box.
+   *
+   * @public
+   */
+  resizeToBounds(shapes, bounds) {
+    if (this.getIsReadonly()) return this;
+    const targetBounds = import_Box.Box.From(bounds);
+    const { clusters: shapeClusters, allBounds } = this.getShapeClusters(
+      shapes,
+      "resize_to_bounds",
+      { filterAxisAligned: true }
+    );
+    if (shapeClusters.length === 0) return this;
+    const commonBounds = import_Box.Box.Common(allBounds);
+    if (!commonBounds) return this;
+    if (commonBounds.width === 0 || commonBounds.height === 0) return this;
+    const scaleX = targetBounds.width / commonBounds.width;
+    const scaleY = targetBounds.height / commonBounds.height;
+    const scale = new import_Vec.Vec(scaleX, scaleY);
+    shapeClusters.forEach(({ shapes: shapes2, pageBounds }) => {
+      const localOffset = new import_Vec.Vec(
+        targetBounds.minX - commonBounds.minX + (pageBounds.minX - commonBounds.minX) * (scaleX - 1),
+        targetBounds.minY - commonBounds.minY + (pageBounds.minY - commonBounds.minY) * (scaleY - 1)
+      );
+      const scaleOrigin = new import_Vec.Vec(
+        targetBounds.minX + (pageBounds.minX - commonBounds.minX) * scaleX,
+        targetBounds.minY + (pageBounds.minY - commonBounds.minY) * scaleY
+      );
+      for (const shape of shapes2) {
+        const shapeLocalOffset = localOffset.clone();
+        const parentTransform = this.getShapeParentTransform(shape);
+        if (parentTransform) shapeLocalOffset.rot(-parentTransform.rotation());
+        shapeLocalOffset.add(shape);
+        const changes = this.getChangesToTranslateShape(shape, shapeLocalOffset);
+        this.updateShape(changes);
+        this.resizeShape(shape.id, scale, {
+          initialBounds: this.getShapeGeometry(shape).bounds,
+          scaleOrigin,
+          isAspectRatioLocked: this.getShapeUtil(shape).isAspectRatioLocked(shape),
+          scaleAxisRotation: 0
+        });
+      }
+    });
+    return this;
+  }
   /**
    * Resize a shape.
    *
@@ -6725,38 +6678,10 @@ class Editor extends (_a = import_eventemitter3.default, _getIsShapeHiddenCache_
     const bindingIdMap = new Map(
       preserveIds ? bindings.map((binding) => [binding.id, binding.id]) : bindings.map((binding) => [binding.id, (0, import_tlschema.createBindingId)()])
     );
-    let pasteParentId = this.getCurrentPageId();
-    let lowestDepth = Infinity;
-    let lowestAncestors = [];
-    for (const shape of this.getSelectedShapes()) {
-      if (lowestDepth === 0) break;
-      const isFrame = this.isShapeOfType(shape, "frame");
-      const ancestors = this.getShapeAncestors(shape);
-      if (isFrame) ancestors.push(shape);
-      const depth = isFrame ? ancestors.length + 1 : ancestors.length;
-      if (depth < lowestDepth) {
-        lowestDepth = depth;
-        lowestAncestors = ancestors;
-        pasteParentId = isFrame ? shape.id : shape.parentId;
-      } else if (depth === lowestDepth) {
-        if (lowestAncestors.length !== ancestors.length) {
-          throw Error(`Ancestors: ${lowestAncestors.length} !== ${ancestors.length}`);
-        }
-        if (lowestAncestors.length === 0) {
-          pasteParentId = currentPageId;
-          break;
-        } else {
-          pasteParentId = currentPageId;
-          for (let i = 0; i < lowestAncestors.length; i++) {
-            if (ancestors[i] !== lowestAncestors[i]) break;
-            pasteParentId = ancestors[i].id;
-          }
-        }
-      }
-    }
+    let pasteParentId = currentPageId;
+    const shapesById = new Map(shapes.map((s) => [s.id, s]));
+    const rootShapesFromContent = (0, import_utils.compact)(rootShapeIds.map((id) => shapesById.get(id)));
     if (point) {
-      const shapesById = new Map(shapes.map((shape) => [shape.id, shape]));
-      const rootShapesFromContent = (0, import_utils.compact)(rootShapeIds.map((id) => shapesById.get(id)));
       if (rootShapesFromContent.length > 0) {
         const targetParent = this.getShapeAtPoint(point, {
           hitInside: true,
@@ -6764,38 +6689,55 @@ class Editor extends (_a = import_eventemitter3.default, _getIsShapeHiddenCache_
           hitLocked: true,
           filter: (shape) => {
             const util = this.getShapeUtil(shape);
-            if (!util.canReceiveNewChildrenOfType) return false;
             return rootShapesFromContent.every(
-              (rootShape) => util.canReceiveNewChildrenOfType(shape, rootShape.type)
+              (rootShape) => util.canReceiveNewChildrenOfType?.(shape, rootShape.type)
             );
           }
         });
-        pasteParentId = targetParent ? targetParent.id : currentPageId;
-      }
-    }
-    let isDuplicating = false;
-    if (!(0, import_tlschema.isPageId)(pasteParentId)) {
-      const parent = this.getShape(pasteParentId);
-      if (parent) {
-        if (!this.getViewportPageBounds().includes(this.getShapePageBounds(parent))) {
-          pasteParentId = currentPageId;
-        } else {
-          if (rootShapeIds.length === 1) {
-            const rootShape = shapes.find((s) => s.id === rootShapeIds[0]);
-            if (this.isShapeOfType(parent, "frame") && this.isShapeOfType(rootShape, "frame") && rootShape.props.w === parent?.props.w && rootShape.props.h === parent?.props.h) {
-              isDuplicating = true;
+        pasteParentId = targetParent?.id ?? currentPageId;
+      }
+    } else if (!preservePosition) {
+      const selectedShapes = this.getSelectedShapes();
+      let selectedParent = null;
+      const canAcceptAll = (candidate) => {
+        const util = this.getShapeUtil(candidate);
+        return rootShapesFromContent.every(
+          (rs) => util.canReceiveNewChildrenOfType?.(candidate, rs.type)
+        );
+      };
+      for (const shape of selectedShapes) {
+        const candidate = canAcceptAll(shape) ? shape : this.findShapeAncestor(shape, canAcceptAll) ?? ((0, import_tlschema.isShapeId)(shape.parentId) ? this.getShape(shape.parentId) : null);
+        if (!candidate) {
+          selectedParent = null;
+          break;
+        }
+        if (!selectedParent) {
+          selectedParent = candidate;
+        } else if (selectedParent.id !== candidate.id) {
+          const spAncestors = this.getShapeAncestors(selectedParent);
+          if (canAcceptAll(selectedParent)) spAncestors.push(selectedParent);
+          const acceptingAncestors = spAncestors.filter(canAcceptAll);
+          const candidateAncestorIds = /* @__PURE__ */ new Set([
+            candidate.id,
+            ...this.getShapeAncestors(candidate).map((a) => a.id)
+          ]);
+          let common = null;
+          for (let i = acceptingAncestors.length - 1; i >= 0; i--) {
+            if (candidateAncestorIds.has(acceptingAncestors[i].id)) {
+              common = acceptingAncestors[i];
+              break;
             }
           }
+          selectedParent = common;
+          if (!selectedParent) break;
         }
-      } else {
-        pasteParentId = currentPageId;
       }
-    }
-    if (!isDuplicating) {
-      isDuplicating = shapeIdMap.has(pasteParentId);
-    }
-    if (isDuplicating) {
-      pasteParentId = this.getShape(pasteParentId).parentId;
+      if (selectedParent && shapeIdMap.has(selectedParent.id)) {
+        selectedParent = null;
+      }
+      if (selectedParent) {
+        pasteParentId = selectedParent.id;
+      }
     }
     let index = this.getHighestIndexForParent(pasteParentId);
     const rootShapes = [];
@@ -6859,22 +6801,17 @@ class Editor extends (_a = import_eventemitter3.default, _getIsShapeHiddenCache_
       })
     );
     this.run(() => {
-      if (assetsToCreate.length > 0) {
-        this.createAssets(assetsToCreate);
-      }
+      if (assetsToCreate.length > 0) this.createAssets(assetsToCreate);
       this.createShapes(newShapes);
       this.createBindings(newBindings);
-      if (select) {
-        this.select(...rootShapes.map((s) => s.id));
-      }
+      if (select) this.select(...rootShapes.map((s) => s.id));
       if (pasteParentId !== currentPageId) {
         this.reparentShapes(
           rootShapes.map((s) => s.id),
           pasteParentId
         );
       }
-      const newCreatedShapes = newShapes.map((s) => this.getShape(s.id));
-      const bounds = import_Box.Box.Common(newCreatedShapes.map((s) => this.getShapePageBounds(s)));
+      const rootBounds = import_Box.Box.Common((0, import_utils.compact)(rootShapes.map((s) => this.getShapePageBounds(s.id))));
       if (point === void 0) {
         if (!(0, import_tlschema.isPageId)(pasteParentId)) {
           const shape = this.getShape(pasteParentId);
@@ -6882,40 +6819,44 @@ class Editor extends (_a = import_eventemitter3.default, _getIsShapeHiddenCache_
             this.getShapePageTransform(shape),
             this.getShapeGeometry(shape).bounds.center
           );
+        } else if (preservePosition) {
+          point = rootBounds.center;
         } else {
           const viewportPageBounds = this.getViewportPageBounds();
-          if (preservePosition || viewportPageBounds.includes(import_Box.Box.From(bounds))) {
-            point = bounds.center;
-          } else {
-            point = viewportPageBounds.center;
-          }
-        }
-      }
-      if (rootShapes.length === 1) {
-        const onlyRoot = rootShapes[0];
-        if (this.isShapeOfType(onlyRoot, "frame")) {
-          while (this.getShapesAtPoint(point).some(
-            (shape) => this.isShapeOfType(shape, "frame") && shape.props.w === onlyRoot.props.w && shape.props.h === onlyRoot.props.h
-          )) {
-            point.x += bounds.w + 16;
-          }
+          const anyOverlap = rootShapes.some((s) => {
+            const b = this.getShapePageBounds(s.id);
+            return b && viewportPageBounds.collides(b);
+          });
+          point = anyOverlap ? rootBounds.center : viewportPageBounds.center;
         }
       }
       const pageCenter = import_Box.Box.Common(
         (0, import_utils.compact)(rootShapes.map(({ id }) => this.getShapePageBounds(id)))
       ).center;
       const offset = import_Vec.Vec.Sub(point, pageCenter);
-      this.updateShapes(
-        rootShapes.map(({ id }) => {
-          const s = this.getShape(id);
-          const localRotation = this.getShapeParentTransform(id).decompose().rotation;
-          const localDelta = import_Vec.Vec.Rot(offset, -localRotation);
-          return { id: s.id, type: s.type, x: s.x + localDelta.x, y: s.y + localDelta.y };
-        })
-      );
+      if (offset.x !== 0 || offset.y !== 0) {
+        this.updateShapes(
+          rootShapes.map(({ id }) => {
+            const s = this.getShape(id);
+            const localRotation = this.getShapeParentTransform(id).decompose().rotation;
+            const localDelta = import_Vec.Vec.Rot(offset, -localRotation);
+            return { id: s.id, type: s.type, x: s.x + localDelta.x, y: s.y + localDelta.y };
+          })
+        );
+      }
       if ((0, import_tlschema.isPageId)(pasteParentId)) {
         const currentRootShapes = (0, import_utils.compact)(rootShapes.map((s) => this.getShape(s.id)));
-        const { reparenting } = (0, import_reparenting.getDroppedShapesToNewParents)(this, currentRootShapes);
+        const { reparenting } = (0, import_reparenting.getDroppedShapesToNewParents)(
+          this,
+          currentRootShapes,
+          (shape, parent) => {
+            if (shapeIdMap.has(parent.id)) return false;
+            const shapeBounds = this.getShapePageBounds(shape);
+            const parentBounds = this.getShapePageBounds(parent);
+            if (!shapeBounds || !parentBounds) return false;
+            return parentBounds.containsPoint(shapeBounds.center);
+          }
+        );
         reparenting.forEach((childrenToReparent, newParentId) => {
           if (childrenToReparent.length === 0) return;
           this.reparentShapes(
@@ -6924,6 +6865,17 @@ class Editor extends (_a = import_eventemitter3.default, _getIsShapeHiddenCache_
           );
         });
       }
+      const newShapeIdSet = new Set(newShapes.map((s) => s.id));
+      const shapesToKickout = rootShapes.map((s) => s.id).filter((id) => {
+        const shape = this.getShape(id);
+        if (!shape) return false;
+        if ((0, import_tlschema.isPageId)(shape.parentId)) return false;
+        const children = this.getSortedChildIdsForParent(id);
+        return !children.some((childId) => newShapeIdSet.has(childId));
+      });
+      if (shapesToKickout.length > 0) {
+        (0, import_reparenting.kickoutOccludedShapes)(this, shapesToKickout);
+      }
     });
     return this;
   }