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

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/Tooltip.d.ts

@@ -7,12 +7,26 @@ export declare const updateTooltipPosition: (tooltip: HTMLDivElement, item: {
     width: number;
     height: number;
 }, position?: "bottom" | "top") => void;
+export declare const hideTooltip: () => void;
+/**
+ * Shows the tooltip for `item`. For elements that can't be wrapped
+ * in <Tooltip>. Pair with `hideTooltip()`.
+ */
+export declare const showTooltip: (item: HTMLElement, label: string, { long, delay, position, }?: {
+    long?: boolean;
+    /** show after a short delay (unless a tooltip was visible just now) */
+    delay?: boolean;
+    position?: "bottom" | "top";
+}) => void;
 type TooltipProps = {
     children: React.ReactNode;
     label: string;
     long?: boolean;
     style?: React.CSSProperties;
+    className?: string;
     disabled?: boolean;
+    /** show after a short delay (unless a tooltip was visible just now) */
+    delay?: boolean;
 };
-export declare const Tooltip: ({ children, label, long, style, disabled, }: TooltipProps) => import("react/jsx-runtime").JSX.Element | null;
+export declare const Tooltip: ({ children, label, long, style, className, disabled, delay, }: TooltipProps) => import("react/jsx-runtime").JSX.Element | null;
 export {};

package/dist/types/excalidraw/components/TopPicksDnD/TopPicksContextMenu.d.ts

