@dwelle/excalidraw 0.5.0-b8a955d → 0.5.0-ba41ca2

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

@@ -1,5 +1,4 @@
-import type { ExcalidrawElement, ExcalidrawFrameLikeElement, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
-import type { FileSystemHandle } from "./filesystem";
+import type { ExcalidrawElement, ExcalidrawFrameLikeElement, NonDeleted, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
 import type { ExportType } from "../scene/types";
 import type { AppState, BinaryFiles } from "../types";
 export { loadFromBlob } from "./blob";
@@ -7,8 +6,8 @@ export { loadFromJSON, saveAsJSON } from "./json";
 export type ExportedElements = readonly NonDeletedExcalidrawElement[] & {
     _brand: "exportedElements";
 };
-export declare const prepareElementsForExport: (elements: readonly ExcalidrawElement[], { selectedElementIds }: Pick<AppState, "selectedElementIds">, exportSelectionOnly: boolean) => {
-    exportingFrame: ExcalidrawFrameLikeElement | null;
+export declare const prepareElementsForExport: (allElements: readonly ExcalidrawElement[], { selectedElementIds }: Pick<AppState, "selectedElementIds">, exportSelectionOnly: boolean) => {
+    exportingFrame: NonDeleted<ExcalidrawFrameLikeElement> | null;
     exportedElements: ExportedElements;
 };
 export declare const exportAsImage: ({ type, data, config, }: {
@@ -24,7 +23,7 @@ export declare const exportAsImage: ({ type, data, config, }: {
         viewBackgroundColor: string;
         /** filename, if applicable */
         name?: string;
-        fileHandle?: FileSystemHandle | null;
-        exportingFrame: ExcalidrawFrameLikeElement | null;
+        fileHandle?: FileSystemFileHandle | null;
+        exportingFrame: NonDeleted<ExcalidrawFrameLikeElement> | null;
     };
-}) => Promise<FileSystemHandle | null | undefined>;
+}) => Promise<FileSystemFileHandle | null | undefined>;

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

@@ -1,11 +1,19 @@
 import type { ExcalidrawElement } from "@excalidraw/element/types";
+import type { MaybePromise } from "@excalidraw/common/utility-types";
 import type { AppState, BinaryFiles, LibraryItems } from "../types";
 import type { ImportedDataState, ImportedLibraryData } from "./types";
+export type JSONExportData = {
+    elements: readonly ExcalidrawElement[];
+    appState: AppState;
+    files: BinaryFiles;
+};
 export declare const serializeAsJSON: (elements: readonly ExcalidrawElement[], appState: Partial<AppState>, files: BinaryFiles, type: "local" | "database") => string;
-export declare const saveAsJSON: (elements: readonly ExcalidrawElement[], appState: AppState, files: BinaryFiles, 
-/** filename */
-name?: string) => Promise<{
-    fileHandle: import("browser-fs-access").FileSystemHandle | null;
+export declare const saveAsJSON: ({ data, filename, fileHandle, }: {
+    data: MaybePromise<JSONExportData>;
+    filename: string;
+    fileHandle: AppState["fileHandle"];
+}) => Promise<{
+    fileHandle: FileSystemFileHandle | null;
 }>;
 export declare const loadFromJSON: (localAppState: AppState, localElements: readonly ExcalidrawElement[] | null) => Promise<{
     elements: import("@excalidraw/element/types").OrderedExcalidrawElement[];
@@ -18,9 +26,81 @@ export declare const loadFromJSON: (localAppState: AppState, localElements: read
             clip: boolean;
         };
         viewBackgroundColor: string;
+        name: string | null;
+        zoom: import("../types").Zoom;
         scrollX: number;
         scrollY: number;
-        zoom: import("../types").Zoom;
+        viewModeEnabled: boolean;
+        openDialog: null | {
+            name: "imageExport" | "help" | "jsonExport";
+        } | {
+            name: "ttd";
+            tab: "text-to-diagram" | "mermaid";
+        } | {
+            name: "commandPalette";
+        } | {
+            name: "settings";
+        } | {
+            name: "elementLinkSelector";
+            sourceElementId: ExcalidrawElement["id"];
+        } | {
+            name: "charts";
+            data: import("../charts").Spreadsheet;
+            rawText: string;
+        };
+        editingGroupId: import("@excalidraw/element/types").GroupId | null;
+        selectedElementIds: Readonly<{
+            [id: string]: true;
+        }>;
+        frameToHighlight: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawFrameLikeElement> | null;
+        activeTool: {
+            lastActiveTool: import("../types").ActiveTool | null;
+            locked: boolean;
+            fromSelection: boolean;
+        } & import("../types").ActiveTool;
+        activeEmbeddable: {
+            element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
+            state: "hover" | "active";
+        } | null;
+        selectionElement: import("@excalidraw/element/types").NonDeletedExcalidrawElement | null;
+        selectedGroupIds: {
+            [groupId: string]: boolean;
+        };
+        selectedLinearElement: import("@excalidraw/element").LinearElementEditor | null;
+        multiElement: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawLinearElement> | null;
+        newElement: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawNonSelectionElement> | null;
+        isBindingEnabled: boolean;
+        isMidpointSnappingEnabled: boolean;
+        gridModeEnabled: boolean;
+        suggestedBinding: {
+            element: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawBindableElement>;
+            midPoint?: import("@excalidraw/math").GlobalPoint;
+        } | null;
+        hoveredArrowTextAnchor: {
+            elementId: import("@excalidraw/element/types").ExcalidrawArrowElement["id"];
+            anchor: "start" | "end" | "label";
+        } | null;
+        isRotating: boolean;
+        elementsToHighlight: readonly import("@excalidraw/element/types").NonDeletedExcalidrawElement[] | null;
+        collaborators: Map<import("../types").SocketId, import("../types").Collaborator>;
+        snapLines: readonly import("../snapping").SnapLine[];
+        zenModeEnabled: boolean;
+        editingTextElement: import("@excalidraw/element/types").ExcalidrawTextElement | null;
+        isCropping: boolean;
+        croppingElementId: ExcalidrawElement["id"] | null;
+        searchMatches: Readonly<{
+            focusedId: ExcalidrawElement["id"] | null;
+            matches: readonly import("../types").SearchMatch[];
+        }> | null;
+        activeLockedId: string | null;
+        hoveredElementIds: Readonly<{
+            [id: string]: true;
+        }>;
+        shouldCacheIgnoreZoom: boolean;
+        exportScale: number;
+        currentItemArrowType: "sharp" | "round" | "elbow";
+        gridSize: number;
+        bindMode: import("@excalidraw/element/types").BindMode;
         contextMenu: {
             items: import("../components/ContextMenu").ContextMenuItems;
             top: number;
@@ -29,26 +109,10 @@ export declare const loadFromJSON: (localAppState: AppState, localElements: read
         showWelcomeScreen: boolean;
         isLoading: boolean;
         errorMessage: React.ReactNode;
-        activeEmbeddable: {
-            element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
-            state: "hover" | "active";
-        } | null;
-        newElement: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawNonSelectionElement> | null;
         resizingElement: import("@excalidraw/element/types").NonDeletedExcalidrawElement | null;
-        multiElement: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawLinearElement> | null;
-        selectionElement: import("@excalidraw/element/types").NonDeletedExcalidrawElement | null;
-        isBindingEnabled: boolean;
-        startBoundElement: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawBindableElement> | null;
-        suggestedBinding: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawBindableElement> | null;
-        frameToHighlight: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawFrameLikeElement> | null;
-        editingFrame: string | null;
-        elementsToHighlight: import("@excalidraw/element/types").NonDeleted<ExcalidrawElement>[] | null;
-        editingTextElement: import("@excalidraw/element/types").NonDeletedExcalidrawElement | null;
-        activeTool: {
-            lastActiveTool: import("../types").ActiveTool | null;
-            locked: boolean;
-            fromSelection: boolean;
-        } & import("../types").ActiveTool;
+        boxSelectionMode: import("../types").BoxSelectionMode;
+        bindingPreference: "enabled" | "disabled";
+        editingFrame: import("@excalidraw/element/types").ExcalidrawFrameLikeElement["id"] | null;
         preferredSelectionTool: {
             type: "selection" | "lasso";
             initialized: boolean;
@@ -58,13 +122,13 @@ export declare const loadFromJSON: (localAppState: AppState, localElements: read
         exportBackground: boolean;
         exportEmbedScene: boolean;
         exportWithDarkMode: boolean;
-        exportScale: number;
         currentItemStrokeColor: string;
         currentItemBackgroundColor: string;
         currentItemFillStyle: ExcalidrawElement["fillStyle"];
-        currentItemStrokeWidth: number;
+        currentItemStrokeWidthKey: import("@excalidraw/common").StrokeWidthKey;
         currentItemStrokeStyle: ExcalidrawElement["strokeStyle"];
         currentItemRoughness: number;
+        currentItemStrokeVariability: import("@excalidraw/element/types").StrokeVariability;
         currentItemOpacity: number;
         currentItemFontFamily: import("@excalidraw/element/types").FontFamilyValues;
         currentItemFontSize: number;
@@ -73,93 +137,47 @@ export declare const loadFromJSON: (localAppState: AppState, localElements: read
         currentItemEndArrowhead: import("@excalidraw/element/types").Arrowhead | null;
         currentHoveredFontFamily: import("@excalidraw/element/types").FontFamilyValues | null;
         currentItemRoundness: import("@excalidraw/element/types").StrokeRoundness;
-        currentItemArrowType: "sharp" | "round" | "elbow";
+        scrollConstraints: import("../types").ScrollConstraints | null;
         cursorButton: "up" | "down";
         scrolledOutside: boolean;
-        name: string | null;
         isResizing: boolean;
-        isRotating: boolean;
         openMenu: "canvas" | null;
         openPopup: "canvasBackground" | "elementBackground" | "elementStroke" | "fontFamily" | "compactTextProperties" | "compactStrokeStyles" | "compactOtherProperties" | "compactArrowProperties" | null;
         openSidebar: {
             name: import("../types").SidebarName;
             tab?: import("../types").SidebarTabName;
         } | null;
-        openDialog: null | {
-            name: "imageExport" | "help" | "jsonExport";
-        } | {
-            name: "ttd";
-            tab: "text-to-diagram" | "mermaid";
-        } | {
-            name: "commandPalette";
-        } | {
-            name: "settings";
-        } | {
-            name: "elementLinkSelector";
-            sourceElementId: ExcalidrawElement["id"];
-        };
         defaultSidebarDockedPreference: boolean;
         lastPointerDownWith: import("@excalidraw/element/types").PointerType;
-        selectedElementIds: Readonly<{
-            [id: string]: true;
-        }>;
-        hoveredElementIds: Readonly<{
-            [id: string]: true;
-        }>;
         previousSelectedElementIds: {
             [id: string]: true;
         };
         selectedElementsAreBeingDragged: boolean;
-        shouldCacheIgnoreZoom: boolean;
         toast: {
-            message: string;
+            message: React.ReactNode;
             closable?: boolean;
             duration?: number;
         } | null;
-        zenModeEnabled: boolean;
-        gridSize: number;
         gridStep: number;
-        gridModeEnabled: boolean;
-        viewModeEnabled: boolean;
-        selectedGroupIds: {
-            [groupId: string]: boolean;
-        };
-        editingGroupId: import("@excalidraw/element/types").GroupId | null;
-        fileHandle: import("browser-fs-access").FileSystemHandle | null;
-        collaborators: Map<import("../types").SocketId, import("../types").Collaborator>;
+        fileHandle: FileSystemFileHandle | null;
         stats: {
             open: boolean;
             panels: number;
         };
-        currentChartType: import("@excalidraw/element/types").ChartType;
-        pasteDialog: {
-            shown: false;
-            data: null;
-        } | {
-            shown: true;
-            data: import("../charts").Spreadsheet;
-        };
         showHyperlinkPopup: false | "info" | "editor";
-        selectedLinearElement: import("@excalidraw/element").LinearElementEditor | null;
-        snapLines: readonly import("../snapping").SnapLine[];
         originSnapOffset: {
             x: number;
             y: number;
         } | null;
         objectsSnapModeEnabled: boolean;
-        userToFollow: import("../types").UserToFollow | null;
-        followedBy: Set<import("../types").SocketId>;
-        isCropping: boolean;
-        croppingElementId: ExcalidrawElement["id"] | null;
-        searchMatches: Readonly<{
-            focusedId: ExcalidrawElement["id"] | null;
-            matches: readonly import("../types").SearchMatch[];
-        }> | null;
-        activeLockedId: string | null;
         lockedMultiSelections: {
             [groupId: string]: true;
         };
-        bindMode: import("@excalidraw/element/types").BindMode;
+        colorTopPicks: {
+            elementStroke: readonly string[] | null;
+            elementBackground: readonly string[] | null;
+            bucketFill: readonly string[] | null;
+        };
     };
     files: BinaryFiles;
 }>;

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

@@ -37,7 +37,7 @@ export interface LibraryMigrationAdapter {
     /** clears entire storage afterwards */
     clear(): MaybePromise<void>;
 }
-export declare const libraryItemsAtom: import("jotai/vanilla/atom").PrimitiveAtom<{
+export declare const libraryItemsAtom: import("jotai").PrimitiveAtom<{
     status: "loading" | "loaded";
     /** indicates whether library is initialized with library items (has gone
      * through at least one update). Used in UI. Specific to this atom only. */

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

@@ -1,5 +1,10 @@
+import type { MaybePromise } from "@excalidraw/common/utility-types";
 import type { ExcalidrawElement } from "@excalidraw/element/types";
 import type { AppState, BinaryFiles } from "../types";
-export declare const resaveAsImageWithScene: (elements: readonly ExcalidrawElement[], appState: AppState, files: BinaryFiles, name: string) => Promise<{
-    fileHandle: import("browser-fs-access").FileSystemHandle;
+export declare const resaveAsImageWithScene: (data: MaybePromise<{
+    elements: readonly ExcalidrawElement[];
+    appState: AppState;
+    files: BinaryFiles;
+}>, fileHandle: FileSystemFileHandle, filename: string) => Promise<{
+    fileHandle: FileSystemFileHandle;
 }>;

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

@@ -2,7 +2,7 @@ import { type CombineBrandsIfNeeded } from "@excalidraw/common";
 import type { ElementsMap, ElementsMapOrArray, ExcalidrawElement, ExcalidrawSelectionElement, OrderedExcalidrawElement } from "@excalidraw/element/types";
 import type { AppState, BinaryFiles, LibraryItem } from "../types";
 import type { ImportedDataState } from "./types";
-type RestoredAppState = Omit<AppState, "offsetTop" | "offsetLeft" | "width" | "height" | "scrollConstraints">;
+type RestoredAppState = Omit<AppState, "offsetTop" | "offsetLeft" | "width" | "height">;
 export declare const AllowedExcalidrawActiveTools: Record<AppState["activeTool"]["type"], boolean>;
 export type RestoredDataState = {
     elements: OrderedExcalidrawElement[];

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

@@ -0,0 +1,16 @@
+import type { GlobalPoint } from "@excalidraw/math";
+import type App from "./components/App";
+import type { Trail } from "./animatedTrail";
+export declare class DrawShapeTrail implements Trail {
+    private app;
+    private trail;
+    constructor(app: App);
+    private getTrailOptions;
+    startPath(x: number, y: number): void;
+    addPointToPath(x: number, y: number): void;
+    endPath(): void;
+    clearTrails(): void;
+    getCurrentPoints(): GlobalPoint[];
+    start(container: SVGSVGElement): void;
+    stop(): void;
+}

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

@@ -1,10 +1,9 @@
-import { AnimatedTrail } from "../animated-trail";
-import type { AnimationFrameHandler } from "../animation-frame-handler";
+import { AnimatedTrail } from "../animatedTrail";
 import type App from "../components/App";
 export declare class EraserTrail extends AnimatedTrail {
     private elementsToErase;
     private groupsToErase;
-    constructor(animationFrameHandler: AnimationFrameHandler, app: App);
+    constructor(app: App);
     startPath(x: number, y: number): void;
     addPointToPath(x: number, y: number, restore?: boolean): string[];
     private updateElementsToBeErased;

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

@@ -0,0 +1,29 @@
+import type { AppState } from "../types";
+/**
+ * Subscribes to specific appState changes. The component re-renders
+ * only when the specified prop(s) change — not on every appState update.
+ *
+ * Works both inside and outside the <Excalidraw> tree, as long as
+ * ExcalidrawAPIContext.Provider is an ancestor (automatically provided
+ * inside <Excalidraw>, or manually by the host app).
+ *
+ * Returns the narrowed value depending on prop form:
+ *  - `keyof AppState` → `AppState[K]`
+ *  - `(keyof AppState)[]` → whole `AppState`
+ *  - selector function → selector's return type `T`
+ *
+ * If excalidrawAPI is not ready yet (host apps), hook is rerendered with latest
+ * value once available.
+ */
+export declare function useAppStateValue<K extends keyof AppState>(prop: K, _internal?: boolean): AppState[K];
+export declare function useAppStateValue(props: (keyof AppState)[], _internal?: boolean): AppState;
+export declare function useAppStateValue<T>(selector: (appState: AppState) => T, _internal?: boolean): T;
+/**
+ * Subscribes to specific appState changes without causing component rerenders.
+ *
+ * The callback is called on every matching change, but also on initial render
+ * so you can initialize your state.
+ */
+export declare function useOnAppStateChange<K extends keyof AppState>(prop: K, callback: (value: AppState[K], appState: AppState) => void): undefined;
+export declare function useOnAppStateChange(props: (keyof AppState)[], callback: (props: AppState, appState: AppState) => void): undefined;
+export declare function useOnAppStateChange<T>(selector: (appState: AppState) => T, callback: (value: T, appState: AppState) => void): undefined;

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

@@ -1,6 +1,6 @@
 import type { LibraryItem } from "../types";
 export type SvgCache = Map<LibraryItem["id"], SVGSVGElement>;
-export declare const libraryItemSvgsCache: import("jotai/vanilla/atom").PrimitiveAtom<SvgCache> & {
+export declare const libraryItemSvgsCache: import("jotai").PrimitiveAtom<SvgCache> & {
     init: SvgCache;
 };
 export declare const useLibraryItemSvg: (id: LibraryItem["id"] | null, elements: LibraryItem["elements"] | undefined, svgCache: SvgCache, ref: React.RefObject<HTMLDivElement | null>) => SVGSVGElement | undefined;

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

@@ -1,12 +1,22 @@
 import React from "react";
+import { applyDarkModeFilter, getStrokeWidthByKey } from "@excalidraw/common";
 import Footer from "./components/footer/FooterCenter";
 import LiveCollaborationTrigger from "./components/live-collaboration/LiveCollaborationTrigger";
 import MainMenu from "./components/main-menu/MainMenu";
 import WelcomeScreen from "./components/welcome-screen/WelcomeScreen";
+import { useOnAppStateChange as _useOnAppStateChange } from "./hooks/useAppStateValue";
 import "./css/app.scss";
 import "./css/styles.scss";
 import "./fonts/fonts.css";
-import type { ExcalidrawProps } from "./types";
+import type { AppState, ExcalidrawProps } from "./types";
+/**
+ * Stateless provider that allows `useExcalidrawAPI()` (and hooks built
+ * on it, such as `useAppStateValue()` and `useOnAppStateChange()`) to work
+ * outside the <Excalidraw> component tree.
+ */
+export declare const ExcalidrawAPIProvider: ({ children, }: {
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
 export declare const Excalidraw: React.MemoExoticComponent<(props: ExcalidrawProps) => import("react/jsx-runtime").JSX.Element>;
 export { getSceneVersion, hashElementsVersion, hashString, getNonDeletedElements, } from "@excalidraw/element";
 export { getTextFromElements } from "@excalidraw/element";
@@ -19,7 +29,7 @@ export { serializeAsJSON, serializeLibraryAsJSON } from "./data/json";
 export { loadFromBlob, loadSceneOrLibraryFromBlob, loadLibraryFromBlob, } from "./data/blob";
 export { mergeLibraryItems, getLibraryItemsHash } from "./data/library";
 export { isLinearElement } from "@excalidraw/element";
-export { FONT_FAMILY, THEME, MIME_TYPES, ROUNDNESS, DEFAULT_LASER_COLOR, UserIdleState, normalizeLink, sceneCoordsToViewportCoords, viewportCoordsToSceneCoords, getFormFactor, } from "@excalidraw/common";
+export { FONT_FAMILY, THEME, MIME_TYPES, ROUNDNESS, DEFAULT_LASER_COLOR, UserIdleState, normalizeLink, sceneCoordsToViewportCoords, viewportCoordsToSceneCoords, getFormFactor, throttleRAF, } from "@excalidraw/common";
 export { mutateElement, newElementWith, bumpVersion, } from "@excalidraw/element";
 export { CaptureUpdateAction } from "@excalidraw/element";
 export { parseLibraryTokensFromUrl, useHandleLibrary } from "./data/library";
@@ -28,7 +38,7 @@ export { Button } from "./components/Button";
 export { Footer };
 export { MainMenu };
 export { Ellipsify } from "./components/Ellipsify";
-export { useEditorInterface, useStylesPanelMode } from "./components/App";
+export { useEditorInterface, useStylesPanelMode, useExcalidrawAPI, ExcalidrawAPIContext, } from "./components/App";
 export { WelcomeScreen };
 export { LiveCollaborationTrigger };
 export { Stats } from "./components/Stats";
@@ -36,19 +46,35 @@ export { exportToCanvas } from "./scene/export";
 export { DefaultSidebar } from "./components/DefaultSidebar";
 export { TTDDialog } from "./components/TTDDialog/TTDDialog";
 export { TTDDialogTrigger } from "./components/TTDDialog/TTDDialogTrigger";
-export { TTDStreamFetch } from "./components/TTDDialog/utils/TTDStreamFetch";
+export { TTDStreamFetch, parseSSEStream, } from "./components/TTDDialog/utils/TTDStreamFetch";
+export type { StreamChunk } from "./components/TTDDialog/utils/TTDStreamFetch";
 export type { TTDPersistenceAdapter, SavedChat, SavedChats, } from "./components/TTDDialog/types";
-export { zoomToFitBounds } from "./actions/actionCanvas";
+export type { ViewportStatusFrame } from "./types";
+export { zoomToFitBounds, DEFAULT_OVERSCROLL } from "./viewport";
 export { getCommonBounds, getVisibleSceneBounds, convertToExcalidrawElements, } from "@excalidraw/element";
-export { elementsOverlappingBBox, isElementInsideBBox, elementPartiallyOverlapsWithOrContainsBBox, } from "@excalidraw/utils/withinBounds";
+export { elementsOverlappingBBox } from "@excalidraw/element";
 export { DiagramToCodePlugin } from "./components/DiagramToCodePlugin/DiagramToCodePlugin";
 export { getDataURL } from "./data/blob";
 export { isElementLink } from "@excalidraw/element";
+export { Fonts } from "./fonts/Fonts";
 export { setCustomTextMetricsProvider } from "@excalidraw/element";
+export { CommandPalette } from "./components/CommandPalette/CommandPalette";
+export { renderSpreadsheet, tryParseSpreadsheet, isSpreadsheetValidForChartType, } from "./charts/index";
+/**
+ * hook that subscribes to specific appState prop(s)
+ *
+ * @param prop - appState prop(s) to subscribe to, or a selector function.
+ * NOTE `prop/selector` is memoized and will not change after initial render
+ */
+export declare function useExcalidrawStateValue<K extends keyof AppState>(prop: K): AppState[K] | undefined;
+export declare function useExcalidrawStateValue<T extends keyof AppState>(props: T[]): AppState | undefined;
+export declare function useExcalidrawStateValue<T>(selector: (appState: AppState) => T): T | undefined;
+export { _useOnAppStateChange as useOnExcalidrawStateChange };
+export { applyDarkModeFilter, getStrokeWidthByKey };
 export { getDefaultAppState, cleanAppStateForExport, clearAppStateForLocalStorage, } from "./appState";
 export { libraryItemsAtom } from "./data/library";
-export * as icons from "./components/icons";
-export * as actions from "./actions/index";
 export { duplicateElements, duplicateElement } from "../element/src/duplicate";
 export { parseMermaidToExcalidraw } from "@excalidraw/mermaid-to-excalidraw";
-export { CommandPalette } from "./components/CommandPalette/CommandPalette";
+export * as icons from "./components/icons";
+export * as actions from "./actions/index";
+export type { SetViewportOptions } from "./viewport";

package/dist/types/excalidraw/{laser-trails.d.ts → laserTrails.d.ts}

@@ -1,20 +1,18 @@
-import { AnimatedTrail } from "./animated-trail";
-import type { Trail } from "./animated-trail";
-import type { AnimationFrameHandler } from "./animation-frame-handler";
+import { AnimatedTrail } from "./animatedTrail";
+import type { Trail } from "./animatedTrail";
 import type App from "./components/App";
 export declare class LaserTrails implements Trail {
-    private animationFrameHandler;
     private app;
     localTrail: AnimatedTrail;
     private collabTrails;
     private container?;
-    constructor(animationFrameHandler: AnimationFrameHandler, app: App);
+    constructor(app: App);
     private getTrailOptions;
     startPath(x: number, y: number): void;
     addPointToPath(x: number, y: number): void;
     endPath(): void;
     start(container: SVGSVGElement): void;
     stop(): void;
-    onFrame(): void;
-    private updateCollabTrails;
+    private stopCollabTrails;
+    updateCollabTrails(collaborators: App["state"]["collaborators"]): void;
 }

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

@@ -1,5 +1,4 @@
-import { type AnimationFrameHandler } from "../animation-frame-handler";
-import { AnimatedTrail } from "../animated-trail";
+import { AnimatedTrail } from "../animatedTrail";
 import type App from "../components/App";
 export declare class LassoTrail extends AnimatedTrail {
     private intersectedElements;
@@ -7,7 +6,7 @@ export declare class LassoTrail extends AnimatedTrail {
     private elementsSegments;
     private canvasTranslate;
     private keepPreviousSelection;
-    constructor(animationFrameHandler: AnimationFrameHandler, app: App);
+    constructor(app: App);
     startPath(x: number, y: number, keepPreviousSelection?: boolean): void;
     selectElementsFromIds: (ids: string[]) => void;
     addPointToPath: (x: number, y: number, keepPreviousSelection?: boolean) => 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/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/interactiveScene.d.ts

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