@excalidraw/common 0.18.0-abeeaeb → 0.18.0-afa3a65

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

@@ -3,6 +3,7 @@ import { AppEventBus, type EXPORT_IMAGE_TYPES, Emitter, type EditorInterface, ty
 import { LinearElementEditor, Scene, Store, type ElementUpdate, StoreDelta, type ApplyToOptions } from "@excalidraw/element";
 import type { LocalPoint, Radians } from "@excalidraw/math";
 import type { ExcalidrawElement, ExcalidrawTextElement, NonDeleted, NonDeletedExcalidrawElement, ExcalidrawTextContainer, ExcalidrawFrameLikeElement, ExcalidrawIframeElement, ExcalidrawEmbeddableElement, Ordered, SceneElementsMap } from "@excalidraw/element/types";
+import type { ArrowEndpoint, TransformHandleDirection } from "@excalidraw/element";
 import type { Mutable } from "@excalidraw/common/utility-types";
 import { ActionManager } from "../actions/manager";
 import { History } from "../history";
@@ -16,6 +17,7 @@ import { LassoTrail } from "../lasso";
 import { EraserTrail } from "../eraser";
 import { AppArrowText } from "./App.arrowText";
 import { AppBucketFill } from "./App.bucketFill";
+import { AppToolDrag } from "./App.toolDrag";
 import { AppCursor } from "./App.cursor";
 import { AppDrawShape } from "./App.drawshape";
 import { AppFlowchart } from "./App.flowchart";
@@ -82,6 +84,8 @@ declare class App extends React.Component<AppProps, AppState> {
     editorInterface: EditorInterface;
     private stylesPanelMode;
     private excalidrawContainerRef;
+    get ownerDocument(): Document;
+    get ownerWindow(): Window & typeof globalThis;
     scene: Scene;
     fonts: Fonts;
     renderer: Renderer;
@@ -93,7 +97,7 @@ declare class App extends React.Component<AppProps, AppState> {
     library: AppClassProperties["library"];
     libraryItemsFromStorage: LibraryItems | undefined;
     id: string;
-    private store;
+    store: Store;
     private history;
     excalidrawContainerValue: {
         container: HTMLDivElement | null;
@@ -119,6 +123,7 @@ declare class App extends React.Component<AppProps, AppState> {
     private appStateObserver;
     onStateChange: OnStateChange;
     bucketFill: AppBucketFill;
+    toolDrag: AppToolDrag;
     flowchart: AppFlowchart;
     cursor: AppCursor;
     arrowText: AppArrowText;
@@ -127,6 +132,13 @@ declare class App extends React.Component<AppProps, AppState> {
     private textWysiwygSubmitHandler;
     hitLinkElement?: NonDeletedExcalidrawElement;
     lastPointerDownEvent: React.PointerEvent<HTMLElement> | null;
+    /**
+     * the handle of the resize in progress while `state.isResizing` — for UI
+     * that words itself by handle (a sticky note's corners resize
+     * proportionally, its edges freely); not app state, so it costs no
+     * re-render of its own
+     */
+    activeResizeHandle: TransformHandleDirection | null;
     lastPointerUpEvent: React.PointerEvent<HTMLElement> | PointerEvent | null;
     lastPointerUpIsDoubleClick: boolean;
     lastPointerMoveEvent: PointerEvent | null;
@@ -185,6 +197,7 @@ declare class App extends React.Component<AppProps, AppState> {
             wasAddedToSelection: boolean;
             hasBeenDuplicated: boolean;
             hasHitCommonBoundingBoxOfSelectedElements: boolean;
+            arrowLabel: boolean;
         };
         withCmdOrCtrl: boolean;
         drag: {
@@ -247,6 +260,7 @@ declare class App extends React.Component<AppProps, AppState> {
             wasAddedToSelection: boolean;
             hasBeenDuplicated: boolean;
             hasHitCommonBoundingBoxOfSelectedElements: boolean;
+            arrowLabel: boolean;
         };
         withCmdOrCtrl: boolean;
         drag: {
@@ -363,6 +377,11 @@ declare class App extends React.Component<AppProps, AppState> {
     getEffectiveGridSize: () => NullableGridSize;
     private getTextCreationGridPoint;
     private getHTMLIFrameElement;
+    /**
+     * AI-generated iframe elements aren't interactive while their generation
+     * is still in progress (the partial content is render-only).
+     */
+    private isIframeLikeInteractive;
     private handleIframeLikeElementHover;
     /** @returns true if iframe-like element click handled */
     private handleIframeLikeCenterClick;
@@ -571,9 +590,12 @@ declare class App extends React.Component<AppProps, AppState> {
     }) & {
         preferSelected?: boolean;
     }): NonDeleted<ExcalidrawElement> | null;
-    private getElementsAtPosition;
+    getElementsAtPosition(x: number, y: number, opts?: {
+        includeBoundTextElement?: boolean;
+        includeLockedElements?: boolean;
+    }): NonDeleted<ExcalidrawElement>[];
     getElementHitThreshold(element: ExcalidrawElement): number;
-    private hitElement;
+    hitElement(x: number, y: number, element: NonDeletedExcalidrawElement, considerBoundingBox?: boolean): boolean;
     getTextBindableContainerAtPosition(x: number, y: number): (Readonly<{
         id: string;
         x: number;
@@ -601,6 +623,7 @@ declare class App extends React.Component<AppProps, AppState> {
         frameId: string | null;
         boundElements: readonly import("@excalidraw/element/types").BoundElement[] | null;
         updated: number;
+        created: number | null;
         link: string | null;
         locked: boolean;
         customData?: Record<string, any>;
@@ -635,6 +658,43 @@ declare class App extends React.Component<AppProps, AppState> {
         frameId: string | null;
         boundElements: readonly import("@excalidraw/element/types").BoundElement[] | null;
         updated: number;
+        created: number | null;
+        link: string | null;
+        locked: boolean;
+        customData?: Record<string, any>;
+    }> & Readonly<{
+        type: "stickynote";
+        baseHeight: number;
+    }> & {
+        isDeleted: false;
+    }) | (Readonly<{
+        id: string;
+        x: number;
+        y: number;
+        strokeColor: string;
+        backgroundColor: string;
+        fillStyle: import("@excalidraw/element/types").FillStyle;
+        strokeWidth: number;
+        strokeStyle: import("@excalidraw/element/types").StrokeStyle;
+        roundness: null | {
+            type: import("@excalidraw/element/types").RoundnessType;
+            value?: number;
+        };
+        roughness: number;
+        opacity: number;
+        width: number;
+        height: number;
+        angle: Radians;
+        seed: number;
+        version: number;
+        versionNonce: number;
+        index: import("@excalidraw/element/types").FractionalIndex | null;
+        isDeleted: boolean;
+        groupIds: readonly import("@excalidraw/element/types").GroupId[];
+        frameId: string | null;
+        boundElements: readonly import("@excalidraw/element/types").BoundElement[] | null;
+        updated: number;
+        created: number | null;
         link: string | null;
         locked: boolean;
         customData?: Record<string, any>;
@@ -669,6 +729,7 @@ declare class App extends React.Component<AppProps, AppState> {
         frameId: string | null;
         boundElements: readonly import("@excalidraw/element/types").BoundElement[] | null;
         updated: number;
+        created: number | null;
         link: string | null;
         locked: boolean;
         customData?: Record<string, any>;
@@ -703,6 +764,7 @@ declare class App extends React.Component<AppProps, AppState> {
         frameId: string | null;
         boundElements: readonly import("@excalidraw/element/types").BoundElement[] | null;
         updated: number;
+        created: number | null;
         link: string | null;
         locked: boolean;
         customData?: Record<string, any>;
@@ -731,7 +793,25 @@ declare class App extends React.Component<AppProps, AppState> {
      * so the whole create-and-type lands in a single entry.
      */
     private isEditingTextContent;
-    private startTextEditing;
+    startTextEditing: ({ sceneX, sceneY, insertAtParentCenter, container, autoEdit, initialCaretSceneCoords, arrowEndpoint, }: {
+        /** X position to insert text at */
+        sceneX: number;
+        /** Y position to insert text at */
+        sceneY: number;
+        /** whether to attempt to insert at element center if applicable */
+        insertAtParentCenter?: boolean;
+        container?: ExcalidrawTextContainer | null;
+        autoEdit?: boolean;
+        initialCaretSceneCoords?: {
+            x: number;
+            y: number;
+        };
+        /**
+         * creates the text as a label for this arrow endpoint: the binding then
+         * dictates the text's position and alignment, overriding (sceneX, sceneY)
+         */
+        arrowEndpoint?: ArrowEndpoint | null;
+    }) => void;
     private startImageCropping;
     private finishImageCropping;
     private shouldHandleBrowserCanvasDoubleClick;
@@ -784,6 +864,10 @@ declare class App extends React.Component<AppProps, AppState> {
     private handleCanvasPointerMove;
     private handleEraser;
     private handleTouchMove;
+    /**
+     * Applies the hover affordances of a selected linear element: the cursor,
+     * plus the hovered-handle state that renders them highlighted.
+     */
     handleHoverSelectedLinearElement(linearElementEditor: LinearElementEditor, scenePointerX: number, scenePointerY: number): void;
     private handleCanvasPointerDown;
     private handleCanvasPointerUp;
@@ -826,8 +910,10 @@ declare class App extends React.Component<AppProps, AppState> {
     }) => NonDeleted<ExcalidrawEmbeddableElement> | undefined;
     private newImagePlaceholder;
     private handleLinearElementOnPointerDown;
-    private getCurrentItemRoundness;
-    private getCurrentItemStrokeWidth;
+    getCurrentItemRoundness(elementType: "selection" | "rectangle" | "stickynote" | "diamond" | "ellipse" | "iframe" | "embeddable"): {
+        type: 2 | 3;
+    } | null;
+    getCurrentItemStrokeWidth(elementType: ExcalidrawElement["type"]): number;
     private createGenericElementOnPointerDown;
     private createFrameElementOnPointerDown;
     private maybeCacheReferenceSnapPoints;

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

@@ -0,0 +1,63 @@
+import type { ExcalidrawNonSelectionElement, NonDeleted } from "@excalidraw/element/types";
+import type App from "./App";
+import type { ToolType } from "../types";
+type ScenePoint = {
+    x: number;
+    y: number;
+};
+/** what a drag places: any element the new-element canvas can preview */
+type DraggedElement = NonDeleted<ExcalidrawNonSelectionElement>;
+/**
+ * A tool the user can drag out of the toolbar to drop a default-sized element
+ * where the pointer is released.
+ */
+type DraggableTool = {
+    /** the element the drop creates, centered on the pointer */
+    createElement: (app: App, center: ScenePoint) => DraggedElement;
+    /** what the tool does once its element is on the canvas (e.g. start editing) */
+    onDrop?: (app: App, element: DraggedElement) => void;
+};
+/**
+ * The tools that can be dragged out of the toolbar. Add an entry to make a
+ * tool's button draggable — the gesture, preview and drop are shared.
+ */
+export declare const DRAGGABLE_TOOLS: Partial<Record<ToolType, DraggableTool>>;
+/** CSS opacity of the preview canvas while dragging */
+export declare const TOOL_DRAG_PREVIEW_OPACITY = 0.5;
+/**
+ * Dragging a tool out of the toolbar. The preview element exists only here
+ * until the drop — it is not in the scene, the store or the history, so
+ * collaborators never see it and an aborted drag leaves nothing behind. It
+ * is painted by the `NewElementCanvas`, drawn exactly as it will land, with
+ * the canvas itself made translucent.
+ *
+ * The button arms on pointerdown; the drag starts once the pointer has
+ * moved `DRAGGING_THRESHOLD`, so a plain click still selects the tool. The
+ * gesture lives on the owner window (the pointer leaves the button at once),
+ * like the other pointer gestures in `App`.
+ */
+export declare class AppToolDrag {
+    private app;
+    constructor(app: App);
+    /** the element under the pointer while dragging, `null` otherwise */
+    preview: DraggedElement | null;
+    private armed;
+    private tool;
+    private type;
+    static isDraggable: (type: ToolType) => boolean;
+    isDragging: () => boolean;
+    /**
+     * Arm a drag from a tool button's pointerdown. Returns whether the tool is
+     * draggable (the caller lets a non-draggable press fall through).
+     */
+    handleButtonPointerDown: (type: ToolType, event: PointerEvent) => boolean;
+    private onPointerMove;
+    private onPointerUp;
+    private onKeyDown;
+    /** drop the gesture without a trace */
+    cancel: () => void;
+    private isOverCanvas;
+    private addListeners;
+    private removeListeners;
+}
+export {};

package/dist/types/excalidraw/components/IconButton.d.ts

@@ -41,6 +41,8 @@ type IconButtonProps = (IconButtonBaseProps & {
     onSelect?(data: {
         pointerType: PointerType | null;
     }): void;
+    /** the press that may become a click — e.g. to arm a drag out of the toolbar */
+    onPointerDown?(event: React.PointerEvent<HTMLButtonElement>): void;
 });
 export declare const IconButton: React.ForwardRefExoticComponent<IconButtonProps & React.RefAttributes<unknown>>;
 export {};

package/dist/types/excalidraw/components/Tools.d.ts

@@ -1,7 +1,7 @@
 import type { AppClassProperties, AppState, ToolType, UIAppState } from "../types";
 export type ToolConfig = {
     icon: React.ReactNode;
-    /** letter shortcut(s) — the first one is shown in tooltips */
+    /** letter shortcut(s) — the first one is shown in tooltips and badges */
     letterKey?: string | readonly string[];
     /** whether `letterKey` requires Shift to be held (e.g. Shift+X) */
     shiftKey?: boolean;
@@ -31,6 +31,7 @@ export declare const TOOLS: {
     line: ToolConfig;
     freedraw: ToolConfig;
     text: ToolConfig;
+    stickynote: ToolConfig;
     image: ToolConfig;
     eraser: ToolConfig;
     frame: ToolConfig;
@@ -49,7 +50,7 @@ export declare const TOGGLE_TOOLS: readonly (ToolType | "custom")[];
 export declare const getToolLetter: (type: ToolbarToolType) => string | undefined;
 /** human-readable shortcut hint, e.g. "R or 2", used in tooltips & aria */
 export declare const getToolShortcut: (type: ToolbarToolType) => string;
-export declare const findShapeByKey: (key: string, app: AppClassProperties, shiftKey?: boolean) => "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "embeddable" | "image" | "frame" | "freedraw" | "lasso" | "eraser" | "hand" | "laser" | "autoshape" | "bucketfill" | null;
+export declare const findShapeByKey: (key: string, app: AppClassProperties, shiftKey?: boolean) => "line" | "arrow" | "text" | "selection" | "rectangle" | "stickynote" | "diamond" | "ellipse" | "embeddable" | "image" | "frame" | "freedraw" | "lasso" | "eraser" | "hand" | "laser" | "autoshape" | "bucketfill" | null;
 /**
  * Whether a toolbar entry activating the given tool renders disabled — true
  * when the active tool is host-controlled (`props.activeTool`) and the entry
@@ -99,6 +100,10 @@ export declare const TextToolButton: {
     ({ app, activeTool, hideKeyBinding, hideShortcut, }: ToolButtonComponentProps): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
+export declare const StickyNoteToolButton: {
+    ({ app, activeTool, hideKeyBinding, hideShortcut, }: ToolButtonComponentProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
 export declare const ImageToolButton: {
     ({ app, activeTool, hideKeyBinding, hideShortcut, }: ToolButtonComponentProps): import("react/jsx-runtime").JSX.Element;
     displayName: string;

package/dist/types/excalidraw/components/canvases/NewElementCanvas.d.ts

@@ -10,6 +10,8 @@ interface NewElementCanvasProps {
     scale: number;
     rc: RoughCanvas;
     renderConfig: StaticCanvasRenderConfig;
+    /** CSS opacity of the whole canvas — a translucent preview of a finished element */
+    opacity?: number;
 }
 declare const NewElementCanvas: (props: NewElementCanvasProps) => import("react/jsx-runtime").JSX.Element;
 export default NewElementCanvas;

package/dist/types/excalidraw/components/icons.d.ts

@@ -200,6 +200,7 @@ export declare const alertTriangleIcon: import("react/jsx-runtime").JSX.Element;
 export declare const eyeDropperIconSvgPaths: readonly ["M4 16l11.7 -11.7a1 1 0 0 1 1.4 0l2.6 2.6a1 1 0 0 1 0 1.4l-11.7 11.7h-4v-4z", "M11 7l6 6"];
 export declare const eyeDropperIcon: import("react/jsx-runtime").JSX.Element;
 export declare const frameToolIcon: import("react/jsx-runtime").JSX.Element;
+export declare const stickyNoteToolIcon: import("react/jsx-runtime").JSX.Element;
 export declare const mermaidLogoIcon: import("react/jsx-runtime").JSX.Element;
 export declare const RetryIcon: import("react/jsx-runtime").JSX.Element;
 export declare const stackPushIcon: import("react/jsx-runtime").JSX.Element;

package/dist/types/excalidraw/components/shapeActionPredicates.d.ts

@@ -1,7 +1,7 @@
-import type { ExcalidrawElement, NonDeletedElementsMap, NonDeletedSceneElementsMap } from "@excalidraw/element/types";
+import type { ElementsMap, ExcalidrawElement, NonDeletedElementsMap, NonDeletedSceneElementsMap } from "@excalidraw/element/types";
 import type { AppClassProperties, UIAppState } from "../types";
 export declare const canChangeStrokeColor: (appState: UIAppState, targetElements: ExcalidrawElement[]) => boolean;
-export declare const canChangeBackgroundColor: (appState: UIAppState, targetElements: ExcalidrawElement[]) => boolean;
+export declare const canChangeBackgroundColor: (appState: UIAppState, targetElements: ExcalidrawElement[], elementsMap: ElementsMap) => boolean;
 /**
  * Single source of truth for "which shape-action controls are relevant right
  * now". Each flag answers whether a given control should be shown, given the

package/dist/types/excalidraw/data/blob.d.ts

@@ -82,6 +82,8 @@ fileHandle?: FileSystemFileHandle | null) => Promise<{
             exportWithDarkMode: boolean;
             exportScale: number;
             currentItemStrokeColor: string;
+            currentItemStickynoteStrokeColor: string;
+            currentItemStickynoteBackgroundColor: string;
             currentItemBackgroundColor: string;
             currentItemFillStyle: ExcalidrawElement["fillStyle"];
             currentItemStrokeWidthKey: import("@excalidraw/common").StrokeWidthKey;
@@ -179,6 +181,8 @@ fileHandle?: FileSystemFileHandle | null) => Promise<{
                 elementStroke: readonly string[] | null;
                 elementBackground: readonly string[] | null;
                 bucketFill: readonly string[] | null;
+                stickyNoteStroke: readonly string[] | null;
+                stickyNoteBackground: readonly string[] | null;
             };
         };
         files: import("../types").BinaryFiles;
@@ -256,6 +260,8 @@ fileHandle?: FileSystemFileHandle | null) => Promise<{
         exportWithDarkMode: boolean;
         exportScale: number;
         currentItemStrokeColor: string;
+        currentItemStickynoteStrokeColor: string;
+        currentItemStickynoteBackgroundColor: string;
         currentItemBackgroundColor: string;
         currentItemFillStyle: ExcalidrawElement["fillStyle"];
         currentItemStrokeWidthKey: import("@excalidraw/common").StrokeWidthKey;
@@ -353,6 +359,8 @@ fileHandle?: FileSystemFileHandle | null) => Promise<{
             elementStroke: readonly string[] | null;
             elementBackground: readonly string[] | null;
             bucketFill: readonly string[] | null;
+            stickyNoteStroke: readonly string[] | null;
+            stickyNoteBackground: readonly string[] | null;
         };
     };
     files: import("../types").BinaryFiles;

package/dist/types/excalidraw/data/json.d.ts

@@ -80,6 +80,8 @@ export declare const loadFromJSON: (localAppState: AppState, localElements: read
         exportWithDarkMode: boolean;
         exportScale: number;
         currentItemStrokeColor: string;
+        currentItemStickynoteStrokeColor: string;
+        currentItemStickynoteBackgroundColor: string;
         currentItemBackgroundColor: string;
         currentItemFillStyle: ExcalidrawElement["fillStyle"];
         currentItemStrokeWidthKey: import("@excalidraw/common").StrokeWidthKey;
@@ -177,6 +179,8 @@ export declare const loadFromJSON: (localAppState: AppState, localElements: read
             elementStroke: readonly string[] | null;
             elementBackground: readonly string[] | null;
             bucketFill: readonly string[] | null;
+            stickyNoteStroke: readonly string[] | null;
+            stickyNoteBackground: readonly string[] | null;
         };
     };
     files: BinaryFiles;

package/dist/types/excalidraw/fonts/Fonts.d.ts

@@ -15,7 +15,8 @@ export declare class Fonts {
         fontFaces: ExcalidrawFontFace[];
     }>;
     private readonly scene;
-    constructor(scene: Scene);
+    private readonly ownerDocument;
+    constructor(scene: Scene, ownerDocument?: Document);
     /**
      * Get all the font families for the given scene.
      */
@@ -36,7 +37,7 @@ export declare class Fonts {
     /**
      * Load font faces for passed elements - use when the scene is unavailable (i.e. export).
      */
-    static loadElementsFonts: (elements: readonly ExcalidrawElement[]) => Promise<FontFace[]>;
+    static loadElementsFonts: (elements: readonly ExcalidrawElement[], ownerDocument?: Document) => Promise<FontFace[]>;
     /**
      * Generate CSS @font-face declarations for the given elements.
      */

package/dist/types/excalidraw/hooks/useTextEditorFocus.d.ts

@@ -2,13 +2,13 @@ export type CaretPosition = {
     start: number;
     end: number;
 };
-export declare const saveCaretPosition: () => CaretPosition | null;
-export declare const restoreCaretPosition: (position: CaretPosition | null) => void;
-export declare const withCaretPositionPreservation: (callback: () => void, isCompactMode: boolean, isEditingText: boolean, onPreventClose?: () => void) => void;
-export declare const useTextEditorFocus: () => {
+export declare const saveCaretPosition: (ownerDocument?: Document) => CaretPosition | null;
+export declare const restoreCaretPosition: (position: CaretPosition | null, ownerDocument?: Document) => void;
+export declare const withCaretPositionPreservation: (callback: () => void, isCompactMode: boolean, isEditingText: boolean, onPreventClose?: () => void, ownerDocument?: Document) => void;
+export declare const useTextEditorFocus: (ownerDocument?: Document) => {
     saveCaretPosition: () => void;
     restoreCaretPosition: () => void;
     clearSavedPosition: () => void;
     hasSavedPosition: boolean;
 };
-export declare const temporarilyDisableTextEditorBlur: (duration?: number) => void;
+export declare const temporarilyDisableTextEditorBlur: (ownerDocument?: Document, duration?: number) => void;

package/dist/types/excalidraw/renderer/helpers.d.ts

@@ -1,6 +1,31 @@
 import type { StaticCanvasRenderConfig } from "../scene/types";
 import type { AppState, StaticCanvasAppState } from "../types";
+export declare const DEFAULT_SELECTION_COLOR = "#6965db";
+/**
+ * Returns the theme's selection color (`--color-selection`), read from the
+ * computed style of any element inside the editor container so that host
+ * overrides are respected. Falls back to the default when unavailable.
+ */
+export declare const getSelectionColor: (element: Element | null | undefined) => string;
 export declare const fillCircle: (context: CanvasRenderingContext2D, cx: number, cy: number, radius: number, stroke: boolean, fill?: boolean) => void;
+/**
+ * The scroll the renderers draw at: the real one, rounded to whole device
+ * pixels. Panning writes a fractional scroll (pointer delta ÷ zoom), and an
+ * element's cached bitmap blitted at a fractional device offset gets
+ * resampled — so as the fraction drifts under a pan, every element pulses
+ * between crisp and soft. A whole-pixel scroll moves the scene the way a
+ * browser scrolls a page: each element keeps its own, constant sub-pixel
+ * phase and a pan never changes how anything is filtered. The difference
+ * stays under half a device pixel, so hit-testing and DOM overlays keep
+ * using the real scroll. Identity when nothing needs to change.
+ */
+export declare const snapScrollToDevicePixels: <T extends {
+    scrollX: number;
+    scrollY: number;
+    zoom: {
+        value: number;
+    };
+}>(appState: T, scale: number) => T;
 export declare const getNormalizedCanvasDimensions: (canvas: HTMLCanvasElement, scale: number) => [number, number];
 export declare const bootstrapCanvas: ({ canvas, scale, normalizedWidth, normalizedHeight, theme, isExporting, viewBackgroundColor, }: {
     canvas: HTMLCanvasElement;

package/dist/types/excalidraw/renderer/interactiveScene.d.ts

@@ -1,6 +1,6 @@
 import { getScrollBars } from "../scene/scrollbars";
 import type { InteractiveSceneRenderConfig } from "../scene/types";
-declare const _renderInteractiveScene: ({ app, canvas, elementsMap, visibleElements, selectedElements, allElementsMap, scale, appState, renderConfig, editorInterface, animationState, deltaTime, }: InteractiveSceneRenderConfig) => {
+declare const _renderInteractiveScene: ({ app, canvas, elementsMap, visibleElements, selectedElements, allElementsMap, scale, appState: unsnappedAppState, renderConfig, editorInterface, animationState, deltaTime, }: InteractiveSceneRenderConfig) => {
     scrollBars?: ReturnType<typeof getScrollBars>;
     animationState?: typeof animationState;
 };

package/dist/types/excalidraw/scene/Renderer.d.ts

@@ -53,6 +53,7 @@ export declare class Renderer {
             frameId: string | null;
             boundElements: readonly import("@excalidraw/element/types").BoundElement[] | null;
             updated: number;
+            created: number | null;
             link: string | null;
             locked: boolean;
             customData?: Record<string, any>;
@@ -92,6 +93,7 @@ export declare class Renderer {
             frameId: string | null;
             boundElements: readonly import("@excalidraw/element/types").BoundElement[] | null;
             updated: number;
+            created: number | null;
             link: string | null;
             locked: boolean;
             customData?: Record<string, any>;
@@ -126,6 +128,43 @@ export declare class Renderer {
             frameId: string | null;
             boundElements: readonly import("@excalidraw/element/types").BoundElement[] | null;
             updated: number;
+            created: number | null;
+            link: string | null;
+            locked: boolean;
+            customData?: Record<string, any>;
+        }> & Readonly<{
+            type: "stickynote";
+            baseHeight: number;
+        }> & {
+            isDeleted: false;
+        }) | (Readonly<{
+            id: string;
+            x: number;
+            y: number;
+            strokeColor: string;
+            backgroundColor: string;
+            fillStyle: import("@excalidraw/element/types").FillStyle;
+            strokeWidth: number;
+            strokeStyle: import("@excalidraw/element/types").StrokeStyle;
+            roundness: null | {
+                type: import("@excalidraw/element/types").RoundnessType;
+                value?: number;
+            };
+            roughness: number;
+            opacity: number;
+            width: number;
+            height: number;
+            angle: import("@excalidraw/math").Radians;
+            seed: number;
+            version: number;
+            versionNonce: number;
+            index: import("@excalidraw/element/types").FractionalIndex | null;
+            isDeleted: boolean;
+            groupIds: readonly import("@excalidraw/element/types").GroupId[];
+            frameId: string | null;
+            boundElements: readonly import("@excalidraw/element/types").BoundElement[] | null;
+            updated: number;
+            created: number | null;
             link: string | null;
             locked: boolean;
             customData?: Record<string, any>;
@@ -160,6 +199,7 @@ export declare class Renderer {
             frameId: string | null;
             boundElements: readonly import("@excalidraw/element/types").BoundElement[] | null;
             updated: number;
+            created: number | null;
             link: string | null;
             locked: boolean;
             customData?: Record<string, any>;
@@ -194,6 +234,7 @@ export declare class Renderer {
             frameId: string | null;
             boundElements: readonly import("@excalidraw/element/types").BoundElement[] | null;
             updated: number;
+            created: number | null;
             link: string | null;
             locked: boolean;
             customData?: Record<string, any>;
@@ -228,6 +269,7 @@ export declare class Renderer {
             frameId: string | null;
             boundElements: readonly import("@excalidraw/element/types").BoundElement[] | null;
             updated: number;
+            created: number | null;
             link: string | null;
             locked: boolean;
             customData?: Record<string, any>;
@@ -265,6 +307,7 @@ export declare class Renderer {
             frameId: string | null;
             boundElements: readonly import("@excalidraw/element/types").BoundElement[] | null;
             updated: number;
+            created: number | null;
             link: string | null;
             locked: boolean;
             customData?: Record<string, any>;
@@ -303,6 +346,7 @@ export declare class Renderer {
             frameId: string | null;
             boundElements: readonly import("@excalidraw/element/types").BoundElement[] | null;
             updated: number;
+            created: number | null;
             link: string | null;
             locked: boolean;
             customData?: Record<string, any>;
@@ -338,6 +382,7 @@ export declare class Renderer {
             frameId: string | null;
             boundElements: readonly import("@excalidraw/element/types").BoundElement[] | null;
             updated: number;
+            created: number | null;
             link: string | null;
             locked: boolean;
             customData?: Record<string, any>;
@@ -373,6 +418,7 @@ export declare class Renderer {
             frameId: string | null;
             boundElements: readonly import("@excalidraw/element/types").BoundElement[] | null;
             updated: number;
+            created: number | null;
             link: string | null;
             locked: boolean;
             customData?: Record<string, any>;
@@ -380,15 +426,17 @@ export declare class Renderer {
             type: "text";
             fontSize: number;
             fontFamily: import("@excalidraw/element/types").FontFamilyValues;
+            baseFontSize: number | null;
             text: string;
             textAlign: import("@excalidraw/element/types").TextAlign;
             verticalAlign: import("@excalidraw/element/types").VerticalAlign;
-            containerId: import("@excalidraw/element/types").ExcalidrawGenericElement["id"] | null;
+            containerId: import("@excalidraw/element/types").ExcalidrawTextContainer["id"] | null;
             originalText: string;
             autoResize: boolean;
             lineHeight: number & {
                 _brand: "unitlessLineHeight";
             };
+            labelPosition?: number | null;
         }> & {
             isDeleted: false;
         }) | (Readonly<{
@@ -418,6 +466,7 @@ export declare class Renderer {
             frameId: string | null;
             boundElements: readonly import("@excalidraw/element/types").BoundElement[] | null;
             updated: number;
+            created: number | null;
             link: string | null;
             locked: boolean;
             customData?: Record<string, any>;

package/dist/types/excalidraw/scene/index.d.ts

@@ -1,4 +1,4 @@
 export { isSomeElementSelected, getElementsWithinSelection, getSelectedElements, getTargetElements, } from "@excalidraw/element";
 export { getScrollToContentState } from "../viewport";
-export { hasBackground, hasStrokeWidth, hasStrokeStyle, hasFreedrawMode, canHaveArrowheads, canChangeRoundness, } from "@excalidraw/element";
+export { hasBackground, hasFillStyle, hasRoughness, hasStrokeWidth, hasStrokeStyle, hasFreedrawMode, canHaveArrowheads, canChangeRoundness, } from "@excalidraw/element";
 export { getNormalizedZoom, getNormalizedGridSize, getNormalizedGridStep, } from "./normalize";

package/dist/types/excalidraw/scene/types.d.ts

@@ -132,6 +132,7 @@ export type ElementShapes = {
     arrow: Drawable[];
     line: Drawable[];
     text: null;
+    stickynote: null;
     image: null;
     frame: null;
     magicframe: null;