@tldraw/editor 3.14.0-canary.6fbbca54ff57 → 3.14.0-canary.718fcc03811e

package/src/lib/editor/Editor.ts

@@ -2128,7 +2128,7 @@ export class Editor extends EventEmitter<TLEventMap> {
 	 * @readonly
 	 * @public
 	 */
-	getSelectionScreenBounds(): Box | undefined {
+	@computed getSelectionScreenBounds(): Box | undefined {
 		const bounds = this.getSelectionPageBounds()
 		if (!bounds) return undefined
 		const { x, y } = this.pageToScreen(bounds.point)
@@ -5528,7 +5528,7 @@ export class Editor extends EventEmitter<TLEventMap> {
 		if (!id) return undefined
 		const freshShape = this.getShape(id)
 		if (freshShape === undefined || !isShapeId(freshShape.parentId)) return undefined
-		return this.getShape(freshShape.parentId)
+		return this.store.get(freshShape.parentId)
 	}
 
 	/**
@@ -5711,10 +5711,6 @@ export class Editor extends EventEmitter<TLEventMap> {
 					const newPoint = invertedParentTransform.applyToPoint(pagePoint)
 					const newRotation = pageTransform.rotation() - parentPageRotation
 
-					if (shape.id === parentId) {
-						throw Error('Attempted to reparent a shape to itself!')
-					}
-
 					changes.push({
 						id: shape.id,
 						type: shape.type,
@@ -5818,11 +5814,6 @@ export class Editor extends EventEmitter<TLEventMap> {
 		return shapeIds
 	}
 
-	/** @deprecated Use {@link Editor.getDraggingOverShape} instead */
-	getDroppingOverShape(point: Vec, droppingShapes: TLShape[]): TLShape | undefined {
-		return this.getDraggingOverShape(point, droppingShapes)
-	}
-
 	/**
 	 * Get the shape that some shapes should be dropped on at a given point.
 	 *
@@ -5833,33 +5824,35 @@ export class Editor extends EventEmitter<TLEventMap> {
 	 *
 	 * @public
 	 */
-	getDraggingOverShape(point: Vec, droppingShapes: TLShape[]): TLShape | undefined {
-		// get fresh moving shapes
-		const draggingShapes = compact(droppingShapes.map((s) => this.getShape(s))).filter(
-			(s) => !s.isLocked && !this.isShapeHidden(s)
-		)
+	getDroppingOverShape(point: VecLike, droppingShapes: TLShape[] = []) {
+		// starting from the top...
+		const currentPageShapesSorted = this.getCurrentPageShapesSorted()
+		for (let i = currentPageShapesSorted.length - 1; i >= 0; i--) {
+			const shape = currentPageShapesSorted[i]
 
-		const maybeDraggingOverShapes = this.getShapesAtPoint(point, {
-			hitInside: true,
-			margin: 0,
-		}).filter(
-			(s) =>
-				!droppingShapes.includes(s) &&
-				!s.isLocked &&
-				!this.isShapeHidden(s) &&
-				!draggingShapes.includes(s)
-		)
+			if (
+				// ignore hidden shapes
+				this.isShapeHidden(shape) ||
+				// don't allow dropping on selected shapes
+				this.getSelectedShapeIds().includes(shape.id) ||
+				// only allow shapes that can receive children
+				!this.getShapeUtil(shape).canDropShapes(shape, droppingShapes) ||
+				// don't allow dropping a shape on itself or one of it's children
+				droppingShapes.find((s) => s.id === shape.id || this.hasAncestor(shape, s.id))
+			) {
+				continue
+			}
+
+			// Only allow dropping into the masked page bounds of the shape, e.g. when a frame is
+			// partially clipped by its own parent frame
+			const maskedPageBounds = this.getShapeMaskedPageBounds(shape.id)
 
-		for (const maybeDraggingOverShape of maybeDraggingOverShapes) {
-			const shapeUtil = this.getShapeUtil(maybeDraggingOverShape)
-			// Any shape that can handle any dragging interactions is a valid target
 			if (
-				shapeUtil.onDragShapesOver ||
-				shapeUtil.onDragShapesIn ||
-				shapeUtil.onDragShapesOut ||
-				shapeUtil.onDropShapesOver
+				maskedPageBounds &&
+				maskedPageBounds.containsPoint(point) &&
+				this.getShapeGeometry(shape).hitTestPoint(this.getPointInShapeSpace(shape, point), 0, true)
 			) {
-				return maybeDraggingOverShape
+				return shape
 			}
 		}
 	}
@@ -6218,12 +6211,11 @@ export class Editor extends EventEmitter<TLEventMap> {
 	 */
 	duplicateShapes(shapes: TLShapeId[] | TLShape[], offset?: VecLike): this {
 		this.run(() => {
-			const _ids =
+			const ids =
 				typeof shapes[0] === 'string'
 					? (shapes as TLShapeId[])
 					: (shapes as TLShape[]).map((s) => s.id)
 
-			const ids = this._shouldIgnoreShapeLock ? _ids : this._getUnlockedShapeIds(_ids)
 			if (ids.length <= 0) return this
 
 			const initialIds = new Set(ids)
@@ -7813,10 +7805,9 @@ export class Editor extends EventEmitter<TLEventMap> {
 
 					for (let i = currentPageShapesSorted.length - 1; i >= 0; i--) {
 						const parent = currentPageShapesSorted[i]
-						const util = this.getShapeUtil(parent)
 						if (
-							util.canReceiveNewChildrenOfType(parent, partial.type) &&
 							!this.isShapeHidden(parent) &&
+							this.getShapeUtil(parent).canReceiveNewChildrenOfType(parent, partial.type) &&
 							this.isPointInShape(
 								parent,
 								// If no parent is provided, then we can treat the
@@ -7945,8 +7936,6 @@ export class Editor extends EventEmitter<TLEventMap> {
 				}
 			})
 
-			this.emit('created-shapes', shapeRecordsToCreate)
-			this.emit('edit')
 			this.store.put(shapeRecordsToCreate)
 		})
 
@@ -8341,8 +8330,6 @@ export class Editor extends EventEmitter<TLEventMap> {
 				updates.push(updated)
 			}
 
-			this.emit('edited-shapes', updates)
-			this.emit('edit')
 			this.store.put(updates)
 		})
 	}
@@ -8392,8 +8379,6 @@ export class Editor extends EventEmitter<TLEventMap> {
 			})
 		}
 
-		this.emit('deleted-shapes', [...allShapeIdsToDelete])
-		this.emit('edit')
 		return this.run(() => this.store.remove([...allShapeIdsToDelete]))
 	}
 
@@ -9520,8 +9505,6 @@ export class Editor extends EventEmitter<TLEventMap> {
 			previousPagePoint,
 			currentScreenPoint,
 			currentPagePoint,
-			originScreenPoint,
-			originPagePoint,
 		} = this.inputs
 
 		const { screenBounds } = this.store.unsafeGetWithoutCapture(TLINSTANCE_ID)!
@@ -9550,8 +9533,8 @@ export class Editor extends EventEmitter<TLEventMap> {
 		// Reset velocity on pointer down, or when a pinch starts or ends
 		if (info.name === 'pointer_down' || this.inputs.isPinching) {
 			pointerVelocity.set(0, 0)
-			originScreenPoint.setTo(currentScreenPoint)
-			originPagePoint.setTo(currentPagePoint)
+			this.inputs.originScreenPoint.setTo(currentScreenPoint)
+			this.inputs.originPagePoint.setTo(currentPagePoint)
 		}
 
 		// todo: We only have to do this if there are multiple users in the document

package/src/lib/editor/managers/TextManager/TextManager.ts

@@ -26,7 +26,6 @@ export interface TLMeasureTextOpts {
 	fontWeight: string
 	fontFamily: string
 	fontSize: number
-	/** This must be a number, e.g. 1.35, not a pixel value. */
 	lineHeight: number
 	/**
 	 * When maxWidth is a number, the text will be wrapped to that maxWidth. When maxWidth
@@ -76,7 +75,6 @@ export class TextManager {
 		// we need to save the default styles so that we can restore them when we're done
 		// these must be the css names, not the js names for the styles
 		this.defaultStyles = {
-			'overflow-wrap': 'break-word',
 			'word-break': 'auto',
 			width: null,
 			height: null,
@@ -125,7 +123,7 @@ export class TextManager {
 		elm.style.setProperty('font-style', opts.fontStyle)
 		elm.style.setProperty('font-weight', opts.fontWeight)
 		elm.style.setProperty('font-size', opts.fontSize + 'px')
-		elm.style.setProperty('line-height', opts.lineHeight.toString())
+		elm.style.setProperty('line-height', opts.lineHeight * opts.fontSize + 'px')
 		elm.style.setProperty('padding', opts.padding)
 
 		if (opts.maxWidth) {
@@ -289,7 +287,7 @@ export class TextManager {
 		elm.style.setProperty('font-style', opts.fontStyle)
 		elm.style.setProperty('font-weight', opts.fontWeight)
 		elm.style.setProperty('font-size', opts.fontSize + 'px')
-		elm.style.setProperty('line-height', opts.lineHeight.toString())
+		elm.style.setProperty('line-height', opts.lineHeight * opts.fontSize + 'px')
 
 		const elementWidth = Math.ceil(opts.width - opts.padding * 2)
 		elm.style.setProperty('width', `${elementWidth}px`)

package/src/lib/editor/shapes/ShapeUtil.ts

@@ -4,15 +4,12 @@ import { LegacyMigrations, MigrationSequence } from '@tldraw/store'
 import {
 	RecordProps,
 	TLHandle,
-	TLParentId,
 	TLPropsMigrations,
 	TLShape,
 	TLShapeCrop,
-	TLShapeId,
 	TLShapePartial,
 	TLUnknownShape,
 } from '@tldraw/tlschema'
-import { IndexKey } from '@tldraw/utils'
 import { ReactElement } from 'react'
 import { Box, SelectionHandle } from '../../primitives/Box'
 import { Vec } from '../../primitives/Vec'
@@ -390,6 +387,17 @@ export abstract class ShapeUtil<Shape extends TLUnknownShape = TLUnknownShape> {
 		return false
 	}
 
+	/**
+	 * Get whether the shape can receive children of a given type.
+	 *
+	 * @param shape - The shape type.
+	 * @param shapes - The shapes that are being dropped.
+	 * @public
+	 */
+	canDropShapes(_shape: Shape, _shapes: TLShape[]) {
+		return false
+	}
+
 	/**
 	 * Get the shape as an SVG object.
 	 *
@@ -509,16 +517,7 @@ export abstract class ShapeUtil<Shape extends TLUnknownShape = TLUnknownShape> {
 	): Omit<TLShapePartial<Shape>, 'id' | 'type'> | undefined | void
 
 	/**
-	 * A callback called when some other shapes are dragged into this one. This fires when the shapes are dragged over the shape for the first time.
-	 *
-	 * @param shape - The shape.
-	 * @param shapes - The shapes that are being dragged in.
-	 * @public
-	 */
-	onDragShapesIn?(shape: Shape, shapes: TLShape[], info: TLDragShapesInInfo): void
-
-	/**
-	 * A callback called when some other shapes are dragged over this one. This fires when the shapes are dragged over the shape for the first time (after the onDragShapesIn callback), and again on every update while the shapes are being dragged.
+	 * A callback called when some other shapes are dragged over this one.
 	 *
 	 * @example
 	 *
@@ -532,7 +531,7 @@ export abstract class ShapeUtil<Shape extends TLUnknownShape = TLUnknownShape> {
 	 * @param shapes - The shapes that are being dragged over this one.
 	 * @public
 	 */
-	onDragShapesOver?(shape: Shape, shapes: TLShape[], info: TLDragShapesOverInfo): void
+	onDragShapesOver?(shape: Shape, shapes: TLShape[]): void
 
 	/**
 	 * A callback called when some other shapes are dragged out of this one.
@@ -541,7 +540,7 @@ export abstract class ShapeUtil<Shape extends TLUnknownShape = TLUnknownShape> {
 	 * @param shapes - The shapes that are being dragged out.
 	 * @public
 	 */
-	onDragShapesOut?(shape: Shape, shapes: TLShape[], info: TLDragShapesOutInfo): void
+	onDragShapesOut?(shape: Shape, shapes: TLShape[]): void
 
 	/**
 	 * A callback called when some other shapes are dropped over this one.
@@ -550,7 +549,7 @@ export abstract class ShapeUtil<Shape extends TLUnknownShape = TLUnknownShape> {
 	 * @param shapes - The shapes that are being dropped over this one.
 	 * @public
 	 */
-	onDropShapesOver?(shape: Shape, shapes: TLShape[], info: TLDropShapesOverInfo): void
+	onDropShapesOver?(shape: Shape, shapes: TLShape[]): void
 
 	/**
 	 * A callback called when a shape starts being resized.
@@ -746,37 +745,6 @@ export interface TLCropInfo<T extends TLShape> {
 	crop: TLShapeCrop
 	uncroppedSize: { w: number; h: number }
 	initialShape: T
-	aspectRatioLocked?: boolean
-}
-
-/** @public */
-export interface TLDragShapesInInfo {
-	initialDraggingOverShapeId: TLShapeId | null
-	prevDraggingOverShapeId: TLShapeId | null
-	initialParentIds: Map<TLShapeId, TLParentId>
-	initialIndices: Map<TLShapeId, IndexKey>
-}
-
-/** @public */
-export interface TLDragShapesOverInfo {
-	initialDraggingOverShapeId: TLShapeId | null
-	initialParentIds: Map<TLShapeId, TLParentId>
-	initialIndices: Map<TLShapeId, IndexKey>
-}
-
-/** @public */
-export interface TLDragShapesOutInfo {
-	nextDraggingOverShapeId: TLShapeId | null
-	initialDraggingOverShapeId: TLShapeId | null
-	initialParentIds: Map<TLShapeId, TLParentId>
-	initialIndices: Map<TLShapeId, IndexKey>
-}
-
-/** @public */
-export interface TLDropShapesOverInfo {
-	initialDraggingOverShapeId: TLShapeId | null
-	initialParentIds: Map<TLShapeId, TLParentId>
-	initialIndices: Map<TLShapeId, IndexKey>
 }
 
 /**

package/src/lib/editor/tools/StateNode.ts

@@ -206,15 +206,15 @@ export abstract class StateNode implements Partial<TLEventHandlers> {
 	}
 
 	// todo: move this logic into transition
-	exit(info: any, to: string) {
+	exit(info: any, from: string) {
 		if (debugFlags.measurePerformance.get() && this.performanceTracker.isStarted()) {
 			this.performanceTracker.stop()
 		}
 		this._isActive.set(false)
-		this.onExit?.(info, to)
+		this.onExit?.(info, from)
 
 		if (!this.getIsActive()) {
-			this.getCurrent()?.exit(info, to)
+			this.getCurrent()?.exit(info, from)
 		}
 	}
 

package/src/lib/editor/types/emit-types.ts

@@ -18,10 +18,6 @@ export interface TLEventMap {
 	frame: [number]
 	'select-all-text': [{ shapeId: TLShapeId }]
 	'place-caret': [{ shapeId: TLShapeId; point: { x: number; y: number } }]
-	'created-shapes': [TLRecord[]]
-	'edited-shapes': [TLRecord[]]
-	'deleted-shapes': [TLShapeId[]]
-	edit: []
 }
 
 /** @public */

package/src/lib/primitives/geometry/Geometry2d.ts

@@ -44,7 +44,6 @@ export const Geometry2dFilters: {
 /** @public */
 export interface TransformedGeometry2dOptions {
 	isLabel?: boolean
-	isEmptyLabel?: boolean
 	isInternal?: boolean
 	debugColor?: string
 	ignore?: boolean
@@ -58,24 +57,20 @@ export interface Geometry2dOptions extends TransformedGeometry2dOptions {
 
 /** @public */
 export abstract class Geometry2d {
-	// todo: consider making accessors for these too, so that they can be overridden in subclasses by geometries with more complex logic
 	isFilled = false
 	isClosed = true
 	isLabel = false
-	isEmptyLabel = false
 	isInternal = false
 	debugColor?: string
 	ignore?: boolean
 
 	constructor(opts: Geometry2dOptions) {
-		const { isLabel = false, isEmptyLabel = false, isInternal = false } = opts
 		this.isFilled = opts.isFilled
 		this.isClosed = opts.isClosed
+		this.isLabel = opts.isLabel ?? false
+		this.isInternal = opts.isInternal ?? false
 		this.debugColor = opts.debugColor
 		this.ignore = opts.ignore
-		this.isLabel = isLabel
-		this.isEmptyLabel = isEmptyLabel
-		this.isInternal = isInternal
 	}
 
 	isExcludedByFilter(filters?: Geometry2dFilters) {

package/src/version.ts

@@ -1,9 +1,9 @@
 // This file is automatically generated by internal/scripts/refresh-assets.ts.
 // Do not edit manually. Or do, I'm a comment, not a cop.
 
-export const version = '3.14.0-canary.6fbbca54ff57'
+export const version = '3.14.0-canary.718fcc03811e'
 export const publishDates = {
 	major: '2024-09-13T14:36:29.063Z',
-	minor: '2025-06-24T16:09:26.541Z',
-	patch: '2025-06-24T16:09:26.541Z',
+	minor: '2025-06-18T12:23:40.139Z',
+	patch: '2025-06-18T12:23:40.139Z',
 }

package/dist-cjs/lib/utils/reparenting.js

@@ -1,232 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var reparenting_exports = {};
-__export(reparenting_exports, {
-  doesGeometryOverlapPolygon: () => doesGeometryOverlapPolygon,
-  getDroppedShapesToNewParents: () => getDroppedShapesToNewParents,
-  kickoutOccludedShapes: () => kickoutOccludedShapes
-});
-module.exports = __toCommonJS(reparenting_exports);
-var import_state = require("@tldraw/state");
-var import_utils = require("@tldraw/utils");
-var import_Group2d = require("../primitives/geometry/Group2d");
-var import_intersect = require("../primitives/intersect");
-var import_utils2 = require("../primitives/utils");
-function kickoutOccludedShapes(editor, shapeIds, opts) {
-  const parentsToCheck = /* @__PURE__ */ new Set();
-  for (const id of shapeIds) {
-    const shape = editor.getShape(id);
-    if (!shape) continue;
-    parentsToCheck.add(shape);
-    const parent = editor.getShape(shape.parentId);
-    if (!parent) continue;
-    parentsToCheck.add(parent);
-  }
-  const parentsToLostChildren = /* @__PURE__ */ new Map();
-  for (const parent of parentsToCheck) {
-    const childIds = editor.getSortedChildIdsForParent(parent);
-    if (opts?.filter && !opts.filter(parent)) {
-      parentsToLostChildren.set(parent, childIds);
-    } else {
-      const overlappingChildren = getOverlappingShapes(editor, parent.id, childIds);
-      if (overlappingChildren.length < childIds.length) {
-        parentsToLostChildren.set(
-          parent,
-          childIds.filter((id) => !overlappingChildren.includes(id))
-        );
-      }
-    }
-  }
-  const sortedShapeIds = editor.getCurrentPageShapesSorted().map((s) => s.id);
-  const parentsToNewChildren = {};
-  for (const [prevParent, lostChildrenIds] of parentsToLostChildren) {
-    const lostChildren = (0, import_utils.compact)(lostChildrenIds.map((id) => editor.getShape(id)));
-    const { reparenting, remainingShapesToReparent } = getDroppedShapesToNewParents(
-      editor,
-      lostChildren,
-      (shape, maybeNewParent) => {
-        if (opts?.filter && !opts.filter(maybeNewParent)) return false;
-        return maybeNewParent.id !== prevParent.id && sortedShapeIds.indexOf(maybeNewParent.id) < sortedShapeIds.indexOf(shape.id);
-      }
-    );
-    reparenting.forEach((childrenToReparent, newParentId) => {
-      if (childrenToReparent.length === 0) return;
-      if (!parentsToNewChildren[newParentId]) {
-        parentsToNewChildren[newParentId] = {
-          parentId: newParentId,
-          shapeIds: []
-        };
-      }
-      parentsToNewChildren[newParentId].shapeIds.push(...childrenToReparent.map((s) => s.id));
-    });
-    if (remainingShapesToReparent.size > 0) {
-      const newParentId = editor.findShapeAncestor(prevParent, (s) => editor.isShapeOfType(s, "group"))?.id ?? editor.getCurrentPageId();
-      remainingShapesToReparent.forEach((shape) => {
-        if (!parentsToNewChildren[newParentId]) {
-          let insertIndexKey;
-          const oldParentSiblingIds = editor.getSortedChildIdsForParent(newParentId);
-          const oldParentIndex = oldParentSiblingIds.indexOf(prevParent.id);
-          if (oldParentIndex > -1) {
-            const siblingsIndexAbove = oldParentSiblingIds[oldParentIndex + 1];
-            const indexKeyAbove = siblingsIndexAbove ? editor.getShape(siblingsIndexAbove).index : (0, import_utils.getIndexAbove)(prevParent.index);
-            insertIndexKey = (0, import_utils.getIndexBetween)(prevParent.index, indexKeyAbove);
-          } else {
-          }
-          parentsToNewChildren[newParentId] = {
-            parentId: newParentId,
-            shapeIds: [],
-            index: insertIndexKey
-          };
-        }
-        parentsToNewChildren[newParentId].shapeIds.push(shape.id);
-      });
-    }
-  }
-  editor.run(() => {
-    Object.values(parentsToNewChildren).forEach(({ parentId, shapeIds: shapeIds2, index }) => {
-      if (shapeIds2.length === 0) return;
-      shapeIds2.sort((a, b) => sortedShapeIds.indexOf(a) < sortedShapeIds.indexOf(b) ? -1 : 1);
-      editor.reparentShapes(shapeIds2, parentId, index);
-    });
-  });
-}
-function getOverlappingShapes(editor, shape, otherShapes) {
-  if (otherShapes.length === 0) {
-    return import_state.EMPTY_ARRAY;
-  }
-  const parentPageBounds = editor.getShapePageBounds(shape);
-  if (!parentPageBounds) return import_state.EMPTY_ARRAY;
-  const parentGeometry = editor.getShapeGeometry(shape);
-  const parentPageTransform = editor.getShapePageTransform(shape);
-  const parentPageCorners = parentPageTransform.applyToPoints(parentGeometry.vertices);
-  const parentPageMaskVertices = editor.getShapeMask(shape);
-  const parentPagePolygon = parentPageMaskVertices ? (0, import_intersect.intersectPolygonPolygon)(parentPageMaskVertices, parentPageCorners) : parentPageCorners;
-  if (!parentPagePolygon) return import_state.EMPTY_ARRAY;
-  return otherShapes.filter((childId) => {
-    const shapePageBounds = editor.getShapePageBounds(childId);
-    if (!shapePageBounds || !parentPageBounds.includes(shapePageBounds)) return false;
-    const parentPolygonInShapeShape = editor.getShapePageTransform(childId).clone().invert().applyToPoints(parentPagePolygon);
-    const geometry = editor.getShapeGeometry(childId);
-    return doesGeometryOverlapPolygon(geometry, parentPolygonInShapeShape);
-  });
-}
-function doesGeometryOverlapPolygon(geometry, parentCornersInShapeSpace) {
-  if (geometry instanceof import_Group2d.Group2d) {
-    return geometry.children.some(
-      (childGeometry) => doesGeometryOverlapPolygon(childGeometry, parentCornersInShapeSpace)
-    );
-  }
-  const { vertices, center, isFilled, isEmptyLabel, isClosed } = geometry;
-  if (isEmptyLabel) return false;
-  if (vertices.some((v) => (0, import_utils2.pointInPolygon)(v, parentCornersInShapeSpace))) {
-    return true;
-  }
-  if (isClosed) {
-    if (isFilled) {
-      if ((0, import_utils2.pointInPolygon)(center, parentCornersInShapeSpace)) {
-        return true;
-      }
-      if (parentCornersInShapeSpace.every((v) => (0, import_utils2.pointInPolygon)(v, vertices))) {
-        return true;
-      }
-    }
-    if ((0, import_intersect.polygonsIntersect)(parentCornersInShapeSpace, vertices)) {
-      return true;
-    }
-  } else {
-    if ((0, import_intersect.polygonIntersectsPolyline)(parentCornersInShapeSpace, vertices)) {
-      return true;
-    }
-  }
-  return false;
-}
-function getDroppedShapesToNewParents(editor, shapes, cb) {
-  const shapesToActuallyCheck = new Set(shapes);
-  const movingGroups = /* @__PURE__ */ new Set();
-  for (const shape of shapes) {
-    const parent = editor.getShapeParent(shape);
-    if (parent && editor.isShapeOfType(parent, "group")) {
-      if (!movingGroups.has(parent)) {
-        movingGroups.add(parent);
-      }
-    }
-  }
-  for (const movingGroup of movingGroups) {
-    const children = (0, import_utils.compact)(
-      editor.getSortedChildIdsForParent(movingGroup).map((id) => editor.getShape(id))
-    );
-    for (const child of children) {
-      shapesToActuallyCheck.delete(child);
-    }
-    shapesToActuallyCheck.add(movingGroup);
-  }
-  const shapeGroupIds = /* @__PURE__ */ new Map();
-  const reparenting = /* @__PURE__ */ new Map();
-  const remainingShapesToReparent = new Set(shapesToActuallyCheck);
-  const potentialParentShapes = editor.getCurrentPageShapesSorted().filter(
-    (s) => editor.getShapeUtil(s).canReceiveNewChildrenOfType?.(s, s.type) && !remainingShapesToReparent.has(s)
-  );
-  parentCheck: for (let i = potentialParentShapes.length - 1; i >= 0; i--) {
-    const parentShape = potentialParentShapes[i];
-    const parentShapeContainingGroupId = editor.findShapeAncestor(
-      parentShape,
-      (s) => editor.isShapeOfType(s, "group")
-    )?.id;
-    const parentGeometry = editor.getShapeGeometry(parentShape);
-    const parentPageTransform = editor.getShapePageTransform(parentShape);
-    const parentPageMaskVertices = editor.getShapeMask(parentShape);
-    const parentPageCorners = parentPageTransform.applyToPoints(parentGeometry.vertices);
-    const parentPagePolygon = parentPageMaskVertices ? (0, import_intersect.intersectPolygonPolygon)(parentPageMaskVertices, parentPageCorners) : parentPageCorners;
-    if (!parentPagePolygon) continue parentCheck;
-    const childrenToReparent = [];
-    shapeCheck: for (const shape of remainingShapesToReparent) {
-      if (parentShape.id === shape.id) continue shapeCheck;
-      if (cb && !cb(shape, parentShape)) continue shapeCheck;
-      if (!shapeGroupIds.has(shape.id)) {
-        shapeGroupIds.set(
-          shape.id,
-          editor.findShapeAncestor(shape, (s) => editor.isShapeOfType(s, "group"))?.id
-        );
-      }
-      const shapeGroupId = shapeGroupIds.get(shape.id);
-      if (shapeGroupId !== parentShapeContainingGroupId) continue shapeCheck;
-      if (editor.findShapeAncestor(parentShape, (s) => shape.id === s.id)) continue shapeCheck;
-      const parentPolygonInShapeSpace = editor.getShapePageTransform(shape).clone().invert().applyToPoints(parentPagePolygon);
-      if (doesGeometryOverlapPolygon(editor.getShapeGeometry(shape), parentPolygonInShapeSpace)) {
-        if (!editor.getShapeUtil(parentShape).canReceiveNewChildrenOfType?.(parentShape, shape.type))
-          continue shapeCheck;
-        if (shape.parentId !== parentShape.id) {
-          childrenToReparent.push(shape);
-        }
-        remainingShapesToReparent.delete(shape);
-        continue shapeCheck;
-      }
-    }
-    if (childrenToReparent.length) {
-      reparenting.set(parentShape.id, childrenToReparent);
-    }
-  }
-  return {
-    // these are the shapes that will be reparented to new parents
-    reparenting,
-    // these are the shapes that will be reparented to the page or their ancestral group
-    remainingShapesToReparent
-  };
-}
-//# sourceMappingURL=reparenting.js.map