@excalidraw/common 0.18.0-4a5c9e9 → 0.18.0-4ce38fb

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

@@ -0,0 +1,9 @@
+import type { ElementRenderOffsets, ElementRenderOverrides } from "./types";
+/** Validate and copy before publishing, so a rejected snapshot changes nothing. */
+export declare const copyElementRenderOverrides: (overrides: ElementRenderOverrides | null) => ElementRenderOverrides;
+/**
+ * Extracts the offsets of a snapshot, returning `previous` when they are the
+ * same. Visibility is memoized on this map's identity, so a snapshot that only
+ * changes opacities (a fade) never re-runs viewport geometry.
+ */
+export declare const getElementRenderOffsets: (overrides: ElementRenderOverrides, previous: ElementRenderOffsets) => ElementRenderOffsets;

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

@@ -3,10 +3,14 @@ export type Animation<R extends object> = (params: {
     state?: R;
 }) => R | null | undefined;
 export declare class AnimationController {
-    private static isRunning;
+    private static scheduledFrame;
     private static animations;
     static start<R extends object>(key: string, animation: Animation<R>): void;
+    private static scheduleNextFrame;
+    private static cancelScheduledFrame;
+    private static cancelScheduledFrameIfIdle;
     private static tick;
     static running(key: string): boolean;
     static cancel(key: string): void;
+    static reset(): 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,9 +1,7 @@
 import { getScrollBars } from "../scene/scrollbars";
-import type { InteractiveSceneRenderConfig, RenderableElementsMap } from "../scene/types";
-declare const _renderInteractiveScene: ({ app, canvas, elementsMap, visibleElements, selectedElements, allElementsMap, scale, appState, renderConfig, editorInterface, animationState, deltaTime, }: InteractiveSceneRenderConfig) => {
+import type { InteractiveSceneRenderConfig } from "../scene/types";
+declare const _renderInteractiveScene: ({ app, canvas, elementsMap, visibleElements, selectedElements, allElementsMap, scale, appState: unsnappedAppState, renderConfig, editorInterface, animationState, deltaTime, }: InteractiveSceneRenderConfig) => {
     scrollBars?: ReturnType<typeof getScrollBars>;
-    atLeastOneVisibleElement: boolean;
-    elementsMap: RenderableElementsMap;
     animationState?: typeof animationState;
 };
 /**

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

@@ -1,30 +1,499 @@
-import type { ExcalidrawElement, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
+import type { NonDeletedExcalidrawElement } from "@excalidraw/element/types";
 import type { Scene } from "@excalidraw/element";
 import type { RenderableElementsMap } from "./types";
-import type { AppState } from "../types";
+import type { AppState, ElementRenderOffsets } from "../types";
+type GetRenderableElementsOpts = {
+    zoom: AppState["zoom"];
+    offsetLeft: AppState["offsetLeft"];
+    offsetTop: AppState["offsetTop"];
+    scrollX: AppState["scrollX"];
+    scrollY: AppState["scrollY"];
+    height: AppState["height"];
+    width: AppState["width"];
+    editingTextElement: AppState["editingTextElement"];
+    newElement: AppState["newElement"];
+    selectedElements: readonly NonDeletedExcalidrawElement[];
+    selectedElementsAreBeingDragged: AppState["selectedElementsAreBeingDragged"];
+    frameToHighlight: AppState["frameToHighlight"];
+};
 export declare class Renderer {
     private scene;
     constructor(scene: Scene);
-    getRenderableElements: ((opts: {
-        zoom: Readonly<{
-            value: import("../types").NormalizedZoomValue;
-        }>;
-        offsetLeft: AppState["offsetLeft"];
-        offsetTop: AppState["offsetTop"];
-        scrollX: AppState["scrollX"];
-        scrollY: AppState["scrollY"];
-        height: AppState["height"];
-        width: AppState["width"];
-        editingTextElement: AppState["editingTextElement"];
-        /** note: first render of newElement will always bust the cache
-         * (we'd have to prefilter elements outside of this function) */
-        newElementId: ExcalidrawElement["id"] | undefined;
-        sceneNonce: ReturnType<InstanceType<typeof Scene>["getSceneNonce"]>;
-    }) => {
+    /**
+     * Adjusts the document-visible set for render-override translations: an
+     * element leaves it when its offset moves it out of view and enters it when
+     * its offset brings it in; everything else keeps its document visibility.
+     * Only translated elements go through viewport geometry. The result is
+     * memoized on the offsets' identity so that opacity-only snapshots don't
+     * reach it at all.
+     */
+    getVisibleElementsWithRenderOffsets(visibleElements: readonly NonDeletedExcalidrawElement[], elementsMap: RenderableElementsMap, appState: AppState, offsets: ElementRenderOffsets): readonly NonDeletedExcalidrawElement[];
+    private _getVisibleElementsWithRenderOffsets;
+    /** the document-visible elements as a set, cached per visible array */
+    private visibleSets;
+    private getVisibleSet;
+    private getVisibleCanvasElements;
+    private getRenderableElementsMap;
+    private sortSelectedElementsIntoHighlightedFrame;
+    private _getRenderableElements;
+    getRenderableElements: (opts: GetRenderableElementsOpts) => {
         elementsMap: RenderableElementsMap;
         visibleElements: readonly NonDeletedExcalidrawElement[];
-    }) & {
-        clear: () => void;
+        newElementCanvasElement: (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>;
+        }> & Readonly<{
+            type: "line" | "arrow";
+            points: readonly import("@excalidraw/math").LocalPoint[];
+            startBinding: import("@excalidraw/element/types").FixedPointBinding | null;
+            endBinding: import("@excalidraw/element/types").FixedPointBinding | null;
+            startArrowhead: import("@excalidraw/element/types").Arrowhead | null;
+            endArrowhead: import("@excalidraw/element/types").Arrowhead | null;
+        }> & {
+            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>;
+        }> & {
+            type: "rectangle";
+        } & {
+            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>;
+        }> & 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>;
+        }> & {
+            type: "diamond";
+        } & {
+            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>;
+        }> & {
+            type: "ellipse";
+        } & {
+            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>;
+        }> & Readonly<{
+            type: "embeddable";
+        }> & {
+            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>;
+        }> & Readonly<{
+            type: "iframe";
+            customData?: {
+                generationData?: import("@excalidraw/element/types").MagicGenerationData;
+            };
+        }> & {
+            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>;
+        }> & Readonly<{
+            type: "image";
+            fileId: import("@excalidraw/element/types").FileId | null;
+            status: "pending" | "saved" | "error";
+            scale: [number, number];
+            crop: import("@excalidraw/element/types").ImageCrop | null;
+        }> & {
+            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>;
+        }> & {
+            type: "frame";
+            name: string | null;
+        } & {
+            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>;
+        }> & {
+            type: "magicframe";
+            name: string | null;
+        } & {
+            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>;
+        }> & Readonly<{
+            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").ExcalidrawTextContainer["id"] | null;
+            originalText: string;
+            autoResize: boolean;
+            lineHeight: number & {
+                _brand: "unitlessLineHeight";
+            };
+            labelPosition?: number | null;
+        }> & {
+            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>;
+        }> & Readonly<{
+            type: "freedraw";
+            points: readonly import("@excalidraw/math").LocalPoint[];
+            pressures: readonly number[];
+            simulatePressure: boolean;
+            strokeOptions: import("@excalidraw/element/types").StrokeOptions;
+        }> & {
+            isDeleted: false;
+        }) | null;
+        canvasNonce: string;
     };
     destroy(): void;
 }
