Virtual whiteboard for sketching hand-drawn like diagrams
feat(editor): auto increment numbers/lists on duplicate (#12189)
David Luzar9ba66ed9b5bf
diff --git a/packages/element/src/index.ts b/packages/element/src/index.tsindex c45184036f..8fa93b2de6 100644--- a/packages/element/src/index.ts+++ b/packages/element/src/index.ts@@ -81,6 +81,7 @@ export * from "./groups";export * from "./heading";export * from "./image";export * from "./linearElementEditor";+export * from "./listMarker";export * from "./mutateElement";export * from "./newElement";export * from "./positionElementsOnGrid";diff --git a/packages/element/src/listMarker.ts b/packages/element/src/listMarker.tsnew file mode 100644index 0000000000..37c0f6193c--- /dev/null+++ b/packages/element/src/listMarker.ts@@ -0,0 +1,364 @@+import { arrayToMap } from "@excalidraw/common";++import { refreshTextDimensions } from "./newElement";+import {+ getBoundTextElement,+ getContainerElement,+ redrawTextBoundingBox,+} from "./textElement";+import { isBoundToContainer, isTextElement } from "./typeChecks";++import type { Scene } from "./Scene";+import type { ExcalidrawElement, ExcalidrawTextElement } from "./types";++/**+ * A list marker a text starts with: `1.`, `1)`, `(1)`, `[1]`, `a.`, `a)`,+ * `(a)`, `A.`, `iv.` etc. Must be followed by whitespace (or nothing), so that+ * `1.5` or `e.g.` aren't list markers. See also `LONE_NUMBER_REGEX`.+ *+ * (Letters don't take `[]`, as `[a]` tends to mean other things.)+ */+const LIST_MARKER_REGEX =+ /^(\s*)(?:\((\d{1,9}|[a-zA-Z]+)\)|\[(\d{1,9})\]|(\d{1,9}|[a-zA-Z]+)([.)]))(?=\s|$)/;++/** a text that's just a number counts as a list item too (e.g. a step badge) */+const LONE_NUMBER_REGEX = /^(\s*)(\d{1,9})\s*$/;++/** letters below `i` count alphabetically, from `i` up as roman numerals */+const LAST_ALPHA_ORDINAL = "h".charCodeAt(0) - "a".charCodeAt(0) + 1;++type ListMarkerKind = "decimal" | "alpha" | "roman";++/**+ * Lists count up to 42 (so that e.g. `2024. foo` isn't a list item), roman+ * numerals up to `xcix`.+ */+const MAX_ORDINAL: Record<ListMarkerKind, number> = {+ decimal: 42,+ alpha: 9, // i. (then switching to roman)+ roman: 99,+};++const toRoman = (value: number) =>+ ["", "x", "xx", "xxx", "xl", "l", "lx", "lxx", "lxxx", "xc"][+ Math.floor(value / 10)+ ] + ["", "i", "ii", "iii", "iv", "v", "vi", "vii", "viii", "ix"][value % 10];++const ROMAN_VALUES = new Map(+ Array.from({ length: MAX_ORDINAL.roman }, (_, index) => [+ toRoman(index + 1),+ index + 1,+ ]),+);++type ListMarker = {+ /** where the marker's value starts in the text */+ index: number;+ value: string;+ kind: ListMarkerKind;+ isUpperCase: boolean;+ /** e.g. `1.` and `2.` are of the same style, but `1.` and `(1)` aren't */+ style: string;+ /** 1-based */+ ordinal: number;+ /** where the item's text (after the marker and whitespace) starts */+ contentIndex: number;+};++const parseLoneNumber = (text: string): ListMarker | null => {+ const match = text.match(LONE_NUMBER_REGEX);+ if (!match) {+ return null;+ }++ const [, indent, value] = match;++ return {+ index: indent.length,+ value,+ kind: "decimal",+ isUpperCase: false,+ style: "decimal",+ ordinal: parseInt(value, 10),+ contentIndex: text.length,+ };+};++const parseListMarker = (text: string): ListMarker | null => {+ const match = text.match(LIST_MARKER_REGEX);+ if (!match) {+ return null;+ }++ const [, indent, parenValue, bracketValue, plainValue, plainSuffix] = match;+ const value = parenValue ?? bracketValue ?? plainValue;+ const lowerCaseValue = value.toLowerCase();+ const isUpperCase = /[A-Z]/.test(value);+ const alphaOrdinal = lowerCaseValue.charCodeAt(0) - "a".charCodeAt(0) + 1;++ let kind: ListMarkerKind;+ let ordinal: number;++ if (/\d/.test(value)) {+ kind = "decimal";+ ordinal = parseInt(value, 10);+ } else if (isUpperCase && /[a-z]/.test(value)) {+ // mixed case+ return null;+ } else if (value.length === 1 && alphaOrdinal <= LAST_ALPHA_ORDINAL) {+ kind = "alpha";+ ordinal = alphaOrdinal;+ } else if (ROMAN_VALUES.has(lowerCaseValue)) {+ kind = "roman";+ ordinal = ROMAN_VALUES.get(lowerCaseValue)!;+ } else {+ return null;+ }++ const affixes =+ parenValue !== undefined+ ? "()"+ : bracketValue !== undefined+ ? "[]"+ : plainSuffix;++ return {+ index: indent.length + (plainValue !== undefined ? 0 : 1),+ value,+ kind,+ isUpperCase,+ style: `${kind}${isUpperCase ? "-upper" : ""}${affixes}`,+ ordinal,+ contentIndex:+ match[0].length + text.slice(match[0].length).match(/^\s*/)![0].length,+ };+};++/**+ * @returns the list marker the text starts with (or the number the text is),+ * unless the text is a whole list (other lines start with markers of+ * the same style)+ */+const getListItemMarker = (text: string): ListMarker | null => {+ const marker = parseLoneNumber(text) ?? parseListMarker(text);+ if (!marker || marker.ordinal > MAX_ORDINAL[marker.kind]) {+ return null;+ }++ const otherLines = text.slice(marker.index).split("\n").slice(1);+ if (+ otherLines.some((line) => parseListMarker(line)?.style === marker.style)+ ) {+ return null;+ }++ return marker;+};++/** @returns `null` if the marker would be past `MAX_ORDINAL` */+const renumberListMarker = (+ text: string,+ marker: ListMarker,+ ordinal: number,+): string | null => {+ if (ordinal > MAX_ORDINAL[marker.kind]) {+ return null;+ }++ let value: string;+ if (marker.kind === "decimal") {+ // keep zero padding (`01.` -> `02.`)+ value = String(ordinal).padStart(+ marker.value.startsWith("0") ? marker.value.length : 0,+ "0",+ );+ } else if (marker.kind === "alpha") {+ value = String.fromCharCode("a".charCodeAt(0) + ordinal - 1);+ } else {+ value = toRoman(ordinal);+ }++ if (marker.isUpperCase) {+ value = value.toUpperCase();+ }++ return (+ text.slice(0, marker.index) ++ value ++ text.slice(marker.index + marker.value.length)+ );+};++/** a list marker advanced by duplication, to go back and forth */+export type ListMarkerAdvance = {+ elementId: ExcalidrawTextElement["id"];+ prevOriginalText: string;+ nextOriginalText: string;+ /**+ * where the item's text (after the marker and whitespace) starts in+ * `nextOriginalText` (its length if there's none)+ */+ contentStart: number;+ /** the label's container before the label (may have) grown it */+ prevContainerSize: { width: number; height: number } | null;+};++const setText = (+ element: ExcalidrawTextElement,+ container: ExcalidrawElement | null,+ originalText: string,+ scene: Scene,+) => {+ if (container) {+ scene.mutateElement(element, { originalText });+ // re-wraps the label, and grows the container if need be+ redrawTextBoundingBox(element, container, scene);+ } else {+ scene.mutateElement(element, {+ originalText,+ // re-wraps the text, and keeps it anchored as per its alignment+ ...refreshTextDimensions(+ element,+ null,+ scene.getNonDeletedElementsMap(),+ originalText,+ ),+ });+ }+};++/**+ * Advances the list markers of the duplicated texts and labels, so that+ * duplicating `1. foo` gives `2. foo` (and `1` gives `2`).+ *+ * Duplicating several list items at once continues the list from the+ * highest of them: duplicating `1.`, `3.`, `5.` gives `6.`, `7.`, `8.` (only+ * if they're just markers, i.e. without text).+ *+ * Only if nothing but list items (texts, or containers with list item labels)+ * is duplicated.+ */+export const advanceDuplicatedListMarkers = (+ duplicatedElements: readonly ExcalidrawElement[],+ scene: Scene,+): ListMarkerAdvance[] => {+ const duplicatesMap = arrayToMap(duplicatedElements);+ const elementsMap = scene.getNonDeletedElementsMap();++ // per marker style+ const itemsByStyle = new Map<+ string,+ {+ element: ExcalidrawTextElement;+ container: ExcalidrawElement | null;+ marker: ListMarker;+ }[]+ >();++ for (const element of duplicatedElements) {+ // a label goes with its container+ if (isBoundToContainer(element) && duplicatesMap.has(element.containerId)) {+ continue;+ }++ const text = isTextElement(element)+ ? element+ : getBoundTextElement(element, elementsMap);+ const marker = text && getListItemMarker(text.originalText);+ // list items duplicated along with anything else (another text, a shape,+ // a frame they're in…) are copied as they are+ if (!text || !marker) {+ return [];+ }++ const items = itemsByStyle.get(marker.style) ?? [];+ items.push({+ element: text,+ container: text === element ? null : element,+ marker,+ });+ itemsByStyle.set(marker.style, items);+ }++ // several list items are continued only if they're just markers (`1.`,+ // `2.`, `3.`), not items with text (`1. foo`, `2. bar`)+ const allItems = [...itemsByStyle.values()].flat();+ if (+ allItems.length > 1 &&+ allItems.some(+ ({ element, marker }) =>+ marker.contentIndex < element.originalText.length,+ )+ ) {+ return [];+ }++ const advances: ListMarkerAdvance[] = [];++ for (const items of itemsByStyle.values()) {+ const maxOrdinal = Math.max(...items.map((item) => item.marker.ordinal));+ // (stable, so items with the same marker keep their order)+ items.sort((a, b) => a.marker.ordinal - b.marker.ordinal);++ for (const [index, { element, container, marker }] of items.entries()) {+ const nextOriginalText = renumberListMarker(+ element.originalText,+ marker,+ maxOrdinal + 1 + index,+ );+ if (nextOriginalText === null) {+ continue;+ }++ advances.push({+ elementId: element.id,+ prevOriginalText: element.originalText,+ nextOriginalText,+ contentStart:+ marker.contentIndex ++ nextOriginalText.length -+ element.originalText.length,+ prevContainerSize: container+ ? { width: container.width, height: container.height }+ : null,+ });++ setText(element, container, nextOriginalText, scene);+ }+ }++ return advances;+};++/**+ * Sets the advanced list markers back (`"prev"`), or forth again (`"next"`).+ */+export const applyListMarkerAdvances = (+ advances: readonly ListMarkerAdvance[],+ direction: "prev" | "next",+ scene: Scene,+) => {+ const elementsMap = scene.getNonDeletedElementsMap();++ for (const advance of advances) {+ const element = elementsMap.get(advance.elementId);+ if (!element || !isTextElement(element)) {+ continue;+ }++ const container = getContainerElement(element, elementsMap);+ if (direction === "prev" && container && advance.prevContainerSize) {+ // labels only ever grow their containers+ scene.mutateElement(container, advance.prevContainerSize);+ }++ setText(+ element,+ container,+ direction === "prev"+ ? advance.prevOriginalText+ : advance.nextOriginalText,+ scene,+ );+ }+};diff --git a/packages/element/tests/duplicate.test.tsx b/packages/element/tests/duplicate.test.tsxindex abe8caa8b6..5c0fd9a0fd 100644--- a/packages/element/tests/duplicate.test.tsx+++ b/packages/element/tests/duplicate.test.tsx@@ -16,11 +16,16 @@ import { API } from "@excalidraw/excalidraw/tests/helpers/api";import { UI, Keyboard, Pointer } from "@excalidraw/excalidraw/tests/helpers/ui";+import { getTextEditor } from "@excalidraw/excalidraw/tests/queries/dom";+import {+ GlobalTestState,act,assertElements,+ fireEvent,getCloneByOrigId,render,+ waitFor,} from "@excalidraw/excalidraw/tests/test-utils";import type { LocalPoint } from "@excalidraw/math";@@ -31,7 +36,13 @@ import {duplicateElements,} from "../src/duplicate";-import type { ExcalidrawLinearElement } from "../src/types";+import { isBoundToContainer, isTextElement } from "../src/typeChecks";++import type {+ ExcalidrawLinearElement,+ ExcalidrawTextElement,+ NonDeletedExcalidrawElement,+} from "../src/types";const { h } = window;const mouse = new Pointer("mouse");@@ -863,3 +874,313 @@ describe("duplication z-order", () => {]);});});++describe("duplicating list items", () => {+ beforeEach(async () => {+ await render(<Excalidraw handleKeyboardGlobally={true} />);+ });++ const duplicate = (texts: string[]) => {+ const elements = texts.map((text, index) =>+ API.createElement({ type: "text", text, y: index * 100 }),+ );+ API.setElements(elements);+ API.setSelectedElements(elements);++ act(() => {+ h.app.actionManager.executeAction(actionDuplicateSelection);+ });++ // (each duplicate goes right after its original)+ const duplicates = h.elements.filter(+ (element) => h.state.selectedElementIds[element.id],+ ) as ExcalidrawTextElement[];++ return duplicates.map((element) => {+ expect(element).toMatchObject({ text: element.originalText });+ return element.originalText;+ });+ };++ it.each([+ ["1. foo", "2. foo"],+ ["1) foo", "2) foo"],+ ["(9) foo", "(10) foo"],+ ["[1] foo", "[2] foo"],+ ["09. foo", "10. foo"],+ ["0.", "1."],+ [" b. foo", " c. foo"],+ ["A) foo", "B) foo"],+ ["(a) foo", "(b) foo"],+ ["(A) foo", "(B) foo"],+ // below `i` alphabetically, from `i` up as roman numerals+ ["h. foo", "i. foo"],+ ["i. foo", "ii. foo"],+ ["viii) foo", "ix) foo"],+ ["(iv) foo", "(v) foo"],+ ["XXXIX. foo", "XL. foo"],+ ["l. foo", "li. foo"],+ ["1. step\n a. sub-step", "2. step\n a. sub-step"],+ // lone numbers+ ["7", "8"],+ [" 05 ", " 06 "],+ // numbers up to 42+ ["41", "42"],+ ["42", "42"],+ ["2024", "2024"],+ ["(41) foo", "(42) foo"],+ ["42. foo", "42. foo"],+ // not list items+ ["1.5 kg", "1.5 kg"],+ ["e.g. foo", "e.g. foo"],+ ["[a] foo", "[a] foo"],+ ["j. foo", "j. foo"],+ ["Ii. foo", "Ii. foo"],+ ["iiii. foo", "iiii. foo"],+ ["xcix. foo", "xcix. foo"],+ ["1. foo\n2. bar", "1. foo\n2. bar"],+ ])("advances the marker of %j", (text, expected) => {+ expect(duplicate([text])).toEqual([expected]);+ });++ it("continues the list from the highest of the duplicated items", () => {+ expect(duplicate(["5.", "1.", "3.", "a.", "1", "1"])).toEqual([+ "8.",+ "6.",+ "7.",+ "b.",+ "2",+ "3",+ ]);+ });++ it.each<[string, () => NonDeletedExcalidrawElement[], string[]]>([+ [+ "labeled containers",+ () => [+ ...API.createTextContainer({ label: { text: "1." } }),+ ...API.createTextContainer({ label: { text: "2." } }),+ ],+ ["3.", "4."],+ ],+ // several list items only if they're just markers+ [+ "list items with text",+ () => [+ API.createElement({ type: "text", text: "1. aa" }),+ API.createElement({ type: "text", text: "2. bb" }),+ API.createElement({ type: "text", text: "3. cc" }),+ ],+ ["1. aa", "2. bb", "3. cc"],+ ],+ // along with anything else, list items are copied as they are+ [+ "a labeled container and another element",+ () => [+ ...API.createTextContainer({ label: { text: "1. foo" } }),+ API.createElement({ type: "rectangle" }),+ ],+ ["1. foo"],+ ],+ [+ "a list item and another text",+ () => [+ API.createElement({ type: "text", text: "1. foo" }),+ API.createElement({ type: "text", text: "foo" }),+ ],+ ["1. foo", "foo"],+ ],+ [+ "a list item and another element",+ () => [+ API.createElement({ type: "text", text: "1. foo" }),+ API.createElement({ type: "rectangle" }),+ ],+ ["1. foo"],+ ],+ ])("duplicating %s", (_, createElements, expected) => {+ const elements = createElements();+ API.setElements(elements);+ API.setSelectedElements(+ elements.filter((element) => !isBoundToContainer(element)),+ );++ act(() => {+ h.app.actionManager.executeAction(actionDuplicateSelection);+ });++ expect(+ elements+ .filter(isTextElement)+ .map(+ (text) =>+ (getCloneByOrigId(text.id) as ExcalidrawTextElement).originalText,+ ),+ ).toEqual(expected);+ });++ it("stops letters at `i` (the switch to roman numerals)", () => {+ expect(duplicate(["g.", "h."])).toEqual(["i.", "h."]);+ });++ it.each([+ ["rectangle", "9. foo", "10. foo"],+ ["stickynote", "9. foo", "10. foo"],+ ["ellipse", "3", "4"],+ ] as const)(+ "advances the marker of a %s label %j",+ (type, text, expected) => {+ const container = API.createElement({ type });+ const label = API.createElement({+ type: "text",+ text,+ containerId: container.id,+ });+ API.setElements([container, label]);+ h.app.scene.mutateElement(container, {+ boundElements: [{ type: "text", id: label.id }],+ });+ API.setSelectedElements([container]);++ act(() => {+ h.app.actionManager.executeAction(actionDuplicateSelection);+ });++ assertElements(h.elements, [+ { id: container.id },+ { id: label.id, originalText: text },+ { [ORIG_ID]: container.id, selected: true },+ {+ [ORIG_ID]: label.id,+ containerId: getCloneByOrigId(container.id).id,+ originalText: expected,+ },+ ]);+ },+ );++ it("undo reverts the marker before the duplication", () => {+ const text = API.createElement({ type: "text", text: "1. foo" });+ API.setElements([text]);+ API.setSelectedElements([text]);++ act(() => {+ h.app.actionManager.executeAction(actionDuplicateSelection);+ });+ // (undo loses the ORIG_ID)+ const { id } = getCloneByOrigId(text.id);++ Keyboard.undo();+ assertElements(h.elements, [+ { id: text.id, originalText: "1. foo" },+ { id, selected: true, originalText: "1. foo" },+ ]);++ Keyboard.undo();+ assertElements(h.elements, [{ id: text.id }, { id, isDeleted: true }]);+ });++ it("alt-drag advances the markers from the start of the drag, undoably", async () => {+ const [container, label] = API.createTextContainer({+ label: { text: "9. foo" },+ });+ API.setElements([container, label]);+ API.setSelectedElements([container]);++ Keyboard.withModifierKeys({ alt: true }, () => {+ mouse.down(container.x + 5, container.y + 5);+ mouse.move(50, 50);+ });++ expect(getCloneByOrigId(label.id)).toMatchObject({+ originalText: "10. foo",+ });++ Keyboard.withModifierKeys({ alt: true }, () => {+ mouse.up();+ });++ // (undo loses the ORIG_ID)+ const duplicate = getCloneByOrigId(container.id);+ const duplicateLabel = getCloneByOrigId(label.id);+ expect(duplicateLabel).toMatchObject({ originalText: "10. foo" });++ // on to editing the item's text+ const editor = await getTextEditor();+ expect(h.state.editingTextElement?.id).toBe(duplicateLabel.id);+ expect(editor.value).toBe("10. foo");+ await waitFor(() =>+ expect([editor.selectionStart, editor.selectionEnd]).toEqual([4, 7]),+ );+ Keyboard.exitTextEditor(editor);++ Keyboard.undo();+ assertElements(h.elements, [+ { id: container.id },+ { id: label.id, originalText: "9. foo" },+ { id: duplicate.id, selected: true, x: duplicate.x, y: duplicate.y },+ { id: duplicateLabel.id, originalText: "9. foo" },+ ]);++ Keyboard.redo();+ assertElements(h.elements, [+ { id: container.id },+ { id: label.id },+ { id: duplicate.id, selected: true },+ { id: duplicateLabel.id, originalText: "10. foo" },+ ]);+ });++ it("alt-drag doesn't edit a list item without text", () => {+ const text = API.createElement({ type: "text", text: "1" });+ API.setElements([text]);+ API.setSelectedElements([text]);++ Keyboard.withModifierKeys({ alt: true }, () => {+ mouse.down(text.x + 5, text.y + 5);+ mouse.up(50, 50);+ });++ expect(getCloneByOrigId(text.id)).toMatchObject({ originalText: "2" });+ expect(h.state.editingTextElement).toBe(null);+ });++ it("alt-drag doesn't edit the list item when the drag gets interrupted", () => {+ const text = API.createElement({ type: "text", text: "1. foo" });+ API.setElements([text]);+ API.setSelectedElements([text]);++ Keyboard.withModifierKeys({ alt: true }, () => {+ mouse.down(text.x + 5, text.y + 5);+ mouse.move(50, 50);+ });+ fireEvent.pointerCancel(GlobalTestState.interactiveCanvas, {+ pointerId: 1,+ });++ expect(getCloneByOrigId(text.id)).toMatchObject({ originalText: "2. foo" });+ expect(h.state.editingTextElement).toBe(null);+ });++ it("leaves the texts of a duplicated frame as they are", () => {+ const frame = API.createElement({ type: "frame", width: 500 });+ const text = API.createElement({+ type: "text",+ text: "1. foo",+ frameId: frame.id,+ });+ API.setElements([text, frame]);+ API.setSelectedElements([frame]);++ act(() => {+ h.app.actionManager.executeAction(actionDuplicateSelection);+ });++ assertElements(h.elements, [+ { id: text.id },+ { id: frame.id },+ { [ORIG_ID]: text.id, originalText: "1. foo" },+ { [ORIG_ID]: frame.id, selected: true },+ ]);+ });+});diff --git a/packages/excalidraw/actions/actionDuplicateSelection.tsx b/packages/excalidraw/actions/actionDuplicateSelection.tsxindex f0386108f0..dea47f7cda 100644--- a/packages/excalidraw/actions/actionDuplicateSelection.tsx+++ b/packages/excalidraw/actions/actionDuplicateSelection.tsx@@ -98,6 +98,8 @@ export const actionDuplicateSelection = register({}}+ app.duplicate.advanceListMarkers(duplicatedElements);+return {elements: syncMovedIndices(elementsWithDuplicates,diff --git a/packages/excalidraw/components/App.duplicate.ts b/packages/excalidraw/components/App.duplicate.tsindex f9118b2d62..e6af94981d 100644--- a/packages/excalidraw/components/App.duplicate.ts+++ b/packages/excalidraw/components/App.duplicate.ts@@ -10,18 +10,22 @@ import {import {addElementsToFrame,+ advanceDuplicatedListMarkers,+ applyListMarkerAdvances,deepCopyElement,duplicateElements,filterElementsEligibleAsFrameChildren,getCommonBounds,getSelectionStateForElements,isBindableElement,+ isTextElement,newElementWith,reconcileDuplicatedElements,syncMovedIndices,updateBoundElements,} from "@excalidraw/element";+import type { ListMarkerAdvance } from "@excalidraw/element";import type { ExcalidrawElement } from "@excalidraw/element/types";import type { PointerDownState } from "../types";@@ -44,7 +48,13 @@ type Duplication = Pick<* `runOnDuplicate()`.*/export class AppDuplicate {- constructor(private app: App) {}+ constructor(+ private app: App,+ private dependencies: {+ /** pointers currently down */+ getPointerCount: () => number;+ },+ ) {}/*** Hands the duplication over to the host's `props.onDuplicate` (if any),@@ -70,6 +80,99 @@ export class AppDuplicate {);};+ /**+ * Runs `update` once what's pending is committed, capturing what it changes+ * (if it returns `true`) as a separate undo step.+ */+ private afterCommit(update: () => boolean) {+ // (setState callbacks run after componentDidUpdate, which commits)+ this.app.setState({}, () => {+ if (update()) {+ this.app.store.scheduleCapture();+ }+ });+ }++ /**+ * Advances the list markers of the duplicated texts (`1.` -> `2.`) once+ * the duplication is committed, as a separate undo step, so that undo+ * reverts the markers first.+ */+ advanceListMarkers = (duplicatedElements: readonly ExcalidrawElement[]) => {+ this.afterCommit(() => {+ const duplicates = duplicatedElements.flatMap(+ (element) => this.app.scene.getNonDeletedElement(element.id) ?? [],+ );++ return (+ advanceDuplicatedListMarkers(duplicates, this.app.scene).length > 0+ );+ });+ };++ /**+ * On alt-drag drop: the list markers advanced along with the drag go back,+ * for the drag to be committed as is, and forth again once it is, as+ * a separate undo step (before the browser gets to paint either).+ *+ * A single list item with text after its marker is then edited, with that+ * text selected (`1. |foo|`), as it's likely to differ from the original's.+ */+ commitDraggedListMarkers = (+ advances: readonly ListMarkerAdvance[],+ {+ editListItem,+ }: {+ /** `false` if the drag didn't end with a genuine pointerup */+ editListItem: boolean;+ },+ ) => {+ applyListMarkerAdvances(advances, "prev", this.app.scene);++ this.afterCommit(() => {+ applyListMarkerAdvances(advances, "next", this.app.scene);++ const [advance] = advances;+ if (+ editListItem &&+ advances.length === 1 &&+ advance.contentStart < advance.nextOriginalText.length+ ) {+ // once the marker is committed+ this.afterCommit(() => {+ this.editListItemText(advance);+ return false;+ });+ }++ return true;+ });+ };++ private editListItemText(advance: ListMarkerAdvance) {+ const element = this.app.scene.getNonDeletedElement(advance.elementId);+ if (+ !element ||+ !isTextElement(element) ||+ element.originalText !== advance.nextOriginalText ||+ // another interaction has started+ this.dependencies.getPointerCount() > 0+ ) {+ return;+ }++ this.app.text.startTextEditing({+ sceneX: element.x,+ sceneY: element.y,+ insertAtParentCenter: false,+ textElement: element,+ initialSelection: {+ start: advance.contentStart,+ end: element.originalText.length,+ },+ });+ }+/*** Duplicates elements so that they end up centered at the scene coords* (and in the frame at that point, if any). Doesn't update the scene.@@ -249,13 +352,6 @@ export class AppDuplicate {// (originals whose duplicates were vetoed are left behind)const duplicateElementsMap = arrayToMap(duplicatedElements);- duplicatedElements.forEach((element) => {- pointerDownState.originalElements.set(- element.id,- deepCopyElement(element),- );- });-const elementsWithIndices = syncMovedIndices(nextElements,duplicateElementsMap,@@ -304,6 +400,22 @@ export class AppDuplicate {}));this.app.scene.replaceAllElements(elementsWithIndices);++ // visible from the start of the drag, captured on drop (see+ // `commitDraggedListMarkers()`)+ pointerDownState.hit.advancedListMarkers = advanceDuplicatedListMarkers(+ duplicatedElements,+ this.app.scene,+ );++ // (after advancing the list markers, which may resize the duplicates)+ duplicatedElements.forEach((element) => {+ pointerDownState.originalElements.set(+ element.id,+ deepCopyElement(element),+ );+ });+selectedElements.forEach((element) => {if (isBindableElement(element) &&diff --git a/packages/excalidraw/components/App.text.ts b/packages/excalidraw/components/App.text.tsindex f54666246e..a9eaf9fe06 100644--- a/packages/excalidraw/components/App.text.ts+++ b/packages/excalidraw/components/App.text.ts@@ -170,6 +170,7 @@ export class AppText {{isExistingElement = false,initialCaretSceneCoords = null,+ initialSelection = null,}: {isExistingElement?: boolean;/**@@ -177,6 +178,8 @@ export class AppText {* text should be auto-selected*/initialCaretSceneCoords?: { x: number; y: number } | null;+ /** range of the text to select (takes precedence over the caret) */+ initialSelection?: { start: number; end: number } | null;},) {const elementsMap = this.app.scene.getElementsMapIncludingDeleted();@@ -359,6 +362,7 @@ export class AppText {excalidrawContainer: this.dependencies.getContainer(),app: this.app,initialCaretSceneCoords,+ initialSelection,// when text is selected, it's hard (at least on iOS) to re-position the// caret (i.e. deselect). There's not much use for always selecting// the text on edit anyway (and users can select-all from contextmenu@@ -601,6 +605,7 @@ export class AppText {container,autoEdit = true,initialCaretSceneCoords,+ initialSelection,arrowEndpoint,textElement,}: {@@ -613,6 +618,8 @@ export class AppText {container?: ExcalidrawTextContainer | null;autoEdit?: boolean;initialCaretSceneCoords?: { x: number; y: number };+ /** range of an existing text to select (takes precedence over the caret) */+ initialSelection?: { start: number; end: number };/*** creates the text as a label for this arrow endpoint: the binding then* dictates the text's position and alignment, overriding (sceneX, sceneY)@@ -843,6 +850,7 @@ export class AppText {initialCaretSceneCoords: existingTextElement? initialCaretSceneCoords: null,+ initialSelection: existingTextElement ? initialSelection : null,});} else {this.app.setState({diff --git a/packages/excalidraw/components/App.tsx b/packages/excalidraw/components/App.tsxindex a26fe3f083..d770f1ccea 100644--- a/packages/excalidraw/components/App.tsx+++ b/packages/excalidraw/components/App.tsx@@ -679,7 +679,9 @@ class App extends React.Component<AppProps, AppState> {public onStateChange: OnStateChange = this.appStateObserver.onStateChange;public bucketFill: AppBucketFill = new AppBucketFill(this);- public duplicate: AppDuplicate = new AppDuplicate(this);+ public duplicate: AppDuplicate = new AppDuplicate(this, {+ getPointerCount: () => gesture.pointers.size,+ });public toolDrag: AppToolDrag = new AppToolDrag(this);public flowchart: AppFlowchart = new AppFlowchart(this);public cursor: AppCursor = new AppCursor(this);@@ -8272,6 +8274,7 @@ class App extends React.Component<AppProps, AppState> {allHitElements: [],wasAddedToSelection: false,hasBeenDuplicated: false,+ advancedListMarkers: [],arrowLabel: false,hasHitCommonBoundingBoxOfSelectedElements:this.isHittingCommonBoundingBoxOfSelectedElements(@@ -10358,6 +10361,15 @@ class App extends React.Component<AppProps, AppState> {this.textTool.handlePointerUp(childEvent, pointerDownState);+ if (pointerDownState.hit.advancedListMarkers.length) {+ this.duplicate.commitDraggedListMarkers(+ pointerDownState.hit.advancedListMarkers,+ // not for a replay by the missing-pointerup cleanup (a+ // pointercancel, or the next interaction's pointerdown)+ { editListItem: childEvent.type === "pointerup" },+ );+ }+// an armed bucket fill commits only on a GENUINE pointer up. The// missing-pointer-up cleanup replays this handler with the pointer// DOWN event (e.g. when a second finger lands mid-press — pinch/pandiff --git a/packages/excalidraw/types.ts b/packages/excalidraw/types.tsindex 7b35930d33..a9cf94570e 100644--- a/packages/excalidraw/types.ts+++ b/packages/excalidraw/types.ts@@ -9,7 +9,10 @@ import type {import type { LinearElementEditor } from "@excalidraw/element";-import type { MaybeTransformHandleType } from "@excalidraw/element";+import type {+ ListMarkerAdvance,+ MaybeTransformHandleType,+} from "@excalidraw/element";import type {PointerType,@@ -1284,6 +1287,9 @@ export type PointerDownState = Readonly<{// Whether selected element(s) were duplicated, might change during the// pointer interactionhasBeenDuplicated: boolean;+ // The list markers advanced by duplicating the selected element(s)+ // (alt-drag)+ advancedListMarkers: readonly ListMarkerAdvance[];// Whether the pointer is hitting the common bounding box of selected// elements, which is useful for discriminating between selecitng// the entire selection vs a specific elementdiff --git a/packages/excalidraw/wysiwyg/textWysiwyg.tsx b/packages/excalidraw/wysiwyg/textWysiwyg.tsxindex b6164f3863..b9a8863ece 100644--- a/packages/excalidraw/wysiwyg/textWysiwyg.tsx+++ b/packages/excalidraw/wysiwyg/textWysiwyg.tsx@@ -257,6 +257,7 @@ export const textWysiwyg = ({app,autoSelect = true,initialCaretSceneCoords = null,+ initialSelection = null,}: {/*** textWysiwyg only deals with `originalText`@@ -273,6 +274,8 @@ export const textWysiwyg = ({app: App;autoSelect?: boolean;initialCaretSceneCoords?: { x: number; y: number } | null;+ /** range of `originalText` to select (takes precedence over the caret) */+ initialSelection?: { start: number; end: number } | null;}): SubmitHandler => {const ownerDocument = excalidrawContainer?.ownerDocument ?? document;const ownerWindow = ownerDocument.defaultView ?? window;@@ -724,18 +727,20 @@ export const textWysiwyg = ({}};- let pendingInitialSelection = (() => {- const caretIndex = getCaretIndexFromInitialSceneCoords();+ let pendingInitialSelection =+ initialSelection ??+ (() => {+ const caretIndex = getCaretIndexFromInitialSceneCoords();- if (caretIndex === null) {- return null;- }+ if (caretIndex === null) {+ return null;+ }- return {- start: caretIndex,- end: caretIndex,- };- })();+ return {+ start: caretIndex,+ end: caretIndex,+ };+ })();if (onChange) {editable.onpaste = async (event) => {