@@ -0,0 +1,14 @@
+import type { ReactElement } from "react";
+/**
+ * right-click context menu of a customizable top-picks strip, resetting it
+ * to its default picks. Renders the strip as-is when not customizable.
+ */
+export declare const TopPicksContextMenu: ({ children, onReset, isCustomized, resetLabel, }: {
+    /** the strip (must accept a ref — used as the menu trigger) */
+    children: ReactElement;
+    /** present when the strip is user-customizable */
+    onReset?: () => void;
+    /** whether custom picks are currently applied (enables the reset item) */
+    isCustomized: boolean;
+    resetLabel: string;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/types/excalidraw/components/TopPicksDnD/TopPicksTip.d.ts

@@ -0,0 +1,11 @@
+/**
+ * "drag to pin" hint shown in a picker popup whose top picks are
+ * customizable — with a reset link while the picks are customized
+ */
+export declare const TopPicksTip: ({ className, tip, onReset, resetTitle, }: {
+    className?: string;
+    tip: string;
+    /** present only while the top picks are customized */
+    onReset?: () => void;
+    resetTitle: string;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/types/excalidraw/components/TopPicksDnD/topPicksDnD.d.ts

@@ -0,0 +1,58 @@
+import "./TopPicksDnD.scss";
+type DragOrigin = {
+    kind: "source";
+} | {
+    kind: "pick";
+    index: number;
+};
+export type TopPicksDragState<T> = {
+    value: T;
+    origin: DragOrigin;
+    /** hovered strip slot — the slot to replace (source drags) or the final
+     * position (pick reorders). null while the pointer is outside the strip */
+    overIndex: number | null;
+    /** index of an already-pinned identical value that blocks the drop */
+    duplicateIndex: number | null;
+    /** signed distance between strip slot centers (for reorder preview) */
+    slotSpan: number;
+} | null;
+export type TopPicksGhost = {
+    /** the ghost's visual. Rendered into `document.body` — outside the
+     * editor's CSS scope, so theme-dependent styling must be resolved from the
+     * rendered DOM (computed styles) rather than CSS variables */
+    content: HTMLElement;
+    /** where the ghost spawns (its size) and flies back to on cancel */
+    rect: DOMRect;
+};
+/** called on pointerdown (the source may not stay mounted until the drag
+ * activates), for every potential drag — keep it cheap */
+export type CreateTopPicksGhost<T> = (args: {
+    value: T;
+    /** the element the drag started on */
+    sourceEl: HTMLElement;
+    /** the registered strip */
+    stripEl: HTMLElement;
+}) => TopPicksGhost;
+export type TopPicksDnD<T> = {
+    dragState: TopPicksDragState<T>;
+    startSourceDrag: (event: React.PointerEvent, value: T | null) => void;
+    startPickDrag: (event: React.PointerEvent, index: number, value: T) => void;
+    setStripEl: (el: HTMLDivElement | null) => void;
+};
+/**
+ * live preview of the reorder result — the translation (px) moving the pick
+ * at `index` to the slot it would occupy if dropped right now
+ */
+export declare const getTopPickReorderOffset: (dragState: TopPicksDragState<unknown>, index: number) => number;
+/** "marching ants" outline hinting that the strip accepts the drop — SVG
+ * because CSS dashed outlines/borders can't animate their dash offset */
+export declare const TopPicksDnDOutline: () => import("react/jsx-runtime").JSX.Element;
+export declare const useTopPicksDnD: <T>({ enabled, picks, onPicksChange, isSamePick, createGhost, }: {
+    enabled: boolean;
+    picks: readonly T[];
+    onPicksChange: (picks: T[]) => void;
+    /** value-equality — pins identical to an existing pick are refused */
+    isSamePick?: (a: T, b: T) => boolean;
+    createGhost: CreateTopPicksGhost<T>;
+}) => TopPicksDnD<T>;
+export {};

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

@@ -197,8 +197,10 @@ export declare const playerPlayIcon: import("react/jsx-runtime").JSX.Element;
 export declare const playerStopFilledIcon: import("react/jsx-runtime").JSX.Element;
 export declare const tablerCheckIcon: import("react/jsx-runtime").JSX.Element;
 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/main-menu/DefaultItems.d.ts

@@ -74,9 +74,11 @@ export declare const Preferences: {
     }): import("react/jsx-runtime").JSX.Element;
     ToggleToolLock: () => import("react/jsx-runtime").JSX.Element;
     BoxSelectionMode: () => import("react/jsx-runtime").JSX.Element;
+    InputDevice: () => import("react/jsx-runtime").JSX.Element;
     ToggleSnapMode: () => import("react/jsx-runtime").JSX.Element;
     ToggleArrowBinding: () => import("react/jsx-runtime").JSX.Element;
     ToggleMidpointSnapping: () => import("react/jsx-runtime").JSX.Element;
+    ToggleShowHints: () => import("react/jsx-runtime").JSX.Element;
     ToggleGridMode: () => import("react/jsx-runtime").JSX.Element;
     ToggleZenMode: () => import("react/jsx-runtime").JSX.Element;
     ToggleViewMode: () => import("react/jsx-runtime").JSX.Element | null;

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

@@ -20,6 +20,7 @@ fileHandle?: FileSystemFileHandle | null) => Promise<{
     data: {
         elements: import("@excalidraw/element/types").OrderedExcalidrawElement[];
         appState: {
+            zoom: import("../types").Zoom;
             viewModeEnabled: boolean;
             activeTool: {
                 lastActiveTool: import("../types").ActiveTool | null;
@@ -53,11 +54,20 @@ fileHandle?: FileSystemFileHandle | null) => Promise<{
             boxSelectionMode: import("../types").BoxSelectionMode;
             bindingPreference: "enabled" | "disabled";
             isMidpointSnappingEnabled: boolean;
+            showHints: boolean;
+            inputDevice: import("../types").InputDevice;
             suggestedBinding: {
                 element: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawBindableElement>;
                 midPoint?: import("@excalidraw/math").GlobalPoint;
             } | null;
-            hoveredArrowTextAnchor: {
+            textToolHover: {
+                type: "text";
+                elementId: ExcalidrawElement["id"];
+            } | {
+                type: "container";
+                elementId: ExcalidrawElement["id"];
+            } | {
+                type: "arrow";
                 elementId: import("@excalidraw/element/types").ExcalidrawArrowElement["id"];
                 anchor: "start" | "end" | "label";
             } | null;
@@ -82,6 +92,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;
@@ -104,7 +116,6 @@ fileHandle?: FileSystemFileHandle | null) => Promise<{
             scrolledOutside: boolean;
             isResizing: boolean;
             isRotating: boolean;
-            zoom: import("../types").Zoom;
             openMenu: "canvas" | null;
             openPopup: "canvasBackground" | "elementBackground" | "elementStroke" | "fontFamily" | "compactTextProperties" | "compactStrokeStyles" | "compactOtherProperties" | "compactArrowProperties" | null;
             openSidebar: {
@@ -175,6 +186,14 @@ fileHandle?: FileSystemFileHandle | null) => Promise<{
                 [groupId: string]: true;
             };
             bindMode: import("@excalidraw/element/types").BindMode;
+            colorTopPicks: {
+                elementStroke: readonly string[] | null;
+                elementBackground: readonly string[] | null;
+                bucketFill: readonly string[] | null;
+                stickyNoteStroke: readonly string[] | null;
+                stickyNoteBackground: readonly string[] | null;
+            };
+            fontTopPicks: readonly import("@excalidraw/element/types").FontFamilyValues[] | null;
         };
         files: import("../types").BinaryFiles;
     };
@@ -189,6 +208,7 @@ localAppState: AppState | null, localElements: readonly ExcalidrawElement[] | nu
 fileHandle?: FileSystemFileHandle | null) => Promise<{
     elements: import("@excalidraw/element/types").OrderedExcalidrawElement[];
     appState: {
+        zoom: import("../types").Zoom;
         viewModeEnabled: boolean;
         activeTool: {
             lastActiveTool: import("../types").ActiveTool | null;
@@ -222,11 +242,20 @@ fileHandle?: FileSystemFileHandle | null) => Promise<{
         boxSelectionMode: import("../types").BoxSelectionMode;
         bindingPreference: "enabled" | "disabled";
         isMidpointSnappingEnabled: boolean;
+        showHints: boolean;
+        inputDevice: import("../types").InputDevice;
         suggestedBinding: {
             element: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawBindableElement>;
             midPoint?: import("@excalidraw/math").GlobalPoint;
         } | null;
-        hoveredArrowTextAnchor: {
+        textToolHover: {
+            type: "text";
+            elementId: ExcalidrawElement["id"];
+        } | {
+            type: "container";
+            elementId: ExcalidrawElement["id"];
+        } | {
+            type: "arrow";
             elementId: import("@excalidraw/element/types").ExcalidrawArrowElement["id"];
             anchor: "start" | "end" | "label";
         } | null;
@@ -251,6 +280,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;
@@ -273,7 +304,6 @@ fileHandle?: FileSystemFileHandle | null) => Promise<{
         scrolledOutside: boolean;
         isResizing: boolean;
         isRotating: boolean;
-        zoom: import("../types").Zoom;
         openMenu: "canvas" | null;
         openPopup: "canvasBackground" | "elementBackground" | "elementStroke" | "fontFamily" | "compactTextProperties" | "compactStrokeStyles" | "compactOtherProperties" | "compactArrowProperties" | null;
         openSidebar: {
@@ -344,6 +374,14 @@ fileHandle?: FileSystemFileHandle | null) => Promise<{
             [groupId: string]: true;
         };
         bindMode: import("@excalidraw/element/types").BindMode;
+        colorTopPicks: {
+            elementStroke: readonly string[] | null;
+            elementBackground: readonly string[] | null;
+            bucketFill: readonly string[] | null;
+            stickyNoteStroke: readonly string[] | null;
+            stickyNoteBackground: readonly string[] | null;
+        };
+        fontTopPicks: readonly import("@excalidraw/element/types").FontFamilyValues[] | null;
     };
     files: import("../types").BinaryFiles;
 }>;

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

@@ -18,6 +18,7 @@ export declare const saveAsJSON: ({ data, filename, fileHandle, }: {
 export declare const loadFromJSON: (localAppState: AppState, localElements: readonly ExcalidrawElement[] | null) => Promise<{
     elements: import("@excalidraw/element/types").OrderedExcalidrawElement[];
     appState: {
+        zoom: import("../types").Zoom;
         viewModeEnabled: boolean;
         activeTool: {
             lastActiveTool: import("../types").ActiveTool | null;
@@ -51,11 +52,20 @@ export declare const loadFromJSON: (localAppState: AppState, localElements: read
         boxSelectionMode: import("../types").BoxSelectionMode;
         bindingPreference: "enabled" | "disabled";
         isMidpointSnappingEnabled: boolean;
+        showHints: boolean;
+        inputDevice: import("../types").InputDevice;
         suggestedBinding: {
             element: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawBindableElement>;
             midPoint?: import("@excalidraw/math").GlobalPoint;
         } | null;
-        hoveredArrowTextAnchor: {
+        textToolHover: {
+            type: "text";
+            elementId: ExcalidrawElement["id"];
+        } | {
+            type: "container";
+            elementId: ExcalidrawElement["id"];
+        } | {
+            type: "arrow";
             elementId: import("@excalidraw/element/types").ExcalidrawArrowElement["id"];
             anchor: "start" | "end" | "label";
         } | null;
@@ -80,6 +90,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;
@@ -102,7 +114,6 @@ export declare const loadFromJSON: (localAppState: AppState, localElements: read
         scrolledOutside: boolean;
         isResizing: boolean;
         isRotating: boolean;
-        zoom: import("../types").Zoom;
         openMenu: "canvas" | null;
         openPopup: "canvasBackground" | "elementBackground" | "elementStroke" | "fontFamily" | "compactTextProperties" | "compactStrokeStyles" | "compactOtherProperties" | "compactArrowProperties" | null;
         openSidebar: {
@@ -173,6 +184,14 @@ export declare const loadFromJSON: (localAppState: AppState, localElements: read
             [groupId: string]: true;
         };
         bindMode: import("@excalidraw/element/types").BindMode;
+        colorTopPicks: {
+            elementStroke: readonly string[] | null;
+            elementBackground: readonly string[] | null;
+            bucketFill: readonly string[] | null;
+            stickyNoteStroke: readonly string[] | null;
+            stickyNoteBackground: readonly string[] | null;
+        };
+        fontTopPicks: readonly import("@excalidraw/element/types").FontFamilyValues[] | 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/lasso/utils.d.ts

@@ -1,5 +1,6 @@
 import type { ElementsSegmentsMap, GlobalPoint } from "@excalidraw/math/types";
 import type { ElementsMap, ExcalidrawElement } from "@excalidraw/element/types";
+import type { BoxSelectionMode } from "../types";
 export declare const getLassoSelectedElementIds: (input: {
     lassoPath: GlobalPoint[];
     elements: readonly ExcalidrawElement[];
@@ -8,6 +9,7 @@ export declare const getLassoSelectedElementIds: (input: {
     intersectedElements: Set<ExcalidrawElement["id"]>;
     enclosedElements: Set<ExcalidrawElement["id"]>;
     simplifyDistance?: number;
+    mode?: BoxSelectionMode;
 }) => {
     selectedElementIds: string[];
 };

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/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;
 };