fix: checkbox position misaligned caused by margin

examples/excalidraw/with-script-in-browser/package.json

@@ -8,7 +8,7 @@
     "@excalidraw/excalidraw": "*"
   },
   "devDependencies": {
-    "vite": "5.4.12",
+    "vite": "5.0.12",
     "typescript": "^5"
   },
   "scripts": {

packages/excalidraw/actions/actionDeleteSelected.test.tsx

@@ -1,211 +0,0 @@
-import React from "react";
-import { Excalidraw, mutateElement } from "../index";
-import { act, assertElements, render } from "../tests/test-utils";
-import { API } from "../tests/helpers/api";
-import { actionDeleteSelected } from "./actionDeleteSelected";
-
-const { h } = window;
-
-describe("deleting selected elements when frame selected should keep children + select them", () => {
-  beforeEach(async () => {
-    await render(<Excalidraw />);
-  });
-
-  it("frame only", async () => {
-    const f1 = API.createElement({
-      type: "frame",
-    });
-
-    const r1 = API.createElement({
-      type: "rectangle",
-      frameId: f1.id,
-    });
-
-    API.setElements([f1, r1]);
-
-    API.setSelectedElements([f1]);
-
-    act(() => {
-      h.app.actionManager.executeAction(actionDeleteSelected);
-    });
-
-    assertElements(h.elements, [
-      { id: f1.id, isDeleted: true },
-      { id: r1.id, isDeleted: false, selected: true },
-    ]);
-  });
-
-  it("frame + text container (text's frameId set)", async () => {
-    const f1 = API.createElement({
-      type: "frame",
-    });
-
-    const r1 = API.createElement({
-      type: "rectangle",
-      frameId: f1.id,
-    });
-
-    const t1 = API.createElement({
-      type: "text",
-      width: 200,
-      height: 100,
-      fontSize: 20,
-      containerId: r1.id,
-      frameId: f1.id,
-    });
-
-    mutateElement(r1, {
-      boundElements: [{ type: "text", id: t1.id }],
-    });
-
-    API.setElements([f1, r1, t1]);
-
-    API.setSelectedElements([f1]);
-
-    act(() => {
-      h.app.actionManager.executeAction(actionDeleteSelected);
-    });
-
-    assertElements(h.elements, [
-      { id: f1.id, isDeleted: true },
-      { id: r1.id, isDeleted: false, selected: true },
-      { id: t1.id, isDeleted: false },
-    ]);
-  });
-
-  it("frame + text container (text's frameId not set)", async () => {
-    const f1 = API.createElement({
-      type: "frame",
-    });
-
-    const r1 = API.createElement({
-      type: "rectangle",
-      frameId: f1.id,
-    });
-
-    const t1 = API.createElement({
-      type: "text",
-      width: 200,
-      height: 100,
-      fontSize: 20,
-      containerId: r1.id,
-      frameId: null,
-    });
-
-    mutateElement(r1, {
-      boundElements: [{ type: "text", id: t1.id }],
-    });
-
-    API.setElements([f1, r1, t1]);
-
-    API.setSelectedElements([f1]);
-
-    act(() => {
-      h.app.actionManager.executeAction(actionDeleteSelected);
-    });
-
-    assertElements(h.elements, [
-      { id: f1.id, isDeleted: true },
-      { id: r1.id, isDeleted: false, selected: true },
-      { id: t1.id, isDeleted: false },
-    ]);
-  });
-
-  it("frame + text container (text selected too)", async () => {
-    const f1 = API.createElement({
-      type: "frame",
-    });
-
-    const r1 = API.createElement({
-      type: "rectangle",
-      frameId: f1.id,
-    });
-
-    const t1 = API.createElement({
-      type: "text",
-      width: 200,
-      height: 100,
-      fontSize: 20,
-      containerId: r1.id,
-      frameId: null,
-    });
-
-    mutateElement(r1, {
-      boundElements: [{ type: "text", id: t1.id }],
-    });
-
-    API.setElements([f1, r1, t1]);
-
-    API.setSelectedElements([f1, t1]);
-
-    act(() => {
-      h.app.actionManager.executeAction(actionDeleteSelected);
-    });
-
-    assertElements(h.elements, [
-      { id: f1.id, isDeleted: true },
-      { id: r1.id, isDeleted: false, selected: true },
-      { id: t1.id, isDeleted: false },
-    ]);
-  });
-
-  it("frame + labeled arrow", async () => {
-    const f1 = API.createElement({
-      type: "frame",
-    });
-
-    const a1 = API.createElement({
-      type: "arrow",
-      frameId: f1.id,
-    });
-
-    const t1 = API.createElement({
-      type: "text",
-      width: 200,
-      height: 100,
-      fontSize: 20,
-      containerId: a1.id,
-      frameId: null,
-    });
-
-    mutateElement(a1, {
-      boundElements: [{ type: "text", id: t1.id }],
-    });
-
-    API.setElements([f1, a1, t1]);
-
-    API.setSelectedElements([f1, t1]);
-
-    act(() => {
-      h.app.actionManager.executeAction(actionDeleteSelected);
-    });
-
-    assertElements(h.elements, [
-      { id: f1.id, isDeleted: true },
-      { id: a1.id, isDeleted: false, selected: true },
-      { id: t1.id, isDeleted: false },
-    ]);
-  });
-
-  it("frame + children selected", async () => {
-    const f1 = API.createElement({
-      type: "frame",
-    });
-    const r1 = API.createElement({
-      type: "rectangle",
-      frameId: f1.id,
-    });
-    API.setElements([f1, r1]);
-
-    API.setSelectedElements([f1, r1]);
-
-    act(() => {
-      h.app.actionManager.executeAction(actionDeleteSelected);
-    });
-
-    assertElements(h.elements, [
-      { id: f1.id, isDeleted: true },
-      { id: r1.id, isDeleted: false, selected: true },
-    ]);
-  });
-});

packages/excalidraw/actions/actionDeleteSelected.tsx

@@ -18,8 +18,6 @@ import {
 import { updateActiveTool } from "../utils";
 import { TrashIcon } from "../components/icons";
 import { StoreAction } from "../store";
-import { getContainerElement } from "../element/textElement";
-import { getFrameChildren } from "../frame";
 
 const deleteSelectedElements = (
   elements: readonly ExcalidrawElement[],
@@ -35,50 +33,10 @@ const deleteSelectedElements = (
 
   const selectedElementIds: Record<ExcalidrawElement["id"], true> = {};
 
-  const elementsMap = app.scene.getNonDeletedElementsMap();
-
-  const processedElements = new Set<ExcalidrawElement["id"]>();
-
-  for (const frameId of framesToBeDeleted) {
-    const frameChildren = getFrameChildren(elements, frameId);
-    for (const el of frameChildren) {
-      if (processedElements.has(el.id)) {
-        continue;
-      }
-
-      if (isBoundToContainer(el)) {
-        const containerElement = getContainerElement(el, elementsMap);
-        if (containerElement) {
-          selectedElementIds[containerElement.id] = true;
-        }
-      } else {
-        selectedElementIds[el.id] = true;
-      }
-      processedElements.add(el.id);
-    }
-  }
-
   let shouldSelectEditingGroup = true;
 
   const nextElements = elements.map((el) => {
     if (appState.selectedElementIds[el.id]) {
-      const boundElement = isBoundToContainer(el)
-        ? getContainerElement(el, elementsMap)
-        : null;
-
-      if (el.frameId && framesToBeDeleted.has(el.frameId)) {
-        shouldSelectEditingGroup = false;
-        selectedElementIds[el.id] = true;
-        return el;
-      }
-
-      if (
-        boundElement?.frameId &&
-        framesToBeDeleted.has(boundElement?.frameId)
-      ) {
-        return el;
-      }
-
       if (el.boundElements) {
         el.boundElements.forEach((candidate) => {
           const bound = app.scene.getNonDeletedElementsMap().get(candidate.id);
@@ -101,9 +59,7 @@ const deleteSelectedElements = (
     // if deleting a frame, remove the children from it and select them
     if (el.frameId && framesToBeDeleted.has(el.frameId)) {
       shouldSelectEditingGroup = false;
-      if (!isBoundToContainer(el)) {
-        selectedElementIds[el.id] = true;
-      }
+      selectedElementIds[el.id] = true;
       return newElementWith(el, { frameId: null });
     }
 
@@ -268,13 +224,11 @@ export const actionDeleteSelected = register({
         storeAction: StoreAction.CAPTURE,
       };
     }
-
     let { elements: nextElements, appState: nextAppState } =
       deleteSelectedElements(elements, appState, app);
-
     fixBindingsAfterDeletion(
       nextElements,
-      nextElements.filter((el) => el.isDeleted),
+      elements.filter(({ id }) => appState.selectedElementIds[id]),
     );
 
     nextAppState = handleGroupEditingState(nextAppState, nextElements);

packages/excalidraw/actions/actionDuplicateSelection.test.tsx

@@ -1,530 +0,0 @@
-import { Excalidraw } from "../index";
-import {
-  act,
-  assertElements,
-  getCloneByOrigId,
-  render,
-} from "../tests/test-utils";
-import { API } from "../tests/helpers/api";
-import { actionDuplicateSelection } from "./actionDuplicateSelection";
-import React from "react";
-import { ORIG_ID } from "../constants";
-
-const { h } = window;
-
-describe("actionDuplicateSelection", () => {
-  beforeEach(async () => {
-    await render(<Excalidraw />);
-  });
-
-  describe("duplicating frames", () => {
-    it("frame selected only", async () => {
-      const frame = API.createElement({
-        type: "frame",
-      });
-
-      const rectangle = API.createElement({
-        type: "rectangle",
-        frameId: frame.id,
-      });
-
-      API.setElements([frame, rectangle]);
-      API.setSelectedElements([frame]);
-
-      act(() => {
-        h.app.actionManager.executeAction(actionDuplicateSelection);
-      });
-
-      assertElements(h.elements, [
-        { id: frame.id },
-        { id: rectangle.id, frameId: frame.id },
-        { [ORIG_ID]: rectangle.id, frameId: getCloneByOrigId(frame.id)?.id },
-        { [ORIG_ID]: frame.id, selected: true },
-      ]);
-    });
-
-    it("frame selected only (with text container)", async () => {
-      const frame = API.createElement({
-        type: "frame",
-      });
-
-      const [rectangle, text] = API.createTextContainer({ frameId: frame.id });
-
-      API.setElements([frame, rectangle, text]);
-      API.setSelectedElements([frame]);
-
-      act(() => {
-        h.app.actionManager.executeAction(actionDuplicateSelection);
-      });
-
-      assertElements(h.elements, [
-        { id: frame.id },
-        { id: rectangle.id, frameId: frame.id },
-        { id: text.id, containerId: rectangle.id, frameId: frame.id },
-        { [ORIG_ID]: rectangle.id, frameId: getCloneByOrigId(frame.id)?.id },
-        {
-          [ORIG_ID]: text.id,
-          containerId: getCloneByOrigId(rectangle.id)?.id,
-          frameId: getCloneByOrigId(frame.id)?.id,
-        },
-        { [ORIG_ID]: frame.id, selected: true },
-      ]);
-    });
-
-    it("frame + text container selected (order A)", async () => {
-      const frame = API.createElement({
-        type: "frame",
-      });
-
-      const [rectangle, text] = API.createTextContainer({ frameId: frame.id });
-
-      API.setElements([frame, rectangle, text]);
-      API.setSelectedElements([frame, rectangle]);
-
-      act(() => {
-        h.app.actionManager.executeAction(actionDuplicateSelection);
-      });
-
-      assertElements(h.elements, [
-        { id: frame.id },
-        { id: rectangle.id, frameId: frame.id },
-        { id: text.id, containerId: rectangle.id, frameId: frame.id },
-        {
-          [ORIG_ID]: rectangle.id,
-          frameId: getCloneByOrigId(frame.id)?.id,
-        },
-        {
-          [ORIG_ID]: text.id,
-          containerId: getCloneByOrigId(rectangle.id)?.id,
-          frameId: getCloneByOrigId(frame.id)?.id,
-        },
-        {
-          [ORIG_ID]: frame.id,
-          selected: true,
-        },
-      ]);
-    });
-
-    it("frame + text container selected (order B)", async () => {
-      const frame = API.createElement({
-        type: "frame",
-      });
-
-      const [rectangle, text] = API.createTextContainer({ frameId: frame.id });
-
-      API.setElements([text, rectangle, frame]);
-      API.setSelectedElements([rectangle, frame]);
-
-      act(() => {
-        h.app.actionManager.executeAction(actionDuplicateSelection);
-      });
-
-      assertElements(h.elements, [
-        { id: rectangle.id, frameId: frame.id },
-        { id: text.id, containerId: rectangle.id, frameId: frame.id },
-        { id: frame.id },
-        {
-          type: "rectangle",
-          [ORIG_ID]: `${rectangle.id}`,
-        },
-        {
-          [ORIG_ID]: `${text.id}`,
-          type: "text",
-          containerId: getCloneByOrigId(rectangle.id)?.id,
-          frameId: getCloneByOrigId(frame.id)?.id,
-        },
-        { [ORIG_ID]: `${frame.id}`, type: "frame", selected: true },
-      ]);
-    });
-  });
-
-  describe("duplicating frame children", () => {
-    it("frame child selected", () => {
-      const frame = API.createElement({
-        type: "frame",
-      });
-
-      const rectangle = API.createElement({
-        type: "rectangle",
-        frameId: frame.id,
-      });
-
-      API.setElements([frame, rectangle]);
-      API.setSelectedElements([rectangle]);
-
-      act(() => {
-        h.app.actionManager.executeAction(actionDuplicateSelection);
-      });
-
-      assertElements(h.elements, [
-        { id: frame.id },
-        { id: rectangle.id, frameId: frame.id },
-        { [ORIG_ID]: rectangle.id, frameId: frame.id, selected: true },
-      ]);
-    });
-
-    it("frame text container selected (rectangle selected)", () => {
-      const frame = API.createElement({
-        type: "frame",
-      });
-
-      const [rectangle, text] = API.createTextContainer({ frameId: frame.id });
-
-      API.setElements([frame, rectangle, text]);
-      API.setSelectedElements([rectangle]);
-
-      act(() => {
-        h.app.actionManager.executeAction(actionDuplicateSelection);
-      });
-
-      assertElements(h.elements, [
-        { id: frame.id },
-        { id: rectangle.id, frameId: frame.id },
-        { id: text.id, containerId: rectangle.id, frameId: frame.id },
-        { [ORIG_ID]: rectangle.id, frameId: frame.id, selected: true },
-        {
-          [ORIG_ID]: text.id,
-          containerId: getCloneByOrigId(rectangle.id).id,
-          frameId: frame.id,
-        },
-      ]);
-    });
-
-    it("frame bound text selected (container not selected)", () => {
-      const frame = API.createElement({
-        type: "frame",
-      });
-
-      const [rectangle, text] = API.createTextContainer({ frameId: frame.id });
-
-      API.setElements([frame, rectangle, text]);
-      API.setSelectedElements([text]);
-
-      act(() => {
-        h.app.actionManager.executeAction(actionDuplicateSelection);
-      });
-
-      assertElements(h.elements, [
-        { id: frame.id },
-        { id: rectangle.id, frameId: frame.id },
-        { id: text.id, containerId: rectangle.id, frameId: frame.id },
-        { [ORIG_ID]: rectangle.id, frameId: frame.id, selected: true },
-        {
-          [ORIG_ID]: text.id,
-          containerId: getCloneByOrigId(rectangle.id).id,
-          frameId: frame.id,
-        },
-      ]);
-    });
-
-    it("frame text container selected (text not exists)", () => {
-      const frame = API.createElement({
-        type: "frame",
-      });
-
-      const [rectangle] = API.createTextContainer({ frameId: frame.id });
-
-      API.setElements([frame, rectangle]);
-      API.setSelectedElements([rectangle]);
-
-      act(() => {
-        h.app.actionManager.executeAction(actionDuplicateSelection);
-      });
-
-      assertElements(h.elements, [
-        { id: frame.id },
-        { id: rectangle.id, frameId: frame.id },
-        { [ORIG_ID]: rectangle.id, frameId: frame.id, selected: true },
-      ]);
-    });
-
-    // shouldn't happen
-    it("frame bound text selected (container not exists)", () => {
-      const frame = API.createElement({
-        type: "frame",
-      });
-
-      const [, text] = API.createTextContainer({ frameId: frame.id });
-
-      API.setElements([frame, text]);
-      API.setSelectedElements([text]);
-
-      act(() => {
-        h.app.actionManager.executeAction(actionDuplicateSelection);
-      });
-
-      assertElements(h.elements, [
-        { id: frame.id },
-        { id: text.id, frameId: frame.id },
-        { [ORIG_ID]: text.id, frameId: frame.id },
-      ]);
-    });
-
-    it("frame bound container selected (text has no frameId)", () => {
-      const frame = API.createElement({
-        type: "frame",
-      });
-
-      const [rectangle, text] = API.createTextContainer({
-        frameId: frame.id,
-        label: { frameId: null },
-      });
-
-      API.setElements([frame, rectangle, text]);
-      API.setSelectedElements([rectangle]);
-
-      act(() => {
-        h.app.actionManager.executeAction(actionDuplicateSelection);
-      });
-
-      assertElements(h.elements, [
-        { id: frame.id },
-        { id: rectangle.id, frameId: frame.id },
-        { id: text.id, containerId: rectangle.id },
-        { [ORIG_ID]: rectangle.id, frameId: frame.id, selected: true },
-        {
-          [ORIG_ID]: text.id,
-          containerId: getCloneByOrigId(rectangle.id).id,
-        },
-      ]);
-    });
-  });
-
-  describe("duplicating multiple frames", () => {
-    it("multiple frames selected (no children)", () => {
-      const frame1 = API.createElement({
-        type: "frame",
-      });
-
-      const rect1 = API.createElement({
-        type: "rectangle",
-        frameId: frame1.id,
-      });
-
-      const frame2 = API.createElement({
-        type: "frame",
-      });
-
-      const rect2 = API.createElement({
-        type: "rectangle",
-        frameId: frame2.id,
-      });
-
-      const ellipse = API.createElement({
-        type: "ellipse",
-      });
-
-      API.setElements([rect1, frame1, ellipse, rect2, frame2]);
-      API.setSelectedElements([frame1, frame2]);
-
-      act(() => {
-        h.app.actionManager.executeAction(actionDuplicateSelection);
-      });
-
-      assertElements(h.elements, [
-        { id: rect1.id, frameId: frame1.id },
-        { id: frame1.id },
-        { [ORIG_ID]: rect1.id, frameId: getCloneByOrigId(frame1.id)?.id },
-        { [ORIG_ID]: frame1.id, selected: true },
-        { id: ellipse.id },
-        { id: rect2.id, frameId: frame2.id },
-        { id: frame2.id },
-        { [ORIG_ID]: rect2.id, frameId: getCloneByOrigId(frame2.id)?.id },
-        { [ORIG_ID]: frame2.id, selected: true },
-      ]);
-    });
-
-    it("multiple frames selected (no children) + unrelated element", () => {
-      const frame1 = API.createElement({
-        type: "frame",
-      });
-
-      const rect1 = API.createElement({
-        type: "rectangle",
-        frameId: frame1.id,
-      });
-
-      const frame2 = API.createElement({
-        type: "frame",
-      });
-
-      const rect2 = API.createElement({
-        type: "rectangle",
-        frameId: frame2.id,
-      });
-
-      const ellipse = API.createElement({
-        type: "ellipse",
-      });
-
-      API.setElements([rect1, frame1, ellipse, rect2, frame2]);
-      API.setSelectedElements([frame1, ellipse, frame2]);
-
-      act(() => {
-        h.app.actionManager.executeAction(actionDuplicateSelection);
-      });
-
-      assertElements(h.elements, [
-        { id: rect1.id, frameId: frame1.id },
-        { id: frame1.id },
-        { [ORIG_ID]: rect1.id, frameId: getCloneByOrigId(frame1.id)?.id },
-        { [ORIG_ID]: frame1.id, selected: true },
-        { id: ellipse.id },
-        { [ORIG_ID]: ellipse.id, selected: true },
-        { id: rect2.id, frameId: frame2.id },
-        { id: frame2.id },
-        { [ORIG_ID]: rect2.id, frameId: getCloneByOrigId(frame2.id)?.id },
-        { [ORIG_ID]: frame2.id, selected: true },
-      ]);
-    });
-  });
-
-  describe("duplicating containers/bound elements", () => {
-    it("labeled arrow (arrow selected)", () => {
-      const [arrow, text] = API.createLabeledArrow();
-
-      API.setElements([arrow, text]);
-      API.setSelectedElements([arrow]);
-
-      act(() => {
-        h.app.actionManager.executeAction(actionDuplicateSelection);
-      });
-
-      assertElements(h.elements, [
-        { id: arrow.id },
-        { id: text.id, containerId: arrow.id },
-        { [ORIG_ID]: arrow.id, selected: true },
-        { [ORIG_ID]: text.id, containerId: getCloneByOrigId(arrow.id)?.id },
-      ]);
-    });
-
-    // shouldn't happen
-    it("labeled arrow (text selected)", () => {
-      const [arrow, text] = API.createLabeledArrow();
-
-      API.setElements([arrow, text]);
-      API.setSelectedElements([text]);
-
-      act(() => {
-        h.app.actionManager.executeAction(actionDuplicateSelection);
-      });
-
-      assertElements(h.elements, [
-        { id: arrow.id },
-        { id: text.id, containerId: arrow.id },
-        { [ORIG_ID]: arrow.id, selected: true },
-        { [ORIG_ID]: text.id, containerId: getCloneByOrigId(arrow.id)?.id },
-      ]);
-    });
-  });
-
-  describe("duplicating groups", () => {
-    it("duplicate group containing frame (children don't have groupIds set)", () => {
-      const frame = API.createElement({
-        type: "frame",
-        groupIds: ["A"],
-      });
-
-      const [rectangle, text] = API.createTextContainer({
-        frameId: frame.id,
-      });
-
-      const ellipse = API.createElement({
-        type: "ellipse",
-        groupIds: ["A"],
-      });
-
-      API.setElements([rectangle, text, frame, ellipse]);
-      API.setSelectedElements([frame, ellipse]);
-
-      act(() => {
-        h.app.actionManager.executeAction(actionDuplicateSelection);
-      });
-
-      assertElements(h.elements, [
-        { id: rectangle.id, frameId: frame.id },
-        { id: text.id, frameId: frame.id },
-        { id: frame.id },
-        { id: ellipse.id },
-        { [ORIG_ID]: rectangle.id, frameId: getCloneByOrigId(frame.id)?.id },
-        { [ORIG_ID]: text.id, frameId: getCloneByOrigId(frame.id)?.id },
-        { [ORIG_ID]: frame.id, selected: true },
-        { [ORIG_ID]: ellipse.id, selected: true },
-      ]);
-    });
-
-    it("duplicate group containing frame (children have groupIds)", () => {
-      const frame = API.createElement({
-        type: "frame",
-        groupIds: ["A"],
-      });
-
-      const [rectangle, text] = API.createTextContainer({
-        frameId: frame.id,
-        groupIds: ["A"],
-      });
-
-      const ellipse = API.createElement({
-        type: "ellipse",
-        groupIds: ["A"],
-      });
-
-      API.setElements([rectangle, text, frame, ellipse]);
-      API.setSelectedElements([frame, ellipse]);
-
-      act(() => {
-        h.app.actionManager.executeAction(actionDuplicateSelection);
-      });
-
-      assertElements(h.elements, [
-        { id: rectangle.id, frameId: frame.id },
-        { id: text.id, frameId: frame.id },
-        { id: frame.id },
-        { id: ellipse.id },
-        {
-          [ORIG_ID]: rectangle.id,
-          frameId: getCloneByOrigId(frame.id)?.id,
-          // FIXME shouldn't be selected (in selectGroupsForSelectedElements)
-          selected: true,
-        },
-        {
-          [ORIG_ID]: text.id,
-          frameId: getCloneByOrigId(frame.id)?.id,
-          // FIXME shouldn't be selected (in selectGroupsForSelectedElements)
-          selected: true,
-        },
-        { [ORIG_ID]: frame.id, selected: true },
-        { [ORIG_ID]: ellipse.id, selected: true },
-      ]);
-    });
-
-    it("duplicating element nested in group", () => {
-      const ellipse = API.createElement({
-        type: "ellipse",
-        groupIds: ["B"],
-      });
-      const rect1 = API.createElement({
-        type: "rectangle",
-        groupIds: ["A", "B"],
-      });
-      const rect2 = API.createElement({
-        type: "rectangle",
-        groupIds: ["A", "B"],
-      });
-
-      API.setElements([ellipse, rect1, rect2]);
-      API.setSelectedElements([ellipse], "B");
-
-      act(() => {
-        h.app.actionManager.executeAction(actionDuplicateSelection);
-      });
-
-      assertElements(h.elements, [
-        { id: ellipse.id },
-        { [ORIG_ID]: ellipse.id, groupIds: ["B"], selected: true },
-        { id: rect1.id, groupIds: ["A", "B"] },
-        { id: rect2.id, groupIds: ["A", "B"] },
-      ]);
-    });
-  });
-});

packages/excalidraw/actions/actionDuplicateSelection.tsx

@@ -5,13 +5,7 @@ import { duplicateElement, getNonDeletedElements } from "../element";
 import { isSomeElementSelected } from "../scene";
 import { ToolButton } from "../components/ToolButton";
 import { t } from "../i18n";
-import {
-  arrayToMap,
-  castArray,
-  findLastIndex,
-  getShortcutKey,
-  invariant,
-} from "../utils";
+import { arrayToMap, getShortcutKey } from "../utils";
 import { LinearElementEditor } from "../element/linearElementEditor";
 import {
   selectGroupsForSelectedElements,
@@ -25,13 +19,8 @@ import { DEFAULT_GRID_SIZE } from "../constants";
 import {
   bindTextToShapeAfterDuplication,
   getBoundTextElement,
-  getContainerElement,
 } from "../element/textElement";
-import {
-  hasBoundTextElement,
-  isBoundToContainer,
-  isFrameLikeElement,
-} from "../element/typeChecks";
+import { isBoundToContainer, isFrameLikeElement } from "../element/typeChecks";
 import { normalizeElementOrder } from "../element/sortElements";
 import { DuplicateIcon } from "../components/icons";
 import {
@@ -42,6 +31,7 @@ import {
   excludeElementsInFramesFromSelection,
   getSelectedElements,
 } from "../scene/selection";
+import { syncMovedIndices } from "../fractionalIndex";
 import { StoreAction } from "../store";
 
 export const actionDuplicateSelection = register({
@@ -95,66 +85,34 @@ const duplicateElements = (
 ): Partial<ActionResult> => {
   // ---------------------------------------------------------------------------
 
+  // step (1)
+
+  const sortedElements = normalizeElementOrder(elements);
   const groupIdMap = new Map();
   const newElements: ExcalidrawElement[] = [];
   const oldElements: ExcalidrawElement[] = [];
   const oldIdToDuplicatedId = new Map();
   const duplicatedElementsMap = new Map<string, ExcalidrawElement>();
 
-  const elementsMap = arrayToMap(elements);
-
-  const duplicateAndOffsetElement = <
-    T extends ExcalidrawElement | ExcalidrawElement[],
-  >(
-    element: T,
-  ): T extends ExcalidrawElement[]
-    ? ExcalidrawElement[]
-    : ExcalidrawElement | null => {
-    const elements = castArray(element);
-
-    const _newElements = elements.reduce(
-      (acc: ExcalidrawElement[], element) => {
-        if (processedIds.has(element.id)) {
-          return acc;
-        }
-
-        processedIds.set(element.id, true);
-
-        const newElement = duplicateElement(
-          appState.editingGroupId,
-          groupIdMap,
-          element,
-          {
-            x: element.x + DEFAULT_GRID_SIZE / 2,
-            y: element.y + DEFAULT_GRID_SIZE / 2,
-          },
-        );
-
-        processedIds.set(newElement.id, true);
-
-        duplicatedElementsMap.set(newElement.id, newElement);
-        oldIdToDuplicatedId.set(element.id, newElement.id);
-
-        oldElements.push(element);
-        newElements.push(newElement);
-
-        acc.push(newElement);
-        return acc;
+  const duplicateAndOffsetElement = (element: ExcalidrawElement) => {
+    const newElement = duplicateElement(
+      appState.editingGroupId,
+      groupIdMap,
+      element,
+      {
+        x: element.x + DEFAULT_GRID_SIZE / 2,
+        y: element.y + DEFAULT_GRID_SIZE / 2,
       },
-      [],
     );
-
-    return (
-      Array.isArray(element) ? _newElements : _newElements[0] || null
-    ) as T extends ExcalidrawElement[]
-      ? ExcalidrawElement[]
-      : ExcalidrawElement | null;
+    duplicatedElementsMap.set(newElement.id, newElement);
+    oldIdToDuplicatedId.set(element.id, newElement.id);
+    oldElements.push(element);
+    newElements.push(newElement);
+    return newElement;
   };
 
-  elements = normalizeElementOrder(elements);
-
   const idsOfElementsToDuplicate = arrayToMap(
-    getSelectedElements(elements, appState, {
+    getSelectedElements(sortedElements, appState, {
       includeBoundTextElement: true,
       includeElementsInFrames: true,
     }),
@@ -172,134 +130,123 @@ const duplicateElements = (
   // loop over them.
   const processedIds = new Map<ExcalidrawElement["id"], true>();
 
-  const elementsWithClones: ExcalidrawElement[] = elements.slice();
-
-  const insertAfterIndex = (
-    index: number,
-    elements: ExcalidrawElement | null | ExcalidrawElement[],
-  ) => {
-    invariant(index !== -1, "targetIndex === -1 ");
-
-    if (!Array.isArray(elements) && !elements) {
-      return;
+  const markAsProcessed = (elements: ExcalidrawElement[]) => {
+    for (const element of elements) {
+      processedIds.set(element.id, true);
     }
-
-    elementsWithClones.splice(index + 1, 0, ...castArray(elements));
+    return elements;
   };
 
-  const frameIdsToDuplicate = new Set(
-    elements
-      .filter(
-        (el) => idsOfElementsToDuplicate.has(el.id) && isFrameLikeElement(el),
-      )
-      .map((el) => el.id),
-  );
+  const elementsWithClones: ExcalidrawElement[] = [];
 
-  for (const element of elements) {
-    if (processedIds.has(element.id)) {
+  let index = -1;
+
+  while (++index < sortedElements.length) {
+    const element = sortedElements[index];
+
+    if (processedIds.get(element.id)) {
       continue;
     }
 
-    if (!idsOfElementsToDuplicate.has(element.id)) {
-      continue;
-    }
+    const boundTextElement = getBoundTextElement(element, arrayToMap(elements));
+    const isElementAFrameLike = isFrameLikeElement(element);
 
-    // groups
-    // -------------------------------------------------------------------------
+    if (idsOfElementsToDuplicate.get(element.id)) {
+      // if a group or a container/bound-text or frame, duplicate atomically
+      if (element.groupIds.length || boundTextElement || isElementAFrameLike) {
+        const groupId = getSelectedGroupForElement(appState, element);
+        if (groupId) {
+          // TODO:
+          // remove `.flatMap...`
+          // if the elements in a frame are grouped when the frame is grouped
+          const groupElements = getElementsInGroup(
+            sortedElements,
+            groupId,
+          ).flatMap((element) =>
+            isFrameLikeElement(element)
+              ? [...getFrameChildren(elements, element.id), element]
+              : [element],
+          );
 
-    const groupId = getSelectedGroupForElement(appState, element);
-    if (groupId) {
-      const groupElements = getElementsInGroup(elements, groupId).flatMap(
-        (element) =>
-          isFrameLikeElement(element)
-            ? [...getFrameChildren(elements, element.id), element]
-            : [element],
-      );
+          elementsWithClones.push(
+            ...markAsProcessed([
+              ...groupElements,
+              ...groupElements.map((element) =>
+                duplicateAndOffsetElement(element),
+              ),
+            ]),
+          );
+          continue;
+        }
+        if (boundTextElement) {
+          elementsWithClones.push(
+            ...markAsProcessed([
+              element,
+              boundTextElement,
+              duplicateAndOffsetElement(element),
+              duplicateAndOffsetElement(boundTextElement),
+            ]),
+          );
+          continue;
+        }
+        if (isElementAFrameLike) {
+          const elementsInFrame = getFrameChildren(sortedElements, element.id);
 
-      const targetIndex = findLastIndex(elementsWithClones, (el) => {
-        return el.groupIds?.includes(groupId);
-      });
+          elementsWithClones.push(
+            ...markAsProcessed([
+              ...elementsInFrame,
+              element,
+              ...elementsInFrame.map((e) => duplicateAndOffsetElement(e)),
+              duplicateAndOffsetElement(element),
+            ]),
+          );
 
-      insertAfterIndex(targetIndex, duplicateAndOffsetElement(groupElements));
-      continue;
-    }
-
-    // frame duplication
-    // -------------------------------------------------------------------------
-
-    if (element.frameId && frameIdsToDuplicate.has(element.frameId)) {
-      continue;
-    }
-
-    if (isFrameLikeElement(element)) {
-      const frameId = element.id;
-
-      const frameChildren = getFrameChildren(elements, frameId);
-
-      const targetIndex = findLastIndex(elementsWithClones, (el) => {
-        return el.frameId === frameId || el.id === frameId;
-      });
-
-      insertAfterIndex(
-        targetIndex,
-        duplicateAndOffsetElement([...frameChildren, element]),
-      );
-      continue;
-    }
-
-    // text container
-    // -------------------------------------------------------------------------
-
-    if (hasBoundTextElement(element)) {
-      const boundTextElement = getBoundTextElement(element, elementsMap);
-
-      const targetIndex = findLastIndex(elementsWithClones, (el) => {
-        return (
-          el.id === element.id ||
-          ("containerId" in el && el.containerId === element.id)
-        );
-      });
-
-      if (boundTextElement) {
-        insertAfterIndex(
-          targetIndex,
-          duplicateAndOffsetElement([element, boundTextElement]),
-        );
-      } else {
-        insertAfterIndex(targetIndex, duplicateAndOffsetElement(element));
+          continue;
+        }
       }
-
-      continue;
-    }
-
-    if (isBoundToContainer(element)) {
-      const container = getContainerElement(element, elementsMap);
-
-      const targetIndex = findLastIndex(elementsWithClones, (el) => {
-        return el.id === element.id || el.id === container?.id;
-      });
-
-      if (container) {
-        insertAfterIndex(
-          targetIndex,
-          duplicateAndOffsetElement([container, element]),
+      // since elements in frames have a lower z-index than the frame itself,
+      // they will be looped first and if their frames are selected as well,
+      // they will have been copied along with the frame atomically in the
+      // above branch, so we must skip those elements here
+      //
+      // now, for elements do not belong any frames or elements whose frames
+      // are selected (or elements that are left out from the above
+      // steps for whatever reason) we (should at least) duplicate them here
+      if (!element.frameId || !idsOfElementsToDuplicate.has(element.frameId)) {
+        elementsWithClones.push(
+          ...markAsProcessed([element, duplicateAndOffsetElement(element)]),
         );
-      } else {
-        insertAfterIndex(targetIndex, duplicateAndOffsetElement(element));
       }
-
-      continue;
+    } else {
+      elementsWithClones.push(...markAsProcessed([element]));
     }
-
-    // default duplication (regular elements)
-    // -------------------------------------------------------------------------
-
-    insertAfterIndex(
-      findLastIndex(elementsWithClones, (el) => el.id === element.id),
-      duplicateAndOffsetElement(element),
-    );
   }
 
+  // step (2)
+
+  // second pass to remove duplicates. We loop from the end as it's likelier
+  // that the last elements are in the correct order (contiguous or otherwise).
+  // Thus we need to reverse as the last step (3).
+
+  const finalElementsReversed: ExcalidrawElement[] = [];
+
+  const finalElementIds = new Map<ExcalidrawElement["id"], true>();
+  index = elementsWithClones.length;
+
+  while (--index >= 0) {
+    const element = elementsWithClones[index];
+    if (!finalElementIds.get(element.id)) {
+      finalElementIds.set(element.id, true);
+      finalElementsReversed.push(element);
+    }
+  }
+
+  // step (3)
+  const finalElements = syncMovedIndices(
+    finalElementsReversed.reverse(),
+    arrayToMap(newElements),
+  );
+
   // ---------------------------------------------------------------------------
 
   bindTextToShapeAfterDuplication(
@@ -313,7 +260,7 @@ const duplicateElements = (
     oldIdToDuplicatedId,
   );
   bindElementsToFramesAfterDuplication(
-    elementsWithClones,
+    finalElements,
     oldElements,
     oldIdToDuplicatedId,
   );
@@ -322,7 +269,7 @@ const duplicateElements = (
     excludeElementsInFramesFromSelection(newElements);
 
   return {
-    elements: elementsWithClones,
+    elements: finalElements,
     appState: {
       ...appState,
       ...selectGroupsForSelectedElements(
@@ -338,7 +285,7 @@ const duplicateElements = (
             {},
           ),
         },
-        getNonDeletedElements(elementsWithClones),
+        getNonDeletedElements(finalElements),
         appState,
         null,
       ),

packages/excalidraw/actions/actionProperties.tsx

@@ -1605,8 +1605,6 @@ export const actionChangeArrowType = register({
             elements,
             elementsMap,
             appState.zoom,
-            false,
-            true,
           );
         const endHoveredElement =
           !newElement.endBinding &&
@@ -1615,8 +1613,6 @@ export const actionChangeArrowType = register({
             elements,
             elementsMap,
             appState.zoom,
-            false,
-            true,
           );
         const startElement = startHoveredElement
           ? startHoveredElement

packages/excalidraw/components/App.tsx

@@ -5770,10 +5770,7 @@ class App extends React.Component<AppProps, AppState> {
         });
       }
       if (editingLinearElement?.lastUncommittedPoint != null) {
-        this.maybeSuggestBindingAtCursor(
-          scenePointer,
-          editingLinearElement.elbowed,
-        );
+        this.maybeSuggestBindingAtCursor(scenePointer);
       } else {
         // causes stack overflow if not sync
         flushSync(() => {
@@ -5793,7 +5790,7 @@ class App extends React.Component<AppProps, AppState> {
           this.state.startBoundElement,
         );
       } else {
-        this.maybeSuggestBindingAtCursor(scenePointer, false);
+        this.maybeSuggestBindingAtCursor(scenePointer);
       }
     }
 
@@ -7731,7 +7728,6 @@ class App extends React.Component<AppProps, AppState> {
         this.scene.getNonDeletedElementsMap(),
         this.state.zoom,
         isElbowArrow(element),
-        isElbowArrow(element),
       );
 
       this.scene.insertElement(element);
@@ -10009,20 +10005,15 @@ class App extends React.Component<AppProps, AppState> {
     }
   };
 
-  private maybeSuggestBindingAtCursor = (
-    pointerCoords: {
-      x: number;
-      y: number;
-    },
-    considerAll: boolean,
-  ): void => {
+  private maybeSuggestBindingAtCursor = (pointerCoords: {
+    x: number;
+    y: number;
+  }): void => {
     const hoveredBindableElement = getHoveredElementForBinding(
       pointerCoords,
       this.scene.getNonDeletedElements(),
       this.scene.getNonDeletedElementsMap(),
       this.state.zoom,
-      false,
-      considerAll,
     );
     this.setState({
       suggestedBindings:
@@ -10052,8 +10043,7 @@ class App extends React.Component<AppProps, AppState> {
           this.scene.getNonDeletedElements(),
           this.scene.getNonDeletedElementsMap(),
           this.state.zoom,
-          isElbowArrow(linearElement),
-          isElbowArrow(linearElement),
+          isArrowElement(linearElement) && isElbowArrow(linearElement),
         );
         if (
           hoveredBindableElement != null &&

packages/excalidraw/components/IconPicker.tsx

@@ -5,7 +5,7 @@ import { getLanguage, t } from "../i18n";
 import clsx from "clsx";
 import Collapsible from "./Stats/Collapsible";
 import { atom, useAtom } from "../editor-jotai";
-import { useDevice } from "./App";
+import { useDevice } from "..";
 
 import "./IconPicker.scss";
 

packages/excalidraw/components/LibraryUnit.scss

@@ -63,27 +63,6 @@
     max-width: 100%;
   }
 
-  .library-unit__checkbox-container,
-  .library-unit__checkbox-container:hover,
-  .library-unit__checkbox-container:active {
-    align-items: center;
-    background: none;
-    border: none;
-    color: var(--icon-fill-color);
-    display: flex;
-    justify-content: center;
-    margin: 0;
-    padding: 0.5rem;
-    position: absolute;
-    left: 2rem;
-    bottom: 2rem;
-    cursor: pointer;
-
-    input {
-      cursor: pointer;
-    }
-  }
-
   .library-unit__checkbox {
     position: absolute;
     top: 0.125rem;
@@ -91,7 +70,7 @@
     margin: 0;
 
     .Checkbox-box {
-      margin: 0;
+      margin: 0 !important;
       width: 1rem;
       height: 1rem;
       border-radius: 4px;

packages/excalidraw/components/Range.scss

@@ -1,7 +1,10 @@
 @import "../css/variables.module.scss";
 
 .excalidraw {
-  --slider-thumb-size: 16px;
+  --Range-track-background: var(--button-bg);
+  --Range-track-background-active: var(--color-primary);
+  --Range-thumb-background: var(--color-on-surface);
+  --Range-legend-color: var(--text-primary-color);
 
   .range-wrapper {
     position: relative;
@@ -13,7 +16,7 @@
     width: 100%;
     height: 4px;
     -webkit-appearance: none;
-    background: var(--color-slider-track);
+    background: var(--Range-track-background);
     border-radius: 2px;
     outline: none;
   }
@@ -21,18 +24,18 @@
   .range-input::-webkit-slider-thumb {
     -webkit-appearance: none;
     appearance: none;
-    width: var(--slider-thumb-size);
-    height: var(--slider-thumb-size);
-    background: var(--color-slider-thumb);
+    width: 20px;
+    height: 20px;
+    background: var(--Range-thumb-background);
     border-radius: 50%;
     cursor: pointer;
     border: none;
   }
 
   .range-input::-moz-range-thumb {
-    width: var(--slider-thumb-size);
-    height: var(--slider-thumb-size);
-    background: var(--color-slider-thumb);
+    width: 20px;
+    height: 20px;
+    background: var(--Range-thumb-background);
     border-radius: 50%;
     cursor: pointer;
     border: none;
@@ -43,7 +46,7 @@
     bottom: 0;
     transform: translateX(-50%);
     font-size: 12px;
-    color: var(--text-primary-color);
+    color: var(--Range-legend-color);
   }
 
   .zero-label {
@@ -51,6 +54,6 @@
     bottom: 0;
     left: 4px;
     font-size: 12px;
-    color: var(--text-primary-color);
+    color: var(--Range-legend-color);
   }
 }

packages/excalidraw/components/Range.tsx

@@ -34,7 +34,7 @@ export const Range = ({
       const position =
         (value / 100) * (inputWidth - thumbWidth) + thumbWidth / 2;
       valueElement.style.left = `${position}px`;
-      rangeElement.style.background = `linear-gradient(to right, var(--color-slider-track) 0%, var(--color-slider-track) ${value}%, var(--button-bg) ${value}%, var(--button-bg) 100%)`;
+      rangeElement.style.background = `linear-gradient(to right, var(--color-primary) 0%, var(--color-primary) ${value}%, var(--button-bg) ${value}%, var(--button-bg) 100%)`;
     }
   }, [value]);
 

packages/excalidraw/constants.ts

@@ -458,6 +458,3 @@ export const ARROW_TYPE: { [T in AppState["currentItemArrowType"]]: T } = {
 
 export const DEFAULT_REDUCED_GLOBAL_ALPHA = 0.3;
 export const ELEMENT_LINK_KEY = "element";
-
-/** used in tests */
-export const ORIG_ID = Symbol.for("__test__originalId__");

packages/excalidraw/css/styles.scss

@@ -649,21 +649,15 @@ body.excalidraw-cursor-resize * {
     @include filledButtonOnCanvas;
   }
 
-  .App-mobile-menu,
   .App-menu__left {
     --button-border: transparent;
     --button-bg: var(--color-surface-mid);
-  }
 
-  @at-root .excalidraw.theme--dark#{&} {
-    .App-mobile-menu,
-    .App-menu__left {
+    @at-root .excalidraw.theme--dark#{&} {
       --button-hover-bg: #363541;
       --button-bg: var(--color-surface-high);
     }
-  }
 
-  .App-menu__left {
     .buttonList {
       padding: 0.25rem 0;
     }

packages/excalidraw/css/theme.scss

@@ -32,6 +32,7 @@
     0px 0px 3.1270833015441895px 0px rgba(0, 0, 0, 0.08),
     0px 7px 14px 0px rgba(0, 0, 0, 0.05);
 
+  --button-bg: var(--color-surface-mid);
   --button-hover-bg: var(--color-surface-high);
   --button-active-bg: var(--color-surface-high);
   --button-active-border: var(--color-brand-active);
@@ -53,9 +54,6 @@
   --scrollbar-thumb: var(--button-gray-2);
   --scrollbar-thumb-hover: var(--button-gray-3);
 
-  --color-slider-track: hsl(240, 100%, 90%);
-  --color-slider-thumb: var(--color-gray-80);
-
   --modal-shadow: 0px 100px 80px rgba(0, 0, 0, 0.07),
     0px 41.7776px 33.4221px rgba(0, 0, 0, 0.0503198),
     0px 22.3363px 17.869px rgba(0, 0, 0, 0.0417275),
@@ -174,6 +172,8 @@
     --button-destructive-bg-color: #5a0000;
     --button-destructive-color: #{$oc-red-3};
 
+    --button-bg: var(--color-surface-high);
+
     --button-gray-1: #363636;
     --button-gray-2: #272727;
     --button-gray-3: #222;
@@ -210,8 +210,6 @@
     --scrollbar-thumb: #{$oc-gray-8};
     --scrollbar-thumb-hover: #{$oc-gray-7};
 
-    --color-slider-track: hsl(244, 23%, 39%);
-
     // will be inverted to a lighter color.
     --color-selection: #3530c4;
 

packages/excalidraw/element/binding.ts

@@ -49,11 +49,7 @@ import type { ElementUpdate } from "./mutateElement";
 import { mutateElement } from "./mutateElement";
 import type Scene from "../scene/Scene";
 import { LinearElementEditor } from "./linearElementEditor";
-import {
-  arrayToMap,
-  isBindingFallthroughEnabled,
-  tupleToCoors,
-} from "../utils";
+import { arrayToMap, tupleToCoors } from "../utils";
 import { KEYS } from "../keys";
 import { getBoundTextElement, handleBindTextResize } from "./textElement";
 import { aabbForElement, getElementShape, pointInsideBounds } from "../shapes";
@@ -79,7 +75,6 @@ import {
   clamp,
 } from "../../math";
 import { segmentIntersectRectangleElement } from "../../utils/geometry/shape";
-import { getElementsAtPosition } from "../scene/comparisons";
 
 export type SuggestedBinding =
   | NonDeleted<ExcalidrawBindableElement>
@@ -430,8 +425,7 @@ export const maybeBindLinearElement = (
     elements,
     elementsMap,
     appState.zoom,
-    isElbowArrow(linearElement),
-    isElbowArrow(linearElement),
+    isElbowArrow(linearElement) && isElbowArrow(linearElement),
   );
 
   if (hoveredElement !== null) {
@@ -564,64 +558,7 @@ export const getHoveredElementForBinding = (
   elementsMap: NonDeletedSceneElementsMap,
   zoom?: AppState["zoom"],
   fullShape?: boolean,
-  considerAllElements?: boolean,
 ): NonDeleted<ExcalidrawBindableElement> | null => {
-  if (considerAllElements) {
-    let cullRest = false;
-    const candidateElements = getElementsAtPosition(
-      elements,
-      (element) =>
-        isBindableElement(element, false) &&
-        bindingBorderTest(
-          element,
-          pointerCoords,
-          elementsMap,
-          zoom,
-          (fullShape ||
-            !isBindingFallthroughEnabled(
-              element as ExcalidrawBindableElement,
-            )) &&
-            // disable fullshape snapping for frame elements so we
-            // can bind to frame children
-            !isFrameLikeElement(element),
-        ),
-    ).filter((element) => {
-      if (cullRest) {
-        return false;
-      }
-
-      if (!isBindingFallthroughEnabled(element as ExcalidrawBindableElement)) {
-        cullRest = true;
-      }
-
-      return true;
-    }) as NonDeleted<ExcalidrawBindableElement>[] | null;
-
-    // Return early if there are no candidates or just one candidate
-    if (!candidateElements || candidateElements.length === 0) {
-      return null;
-    }
-
-    if (candidateElements.length === 1) {
-      return candidateElements[0] as NonDeleted<ExcalidrawBindableElement>;
-    }
-
-    // Prefer the shape with the border being tested (if any)
-    const borderTestElements = candidateElements.filter((element) =>
-      bindingBorderTest(element, pointerCoords, elementsMap, zoom, false),
-    );
-    if (borderTestElements.length === 1) {
-      return borderTestElements[0];
-    }
-
-    // Prefer smaller shapes
-    return candidateElements
-      .sort(
-        (a, b) => b.width ** 2 + b.height ** 2 - (a.width ** 2 + a.height ** 2),
-      )
-      .pop() as NonDeleted<ExcalidrawBindableElement>;
-  }
-
   const hoveredElement = getElementAtPosition(
     elements,
     (element) =>
@@ -633,8 +570,7 @@ export const getHoveredElementForBinding = (
         zoom,
         // disable fullshape snapping for frame elements so we
         // can bind to frame children
-        (fullShape || !isBindingFallthroughEnabled(element)) &&
-          !isFrameLikeElement(element),
+        fullShape && !isFrameLikeElement(element),
       ),
   );
 
@@ -1284,8 +1220,6 @@ const getElligibleElementForBindingElement = (
     elements,
     elementsMap,
     zoom,
-    isElbowArrow(linearElement),
-    isElbowArrow(linearElement),
   );
 };
 

packages/excalidraw/element/elbowArrow.ts

@@ -20,11 +20,11 @@ import {
   bindPointToSnapToElementOutline,
   distanceToBindableElement,
   avoidRectangularCorner,
+  getHoveredElementForBinding,
   FIXED_BINDING_DISTANCE,
   getHeadingForElbowArrowSnap,
   getGlobalFixedPointForBindableElement,
   snapToMid,
-  getHoveredElementForBinding,
 } from "./binding";
 import type { Bounds } from "./bounds";
 import type { Heading } from "./heading";
@@ -244,12 +244,6 @@ const handleSegmentRenormalization = (
       );
     }
 
-    import.meta.env.DEV &&
-      invariant(
-        validateElbowPoints(nextPoints),
-        "Invalid elbow points with fixed segments",
-      );
-
     return normalizeArrowElementUpdate(
       nextPoints,
       filteredNextFixedSegments,
@@ -872,8 +866,6 @@ export const updateElbowArrowPoints = (
   updates: {
     points?: readonly LocalPoint[];
     fixedSegments?: FixedSegment[] | null;
-    startBinding?: FixedPointBinding | null;
-    endBinding?: FixedPointBinding | null;
   },
   options?: {
     isDragging?: boolean;
@@ -920,11 +912,7 @@ export const updateElbowArrowPoints = (
   // 0. During all element replacement in the scene, we just need to renormalize
   // the arrow
   // TODO (dwelle,mtolmacs): Remove this once Scene.getScene() is removed
-  if (
-    elementsMap.size === 0 &&
-    updates.points &&
-    validateElbowPoints(updates.points)
-  ) {
+  if (elementsMap.size === 0 && updates.points) {
     return normalizeArrowElementUpdate(
       updates.points.map((p) =>
         pointFrom<GlobalPoint>(arrow.x + p[0], arrow.y + p[1]),
@@ -955,48 +943,17 @@ export const updateElbowArrowPoints = (
     hoveredStartElement,
     hoveredEndElement,
     ...rest
-  } = getElbowArrowData(
-    {
-      x: arrow.x,
-      y: arrow.y,
-      startBinding:
-        typeof updates.startBinding !== "undefined"
-          ? updates.startBinding
-          : arrow.startBinding,
-      endBinding:
-        typeof updates.endBinding !== "undefined"
-          ? updates.endBinding
-          : arrow.endBinding,
-      startArrowhead: arrow.startArrowhead,
-      endArrowhead: arrow.endArrowhead,
-    },
-    elementsMap,
-    updatedPoints,
-    options,
-  );
+  } = getElbowArrowData(arrow, elementsMap, updatedPoints, options);
 
   const fixedSegments = updates.fixedSegments ?? arrow.fixedSegments ?? [];
 
   ////
   // 1. Renormalize the arrow
   ////
-  if (
-    !updates.points &&
-    !updates.fixedSegments &&
-    !updates.startBinding &&
-    !updates.endBinding
-  ) {
+  if (!updates.points && !updates.fixedSegments) {
     return handleSegmentRenormalization(arrow, elementsMap);
   }
 
-  // Short circuit on no-op to avoid huge performance hit
-  if (
-    updates.startBinding === arrow.startBinding &&
-    updates.endBinding === arrow.endBinding
-  ) {
-    return {};
-  }
-
   ////
   // 2. Just normal elbow arrow things
   ////
@@ -1043,7 +1000,6 @@ export const updateElbowArrowPoints = (
 
   ////
   // 5. Handle resize
-  ////
   if (updates.points && updates.fixedSegments) {
     return updates;
   }
@@ -2154,7 +2110,6 @@ const getHoveredElements = (
       nonDeletedSceneElementsMap,
       zoom,
       true,
-      true,
     ),
     getHoveredElementForBinding(
       tupleToCoors(origEndGlobalPoint),
@@ -2162,23 +2117,9 @@ const getHoveredElements = (
       nonDeletedSceneElementsMap,
       zoom,
       true,
-      true,
     ),
   ];
 };
 
 const gridAddressesEqual = (a: GridAddress, b: GridAddress): boolean =>
   a[0] === b[0] && a[1] === b[1];
-
-const validateElbowPoints = <P extends GlobalPoint | LocalPoint>(
-  points: readonly P[],
-  tolerance: number = DEDUP_TRESHOLD,
-) =>
-  points
-    .slice(1)
-    .map(
-      (p, i) =>
-        Math.abs(p[0] - points[i][0]) < tolerance ||
-        Math.abs(p[1] - points[i][1]) < tolerance,
-    )
-    .every(Boolean);

packages/excalidraw/element/flowchart.ts

@@ -10,15 +10,13 @@ import {
 import { bindLinearElement } from "./binding";
 import { LinearElementEditor } from "./linearElementEditor";
 import { newArrowElement, newElement } from "./newElement";
-import type { SceneElementsMap } from "./types";
-import {
-  type ElementsMap,
-  type ExcalidrawBindableElement,
-  type ExcalidrawElement,
-  type ExcalidrawFlowchartNodeElement,
-  type NonDeletedSceneElementsMap,
-  type Ordered,
-  type OrderedExcalidrawElement,
+import type {
+  ElementsMap,
+  ExcalidrawBindableElement,
+  ExcalidrawElement,
+  ExcalidrawFlowchartNodeElement,
+  NonDeletedSceneElementsMap,
+  OrderedExcalidrawElement,
 } from "./types";
 import { KEYS } from "../keys";
 import type { AppState, PendingExcalidrawElements } from "../types";
@@ -30,10 +28,9 @@ import {
   isFrameElement,
   isFlowchartNodeElement,
 } from "./typeChecks";
-import { invariant, toBrandedType } from "../utils";
+import { invariant } from "../utils";
 import { pointFrom, type LocalPoint } from "../../math";
 import { aabbForElement } from "../shapes";
-import { updateElbowArrowPoints } from "./elbowArrow";
 
 type LinkDirection = "up" | "right" | "down" | "left";
 
@@ -470,23 +467,7 @@ const createBindingArrow = (
     },
   ]);
 
-  const update = updateElbowArrowPoints(
-    bindingArrow,
-    toBrandedType<SceneElementsMap>(
-      new Map([
-        ...elementsMap.entries(),
-        [startBindingElement.id, startBindingElement],
-        [endBindingElement.id, endBindingElement],
-        [bindingArrow.id, bindingArrow],
-      ] as [string, Ordered<ExcalidrawElement>][]),
-    ),
-    { points: bindingArrow.points },
-  );
-
-  return {
-    ...bindingArrow,
-    ...update,
-  };
+  return bindingArrow;
 };
 
 export class FlowChartNavigator {

packages/excalidraw/element/linearElementEditor.ts

@@ -444,8 +444,6 @@ export class LinearElementEditor {
                 elements,
                 elementsMap,
                 appState.zoom,
-                isElbowArrow(element),
-                isElbowArrow(element),
               )
             : null;
 
@@ -798,7 +796,6 @@ export class LinearElementEditor {
           elements,
           elementsMap,
           app.state.zoom,
-          linearElementEditor.elbowed,
         ),
       };
 

packages/excalidraw/element/mutateElement.ts

@@ -33,16 +33,13 @@ export const mutateElement = <TElement extends Mutable<ExcalidrawElement>>(
 
   // casting to any because can't use `in` operator
   // (see https://github.com/microsoft/TypeScript/issues/21732)
-  const { points, fixedSegments, fileId, startBinding, endBinding } =
-    updates as any;
+  const { points, fixedSegments, fileId } = updates as any;
 
   if (
     isElbowArrow(element) &&
     (Object.keys(updates).length === 0 || // normalization case
       typeof points !== "undefined" || // repositioning
-      typeof fixedSegments !== "undefined" || // segment fixing
-      typeof startBinding !== "undefined" ||
-      typeof endBinding !== "undefined") // manual binding to element
+      typeof fixedSegments !== "undefined") // segment fixing
   ) {
     const elementsMap = toBrandedType<SceneElementsMap>(
       Scene.getScene(element)?.getNonDeletedElementsMap() ?? new Map(),
@@ -61,8 +58,6 @@ export const mutateElement = <TElement extends Mutable<ExcalidrawElement>>(
         {
           fixedSegments,
           points,
-          startBinding,
-          endBinding,
         },
         {
           isDragging: options?.isDragging,

packages/excalidraw/element/newElement.ts

@@ -45,7 +45,6 @@ import {
   DEFAULT_FONT_SIZE,
   DEFAULT_TEXT_ALIGN,
   DEFAULT_VERTICAL_ALIGN,
-  ORIG_ID,
   VERTICAL_ALIGN,
 } from "../constants";
 import type { MarkOptional, Merge, Mutable } from "../utility-types";
@@ -593,18 +592,26 @@ export const deepCopyElement = <T extends ExcalidrawElement>(
   return _deepCopyElement(val);
 };
 
-const __test__defineOrigId = (clonedObj: object, origId: string) => {
-  Object.defineProperty(clonedObj, ORIG_ID, {
-    value: origId,
-    writable: false,
-    enumerable: false,
-  });
-};
-
 /**
- * utility wrapper to generate new id.
+ * utility wrapper to generate new id. In test env it reuses the old + postfix
+ * for test assertions.
  */
-const regenerateId = () => {
+export const regenerateId = (
+  /** supply null if no previous id exists */
+  previousId: string | null,
+) => {
+  if (isTestEnv() && previousId) {
+    let nextId = `${previousId}_copy`;
+    // `window.h` may not be defined in some unit tests
+    if (
+      window.h?.app
+        ?.getSceneElementsIncludingDeleted()
+        .find((el: ExcalidrawElement) => el.id === nextId)
+    ) {
+      nextId += "_copy";
+    }
+    return nextId;
+  }
   return randomId();
 };
 
@@ -630,11 +637,7 @@ export const duplicateElement = <TElement extends ExcalidrawElement>(
 ): Readonly<TElement> => {
   let copy = deepCopyElement(element);
 
-  if (isTestEnv()) {
-    __test__defineOrigId(copy, element.id);
-  }
-
-  copy.id = regenerateId();
+  copy.id = regenerateId(copy.id);
   copy.boundElements = null;
   copy.updated = getUpdatedTimestamp();
   copy.seed = randomInteger();
@@ -643,7 +646,7 @@ export const duplicateElement = <TElement extends ExcalidrawElement>(
     editingGroupId,
     (groupId) => {
       if (!groupIdMapForOperation.has(groupId)) {
-        groupIdMapForOperation.set(groupId, regenerateId());
+        groupIdMapForOperation.set(groupId, regenerateId(groupId));
       }
       return groupIdMapForOperation.get(groupId)!;
     },
@@ -689,7 +692,7 @@ export const duplicateElements = (
     // if we haven't migrated the element id, but an old element with the same
     // id exists, generate a new id for it and return it
     if (origElementsMap.has(id)) {
-      const newId = regenerateId();
+      const newId = regenerateId(id);
       elementNewIdsMap.set(id, newId);
       return newId;
     }
@@ -703,9 +706,6 @@ export const duplicateElements = (
     const clonedElement: Mutable<ExcalidrawElement> = _deepCopyElement(element);
 
     clonedElement.id = maybeGetNewId(element.id)!;
-    if (isTestEnv()) {
-      __test__defineOrigId(clonedElement, element.id);
-    }
 
     if (opts?.randomizeSeed) {
       clonedElement.seed = randomInteger();
@@ -715,7 +715,7 @@ export const duplicateElements = (
     if (clonedElement.groupIds) {
       clonedElement.groupIds = clonedElement.groupIds.map((groupId) => {
         if (!groupNewIdsMap.has(groupId)) {
-          groupNewIdsMap.set(groupId, regenerateId());
+          groupNewIdsMap.set(groupId, regenerateId(groupId));
         }
         return groupNewIdsMap.get(groupId)!;
       });

packages/excalidraw/element/sortElements.ts

@@ -116,5 +116,8 @@ const normalizeBoundElementsOrder = (
 export const normalizeElementOrder = (
   elements: readonly ExcalidrawElement[],
 ) => {
-  return normalizeBoundElementsOrder(normalizeGroupElementOrder(elements));
+  // console.time();
+  const ret = normalizeBoundElementsOrder(normalizeGroupElementOrder(elements));
+  // console.timeEnd();
+  return ret;
 };

packages/excalidraw/frame.test.tsx

@@ -1,8 +1,9 @@
+import React from "react";
 import type { ExcalidrawElement } from "./element/types";
 import { convertToExcalidrawElements, Excalidraw } from "./index";
 import { API } from "./tests/helpers/api";
 import { Keyboard, Pointer } from "./tests/helpers/ui";
-import { getCloneByOrigId, render } from "./tests/test-utils";
+import { render } from "./tests/test-utils";
 
 const { h } = window;
 const mouse = new Pointer("mouse");
@@ -412,9 +413,9 @@ describe("adding elements to frames", () => {
 
       dragElementIntoFrame(frame, rect2);
 
-      selectElementAndDuplicate(rect2);
+      const rect2_copy = { ...rect2, id: `${rect2.id}_copy` };
 
-      const rect2_copy = getCloneByOrigId(rect2.id);
+      selectElementAndDuplicate(rect2);
 
       expect(rect2_copy.frameId).toBe(frame.id);
       expect(rect2.frameId).toBe(frame.id);
@@ -426,11 +427,11 @@ describe("adding elements to frames", () => {
 
       dragElementIntoFrame(frame, rect2);
 
+      const rect2_copy = { ...rect2, id: `${rect2.id}_copy` };
+
       // move the rect2 outside the frame
       selectElementAndDuplicate(rect2, [-1000, -1000]);
 
-      const rect2_copy = getCloneByOrigId(rect2.id);
-
       expect(rect2_copy.frameId).toBe(frame.id);
       expect(rect2.frameId).toBe(null);
       expectEqualIds([rect2_copy, frame, rect2]);

packages/excalidraw/package.json

@@ -103,7 +103,6 @@
     "@types/pako": "1.0.3",
     "@types/pica": "5.1.3",
     "@types/resize-observer-browser": "0.1.7",
-    "ansicolor": "2.0.3",
     "autoprefixer": "10.4.7",
     "babel-loader": "8.2.5",
     "babel-plugin-transform-class-properties": "6.24.1",

packages/excalidraw/scene/comparisons.ts

@@ -75,23 +75,20 @@ export const getElementsAtPosition = (
   isAtPositionFn: (element: NonDeletedExcalidrawElement) => boolean,
 ) => {
   const iframeLikes: ExcalidrawIframeElement[] = [];
-  const elementsAtPosition: NonDeletedExcalidrawElement[] = [];
-  // We need to to hit testing from front (end of the array) to back (beginning of the array)
-  // because array is ordered from lower z-index to highest and we want element z-index
-  // with higher z-index
-  for (let index = elements.length - 1; index >= 0; --index) {
-    const element = elements[index];
-    if (element.isDeleted) {
-      continue;
+  // The parameter elements comes ordered from lower z-index to higher.
+  // We want to preserve that order on the returned array.
+  // Exception being embeddables which should be on top of everything else in
+  // terms of hit testing.
+  const elsAtPos = elements.filter((element) => {
+    const hit = !element.isDeleted && isAtPositionFn(element);
+    if (hit) {
+      if (isIframeElement(element)) {
+        iframeLikes.push(element);
+        return false;
+      }
+      return true;
     }
-    if (isIframeElement(element)) {
-      iframeLikes.push(element);
-      continue;
-    }
-    if (isAtPositionFn(element)) {
-      elementsAtPosition.push(element);
-    }
-  }
-
-  return elementsAtPosition.concat(iframeLikes);
+    return false;
+  });
+  return elsAtPos.concat(iframeLikes);
 };

packages/excalidraw/tests/__snapshots__/contextmenu.test.tsx.snap

@@ -2517,7 +2517,7 @@ exports[`contextMenu element > selecting 'Duplicate' in context menu duplicates
   "scrolledOutside": false,
   "searchMatches": [],
   "selectedElementIds": {
-    "id1": true,
+    "id0_copy": true,
   },
   "selectedElementsAreBeingDragged": false,
   "selectedGroupIds": {},
@@ -2590,7 +2590,7 @@ exports[`contextMenu element > selecting 'Duplicate' in context menu duplicates
   "frameId": null,
   "groupIds": [],
   "height": 20,
-  "id": "id1",
+  "id": "id0_copy",
   "index": "a1",
   "isDeleted": false,
   "link": null,
@@ -2680,7 +2680,7 @@ History {
         "delta": Delta {
           "deleted": {
             "selectedElementIds": {
-              "id1": true,
+              "id0_copy": true,
             },
           },
           "inserted": {
@@ -2693,7 +2693,7 @@ History {
       "elementsChange": ElementsChange {
         "added": Map {},
         "removed": Map {
-          "id1" => Delta {
+          "id0_copy" => Delta {
             "deleted": {
               "angle": 0,
               "backgroundColor": "transparent",

packages/excalidraw/tests/__snapshots__/move.test.tsx.snap

@@ -10,7 +10,7 @@ exports[`duplicate element on move when ALT is clicked > rectangle 5`] = `
   "frameId": null,
   "groupIds": [],
   "height": 50,
-  "id": "id2",
+  "id": "id0_copy",
   "index": "a0",
   "isDeleted": false,
   "link": null,

packages/excalidraw/tests/__snapshots__/regressionTests.test.tsx.snap

@@ -2129,7 +2129,7 @@ History {
       "elementsChange": ElementsChange {
         "added": Map {},
         "removed": Map {
-          "id2" => Delta {
+          "id0_copy" => Delta {
             "deleted": {
               "angle": 0,
               "backgroundColor": "transparent",
@@ -10619,7 +10619,7 @@ History {
       "elementsChange": ElementsChange {
         "added": Map {},
         "removed": Map {
-          "id6" => Delta {
+          "id0_copy" => Delta {
             "deleted": {
               "angle": 0,
               "backgroundColor": "transparent",
@@ -10628,7 +10628,7 @@ History {
               "fillStyle": "solid",
               "frameId": null,
               "groupIds": [
-                "id7",
+                "id4_copy",
               ],
               "height": 10,
               "index": "a0",
@@ -10652,7 +10652,7 @@ History {
               "isDeleted": true,
             },
           },
-          "id8" => Delta {
+          "id1_copy" => Delta {
             "deleted": {
               "angle": 0,
               "backgroundColor": "transparent",
@@ -10661,7 +10661,7 @@ History {
               "fillStyle": "solid",
               "frameId": null,
               "groupIds": [
-                "id7",
+                "id4_copy",
               ],
               "height": 10,
               "index": "a1",
@@ -10685,7 +10685,7 @@ History {
               "isDeleted": true,
             },
           },
-          "id9" => Delta {
+          "id2_copy" => Delta {
             "deleted": {
               "angle": 0,
               "backgroundColor": "transparent",
@@ -10694,7 +10694,7 @@ History {
               "fillStyle": "solid",
               "frameId": null,
               "groupIds": [
-                "id7",
+                "id4_copy",
               ],
               "height": 10,
               "index": "a2",

packages/excalidraw/tests/helpers/api.ts

@@ -40,7 +40,6 @@ import { createTestHook } from "../../components/App";
 import type { Action } from "../../actions/types";
 import { mutateElement } from "../../element/mutateElement";
 import { pointFrom, type LocalPoint, type Radians } from "../../../math";
-import { selectGroupsForSelectedElements } from "../../groups";
 
 const readFile = util.promisify(fs.readFile);
 // so that window.h is available when App.tsx is not imported as well.
@@ -69,21 +68,13 @@ export class API {
     });
   };
 
-  static setSelectedElements = (elements: ExcalidrawElement[], editingGroupId?: string | null) => {
+  static setSelectedElements = (elements: ExcalidrawElement[]) => {
     act(() => {
       h.setState({
-        ...selectGroupsForSelectedElements(
-        {
-          editingGroupId: editingGroupId ?? null,
-          selectedElementIds: elements.reduce((acc, element) => {
-            acc[element.id] = true;
-            return acc;
-          }, {} as Record<ExcalidrawElement["id"], true>),
-        },
-        elements,
-        h.state,
-        h.app,
-        )
+        selectedElementIds: elements.reduce((acc, element) => {
+          acc[element.id] = true;
+          return acc;
+        }, {} as Record<ExcalidrawElement["id"], true>),
       });
     });
   };
@@ -167,7 +158,7 @@ export class API {
     isDeleted?: boolean;
     frameId?: ExcalidrawElement["id"] | null;
     index?: ExcalidrawElement["index"];
-    groupIds?: ExcalidrawElement["groupIds"];
+    groupIds?: string[];
     // generic element props
     strokeColor?: ExcalidrawGenericElement["strokeColor"];
     backgroundColor?: ExcalidrawGenericElement["backgroundColor"];
@@ -378,84 +369,6 @@ export class API {
     return element as any;
   };
 
-  static createTextContainer = (opts?: {
-    frameId?: ExcalidrawElement["id"];
-    groupIds?: ExcalidrawElement["groupIds"];
-    label?: {
-      text?: string;
-      frameId?: ExcalidrawElement["id"] | null;
-      groupIds?: ExcalidrawElement["groupIds"];
-    };
-  }) => {
-    const rectangle = API.createElement({
-      type: "rectangle",
-      frameId: opts?.frameId || null,
-      groupIds: opts?.groupIds,
-    });
-
-    const text = API.createElement({
-      type: "text",
-      text: opts?.label?.text || "sample-text",
-      width: 50,
-      height: 20,
-      fontSize: 16,
-      containerId: rectangle.id,
-      frameId:
-        opts?.label?.frameId === undefined
-          ? opts?.frameId ?? null
-          : opts?.label?.frameId ?? null,
-      groupIds: opts?.label?.groupIds === undefined
-      ? opts?.groupIds
-      : opts?.label?.groupIds ,
-
-    });
-
-    mutateElement(
-      rectangle,
-      {
-        boundElements: [{ type: "text", id: text.id }],
-      },
-      false,
-    );
-
-    return [rectangle, text];
-  };
-
-  static createLabeledArrow = (opts?: {
-    frameId?: ExcalidrawElement["id"];
-    label?: {
-      text?: string;
-      frameId?: ExcalidrawElement["id"] | null;
-    };
-  }) => {
-    const arrow = API.createElement({
-      type: "arrow",
-      frameId: opts?.frameId || null,
-    });
-
-    const text = API.createElement({
-      type: "text",
-      id: "text2",
-      width: 50,
-      height: 20,
-      containerId: arrow.id,
-      frameId:
-        opts?.label?.frameId === undefined
-          ? opts?.frameId ?? null
-          : opts?.label?.frameId ?? null,
-    });
-
-    mutateElement(
-      arrow,
-      {
-        boundElements: [{ type: "text", id: text.id }],
-      },
-      false,
-    );
-
-    return [arrow, text];
-  };
-
   static readFile = async <T extends "utf8" | null>(
     filepath: string,
     encoding?: T,

packages/excalidraw/tests/history.test.tsx

@@ -7,7 +7,6 @@ import {
   assertSelectedElements,
   render,
   togglePopover,
-  getCloneByOrigId,
 } from "./test-utils";
 import { Excalidraw } from "../index";
 import { Keyboard, Pointer, UI } from "./helpers/ui";
@@ -16,7 +15,7 @@ import { getDefaultAppState } from "../appState";
 import { fireEvent, queryByTestId, waitFor } from "@testing-library/react";
 import { createUndoAction, createRedoAction } from "../actions/actionHistory";
 import { actionToggleViewMode } from "../actions/actionToggleViewMode";
-import { EXPORT_DATA_TYPES, MIME_TYPES, ORIG_ID } from "../constants";
+import { EXPORT_DATA_TYPES, MIME_TYPES } from "../constants";
 import type { AppState } from "../types";
 import { arrayToMap } from "../utils";
 import {
@@ -1139,8 +1138,8 @@ describe("history", () => {
       expect(h.elements).toEqual([
         expect.objectContaining({ id: rect1.id, isDeleted: false }),
         expect.objectContaining({ id: rect2.id, isDeleted: false }),
-        expect.objectContaining({ [ORIG_ID]: rect1.id, isDeleted: true }),
-        expect.objectContaining({ [ORIG_ID]: rect2.id, isDeleted: true }),
+        expect.objectContaining({ id: `${rect1.id}_copy`, isDeleted: true }),
+        expect.objectContaining({ id: `${rect2.id}_copy`, isDeleted: true }),
       ]);
       expect(h.state.editingGroupId).toBeNull();
       expect(h.state.selectedGroupIds).toEqual({ A: true });
@@ -1152,8 +1151,8 @@ describe("history", () => {
       expect(h.elements).toEqual([
         expect.objectContaining({ id: rect1.id, isDeleted: false }),
         expect.objectContaining({ id: rect2.id, isDeleted: false }),
-        expect.objectContaining({ [ORIG_ID]: rect1.id, isDeleted: false }),
-        expect.objectContaining({ [ORIG_ID]: rect2.id, isDeleted: false }),
+        expect.objectContaining({ id: `${rect1.id}_copy`, isDeleted: false }),
+        expect.objectContaining({ id: `${rect2.id}_copy`, isDeleted: false }),
       ]);
       expect(h.state.editingGroupId).toBeNull();
       expect(h.state.selectedGroupIds).not.toEqual(
@@ -1172,14 +1171,14 @@ describe("history", () => {
         expect.arrayContaining([
           expect.objectContaining({ id: rect1.id, isDeleted: false }),
           expect.objectContaining({ id: rect2.id, isDeleted: false }),
-          expect.objectContaining({ [ORIG_ID]: rect1.id, isDeleted: true }),
-          expect.objectContaining({ [ORIG_ID]: rect2.id, isDeleted: true }),
+          expect.objectContaining({ id: `${rect1.id}_copy`, isDeleted: true }),
+          expect.objectContaining({ id: `${rect2.id}_copy`, isDeleted: true }),
           expect.objectContaining({
-            [ORIG_ID]: getCloneByOrigId(rect1.id)?.id,
+            id: `${rect1.id}_copy_copy`,
             isDeleted: false,
           }),
           expect.objectContaining({
-            [ORIG_ID]: getCloneByOrigId(rect2.id)?.id,
+            id: `${rect2.id}_copy_copy`,
             isDeleted: false,
           }),
         ]),

packages/excalidraw/tests/library.test.tsx

@@ -1,11 +1,11 @@
 import React from "react";
 import { vi } from "vitest";
-import { fireEvent, getCloneByOrigId, render, waitFor } from "./test-utils";
+import { fireEvent, render, waitFor } from "./test-utils";
 import { act, queryByTestId } from "@testing-library/react";
 
 import { Excalidraw } from "../index";
 import { API } from "./helpers/api";
-import { MIME_TYPES, ORIG_ID } from "../constants";
+import { MIME_TYPES } from "../constants";
 import type { LibraryItem, LibraryItems } from "../types";
 import { UI } from "./helpers/ui";
 import { serializeLibraryAsJSON } from "../data/json";
@@ -76,7 +76,7 @@ describe("library", () => {
       }),
     );
     await waitFor(() => {
-      expect(h.elements).toEqual([expect.objectContaining({ [ORIG_ID]: "A" })]);
+      expect(h.elements).toEqual([expect.objectContaining({ id: "A_copy" })]);
     });
   });
 
@@ -125,27 +125,23 @@ describe("library", () => {
     );
 
     await waitFor(() => {
-      expect(h.elements).toEqual(
-        expect.arrayContaining([
-          expect.objectContaining({
-            [ORIG_ID]: "rectangle1",
-            boundElements: expect.arrayContaining([
-              { type: "text", id: getCloneByOrigId("text1").id },
-              { type: "arrow", id: getCloneByOrigId("arrow1").id },
-            ]),
-          }),
-          expect.objectContaining({
-            [ORIG_ID]: "text1",
-            containerId: getCloneByOrigId("rectangle1").id,
-          }),
-          expect.objectContaining({
-            [ORIG_ID]: "arrow1",
-            endBinding: expect.objectContaining({
-              elementId: getCloneByOrigId("rectangle1").id,
-            }),
-          }),
-        ]),
-      );
+      expect(h.elements).toEqual([
+        expect.objectContaining({
+          id: "rectangle1_copy",
+          boundElements: expect.arrayContaining([
+            { type: "text", id: "text1_copy" },
+            { type: "arrow", id: "arrow1_copy" },
+          ]),
+        }),
+        expect.objectContaining({
+          id: "text1_copy",
+          containerId: "rectangle1_copy",
+        }),
+        expect.objectContaining({
+          id: "arrow1_copy",
+          endBinding: expect.objectContaining({ elementId: "rectangle1_copy" }),
+        }),
+      ]);
     });
   });
 
@@ -174,11 +170,10 @@ describe("library", () => {
     await waitFor(() => {
       expect(h.elements).toEqual([
         expect.objectContaining({
-          [ORIG_ID]: "elem1",
+          id: "elem1_copy",
         }),
         expect.objectContaining({
-          id: expect.not.stringMatching(/^elem1$/),
-          [ORIG_ID]: expect.not.stringMatching(/^\w+$/),
+          id: expect.not.stringMatching(/^(elem1_copy|elem1)$/),
         }),
       ]);
     });
@@ -194,7 +189,7 @@ describe("library", () => {
       }),
     );
     await waitFor(() => {
-      expect(h.elements).toEqual([expect.objectContaining({ [ORIG_ID]: "A" })]);
+      expect(h.elements).toEqual([expect.objectContaining({ id: "A_copy" })]);
     });
     expect(h.state.activeTool.type).toBe("selection");
   });

packages/excalidraw/tests/test-utils.ts

@@ -11,10 +11,6 @@ import { getSelectedElements } from "../scene/selection";
 import type { ExcalidrawElement } from "../element/types";
 import { UI } from "./helpers/ui";
 import { diffStringsUnified } from "jest-diff";
-import ansi from "ansicolor";
-import { ORIG_ID } from "../constants";
-import { arrayToMap } from "../utils";
-import type { AllPossibleKeys } from "../utility-types";
 
 const customQueries = {
   ...queries,
@@ -299,150 +295,3 @@ expect.addSnapshotSerializer({
     );
   },
 });
-
-export const getCloneByOrigId = <T extends boolean = false>(
-  origId: ExcalidrawElement["id"],
-  returnNullIfNotExists: T = false as T,
-): T extends true ? ExcalidrawElement | null : ExcalidrawElement => {
-  const clonedElement = window.h.elements?.find(
-    (el) => (el as any)[ORIG_ID] === origId,
-  );
-  if (clonedElement) {
-    return clonedElement;
-  }
-  if (returnNullIfNotExists !== true) {
-    throw new Error(`cloned element not found for origId: ${origId}`);
-  }
-  return null as T extends true ? ExcalidrawElement | null : ExcalidrawElement;
-};
-
-/**
- * Assertion helper that strips the actual elements of extra attributes
- * so that diffs are easier to read in case of failure.
- *
- * Asserts element order as well, and selected element ids
- * (when `selected: true` set for given element).
- *
- * If testing cloned elements, you can use { `[ORIG_ID]: origElement.id }
- * If you need to refer to cloned element properties, you can use
- * `getCloneByOrigId()`, e.g.: `{ frameId: getCloneByOrigId(origFrame.id)?.id }`
- */
-export const assertElements = <T extends AllPossibleKeys<ExcalidrawElement>>(
-  actualElements: readonly ExcalidrawElement[],
-  /** array order matters */
-  expectedElements: (Partial<Record<T, any>> & {
-    /** meta, will be stripped for element attribute checks */
-    selected?: true;
-  } & (
-      | {
-          id: ExcalidrawElement["id"];
-        }
-      | { [ORIG_ID]?: string }
-    ))[],
-) => {
-  const h = window.h;
-
-  const expectedElementsWithIds: (typeof expectedElements[number] & {
-    id: ExcalidrawElement["id"];
-  })[] = expectedElements.map((el) => {
-    if ("id" in el) {
-      return el;
-    }
-    const actualElement = actualElements.find(
-      (act) => (act as any)[ORIG_ID] === el[ORIG_ID],
-    );
-    if (actualElement) {
-      return { ...el, id: actualElement.id };
-    }
-    return {
-      ...el,
-      id: "UNKNOWN_ID",
-    };
-  });
-
-  const map_expectedElements = arrayToMap(expectedElementsWithIds);
-
-  const selectedElementIds = expectedElementsWithIds.reduce(
-    (acc: Record<ExcalidrawElement["id"], true>, el) => {
-      if (el.selected) {
-        acc[el.id] = true;
-      }
-      return acc;
-    },
-    {},
-  );
-
-  const mappedActualElements = actualElements.map((el) => {
-    const expectedElement = map_expectedElements.get(el.id);
-    if (expectedElement) {
-      const pickedAttrs: Record<string, any> = {};
-
-      for (const key of Object.keys(expectedElement)) {
-        if (key === "selected") {
-          delete expectedElement.selected;
-          continue;
-        }
-        pickedAttrs[key] = (el as any)[key];
-      }
-
-      if (ORIG_ID in expectedElement) {
-        // @ts-ignore
-        pickedAttrs[ORIG_ID] = (el as any)[ORIG_ID];
-      }
-
-      return pickedAttrs;
-    }
-    return el;
-  });
-
-  try {
-    // testing order separately for even easier diffs
-    expect(actualElements.map((x) => x.id)).toEqual(
-      expectedElementsWithIds.map((x) => x.id),
-    );
-  } catch (err: any) {
-    let errStr = "\n\nmismatched element order\n\n";
-
-    errStr += `actual:   ${ansi.lightGray(
-      `[${err.actual
-        .map((id: string, index: number) => {
-          const act = actualElements[index];
-
-          return `${
-            id === err.expected[index] ? ansi.green(id) : ansi.red(id)
-          } (${act.type.slice(0, 4)}${
-            ORIG_ID in act ? ` ↳ ${(act as any)[ORIG_ID]}` : ""
-          })`;
-        })
-        .join(", ")}]`,
-    )}\n${ansi.lightGray(
-      `expected: [${err.expected
-        .map((exp: string, index: number) => {
-          const expEl = actualElements.find((el) => el.id === exp);
-          const origEl =
-            expEl &&
-            actualElements.find((el) => el.id === (expEl as any)[ORIG_ID]);
-          return expEl
-            ? `${
-                exp === err.actual[index]
-                  ? ansi.green(expEl.id)
-                  : ansi.red(expEl.id)
-              } (${expEl.type.slice(0, 4)}${origEl ? ` ↳ ${origEl.id}` : ""})`
-            : exp;
-        })
-        .join(", ")}]\n`,
-    )}`;
-
-    const error = new Error(errStr);
-    const stack = err.stack.split("\n");
-    stack.splice(1, 1);
-    error.stack = stack.join("\n");
-    throw error;
-  }
-
-  expect(mappedActualElements).toEqual(
-    expect.arrayContaining(expectedElementsWithIds),
-  );
-
-  expect(h.state.selectedElementIds).toEqual(selectedElementIds);
-};

packages/excalidraw/tests/zindex.test.tsx

@@ -1,6 +1,6 @@
 import React from "react";
 import ReactDOM from "react-dom";
-import { act, getCloneByOrigId, render } from "./test-utils";
+import { act, render } from "./test-utils";
 import { Excalidraw } from "../index";
 import { reseed } from "../random";
 import {
@@ -916,9 +916,9 @@ describe("z-index manipulation", () => {
     API.executeAction(actionDuplicateSelection);
     expect(h.elements).toMatchObject([
       { id: "A" },
-      { id: getCloneByOrigId("A").id },
+      { id: "A_copy" },
       { id: "B" },
-      { id: getCloneByOrigId("B").id },
+      { id: "B_copy" },
     ]);
 
     populateElements([
@@ -930,12 +930,12 @@ describe("z-index manipulation", () => {
       { id: "A" },
       { id: "B" },
       {
-        id: getCloneByOrigId("A").id,
+        id: "A_copy",
 
         groupIds: [expect.stringMatching(/.{3,}/)],
       },
       {
-        id: getCloneByOrigId("B").id,
+        id: "B_copy",
 
         groupIds: [expect.stringMatching(/.{3,}/)],
       },
@@ -951,12 +951,12 @@ describe("z-index manipulation", () => {
       { id: "A" },
       { id: "B" },
       {
-        id: getCloneByOrigId("A").id,
+        id: "A_copy",
 
         groupIds: [expect.stringMatching(/.{3,}/)],
       },
       {
-        id: getCloneByOrigId("B").id,
+        id: "B_copy",
 
         groupIds: [expect.stringMatching(/.{3,}/)],
       },
@@ -972,10 +972,10 @@ describe("z-index manipulation", () => {
     expect(h.elements.map((element) => element.id)).toEqual([
       "A",
       "B",
-      getCloneByOrigId("A").id,
-      getCloneByOrigId("B").id,
+      "A_copy",
+      "B_copy",
       "C",
-      getCloneByOrigId("C").id,
+      "C_copy",
     ]);
 
     populateElements([
@@ -988,12 +988,12 @@ describe("z-index manipulation", () => {
     expect(h.elements.map((element) => element.id)).toEqual([
       "A",
       "B",
-      getCloneByOrigId("A").id,
-      getCloneByOrigId("B").id,
+      "A_copy",
+      "B_copy",
       "C",
       "D",
-      getCloneByOrigId("C").id,
-      getCloneByOrigId("D").id,
+      "C_copy",
+      "D_copy",
     ]);
 
     populateElements(
@@ -1010,10 +1010,10 @@ describe("z-index manipulation", () => {
     expect(h.elements.map((element) => element.id)).toEqual([
       "A",
       "B",
-      getCloneByOrigId("A").id,
-      getCloneByOrigId("B").id,
+      "A_copy",
+      "B_copy",
       "C",
-      getCloneByOrigId("C").id,
+      "C_copy",
     ]);
 
     populateElements(
@@ -1031,9 +1031,9 @@ describe("z-index manipulation", () => {
       "A",
       "B",
       "C",
-      getCloneByOrigId("A").id,
-      getCloneByOrigId("B").id,
-      getCloneByOrigId("C").id,
+      "A_copy",
+      "B_copy",
+      "C_copy",
     ]);
 
     populateElements(
@@ -1054,15 +1054,15 @@ describe("z-index manipulation", () => {
       "A",
       "B",
       "C",
-      getCloneByOrigId("A").id,
-      getCloneByOrigId("B").id,
-      getCloneByOrigId("C").id,
+      "A_copy",
+      "B_copy",
+      "C_copy",
       "D",
       "E",
       "F",
-      getCloneByOrigId("D").id,
-      getCloneByOrigId("E").id,
-      getCloneByOrigId("F").id,
+      "D_copy",
+      "E_copy",
+      "F_copy",
     ]);
 
     populateElements(
@@ -1076,7 +1076,7 @@ describe("z-index manipulation", () => {
     API.executeAction(actionDuplicateSelection);
     expect(h.elements.map((element) => element.id)).toEqual([
       "A",
-      getCloneByOrigId("A").id,
+      "A_copy",
       "B",
       "C",
     ]);
@@ -1093,7 +1093,7 @@ describe("z-index manipulation", () => {
     expect(h.elements.map((element) => element.id)).toEqual([
       "A",
       "B",
-      getCloneByOrigId("B").id,
+      "B_copy",
       "C",
     ]);
 
@@ -1108,9 +1108,9 @@ describe("z-index manipulation", () => {
     API.executeAction(actionDuplicateSelection);
     expect(h.elements.map((element) => element.id)).toEqual([
       "A",
-      getCloneByOrigId("A").id,
+      "A_copy",
       "B",
-      getCloneByOrigId("B").id,
+      "B_copy",
       "C",
     ]);
   });
@@ -1125,8 +1125,8 @@ describe("z-index manipulation", () => {
     expect(h.elements.map((element) => element.id)).toEqual([
       "A",
       "C",
-      getCloneByOrigId("A").id,
-      getCloneByOrigId("C").id,
+      "A_copy",
+      "C_copy",
       "B",
     ]);
   });
@@ -1144,9 +1144,9 @@ describe("z-index manipulation", () => {
       "A",
       "B",
       "C",
-      getCloneByOrigId("A").id,
-      getCloneByOrigId("B").id,
-      getCloneByOrigId("C").id,
+      "A_copy",
+      "B_copy",
+      "C_copy",
       "D",
     ]);
   });

packages/excalidraw/utility-types.ts

@@ -65,6 +65,3 @@ export type MakeBrand<T extends string> = {
 
 /** Maybe just promise or already fulfilled one! */
 export type MaybePromise<T> = T | Promise<T>;
-
-// get union of all keys from the union of types
-export type AllPossibleKeys<T> = T extends any ? keyof T : never;

packages/excalidraw/utils.ts

@@ -9,11 +9,7 @@ import {
   isDarwin,
   WINDOWS_EMOJI_FALLBACK_FONT,
 } from "./constants";
-import type {
-  ExcalidrawBindableElement,
-  FontFamilyValues,
-  FontString,
-} from "./element/types";
+import type { FontFamilyValues, FontString } from "./element/types";
 import type {
   ActiveTool,
   AppState,
@@ -547,9 +543,6 @@ export const isTransparent = (color: string) => {
   );
 };
 
-export const isBindingFallthroughEnabled = (el: ExcalidrawBindableElement) =>
-  el.fillStyle !== "solid" || isTransparent(el.backgroundColor);
-
 export type ResolvablePromise<T> = Promise<T> & {
   resolve: [T] extends [undefined]
     ? (value?: MaybePromise<Awaited<T>>) => void
@@ -1240,6 +1233,3 @@ export class PromisePool<T> {
 export const escapeDoubleQuotes = (str: string) => {
   return str.replace(/"/g, "&quot;");
 };
-
-export const castArray = <T>(value: T | T[]): T[] =>
-  Array.isArray(value) ? value : [value];

yarn.lock

@@ -3916,11 +3916,6 @@ ansi-styles@^6.0.0, ansi-styles@^6.1.0:
   resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-6.2.1.tgz#0e62320cf99c21afff3b3012192546aacbfb05c5"
   integrity sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==
 
-ansicolor@2.0.3:
-  version "2.0.3"
-  resolved "https://registry.yarnpkg.com/ansicolor/-/ansicolor-2.0.3.tgz#ec4448ae5baf8c2d62bf2dad52eac06ba0b5ea21"
-  integrity sha512-pzusTqk9VHrjgMCcTPDTTvfJfx6Q3+L5tQ6yKC8Diexmoit4YROTFIkxFvRTNL9y5s0Q8HrSrgerCD5bIC+Kiw==
-
 anymatch@~3.1.2:
   version "3.1.3"
   resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-3.1.3.tgz#790c58b19ba1720a84205b57c618d5ad8524973e"