@excalidraw/element 0.18.0-1b287a8ba → 0.18.0-39ce38a0d-200a6bd94

package/dist/dev/index.js

@@ -8127,7 +8127,8 @@ var LinearElementEditor = class _LinearElementEditor {
   segmentMidPointHoveredCoords;
   elbowed;
   customLineAngle;
-  constructor(element, elementsMap) {
+  isEditing;
+  constructor(element, elementsMap, isEditing = false) {
     this.elementId = element.id;
     if (!pointsEqual6(element.points[0], pointFrom8(0, 0))) {
       console.error("Linear element is not normalized", Error().stack);
@@ -8158,6 +8159,7 @@ var LinearElementEditor = class _LinearElementEditor {
     this.segmentMidPointHoveredCoords = null;
     this.elbowed = isElbowArrow(element) && element.elbowed;
     this.customLineAngle = null;
+    this.isEditing = isEditing;
   }
   // ---------------------------------------------------------------------------
   // static methods
@@ -8175,11 +8177,11 @@ var LinearElementEditor = class _LinearElementEditor {
     return null;
   }
   static handleBoxSelection(event, appState, setState, elementsMap) {
-    if (!appState.editingLinearElement || !appState.selectionElement) {
+    if (!appState.selectedLinearElement?.isEditing || !appState.selectionElement) {
       return false;
     }
-    const { editingLinearElement } = appState;
-    const { selectedPointsIndices, elementId } = editingLinearElement;
+    const { selectedLinearElement } = appState;
+    const { selectedPointsIndices, elementId } = selectedLinearElement;
     const element = _LinearElementEditor.getElement(elementId, elementsMap);
     if (!element) {
       return false;
@@ -8201,8 +8203,8 @@ var LinearElementEditor = class _LinearElementEditor {
       return true;
     });
     setState({
-      editingLinearElement: {
-        ...editingLinearElement,
+      selectedLinearElement: {
+        ...selectedLinearElement,
         selectedPointsIndices: nextSelectedPoints.length ? nextSelectedPoints : null
       }
     });
@@ -8356,7 +8358,6 @@ var LinearElementEditor = class _LinearElementEditor {
       };
       return {
         ...app.state,
-        editingLinearElement: app.state.editingLinearElement ? newLinearElementEditor : null,
         selectedLinearElement: newLinearElementEditor,
         suggestedBindings
       };
@@ -8440,7 +8441,7 @@ var LinearElementEditor = class _LinearElementEditor {
   }
   static getEditorMidPoints = (element, elementsMap, appState) => {
     const boundText = getBoundTextElement(element, elementsMap);
-    if (!isElbowArrow(element) && !appState.editingLinearElement && element.points.length > 2 && !boundText) {
+    if (!isElbowArrow(element) && !appState.selectedLinearElement?.isEditing && element.points.length > 2 && !boundText) {
       return [];
     }
     const points = _LinearElementEditor.getPointsGlobalCoordinates(
@@ -8490,7 +8491,7 @@ var LinearElementEditor = class _LinearElementEditor {
       element,
       elementsMap
     );
-    if (points.length >= 3 && !appState.editingLinearElement && !isElbowArrow(element)) {
+    if (points.length >= 3 && !appState.selectedLinearElement?.isEditing && !isElbowArrow(element)) {
       return null;
     }
     const threshold = (_LinearElementEditor.POINT_HANDLE_SIZE + 1) / appState.zoom.value;
@@ -8630,7 +8631,7 @@ var LinearElementEditor = class _LinearElementEditor {
         segmentMidpoint,
         elementsMap
       );
-    } else if (event.altKey && appState.editingLinearElement) {
+    } else if (event.altKey && appState.selectedLinearElement?.isEditing) {
       if (linearElementEditor.lastUncommittedPoint == null) {
         scene.mutateElement(element, {
           points: [
@@ -8740,14 +8741,14 @@ var LinearElementEditor = class _LinearElementEditor {
   }
   static handlePointerMove(event, scenePointerX, scenePointerY, app) {
     const appState = app.state;
-    if (!appState.editingLinearElement) {
+    if (!appState.selectedLinearElement?.isEditing) {
       return null;
     }
-    const { elementId, lastUncommittedPoint } = appState.editingLinearElement;
+    const { elementId, lastUncommittedPoint } = appState.selectedLinearElement;
     const elementsMap = app.scene.getNonDeletedElementsMap();
     const element = _LinearElementEditor.getElement(elementId, elementsMap);
     if (!element) {
-      return appState.editingLinearElement;
+      return appState.selectedLinearElement;
     }
     const { points } = element;
     const lastPoint = points[points.length - 1];
@@ -8755,10 +8756,10 @@ var LinearElementEditor = class _LinearElementEditor {
       if (lastPoint === lastUncommittedPoint) {
         _LinearElementEditor.deletePoints(element, app, [points.length - 1]);
       }
-      return {
-        ...appState.editingLinearElement,
+      return appState.selectedLinearElement?.lastUncommittedPoint ? {
+        ...appState.selectedLinearElement,
         lastUncommittedPoint: null
-      };
+      } : appState.selectedLinearElement;
     }
     let newPoint;
     if (shouldRotateWithDiscreteAngle(event) && points.length >= 2) {
@@ -8778,8 +8779,8 @@ var LinearElementEditor = class _LinearElementEditor {
       newPoint = _LinearElementEditor.createPointAt(
         element,
         elementsMap,
-        scenePointerX - appState.editingLinearElement.pointerOffset.x,
-        scenePointerY - appState.editingLinearElement.pointerOffset.y,
+        scenePointerX - appState.selectedLinearElement.pointerOffset.x,
+        scenePointerY - appState.selectedLinearElement.pointerOffset.y,
         event[KEYS2.CTRL_OR_CMD] || isElbowArrow(element) ? null : app.getEffectiveGridSize()
       );
     }
@@ -8800,7 +8801,7 @@ var LinearElementEditor = class _LinearElementEditor {
       _LinearElementEditor.addPoints(element, app.scene, [newPoint]);
     }
     return {
-      ...appState.editingLinearElement,
+      ...appState.selectedLinearElement,
       lastUncommittedPoint: element.points[element.points.length - 1]
     };
   }
@@ -8906,11 +8907,11 @@ var LinearElementEditor = class _LinearElementEditor {
   // ---------------------------------------------------------------------------
   static duplicateSelectedPoints(appState, scene) {
     invariant6(
-      appState.editingLinearElement,
+      appState.selectedLinearElement?.isEditing,
       "Not currently editing a linear element"
     );
     const elementsMap = scene.getNonDeletedElementsMap();
-    const { selectedPointsIndices, elementId } = appState.editingLinearElement;
+    const { selectedPointsIndices, elementId } = appState.selectedLinearElement;
     const element = _LinearElementEditor.getElement(elementId, elementsMap);
     invariant6(
       element,
@@ -8957,14 +8958,14 @@ var LinearElementEditor = class _LinearElementEditor {
     }
     return {
       ...appState,
-      editingLinearElement: {
-        ...appState.editingLinearElement,
+      selectedLinearElement: {
+        ...appState.selectedLinearElement,
         selectedPointsIndices: nextSelectedIndices
       }
     };
   }
   static deletePoints(element, app, pointIndices) {
-    const isUncommittedPoint = app.state.editingLinearElement?.lastUncommittedPoint === element.points[element.points.length - 1];
+    const isUncommittedPoint = app.state.selectedLinearElement?.isEditing && app.state.selectedLinearElement?.lastUncommittedPoint === element.points[element.points.length - 1];
     const nextPoints = element.points.filter((_, idx) => {
       return !pointIndices.includes(idx);
     });
@@ -9073,7 +9074,7 @@ var LinearElementEditor = class _LinearElementEditor {
       pointFrom8(origin.x, origin.y),
       pointFrom8(pointerCoords.x, pointerCoords.y)
     );
-    if (!appState.editingLinearElement && dist < DRAGGING_THRESHOLD / appState.zoom.value) {
+    if (!appState.selectedLinearElement?.isEditing && dist < DRAGGING_THRESHOLD / appState.zoom.value) {
       return false;
     }
     return true;
@@ -10562,6 +10563,11 @@ var getCanvasPadding = (element) => {
       return element.strokeWidth * 12;
     case "text":
       return element.fontSize / 2;
+    case "arrow":
+      if (element.endArrowhead || element.endArrowhead) {
+        return 40;
+      }
+      return 20;
     default:
       return 20;
   }
@@ -13231,8 +13237,9 @@ var Store = class {
   constructor(app) {
     this.app = app;
   }
-  // internally used by history
+  // for internal use by history
   onDurableIncrementEmitter = new Emitter();
+  // for public use as part of onIncrement API
   onStoreIncrementEmitter = new Emitter();
   scheduledMacroActions = /* @__PURE__ */ new Set();
   scheduledMicroActions = [];
@@ -13808,14 +13815,14 @@ var getDefaultObservedAppState = () => {
     viewBackgroundColor: COLOR_PALETTE2.white,
     selectedElementIds: {},
     selectedGroupIds: {},
-    editingLinearElementId: null,
-    selectedLinearElementId: null,
+    activeLinearElement: null,
     croppingElementId: null,
     activeLockedId: null,
     lockedMultiSelections: {}
   };
 };
 var getObservedAppState = (appState) => {
+  const selectedLinearElement = appState.selectedLinearElement;
   const observedAppState = {
     name: appState.name,
     editingGroupId: appState.editingGroupId,
@@ -13825,10 +13832,10 @@ var getObservedAppState = (appState) => {
     croppingElementId: appState.croppingElementId,
     activeLockedId: appState.activeLockedId,
     lockedMultiSelections: appState.lockedMultiSelections,
-    editingLinearElementId: appState.editingLinearElement?.elementId ?? // prefer app state, as it's likely newer
-    appState.editingLinearElementId ?? // fallback to observed app state, as it's likely older coming from a previous snapshot
-    null,
-    selectedLinearElementId: appState.selectedLinearElement?.elementId ?? appState.selectedLinearElementId ?? null
+    activeLinearElement: selectedLinearElement ? {
+      id: selectedLinearElement.elementId,
+      isEditing: !!selectedLinearElement.isEditing
+    } : appState.activeLinearElement ?? null
   };
   Reflect.defineProperty(observedAppState, hiddenObservedAppStateProp, {
     value: true,
@@ -14632,6 +14639,15 @@ var Delta = class _Delta {
   static isEmpty(delta) {
     return !Object.keys(delta.deleted).length && !Object.keys(delta.inserted).length;
   }
+  /**
+   * Merges two deltas into a new one.
+   */
+  static merge(delta1, delta2) {
+    return _Delta.create(
+      { ...delta1.deleted, ...delta2.deleted },
+      { ...delta1.inserted, ...delta2.inserted }
+    );
+  }
   /**
    * Merges deleted and inserted object partials.
    */
@@ -14877,6 +14893,10 @@ var AppStateDelta = class _AppStateDelta {
     const inversedDelta = Delta.create(this.delta.inserted, this.delta.deleted);
     return new _AppStateDelta(inversedDelta);
   }
+  squash(delta) {
+    this.delta = Delta.merge(this.delta, delta.delta);
+    return this;
+  }
   applyTo(appState, nextElements) {
     try {
       const {
@@ -14886,8 +14906,7 @@ var AppStateDelta = class _AppStateDelta {
       const {
         selectedElementIds: addedSelectedElementIds = {},
         selectedGroupIds: addedSelectedGroupIds = {},
-        selectedLinearElementId,
-        editingLinearElementId,
+        activeLinearElement,
         ...directlyApplicablePartial
       } = this.delta.inserted;
       const mergedSelectedElementIds = Delta.mergeObjects(
@@ -14900,27 +14919,19 @@ var AppStateDelta = class _AppStateDelta {
         addedSelectedGroupIds,
         removedSelectedGroupIds
       );
-      const selectedLinearElement = selectedLinearElementId && nextElements.has(selectedLinearElementId) ? new LinearElementEditor(
+      const selectedLinearElement = activeLinearElement && nextElements.has(activeLinearElement.id) ? new LinearElementEditor(
         nextElements.get(
-          selectedLinearElementId
+          activeLinearElement.id
         ),
-        nextElements
-      ) : null;
-      const editingLinearElement = editingLinearElementId && nextElements.has(editingLinearElementId) ? new LinearElementEditor(
-        nextElements.get(
-          editingLinearElementId
-        ),
-        nextElements
+        nextElements,
+        activeLinearElement.isEditing
       ) : null;
       const nextAppState = {
         ...appState,
         ...directlyApplicablePartial,
         selectedElementIds: mergedSelectedElementIds,
         selectedGroupIds: mergedSelectedGroupIds,
-        selectedLinearElement: typeof selectedLinearElementId !== "undefined" ? selectedLinearElement : appState.selectedLinearElement,
-        // otherwise assign what we had before
-        editingLinearElement: typeof editingLinearElementId !== "undefined" ? editingLinearElement : appState.editingLinearElement
-        // otherwise assign what we had before
+        selectedLinearElement: typeof activeLinearElement !== "undefined" ? selectedLinearElement : appState.selectedLinearElement
       };
       const constainsVisibleChanges = this.filterInvisibleChanges(
         appState,
@@ -15010,14 +15021,13 @@ var AppStateDelta = class _AppStateDelta {
               nextAppState[key] = null;
             }
             break;
-          case "selectedLinearElementId":
-          case "editingLinearElementId":
+          case "activeLinearElement":
             const appStateKey = _AppStateDelta.convertToAppStateKey(key);
-            const linearElement = nextAppState[appStateKey];
-            if (!linearElement) {
+            const nextLinearElement = nextAppState[appStateKey];
+            if (!nextLinearElement) {
               visibleDifferenceFlag.value = true;
             } else {
-              const element = nextElements.get(linearElement.elementId);
+              const element = nextElements.get(nextLinearElement.elementId);
               if (element && !element.isDeleted) {
                 visibleDifferenceFlag.value = true;
               } else {
@@ -15025,29 +15035,26 @@ var AppStateDelta = class _AppStateDelta {
               }
             }
             break;
-          case "lockedMultiSelections": {
+          case "lockedMultiSelections":
             const prevLockedUnits = prevAppState[key] || {};
             const nextLockedUnits = nextAppState[key] || {};
             if (!isShallowEqual2(prevLockedUnits, nextLockedUnits)) {
               visibleDifferenceFlag.value = true;
             }
             break;
-          }
-          case "activeLockedId": {
+          case "activeLockedId":
             const prevHitLockedId = prevAppState[key] || null;
             const nextHitLockedId = nextAppState[key] || null;
             if (prevHitLockedId !== nextHitLockedId) {
               visibleDifferenceFlag.value = true;
             }
             break;
-          }
-          default: {
+          default:
             assertNever4(
               key,
               `Unknown ObservedElementsAppState's key "${key}"`,
               true
             );
-          }
         }
       }
     }
@@ -15055,10 +15062,8 @@ var AppStateDelta = class _AppStateDelta {
   }
   static convertToAppStateKey(key) {
     switch (key) {
-      case "selectedLinearElementId":
+      case "activeLinearElement":
         return "selectedLinearElement";
-      case "editingLinearElementId":
-        return "editingLinearElement";
     }
   }
   static filterSelectedElements(selectedElementIds, elements, visibleDifferenceFlag) {
@@ -15099,8 +15104,7 @@ var AppStateDelta = class _AppStateDelta {
       editingGroupId,
       selectedGroupIds,
       selectedElementIds,
-      editingLinearElementId,
-      selectedLinearElementId,
+      activeLinearElement,
       croppingElementId,
       lockedMultiSelections,
       activeLockedId,
@@ -15319,8 +15323,8 @@ var ElementsDelta = class _ElementsDelta {
   inverse() {
     const inverseInternal = (deltas) => {
       const inversedDeltas = {};
-      for (const [id, delta] of Object.entries(deltas)) {
-        inversedDeltas[id] = Delta.create(delta.inserted, delta.deleted);
+      for (const [id, { inserted, deleted }] of Object.entries(deltas)) {
+        inversedDeltas[id] = Delta.create({ ...inserted }, { ...deleted });
       }
       return inversedDeltas;
     };
@@ -15452,6 +15456,34 @@ var ElementsDelta = class _ElementsDelta {
       return [nextElements, flags.containsVisibleDifference];
     }
   }
+  squash(delta) {
+    const { added, removed, updated } = delta;
+    for (const [id, nextDelta] of Object.entries(added)) {
+      const prevDelta = this.added[id];
+      if (!prevDelta) {
+        this.added[id] = nextDelta;
+      } else {
+        this.added[id] = Delta.merge(prevDelta, nextDelta);
+      }
+    }
+    for (const [id, nextDelta] of Object.entries(removed)) {
+      const prevDelta = this.removed[id];
+      if (!prevDelta) {
+        this.removed[id] = nextDelta;
+      } else {
+        this.removed[id] = Delta.merge(prevDelta, nextDelta);
+      }
+    }
+    for (const [id, nextDelta] of Object.entries(updated)) {
+      const prevDelta = this.updated[id];
+      if (!prevDelta) {
+        this.updated[id] = nextDelta;
+      } else {
+        this.updated[id] = Delta.merge(prevDelta, nextDelta);
+      }
+    }
+    return this;
+  }
   static createApplier = (nextElements, snapshot, options, flags) => (deltas) => {
     const getElement = _ElementsDelta.createGetter(
       nextElements,
@@ -15595,19 +15627,10 @@ var ElementsDelta = class _ElementsDelta {
     const prevAffectedElements = new Map(
       Array.from(prevElements).filter(([id]) => nextAffectedElements.has(id))
     );
-    const { added, removed, updated } = _ElementsDelta.calculate(
-      prevAffectedElements,
-      nextAffectedElements
+    this.squash(
+      // technically we could do better here if perf. would become an issue
+      _ElementsDelta.calculate(prevAffectedElements, nextAffectedElements)
     );
-    for (const [id, delta] of Object.entries(added)) {
-      this.added[id] = delta;
-    }
-    for (const [id, delta] of Object.entries(removed)) {
-      this.removed[id] = delta;
-    }
-    for (const [id, delta] of Object.entries(updated)) {
-      this.updated[id] = delta;
-    }
     return nextAffectedElements;
   }
   /**
@@ -18453,7 +18476,7 @@ var getTransformHandles = (element, zoom, elementsMap, pointerType = "mouse", om
   );
 };
 var shouldShowBoundingBox = (elements, appState) => {
-  if (appState.editingLinearElement) {
+  if (appState.selectedLinearElement?.isEditing) {
     return false;
   }
   if (elements.length > 1) {