@excalidraw/excalidraw 0.17.1-d9bbf1e → 0.17.1-e63dd02

package/dist/excalidraw/binaryheap.js

@@ -0,0 +1,93 @@
+export default class BinaryHeap {
+    scoreFunction;
+    content = [];
+    constructor(scoreFunction) {
+        this.scoreFunction = scoreFunction;
+    }
+    sinkDown(idx) {
+        const node = this.content[idx];
+        while (idx > 0) {
+            const parentN = ((idx + 1) >> 1) - 1;
+            const parent = this.content[parentN];
+            if (this.scoreFunction(node) < this.scoreFunction(parent)) {
+                this.content[parentN] = node;
+                this.content[idx] = parent;
+                idx = parentN; // TODO: Optimize
+            }
+            else {
+                break;
+            }
+        }
+    }
+    bubbleUp(idx) {
+        const length = this.content.length;
+        const node = this.content[idx];
+        const score = this.scoreFunction(node);
+        while (true) {
+            const child2N = (idx + 1) << 1;
+            const child1N = child2N - 1;
+            let swap = null;
+            let child1Score = 0;
+            if (child1N < length) {
+                const child1 = this.content[child1N];
+                child1Score = this.scoreFunction(child1);
+                if (child1Score < score) {
+                    swap = child1N;
+                }
+            }
+            if (child2N < length) {
+                const child2 = this.content[child2N];
+                const child2Score = this.scoreFunction(child2);
+                if (child2Score < (swap === null ? score : child1Score)) {
+                    swap = child2N;
+                }
+            }
+            if (swap !== null) {
+                this.content[idx] = this.content[swap];
+                this.content[swap] = node;
+                idx = swap; // TODO: Optimize
+            }
+            else {
+                break;
+            }
+        }
+    }
+    push(node) {
+        this.content.push(node);
+        this.sinkDown(this.content.length - 1);
+    }
+    pop() {
+        if (this.content.length === 0) {
+            return null;
+        }
+        const result = this.content[0];
+        const end = this.content.pop();
+        if (this.content.length > 0) {
+            this.content[0] = end;
+            this.bubbleUp(0);
+        }
+        return result;
+    }
+    remove(node) {
+        if (this.content.length === 0) {
+            return;
+        }
+        const i = this.content.indexOf(node);
+        const end = this.content.pop();
+        if (i < this.content.length) {
+            this.content[i] = end;
+            if (this.scoreFunction(end) < this.scoreFunction(node)) {
+                this.sinkDown(i);
+            }
+            else {
+                this.bubbleUp(i);
+            }
+        }
+    }
+    size() {
+        return this.content.length;
+    }
+    rescoreElement(node) {
+        this.sinkDown(this.content.indexOf(node));
+    }
+}

package/dist/excalidraw/change.d.ts

@@ -1,7 +1,8 @@
-import { ElementUpdate } from "./element/mutateElement";
-import { OrderedExcalidrawElement, SceneElementsMap } from "./element/types";
-import { AppState, ObservedAppState } from "./types";
-import { ValueOf } from "./utility-types";
+import type { ElementUpdate } from "./element/mutateElement";
+import type { OrderedExcalidrawElement, SceneElementsMap } from "./element/types";
+import type Scene from "./scene/Scene";
+import type { AppState, ObservedAppState } from "./types";
+import type { ValueOf } from "./utility-types";
 /**
  * Represents the difference between two objects of the same type.
  *
@@ -153,7 +154,7 @@ export declare class ElementsChange implements Change<SceneElementsMap> {
      * @returns new instance with modified delta/s
      */
     applyLatestChanges(elements: SceneElementsMap): ElementsChange;
-    applyTo(elements: SceneElementsMap, snapshot: Map<string, OrderedExcalidrawElement>): [SceneElementsMap, boolean];
+    applyTo(elements: SceneElementsMap, snapshot: Map<string, OrderedExcalidrawElement>, scene: Scene): [SceneElementsMap, boolean];
     private static createApplier;
     private static createGetter;
     private static applyDelta;

