feat(editor): highlight duplicate matches in mermaid editor

Co-authored-by: dwelle <5153846+dwelle@users.noreply.github.com>

excalidraw-app/components/AI.tsx

@@ -25,19 +25,15 @@ export const AIComponents = ({
           const appState = excalidrawAPI.getAppState();
 
           const blob = await exportToBlob({
-            data: {
-              elements: children,
-              appState: {
-                ...appState,
-                exportBackground: true,
-                viewBackgroundColor: appState.viewBackgroundColor,
-              },
-              files: excalidrawAPI.getFiles(),
-            },
-            config: {
-              exportingFrame: frame,
-              mimeType: MIME_TYPES.jpg,
+            elements: children,
+            appState: {
+              ...appState,
+              exportBackground: true,
+              viewBackgroundColor: appState.viewBackgroundColor,
             },
+            exportingFrame: frame,
+            files: excalidrawAPI.getFiles(),
+            mimeType: MIME_TYPES.jpg,
           });
 
           const dataURL = await getDataURL(blob);

packages/element/src/collision.ts

@@ -465,7 +465,12 @@ export const intersectElementWithLineSegment = (
     case "line":
     case "freedraw":
     case "arrow":
-      return intersectLinearOrFreeDrawWithLineSegment(element, line, onlyFirst);
+      return intersectLinearOrFreeDrawWithLineSegment(
+        element,
+        line,
+        elementsMap,
+        onlyFirst,
+      );
   }
 };
 
@@ -532,11 +537,15 @@ const lineIntersections = (
 const intersectLinearOrFreeDrawWithLineSegment = (
   element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement,
   segment: LineSegment<GlobalPoint>,
+  elementsMap: ElementsMap,
   onlyFirst = false,
 ): GlobalPoint[] => {
   // NOTE: This is the only one which return the decomposed elements
   // rotated! This is due to taking advantage of roughjs definitions.
-  const [lines, curves] = deconstructLinearOrFreeDrawElement(element);
+  const [lines, curves] = deconstructLinearOrFreeDrawElement(
+    element,
+    elementsMap,
+  );
   const intersections: GlobalPoint[] = [];
 
   for (const l of lines) {

packages/element/src/distance.ts

@@ -48,7 +48,7 @@ export const distanceToElement = (
     case "line":
     case "arrow":
     case "freedraw":
-      return distanceToLinearOrFreeDraElement(element, p);
+      return distanceToLinearOrFreeDraElement(element, elementsMap, p);
   }
 };
 
@@ -133,9 +133,13 @@ const distanceToEllipseElement = (
 
 const distanceToLinearOrFreeDraElement = (
   element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement,
+  elementsMap: ElementsMap,
   p: GlobalPoint,
 ) => {
-  const [lines, curves] = deconstructLinearOrFreeDrawElement(element);
+  const [lines, curves] = deconstructLinearOrFreeDrawElement(
+    element,
+    elementsMap,
+  );
   return Math.min(
     ...lines.map((s) => distanceToLineSegment(p, s)),
     ...curves.map((a) => curvePointDistance(a, p)),

packages/element/src/linearElementEditor.ts

@@ -476,16 +476,22 @@ export class LinearElementEditor {
       });
     }
 
-    invariant(
-      lastClickedPoint > -1 &&
-        selectedPointsIndices.includes(lastClickedPoint) &&
-        element.points[lastClickedPoint],
-      `There must be a valid lastClickedPoint in order to drag it. selectedPointsIndices(${JSON.stringify(
-        selectedPointsIndices,
-      )}) points(0..${
-        element.points.length - 1
-      }) lastClickedPoint(${lastClickedPoint})`,
-    );
+    if (
+      lastClickedPoint < 0 ||
+      !selectedPointsIndices.includes(lastClickedPoint) ||
+      !element.points[lastClickedPoint]
+    ) {
+      console.error(
+        `There must be a valid lastClickedPoint in order to drag it. selectedPointsIndices(${JSON.stringify(
+          selectedPointsIndices,
+        )}) points(0..${
+          element.points.length - 1
+        }) lastClickedPoint(${lastClickedPoint})`,
+      );
+
+      // Fall back to the actual last point as a last resort.
+      lastClickedPoint = element.points.length - 1;
+    }
 
     // point that's being dragged (out of all selected points)
     const draggingPoint = element.points[lastClickedPoint];
@@ -794,6 +800,7 @@ export class LinearElementEditor {
           element.points[index + 1],
           index,
           appState.zoom,
+          elementsMap,
         )
       ) {
         midpoints.push(null);
@@ -803,6 +810,7 @@ export class LinearElementEditor {
       const segmentMidPoint = LinearElementEditor.getSegmentMidPoint(
         element,
         index + 1,
+        elementsMap,
       );
       midpoints.push(segmentMidPoint);
       index++;
@@ -890,6 +898,7 @@ export class LinearElementEditor {
     endPoint: P,
     index: number,
     zoom: Zoom,
+    elementsMap: ElementsMap,
   ) {
     if (isElbowArrow(element)) {
       if (index >= 0 && index < element.points.length) {
@@ -904,7 +913,10 @@ export class LinearElementEditor {
 
     let distance = pointDistance(startPoint, endPoint);
     if (element.points.length > 2 && element.roundness) {
-      const [lines, curves] = deconstructLinearOrFreeDrawElement(element);
+      const [lines, curves] = deconstructLinearOrFreeDrawElement(
+        element,
+        elementsMap,
+      );
 
       invariant(
         lines.length === 0 && curves.length > 0,
@@ -924,6 +936,7 @@ export class LinearElementEditor {
   static getSegmentMidPoint(
     element: NonDeleted<ExcalidrawLinearElement>,
     index: number,
+    elementsMap: ElementsMap,
   ): GlobalPoint {
     if (isElbowArrow(element)) {
       invariant(
@@ -936,7 +949,10 @@ export class LinearElementEditor {
       return pointFrom<GlobalPoint>(element.x + p[0], element.y + p[1]);
     }
 
-    const [lines, curves] = deconstructLinearOrFreeDrawElement(element);
+    const [lines, curves] = deconstructLinearOrFreeDrawElement(
+      element,
+      elementsMap,
+    );
 
     invariant(
       (lines.length === 0 && curves.length > 0) ||
@@ -1851,6 +1867,7 @@ export class LinearElementEditor {
       const midSegmentMidpoint = LinearElementEditor.getSegmentMidPoint(
         element,
         index + 1,
+        elementsMap,
       );
 
       x = midSegmentMidpoint[0] - boundTextElement.width / 2;
@@ -2400,7 +2417,7 @@ const pointDraggingUpdates = (
     ? nextArrow.points[0]
     : endBindable
     ? updateBoundPoint(
-        element,
+        nextArrow,
         "endBinding",
         nextArrow.endBinding,
         endBindable,
@@ -2431,7 +2448,7 @@ const pointDraggingUpdates = (
       ? endLocalPoint
       : startBindable
       ? updateBoundPoint(
-          element,
+          nextArrow,
           "startBinding",
           nextArrow.startBinding,
           startBindable,

packages/element/src/selection.ts

@@ -11,6 +11,7 @@ import {
   isBoundToContainer,
   isFrameLikeElement,
   isLinearElement,
+  isTextElement,
 } from "./typeChecks";
 import {
   elementOverlapsWithFrame,
@@ -25,6 +26,7 @@ import type {
   ElementsMap,
   ElementsMapOrArray,
   ExcalidrawElement,
+  NonDeleted,
   NonDeletedExcalidrawElement,
 } from "./types";
 
@@ -288,3 +290,19 @@ export const getSelectionStateForElements = (
     ),
   };
 };
+
+/**
+ * Returns editing or single-selected text element, if any.
+ */
+export const getActiveTextElement = (
+  selectedElements: readonly NonDeleted<ExcalidrawElement>[],
+  appState: Pick<AppState, "editingTextElement">,
+) => {
+  const activeTextElement =
+    appState.editingTextElement ||
+    (selectedElements.length === 1 &&
+      isTextElement(selectedElements[0]) &&
+      selectedElements[0]);
+
+  return activeTextElement || null;
+};

packages/element/src/shape.ts

@@ -57,8 +57,8 @@ import { headingForPointIsHorizontal } from "./heading";
 
 import { canChangeRoundness } from "./comparisons";
 import {
+  elementCenterPoint,
   getArrowheadPoints,
-  getCenterForBounds,
   getDiamondPoints,
   getElementAbsoluteCoords,
 } from "./bounds";
@@ -583,7 +583,11 @@ const getArrowheadShapes = (
 
 export const generateLinearCollisionShape = (
   element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement,
-) => {
+  elementsMap: ElementsMap,
+): {
+  op: string;
+  data: number[];
+}[] => {
   const generator = new RoughGenerator();
   const options: Options = {
     seed: element.seed,
@@ -592,20 +596,7 @@ export const generateLinearCollisionShape = (
     roughness: 0,
     preserveVertices: true,
   };
-  const center = getCenterForBounds(
-    // Need a non-rotated center point
-    element.points.reduce(
-      (acc, point) => {
-        return [
-          Math.min(element.x + point[0], acc[0]),
-          Math.min(element.y + point[1], acc[1]),
-          Math.max(element.x + point[0], acc[2]),
-          Math.max(element.y + point[1], acc[3]),
-        ];
-      },
-      [Infinity, Infinity, -Infinity, -Infinity],
-    ),
-  );
+  const center = elementCenterPoint(element, elementsMap);
 
   switch (element.type) {
     case "line":

packages/element/src/textElement.ts

@@ -347,6 +347,7 @@ export const getContainerCenter = (
     midSegmentMidpoint = LinearElementEditor.getSegmentMidPoint(
       container,
       index + 1,
+      elementsMap,
     );
   }
   return { x: midSegmentMidpoint[0], y: midSegmentMidpoint[1] };
@@ -441,7 +442,8 @@ const VALID_CONTAINER_TYPES = new Set([
 
 export const isValidTextContainer = (element: {
   type: ExcalidrawElementType;
-}) => VALID_CONTAINER_TYPES.has(element.type);
+}): element is ExcalidrawTextContainer =>
+  VALID_CONTAINER_TYPES.has(element.type);
 
 export const computeContainerDimensionForBoundText = (
   dimension: number,

packages/element/src/textWrapping.ts

@@ -4,6 +4,22 @@ import { charWidth, getLineWidth } from "./textMeasurements";
 
 import type { FontString } from "./types";
 
+/**
+ * This module approximates browser-like soft wrapping for Excalidraw text.
+ *
+ * The flow is:
+ * 1. `parseTokens()` splits a hard line into breakable tokens using a unicode-aware regex.
+ * 2. `getWrappedTextLines()` reflows each hard line into one or more visual lines and
+ *    records where each visual line came from in the source text.
+ * 3. `wrapLine()` assembles tokens into lines, and `wrapWord()` handles a single token
+ *    that is wider than the available width.
+ * 4. `trimLine()` / `trimLineEndAtSoftBreak()` mirror browser behavior around trailing
+ *    whitespace so the rendered text stays consistent with what users see on canvas.
+ *
+ * Mostly, you'll want to use wrapText(). getWrappedTextLines() is for callers
+ * that need metadata such as mapping visual lines back to `originalText`
+ * for caret placement or future editor features.
+ */
 let cachedCjkRegex: RegExp | undefined;
 let cachedLineBreakRegex: RegExp | undefined;
 let cachedEmojiRegex: RegExp | undefined;
@@ -358,6 +374,10 @@ const Break = {
 
 /**
  * Breaks the line into the tokens based on the found line break opporutnities.
+ *
+ * Note: tokenization normalizes to NFC first so decomposed graphemes are treated as
+ * their composed variants for wrapping. Any code that needs exact source offsets should
+ * keep in mind that this assumes the input text is already NFC-normalized.
  */
 export const parseTokens = (line: string) => {
   const breakLineRegex = getLineBreakRegex();
@@ -370,56 +390,120 @@ export const parseTokens = (line: string) => {
 
 /**
  * Wraps the original text into the lines based on the given width.
+ *
+ * This is a convenience adapter over `getWrappedTextLines()` for call sites
+ * that only need the rendered wrapped string and not the source offsets.
  */
 export const wrapText = (
   text: string,
   font: FontString,
   maxWidth: number,
 ): string => {
+  return getWrappedTextLines(text, font, maxWidth)
+    .map((line) => line.text)
+    .join("\n");
+};
+
+/**
+ * A single rendered visual line produced from the original text.
+ *
+ * `start` and `end` are end-exclusive code-unit offsets into the original text, and do
+ * not include synthetic soft line breaks inserted by this module. If trailing whitespace
+ * was trimmed away at a wrap boundary, `end` points to the last rendered character.
+ */
+export type WrappedTextLine = {
+  text: string;
+  start: number;
+  end: number;
+};
+
+/**
+ * Splits only on existing hard line breaks and preserves original offsets.
+ */
+const getHardLineBreaks = (text: string): WrappedTextLine[] => {
+  let offset = 0;
+
+  return text.split("\n").map((line) => {
+    const start = offset;
+    const end = start + line.length;
+
+    offset = end + 1;
+
+    return {
+      text: line,
+      start,
+      end,
+    };
+  });
+};
+
+/**
+ * Returns the rendered visual lines together with their source offsets.
+ *
+ * This is the source-of-truth wrapping pipeline for callers that need more than the
+ * final wrapped string, for example caret placement or future editor/rich-text mapping.
+ */
+export const getWrappedTextLines = (
+  text: string,
+  font: FontString,
+  maxWidth: number,
+): WrappedTextLine[] => {
   // if maxWidth is not finite or NaN which can happen in case of bugs in
   // computation, we need to make sure we don't continue as we'll end up
   // in an infinite loop
   if (!Number.isFinite(maxWidth) || maxWidth < 0) {
-    return text;
+    return getHardLineBreaks(text);
   }
 
-  const lines: Array<string> = [];
-  const originalLines = text.split("\n");
+  const lines: WrappedTextLine[] = [];
+  let offset = 0;
 
-  for (const originalLine of originalLines) {
-    const currentLineWidth = getLineWidth(originalLine, font);
+  for (const originalLine of text.split("\n")) {
+    const originalLineWidth = getLineWidth(originalLine, font);
 
-    if (currentLineWidth <= maxWidth) {
-      lines.push(originalLine);
-      continue;
+    if (originalLineWidth <= maxWidth) {
+      lines.push({
+        text: originalLine,
+        start: offset,
+        end: offset + originalLine.length,
+      });
+    } else {
+      lines.push(...wrapLine(originalLine, font, maxWidth, offset));
     }
 
-    const wrappedLine = wrapLine(originalLine, font, maxWidth);
-    lines.push(...wrappedLine);
+    offset += originalLine.length + 1;
   }
 
-  return lines.join("\n");
+  return lines;
 };
 
 /**
- * Wraps the original line into the lines based on the given width.
+ * Wraps a single hard line into one or more visual lines.
+ *
+ * The line-local offsets are tracked in original-text code units so
+ * we can map the visual line back to the source.
  */
 const wrapLine = (
   line: string,
   font: FontString,
   maxWidth: number,
-): string[] => {
-  const lines: Array<string> = [];
+  lineStart: number,
+): WrappedTextLine[] => {
+  const lines: WrappedTextLine[] = [];
   const tokens = parseTokens(line);
-  const tokenIterator = tokens[Symbol.iterator]();
 
   let currentLine = "";
+  let currentLineStart = lineStart;
+  let currentLineEnd = lineStart;
   let currentLineWidth = 0;
+  // Tracks the next token's code-unit position in the original source string.
+  let tokenOffset = lineStart;
+  let tokenIndex = 0;
 
-  let iterator = tokenIterator.next();
-
-  while (!iterator.done) {
-    const token = iterator.value;
+  while (tokenIndex < tokens.length) {
+    const token = tokens[tokenIndex];
+    const tokenStart = tokenOffset;
+    const tokenEnd = tokenStart + token.length;
     const testLine = currentLine + token;
 
     // cache single codepoint whitespace, CJK or emoji width calc. as kerning should not apply here
@@ -429,37 +513,59 @@ const wrapLine = (
 
     // build up the current line, skipping length check for possibly trailing whitespaces
     if (/\s/.test(token) || testLineWidth <= maxWidth) {
+      if (!currentLine) {
+        currentLineStart = tokenStart;
+      }
       currentLine = testLine;
+      currentLineEnd = tokenEnd;
       currentLineWidth = testLineWidth;
-      iterator = tokenIterator.next();
+      tokenOffset = tokenEnd;
+      tokenIndex++;
       continue;
     }
 
     // current line is empty => just the token (word) is longer than `maxWidth` and needs to be wrapped
     if (!currentLine) {
-      const wrappedWord = wrapWord(token, font, maxWidth);
-      const trailingLine = wrappedWord[wrappedWord.length - 1] ?? "";
+      const wrappedWord = wrapWord(token, font, maxWidth, tokenStart);
+      const trailingLine = wrappedWord[wrappedWord.length - 1] ?? {
+        text: "",
+        start: tokenStart,
+        end: tokenStart,
+      };
       const precedingLines = wrappedWord.slice(0, -1);
 
       lines.push(...precedingLines);
 
       // trailing line of the wrapped word might still be joined with next token/s
-      currentLine = trailingLine;
-      currentLineWidth = getLineWidth(trailingLine, font);
-      iterator = tokenIterator.next();
+      currentLine = trailingLine.text;
+      currentLineStart = trailingLine.start;
+      currentLineEnd = trailingLine.end;
+      currentLineWidth = getLineWidth(trailingLine.text, font);
+      tokenOffset = tokenEnd;
+      tokenIndex++;
     } else {
       // push & reset, but don't iterate on the next token, as we didn't use it yet!
-      lines.push(currentLine.trimEnd());
+      lines.push(
+        trimLineEndAtSoftBreak(currentLine, currentLineStart, currentLineEnd),
+      );
 
       // purposefully not iterating and not setting `currentLine` to `token`, so that we could use a simple !currentLine check above
       currentLine = "";
+      currentLineStart = tokenStart;
+      currentLineEnd = tokenStart;
       currentLineWidth = 0;
     }
   }
 
   // iterator done, push the trailing line if exists
   if (currentLine) {
-    const trailingLine = trimLine(currentLine, font, maxWidth);
+    const trailingLine = trimLine(
+      currentLine,
+      currentLineStart,
+      currentLineEnd,
+      font,
+      maxWidth,
+    );
     lines.push(trailingLine);
   }
 
@@ -467,59 +573,100 @@ const wrapLine = (
 };
 
 /**
- * Wraps the word into the lines based on the given width.
+ * Wraps a single word that could not be placed on an empty line as-is.
  */
 const wrapWord = (
   word: string,
   font: FontString,
   maxWidth: number,
-): Array<string> => {
+  wordStart: number,
+): WrappedTextLine[] => {
   // multi-codepoint emojis are already broken apart and shouldn't be broken further
   if (getEmojiRegex().test(word)) {
-    return [word];
+    return [
+      {
+        text: word,
+        start: wordStart,
+        end: wordStart + word.length,
+      },
+    ];
   }
 
   satisfiesWordInvariant(word);
 
-  const lines: Array<string> = [];
+  const lines: WrappedTextLine[] = [];
   const chars = Array.from(word);
 
   let currentLine = "";
+  let currentLineStart = wordStart;
+  let currentLineEnd = wordStart;
   let currentLineWidth = 0;
+  let offset = wordStart;
 
   for (const char of chars) {
+    const charStart = offset;
+    const charEnd = charStart + char.length;
     const _charWidth = charWidth.calculate(char, font);
     const testLineWidth = currentLineWidth + _charWidth;
 
     if (testLineWidth <= maxWidth) {
+      if (!currentLine) {
+        currentLineStart = charStart;
+      }
       currentLine = currentLine + char;
+      currentLineEnd = charEnd;
       currentLineWidth = testLineWidth;
+      offset = charEnd;
       continue;
     }
 
     if (currentLine) {
-      lines.push(currentLine);
+      lines.push({
+        text: currentLine,
+        start: currentLineStart,
+        end: currentLineEnd,
+      });
     }
 
     currentLine = char;
+    currentLineStart = charStart;
+    currentLineEnd = charEnd;
     currentLineWidth = _charWidth;
+    offset = charEnd;
   }
 
   if (currentLine) {
-    lines.push(currentLine);
+    lines.push({
+      text: currentLine,
+      start: currentLineStart,
+      end: currentLineEnd,
+    });
   }
 
   return lines;
 };
 
 /**
- * Similarly to browsers, does not trim all trailing whitespaces, but only those exceeding the `maxWidth`.
+ * Trims trailing whitespace that is exceeding the `maxWidth`.
+ *
+ * Used for the trailing visual line of a hard line, where some trailing
+ * whitespace may still be visible if it fits into the available width.
  */
-const trimLine = (line: string, font: FontString, maxWidth: number) => {
+const trimLine = (
+  line: string,
+  start: number,
+  end: number,
+  font: FontString,
+  maxWidth: number,
+): WrappedTextLine => {
   const shouldTrimWhitespaces = getLineWidth(line, font) > maxWidth;
 
   if (!shouldTrimWhitespaces) {
-    return line;
+    return {
+      text: line,
+      start,
+      end,
+    };
   }
 
   // defensively default to `trimeEnd` in case the regex does not match
@@ -543,7 +690,30 @@ const trimLine = (line: string, font: FontString, maxWidth: number) => {
     trimmedLineWidth = testLineWidth;
   }
 
-  return trimmedLine;
+  return {
+    text: trimmedLine,
+    start,
+    end: end - (line.length - trimmedLine.length),
+  };
+};
+
+/**
+ * Used for internal soft-wrap boundaries, where trailing whitespace should not
+ * survive into the rendered line even though it still exists in the original
+ * text.
+ */
+const trimLineEndAtSoftBreak = (
+  line: string,
+  start: number,
+  end: number,
+): WrappedTextLine => {
+  const trimmedLine = line.trimEnd();
+
+  return {
+    text: trimmedLine,
+    start,
+    end: end - (line.length - trimmedLine.length),
+  };
 };
 
 /**

packages/element/src/utils.ts

@@ -124,6 +124,7 @@ const setElementShapesCacheEntry = <T extends ExcalidrawElement>(
  */
 export function deconstructLinearOrFreeDrawElement(
   element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement,
+  elementsMap: ElementsMap,
 ): [LineSegment<GlobalPoint>[], Curve<GlobalPoint>[]] {
   const cachedShape = getElementShapesCacheEntry(element, 0);
 
@@ -131,10 +132,7 @@ export function deconstructLinearOrFreeDrawElement(
     return cachedShape;
   }
 
-  const ops = generateLinearCollisionShape(element) as {
-    op: string;
-    data: number[];
-  }[];
+  const ops = generateLinearCollisionShape(element, elementsMap);
   const lines = [];
   const curves = [];
 

packages/element/tests/cropElement.test.tsx

@@ -330,30 +330,22 @@ describe("Cropping and other features", async () => {
     const widthToHeightRatio = image.width / image.height;
 
     const canvas = await exportToCanvas({
-      data: {
-        elements: [image],
-        // @ts-ignore
-        appState: h.state,
-        files: h.app.files,
-      },
-      config: {
-        padding: 0,
-      },
+      elements: [image],
+      // @ts-ignore
+      appState: h.state,
+      files: h.app.files,
+      exportPadding: 0,
     });
     const exportedCanvasRatio = canvas.width / canvas.height;
 
     expect(widthToHeightRatio).toBeCloseTo(exportedCanvasRatio);
 
     const svg = await exportToSvg({
-      data: {
-        elements: [image],
-        // @ts-ignore
-        appState: h.state,
-        files: h.app.files,
-      },
-      config: {
-        padding: 0,
-      },
+      elements: [image],
+      // @ts-ignore
+      appState: h.state,
+      files: h.app.files,
+      exportPadding: 0,
     });
     const svgWidth = svg.getAttribute("width");
     const svgHeight = svg.getAttribute("height");

packages/element/tests/textWrapping.test.ts

@@ -1,4 +1,8 @@
-import { wrapText, parseTokens } from "../src/textWrapping";
+import {
+  getWrappedTextLines,
+  parseTokens,
+  wrapText,
+} from "../src/textWrapping";
 
 import type { FontString } from "../src/types";
 
@@ -102,6 +106,71 @@ describe("Test wrapText", () => {
     expect(res2).toBe(`\tA)\none\ntab\n- two\ntabs\n- 8\nspace\ns`);
   });
 
+  it("should retain original text offsets for wrapped lines", () => {
+    expect(getWrappedTextLines("Hello World!", font, 60)).toEqual([
+      {
+        text: "Hello",
+        start: 0,
+        end: 5,
+      },
+      {
+        text: "World!",
+        start: 6,
+        end: 12,
+      },
+    ]);
+  });
+
+  it("should exclude whitespace trimmed away at soft-wrap boundaries from line offsets", () => {
+    expect(getWrappedTextLines("  Hello  World", font, 90)).toEqual([
+      {
+        text: "  Hello",
+        start: 0,
+        end: 7,
+      },
+      {
+        text: "World",
+        start: 9,
+        end: 14,
+      },
+    ]);
+  });
+
+  it("should retain offsets when wrapping a single long token", () => {
+    expect(getWrappedTextLines("Excalidraw", font, 50)).toEqual([
+      {
+        text: "Excal",
+        start: 0,
+        end: 5,
+      },
+      {
+        text: "idraw",
+        start: 5,
+        end: 10,
+      },
+    ]);
+  });
+
+  it("should preserve empty hard lines in metadata", () => {
+    expect(getWrappedTextLines("A\n\nB", font, 100)).toEqual([
+      {
+        text: "A",
+        start: 0,
+        end: 1,
+      },
+      {
+        text: "",
+        start: 2,
+        end: 2,
+      },
+      {
+        text: "B",
+        start: 3,
+        end: 4,
+      },
+    ]);
+  });
+
   describe("When text is CJK", () => {
     it("should break each CJK character when width is very small", () => {
       // "안녕하세요" (Hangul) + "こんにちは世界" (Hiragana, Kanji) + "ｺﾝﾆﾁハ" (Katakana) + "你好" (Han) = "Hello Hello World Hello Hi"

packages/excalidraw/actions/actionProperties.tsx

@@ -191,7 +191,7 @@ export const getFormValue = function <T extends Primitive>(
   elements: readonly ExcalidrawElement[],
   app: AppClassProperties,
   getAttribute: (element: ExcalidrawElement) => T,
-  isRelevantElement: true | ((element: ExcalidrawElement) => boolean),
+  elementPredicate: true | ((element: ExcalidrawElement) => boolean),
   defaultValue: T | ((isSomeElementSelected: boolean) => T),
 ): T {
   const editingTextElement = app.state.editingTextElement;
@@ -209,9 +209,9 @@ export const getFormValue = function <T extends Primitive>(
     if (hasSelection) {
       const selectedElements = app.scene.getSelectedElements(app.state);
       const targetElements =
-        isRelevantElement === true
+        elementPredicate === true
           ? selectedElements
-          : selectedElements.filter((el) => isRelevantElement(el));
+          : selectedElements.filter((el) => elementPredicate(el));
 
       ret =
         reduceToCommonValue(targetElements, getAttribute) ??
@@ -730,9 +730,28 @@ export const actionChangeOpacity = register<ExcalidrawElement["opacity"]>({
       captureUpdate: CaptureUpdateAction.IMMEDIATELY,
     };
   },
-  PanelComponent: ({ app, updateData }) => (
-    <Range updateData={updateData} app={app} testId="opacity" />
-  ),
+  PanelComponent: ({ elements, appState, app, updateData }) => {
+    const opacity = getFormValue(
+      elements,
+      app,
+      (element) => element.opacity,
+      true,
+      (hasSelection) => (hasSelection ? null : appState.currentItemOpacity),
+    );
+
+    return (
+      <Range
+        label={t("labels.opacity")}
+        value={opacity ?? appState.currentItemOpacity}
+        hasCommonValue={opacity !== null}
+        onChange={updateData}
+        min={0}
+        max={100}
+        step={10}
+        testId="opacity"
+      />
+    );
+  },
 });
 
 export const actionChangeFontSize = register<ExcalidrawTextElement["fontSize"]>(

packages/excalidraw/actions/actionTextAutoResize.ts

@@ -1,24 +1,24 @@
 import { getFontString } from "@excalidraw/common";
 
-import { newElementWith } from "@excalidraw/element";
+import { isExcalidrawElement, newElementWith } from "@excalidraw/element";
 import { measureText } from "@excalidraw/element";
 
 import { isTextElement } from "@excalidraw/element";
 
 import { CaptureUpdateAction } from "@excalidraw/element";
 
+import type { ExcalidrawElement } from "@excalidraw/element/types";
+
 import { getSelectedElements } from "../scene";
 
 import { register } from "./register";
 
-import type { AppClassProperties } from "../types";
-
 export const actionTextAutoResize = register({
   name: "autoResize",
   label: "labels.autoResize",
   icon: null,
   trackEvent: { category: "element" },
-  predicate: (elements, appState, _: unknown, app: AppClassProperties) => {
+  predicate: (elements, appState, _: unknown) => {
     const selectedElements = getSelectedElements(elements, appState);
     return (
       selectedElements.length === 1 &&
@@ -26,13 +26,18 @@ export const actionTextAutoResize = register({
       !selectedElements[0].autoResize
     );
   },
-  perform: (elements, appState, _, app) => {
+  perform: (elements, appState, targetElement) => {
     const selectedElements = getSelectedElements(elements, appState);
 
+    const targetTextElement =
+      isExcalidrawElement(targetElement) && isTextElement(targetElement)
+        ? targetElement
+        : (selectedElements[0] as ExcalidrawElement | undefined);
+
     return {
       appState,
       elements: elements.map((element) => {
-        if (element.id === selectedElements[0].id && isTextElement(element)) {
+        if (element.id === targetTextElement?.id && isTextElement(element)) {
           const metrics = measureText(
             element.originalText,
             getFontString(element),

packages/excalidraw/components/App.tsx

@@ -257,6 +257,7 @@ import {
   handleFocusPointPointerUp,
   maybeHandleArrowPointlikeDrag,
   getUncroppedWidthAndHeight,
+  getActiveTextElement,
 } from "@excalidraw/element";
 
 import type { GlobalPoint, LocalPoint, Radians } from "@excalidraw/math";
@@ -416,6 +417,7 @@ import {
 import { ElementCanvasButtons } from "../components/ElementCanvasButtons";
 import { LaserTrails } from "../laser-trails";
 import { withBatchedUpdates, withBatchedUpdatesThrottled } from "../reactUtils";
+import { isPointHittingTextAutoResizeHandle } from "../textAutoResizeHandle";
 import { textWysiwyg } from "../wysiwyg/textWysiwyg";
 import { isOverScrollBars } from "../scene/scrollbars";
 
@@ -684,9 +686,15 @@ class App extends React.Component<AppProps, AppState> {
   lastPointerDownEvent: React.PointerEvent<HTMLElement> | null = null;
   lastPointerUpEvent: React.PointerEvent<HTMLElement> | PointerEvent | null =
     null;
+  // TODO this is a hack and we should ideally unify touch and pointer events
+  // and implement our own double click handling end-to-end (currently we're
+  // using a mix of native browser for click events and manual for touch -
+  // and browser doubleClick sucks to begin with)
+  lastPointerUpIsDoubleClick: boolean = false;
   lastPointerMoveEvent: PointerEvent | null = null;
   /** current frame pointer cords */
   lastPointerMoveCoords: { x: number; y: number } | null = null;
+  private lastCompletedCanvasClicks: { x: number; y: number }[] = [];
   /** previous frame pointer coords */
   previousPointerMoveCoords: { x: number; y: number } | null = null;
   lastViewportPosition = { x: 0, y: 0 };
@@ -1248,6 +1256,26 @@ class App extends React.Component<AppProps, AppState> {
     ) as NullableGridSize;
   };
 
+  private getTextCreationGridPoint = (x: number, y: number) => {
+    const effectiveGridSize = this.getEffectiveGridSize();
+
+    if (effectiveGridSize === null) {
+      return null;
+    }
+
+    const getTextCreationGridCoordinate = (coordinate: number) => {
+      const topLeftGridPoint =
+        Math.floor(coordinate / effectiveGridSize) * effectiveGridSize;
+
+      return topLeftGridPoint;
+    };
+
+    return {
+      x: getTextCreationGridCoordinate(x),
+      y: getTextCreationGridCoordinate(y),
+    };
+  };
+
   private getHTMLIFrameElement(
     element: ExcalidrawIframeLikeElement,
   ): HTMLIFrameElement | undefined {
@@ -1438,6 +1466,21 @@ class App extends React.Component<AppProps, AppState> {
     return true;
   }
 
+  private isDoubleClick = (
+    lastPointerEvent:
+      | PointerEvent
+      | React.PointerEvent<HTMLElement>
+      | undefined
+      | null,
+    currentPointerEvent: PointerEvent | React.PointerEvent<HTMLElement>,
+  ) => {
+    return (
+      lastPointerEvent != null &&
+      currentPointerEvent.timeStamp - lastPointerEvent.timeStamp <=
+        TAP_TWICE_TIMEOUT
+    );
+  };
+
   private isIframeLikeElementCenter(
     el: ExcalidrawIframeLikeElement | null,
     event: React.PointerEvent<HTMLElement> | PointerEvent,
@@ -2321,6 +2364,7 @@ class App extends React.Component<AppProps, AppState> {
                             }
                             handleCanvasRef={this.handleInteractiveCanvasRef}
                             onContextMenu={this.handleCanvasContextMenu}
+                            onClick={this.handleCanvasClick}
                             onPointerMove={this.handleCanvasPointerMove}
                             onPointerUp={this.handleCanvasPointerUp}
                             onPointerCancel={this.removePointer}
@@ -3574,10 +3618,14 @@ class App extends React.Component<AppProps, AppState> {
         this.lassoTrail.endPath();
         this.deselectElements();
 
-        // @ts-ignore
         this.handleCanvasDoubleClick({
           clientX: touch.clientX,
           clientY: touch.clientY,
+          type: "touch",
+          altKey: false,
+          ctrlKey: false,
+          metaKey: false,
+          shiftKey: false,
         });
       }
       didTapTwice = false;
@@ -5617,8 +5665,14 @@ class App extends React.Component<AppProps, AppState> {
     element: ExcalidrawTextElement,
     {
       isExistingElement = false,
+      initialCaretSceneCoords = null,
     }: {
       isExistingElement?: boolean;
+      /**
+       * supply null if no caret positioning is desired, and instead
+       * text should be auto-selected
+       */
+      initialCaretSceneCoords?: { x: number; y: number } | null;
     },
   ) {
     const elementsMap = this.scene.getElementsMapIncludingDeleted();
@@ -5721,6 +5775,7 @@ class App extends React.Component<AppProps, AppState> {
       element,
       excalidrawContainer: this.excalidrawContainerRef.current,
       app: this,
+      initialCaretSceneCoords,
       // 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
@@ -5744,6 +5799,68 @@ class App extends React.Component<AppProps, AppState> {
     });
   }
 
+  private getSelectedTextElement(
+    container?: ExcalidrawTextContainer | null,
+  ): NonDeleted<ExcalidrawTextElement> | null {
+    const selectedElements = this.scene.getSelectedElements(this.state);
+
+    if (selectedElements.length !== 1) {
+      return null;
+    }
+
+    const selectedElement = selectedElements[0]!;
+
+    if (isTextElement(selectedElement)) {
+      return selectedElement;
+    }
+
+    if (!container) {
+      return null;
+    }
+
+    return getBoundTextElement(
+      selectedElement,
+      this.scene.getNonDeletedElementsMap(),
+    );
+  }
+
+  private getSelectedTextEditingContainerAtPosition(
+    hitElement: NonDeletedExcalidrawElement | null,
+    sceneCoords: { x: number; y: number },
+  ): ExcalidrawTextContainer | null | undefined {
+    const selectedElements = this.scene.getSelectedElements(this.state);
+
+    if (
+      selectedElements.length !== 1 ||
+      !hitElement ||
+      hitElement.id !== selectedElements[0]!.id
+    ) {
+      return null;
+    }
+
+    const selectedElement = selectedElements[0]!;
+
+    if (isTextElement(selectedElement)) {
+      return null;
+    }
+
+    if (!isValidTextContainer(selectedElement)) {
+      return undefined;
+    }
+
+    const textElement = this.getSelectedTextElement(selectedElement);
+    const hitTextElement = this.getTextElementAtPosition(
+      sceneCoords.x,
+      sceneCoords.y,
+    );
+
+    if (!textElement || hitTextElement?.id !== textElement.id) {
+      return undefined;
+    }
+
+    return selectedElement;
+  }
+
   private getTextElementAtPosition(
     x: number,
     y: number,
@@ -5757,6 +5874,58 @@ class App extends React.Component<AppProps, AppState> {
     return null;
   }
 
+  private isHittingTextAutoResizeHandle = (
+    selectedElements: NonDeleted<ExcalidrawElement>[],
+    point: Readonly<{ x: number; y: number }>,
+  ): boolean => {
+    const activeTextElement = getActiveTextElement(
+      selectedElements,
+      this.state,
+    );
+
+    if (
+      activeTextElement &&
+      !activeTextElement.isDeleted &&
+      !activeTextElement.autoResize &&
+      isPointHittingTextAutoResizeHandle(
+        point,
+        activeTextElement,
+        this.state.zoom.value,
+        this.editorInterface.formFactor,
+      )
+    ) {
+      return true;
+    }
+
+    return false;
+  };
+
+  private handleTextAutoResizeHandlePointerDown = (
+    selectedElements: NonDeleted<ExcalidrawElement>[],
+    point: Readonly<{ x: number; y: number }>,
+  ) => {
+    const activeTextElement = getActiveTextElement(
+      selectedElements,
+      this.state,
+    );
+    if (
+      !activeTextElement ||
+      !this.isHittingTextAutoResizeHandle(selectedElements, point)
+    ) {
+      return false;
+    }
+
+    this.actionManager.executeAction(
+      actionTextAutoResize,
+      "ui",
+      // we need to pass down the element since it may already be deselected
+      // due to the pointerdown
+      activeTextElement,
+    );
+    this.resetCursor();
+    return true;
+  };
+
   // NOTE: Hot path for hit testing, so avoid unnecessary computations
   private getElementAtPosition(
     x: number,
@@ -5969,6 +6138,7 @@ class App extends React.Component<AppProps, AppState> {
     insertAtParentCenter = true,
     container,
     autoEdit = true,
+    initialCaretSceneCoords,
   }: {
     /** X position to insert text at */
     sceneX: number;
@@ -5978,6 +6148,7 @@ class App extends React.Component<AppProps, AppState> {
     insertAtParentCenter?: boolean;
     container?: ExcalidrawTextContainer | null;
     autoEdit?: boolean;
+    initialCaretSceneCoords?: { x: number; y: number };
   }) => {
     let shouldBindToContainer = false;
 
@@ -5998,24 +6169,9 @@ class App extends React.Component<AppProps, AppState> {
         shouldBindToContainer = true;
       }
     }
-    let existingTextElement: NonDeleted<ExcalidrawTextElement> | null = null;
-
-    const selectedElements = this.scene.getSelectedElements(this.state);
-
-    if (selectedElements.length === 1) {
-      if (isTextElement(selectedElements[0])) {
-        existingTextElement = selectedElements[0];
-      } else if (container) {
-        existingTextElement = getBoundTextElement(
-          selectedElements[0],
-          this.scene.getNonDeletedElementsMap(),
-        );
-      } else {
-        existingTextElement = this.getTextElementAtPosition(sceneX, sceneY);
-      }
-    } else {
-      existingTextElement = this.getTextElementAtPosition(sceneX, sceneY);
-    }
+    const existingTextElement =
+      this.getSelectedTextElement(container) ||
+      this.getTextElementAtPosition(sceneX, sceneY);
 
     const fontFamily =
       existingTextElement?.fontFamily || this.state.currentItemFontFamily;
@@ -6062,11 +6218,32 @@ class App extends React.Component<AppProps, AppState> {
       y: sceneY,
     });
 
+    const textCreationGridPoint = this.getTextCreationGridPoint(sceneX, sceneY);
+
+    const newTextElementPosition = parentCenterPosition
+      ? {
+          x: parentCenterPosition.elementCenterX,
+          y: parentCenterPosition.elementCenterY,
+        }
+      : !existingTextElement
+      ? {
+          x: textCreationGridPoint?.x ?? sceneX,
+          y:
+            textCreationGridPoint === null
+              ? // Free text starts from a point cursor, so center the first line box on it.
+                sceneY - getLineHeightInPx(fontSize, lineHeight) / 2
+              : textCreationGridPoint.y,
+        }
+      : {
+          x: sceneX,
+          y: sceneY,
+        };
+
     const element =
       existingTextElement ||
       newTextElement({
-        x: parentCenterPosition ? parentCenterPosition.elementCenterX : sceneX,
-        y: parentCenterPosition ? parentCenterPosition.elementCenterY : sceneY,
+        x: newTextElementPosition.x,
+        y: newTextElementPosition.y,
         strokeColor: this.state.currentItemStrokeColor,
         backgroundColor: this.state.currentItemBackgroundColor,
         fillStyle: this.state.currentItemFillStyle,
@@ -6116,6 +6293,9 @@ class App extends React.Component<AppProps, AppState> {
     if (autoEdit || existingTextElement || container) {
       this.handleTextWysiwyg(element, {
         isExistingElement: !!existingTextElement,
+        initialCaretSceneCoords: existingTextElement
+          ? initialCaretSceneCoords
+          : null,
       });
     } else {
       this.setState({
@@ -6141,9 +6321,48 @@ class App extends React.Component<AppProps, AppState> {
     }
   };
 
+  private shouldHandleBrowserCanvasDoubleClick = (type: string) => {
+    // TODO remove this once we consolidate double-click logic and handle
+    // ourselves for all event types together
+    if (type === "touch") {
+      return true;
+    }
+    if (this.lastCompletedCanvasClicks.length === 0) {
+      return true;
+    }
+
+    if (this.lastCompletedCanvasClicks.length < 2) {
+      return false;
+    }
+
+    const [firstClick, secondClick] = this.lastCompletedCanvasClicks;
+
+    return (
+      pointDistance(
+        pointFrom(firstClick.x, firstClick.y),
+        pointFrom(secondClick.x, secondClick.y),
+      ) <= DOUBLE_TAP_POSITION_THRESHOLD
+    );
+  };
+
   private handleCanvasDoubleClick = (
-    event: React.MouseEvent<HTMLCanvasElement>,
+    event: Pick<
+      React.MouseEvent<HTMLCanvasElement>,
+      | "type"
+      | "clientX"
+      | "clientY"
+      | "altKey"
+      | "ctrlKey"
+      | "metaKey"
+      | "shiftKey"
+    >,
   ) => {
+    if (
+      this.state.editingTextElement ||
+      !this.shouldHandleBrowserCanvasDoubleClick(event.type)
+    ) {
+      return;
+    }
     // case: double-clicking with arrow/line tool selected would both create
     // text and enter multiElement mode
     if (this.state.multiElement) {
@@ -6331,6 +6550,21 @@ class App extends React.Component<AppProps, AppState> {
     }
   };
 
+  private handleCanvasClick = (event: React.MouseEvent<HTMLCanvasElement>) => {
+    if (event.button !== POINTER_BUTTON.MAIN) {
+      this.lastCompletedCanvasClicks = [];
+      return;
+    }
+
+    this.lastCompletedCanvasClicks = [
+      ...this.lastCompletedCanvasClicks.slice(-1),
+      {
+        x: event.clientX,
+        y: event.clientY,
+      },
+    ];
+  };
+
   private getElementLinkAtPosition = (
     scenePointer: Readonly<{ x: number; y: number }>,
     hitElementMightBeLocked: NonDeletedExcalidrawElement | null,
@@ -6761,27 +6995,23 @@ class App extends React.Component<AppProps, AppState> {
           },
           { informMutation: false, isDragging: false },
         );
+        const newLastIdx = multiElement.points.length - 1;
         this.setState({
           selectedLinearElement: {
             ...selectedLinearElement,
-            selectedPointsIndices:
-              selectedLinearElement.selectedPointsIndices?.includes(
-                multiElement.points.length,
-              )
-                ? [
-                    ...selectedLinearElement.selectedPointsIndices.filter(
-                      (idx) =>
-                        idx !== multiElement.points.length &&
-                        idx !== multiElement.points.length - 1,
+            selectedPointsIndices: selectedLinearElement.selectedPointsIndices
+              ? [
+                  ...new Set(
+                    selectedLinearElement.selectedPointsIndices.map((idx) =>
+                      Math.min(idx, newLastIdx),
                     ),
-                    multiElement.points.length - 1,
-                  ]
-                : selectedLinearElement.selectedPointsIndices,
-            lastCommittedPoint:
-              multiElement.points[multiElement.points.length - 1],
+                  ),
+                ]
+              : selectedLinearElement.selectedPointsIndices,
+            lastCommittedPoint: multiElement.points[newLastIdx],
             initialState: {
               ...selectedLinearElement.initialState,
-              lastClickedPoint: multiElement.points.length - 1,
+              lastClickedPoint: newLastIdx,
             },
           },
         });
@@ -6867,6 +7097,12 @@ class App extends React.Component<AppProps, AppState> {
     const elements = this.scene.getNonDeletedElements();
 
     const selectedElements = this.scene.getSelectedElements(this.state);
+
+    if (this.isHittingTextAutoResizeHandle(selectedElements, scenePointer)) {
+      setCursor(this.interactiveCanvas, CURSOR_TYPE.POINTER);
+      return;
+    }
+
     if (
       selectedElements.length === 1 &&
       !isOverScrollBar &&
@@ -7011,7 +7247,9 @@ class App extends React.Component<AppProps, AppState> {
         setCursor(this.interactiveCanvas, CURSOR_TYPE.AUTO);
       } else if (
         // if using cmd/ctrl, we're not dragging
-        !event[KEYS.CTRL_OR_CMD]
+        !event[KEYS.CTRL_OR_CMD] &&
+        // editing text -> don't show move cursor when hovering over its bbox
+        hitElement?.id !== this.state.editingTextElement?.id
       ) {
         if (
           (hitElement ||
@@ -7232,6 +7470,8 @@ class App extends React.Component<AppProps, AppState> {
   private handleCanvasPointerDown = (
     event: React.PointerEvent<HTMLElement>,
   ) => {
+    const selectedElements = this.scene.getSelectedElements(this.state);
+
     // If Ctrl is not held, ensure isBindingEnabled reflects the user preference.
     if (!event.ctrlKey) {
       const preferenceEnabled = this.state.bindingPreference === "enabled";
@@ -7455,6 +7695,15 @@ class App extends React.Component<AppProps, AppState> {
       selectedElementsAreBeingDragged: false,
     });
 
+    if (
+      this.handleTextAutoResizeHandlePointerDown(
+        selectedElements,
+        pointerDownState.origin,
+      )
+    ) {
+      return;
+    }
+
     if (this.handleDraggingScrollBar(event, pointerDownState)) {
       return;
     }
@@ -7680,6 +7929,10 @@ class App extends React.Component<AppProps, AppState> {
     }
 
     this.removePointer(event);
+    this.lastPointerUpIsDoubleClick = this.isDoubleClick(
+      this.lastPointerUpEvent,
+      event,
+    );
     this.lastPointerUpEvent = event;
 
     if (!event.ctrlKey) {
@@ -8516,6 +8769,7 @@ class App extends React.Component<AppProps, AppState> {
       insertAtParentCenter: !event.altKey,
       container,
       autoEdit: false,
+      initialCaretSceneCoords: { x: sceneX, y: sceneY },
     });
 
     resetCursor(this.interactiveCanvas);
@@ -11001,6 +11255,35 @@ class App extends React.Component<AppProps, AppState> {
         return;
       }
 
+      const selectedTextEditingContainer =
+        this.getSelectedTextEditingContainerAtPosition(hitElement, sceneCoords);
+
+      if (
+        activeTool.type === this.state.preferredSelectionTool.type &&
+        !this.state.editingTextElement &&
+        !pointerDownState.drag.hasOccurred &&
+        !pointerDownState.hit.wasAddedToSelection &&
+        !childEvent.shiftKey &&
+        !childEvent[KEYS.CTRL_OR_CMD] &&
+        !childEvent.altKey &&
+        childEvent.pointerType !== "touch" &&
+        hitElement &&
+        ((isTextElement(hitElement) &&
+          this.state.selectedElementIds[hitElement.id] &&
+          this.scene.getSelectedElements(this.state).length === 1) ||
+          selectedTextEditingContainer)
+      ) {
+        this.startTextEditing({
+          sceneX: sceneCoords.x,
+          sceneY: sceneCoords.y,
+          container: selectedTextEditingContainer,
+          initialCaretSceneCoords: this.lastPointerUpIsDoubleClick
+            ? undefined
+            : sceneCoords,
+        });
+        return;
+      }
+
       if (!activeTool.locked && activeTool.type !== "freedraw" && newElement) {
         this.setState((prevState) => ({
           selectedElementIds: makeNextSelectedElementIds(

packages/excalidraw/components/ImageExportDialog.tsx

@@ -1,3 +1,4 @@
+import { exportToCanvas } from "@excalidraw/utils/export";
 import React, { useEffect, useRef, useState } from "react";
 
 import {
@@ -5,7 +6,6 @@ import {
   EXPORT_IMAGE_TYPES,
   isFirefox,
   EXPORT_SCALES,
-  THEME,
   cloneJSON,
 } from "@excalidraw/common";
 
@@ -26,7 +26,6 @@ import { useCopyStatus } from "../hooks/useCopiedIndicator";
 
 import { t } from "../i18n";
 import { isSomeElementSelected } from "../scene";
-import { exportToCanvas } from "../scene/export";
 
 import { copyIcon, downloadIcon, helpIcon } from "./icons";
 import { Dialog } from "./Dialog";
@@ -129,26 +128,19 @@ const ImageExportModal = ({
     };
 
     exportToCanvas({
-      data: {
-        elements: exportedElements,
-        appState: {
-          ...appStateSnapshot,
-          name: projectName,
-          exportBackground: exportWithBackground,
-          exportScale,
-          exportEmbedScene: embedScene,
-        },
-        files,
-      },
-      config: {
-        padding: DEFAULT_EXPORT_PADDING,
-        maxWidthOrHeight: Math.max(maxWidth, maxHeight),
-        exportingFrame,
-        theme: exportWithDarkMode ? THEME.DARK : THEME.LIGHT,
-        canvasBackgroundColor: exportWithBackground
-          ? appStateSnapshot.viewBackgroundColor
-          : false,
+      elements: exportedElements,
+      appState: {
+        ...appStateSnapshot,
+        name: projectName,
+        exportBackground: exportWithBackground,
+        exportWithDarkMode,
+        exportScale,
+        exportEmbedScene: embedScene,
       },
+      files,
+      exportPadding: DEFAULT_EXPORT_PADDING,
+      maxWidthOrHeight: Math.max(maxWidth, maxHeight),
+      exportingFrame,
     })
       .then(async (canvas) => {
         if (isStaleRequest()) {

packages/excalidraw/components/PasteChartDialog.tsx

@@ -72,20 +72,18 @@ const ChartPreviewBtn = (props: {
     const previewNode = previewRef.current!;
 
     (async () => {
-      svg = await exportToSvg({
-        data: {
-          elements,
-          appState: {
-            exportBackground: false,
-            viewBackgroundColor: "#fff",
-          },
-          files: null,
+      svg = await exportToSvg(
+        elements,
+        {
+          exportBackground: false,
+          viewBackgroundColor: "#fff",
+          exportWithDarkMode: theme === "dark",
         },
-        config: {
+        null, // files
+        {
           skipInliningFonts: true,
-          theme,
         },
-      });
+      );
       svg.querySelector(".style-fonts")?.remove();
       previewNode.replaceChildren();
       previewNode.appendChild(svg);
@@ -136,20 +134,18 @@ const PlainTextPreviewBtn = (props: {
     const previewNode = previewRef.current!;
 
     (async () => {
-      const svg = await exportToSvg({
-        data: {
-          elements: [textElement],
-          appState: {
-            exportBackground: false,
-            viewBackgroundColor: "#fff",
-          },
-          files: null,
+      const svg = await exportToSvg(
+        [textElement],
+        {
+          exportBackground: false,
+          viewBackgroundColor: "#fff",
+          exportWithDarkMode: theme === "dark",
         },
-        config: {
+        null,
+        {
           skipInliningFonts: true,
-          theme,
         },
-      });
+      );
       svg.querySelector(".style-fonts")?.remove();
       previewNode.replaceChildren();
       previewNode.appendChild(svg);

packages/excalidraw/components/PublishLibrary.tsx

@@ -1,3 +1,4 @@
+import { exportToCanvas, exportToSvg } from "@excalidraw/utils/export";
 import { useCallback, useEffect, useRef, useState } from "react";
 
 import {
@@ -12,7 +13,6 @@ import {
 import { EditorLocalStorage } from "../data/EditorLocalStorage";
 import { canvasToBlob, resizeImageFile } from "../data/blob";
 import { t } from "../i18n";
-import { exportToCanvas, exportToSvg } from "../scene/export";
 
 import { Dialog } from "./Dialog";
 import DialogActionButton from "./DialogActionButton";
@@ -63,14 +63,9 @@ const generatePreviewImage = async (libraryItems: LibraryItems) => {
   // ---------------------------------------------------------------------------
   for (const [index, item] of libraryItems.entries()) {
     const itemCanvas = await exportToCanvas({
-      data: {
-        elements: item.elements,
-        files: null,
-        appState: {},
-      },
-      config: {
-        maxWidthOrHeight: BOX_SIZE,
-      },
+      elements: item.elements,
+      files: null,
+      maxWidthOrHeight: BOX_SIZE,
     });
 
     const { width, height } = itemCanvas;
@@ -132,18 +127,14 @@ const SingleLibraryItem = ({
     }
     (async () => {
       const svg = await exportToSvg({
-        data: {
-          elements: libItem.elements,
-          appState: {
-            ...appState,
-            viewBackgroundColor: "#fff",
-            exportBackground: true,
-          },
-          files: null,
-        },
-        config: {
-          skipInliningFonts: true,
+        elements: libItem.elements,
+        appState: {
+          ...appState,
+          viewBackgroundColor: "#fff",
+          exportBackground: true,
         },
+        files: null,
+        skipInliningFonts: true,
       });
       node.innerHTML = svg.outerHTML;
     })();

packages/excalidraw/components/Range.tsx

@@ -1,74 +1,78 @@
 import React, { useEffect } from "react";
 
-import { t } from "../i18n";
-
 import "./Range.scss";
 
-import type { AppClassProperties } from "../types";
-
 export type RangeProps = {
-  updateData: (value: number) => void;
-  app: AppClassProperties;
+  label: React.ReactNode;
+  value: number;
+  onChange: (value: number) => void;
+  min?: number;
+  max?: number;
+  step?: number;
+  minLabel?: React.ReactNode;
+  hasCommonValue?: boolean;
   testId?: string;
 };
 
-export const Range = ({ updateData, app, testId }: RangeProps) => {
+export const Range = ({
+  label,
+  value,
+  onChange,
+  min = 0,
+  max = 100,
+  step = 10,
+  minLabel = min,
+  hasCommonValue = true,
+  testId,
+}: RangeProps) => {
   const rangeRef = React.useRef<HTMLInputElement>(null);
   const valueRef = React.useRef<HTMLDivElement>(null);
-  const selectedElements = app.scene.getSelectedElements(app.state);
-  let hasCommonOpacity = true;
-  const firstElement = selectedElements.at(0);
-  const leastCommonOpacity = selectedElements.reduce((acc, element) => {
-    if (acc != null && acc !== element.opacity) {
-      hasCommonOpacity = false;
-    }
-    if (acc == null || acc > element.opacity) {
-      return element.opacity;
-    }
-    return acc;
-  }, firstElement?.opacity ?? null);
-
-  const value = leastCommonOpacity ?? app.state.currentItemOpacity;
 
   useEffect(() => {
     if (rangeRef.current && valueRef.current) {
       const rangeElement = rangeRef.current;
       const valueElement = valueRef.current;
       const inputWidth = rangeElement.offsetWidth;
-      const thumbWidth = 15; // 15 is the width of the thumb
+      const thumbWidth =
+        parseFloat(
+          getComputedStyle(rangeElement).getPropertyValue(
+            "--slider-thumb-size",
+          ),
+        ) || 16;
+      const progress = ((value - min) / (max - min || 1)) * 100;
       const position =
-        (value / 100) * (inputWidth - thumbWidth) + thumbWidth / 2;
+        (progress / 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-slider-track) 0%, var(--color-slider-track) ${progress}%, var(--button-bg) ${progress}%, var(--button-bg) 100%)`;
     }
-  }, [value]);
+  }, [max, min, value]);
 
   return (
     <label className="control-label">
-      {t("labels.opacity")}
+      {label}
       <div className="range-wrapper">
         <input
           style={{
-            ["--color-slider-track" as string]: hasCommonOpacity
+            ["--color-slider-track" as string]: hasCommonValue
               ? undefined
               : "var(--button-bg)",
           }}
           ref={rangeRef}
           type="range"
-          min="0"
-          max="100"
-          step="10"
+          min={min}
+          max={max}
+          step={step}
           onChange={(event) => {
-            updateData(+event.target.value);
+            onChange(+event.target.value);
           }}
           value={value}
           className="range-input"
           data-testid={testId}
         />
         <div className="value-bubble" ref={valueRef}>
-          {value !== 0 ? value : null}
+          {value !== min ? value : null}
         </div>
-        <div className="zero-label">0</div>
+        <div className="zero-label">{minLabel}</div>
       </div>
     </label>
   );

packages/excalidraw/components/Stats/stats.test.tsx

@@ -361,12 +361,10 @@ describe("stats for a non-generic element", () => {
     mouse.clickAt(20, 30);
     const editor = await getTextEditor();
     updateTextEditor(editor, "Hello!");
-    act(() => {
-      editor.blur();
-    });
+    Keyboard.exitTextEditor(editor);
 
     const text = h.elements[0] as ExcalidrawTextElement;
-    mouse.clickOn(text);
+    API.setSelectedElements([text]);
 
     elementStats = stats?.querySelector("#elementStats");
 

packages/excalidraw/components/TTDDialog/Chat/Chat.scss

@@ -3,7 +3,25 @@
 $verticalBreakpoint: 861px;
 
 .excalidraw {
+  --ttd-mermaid-token-keyword: #0000ff;
+  --ttd-mermaid-token-string: #a31515;
+  --ttd-mermaid-token-comment: #008000;
+  --ttd-mermaid-token-number: #098658;
+  --ttd-mermaid-token-operator: #1e1e1e;
+  --ttd-mermaid-token-punctuation: #1e1e1e;
+  --ttd-mermaid-token-variable-name: #001080;
+  --ttd-mermaid-token-bracket: #af00db;
+
   &.theme--dark {
+    --ttd-mermaid-token-keyword: #569cd6;
+    --ttd-mermaid-token-string: #ce9178;
+    --ttd-mermaid-token-comment: #6a9955;
+    --ttd-mermaid-token-number: #b5cea8;
+    --ttd-mermaid-token-operator: #d4d4d4;
+    --ttd-mermaid-token-punctuation: #d4d4d4;
+    --ttd-mermaid-token-variable-name: #9cdcfe;
+    --ttd-mermaid-token-bracket: #ffd700;
+
     .chat-message {
       &--assistant {
         .chat-message__content {
@@ -194,7 +212,7 @@ $verticalBreakpoint: 861px;
       align-items: flex-start;
 
       .chat-message__content {
-        background: var(--color-surface-low);
+        background: #f7f7f7;
         color: var(--color-on-surface);
         border-radius: var(--border-radius-md);
         min-width: 6rem;
@@ -292,6 +310,51 @@ $verticalBreakpoint: 861px;
       word-wrap: break-word;
     }
 
+    &__text--error {
+      color: inherit;
+    }
+
+    &__text--mermaid {
+      overflow-x: auto;
+      font-weight: 400;
+    }
+
+    &__token {
+      white-space: inherit;
+    }
+
+    &__token--keyword {
+      color: var(--ttd-mermaid-token-keyword);
+    }
+
+    &__token--string {
+      color: var(--ttd-mermaid-token-string);
+    }
+
+    &__token--comment {
+      color: var(--ttd-mermaid-token-comment);
+    }
+
+    &__token--number {
+      color: var(--ttd-mermaid-token-number);
+    }
+
+    &__token--operator {
+      color: var(--ttd-mermaid-token-operator);
+    }
+
+    &__token--punctuation {
+      color: var(--ttd-mermaid-token-punctuation);
+    }
+
+    &__token--variableName {
+      color: var(--ttd-mermaid-token-variable-name);
+    }
+
+    &__token--bracket {
+      color: var(--ttd-mermaid-token-bracket);
+    }
+
     &__cursor {
       display: inline-block;
       margin-left: 2px;
@@ -332,11 +395,13 @@ $verticalBreakpoint: 861px;
     &__error {
       color: var(--color-danger);
       font-weight: 500;
-      white-space: pre-wrap;
-      word-wrap: break-word;
       display: flex;
       flex-direction: column;
       gap: 0.5rem;
+
+      .chat-message__text--mermaid {
+        color: var(--color-on-surface);
+      }
     }
 
     &__error_message {

packages/excalidraw/components/TTDDialog/Chat/ChatMessage.tsx

@@ -5,8 +5,49 @@ import { t } from "../../../i18n";
 import { FilledButton } from "../../FilledButton";
 import { TrashIcon, codeIcon, stackPushIcon, RetryIcon } from "../../icons";
 
+import { tokenizeMermaid } from "../mermaid-highlighting";
+
 import type { TChat, TTTDDialog } from "../types";
 
+const isMermaidMessage = (message: TChat.ChatMessage) =>
+  message.contentFormat === "mermaid";
+
+const renderMessageContent = (
+  message: TChat.ChatMessage,
+  className: string,
+) => {
+  const content = message.content ?? "";
+
+  console.log("@", message);
+
+  if (!isMermaidMessage(message)) {
+    return (
+      <div className={className}>
+        {content}
+        {message.isGenerating && (
+          <span className="chat-message__cursor">▋</span>
+        )}
+      </div>
+    );
+  }
+
+  return (
+    <div className={clsx(className, "chat-message__text--mermaid")}>
+      {tokenizeMermaid(content).map((token, index) => (
+        <span
+          key={`${index}-${token.type ?? "text"}-${token.value}`}
+          className={clsx("chat-message__token", {
+            [`chat-message__token--${token.type}`]: token.type,
+          })}
+        >
+          {token.value}
+        </span>
+      ))}
+      {message.isGenerating && <span className="chat-message__cursor">▋</span>}
+    </div>
+  );
+};
+
 export const ChatMessage: React.FC<{
   message: TChat.ChatMessage;
   onMermaidTabClick?: (message: TChat.ChatMessage) => void;
@@ -122,7 +163,14 @@ export const ChatMessage: React.FC<{
         <div className="chat-message__body">
           {message.error ? (
             <>
-              <div className="chat-message__error">{message.content}</div>
+              <div className="chat-message__error">
+                {renderMessageContent(
+                  message,
+                  clsx("chat-message__text", {
+                    "chat-message__text--error": !isMermaidMessage(message),
+                  }),
+                )}
+              </div>
               {message.errorType !== "parse" && (
                 <div className="chat-message__error_message">
                   Error: {message.error || t("chat.errors.generationFailed")}
@@ -132,7 +180,7 @@ export const ChatMessage: React.FC<{
                 <div className="chat-message__error_message">
                   <p>{t("chat.errors.invalidDiagram")}</p>
                   <div className="chat-message__error-actions">
-                    {onMermaidTabClick && (
+                    {onMermaidTabClick && isMermaidMessage(message) && (
                       <button
                         className="chat-message__error-link"
                         onClick={() => onMermaidTabClick(message)}
@@ -156,18 +204,13 @@ export const ChatMessage: React.FC<{
               )}
             </>
           ) : (
-            <div className="chat-message__text">
-              {message.content}
-              {message.isGenerating && (
-                <span className="chat-message__cursor">▋</span>
-              )}
-            </div>
+            renderMessageContent(message, "chat-message__text")
           )}
         </div>
       </div>
       {message.type === "assistant" && !message.isGenerating && (
         <div className="chat-message__actions">
-          {!message.error && onInsertMessage && (
+          {!message.error && onInsertMessage && isMermaidMessage(message) && (
             <button
               className="chat-message__action"
               onClick={() => onInsertMessage(message)}
@@ -178,7 +221,7 @@ export const ChatMessage: React.FC<{
               {stackPushIcon}
             </button>
           )}
-          {onMermaidTabClick && message.content && (
+          {onMermaidTabClick && isMermaidMessage(message) && message.content && (
             <button
               className="chat-message__action"
               onClick={() => onMermaidTabClick(message)}

packages/excalidraw/components/TTDDialog/Chat/TTDChatPanel.tsx

@@ -25,6 +25,7 @@ export const TTDChatPanel = ({
   onGenerate,
   isGenerating,
   generatedResponse,
+  generatedResponseFormat,
   isMenuOpen,
   onMenuToggle,
   onMenuClose,
@@ -50,6 +51,7 @@ export const TTDChatPanel = ({
   onGenerate: TTTDDialog.OnGenerate;
   isGenerating: boolean;
   generatedResponse: string | null | undefined;
+  generatedResponseFormat?: TChat.ChatMessage["contentFormat"];
 
   isMenuOpen: boolean;
   onMenuToggle: () => void;
@@ -89,7 +91,7 @@ export const TTDChatPanel = ({
       });
     }
 
-    if (generatedResponse) {
+    if (generatedResponse && generatedResponseFormat === "mermaid") {
       actions.push({
         action: onViewAsMermaid,
         label: t("chat.viewAsMermaid"),

packages/excalidraw/components/TTDDialog/Chat/useChatAgent.ts

@@ -25,6 +25,7 @@ export const useChatAgent = () => {
         {
           type: "assistant",
           content: "",
+          contentFormat: "mermaid",
           isGenerating: true,
         },
       ]),

packages/excalidraw/components/TTDDialog/CodeMirrorEditor.tsx

@@ -1,13 +1,21 @@
 import { useEffect, useRef } from "react";
 import {
   Decoration,
+  type DecorationSet,
   EditorView,
+  ViewPlugin,
+  type ViewUpdate,
   keymap,
   lineNumbers,
   placeholder as cmPlaceholder,
   drawSelection,
 } from "@codemirror/view";
-import { Compartment, EditorState, type Extension } from "@codemirror/state";
+import {
+  Compartment,
+  EditorState,
+  type Extension,
+  type Range,
+} from "@codemirror/state";
 import {
   defaultKeymap,
   history,
@@ -40,6 +48,13 @@ const darkTheme = EditorView.theme(
     },
     ".cm-content": { caretColor: "#fff" },
     ".cm-cursor": { borderLeftColor: "#fff" },
+    ".cm-selectionBackground": {
+      backgroundColor: "rgba(86, 156, 214, 0.3)",
+    },
+    "&.cm-focused > .cm-scroller > .cm-selectionLayer .cm-selectionBackground":
+      {
+        backgroundColor: "rgba(86, 156, 214, 0.42)",
+      },
     ".cm-gutters": {
       backgroundColor: "#1e1e1e",
       color: "#858585",
@@ -48,6 +63,10 @@ const darkTheme = EditorView.theme(
     ".cm-activeLineGutter": { backgroundColor: "#2a2a2a" },
     ".cm-activeLine": { backgroundColor: "#2a2a2a" },
     ".cm-errorLine": { backgroundColor: "rgba(255, 0, 0, 0.15)" },
+    ".cm-selectedWordMatch": {
+      backgroundColor: "rgba(255, 209, 102, 0.22)",
+      borderRadius: "2px",
+    },
   },
   { dark: true },
 );
@@ -80,6 +99,10 @@ const lightTheme = EditorView.theme({
   ".cm-activeLineGutter": { backgroundColor: "#e8e8e8" },
   ".cm-activeLine": { backgroundColor: "#e8e8e8" },
   ".cm-errorLine": { backgroundColor: "rgba(255, 0, 0, 0.1)" },
+  ".cm-selectedWordMatch": {
+    backgroundColor: "rgba(255, 209, 102, 0.35)",
+    borderRadius: "2px",
+  },
 });
 
 const lightHighlight = HighlightStyle.define([
@@ -96,6 +119,79 @@ const lightHighlight = HighlightStyle.define([
 // ---- Error line decoration ----
 
 const errorLineDeco = Decoration.line({ class: "cm-errorLine" });
+const selectedWordMatchDeco = Decoration.mark({
+  class: "cm-selectedWordMatch",
+});
+
+const getSelectedWordMatchText = (state: EditorState) => {
+  const mainSelection = state.selection.main;
+  if (state.selection.ranges.length !== 1 || mainSelection.empty) {
+    return null;
+  }
+
+  const selectedWord = state.wordAt(mainSelection.from);
+  if (
+    !selectedWord ||
+    selectedWord.from !== mainSelection.from ||
+    selectedWord.to !== mainSelection.to
+  ) {
+    return null;
+  }
+
+  return state.sliceDoc(mainSelection.from, mainSelection.to);
+};
+
+const getSelectedWordMatchDecorations = (view: EditorView): DecorationSet => {
+  const selectedWord = getSelectedWordMatchText(view.state);
+  if (!selectedWord) {
+    return Decoration.none;
+  }
+
+  const selection = view.state.selection.main;
+  const ranges: Range<Decoration>[] = [];
+  const doc = view.state.doc.toString();
+  let searchFrom = 0;
+
+  while (searchFrom <= doc.length - selectedWord.length) {
+    const matchFrom = doc.indexOf(selectedWord, searchFrom);
+    if (matchFrom === -1) {
+      break;
+    }
+
+    const matchTo = matchFrom + selectedWord.length;
+    const matchWord = view.state.wordAt(matchFrom);
+    if (
+      matchWord?.from === matchFrom &&
+      matchWord.to === matchTo &&
+      (matchFrom !== selection.from || matchTo !== selection.to)
+    ) {
+      ranges.push(selectedWordMatchDeco.range(matchFrom, matchTo));
+    }
+
+    searchFrom = matchTo;
+  }
+
+  return ranges.length ? Decoration.set(ranges) : Decoration.none;
+};
+
+const selectedWordMatchExtension = ViewPlugin.fromClass(
+  class {
+    decorations: DecorationSet;
+
+    constructor(view: EditorView) {
+      this.decorations = getSelectedWordMatchDecorations(view);
+    }
+
+    update(update: ViewUpdate) {
+      if (update.docChanged || update.selectionSet) {
+        this.decorations = getSelectedWordMatchDecorations(update.view);
+      }
+    }
+  },
+  {
+    decorations: (value) => value.decorations,
+  },
+);
 
 const getErrorLineExtension = (
   errorLine: number | null | undefined,
@@ -172,6 +268,7 @@ const CodeMirrorEditor = ({
           errorLineCompartmentRef.current.of([]),
           mermaidLite(),
           drawSelection({ drawRangeCursor: true }),
+          selectedWordMatchExtension,
           ...(placeholder ? [cmPlaceholder(placeholder)] : []),
         ],
       }),

packages/excalidraw/components/TTDDialog/TextToDiagram.tsx

@@ -80,7 +80,10 @@ const TextToDiagramContent = ({
   } = useChatManagement({ persistenceAdapter });
 
   const onViewAsMermaid = () => {
-    if (typeof lastAssistantMessage?.content === "string") {
+    if (
+      lastAssistantMessage?.contentFormat === "mermaid" &&
+      typeof lastAssistantMessage.content === "string"
+    ) {
       saveMermaidDataToStorage(lastAssistantMessage.content);
       setAppState({
         openDialog: { name: "ttd", tab: "mermaid" },
@@ -206,6 +209,7 @@ const TextToDiagramContent = ({
         onGenerate={onGenerate}
         isGenerating={lastAssistantMessage?.isGenerating ?? false}
         generatedResponse={lastAssistantMessage?.content}
+        generatedResponseFormat={lastAssistantMessage?.contentFormat}
         isMenuOpen={isMenuOpen}
         onMenuToggle={handleMenuToggle}
         onMenuClose={handleMenuClose}

packages/excalidraw/components/TTDDialog/common.ts

@@ -1,4 +1,8 @@
-import { DEFAULT_EXPORT_PADDING, EDITOR_LS_KEYS } from "@excalidraw/common";
+import {
+  DEFAULT_EXPORT_PADDING,
+  EDITOR_LS_KEYS,
+  THEME,
+} from "@excalidraw/common";
 
 import { convertToExcalidrawElements } from "@excalidraw/element";
 
@@ -101,16 +105,14 @@ export const convertMermaidToExcalidraw = async ({
     };
 
     const canvas = await exportToCanvas({
-      data: {
-        elements: data.current.elements,
-        files: data.current.files,
-      },
-      config: {
-        padding: DEFAULT_EXPORT_PADDING,
-        maxWidthOrHeight:
-          Math.max(parent.offsetWidth, parent.offsetHeight) *
-          window.devicePixelRatio,
-        theme,
+      elements: data.current.elements,
+      files: data.current.files,
+      exportPadding: DEFAULT_EXPORT_PADDING,
+      maxWidthOrHeight:
+        Math.max(parent.offsetWidth, parent.offsetHeight) *
+        window.devicePixelRatio,
+      appState: {
+        exportWithDarkMode: theme === THEME.DARK,
       },
     });
 

packages/excalidraw/components/TTDDialog/hooks/useTextGeneration.ts

@@ -88,6 +88,7 @@ export const useTextGeneration = ({
         updateAssistantContent(prev, {
           isGenerating: true,
           content: "",
+          contentFormat: "mermaid",
           error: undefined,
           errorType: undefined,
           errorDetails: undefined,

packages/excalidraw/components/TTDDialog/mermaid-highlighting.test.ts

@@ -0,0 +1,40 @@
+import {
+  getMermaidHighlightToken,
+  tokenizeMermaid,
+} from "./mermaid-highlighting";
+
+describe("mermaid highlighting", () => {
+  it("tokenizes mermaid syntax with shared token types", () => {
+    const tokens = tokenizeMermaid('flowchart LR\nA["Hello"] --> B');
+
+    expect(tokens).toEqual([
+      { type: "keyword", value: "flowchart" },
+      { type: null, value: " " },
+      { type: "keyword", value: "LR" },
+      { type: null, value: "\n" },
+      { type: "variableName", value: "A" },
+      { type: "bracket", value: "[" },
+      { type: "string", value: '"Hello"' },
+      { type: "bracket", value: "]" },
+      { type: null, value: " " },
+      { type: "operator", value: "-->" },
+      { type: null, value: " " },
+      { type: "variableName", value: "B" },
+    ]);
+  });
+
+  it("limits comment tokens to a single line", () => {
+    const tokens = tokenizeMermaid("%% comment\nflowchart TD");
+
+    expect(tokens[0]).toEqual({ type: "comment", value: "%% comment" });
+    expect(tokens[1]).toEqual({ type: null, value: "\n" });
+    expect(tokens[2]).toEqual({ type: "keyword", value: "flowchart" });
+  });
+
+  it("falls back to plain text for unsupported characters", () => {
+    expect(getMermaidHighlightToken("@node")).toEqual({
+      type: null,
+      value: "@",
+    });
+  });
+});

packages/excalidraw/components/TTDDialog/mermaid-highlighting.ts

@@ -0,0 +1,79 @@
+export type MermaidHighlightTokenType =
+  | "bracket"
+  | "comment"
+  | "keyword"
+  | "number"
+  | "operator"
+  | "punctuation"
+  | "string"
+  | "variableName";
+
+export type MermaidHighlightToken = {
+  type: MermaidHighlightTokenType | null;
+  value: string;
+};
+
+const DIAGRAM_TYPE_PATTERN =
+  /^(flowchart|graph|sequenceDiagram|classDiagram|stateDiagram|erDiagram|gantt|pie|mindmap|journey|gitGraph|timeline|quadrantChart|sankey|xychart)\b/i;
+const DIRECTION_PATTERN = /^(TB|TD|BT|RL|LR)\b/;
+const KEYWORD_PATTERN =
+  /^(subgraph|end|participant|actor|loop|alt|else|opt|par|critical|break|rect|note|over|activate|deactivate|title|section|class|style|linkStyle|classDef|click)\b/i;
+
+const MERMAID_TOKEN_RULES: ReadonlyArray<{
+  pattern: RegExp;
+  type: MermaidHighlightTokenType | null;
+}> = [
+  { pattern: /^%%[^\n]*/, type: "comment" },
+  { pattern: /^"(?:[^"\\]|\\.)*"/, type: "string" },
+  { pattern: DIAGRAM_TYPE_PATTERN, type: "keyword" },
+  { pattern: DIRECTION_PATTERN, type: "keyword" },
+  { pattern: KEYWORD_PATTERN, type: "keyword" },
+  { pattern: /^[-.=<>|ox]+>/, type: "operator" },
+  { pattern: /^<[-.=<>|ox]+/, type: "operator" },
+  { pattern: /^(--+|\.\.+|==+)/, type: "operator" },
+  { pattern: /^[[\](){}|<>]/, type: "bracket" },
+  { pattern: /^[A-Za-z_][A-Za-z0-9_]*/, type: "variableName" },
+  { pattern: /^\d+(\.\d+)?/, type: "number" },
+  { pattern: /^[,:;]/, type: "punctuation" },
+  { pattern: /^\s+/, type: null },
+];
+
+export const getMermaidHighlightToken = (
+  input: string,
+): MermaidHighlightToken | null => {
+  if (!input) {
+    return null;
+  }
+
+  for (const rule of MERMAID_TOKEN_RULES) {
+    const match = input.match(rule.pattern);
+    if (match) {
+      return {
+        type: rule.type,
+        value: match[0],
+      };
+    }
+  }
+
+  return {
+    type: null,
+    value: input[0],
+  };
+};
+
+export const tokenizeMermaid = (input: string): MermaidHighlightToken[] => {
+  const tokens: MermaidHighlightToken[] = [];
+  let remaining = input;
+
+  while (remaining) {
+    const token = getMermaidHighlightToken(remaining);
+    if (!token) {
+      break;
+    }
+
+    tokens.push(token);
+    remaining = remaining.slice(token.value.length);
+  }
+
+  return tokens;
+};

packages/excalidraw/components/TTDDialog/mermaid-lang-lite.ts

@@ -1,79 +1,17 @@
 import { StreamLanguage } from "@codemirror/language";
 
+import { getMermaidHighlightToken } from "./mermaid-highlighting";
+
 const mermaidStreamParser = StreamLanguage.define({
   token(stream) {
-    // Comments: %%...
-    if (stream.match(/^%%.*$/)) {
-      return "comment";
-    }
-
-    // Strings
-    if (stream.match(/^"(?:[^"\\]|\\.)*"/)) {
-      return "string";
-    }
-
-    // Diagram type keywords (at start of line or after whitespace)
-    if (
-      stream.match(
-        /^(flowchart|graph|sequenceDiagram|classDiagram|stateDiagram|erDiagram|gantt|pie|mindmap|journey|gitGraph|timeline|quadrantChart|sankey|xychart)\b/i,
-      )
-    ) {
-      return "keyword";
-    }
-
-    // Direction keywords
-    if (stream.match(/^(TB|TD|BT|RL|LR)\b/)) {
-      return "keyword";
-    }
-
-    // Keywords
-    if (
-      stream.match(
-        /^(subgraph|end|participant|actor|loop|alt|else|opt|par|critical|break|rect|note|over|activate|deactivate|title|section|class|style|linkStyle|classDef|click)\b/i,
-      )
-    ) {
-      return "keyword";
-    }
-
-    // Arrows: -->, ---, -.->, ===>, etc.
-    if (stream.match(/^[-.=<>|ox]+>/)) {
-      return "operator";
-    }
-    if (stream.match(/^<[-.=<>|ox]+/)) {
-      return "operator";
-    }
-    if (stream.match(/^--+|\.\.+|==+/)) {
-      return "operator";
-    }
-
-    // Labels in brackets/parens: [text], (text), {text}, ((text)), etc.
-    if (stream.match(/^[[\](){}|<>]/)) {
-      return "bracket";
-    }
-
-    // Node IDs (alphanumeric)
-    if (stream.match(/^[A-Za-z_][A-Za-z0-9_]*/)) {
-      return "variableName";
-    }
-
-    // Numbers
-    if (stream.match(/^\d+(\.\d+)?/)) {
-      return "number";
-    }
-
-    // Punctuation
-    if (stream.match(/^[,:;]/)) {
-      return "punctuation";
-    }
-
-    // Skip whitespace
-    if (stream.eatSpace()) {
+    const token = getMermaidHighlightToken(stream.string.slice(stream.pos));
+    if (!token) {
+      stream.skipToEnd();
       return null;
     }
 
-    // Skip any other character
-    stream.next();
-    return null;
+    stream.pos += token.value.length;
+    return token.type;
   },
 });
 

packages/excalidraw/components/TTDDialog/types.ts

@@ -18,6 +18,8 @@ export type MermaidData = {
   files: BinaryFiles | null;
 };
 
+export type ChatMessageContentFormat = "text" | "mermaid";
+
 export interface RateLimits {
   rateLimit: number;
   rateLimitRemaining: number;
@@ -33,6 +35,7 @@ export namespace TChat {
     errorType?: "parse" | "network" | "other";
     lastAttemptAt?: number;
     type: "user" | "assistant" | "warning";
+    contentFormat?: ChatMessageContentFormat;
     warningType?: /* daily rate limit */
     "messageLimitExceeded" | /* general 429 */ "rateLimitExceeded";
     content?: string;

packages/excalidraw/components/TTDDialog/useTTDChatStorage.ts

@@ -7,6 +7,17 @@ import { chatHistoryAtom } from "./TTDContext";
 
 import type { SavedChat, SavedChats, TTDPersistenceAdapter } from "./types";
 
+const normalizePersistedChat = (chat: SavedChat): SavedChat => ({
+  ...chat,
+  messages: chat.messages.map((message) => ({
+    ...message,
+    // Legacy TTD chats predate explicit content format metadata.
+    contentFormat:
+      message.contentFormat ??
+      (message.type === "assistant" ? "mermaid" : undefined),
+  })),
+});
+
 interface UseTTDChatStorageProps {
   persistenceAdapter: TTDPersistenceAdapter;
 }
@@ -56,7 +67,7 @@ export const useTTDChatStorage = ({
     setIsLoading(true);
     try {
       const chats = await persistenceAdapter.loadChats();
-      setSavedChats(chats);
+      setSavedChats(chats.map(normalizePersistedChat));
       setChatsLoaded(true);
     } catch (error) {
       console.warn("Failed to load chats:", error);

packages/excalidraw/components/TTDDialog/utils/chat.test.ts

@@ -117,6 +117,28 @@ describe("chat utils", () => {
       expect(result.messages[0].errorType).toBe("network");
     });
 
+    it("should update content format when provided", () => {
+      const chatHistory: TChat.ChatHistory = {
+        id: "chat-1",
+        currentPrompt: "",
+        messages: [
+          {
+            id: "1",
+            type: "assistant",
+            content: "graph TD",
+            timestamp: new Date("2024-01-01"),
+            contentFormat: "text",
+          },
+        ],
+      };
+
+      const result = updateAssistantContent(chatHistory, {
+        contentFormat: "mermaid",
+      });
+
+      expect(result.messages[0].contentFormat).toBe("mermaid");
+    });
+
     it("should return unchanged chatHistory if no assistant message exists", () => {
       const chatHistory: TChat.ChatHistory = {
         id: "chat-1",
@@ -357,6 +379,7 @@ describe("chat utils", () => {
         {
           type: "assistant",
           content: "Message",
+          contentFormat: "mermaid",
           isGenerating: true,
           error: "Error text",
           errorType: "parse",
@@ -364,6 +387,7 @@ describe("chat utils", () => {
       ]);
 
       expect(result.messages[0].isGenerating).toBe(true);
+      expect(result.messages[0].contentFormat).toBe("mermaid");
       expect(result.messages[0].error).toBe("Error text");
       expect(result.messages[0].errorType).toBe("parse");
     });

packages/excalidraw/components/canvases/InteractiveCanvas.tsx

@@ -54,6 +54,7 @@ type InteractiveCanvasProps = {
     DOMAttributes<HTMLCanvasElement | HTMLDivElement>["onContextMenu"],
     undefined
   >;
+  onClick: Exclude<DOMAttributes<HTMLCanvasElement>["onClick"], undefined>;
   onPointerMove: Exclude<
     DOMAttributes<HTMLCanvasElement>["onPointerMove"],
     undefined
@@ -213,6 +214,7 @@ const InteractiveCanvas = (props: InteractiveCanvasProps) => {
       height={props.appState.height * props.scale}
       ref={props.handleCanvasRef}
       onContextMenu={props.onContextMenu}
+      onClick={props.onClick}
       onPointerMove={props.onPointerMove}
       onPointerUp={props.onPointerUp}
       onPointerCancel={props.onPointerCancel}

packages/excalidraw/data/index.ts

@@ -4,7 +4,6 @@ import {
   IMAGE_MIME_TYPES,
   isFirefox,
   MIME_TYPES,
-  THEME,
   cloneJSON,
   SVG_DOCUMENT_PREAMBLE,
 } from "@excalidraw/common";
@@ -116,29 +115,20 @@ export const exportCanvas = async (
   if (elements.length === 0) {
     throw new Error(t("alerts.cannotExportEmptyCanvas"));
   }
-
-  const theme = appState.exportWithDarkMode ? THEME.DARK : THEME.LIGHT;
-
   if (type === "svg" || type === "clipboard-svg") {
-    const svgPromise = exportToSvg({
-      data: {
-        elements,
-        appState: {
-          ...appState,
-          exportBackground,
-          exportEmbedScene: appState.exportEmbedScene && type === "svg",
-        },
-        files,
+    const svgPromise = exportToSvg(
+      elements,
+      {
+        exportBackground,
+        exportWithDarkMode: appState.exportWithDarkMode,
+        viewBackgroundColor,
+        exportPadding,
+        exportScale: appState.exportScale,
+        exportEmbedScene: appState.exportEmbedScene && type === "svg",
       },
-      config: {
-        padding: exportPadding,
-        exportingFrame,
-        theme,
-        canvasBackgroundColor: exportBackground
-          ? viewBackgroundColor
-          : "transparent",
-      },
-    });
+      files,
+      { exportingFrame },
+    );
 
     if (type === "svg") {
       return fileSave(
@@ -168,19 +158,11 @@ export const exportCanvas = async (
     }
   }
 
-  const tempCanvas = exportToCanvas({
-    data: {
-      elements,
-      appState,
-      files,
-    },
-    config: {
-      canvasBackgroundColor: exportBackground ? viewBackgroundColor : false,
-      padding: exportPadding,
-      theme,
-      scale: appState.exportScale,
-      exportingFrame,
-    },
+  const tempCanvas = exportToCanvas(elements, appState, files, {
+    exportBackground,
+    viewBackgroundColor,
+    exportPadding,
+    exportingFrame,
   });
 
   if (type === "png") {

packages/excalidraw/data/resave.ts

@@ -20,10 +20,6 @@ export const resaveAsImageWithScene = async (
 ) => {
   const fileHandleType = getFileHandleType(fileHandle);
 
-  if (Math.random() < 1) {
-    throw new Error("OLALALALA");
-  }
-
   if (!isImageFileHandleType(fileHandleType)) {
     throw new Error(
       "fileHandle should exist and should be of type svg or png when resaving",

packages/excalidraw/data/restore.ts

@@ -251,7 +251,9 @@ const repairBinding = <T extends ExcalidrawArrowElement>(
       };
     }
 
-    console.error(`could not repair binding for element`);
+    console.error(
+      `Could not repair binding for element "${boundElement?.id}" out of (${elementsMap?.size}) elements`,
+    );
   } catch (error) {
     console.error("Error repairing binding:", error);
   }

packages/excalidraw/hooks/useLibraryItemSvg.ts

@@ -1,9 +1,8 @@
+import { exportToSvg } from "@excalidraw/utils/export";
 import { useEffect, useState } from "react";
 
 import { COLOR_PALETTE } from "@excalidraw/common";
 
-import { exportToSvg } from "../scene/export";
-
 import { atom, useAtom } from "../editor-jotai";
 
 import type { LibraryItem } from "../types";
@@ -13,18 +12,17 @@ export type SvgCache = Map<LibraryItem["id"], SVGSVGElement>;
 export const libraryItemSvgsCache = atom<SvgCache>(new Map());
 
 const exportLibraryItemToSvg = async (elements: LibraryItem["elements"]) => {
+  // TODO should pass theme (appState.exportWithDark) - we're still using
+  // CSS filter here
   return await exportToSvg({
-    data: {
-      elements,
-      appState: {
-        exportBackground: false,
-        viewBackgroundColor: COLOR_PALETTE.white,
-      },
-      files: null,
-    },
-    config: {
-      skipInliningFonts: true,
+    elements,
+    appState: {
+      exportBackground: false,
+      viewBackgroundColor: COLOR_PALETTE.white,
     },
+    files: null,
+    renderEmbeddables: false,
+    skipInliningFonts: true,
   });
 };
 

packages/excalidraw/index-node.ts

@@ -1,3 +1,4 @@
+import { getDefaultAppState } from "./appState";
 import { exportToCanvas } from "./scene/export";
 
 const fs = require("fs");
@@ -58,23 +59,26 @@ const elements = [
 registerFont("./public/Virgil.woff2", { family: "Virgil" });
 registerFont("./public/Cascadia.woff2", { family: "Cascadia" });
 
-(async () => {
-  const canvas = await exportToCanvas({
-    data: {
-      elements: elements as any,
-      appState: {},
-      files: {},
-    },
-    config: {
-      canvasBackgroundColor: "#ffffff",
-      createCanvas,
-    },
-  });
+const canvas = exportToCanvas(
+  elements as any,
+  {
+    ...getDefaultAppState(),
+    offsetTop: 0,
+    offsetLeft: 0,
+    width: 0,
+    height: 0,
+  },
+  {}, // files
+  {
+    exportBackground: true,
+    viewBackgroundColor: "#ffffff",
+  },
+  createCanvas,
+);
 
-  const out = fs.createWriteStream("test.png");
-  const stream = (canvas as any).createPNGStream();
-  stream.pipe(out);
-  out.on("finish", () => {
-    console.info("test.png was created.");
-  });
-})();
+const out = fs.createWriteStream("test.png");
+const stream = (canvas as any).createPNGStream();
+stream.pipe(out);
+out.on("finish", () => {
+  console.info("test.png was created.");
+});

packages/excalidraw/index.tsx

@@ -304,9 +304,7 @@ export {
   exportToBlob,
   exportToSvg,
   exportToClipboard,
-} from "./scene/export";
-
-export type { ExportSceneData, ExportSceneConfig } from "./scene/export";
+} from "@excalidraw/utils/export";
 
 export { serializeAsJSON, serializeLibraryAsJSON } from "./data/json";
 export {
@@ -384,6 +382,8 @@ export { DiagramToCodePlugin } from "./components/DiagramToCodePlugin/DiagramToC
 export { getDataURL } from "./data/blob";
 export { isElementLink } from "@excalidraw/element";
 
+export { Fonts } from "./fonts/Fonts";
+
 export { setCustomTextMetricsProvider } from "@excalidraw/element";
 
 export { CommandPalette } from "./components/CommandPalette/CommandPalette";

packages/excalidraw/renderer/interactiveScene.ts

@@ -41,6 +41,7 @@ import {
   maxBindingDistance_simple,
   isTextElement,
   LinearElementEditor,
+  getActiveTextElement,
 } from "@excalidraw/element";
 
 import { renderSelectionElement } from "@excalidraw/element";
@@ -58,6 +59,8 @@ import {
   isFocusPointVisible,
 } from "@excalidraw/element";
 
+import type { EditorInterface } from "@excalidraw/common";
+
 import type {
   TransformHandles,
   TransformHandleType,
@@ -86,6 +89,10 @@ import {
 } from "../scene/scrollbars";
 
 import { getClientColor, renderRemoteCursors } from "../clients";
+import {
+  getTextAutoResizeHandle,
+  getTextBoxPadding,
+} from "../textAutoResizeHandle";
 
 import {
   bootstrapCanvas,
@@ -1149,6 +1156,7 @@ const renderLinearPointHandles = (
           points[idx],
           idx,
           appState.zoom,
+          elementsMap,
         )
       ) {
         renderSingleLinearPoint(
@@ -1489,21 +1497,58 @@ const renderTextBox = (
   selectionColor: InteractiveCanvasRenderConfig["selectionColor"],
 ) => {
   context.save();
-  const padding = (DEFAULT_TRANSFORM_HANDLE_SPACING * 2) / appState.zoom.value;
+  const padding = getTextBoxPadding(appState.zoom.value);
   const width = text.width + padding * 2;
   const height = text.height + padding * 2;
-  const cx = text.x + width / 2;
-  const cy = text.y + height / 2;
-  const shiftX = -(width / 2 + padding);
-  const shiftY = -(height / 2 + padding);
+  const cx = text.x + text.width / 2;
+  const cy = text.y + text.height / 2;
+  const shiftX = -(text.width / 2 + padding);
+  const shiftY = -(text.height / 2 + padding);
   context.translate(cx + appState.scrollX, cy + appState.scrollY);
   context.rotate(text.angle);
   context.lineWidth = 1 / appState.zoom.value;
   context.strokeStyle = selectionColor;
+  context.globalAlpha = 0.5;
+  context.setLineDash([6 / appState.zoom.value, 4 / appState.zoom.value]);
   context.strokeRect(shiftX, shiftY, width, height);
   context.restore();
 };
 
+const renderResetAutoResizeHandle = (
+  text: NonDeleted<ExcalidrawTextElement>,
+  context: CanvasRenderingContext2D,
+  appState: InteractiveCanvasAppState,
+  selectionColor: InteractiveCanvasRenderConfig["selectionColor"],
+  formFactor: EditorInterface["formFactor"],
+) => {
+  const autoResizeHandle = getTextAutoResizeHandle(
+    text,
+    appState.zoom.value,
+    formFactor,
+  );
+
+  if (!autoResizeHandle) {
+    return;
+  }
+
+  context.save();
+  context.globalAlpha = 0.5;
+  context.lineWidth = 1.5 / appState.zoom.value;
+  context.lineCap = "round";
+  context.strokeStyle = selectionColor;
+  context.beginPath();
+  context.moveTo(
+    autoResizeHandle.start[0] + appState.scrollX,
+    autoResizeHandle.start[1] + appState.scrollY,
+  );
+  context.lineTo(
+    autoResizeHandle.end[0] + appState.scrollX,
+    autoResizeHandle.end[1] + appState.scrollY,
+  );
+  context.stroke();
+  context.restore();
+};
+
 const _renderInteractiveScene = ({
   app,
   canvas,
@@ -1584,10 +1629,19 @@ const _renderInteractiveScene = ({
     }
   }
 
-  if (
-    appState.editingTextElement &&
-    isTextElement(appState.editingTextElement)
-  ) {
+  const activeTextElement = getActiveTextElement(selectedElements, appState);
+
+  if (activeTextElement && !activeTextElement.autoResize) {
+    renderResetAutoResizeHandle(
+      activeTextElement,
+      context,
+      appState,
+      renderConfig.selectionColor,
+      editorInterface.formFactor,
+    );
+  }
+
+  if (appState.editingTextElement) {
     const textElement = allElementsMap.get(appState.editingTextElement.id) as
       | ExcalidrawTextElement
       | undefined;

packages/excalidraw/scene/export.ts

@@ -1,13 +1,13 @@
 import rough from "roughjs/bin/rough";
 
 import {
+  DEFAULT_EXPORT_PADDING,
   FRAME_STYLE,
   FONT_FAMILY,
   SVG_NS,
   THEME,
   MIME_TYPES,
   EXPORT_DATA_TYPES,
-  COLOR_WHITE,
   arrayToMap,
   distance,
   getFontString,
@@ -47,33 +47,20 @@ import type {
   ExcalidrawTextElement,
   NonDeletedExcalidrawElement,
   NonDeletedSceneElementsMap,
-  Theme,
 } from "@excalidraw/element/types";
 
 import { getDefaultAppState } from "../appState";
 import { base64ToString, decode, encode, stringToBase64 } from "../data/encode";
 import { serializeAsJSON } from "../data/json";
-import { restoreAppState } from "../data/restore";
-import { encodePngMetadata } from "../data/image";
 
 import { Fonts } from "../fonts";
 
 import { renderStaticScene } from "../renderer/staticScene";
 import { renderSceneToSvg } from "../renderer/staticSvgScene";
 
-import {
-  copyBlobToClipboardAsPng,
-  copyTextToSystemClipboard,
-  copyToClipboard,
-} from "../clipboard";
-
 import type { RenderableElementsMap } from "./types";
 
-import type { AppState, BinaryFiles, NormalizedZoomValue } from "../types";
-
-// Default minimum export size in pixels
-const DEFAULT_SMALLEST_EXPORT_SIZE = 20;
-const DEFAULT_ZOOM_VALUE = 1 as NormalizedZoomValue;
+import type { AppState, BinaryFiles } from "../types";
 
 const truncateText = (element: ExcalidrawTextElement, maxWidth: number) => {
   if (element.width <= maxWidth) {
@@ -182,205 +169,36 @@ const prepareElementsForRender = ({
   return nextElements;
 };
 
-// ---------------------------------------------------------------------------
-// Types for the new API
-// ---------------------------------------------------------------------------
-
-export type ExportSceneData = {
-  elements: readonly NonDeletedExcalidrawElement[];
-  appState?: Partial<
-    Omit<AppState, "offsetTop" | "offsetLeft" | "exportWithDarkMode">
-  >;
-  files: BinaryFiles | null;
-};
-
-export type ExportSceneConfig = {
-  theme?: Theme;
-  /**
-   * Canvas background. Valid values are:
-   *
-   * - `undefined` - the background of "appState.viewBackgroundColor" is used.
-   * - `false` - no background is used (set to "transparent").
-   * - `string` - should be a valid CSS color.
-   *
-   * @default undefined
-   */
-  canvasBackgroundColor?: string | false;
-  /**
-   * Canvas padding in pixels. Affected by `scale`.
-   *
-   * When `fit` is set to `none`, padding is added to the content bounding box
-   * (including if you set `width` or `height` or `maxWidthOrHeight` or
-   * `widthOrHeight`).
-   *
-   * When `fit` set to `contain`, padding is subtracted from the content
-   * bounding box (ensuring the size doesn't exceed the supplied values, with
-   * the exeception of using alongside `scale` as noted above), and the padding
-   * serves as a minimum distance between the content and the canvas edges, as
-   * it may exceed the supplied padding value from one side or the other in
-   * order to maintain the aspect ratio. It is recommended to set `position`
-   * to `center` when using `fit=contain`.
-   *
-   * When `fit` is set to `none` and either `width` or `height` or
-   * `maxWidthOrHeight` is set, padding is simply adding to the bounding box
-   * and the content may overflow the canvas, thus right or bottom padding
-   * may be ignored.
-   *
-   * @default 0
-   */
-  padding?: number;
-  // -------------------------------------------------------------------------
-  /**
-   * Makes sure the canvas content fits into a frame of width/height no larger
-   * than this value, while maintaining the aspect ratio.
-   *
-   * Final dimensions can get smaller/larger if used in conjunction with
-   * `scale`.
-   */
-  maxWidthOrHeight?: number;
-  /**
-   * Scale the canvas content to be excatly this many pixels wide/tall,
-   * maintaining the aspect ratio.
-   *
-   * Cannot be used in conjunction with `maxWidthOrHeight`.
-   *
-   * Final dimensions can get smaller/larger if used in conjunction with
-   * `scale`.
-   */
-  widthOrHeight?: number;
-  // -------------------------------------------------------------------------
-  /**
-   * Width of the frame. Supply `x` or `y` if you want to ofsset the canvas
-   * content.
-   *
-   * If `width` omitted but `height` supplied, `width` is calculated from the
-   * the content's bounding box to preserve the aspect ratio.
-   *
-   * Defaults to the content bounding box width when both `width` and `height`
-   * are omitted.
-   */
-  width?: number;
-  /**
-   * Height of the frame.
-   *
-   * If `height` omitted but `width` supplied, `height` is calculated from the
-   * content's bounding box to preserve the aspect ratio.
-   *
-   * Defaults to the content bounding box height when both `width` and `height`
-   * are omitted.
-   */
-  height?: number;
-  /**
-   * Left canvas offset. By default the coordinate is relative to the canvas.
-   * You can switch to content coordinates by setting `origin` to `content`.
-   *
-   * Defaults to the `x` postion of the content bounding box.
-   */
-  x?: number;
-  /**
-   * Top canvas offset. By default the coordinate is relative to the canvas.
-   * You can switch to content coordinates by setting `origin` to `content`.
-   *
-   * Defaults to the `y` postion of the content bounding box.
-   */
-  y?: number;
-  /**
-   * Indicates the coordinate system of the `x` and `y` values.
-   *
-   * - `canvas` - `x` and `y` are relative to the canvas [0, 0] position.
-   * - `content` - `x` and `y` are relative to the content bounding box.
-   *
-   * @default "canvas"
-   */
-  origin?: "canvas" | "content";
-  /**
-   * If dimensions specified and `x` and `y` are not specified, this indicates
-   * how the canvas should be scaled.
-   *
-   * Behavior aligns with the `object-fit` CSS property.
-   *
-   * - `none`    - no scaling.
-   * - `contain` - scale to fit the frame. Includes `padding`.
-   *
-   * If `maxWidthOrHeight` or `widthOrHeight` is set, `fit` is ignored.
-   *
-   * @default "contain" unless `width`, `height`, `maxWidthOrHeight`, or
-   * `widthOrHeight` is specified in which case `none` is the default (can be
-   * changed). If `x` or `y` are specified, `none` is forced.
-   */
-  fit?: "none" | "contain";
-  /**
-   * When either `x` or `y` are not specified, indicates how the canvas should
-   * be aligned on the respective axis.
-   *
-   * - `none`   - canvas aligned to top left.
-   * - `center` - canvas is centered on the axis which is not specified
-   *              (or both).
-   *
-   * If `maxWidthOrHeight` or `widthOrHeight` is set, `position` is ignored.
-   *
-   * @default "center"
-   */
-  position?: "center" | "topLeft";
-  // -------------------------------------------------------------------------
-  /**
-   * A multiplier to increase/decrease the frame dimensions
-   * (content resolution).
-   *
-   * For example, if your canvas is 300x150 and you set scale to 2, the
-   * resulting size will be 600x300.
-   *
-   * @default 1
-   */
-  scale?: number;
-  /**
-   * If you need to suply your own canvas, e.g. in test environments or in
-   * Node.js.
-   *
-   * Do not set `canvas.width/height` or modify the canvas context as that's
-   * handled by Excalidraw.
-   *
-   * Defaults to `document.createElement("canvas")`.
-   */
-  createCanvas?: () => HTMLCanvasElement;
-  /**
-   * If you want to supply `width`/`height` dynamically (or derive from the
-   * content bounding box), you can use this function.
-   *
-   * Ignored if `maxWidthOrHeight`, `width`, or `height` is set.
-   */
-  getDimensions?: (
+export const exportToCanvas = async (
+  elements: readonly NonDeletedExcalidrawElement[],
+  appState: AppState,
+  files: BinaryFiles,
+  {
+    exportBackground,
+    exportPadding = DEFAULT_EXPORT_PADDING,
+    viewBackgroundColor,
+    exportingFrame,
+  }: {
+    exportBackground: boolean;
+    exportPadding?: number;
+    viewBackgroundColor: string;
+    exportingFrame?: ExcalidrawFrameLikeElement | null;
+  },
+  createCanvas: (
     width: number,
     height: number,
-  ) => { width: number; height: number; scale?: number };
-
-  exportingFrame?: ExcalidrawFrameLikeElement | null;
-
-  loadFonts?: () => Promise<void>;
-};
-
-// ---------------------------------------------------------------------------
-// Internal helper to configure export dimensions
-// ---------------------------------------------------------------------------
-
-const configExportDimension = async ({
-  data,
-  config,
-}: {
-  data: ExportSceneData;
-  config?: ExportSceneConfig;
-}) => {
-  // clone
-  const cfg = Object.assign({}, config);
-
-  const { exportingFrame } = cfg;
-
-  const elements = data.elements;
-
-  // initialize defaults
-  // ---------------------------------------------------------------------------
-
-  const appState = restoreAppState(data.appState, null);
+  ) => { canvas: HTMLCanvasElement; scale: number } = (width, height) => {
+    const canvas = document.createElement("canvas");
+    canvas.width = width * appState.exportScale;
+    canvas.height = height * appState.exportScale;
+    return { canvas, scale: appState.exportScale };
+  },
+  loadFonts: () => Promise<void> = async () => {
+    await Fonts.loadElementsFonts(elements);
+  },
+) => {
+  // load font faces before continuing, by default leverages browsers' [FontFace API](https://developer.mozilla.org/en-US/docs/Web/API/FontFace)
+  await loadFonts();
 
   const frameRendering = getFrameRenderingConfig(
     exportingFrame ?? null,
@@ -400,255 +218,26 @@ const configExportDimension = async ({
   });
 
   if (exportingFrame) {
-    cfg.padding = 0;
+    exportPadding = 0;
   }
 
-  cfg.fit =
-    cfg.fit ??
-    (cfg.width != null ||
-    cfg.height != null ||
-    cfg.maxWidthOrHeight != null ||
-    cfg.widthOrHeight != null
-      ? "contain"
-      : "none");
-
-  cfg.padding = cfg.padding ?? 0;
-  cfg.scale = cfg.scale ?? 1;
-
-  cfg.origin = cfg.origin ?? "canvas";
-  cfg.position = cfg.position ?? "center";
-
-  if (cfg.maxWidthOrHeight != null && cfg.widthOrHeight != null) {
-    if (!import.meta.env.PROD) {
-      console.warn("`maxWidthOrHeight` is ignored when `widthOrHeight` is set");
-    }
-    cfg.maxWidthOrHeight = undefined;
-  }
-
-  if (
-    (cfg.maxWidthOrHeight != null || cfg.width != null || cfg.height != null) &&
-    cfg.getDimensions
-  ) {
-    if (!import.meta.env.PROD) {
-      console.warn(
-        "`getDimensions` is ignored when `width`, `height`, or `maxWidthOrHeight` is set",
-      );
-    }
-    cfg.getDimensions = undefined;
-  }
-  // ---------------------------------------------------------------------------
-
-  // load font faces before continuing, by default leverages browsers' [FontFace API](https://developer.mozilla.org/en-US/docs/Web/API/FontFace)
-  if (cfg.loadFonts) {
-    await cfg.loadFonts();
-  } else {
-    await Fonts.loadElementsFonts(elements);
-  }
-
-  // value used to scale the canvas context. By default, we use this to
-  // make the canvas fit into the frame (e.g. for `cfg.fit` set to `contain`).
-  // If `cfg.scale` is set, we multiply the resulting canvasScale by it to
-  // scale the output further.
-  let exportScale = 1;
-
-  const origCanvasSize = getCanvasSize(
+  const [minX, minY, width, height] = getCanvasSize(
     exportingFrame ? [exportingFrame] : getRootElements(elementsForRender),
+    exportPadding,
   );
 
-  // variables for original content bounding box
-  const [origX, origY, origWidth, origHeight] = origCanvasSize;
-  // variables for target bounding box
-  let [x, y, width, height] = origCanvasSize;
+  const { canvas, scale = 1 } = createCanvas(width, height);
 
-  x = cfg.x ?? x;
-  y = cfg.y ?? y;
-  width = cfg.width ?? width;
-  height = cfg.height ?? height;
-
-  if (cfg.fit === "contain" || cfg.widthOrHeight || cfg.maxWidthOrHeight) {
-    cfg.padding =
-      cfg.padding && cfg.padding > 0
-        ? Math.min(
-            cfg.padding,
-            (width - DEFAULT_SMALLEST_EXPORT_SIZE) / 2,
-            (height - DEFAULT_SMALLEST_EXPORT_SIZE) / 2,
-          )
-        : 0;
-
-    if (cfg.getDimensions != null) {
-      const ret = cfg.getDimensions(width, height);
-
-      width = ret.width;
-      height = ret.height;
-
-      cfg.padding = Math.min(
-        cfg.padding,
-        (width - DEFAULT_SMALLEST_EXPORT_SIZE) / 2,
-        (height - DEFAULT_SMALLEST_EXPORT_SIZE) / 2,
-      );
-    } else if (cfg.widthOrHeight != null) {
-      cfg.padding = Math.min(
-        cfg.padding,
-        (cfg.widthOrHeight - DEFAULT_SMALLEST_EXPORT_SIZE) / 2,
-      );
-    } else if (cfg.maxWidthOrHeight != null) {
-      cfg.padding = Math.min(
-        cfg.padding,
-        (cfg.maxWidthOrHeight - DEFAULT_SMALLEST_EXPORT_SIZE) / 2,
-      );
-    }
-  }
-
-  if (cfg.maxWidthOrHeight != null || cfg.widthOrHeight != null) {
-    if (cfg.padding) {
-      if (cfg.maxWidthOrHeight != null) {
-        cfg.maxWidthOrHeight -= cfg.padding * 2;
-      } else if (cfg.widthOrHeight != null) {
-        cfg.widthOrHeight -= cfg.padding * 2;
-      }
-    }
-
-    const max = Math.max(width, height);
-    if (cfg.widthOrHeight != null) {
-      // calculate by how much do we need to scale the canvas to fit into the
-      // target dimension (e.g. target: max 50px, actual: 70x100px => scale: 0.5)
-      exportScale = cfg.widthOrHeight / max;
-    } else if (cfg.maxWidthOrHeight != null) {
-      exportScale = cfg.maxWidthOrHeight < max ? cfg.maxWidthOrHeight / max : 1;
-    }
-
-    width *= exportScale;
-    height *= exportScale;
-  } else if (cfg.getDimensions) {
-    const ret = cfg.getDimensions(width, height);
-
-    width = ret.width;
-    height = ret.height;
-    cfg.scale = ret.scale ?? cfg.scale;
-  } else if (cfg.fit === "contain") {
-    width -= cfg.padding * 2;
-    height -= cfg.padding * 2;
-
-    const wRatio = width / origWidth;
-    const hRatio = height / origHeight;
-    // scale the orig canvas to fit in the target region
-    exportScale = Math.min(wRatio, hRatio);
-  }
-
-  x = cfg.x ?? origX;
-  y = cfg.y ?? origY;
-
-  // if we switch to "content" coords, we need to offset cfg-supplied
-  // coords by the x/y of content bounding box
-  if (cfg.origin === "content") {
-    if (cfg.x != null) {
-      x += origX;
-    }
-    if (cfg.y != null) {
-      y += origY;
-    }
-  }
-
-  // Centering the content to the frame.
-  // We divide width/height by canvasScale so that we calculate in the original
-  // aspect ratio dimensions.
-  if (cfg.position === "center") {
-    x -=
-      width / exportScale / 2 -
-      (cfg.x == null ? origWidth : width + cfg.padding * 2) / 2;
-    y -=
-      height / exportScale / 2 -
-      (cfg.y == null ? origHeight : height + cfg.padding * 2) / 2;
-  }
-
-  // rescale padding based on current canvasScale factor so that the resulting
-  // padding is kept the same as supplied by user (with the exception of
-  // `cfg.scale` being set, which also scales the padding)
-  const normalizedPadding = cfg.padding / exportScale;
-
-  // scale the whole frame by cfg.scale (on top of whatever canvasScale we
-  // calculated above)
-  exportScale *= cfg.scale;
-
-  width *= cfg.scale;
-  height *= cfg.scale;
-
-  const exportWidth = width + cfg.padding * 2 * cfg.scale;
-  const exportHeight = height + cfg.padding * 2 * cfg.scale;
-
-  return {
-    config: cfg,
-    normalizedPadding,
-    contentWidth: width,
-    contentHeight: height,
-    exportWidth,
-    exportHeight,
-    exportScale,
-    x,
-    y,
-    elementsForRender,
-    appState,
-    frameRendering,
-  };
-};
-
-// ---------------------------------------------------------------------------
-// exportToCanvas
-// ---------------------------------------------------------------------------
-
-/**
- * This API is usually used as a precursor to searializing to Blob or PNG,
- * but can also be used to create a canvas for other purposes.
- */
-export const exportToCanvas = async ({
-  data,
-  config,
-}: {
-  data: ExportSceneData;
-  config?: ExportSceneConfig;
-}) => {
-  const {
-    config: cfg,
-    normalizedPadding,
-    contentWidth: width,
-    contentHeight: height,
-    exportWidth,
-    exportHeight,
-    exportScale,
-    x,
-    y,
-    elementsForRender,
-    appState,
-    frameRendering,
-  } = await configExportDimension({ data, config });
-
-  const canvas = cfg.createCanvas
-    ? cfg.createCanvas()
-    : document.createElement("canvas");
-
-  canvas.width = exportWidth;
-  canvas.height = exportHeight;
+  const defaultAppState = getDefaultAppState();
 
   const { imageCache } = await updateImageCache({
     imageCache: new Map(),
     fileIds: getInitializedImageElements(elementsForRender).map(
       (element) => element.fileId,
     ),
-    files: data.files || {},
+    files,
   });
 
-  const theme =
-    cfg.theme ?? (appState.exportWithDarkMode ? THEME.DARK : THEME.LIGHT);
-
-  // Determine the background color for the canvas
-  const viewBackgroundColor =
-    cfg.canvasBackgroundColor === false
-      ? // "transparent" triggers clearRect in bootstrapCanvas
-        "transparent"
-      : cfg.canvasBackgroundColor ||
-        appState.viewBackgroundColor ||
-        COLOR_WHITE;
-
   renderStaticScene({
     canvas,
     rc: rough.canvas(canvas),
@@ -656,23 +245,19 @@ export const exportToCanvas = async ({
       arrayToMap(elementsForRender),
     ),
     allElementsMap: toBrandedType<NonDeletedSceneElementsMap>(
-      arrayToMap(syncInvalidIndices(data.elements)),
+      arrayToMap(syncInvalidIndices(elements)),
     ),
     visibleElements: elementsForRender,
-    scale: exportScale,
+    scale,
     appState: {
       ...appState,
       frameRendering,
-      width,
-      height,
-      offsetLeft: 0,
-      offsetTop: 0,
-      scrollX: -x + normalizedPadding,
-      scrollY: -y + normalizedPadding,
-      zoom: { value: DEFAULT_ZOOM_VALUE },
+      viewBackgroundColor: exportBackground ? viewBackgroundColor : null,
+      scrollX: -minX + exportPadding,
+      scrollY: -minY + exportPadding,
+      zoom: defaultAppState.zoom,
       shouldCacheIgnoreZoom: false,
-      theme,
-      viewBackgroundColor,
+      theme: appState.exportWithDarkMode ? THEME.DARK : THEME.LIGHT,
     },
     renderConfig: {
       canvasBackgroundColor: viewBackgroundColor,
@@ -683,44 +268,13 @@ export const exportToCanvas = async ({
       embedsValidationStatus: new Map(),
       elementsPendingErasure: new Set(),
       pendingFlowchartNodes: null,
-      theme,
+      theme: appState.exportWithDarkMode ? THEME.DARK : THEME.LIGHT,
     },
   });
 
   return canvas;
 };
 
-// ---------------------------------------------------------------------------
-// exportToSvg
-// ---------------------------------------------------------------------------
-
-type ExportToSvgConfig = Pick<
-  ExportSceneConfig,
-  | "canvasBackgroundColor"
-  | "padding"
-  | "theme"
-  | "exportingFrame"
-  | "scale"
-  | "width"
-  | "height"
-  | "x"
-  | "y"
-  | "origin"
-  | "fit"
-  | "position"
-  | "maxWidthOrHeight"
-  | "widthOrHeight"
-  | "getDimensions"
-  | "loadFonts"
-> & {
-  /**
-   * if true, all embeddables passed in will be rendered when possible.
-   */
-  renderEmbeddables?: boolean;
-  skipInliningFonts?: true;
-  reuseImages?: boolean;
-};
-
 const createHTMLComment = (text: string) => {
   // surrounding with spaces to maintain prettified consistency with previous
   // iterations
@@ -728,34 +282,61 @@ const createHTMLComment = (text: string) => {
   return document.createComment(` ${text} `);
 };
 
-export const exportToSvg = async ({
-  data,
-  config,
-}: {
-  data: ExportSceneData;
-  config?: ExportToSvgConfig;
-}) => {
-  const {
-    config: cfg,
-    normalizedPadding,
-    exportWidth,
-    exportHeight,
-    exportScale,
-    x,
-    y,
-    elementsForRender,
-    appState,
+export const exportToSvg = async (
+  elements: readonly NonDeletedExcalidrawElement[],
+  appState: {
+    exportBackground: boolean;
+    exportPadding?: number;
+    exportScale?: number;
+    viewBackgroundColor: string;
+    exportWithDarkMode?: boolean;
+    exportEmbedScene?: boolean;
+    frameRendering?: AppState["frameRendering"];
+  },
+  files: BinaryFiles | null,
+  opts?: {
+    /**
+     * if true, all embeddables passed in will be rendered when possible.
+     */
+    renderEmbeddables?: boolean;
+    exportingFrame?: ExcalidrawFrameLikeElement | null;
+    skipInliningFonts?: true;
+    reuseImages?: boolean;
+  },
+): Promise<SVGSVGElement> => {
+  const frameRendering = getFrameRenderingConfig(
+    opts?.exportingFrame ?? null,
+    appState.frameRendering ?? null,
+  );
+
+  let {
+    exportPadding = DEFAULT_EXPORT_PADDING,
+    exportWithDarkMode = false,
+    viewBackgroundColor,
+    exportScale = 1,
+    exportEmbedScene,
+  } = appState;
+
+  const { exportingFrame = null } = opts || {};
+
+  const elementsForRender = prepareElementsForRender({
+    elements,
+    exportingFrame,
+    exportWithDarkMode,
     frameRendering,
-  } = await configExportDimension({ data, config });
+  });
 
-  const offsetX = -(x - normalizedPadding);
-  const offsetY = -(y - normalizedPadding);
+  if (exportingFrame) {
+    exportPadding = 0;
+  }
 
-  const { elements } = data;
+  const [minX, minY, width, height] = getCanvasSize(
+    exportingFrame ? [exportingFrame] : getRootElements(elementsForRender),
+    exportPadding,
+  );
 
-  const theme =
-    cfg.theme ?? (appState.exportWithDarkMode ? THEME.DARK : THEME.LIGHT);
-  const exportWithDarkMode = theme === THEME.DARK;
+  const offsetX = -minX + exportPadding;
+  const offsetY = -minY + exportPadding;
 
   // ---------------------------------------------------------------------------
   // initialize SVG root element
@@ -765,12 +346,9 @@ export const exportToSvg = async ({
 
   svgRoot.setAttribute("version", "1.1");
   svgRoot.setAttribute("xmlns", SVG_NS);
-  svgRoot.setAttribute(
-    "viewBox",
-    `0 0 ${exportWidth / exportScale} ${exportHeight / exportScale}`,
-  );
-  svgRoot.setAttribute("width", `${exportWidth}`);
-  svgRoot.setAttribute("height", `${exportHeight}`);
+  svgRoot.setAttribute("viewBox", `0 0 ${width} ${height}`);
+  svgRoot.setAttribute("width", `${width * exportScale}`);
+  svgRoot.setAttribute("height", `${height * exportScale}`);
 
   const defsElement = svgRoot.ownerDocument.createElementNS(SVG_NS, "defs");
 
@@ -789,7 +367,7 @@ export const exportToSvg = async ({
 
   // we need to serialize the "original" elements before we put them through
   // the tempScene hack which duplicates and regenerates ids
-  if (appState.exportEmbedScene) {
+  if (exportEmbedScene) {
     try {
       encodeSvgBase64Payload({
         metadataElement,
@@ -797,7 +375,7 @@ export const exportToSvg = async ({
         // elements which don't contain the temp frame labels.
         // But it also requires that the exportToSvg is being supplied with
         // only the elements that we're exporting, and no extra.
-        payload: serializeAsJSON(elements, appState, data.files || {}, "local"),
+        payload: serializeAsJSON(elements, appState, files || {}, "local"),
       });
     } catch (error: any) {
       console.error(error);
@@ -835,7 +413,7 @@ export const exportToSvg = async ({
       rect.setAttribute("width", `${frame.width}`);
       rect.setAttribute("height", `${frame.height}`);
 
-      if (!cfg.exportingFrame) {
+      if (!exportingFrame) {
         rect.setAttribute("rx", `${FRAME_STYLE.radius}`);
         rect.setAttribute("ry", `${FRAME_STYLE.radius}`);
       }
@@ -850,10 +428,9 @@ export const exportToSvg = async ({
   // inline font faces
   // ---------------------------------------------------------------------------
 
-  const fontFaces =
-    config?.skipInliningFonts !== true
-      ? await Fonts.generateFontFaceDeclarations(elements)
-      : [];
+  const fontFaces = !opts?.skipInliningFonts
+    ? await Fonts.generateFontFaceDeclarations(elements)
+    : [];
 
   const delimiter = "\n      "; // 6 spaces
 
@@ -870,16 +447,17 @@ export const exportToSvg = async ({
   // ---------------------------------------------------------------------------
 
   // render background rect
-  if (appState.exportBackground && appState.viewBackgroundColor) {
-    const bgColor = cfg.canvasBackgroundColor || appState.viewBackgroundColor;
+  if (appState.exportBackground && viewBackgroundColor) {
     const rect = svgRoot.ownerDocument.createElementNS(SVG_NS, "rect");
     rect.setAttribute("x", "0");
     rect.setAttribute("y", "0");
-    rect.setAttribute("width", `${exportWidth / exportScale}`);
-    rect.setAttribute("height", `${exportHeight / exportScale}`);
+    rect.setAttribute("width", `${width}`);
+    rect.setAttribute("height", `${height}`);
     rect.setAttribute(
       "fill",
-      exportWithDarkMode ? applyDarkModeFilter(bgColor) : bgColor,
+      exportWithDarkMode
+        ? applyDarkModeFilter(viewBackgroundColor)
+        : viewBackgroundColor,
     );
     svgRoot.appendChild(rect);
   }
@@ -890,14 +468,14 @@ export const exportToSvg = async ({
 
   const rsvg = rough.svg(svgRoot);
 
-  const renderEmbeddables = config?.renderEmbeddables ?? false;
+  const renderEmbeddables = opts?.renderEmbeddables ?? false;
 
   renderSceneToSvg(
     elementsForRender,
     toBrandedType<RenderableElementsMap>(arrayToMap(elementsForRender)),
     rsvg,
     svgRoot,
-    data.files || {},
+    files || {},
     {
       offsetX,
       offsetY,
@@ -905,7 +483,7 @@ export const exportToSvg = async ({
       exportWithDarkMode,
       renderEmbeddables,
       frameRendering,
-      canvasBackgroundColor: appState.viewBackgroundColor,
+      canvasBackgroundColor: viewBackgroundColor,
       embedsValidationStatus: renderEmbeddables
         ? new Map(
             elementsForRender
@@ -913,8 +491,8 @@ export const exportToSvg = async ({
               .map((element) => [element.id, true]),
           )
         : new Map(),
-      reuseImages: config?.reuseImages ?? true,
-      theme,
+      reuseImages: opts?.reuseImages ?? true,
+      theme: exportWithDarkMode ? THEME.DARK : THEME.LIGHT,
     },
   );
 
@@ -923,10 +501,6 @@ export const exportToSvg = async ({
   return svgRoot;
 };
 
-// ---------------------------------------------------------------------------
-// SVG payload encoding/decoding
-// ---------------------------------------------------------------------------
-
 export const encodeSvgBase64Payload = ({
   payload,
   metadataElement,
@@ -982,149 +556,26 @@ export const decodeSvgBase64Payload = ({ svg }: { svg: string }) => {
   throw new Error("INVALID");
 };
 
-// ---------------------------------------------------------------------------
-// getCanvasSize
-// ---------------------------------------------------------------------------
-
 // calculate smallest area to fit the contents in
-export const getCanvasSize = (
+const getCanvasSize = (
   elements: readonly NonDeletedExcalidrawElement[],
+  exportPadding: number,
 ): Bounds => {
   const [minX, minY, maxX, maxY] = getCommonBounds(elements);
-  const width = distance(minX, maxX);
-  const height = distance(minY, maxY);
+  const width = distance(minX, maxX) + exportPadding * 2;
+  const height = distance(minY, maxY) + exportPadding * 2;
 
   return [minX, minY, width, height];
 };
 
-/**
- * Gets the export dimensions for a set of elements.
- *
- * @param elements - Elements to calculate size for
- * @param exportPadding - Padding to add around the elements
- * @param scale - Scale factor
- * @returns [width, height] tuple
- */
 export const getExportSize = (
   elements: readonly NonDeletedExcalidrawElement[],
   exportPadding: number,
   scale: number,
 ): [number, number] => {
-  const [, , width, height] = getCanvasSize(elements);
+  const [, , width, height] = getCanvasSize(elements, exportPadding).map(
+    (dimension) => Math.trunc(dimension * scale),
+  );
 
-  return [
-    Math.trunc((width + exportPadding * 2) * scale),
-    Math.trunc((height + exportPadding * 2) * scale),
-  ];
-};
-
-// ---------------------------------------------------------------------------
-// exportToBlob
-// ---------------------------------------------------------------------------
-
-export { MIME_TYPES };
-
-type ExportToBlobConfig = ExportSceneConfig & {
-  mimeType?: string;
-  quality?: number;
-};
-
-export const exportToBlob = async ({
-  data,
-  config,
-}: {
-  data: ExportSceneData;
-  config?: ExportToBlobConfig;
-}): Promise<Blob> => {
-  let { mimeType = MIME_TYPES.png, quality } = config || {};
-
-  if (mimeType === MIME_TYPES.png && typeof quality === "number") {
-    console.warn(`"quality" will be ignored for "${MIME_TYPES.png}" mimeType`);
-  }
-
-  // typo in MIME type (should be "jpeg")
-  if (mimeType === "image/jpg") {
-    mimeType = MIME_TYPES.jpg;
-  }
-
-  if (mimeType === MIME_TYPES.jpg && config?.canvasBackgroundColor !== false) {
-    if (config?.canvasBackgroundColor === undefined) {
-      console.warn(
-        `Defaulting "canvasBackgroundColor" for "${MIME_TYPES.jpg}" mimeType`,
-      );
-      config = {
-        ...config,
-        canvasBackgroundColor:
-          data.appState?.viewBackgroundColor || COLOR_WHITE,
-      };
-    }
-  }
-
-  const canvas = await exportToCanvas({ data, config });
-
-  quality = quality ? quality : /image\/jpe?g/.test(mimeType) ? 0.92 : 0.8;
-
-  return new Promise((resolve, reject) => {
-    canvas.toBlob(
-      async (blob) => {
-        if (!blob) {
-          return reject(new Error("couldn't export to blob"));
-        }
-        if (
-          blob &&
-          mimeType === MIME_TYPES.png &&
-          data.appState?.exportEmbedScene
-        ) {
-          blob = await encodePngMetadata({
-            blob,
-            metadata: serializeAsJSON(
-              // NOTE as long as we're using the Scene hack, we need to ensure
-              // we pass the original, uncloned elements when serializing
-              // so that we keep ids stable
-              data.elements,
-              data.appState,
-              data.files || {},
-              "local",
-            ),
-          });
-        }
-        resolve(blob);
-      },
-      mimeType,
-      quality,
-    );
-  });
-};
-
-// ---------------------------------------------------------------------------
-// exportToClipboard
-// ---------------------------------------------------------------------------
-
-export const exportToClipboard = async ({
-  type,
-  data,
-  config,
-}: {
-  data: ExportSceneData;
-} & (
-  | { type: "png"; config?: ExportToBlobConfig }
-  | { type: "svg"; config?: ExportToSvgConfig }
-  | { type: "json"; config?: never }
-)) => {
-  if (type === "svg") {
-    const svg = await exportToSvg({
-      data: {
-        ...data,
-        appState: restoreAppState(data.appState, null),
-      },
-      config,
-    });
-    await copyTextToSystemClipboard(svg.outerHTML);
-  } else if (type === "png") {
-    await copyBlobToClipboardAsPng(exportToBlob({ data, config }));
-  } else if (type === "json") {
-    await copyToClipboard(data.elements, data.files);
-  } else {
-    throw new Error("Invalid export type");
-  }
+  return [width, height];
 };

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

@@ -224,7 +224,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   "strokeWidth": 2,
   "type": "arrow",
   "updated": 1,
-  "version": 29,
+  "version": 22,
   "width": "94.00000",
   "x": 0,
   "y": 0,
@@ -350,8 +350,9 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
               ],
               "mode": "orbit",
             },
-            "version": 28,
+            "version": 21,
             "width": "88.00000",
+            "y": "7.20923",
           },
           "inserted": {
             "endBinding": {
@@ -381,8 +382,9 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
               ],
               "mode": "orbit",
             },
-            "version": 25,
+            "version": 20,
             "width": "88.00000",
+            "y": "0.01000",
           },
         },
       },
@@ -437,7 +439,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
               ],
             ],
             "startBinding": null,
-            "version": 29,
+            "version": 22,
             "width": "94.00000",
             "x": 0,
             "y": 0,
@@ -462,7 +464,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
               ],
               "mode": "orbit",
             },
-            "version": 28,
+            "version": 21,
             "width": "88.00000",
             "x": 6,
             "y": "7.20923",
@@ -1360,9 +1362,9 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   "strokeWidth": 2,
   "type": "arrow",
   "updated": 1,
-  "version": 8,
+  "version": 7,
   "width": 88,
-  "x": 6,
+  "x": "6.00000",
   "y": "2.00947",
 }
 `;
@@ -1537,12 +1539,12 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
               ],
               "mode": "orbit",
             },
-            "version": 8,
+            "version": 7,
           },
           "inserted": {
             "endBinding": null,
             "startBinding": null,
-            "version": 7,
+            "version": 6,
           },
         },
       },
@@ -1722,7 +1724,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   "updated": 1,
   "version": 8,
   "width": 88,
-  "x": 6,
+  "x": "6.00000",
   "y": "38.80379",
 }
 `;
@@ -1867,7 +1869,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
             "type": "arrow",
             "version": 8,
             "width": 88,
-            "x": 6,
+            "x": "6.00000",
             "y": "38.80379",
           },
           "inserted": {
@@ -2416,7 +2418,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   "strokeWidth": 2,
   "type": "arrow",
   "updated": 1,
-  "version": 12,
+  "version": 11,
   "width": 488,
   "x": 6,
   "y": "-5.39000",
@@ -2581,7 +2583,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
             "strokeStyle": "solid",
             "strokeWidth": 2,
             "type": "arrow",
-            "version": 12,
+            "version": 11,
             "width": 488,
             "x": 6,
             "y": "-5.39000",
@@ -16636,7 +16638,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
             "fillStyle": "solid",
             "frameId": null,
             "groupIds": [],
-            "height": "0.00120",
+            "height": 0,
             "index": "a3",
             "isDeleted": false,
             "link": null,
@@ -16649,7 +16651,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
               ],
               [
                 "88.00000",
-                "0.00120",
+                0,
               ],
             ],
             "roughness": 1,
@@ -16672,7 +16674,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
             "version": 7,
             "width": "88.00000",
             "x": 6,
-            "y": "0.00880",
+            "y": "0.01000",
           },
           "inserted": {
             "isDeleted": true,
@@ -18650,7 +18652,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
             "fillStyle": "solid",
             "frameId": null,
             "groupIds": [],
-            "height": "0.00120",
+            "height": 0,
             "index": "a3",
             "isDeleted": false,
             "link": null,
@@ -18663,7 +18665,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
               ],
               [
                 "88.00000",
-                "0.00120",
+                0,
               ],
             ],
             "roughness": 1,
@@ -18686,7 +18688,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
             "version": 7,
             "width": "88.00000",
             "x": 6,
-            "y": "0.00880",
+            "y": "0.01000",
           },
           "inserted": {
             "isDeleted": true,
@@ -19398,7 +19400,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
             "fillStyle": "solid",
             "frameId": null,
             "groupIds": [],
-            "height": "0.00120",
+            "height": 0,
             "index": "a3",
             "isDeleted": false,
             "link": null,
@@ -19411,7 +19413,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
               ],
               [
                 "88.00000",
-                "0.00120",
+                0,
               ],
             ],
             "roughness": 1,
@@ -19434,7 +19436,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
             "version": 7,
             "width": "88.00000",
             "x": 6,
-            "y": "0.00880",
+            "y": "0.01000",
           },
           "inserted": {
             "isDeleted": true,

packages/excalidraw/tests/export.test.tsx

@@ -83,13 +83,11 @@ describe("export", () => {
   });
 
   it("export svg-embedded scene", async () => {
-    const svg = await exportToSvg({
-      data: {
-        elements: testElements,
-        appState: { ...getDefaultAppState(), exportEmbedScene: true },
-        files: {},
-      },
-    });
+    const svg = await exportToSvg(
+      testElements,
+      { ...getDefaultAppState(), exportEmbedScene: true },
+      {},
+    );
     const svgText = svg.outerHTML;
 
     expect(svgText).toMatchSnapshot(`svg-embdedded scene export output`);
@@ -207,13 +205,7 @@ describe("export", () => {
       },
     } as const;
 
-    const svg = await exportToSvg({
-      data: {
-        elements,
-        appState,
-        files,
-      },
-    });
+    const svg = await exportToSvg(elements, appState, files);
 
     const svgText = svg.outerHTML;
 

packages/excalidraw/tests/helpers/ui.ts

@@ -4,6 +4,7 @@ import {
   elementCenterPoint,
   getCommonBounds,
   getElementPointsCoords,
+  getLineHeightInPx,
 } from "@excalidraw/element";
 import { cropElement } from "@excalidraw/element";
 import {
@@ -20,7 +21,7 @@ import {
   isTextElement,
   isFrameLikeElement,
 } from "@excalidraw/element";
-import { KEYS, arrayToMap } from "@excalidraw/common";
+import { KEYS, arrayToMap, getLineHeight } from "@excalidraw/common";
 
 import type { GlobalPoint, LocalPoint, Radians } from "@excalidraw/math";
 
@@ -516,8 +517,17 @@ export class UI {
     UI.clickTool(type);
 
     if (type === "text") {
+      const clickY = h.state.gridModeEnabled
+        ? y
+        : y +
+          getLineHeightInPx(
+            h.state.currentItemFontSize,
+            getLineHeight(h.state.currentItemFontFamily),
+          ) /
+            2;
+
       mouse.reset();
-      mouse.click(x, y);
+      mouse.click(x, clickY);
     } else if ((type === "line" || type === "arrow") && points.length > 2) {
       points.forEach((point) => {
         mouse.reset();

packages/excalidraw/tests/scene/export.test.ts

@@ -1,10 +1,9 @@
-import { exportToCanvas, exportToSvg } from "../../scene/export";
+import { exportToCanvas, exportToSvg } from "@excalidraw/utils";
 
 import {
   applyDarkModeFilter,
   FONT_FAMILY,
   FRAME_STYLE,
-  THEME,
 } from "@excalidraw/common";
 
 import type {
@@ -54,42 +53,39 @@ describe("exportToSvg", () => {
     },
   ] as NonDeletedExcalidrawElement[];
 
-  const DEFAULT_APP_STATE = {
+  const DEFAULT_OPTIONS = {
     exportBackground: false,
     viewBackgroundColor: "#ffffff",
+    files: {},
   };
 
   it("with default arguments", async () => {
-    const svgElement = await exportUtils.exportToSvg({
-      data: {
-        elements: ELEMENTS,
-        appState: DEFAULT_APP_STATE,
-        files: {},
-      },
-    });
+    const svgElement = await exportUtils.exportToSvg(
+      ELEMENTS,
+      DEFAULT_OPTIONS,
+      null,
+    );
 
     expect(svgElement).toMatchSnapshot();
   });
 
   it("with a CJK font", async () => {
-    const svgElement = await exportUtils.exportToSvg({
-      data: {
-        elements: [
-          ...ELEMENTS,
-          {
-            ...textFixture,
-            height: ELEMENT_HEIGHT,
-            width: ELEMENT_WIDTH,
-            text: "中国你好！这是一个测试。中国你好！日本こんにちは！これはテストです。한국 안녕하세요! 이것은 테스트입니다.",
-            originalText:
-              "中国你好！这是一个测试。中国你好！日本こんにちは！これはテストです。한국 안녕하세요! 이것은 테스트입니다.",
-            index: "a4" as FractionalIndex,
-          } as ExcalidrawTextElement,
-        ],
-        appState: DEFAULT_APP_STATE,
-        files: {},
-      },
-    });
+    const svgElement = await exportUtils.exportToSvg(
+      [
+        ...ELEMENTS,
+        {
+          ...textFixture,
+          height: ELEMENT_HEIGHT,
+          width: ELEMENT_WIDTH,
+          text: "中国你好！这是一个测试。中国你好！日本こんにちは！これはテストです。한국 안녕하세요! 이것은 테스트입니다.",
+          originalText:
+            "中国你好！这是一个测试。中国你好！日本こんにちは！これはテストです。한국 안녕하세요! 이것은 테스트입니다.",
+          index: "a4" as FractionalIndex,
+        } as ExcalidrawTextElement,
+      ],
+      DEFAULT_OPTIONS,
+      null,
+    );
 
     expect(svgElement).toMatchSnapshot();
     // extend the timeout, as it needs to first load the fonts from disk and then perform whole woff2 decode, subset and encode (without workers)
@@ -98,17 +94,15 @@ describe("exportToSvg", () => {
   it("with background color", async () => {
     const BACKGROUND_COLOR = "#abcdef";
 
-    const svgElement = await exportUtils.exportToSvg({
-      data: {
-        elements: ELEMENTS,
-        appState: {
-          ...DEFAULT_APP_STATE,
-          exportBackground: true,
-          viewBackgroundColor: BACKGROUND_COLOR,
-        },
-        files: {},
+    const svgElement = await exportUtils.exportToSvg(
+      ELEMENTS,
+      {
+        ...DEFAULT_OPTIONS,
+        exportBackground: true,
+        viewBackgroundColor: BACKGROUND_COLOR,
       },
-    });
+      null,
+    );
 
     expect(svgElement.querySelector("rect")).toHaveAttribute(
       "fill",
@@ -117,18 +111,14 @@ describe("exportToSvg", () => {
   });
 
   it("with dark mode", async () => {
-    const svgElement = await exportUtils.exportToSvg({
-      data: {
-        elements: ELEMENTS,
-        appState: {
-          ...DEFAULT_APP_STATE,
-        },
-        files: {},
+    const svgElement = await exportUtils.exportToSvg(
+      ELEMENTS,
+      {
+        ...DEFAULT_OPTIONS,
+        exportWithDarkMode: true,
       },
-      config: {
-        theme: THEME.DARK,
-      },
-    });
+      null,
+    );
 
     const textElements = svgElement.querySelectorAll("text");
     expect(textElements.length).toBeGreaterThan(0);
@@ -142,16 +132,14 @@ describe("exportToSvg", () => {
   });
 
   it("with exportPadding", async () => {
-    const svgElement = await exportUtils.exportToSvg({
-      data: {
-        elements: ELEMENTS,
-        appState: DEFAULT_APP_STATE,
-        files: {},
+    const svgElement = await exportUtils.exportToSvg(
+      ELEMENTS,
+      {
+        ...DEFAULT_OPTIONS,
+        exportPadding: 0,
       },
-      config: {
-        padding: 0,
-      },
-    });
+      null,
+    );
 
     expect(svgElement).toHaveAttribute("height", ELEMENT_HEIGHT.toString());
     expect(svgElement).toHaveAttribute("width", ELEMENT_WIDTH.toString());
@@ -164,17 +152,15 @@ describe("exportToSvg", () => {
   it("with scale", async () => {
     const SCALE = 2;
 
-    const svgElement = await exportUtils.exportToSvg({
-      data: {
-        elements: ELEMENTS,
-        appState: DEFAULT_APP_STATE,
-        files: {},
+    const svgElement = await exportUtils.exportToSvg(
+      ELEMENTS,
+      {
+        ...DEFAULT_OPTIONS,
+        exportPadding: 0,
+        exportScale: SCALE,
       },
-      config: {
-        padding: 0,
-        scale: SCALE,
-      },
-    });
+      null,
+    );
 
     expect(svgElement).toHaveAttribute(
       "height",
@@ -187,27 +173,23 @@ describe("exportToSvg", () => {
   });
 
   it("with exportEmbedScene", async () => {
-    const svgElement = await exportUtils.exportToSvg({
-      data: {
-        elements: ELEMENTS,
-        appState: {
-          ...DEFAULT_APP_STATE,
-          exportEmbedScene: true,
-        },
-        files: {},
+    const svgElement = await exportUtils.exportToSvg(
+      ELEMENTS,
+      {
+        ...DEFAULT_OPTIONS,
+        exportEmbedScene: true,
       },
-    });
+      null,
+    );
     expect(svgElement.innerHTML).toMatchSnapshot();
   });
 
   it("with elements that have a link", async () => {
-    const svgElement = await exportUtils.exportToSvg({
-      data: {
-        elements: [rectangleWithLinkFixture],
-        appState: DEFAULT_APP_STATE,
-        files: {},
-      },
-    });
+    const svgElement = await exportUtils.exportToSvg(
+      [rectangleWithLinkFixture],
+      DEFAULT_OPTIONS,
+      null,
+    );
     expect(svgElement.innerHTML).toMatchSnapshot();
   });
 });
@@ -247,14 +229,9 @@ describe("exporting frames", () => {
       ];
 
       const canvas = await exportToCanvas({
-        data: {
-          elements,
-          appState: {},
-          files: null,
-        },
-        config: {
-          padding: 0,
-        },
+        elements,
+        files: null,
+        exportPadding: 0,
       });
 
       expect(canvas.width).toEqual(200);
@@ -281,15 +258,10 @@ describe("exporting frames", () => {
       ];
 
       const canvas = await exportToCanvas({
-        data: {
-          elements,
-          appState: {},
-          files: null,
-        },
-        config: {
-          padding: 0,
-          exportingFrame: frame,
-        },
+        elements,
+        files: null,
+        exportPadding: 0,
+        exportingFrame: frame,
       });
 
       expect(canvas.width).toEqual(frame.width);
@@ -325,15 +297,10 @@ describe("exporting frames", () => {
       });
 
       const svg = await exportToSvg({
-        data: {
-          elements: [rectOverlapping, frame, frameChild],
-          appState: {},
-          files: null,
-        },
-        config: {
-          padding: 0,
-          exportingFrame: frame,
-        },
+        elements: [rectOverlapping, frame, frameChild],
+        files: null,
+        exportPadding: 0,
+        exportingFrame: frame,
       });
 
       // frame itself isn't exported
@@ -374,15 +341,10 @@ describe("exporting frames", () => {
       });
 
       const svg = await exportToSvg({
-        data: {
-          elements: [frameChild, frame, elementOutside],
-          appState: {},
-          files: null,
-        },
-        config: {
-          padding: 0,
-          exportingFrame: frame,
-        },
+        elements: [frameChild, frame, elementOutside],
+        files: null,
+        exportPadding: 0,
+        exportingFrame: frame,
       });
 
       // frame itself isn't exported
@@ -447,15 +409,10 @@ describe("exporting frames", () => {
       );
 
       const svg = await exportToSvg({
-        data: {
-          elements: exportedElements,
-          appState: {},
-          files: null,
-        },
-        config: {
-          padding: 0,
-          exportingFrame,
-        },
+        elements: exportedElements,
+        files: null,
+        exportPadding: 0,
+        exportingFrame,
       });
 
       // frames themselves should be exported when multiple frames selected
@@ -497,15 +454,10 @@ describe("exporting frames", () => {
       );
 
       const svg = await exportToSvg({
-        data: {
-          elements: exportedElements,
-          appState: {},
-          files: null,
-        },
-        config: {
-          padding: 0,
-          exportingFrame,
-        },
+        elements: exportedElements,
+        files: null,
+        exportPadding: 0,
+        exportingFrame,
       });
 
       // frame itself isn't exported
@@ -561,15 +513,10 @@ describe("exporting frames", () => {
       );
 
       const svg = await exportToSvg({
-        data: {
-          elements: exportedElements,
-          appState: {},
-          files: null,
-        },
-        config: {
-          padding: 0,
-          exportingFrame,
-        },
+        elements: exportedElements,
+        files: null,
+        exportPadding: 0,
+        exportingFrame,
       });
 
       // frame shouldn't be exported

packages/excalidraw/textAutoResizeHandle.ts

@@ -0,0 +1,88 @@
+import { DEFAULT_TRANSFORM_HANDLE_SPACING } from "@excalidraw/common";
+import {
+  pointFrom,
+  pointRotateRads,
+  type GlobalPoint,
+  type Radians,
+} from "@excalidraw/math";
+
+import type { EditorInterface } from "@excalidraw/common";
+
+import type { ExcalidrawTextElement } from "@excalidraw/element/types";
+
+const TEXT_AUTO_RESIZE_HANDLE_GAP = 12;
+const TEXT_AUTO_RESIZE_HANDLE_LENGTH = 16;
+const TEXT_AUTO_RESIZE_HANDLE_HITBOX_WIDTH = 10;
+const TEXT_AUTO_RESIZE_HANDLE_HITBOX_HEIGHT =
+  TEXT_AUTO_RESIZE_HANDLE_LENGTH + 2;
+const MAX_HANDLE_HEIGHT_RATIO = 0.8;
+
+export const getTextBoxPadding = (zoomValue: number) =>
+  (DEFAULT_TRANSFORM_HANDLE_SPACING * 2) / zoomValue;
+
+export const getTextAutoResizeHandle = (
+  textElement: ExcalidrawTextElement,
+  zoomValue: number,
+  formFactor: EditorInterface["formFactor"],
+) => {
+  if (
+    formFactor !== "desktop" ||
+    TEXT_AUTO_RESIZE_HANDLE_LENGTH >
+      textElement.height * zoomValue * MAX_HANDLE_HEIGHT_RATIO
+  ) {
+    return null;
+  }
+
+  const padding = getTextBoxPadding(zoomValue);
+  const gap = TEXT_AUTO_RESIZE_HANDLE_GAP / zoomValue;
+  const length = TEXT_AUTO_RESIZE_HANDLE_LENGTH / zoomValue;
+  const center = pointFrom(
+    textElement.x + textElement.width / 2,
+    textElement.y + textElement.height / 2,
+  );
+  const handleCenter = pointRotateRads(
+    pointFrom(center[0] + textElement.width / 2 + padding + gap, center[1]),
+    center,
+    textElement.angle,
+  );
+
+  return {
+    center: handleCenter,
+    start: pointRotateRads(
+      pointFrom(handleCenter[0], handleCenter[1] - length / 2),
+      handleCenter,
+      textElement.angle,
+    ) as GlobalPoint,
+    end: pointRotateRads(
+      pointFrom(handleCenter[0], handleCenter[1] + length / 2),
+      handleCenter,
+      textElement.angle,
+    ) as GlobalPoint,
+    hitboxWidth: TEXT_AUTO_RESIZE_HANDLE_HITBOX_WIDTH / zoomValue,
+    hitboxHeight: TEXT_AUTO_RESIZE_HANDLE_HITBOX_HEIGHT / zoomValue,
+  };
+};
+
+export const isPointHittingTextAutoResizeHandle = (
+  point: Readonly<{ x: number; y: number }>,
+  textElement: ExcalidrawTextElement,
+  zoomValue: number,
+  formFactor: EditorInterface["formFactor"],
+) => {
+  const handle = getTextAutoResizeHandle(textElement, zoomValue, formFactor);
+
+  if (!handle) {
+    return false;
+  }
+
+  const unrotatedPoint = pointRotateRads(
+    pointFrom(point.x, point.y),
+    handle.center,
+    -textElement.angle as Radians,
+  );
+
+  return (
+    Math.abs(unrotatedPoint[0] - handle.center[0]) <= handle.hitboxWidth / 2 &&
+    Math.abs(unrotatedPoint[1] - handle.center[1]) <= handle.hitboxHeight / 2
+  );
+};

packages/excalidraw/types.ts

@@ -32,6 +32,7 @@ import type {
   OrderedExcalidrawElement,
   ExcalidrawNonSelectionElement,
   BindMode,
+  ExcalidrawTextElement,
 } from "@excalidraw/element/types";
 
 import type {
@@ -327,7 +328,7 @@ export interface AppState {
   /**
    * set when a new text is created or when an existing text is being edited
    */
-  editingTextElement: NonDeletedExcalidrawElement | null;
+  editingTextElement: ExcalidrawTextElement | null;
   activeTool: {
     /**
      * indicates a previous tool we should revert back to if we deselect the
@@ -876,9 +877,8 @@ export type PointerDownState = Readonly<{
     // by default same as PointerDownState.origin. On alt-duplication, reset
     // to current pointer position at time of duplication.
     origin: { x: number; y: number };
-    // Whether to block drag after lasso selection
-    // this is meant to be used to block dragging after lasso selection on PCs
-    // until the next pointer down
+    // explicit flag for specific scenarios such as:
+    // - after lasso selection until the next pointer down
     blockDragging: boolean;
   };
   // We need to have these in the state so that we can unsubscribe them

packages/excalidraw/wysiwyg/textWysiwyg.test.tsx

@@ -1,7 +1,10 @@
 import { queryByText } from "@testing-library/react";
 
 import { pointFrom } from "@excalidraw/math";
-import { getOriginalContainerHeightFromCache } from "@excalidraw/element";
+import {
+  getLineHeightInPx,
+  getOriginalContainerHeightFromCache,
+} from "@excalidraw/element";
 
 import {
   CODES,
@@ -210,6 +213,42 @@ describe("textWysiwyg", () => {
       expect(h.elements.length).toBe(1);
     });
 
+    it("should vertically center newly created text on the cursor when clicked with text tool", async () => {
+      API.setAppState({
+        currentItemFontFamily: FONT_FAMILY.Cascadia,
+        currentItemFontSize: 40,
+      });
+      UI.clickTool("text");
+
+      mouse.clickAt(120, 80);
+
+      const editor = await getTextEditor();
+      const text = h.elements[0] as ExcalidrawTextElement;
+      const lineHeightPx = getLineHeightInPx(text.fontSize, text.lineHeight);
+
+      expect(editor).not.toBe(null);
+      expect(text.y + lineHeightPx / 2).toBe(80);
+    });
+
+    it("should snap newly created text top-left to the current grid cell when clicked with text tool in grid mode", async () => {
+      API.setAppState({
+        currentItemFontFamily: FONT_FAMILY.Cascadia,
+        currentItemFontSize: 40,
+        gridModeEnabled: true,
+        gridSize: 24,
+      });
+      UI.clickTool("text");
+
+      mouse.clickAt(113, 86);
+
+      const editor = await getTextEditor();
+      const text = h.elements[0] as ExcalidrawTextElement;
+
+      expect(editor).not.toBe(null);
+      expect(text.x).toBe(96);
+      expect(text.y).toBe(72);
+    });
+
     it("should edit text under cursor when double-clicked with selection tool", async () => {
       const text = API.createElement({
         type: "text",
@@ -232,6 +271,67 @@ describe("textWysiwyg", () => {
       expect(h.elements.length).toBe(1);
     });
 
+    it("should edit selected bound text on single click", async () => {
+      const container = API.createElement({
+        type: "rectangle",
+        width: 160,
+        height: 70,
+        boundElements: [],
+      });
+      const text = API.createElement({
+        type: "text",
+        text: "Hello World!",
+        x: container.x + 20,
+        y: container.y + 20,
+        width: 120,
+        height: 25,
+        containerId: container.id,
+      });
+
+      API.setElements([container, text]);
+      API.updateElement(container, {
+        boundElements: [{ type: "text", id: text.id }],
+      });
+      API.setSelectedElements([container]);
+      UI.clickTool("selection");
+
+      mouse.clickAt(text.x + 26, text.y + 10);
+
+      const editor = await getTextEditor();
+
+      expect(editor).not.toBe(null);
+    });
+
+    it("should not edit selected bound text container when only the container was single-clicked", async () => {
+      const container = API.createElement({
+        type: "rectangle",
+        width: 160,
+        height: 70,
+        boundElements: [],
+      });
+      const text = API.createElement({
+        type: "text",
+        text: "Hello World!",
+        x: container.x + 20,
+        y: container.y + 20,
+        width: 120,
+        height: 25,
+        containerId: container.id,
+      });
+
+      API.setElements([container, text]);
+      API.updateElement(container, {
+        boundElements: [{ type: "text", id: text.id }],
+      });
+      API.setSelectedElements([container]);
+      UI.clickTool("selection");
+
+      mouse.clickAt(container.x + 5, container.y + 10);
+
+      expect(h.state.editingTextElement).toBe(null);
+      expect(await getTextEditor({ waitForEditor: false })).toBe(null);
+    });
+
     // FIXME too flaky. No one knows why.
     it.skip("should bump the version of a labeled arrow when the label is updated", async () => {
       const arrow = UI.createElement("arrow", {
@@ -1511,7 +1611,7 @@ describe("textWysiwyg", () => {
           version: 2,
           width: 610,
           x: 15,
-          y: 25,
+          y: 12.5,
         }),
       );
       expect(h.elements[2] as ExcalidrawTextElement).toEqual(

packages/excalidraw/wysiwyg/textWysiwyg.tsx

@@ -10,7 +10,9 @@ import {
   isTestEnv,
   MIME_TYPES,
   applyDarkModeFilter,
+  isRTL,
 } from "@excalidraw/common";
+import { pointFrom, pointRotateRads, type Radians } from "@excalidraw/math";
 
 import {
   getTextFromElements,
@@ -33,8 +35,11 @@ import {
   getBoundTextElement,
 } from "@excalidraw/element";
 import { getTextWidth } from "@excalidraw/element";
+import { getLineHeightInPx } from "@excalidraw/element";
+import { getLineWidth } from "@excalidraw/element";
 import { normalizeText } from "@excalidraw/element";
 import { wrapText } from "@excalidraw/element";
+import { getWrappedTextLines } from "@excalidraw/element";
 import {
   isArrowElement,
   isBoundToContainer,
@@ -91,6 +96,103 @@ const getTransform = (
   return `translate(${translateX}px, ${translateY}px) scale(${zoom.value}) rotate(${degree}deg)`;
 };
 
+const getLineDirection = (text: string, offset: number) => {
+  const hardLineStart = text.lastIndexOf("\n", Math.max(0, offset - 1)) + 1;
+  const hardLineEnd = text.indexOf("\n", offset);
+  const hardLineText = text.slice(
+    hardLineStart,
+    hardLineEnd === -1 ? text.length : hardLineEnd,
+  );
+
+  return isRTL(hardLineText) ? "rtl" : "ltr";
+};
+
+const getCaretBoundaryOffsets = (text: string) => {
+  const offsets = [0];
+  let offset = 0;
+
+  for (const char of Array.from(text)) {
+    offset += char.length;
+    offsets.push(offset);
+  }
+
+  return offsets;
+};
+
+const getLineCaretOffsetFromNativeLayout = ({
+  text,
+  font,
+  lineHeightPx,
+  direction,
+  targetX,
+}: {
+  text: string;
+  font: ReturnType<typeof getFontString>;
+  lineHeightPx: number;
+  direction: "ltr" | "rtl";
+  targetX: number;
+}) => {
+  if (!text || !document.body || typeof document.createRange !== "function") {
+    return null;
+  }
+
+  const offsets = getCaretBoundaryOffsets(text);
+  const mirror = document.createElement("div");
+  const textNode = document.createTextNode(text);
+  const range = document.createRange();
+  const positions: number[] = [];
+
+  mirror.dir = direction;
+  Object.assign(mirror.style, {
+    position: "fixed",
+    top: "0",
+    left: "0",
+    margin: 0,
+    padding: 0,
+    border: 0,
+    opacity: "0",
+    pointerEvents: "none",
+    whiteSpace: "pre",
+    font,
+    lineHeight: `${lineHeightPx}px`,
+  });
+  mirror.append(textNode);
+  document.body.append(mirror);
+
+  try {
+    for (const offset of offsets) {
+      range.setStart(textNode, offset);
+      range.setEnd(textNode, offset);
+      const caretRect = range.getBoundingClientRect();
+
+      if (!Number.isFinite(caretRect.left)) {
+        return null;
+      }
+
+      positions.push(caretRect.left);
+    }
+  } catch {
+    return null;
+  } finally {
+    mirror.remove();
+  }
+
+  const leftEdge = Math.min(...positions);
+  let closestOffset = offsets[0];
+  let closestDistance = Infinity;
+
+  for (let index = 0; index < offsets.length; index++) {
+    const distance = Math.abs(positions[index] - leftEdge - targetX);
+
+    if (distance < closestDistance) {
+      closestDistance = distance;
+      closestOffset = offsets[index];
+    }
+  }
+
+  return closestOffset;
+};
+
 type SubmitHandler = () => void;
 
 export const textWysiwyg = ({
@@ -103,6 +205,7 @@ export const textWysiwyg = ({
   excalidrawContainer,
   app,
   autoSelect = true,
+  initialCaretSceneCoords = null,
 }: {
   id: ExcalidrawElement["id"];
   /**
@@ -119,7 +222,19 @@ export const textWysiwyg = ({
   excalidrawContainer: HTMLDivElement | null;
   app: App;
   autoSelect?: boolean;
+  initialCaretSceneCoords?: { x: number; y: number } | null;
 }): SubmitHandler => {
+  let currentTextLayout: {
+    angle: Radians;
+    font: ReturnType<typeof getFontString>;
+    height: number;
+    lineHeightPx: number;
+    textAlign: ExcalidrawTextElement["textAlign"];
+    width: number;
+    x: number;
+    y: number;
+  } | null = null;
+
   const textPropertiesUpdated = (
     updatedTextElement: ExcalidrawTextElement,
     editable: HTMLTextAreaElement,
@@ -254,6 +369,7 @@ export const textWysiwyg = ({
       height *= 1.05;
 
       const font = getFontString(updatedTextElement);
+      const angle = getTextElementAngle(updatedTextElement, container);
 
       // Make sure text editor height doesn't go beyond viewport
       const editorMaxHeight =
@@ -269,7 +385,7 @@ export const textWysiwyg = ({
         transform: getTransform(
           width,
           height,
-          getTextElementAngle(updatedTextElement, container),
+          angle,
           appState,
           maxWidth,
           editorMaxHeight,
@@ -283,6 +399,19 @@ export const textWysiwyg = ({
         opacity: updatedTextElement.opacity / 100,
         maxHeight: `${editorMaxHeight}px`,
       });
+      currentTextLayout = {
+        angle: angle as Radians,
+        font,
+        height: updatedTextElement.height,
+        lineHeightPx: getLineHeightInPx(
+          updatedTextElement.fontSize,
+          updatedTextElement.lineHeight,
+        ),
+        textAlign,
+        width: updatedTextElement.width,
+        x: coordX,
+        y: coordY,
+      };
       editable.scrollTop = 0;
       // For some reason updating font attribute doesn't set font family
       // hence updating font family explicitly for test environment
@@ -333,6 +462,71 @@ export const textWysiwyg = ({
   editable.value = element.originalText;
   updateWysiwygStyle();
 
+  const getCaretIndexFromInitialSceneCoords = () => {
+    if (!initialCaretSceneCoords || !currentTextLayout) {
+      return null;
+    }
+
+    const layout = currentTextLayout;
+    const center = pointFrom(
+      layout.x + layout.width / 2,
+      layout.y + layout.height / 2,
+    );
+    const [unrotatedX, unrotatedY] = pointRotateRads(
+      pointFrom(initialCaretSceneCoords.x, initialCaretSceneCoords.y),
+      center,
+      -layout.angle as Radians,
+    );
+    const localX = unrotatedX - layout.x;
+    const localY = unrotatedY - layout.y;
+    const lines = getWrappedTextLines(
+      editable.value,
+      layout.font,
+      whiteSpace === "pre-wrap" ? layout.width : Infinity,
+    );
+    const lineIndex = Math.max(
+      0,
+      Math.min(lines.length - 1, Math.floor(localY / layout.lineHeightPx)),
+    );
+    const line = lines[lineIndex];
+    const direction = getLineDirection(editable.value, line.start);
+    const lineWidth = getLineWidth(line.text, layout.font);
+    const lineStartX =
+      layout.textAlign === "center"
+        ? (layout.width - lineWidth) / 2
+        : layout.textAlign === "right"
+        ? layout.width - lineWidth
+        : 0;
+    const relativeX = localX - lineStartX;
+
+    if (!line.text) {
+      return line.start;
+    }
+
+    const lineCaretOffset = getLineCaretOffsetFromNativeLayout({
+      text: line.text,
+      font: layout.font,
+      lineHeightPx: layout.lineHeightPx,
+      direction,
+      targetX: relativeX,
+    });
+
+    return line.start + (lineCaretOffset || 0);
+  };
+
+  let pendingInitialSelection = (() => {
+    const caretIndex = getCaretIndexFromInitialSceneCoords();
+
+    if (caretIndex === null) {
+      return null;
+    }
+
+    return {
+      start: caretIndex,
+      end: caretIndex,
+    };
+  })();
+
   if (onChange) {
     editable.onpaste = async (event) => {
       // we need to synchronously get the MIME types so we can preventDefault()
@@ -696,6 +890,13 @@ export const textWysiwyg = ({
       // Otherwise, re-enable submit on blur and refocus the editor.
       editable.onblur = handleSubmit;
       editable.focus();
+      if (pendingInitialSelection) {
+        editable.setSelectionRange(
+          pendingInitialSelection.start,
+          pendingInitialSelection.end,
+        );
+        pendingInitialSelection = null;
+      }
     });
   };
 
@@ -786,7 +987,7 @@ export const textWysiwyg = ({
 
   let isDestroyed = false;
 
-  if (autoSelect) {
+  if (autoSelect && !pendingInitialSelection) {
     // select on init (focusing is done separately inside the bindBlurEvent()
     // because we need it to happen *after* the blur event from `pointerdown`)
     editable.select();

packages/math/src/point.ts

@@ -123,10 +123,15 @@ export function pointsEqual<Point extends GlobalPoint | LocalPoint>(
  * @returns The rotated point
  */
 export function pointRotateRads<Point extends GlobalPoint | LocalPoint>(
-  [x, y]: Point,
-  [cx, cy]: Point,
+  point: Point,
+  center: Point,
   angle: Radians,
 ): Point {
+  if (!angle) {
+    return point;
+  }
+  const [x, y] = point;
+  const [cx, cy] = center;
   return pointFrom(
     (x - cx) * Math.cos(angle) - (y - cy) * Math.sin(angle) + cx,
     (x - cx) * Math.sin(angle) + (y - cy) * Math.cos(angle) + cy,

packages/utils/src/export.ts

@@ -0,0 +1,216 @@
+import { MIME_TYPES } from "@excalidraw/common";
+import { getDefaultAppState } from "@excalidraw/excalidraw/appState";
+import {
+  copyBlobToClipboardAsPng,
+  copyTextToSystemClipboard,
+  copyToClipboard,
+} from "@excalidraw/excalidraw/clipboard";
+import { encodePngMetadata } from "@excalidraw/excalidraw/data/image";
+import { serializeAsJSON } from "@excalidraw/excalidraw/data/json";
+import {
+  restoreAppState,
+  restoreElements,
+} from "@excalidraw/excalidraw/data/restore";
+import {
+  exportToCanvas as _exportToCanvas,
+  exportToSvg as _exportToSvg,
+} from "@excalidraw/excalidraw/scene/export";
+
+import type {
+  ExcalidrawElement,
+  ExcalidrawFrameLikeElement,
+  NonDeleted,
+} from "@excalidraw/element/types";
+import type { AppState, BinaryFiles } from "@excalidraw/excalidraw/types";
+
+export { MIME_TYPES };
+
+type ExportOpts = {
+  elements: readonly NonDeleted<ExcalidrawElement>[];
+  appState?: Partial<Omit<AppState, "offsetTop" | "offsetLeft">>;
+  files: BinaryFiles | null;
+  maxWidthOrHeight?: number;
+  exportingFrame?: ExcalidrawFrameLikeElement | null;
+  getDimensions?: (
+    width: number,
+    height: number,
+  ) => { width: number; height: number; scale?: number };
+};
+
+export const exportToCanvas = ({
+  elements,
+  appState,
+  files,
+  maxWidthOrHeight,
+  getDimensions,
+  exportPadding,
+  exportingFrame,
+}: ExportOpts & {
+  exportPadding?: number;
+}) => {
+  const restoredElements = restoreElements(elements, null, {
+    deleteInvisibleElements: true,
+  });
+  const restoredAppState = restoreAppState(appState, null);
+
+  const { exportBackground, viewBackgroundColor } = restoredAppState;
+  return _exportToCanvas(
+    restoredElements,
+    { ...restoredAppState, offsetTop: 0, offsetLeft: 0, width: 0, height: 0 },
+    files || {},
+    { exportBackground, exportPadding, viewBackgroundColor, exportingFrame },
+    (width: number, height: number) => {
+      const canvas = document.createElement("canvas");
+
+      if (maxWidthOrHeight) {
+        if (typeof getDimensions === "function") {
+          console.warn(
+            "`getDimensions()` is ignored when `maxWidthOrHeight` is supplied.",
+          );
+        }
+
+        const max = Math.max(width, height);
+
+        // if content is less then maxWidthOrHeight, fallback on supplied scale
+        const scale =
+          maxWidthOrHeight < max
+            ? maxWidthOrHeight / max
+            : appState?.exportScale ?? 1;
+
+        canvas.width = width * scale;
+        canvas.height = height * scale;
+
+        return {
+          canvas,
+          scale,
+        };
+      }
+
+      const ret = getDimensions?.(width, height) || { width, height };
+
+      canvas.width = ret.width;
+      canvas.height = ret.height;
+
+      return {
+        canvas,
+        scale: ret.scale ?? 1,
+      };
+    },
+  );
+};
+
+export const exportToBlob = async (
+  opts: ExportOpts & {
+    mimeType?: string;
+    quality?: number;
+    exportPadding?: number;
+  },
+): Promise<Blob> => {
+  let { mimeType = MIME_TYPES.png, quality } = opts;
+
+  if (mimeType === MIME_TYPES.png && typeof quality === "number") {
+    console.warn(`"quality" will be ignored for "${MIME_TYPES.png}" mimeType`);
+  }
+
+  // typo in MIME type (should be "jpeg")
+  if (mimeType === "image/jpg") {
+    mimeType = MIME_TYPES.jpg;
+  }
+
+  if (mimeType === MIME_TYPES.jpg && !opts.appState?.exportBackground) {
+    console.warn(
+      `Defaulting "exportBackground" to "true" for "${MIME_TYPES.jpg}" mimeType`,
+    );
+    opts = {
+      ...opts,
+      appState: { ...opts.appState, exportBackground: true },
+    };
+  }
+
+  const canvas = await exportToCanvas(opts);
+
+  quality = quality ? quality : /image\/jpe?g/.test(mimeType) ? 0.92 : 0.8;
+
+  return new Promise((resolve, reject) => {
+    canvas.toBlob(
+      async (blob) => {
+        if (!blob) {
+          return reject(new Error("couldn't export to blob"));
+        }
+        if (
+          blob &&
+          mimeType === MIME_TYPES.png &&
+          opts.appState?.exportEmbedScene
+        ) {
+          blob = await encodePngMetadata({
+            blob,
+            metadata: serializeAsJSON(
+              // NOTE as long as we're using the Scene hack, we need to ensure
+              // we pass the original, uncloned elements when serializing
+              // so that we keep ids stable
+              opts.elements,
+              opts.appState,
+              opts.files || {},
+              "local",
+            ),
+          });
+        }
+        resolve(blob);
+      },
+      mimeType,
+      quality,
+    );
+  });
+};
+
+export const exportToSvg = async ({
+  elements,
+  appState = getDefaultAppState(),
+  files = {},
+  exportPadding,
+  renderEmbeddables,
+  exportingFrame,
+  skipInliningFonts,
+  reuseImages,
+}: Omit<ExportOpts, "getDimensions"> & {
+  exportPadding?: number;
+  renderEmbeddables?: boolean;
+  skipInliningFonts?: true;
+  reuseImages?: boolean;
+}): Promise<SVGSVGElement> => {
+  const restoredElements = restoreElements(elements, null, {
+    deleteInvisibleElements: true,
+  });
+  const restoredAppState = restoreAppState(appState, null);
+
+  const exportAppState = {
+    ...restoredAppState,
+    exportPadding,
+  };
+
+  return _exportToSvg(restoredElements, exportAppState, files, {
+    exportingFrame,
+    renderEmbeddables,
+    skipInliningFonts,
+    reuseImages,
+  });
+};
+
+export const exportToClipboard = async (
+  opts: ExportOpts & {
+    mimeType?: string;
+    quality?: number;
+    type: "png" | "svg" | "json";
+  },
+) => {
+  if (opts.type === "svg") {
+    const svg = await exportToSvg(opts);
+    await copyTextToSystemClipboard(svg.outerHTML);
+  } else if (opts.type === "png") {
+    await copyBlobToClipboardAsPng(exportToBlob(opts));
+  } else if (opts.type === "json") {
+    await copyToClipboard(opts.elements, opts.files);
+  } else {
+    throw new Error("Invalid export type");
+  }
+};

packages/utils/src/index.ts

@@ -1,17 +1,4 @@
-// Re-export from @excalidraw/excalidraw for backwards compatibility
-export {
-  exportToCanvas,
-  exportToBlob,
-  exportToSvg,
-  exportToClipboard,
-  MIME_TYPES,
-} from "@excalidraw/excalidraw/scene/export";
-
-export type {
-  ExportSceneData,
-  ExportSceneConfig,
-} from "@excalidraw/excalidraw/scene/export";
-
+export * from "./export";
 export * from "./withinBounds";
 export * from "./bbox";
 export { getCommonBounds } from "@excalidraw/element";

packages/utils/tests/export.test.ts

@@ -10,22 +10,9 @@ const exportToSvgSpy = vi.spyOn(mockedSceneExportUtils, "exportToSvg");
 describe("exportToCanvas", async () => {
   const EXPORT_PADDING = 10;
 
-  it("with default arguments (no padding)", async () => {
+  it("with default arguments", async () => {
     const canvas = await utils.exportToCanvas({
-      data: diagramFactory({ elementOverrides: { width: 100, height: 100 } }),
-    });
-
-    // New API has no default padding - call sites must explicitly set it
-    expect(canvas.width).toBe(100);
-    expect(canvas.height).toBe(100);
-  });
-
-  it("with padding", async () => {
-    const canvas = await utils.exportToCanvas({
-      data: diagramFactory({ elementOverrides: { width: 100, height: 100 } }),
-      config: {
-        padding: EXPORT_PADDING,
-      },
+      ...diagramFactory({ elementOverrides: { width: 100, height: 100 } }),
     });
 
     expect(canvas.width).toBe(100 + 2 * EXPORT_PADDING);
@@ -34,10 +21,8 @@ describe("exportToCanvas", async () => {
 
   it("when custom width and height", async () => {
     const canvas = await utils.exportToCanvas({
-      data: diagramFactory({ elementOverrides: { width: 100, height: 100 } }),
-      config: {
-        getDimensions: () => ({ width: 200, height: 200, scale: 1 }),
-      },
+      ...diagramFactory({ elementOverrides: { width: 100, height: 100 } }),
+      getDimensions: () => ({ width: 200, height: 200, scale: 1 }),
     });
 
     expect(canvas.width).toBe(200);
@@ -48,27 +33,20 @@ describe("exportToCanvas", async () => {
 describe("exportToBlob", async () => {
   describe("mime type", () => {
     it("should change image/jpg to image/jpeg", async () => {
-      const diagramData = diagramFactory();
       const blob = await utils.exportToBlob({
-        data: {
-          elements: diagramData.elements,
-          appState: {
-            ...diagramData.appState,
-            exportBackground: true,
-          },
-          files: diagramData.files,
-        },
-        config: {
-          getDimensions: (width, height) => ({ width, height, scale: 1 }),
-          // testing typo in MIME type (jpg → jpeg)
-          mimeType: "image/jpg",
+        ...diagramFactory(),
+        getDimensions: (width, height) => ({ width, height, scale: 1 }),
+        // testing typo in MIME type (jpg → jpeg)
+        mimeType: "image/jpg",
+        appState: {
+          exportBackground: true,
         },
       });
       expect(blob?.type).toBe(MIME_TYPES.jpg);
     });
     it("should default to image/png", async () => {
       const blob = await utils.exportToBlob({
-        data: diagramFactory(),
+        ...diagramFactory(),
       });
       expect(blob?.type).toBe(MIME_TYPES.png);
     });
@@ -78,11 +56,9 @@ describe("exportToBlob", async () => {
         .spyOn(console, "warn")
         .mockImplementationOnce(() => void 0);
       await utils.exportToBlob({
-        data: diagramFactory(),
-        config: {
-          mimeType: MIME_TYPES.png,
-          quality: 1,
-        },
+        ...diagramFactory(),
+        mimeType: MIME_TYPES.png,
+        quality: 1,
       });
       expect(consoleSpy).toHaveBeenCalledWith(
         `"quality" will be ignored for "${MIME_TYPES.png}" mimeType`,
@@ -92,9 +68,8 @@ describe("exportToBlob", async () => {
 });
 
 describe("exportToSvg", () => {
-  const getPassedArg = () => exportToSvgSpy.mock.calls[0][0];
-  const passedData = () => getPassedArg().data;
-  const passedConfig = () => getPassedArg().config;
+  const passedElements = () => exportToSvgSpy.mock.calls[0][0];
+  const passedOptions = () => exportToSvgSpy.mock.calls[0][1];
 
   afterEach(() => {
     vi.clearAllMocks();
@@ -102,14 +77,18 @@ describe("exportToSvg", () => {
 
   it("with default arguments", async () => {
     await utils.exportToSvg({
-      data: diagramFactory({
+      ...diagramFactory({
         overrides: { appState: void 0 },
       }),
     });
 
-    const data = passedData();
-    expect(data.elements.length).toBe(3);
-    expect(passedConfig()).toMatchSnapshot();
+    const passedOptionsWhenDefault = {
+      ...passedOptions(),
+      // To avoid varying snapshots
+      name: "name",
+    };
+    expect(passedElements().length).toBe(3);
+    expect(passedOptionsWhenDefault).toMatchSnapshot();
   });
 
   // FIXME the utils.exportToSvg no longer filters out deleted elements.
@@ -117,39 +96,37 @@ describe("exportToSvg", () => {
   // type-checking for it correctly.
   it.skip("with deleted elements", async () => {
     await utils.exportToSvg({
-      data: diagramFactory({
+      ...diagramFactory({
         overrides: { appState: void 0 },
         elementOverrides: { isDeleted: true },
       }),
     });
 
-    expect(passedData().elements.length).toBe(0);
+    expect(passedElements().length).toBe(0);
   });
 
-  it("with padding", async () => {
+  it("with exportPadding", async () => {
     await utils.exportToSvg({
-      data: diagramFactory({ overrides: { appState: { name: "diagram name" } } }),
-      config: {
-        padding: 0,
-      },
+      ...diagramFactory({ overrides: { appState: { name: "diagram name" } } }),
+      exportPadding: 0,
     });
 
-    expect(passedData().elements.length).toBe(3);
-    expect(passedConfig()).toEqual(
-      expect.objectContaining({ padding: 0 }),
+    expect(passedElements().length).toBe(3);
+    expect(passedOptions()).toEqual(
+      expect.objectContaining({ exportPadding: 0 }),
     );
   });
 
   it("with exportEmbedScene", async () => {
     await utils.exportToSvg({
-      data: diagramFactory({
+      ...diagramFactory({
         overrides: {
           appState: { name: "diagram name", exportEmbedScene: true },
         },
       }),
     });
 
-    expect(passedData().elements.length).toBe(3);
-    expect(passedData().appState?.exportEmbedScene).toBe(true);
+    expect(passedElements().length).toBe(3);
+    expect(passedOptions().exportEmbedScene).toBe(true);
   });
 });

packages/utils/tests/utils.unmocked.test.ts

@@ -19,15 +19,13 @@ describe("embedding scene data", () => {
       const sourceElements = [rectangle, ellipse];
 
       const svgNode = await utils.exportToSvg({
-        data: {
-          elements: sourceElements,
-          appState: {
-            viewBackgroundColor: "#ffffff",
-            gridModeEnabled: false,
-            exportEmbedScene: true,
-          },
-          files: null,
+        elements: sourceElements,
+        appState: {
+          viewBackgroundColor: "#ffffff",
+          gridModeEnabled: false,
+          exportEmbedScene: true,
         },
+        files: null,
       });
 
       const svg = svgNode.outerHTML;
@@ -51,18 +49,14 @@ describe("embedding scene data", () => {
       const sourceElements = [rectangle, ellipse];
 
       const blob = await utils.exportToBlob({
-        data: {
-          elements: sourceElements,
-          appState: {
-            viewBackgroundColor: "#ffffff",
-            gridModeEnabled: false,
-            exportEmbedScene: true,
-          },
-          files: null,
-        },
-        config: {
-          mimeType: "image/png",
+        mimeType: "image/png",
+        elements: sourceElements,
+        appState: {
+          viewBackgroundColor: "#ffffff",
+          gridModeEnabled: false,
+          exportEmbedScene: true,
         },
+        files: null,
       });
 
       const parsedString = await decodePngMetadata(blob);