+export {};

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

@@ -1,10 +1,10 @@
-import type { ExcalidrawFrameLikeElement, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
+import type { ExcalidrawFrameLikeElement, NonDeleted, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
 import type { AppState, BinaryFiles } from "../types";
 export declare const exportToCanvas: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState, files: BinaryFiles, { exportBackground, exportPadding, viewBackgroundColor, exportingFrame, }: {
     exportBackground: boolean;
     exportPadding?: number;
     viewBackgroundColor: string;
-    exportingFrame?: ExcalidrawFrameLikeElement | null;
+    exportingFrame?: NonDeleted<ExcalidrawFrameLikeElement> | null;
 }, createCanvas?: (width: number, height: number) => {
     canvas: HTMLCanvasElement;
     scale: number;
@@ -22,7 +22,7 @@ export declare const exportToSvg: (elements: readonly NonDeletedExcalidrawElemen
      * if true, all embeddables passed in will be rendered when possible.
      */
     renderEmbeddables?: boolean;
-    exportingFrame?: ExcalidrawFrameLikeElement | null;
+    exportingFrame?: NonDeleted<ExcalidrawFrameLikeElement> | null;
     skipInliningFonts?: true;
     reuseImages?: boolean;
 }) => Promise<SVGSVGElement>;

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

@@ -1,4 +1,4 @@
 export { isSomeElementSelected, getElementsWithinSelection, getSelectedElements, getTargetElements, } from "@excalidraw/element";
-export { calculateScrollCenter } from "./scroll";
-export { hasBackground, hasStrokeWidth, hasStrokeStyle, canHaveArrowheads, canChangeRoundness, } from "@excalidraw/element";
+export { getScrollToContentState } from "../viewport";
+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

@@ -1,7 +1,7 @@
 import type { UserIdleState, EditorInterface } from "@excalidraw/common";
 import type { ExcalidrawElement, NonDeletedElementsMap, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap } from "@excalidraw/element/types";
 import type { MakeBrand } from "@excalidraw/common/utility-types";
-import type { AppClassProperties, AppState, EmbedsValidationStatus, ElementsPendingErasure, InteractiveCanvasAppState, StaticCanvasAppState, SocketId, PendingExcalidrawElements } from "../types";
+import type { AppClassProperties, AppState, EmbedsValidationStatus, ElementRenderOverrides, ElementsPendingErasure, InteractiveCanvasAppState, StaticCanvasAppState, SocketId, PendingExcalidrawElements } from "../types";
 import type { RoughCanvas } from "roughjs/bin/canvas";
 import type { Drawable } from "roughjs/bin/core";
 export type RenderableElementsMap = NonDeletedElementsMap & MakeBrand<"RenderableElementsMap">;
@@ -9,6 +9,9 @@ export type StaticCanvasRenderConfig = {
     canvasBackgroundColor: AppState["viewBackgroundColor"];
     imageCache: AppClassProperties["imageCache"];
     renderGrid: boolean;
+    /** whether to render link icons on elements with links (never rendered
+     when exporting). @default true */
+    renderLinks?: boolean;
     /** when exporting the behavior is slightly different (e.g. we can't use
      CSS filters), and we disable render optimizations for best output */
     isExporting: boolean;
@@ -16,6 +19,7 @@ export type StaticCanvasRenderConfig = {
     elementsPendingErasure: ElementsPendingErasure;
     pendingFlowchartNodes: PendingExcalidrawElements | null;
     theme: AppState["theme"];
+    elementRenderOverrides?: ElementRenderOverrides;
 };
 export type SVGRenderConfig = {
     offsetX: number;
@@ -52,8 +56,6 @@ export type InteractiveCanvasRenderConfig = {
     renderScrollbars?: boolean;
 };
 export type RenderInteractiveSceneCallback = {
-    atLeastOneVisibleElement: boolean;
-    elementsMap: RenderableElementsMap;
     scrollBars?: ScrollBars;
 };
 export type StaticSceneRenderConfig = {
@@ -89,7 +91,7 @@ export type InteractiveSceneRenderConfig = {
 export type NewElementSceneRenderConfig = {
     canvas: HTMLCanvasElement | null;
     rc: RoughCanvas;
-    newElement: ExcalidrawElement | null;
+    newElement: NonDeletedExcalidrawElement | null;
     elementsMap: RenderableElementsMap;
     allElementsMap: NonDeletedSceneElementsMap;
     scale: number;
@@ -131,6 +133,7 @@ export type ElementShapes = {
     arrow: Drawable[];
     line: Drawable[];
     text: null;
+    stickynote: null;
     image: null;
     frame: null;
     magicframe: null;