package/dist/excalidraw/change.js

@@ -1,7 +1,7 @@
 import { ENV } from "./constants";
 import { BoundElement, BindableElement, bindingProperties, updateBoundElements, } from "./element/binding";
 import { LinearElementEditor } from "./element/linearElementEditor";
-import { mutateElement, newElementWith, } from "./element/mutateElement";
+import { mutateElement, newElementWith } from "./element/mutateElement";
 import { getBoundTextElementId, redrawTextBoundingBox, } from "./element/textElement";
 import { hasBoundTextElement, isBindableElement, isBoundToContainer, isTextElement, } from "./element/typeChecks";
 import { orderByFractionalIndex, syncMovedIndices } from "./fractionalIndex";
@@ -599,7 +599,7 @@ export class ElementsChange {
             shouldRedistribute: true, // redistribute the deltas as `isDeleted` could have been updated
         });
     }
-    applyTo(elements, snapshot) {
+    applyTo(elements, snapshot, scene) {
         let nextElements = toBrandedType(new Map(elements));
         let changedElements;
         const flags = {
@@ -635,7 +635,7 @@ export class ElementsChange {
         try {
             // TODO: #7348 refactor away mutations below, so that we couldn't end up in an incosistent state
             ElementsChange.redrawTextBoundingBoxes(nextElements, changedElements);
-            ElementsChange.redrawBoundArrows(nextElements, changedElements);
+            ElementsChange.redrawBoundArrows(nextElements, changedElements, scene);
             // the following reorder performs also mutations, but only on new instances of changed elements
             // (unless something goes really bad and it fallbacks to fixing all invalid indices)
             nextElements = ElementsChange.reorderElements(nextElements, changedElements, flags);
@@ -847,10 +847,12 @@ export class ElementsChange {
             redrawTextBoundingBox(boundText, container, elements, false);
         }
     }
-    static redrawBoundArrows(elements, changed) {
+    static redrawBoundArrows(elements, changed, scene) {
         for (const element of changed.values()) {
             if (!element.isDeleted && isBindableElement(element)) {
-                updateBoundElements(element, elements);
+                updateBoundElements(element, elements, scene, {
+                    changedElements: changed,
+                });
             }
         }
     }
@@ -858,15 +860,22 @@ export class ElementsChange {
         if (!flags.containsZindexDifference) {
             return elements;
         }
-        const previous = Array.from(elements.values());
-        const reordered = orderByFractionalIndex([...previous]);
-        if (!flags.containsVisibleDifference &&
-            Delta.isRightDifferent(previous, reordered, true)) {
+        const unordered = Array.from(elements.values());
+        const ordered = orderByFractionalIndex([...unordered]);
+        const moved = Delta.getRightDifferences(unordered, ordered, true).reduce((acc, arrayIndex) => {
+            const candidate = unordered[Number(arrayIndex)];
+            if (candidate && changed.has(candidate.id)) {
+                acc.set(candidate.id, candidate);
+            }
+            return acc;
+        }, new Map());
+        if (!flags.containsVisibleDifference && moved.size) {
             // we found a difference in order!
             flags.containsVisibleDifference = true;
         }
-        // let's synchronize all invalid indices of moved elements
-        return arrayToMap(syncMovedIndices(reordered, changed));
+        // synchronize all elements that were actually moved
+        // could fallback to synchronizing all invalid indices
+        return arrayToMap(syncMovedIndices(ordered, moved));
     }
     /**
      * It is necessary to post process the partials in case of reference values,

package/dist/excalidraw/charts.d.ts

@@ -1,4 +1,4 @@
-import { NonDeletedExcalidrawElement } from "./element/types";
+import type { NonDeletedExcalidrawElement } from "./element/types";
 export type ChartElements = readonly NonDeletedExcalidrawElement[];
 export interface Spreadsheet {
     title: string | null;

package/dist/excalidraw/charts.js

@@ -181,8 +181,6 @@ const chartLines = (spreadsheet, x, y, groupId, backgroundColor) => {
         type: "line",
         x,
         y,
-        startArrowhead: null,
-        endArrowhead: null,
         width: chartWidth,
         points: [
             [0, 0],
@@ -196,8 +194,6 @@ const chartLines = (spreadsheet, x, y, groupId, backgroundColor) => {
         type: "line",
         x,
         y,
-        startArrowhead: null,
-        endArrowhead: null,
         height: chartHeight,
         points: [
             [0, 0],
@@ -211,8 +207,6 @@ const chartLines = (spreadsheet, x, y, groupId, backgroundColor) => {
         type: "line",
         x,
         y: y - BAR_HEIGHT - BAR_GAP,
-        startArrowhead: null,
-        endArrowhead: null,
         strokeStyle: "dotted",
         width: chartWidth,
         opacity: GRID_OPACITY,
@@ -306,8 +300,6 @@ const chartTypeLine = (spreadsheet, x, y) => {
         type: "line",
         x: x + BAR_GAP + BAR_WIDTH / 2,
         y: y - BAR_GAP,
-        startArrowhead: null,
-        endArrowhead: null,
         height: maxY - minY,
         width: maxX - minX,
         strokeWidth: 2,
@@ -339,8 +331,6 @@ const chartTypeLine = (spreadsheet, x, y) => {
             type: "line",
             x: x + cx + BAR_WIDTH / 2 + BAR_GAP / 2,
             y: y - cy,
-            startArrowhead: null,
-            endArrowhead: null,
             height: cy,
             strokeStyle: "dotted",
             opacity: GRID_OPACITY,

package/dist/excalidraw/clients.d.ts

@@ -1,5 +1,5 @@
-import { InteractiveCanvasRenderConfig } from "./scene/types";
-import { Collaborator, InteractiveCanvasAppState, SocketId } from "./types";
+import type { InteractiveCanvasRenderConfig } from "./scene/types";
+import type { Collaborator, InteractiveCanvasAppState, SocketId } from "./types";
 export declare const getClientColor: (socketId: SocketId, collaborator: Collaborator | undefined) => string;
 /**
  * returns first char, capitalized

package/dist/excalidraw/clients.js

@@ -1,6 +1,6 @@
 import { COLOR_CHARCOAL_BLACK, COLOR_VOICE_CALL, COLOR_WHITE, THEME, } from "./constants";
 import { roundRect } from "./renderer/roundRect";
-import { UserIdleState, } from "./types";
+import { UserIdleState } from "./types";
 function hashToInteger(id) {
     let hash = 0;
     if (id.length === 0) {

package/dist/excalidraw/clipboard.d.ts

@@ -1,6 +1,6 @@
-import { ExcalidrawElement, NonDeletedExcalidrawElement } from "./element/types";
-import { BinaryFiles } from "./types";
-import { Spreadsheet } from "./charts";
+import type { ExcalidrawElement, NonDeletedExcalidrawElement } from "./element/types";
+import type { BinaryFiles } from "./types";
+import type { Spreadsheet } from "./charts";
 import { ALLOWED_PASTE_MIME_TYPES } from "./constants";
 export type PastedMixedContent = {
     type: "text" | "imageUrl";

package/dist/excalidraw/colors.d.ts

@@ -1,5 +1,5 @@
 import oc from "open-color";
-import { Merge } from "./utility-types";
+import type { Merge } from "./utility-types";
 export type ColorPickerColor = Exclude<keyof oc, "indigo" | "lime"> | "transparent" | "bronze";
 export type ColorTuple = readonly [string, string, string, string, string];
 export type ColorPalette = Merge<Record<ColorPickerColor, ColorTuple>, {

package/dist/excalidraw/components/Actions.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="react" />
-import { ActionManager } from "../actions/manager";
-import { ExcalidrawElement, NonDeletedElementsMap, NonDeletedSceneElementsMap } from "../element/types";
-import { AppClassProperties, AppProps, UIAppState, Zoom } from "../types";
+import type { ActionManager } from "../actions/manager";
+import type { ExcalidrawElement, NonDeletedElementsMap, NonDeletedSceneElementsMap } from "../element/types";
+import type { AppClassProperties, AppProps, UIAppState, Zoom } from "../types";
 import "./Actions.scss";
 export declare const canChangeStrokeColor: (appState: UIAppState, targetElements: ExcalidrawElement[]) => boolean;
 export declare const canChangeBackgroundColor: (appState: UIAppState, targetElements: ExcalidrawElement[]) => boolean;

package/dist/excalidraw/components/Actions.js

@@ -7,9 +7,9 @@ import { SHAPES } from "../shapes";
 import { capitalizeString, isTransparent } from "../utils";
 import Stack from "./Stack";
 import { ToolButton } from "./ToolButton";
-import { hasStrokeColor } from "../scene/comparisons";
+import { hasStrokeColor, toolIsArrow } from "../scene/comparisons";
 import { trackEvent } from "../analytics";
-import { hasBoundTextElement, isTextElement } from "../element/typeChecks";
+import { hasBoundTextElement, isElbowArrow, isLinearElement, isTextElement, } from "../element/typeChecks";
 import clsx from "clsx";
 import { actionToggleZenMode } from "../actions";
 import { Tooltip } from "./Tooltip";
@@ -53,6 +53,10 @@ export const SelectedShapeActions = ({ appState, elementsMap, renderAction, }) =
         !isTransparent(appState.currentItemBackgroundColor)) ||
         targetElements.some((element) => hasBackground(element.type) && !isTransparent(element.backgroundColor));
     const showLinkIcon = targetElements.length === 1 || isSingleElementBoundContainer;
+    const showLineEditorAction = !appState.editingLinearElement &&
+        targetElements.length === 1 &&
+        isLinearElement(targetElements[0]) &&
+        !isElbowArrow(targetElements[0]);
     return (_jsxs("div", { className: "panelColumn", children: [_jsx("div", { children: canChangeStrokeColor(appState, targetElements) &&
                     renderAction("changeStrokeColor") }), canChangeBackgroundColor(appState, targetElements) && (_jsx("div", { children: renderAction("changeBackgroundColor") })), showFillIcons && renderAction("changeFillStyle"), (hasStrokeWidth(appState.activeTool.type) ||
                 targetElements.some((element) => hasStrokeWidth(element.type))) &&
@@ -60,19 +64,20 @@ export const SelectedShapeActions = ({ appState, elementsMap, renderAction, }) =
                 targetElements.some((element) => element.type === "freedraw")) &&
                 renderAction("changeStrokeShape"), (hasStrokeStyle(appState.activeTool.type) ||
                 targetElements.some((element) => hasStrokeStyle(element.type))) && (_jsxs(_Fragment, { children: [renderAction("changeStrokeStyle"), renderAction("changeSloppiness")] })), (canChangeRoundness(appState.activeTool.type) ||
-                targetElements.some((element) => canChangeRoundness(element.type))) && (_jsx(_Fragment, { children: renderAction("changeRoundness") })), (appState.activeTool.type === "text" ||
-                targetElements.some(isTextElement)) && (_jsxs(_Fragment, { children: [renderAction("changeFontSize"), renderAction("changeFontFamily"), (appState.activeTool.type === "text" ||
+                targetElements.some((element) => canChangeRoundness(element.type))) && (_jsx(_Fragment, { children: renderAction("changeRoundness") })), (toolIsArrow(appState.activeTool.type) ||
+                targetElements.some((element) => toolIsArrow(element.type))) && (_jsx(_Fragment, { children: renderAction("changeArrowType") })), (appState.activeTool.type === "text" ||
+                targetElements.some(isTextElement)) && (_jsxs(_Fragment, { children: [renderAction("changeFontFamily"), renderAction("changeFontSize"), (appState.activeTool.type === "text" ||
                         suppportsHorizontalAlign(targetElements, elementsMap)) &&
                         renderAction("changeTextAlign")] })), shouldAllowVerticalAlign(targetElements, elementsMap) &&
                 renderAction("changeVerticalAlign"), (canHaveArrowheads(appState.activeTool.type) ||
-                targetElements.some((element) => canHaveArrowheads(element.type))) && (_jsx(_Fragment, { children: renderAction("changeArrowhead") })), renderAction("changeOpacity"), _jsxs("fieldset", { children: [_jsx("legend", { children: t("labels.layers") }), _jsxs("div", { className: "buttonList", children: [renderAction("sendToBack"), renderAction("sendBackward"), renderAction("bringToFront"), renderAction("bringForward")] })] }), targetElements.length > 1 && !isSingleElementBoundContainer && (_jsxs("fieldset", { children: [_jsx("legend", { children: t("labels.align") }), _jsxs("div", { className: "buttonList", children: [isRTL ? (_jsxs(_Fragment, { children: [renderAction("alignRight"), renderAction("alignHorizontallyCentered"), renderAction("alignLeft")] })) : (_jsxs(_Fragment, { children: [renderAction("alignLeft"), renderAction("alignHorizontallyCentered"), renderAction("alignRight")] })), targetElements.length > 2 &&
+                targetElements.some((element) => canHaveArrowheads(element.type))) && (_jsx(_Fragment, { children: renderAction("changeArrowhead") })), renderAction("changeOpacity"), _jsxs("fieldset", { children: [_jsx("legend", { children: t("labels.layers") }), _jsxs("div", { className: "buttonList", children: [renderAction("sendToBack"), renderAction("sendBackward"), renderAction("bringForward"), renderAction("bringToFront")] })] }), targetElements.length > 1 && !isSingleElementBoundContainer && (_jsxs("fieldset", { children: [_jsx("legend", { children: t("labels.align") }), _jsxs("div", { className: "buttonList", children: [isRTL ? (_jsxs(_Fragment, { children: [renderAction("alignRight"), renderAction("alignHorizontallyCentered"), renderAction("alignLeft")] })) : (_jsxs(_Fragment, { children: [renderAction("alignLeft"), renderAction("alignHorizontallyCentered"), renderAction("alignRight")] })), targetElements.length > 2 &&
                                 renderAction("distributeHorizontally"), _jsx("div", { style: { flexBasis: "100%", height: 0 } }), _jsxs("div", { style: {
                                     display: "flex",
                                     flexWrap: "wrap",
                                     gap: ".5rem",
                                     marginTop: "-0.5rem",
                                 }, children: [renderAction("alignTop"), renderAction("alignVerticallyCentered"), renderAction("alignBottom"), targetElements.length > 2 &&
-                                        renderAction("distributeVertically")] })] })] })), !isEditing && targetElements.length > 0 && (_jsxs("fieldset", { children: [_jsx("legend", { children: t("labels.actions") }), _jsxs("div", { className: "buttonList", children: [!device.editor.isMobile && renderAction("duplicateSelection"), !device.editor.isMobile && renderAction("deleteSelectedElements"), renderAction("group"), renderAction("ungroup"), showLinkIcon && renderAction("hyperlink")] })] }))] }));
+                                        renderAction("distributeVertically")] })] })] })), !isEditing && targetElements.length > 0 && (_jsxs("fieldset", { children: [_jsx("legend", { children: t("labels.actions") }), _jsxs("div", { className: "buttonList", children: [!device.editor.isMobile && renderAction("duplicateSelection"), !device.editor.isMobile && renderAction("deleteSelectedElements"), renderAction("group"), renderAction("ungroup"), showLinkIcon && renderAction("hyperlink"), showLineEditorAction && renderAction("toggleLinearEditor")] })] }))] }));
 };
 export const ShapesSwitcher = ({ activeTool, appState, app, UIOptions, }) => {
     const [isExtraToolsMenuOpen, setIsExtraToolsMenuOpen] = useState(false);
@@ -122,8 +127,8 @@ export const ShapesSwitcher = ({ activeTool, appState, app, UIOptions, }) => {
                                     fontSize: 8,
                                     fontFamily: "Cascadia, monospace",
                                     position: "absolute",
-                                    background: "pink",
-                                    color: "black",
+                                    background: "var(--color-promo)",
+                                    color: "var(--color-surface-lowest)",
                                     bottom: 3,
                                     right: 4,
                                 }, children: "AI" }))] }), _jsxs(DropdownMenu.Content, { onClickOutside: () => setIsExtraToolsMenuOpen(false), onSelect: () => setIsExtraToolsMenuOpen(false), className: "App-toolbar__extra-tools-dropdown", children: [_jsx(DropdownMenu.Item, { onSelect: () => app.setActiveTool({ type: "frame" }), icon: frameToolIcon, shortcut: KEYS.F.toLocaleUpperCase(), "data-testid": "toolbar-frame", selected: frameToolSelected, children: t("toolBar.frame") }), _jsx(DropdownMenu.Item, { onSelect: () => app.setActiveTool({ type: "embeddable" }), icon: EmbedIcon, "data-testid": "toolbar-embeddable", selected: embeddableToolSelected, children: t("toolBar.embeddable") }), _jsx(DropdownMenu.Item, { onSelect: () => app.setActiveTool({ type: "laser" }), icon: laserPointerToolIcon, "data-testid": "toolbar-laser", selected: laserToolSelected, shortcut: KEYS.K.toLocaleUpperCase(), children: t("toolBar.laser") }), _jsx("div", { style: { margin: "6px 0", fontSize: 14, fontWeight: 600 }, children: "Generate" }), app.props.aiEnabled !== false && _jsx(TTDDialogTriggerTunnel.Out, {}), _jsx(DropdownMenu.Item, { onSelect: () => app.setOpenDialog({ name: "ttd", tab: "mermaid" }), icon: mermaidLogoIcon, "data-testid": "toolbar-embeddable", children: t("toolBar.mermaidToExcalidraw") }), app.props.aiEnabled !== false && (_jsxs(_Fragment, { children: [_jsxs(DropdownMenu.Item, { onSelect: () => app.onMagicframeToolSelect(), icon: MagicIcon, "data-testid": "toolbar-magicframe", children: [t("toolBar.magicframe"), _jsx(DropdownMenu.Item.Badge, { children: "AI" })] }), _jsx(DropdownMenu.Item, { onSelect: () => {
@@ -137,7 +142,7 @@ export const ShapesSwitcher = ({ activeTool, appState, app, UIOptions, }) => {
 };
 export const ZoomActions = ({ renderAction, zoom, }) => (_jsx(Stack.Col, { gap: 1, className: "zoom-actions", children: _jsxs(Stack.Row, { align: "center", children: [renderAction("zoomOut"), renderAction("resetZoom"), renderAction("zoomIn")] }) }));
 export const UndoRedoActions = ({ renderAction, className, }) => (_jsxs("div", { className: `undo-redo-buttons ${className}`, children: [_jsx("div", { className: "undo-button-container", children: _jsx(Tooltip, { label: t("buttons.undo"), children: renderAction("undo") }) }), _jsx("div", { className: "redo-button-container", children: _jsxs(Tooltip, { label: t("buttons.redo"), children: [" ", renderAction("redo")] }) })] }));
-export const ExitZenModeAction = ({ actionManager, showExitZenModeBtn, }) => (_jsx("button", { className: clsx("disable-zen-mode", {
+export const ExitZenModeAction = ({ actionManager, showExitZenModeBtn, }) => (_jsx("button", { type: "button", className: clsx("disable-zen-mode", {
         "disable-zen-mode--visible": showExitZenModeBtn,
     }), onClick: () => actionManager.executeAction(actionToggleZenMode), children: t("buttons.exitZenMode") }));
 export const FinalizeAction = ({ renderAction, className, }) => (_jsx("div", { className: `finalize-button ${className}`, children: renderAction("finalize", { size: "small" }) }));

package/dist/excalidraw/components/App.d.ts

@@ -1,15 +1,16 @@
 import React from "react";
-import { RoughCanvas } from "roughjs/bin/canvas";
+import type { RoughCanvas } from "roughjs/bin/canvas";
 import { ActionManager } from "../actions/manager";
-import { EXPORT_IMAGE_TYPES } from "../constants";
-import { ExportedElements } from "../data";
+import type { ActionResult } from "../actions/types";
+import { type EXPORT_IMAGE_TYPES } from "../constants";
+import type { ExportedElements } from "../data";
 import { LinearElementEditor } from "../element/linearElementEditor";
-import { ExcalidrawElement, NonDeleted, NonDeletedExcalidrawElement, ExcalidrawFrameLikeElement, ExcalidrawIframeElement, ExcalidrawEmbeddableElement, Ordered } from "../element/types";
+import type { ExcalidrawElement, NonDeleted, NonDeletedExcalidrawElement, ExcalidrawFrameLikeElement, ExcalidrawIframeElement, ExcalidrawEmbeddableElement, Ordered } from "../element/types";
 import { History } from "../history";
 import Scene from "../scene/Scene";
-import { GeometricShape } from "../../utils/geometry/shape";
-import { AppClassProperties, AppProps, AppState, ExcalidrawImperativeAPI, BinaryFiles, LibraryItems, SceneData, Device, FrameNameBoundsCache, SidebarName, SidebarTabName, ToolType, OnUserFollowedPayload } from "../types";
-import { FileSystemHandle } from "../data/filesystem";
+import type { AppClassProperties, AppProps, AppState, ExcalidrawImperativeAPI, BinaryFiles, LibraryItems, SceneData, Device, FrameNameBoundsCache, SidebarName, SidebarTabName, ToolType, OnUserFollowedPayload } from "../types";
+import type { FileSystemHandle } from "../data/filesystem";
+import { Fonts } from "../fonts";
 import { Renderer } from "../scene/Renderer";
 import { Emitter } from "../emitter";
 import { Store } from "../store";
@@ -50,8 +51,8 @@ declare class App extends React.Component<AppProps, AppState> {
     device: Device;
     private excalidrawContainerRef;
     scene: Scene;
+    fonts: Fonts;
     renderer: Renderer;
-    private fonts;
     private resizeObserver;
     private nearestScrollableContainer;
     library: AppClassProperties["library"];
@@ -252,7 +253,8 @@ declare class App extends React.Component<AppProps, AppState> {
     private onMagicSettingsConfirm;
     onMagicframeToolSelect: () => void;
     private openEyeDropper;
-    private syncActionResult;
+    dismissLinearEditor: () => void;
+    syncActionResult: (actionResult: ActionResult) => void;
     private onBlur;
     private onUnload;
     private disableEvent;
@@ -342,10 +344,10 @@ declare class App extends React.Component<AppProps, AppState> {
         elements?: SceneData["elements"];
         appState?: Pick<AppState, K> | null | undefined;
         collaborators?: SceneData["collaborators"];
-        /** @default StoreAction.CAPTURE */
+        /** @default StoreAction.NONE */
         storeAction?: SceneData["storeAction"];
     }) => void;
-    private onSceneUpdated;
+    private triggerRender;
     /**
      * @returns whether the menu was toggled on or off
      */
@@ -387,12 +389,6 @@ declare class App extends React.Component<AppProps, AppState> {
     private handleTextWysiwyg;
     private deselectElements;
     private getTextElementAtPosition;
-    /**
-     * get the pure geometric shape of an excalidraw element
-     * which is then used for hit detection
-     */
-    getElementShape(element: ExcalidrawElement): GeometricShape;
-    private getBoundTextShape;
     private getElementAtPosition;
     private getElementsAtPosition;
     private getElementHitThreshold;
@@ -494,6 +490,7 @@ declare class App extends React.Component<AppProps, AppState> {
 declare global {
     interface Window {
         h: {
+            scene: Scene;
             elements: readonly ExcalidrawElement[];
             state: AppState;
             setState: React.Component<any, AppState>["setState"];