@myoc/common 0.19.502-ff5a131b0 → 0.19.503

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

@@ -1,76 +1,37 @@
-import type { ExcalidrawElement } from "@excalidraw/element/types";
+import type { ExcalidrawElement, NonDeleted } 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 NonDeleted<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[];
     appState: {
-        viewBackgroundColor: string;
-        theme: import("@excalidraw/element/types").Theme;
-        frameRendering: {
-            enabled: boolean;
-            name: boolean;
-            outline: boolean;
-            clip: boolean;
-        };
-        name: string | null;
-        zoom: import("../types").Zoom;
-        scrollX: number;
-        scrollY: number;
         viewModeEnabled: boolean;
-        openDialog: null | {
-            name: "imageExport" | "help" | "jsonExport";
-        } | {
-            name: "commandPalette";
-        } | {
-            name: "settings";
-        } | {
-            name: "elementLinkSelector";
-            sourceElementId: ExcalidrawElement["id"];
-        };
-        editingGroupId: import("@excalidraw/element/types").GroupId | null;
-        selectedElementIds: Readonly<{
-            [id: string]: true;
-        }>;
-        frameToHighlight: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawFrameLikeElement> | null;
-        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;
-        suggestedBinding: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawBindableElement> | null;
-        isRotating: boolean;
-        elementsToHighlight: import("@excalidraw/element/types").NonDeleted<ExcalidrawElement>[] | null;
-        collaborators: Map<import("../types").SocketId, import("../types").Collaborator>;
-        snapLines: readonly import("../snapping").SnapLine[];
         zenModeEnabled: boolean;
-        editingTextElement: import("@excalidraw/element/types").NonDeletedExcalidrawElement | 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;
-        bindMode: import("@excalidraw/element/types").BindMode;
+        gridModeEnabled: boolean;
+        objectsSnapModeEnabled: boolean;
+        theme: import("@excalidraw/element/types").Theme;
+        name: string | null;
+        wheelZoomsOnDefault?: boolean | undefined;
+        currentItemArrowType: "sharp" | "round" | "elbow";
         gridSize: number;
+        activeTool: {
+            lastActiveTool: import("../types").ActiveTool | null;
+            locked: boolean;
+            fromSelection: boolean;
+        } & import("../types").ActiveTool;
         contextMenu: {
             items: import("../components/ContextMenu").ContextMenuItems;
             top: number;
@@ -81,7 +42,6 @@ export declare const loadFromJSON: (localAppState: AppState, localElements: read
         myocSimplifiedMode: boolean;
         dontResizeLimitMBs: number;
         hideMainMenus: boolean;
-        wheelZoomsOnDefault?: boolean | undefined;
         arrangeConfiguration: {
             algorithm: import("@excalidraw/element/types").ArrangeAlgorithms;
             gap: number;
@@ -91,14 +51,32 @@ export declare const loadFromJSON: (localAppState: AppState, localElements: read
             metric: import("../types").NormaliseMetric;
         };
         errorMessage: React.ReactNode;
+        activeEmbeddable: {
+            element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
+            state: "hover" | "active";
+        } | null;
+        newElement: NonDeleted<import("@excalidraw/element/types").ExcalidrawNonSelectionElement> | null;
         resizingElement: import("@excalidraw/element/types").NonDeletedExcalidrawElement | null;
-        startBoundElement: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawBindableElement> | null;
+        multiElement: NonDeleted<import("@excalidraw/element/types").ExcalidrawLinearElement> | null;
+        selectionElement: import("@excalidraw/element/types").NonDeletedExcalidrawElement | null;
+        isBindingEnabled: boolean;
+        bindingPreference: "enabled" | "disabled";
+        isMidpointSnappingEnabled: boolean;
+        startBoundElement: NonDeleted<import("@excalidraw/element/types").ExcalidrawBindableElement> | null;
+        suggestedBinding: {
+            element: NonDeleted<import("@excalidraw/element/types").ExcalidrawBindableElement>;
+            midPoint?: import("@excalidraw/math").GlobalPoint;
+        } | null;
+        frameToHighlight: NonDeleted<import("@excalidraw/element/types").ExcalidrawFrameLikeElement> | null;
+        frameRendering: {
+            enabled: boolean;
+            name: boolean;
+            outline: boolean;
+            clip: boolean;
+        };
         editingFrame: string | null;
-        activeTool: {
-            lastActiveTool: import("../types").ActiveTool | null;
-            locked: boolean;
-            fromSelection: boolean;
-        } & import("../types").ActiveTool;
+        elementsToHighlight: NonDeleted<ExcalidrawElement>[] | null;
+        editingTextElement: import("@excalidraw/element/types").ExcalidrawTextElement | null;
         preferredSelectionTool: {
             type: "selection" | "lasso";
             initialized: boolean;
@@ -108,6 +86,7 @@ export declare const loadFromJSON: (localAppState: AppState, localElements: read
         exportBackground: boolean;
         exportEmbedScene: boolean;
         exportWithDarkMode: boolean;
+        exportScale: number;
         currentItemStrokeColor: string;
         currentItemBackgroundColor: string;
         currentItemFillStyle: ExcalidrawElement["fillStyle"];
@@ -122,53 +101,83 @@ 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";
+        viewBackgroundColor: string;
+        scrollX: number;
+        scrollY: number;
         cursorButton: "up" | "down";
         scrolledOutside: boolean;
         isResizing: boolean;
+        isRotating: boolean;
+        zoom: import("../types").Zoom;
         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: "commandPalette";
+        } | {
+            name: "settings";
+        } | {
+            name: "elementLinkSelector";
+            sourceElementId: ExcalidrawElement["id"];
+        } | {
+            name: "charts";
+            data: import("../charts").Spreadsheet;
+            rawText: string;
+        };
         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;
         gridStep: number;
-        gridModeEnabled: boolean;
-        fileHandle: import("browser-fs-access").FileSystemHandle | null;
+        selectedGroupIds: {
+            [groupId: string]: boolean;
+        };
+        editingGroupId: import("@excalidraw/element/types").GroupId | null;
+        fileHandle: FileSystemFileHandle | null;
+        collaborators: Map<import("../types").SocketId, import("../types").Collaborator>;
         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;
     };
     files: BinaryFiles;
 }>;

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

@@ -3,10 +3,19 @@ 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 +28,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 +37,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";
@@ -39,4 +48,17 @@ export { elementsOverlappingBBox, isElementInsideBBox, elementPartiallyOverlapsW
 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";
+/**
+ * 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 };

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

@@ -0,0 +1,15 @@
+import { type GlobalPoint } from "@excalidraw/math";
+import type { EditorInterface } from "@excalidraw/common";
+import type { ExcalidrawTextElement } from "@excalidraw/element/types";
+export declare const getTextBoxPadding: (zoomValue: number) => number;
+export declare const getTextAutoResizeHandle: (textElement: ExcalidrawTextElement, zoomValue: number, formFactor: EditorInterface["formFactor"]) => {
+    center: GlobalPoint | import("@excalidraw/math").LocalPoint;
+    start: GlobalPoint;
+    end: GlobalPoint;
+    hitboxWidth: number;
+    hitboxHeight: number;
+} | null;
+export declare const isPointHittingTextAutoResizeHandle: (point: Readonly<{
+    x: number;
+    y: number;
+}>, textElement: ExcalidrawTextElement, zoomValue: number, formFactor: EditorInterface["formFactor"]) => boolean;

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

@@ -1,15 +1,15 @@
 import type { IMAGE_MIME_TYPES, UserIdleState, throttleRAF, MIME_TYPES, ColorTuple, EditorInterface } from "@excalidraw/common";
 import type { LinearElementEditor } from "@excalidraw/element";
 import type { MaybeTransformHandleType } from "@excalidraw/element";
-import type { PointerType, ExcalidrawLinearElement, NonDeletedExcalidrawElement, NonDeleted, TextAlign, ExcalidrawElement, GroupId, ExcalidrawBindableElement, Arrowhead, ChartType, FontFamilyValues, FileId, Theme, StrokeRoundness, ExcalidrawEmbeddableElement, ExcalidrawMagicFrameElement, ExcalidrawFrameLikeElement, ExcalidrawElementType, ExcalidrawIframeLikeElement, OrderedExcalidrawElement, ExcalidrawNonSelectionElement, ArrangeAlgorithms, BindMode } from "@excalidraw/element/types";
+import type { PointerType, ExcalidrawLinearElement, NonDeletedExcalidrawElement, NonDeleted, TextAlign, ExcalidrawElement, GroupId, ExcalidrawBindableElement, Arrowhead, FontFamilyValues, FileId, Theme, StrokeRoundness, ExcalidrawEmbeddableElement, ExcalidrawMagicFrameElement, ExcalidrawFrameLikeElement, ExcalidrawElementType, ExcalidrawIframeLikeElement, OrderedExcalidrawElement, ExcalidrawNonSelectionElement, ArrangeAlgorithms, BindMode, ExcalidrawTextElement } from "@excalidraw/element/types";
 import type { Merge, MaybePromise, ValueOf, MakeBrand } from "@excalidraw/common/utility-types";
 import type { CaptureUpdateActionType, DurableIncrement, EphemeralIncrement } from "@excalidraw/element";
+import type { GlobalPoint } from "@excalidraw/math";
 import type { Action } from "./actions/types";
 import type { Spreadsheet } from "./charts";
 import type { ClipboardData } from "./clipboard";
 import type App from "./components/App";
 import type Library from "./data/library";
-import type { FileSystemHandle } from "./data/filesystem";
 import type { ContextMenuItems } from "./components/ContextMenu";
 import type { SnapLine } from "./snapping";
 import type { ImportedDataState } from "./data/types";
@@ -17,6 +17,7 @@ import type { Language } from "./i18n";
 import type { isOverScrollBars } from "./scene/scrollbars";
 import type React from "react";
 import type { JSX } from "react";
+export type { App };
 export type SocketId = string & {
     _brand: "SocketId";
 };
@@ -128,6 +129,7 @@ export type StaticCanvasAppState = Readonly<_CommonCanvasAppState & {
     croppingElementId: AppState["croppingElementId"];
 }>;
 export type InteractiveCanvasAppState = Readonly<_CommonCanvasAppState & {
+    activeTool: AppState["activeTool"];
     activeEmbeddable: AppState["activeEmbeddable"];
     selectionElement: AppState["selectionElement"];
     selectedGroupIds: AppState["selectedGroupIds"];
@@ -135,6 +137,7 @@ export type InteractiveCanvasAppState = Readonly<_CommonCanvasAppState & {
     multiElement: AppState["multiElement"];
     newElement: AppState["newElement"];
     isBindingEnabled: AppState["isBindingEnabled"];
+    isMidpointSnappingEnabled: AppState["isMidpointSnappingEnabled"];
     suggestedBinding: AppState["suggestedBinding"];
     isRotating: AppState["isRotating"];
     elementsToHighlight: AppState["elementsToHighlight"];
@@ -150,6 +153,7 @@ export type InteractiveCanvasAppState = Readonly<_CommonCanvasAppState & {
     frameRendering: AppState["frameRendering"];
     shouldCacheIgnoreZoom: AppState["shouldCacheIgnoreZoom"];
     exportScale: AppState["exportScale"];
+    currentItemArrowType: AppState["currentItemArrowType"];
 }>;
 export type ObservedAppState = ObservedStandaloneAppState & ObservedElementsAppState;
 export type ObservedStandaloneAppState = {
@@ -215,9 +219,20 @@ export interface AppState {
      * - set on pointer down, updated during pointer move
      */
     selectionElement: NonDeletedExcalidrawElement | null;
+    /**
+     * tracking current arrow binding editor state (takes into account
+     * `bindingPreference` and keyboard modifiers (ctrl/alt)
+     */
     isBindingEnabled: boolean;
+    /** user arrow binding preference */
+    bindingPreference: "enabled" | "disabled";
+    /** user preference whether arrow snap to midpoints while binding */
+    isMidpointSnappingEnabled: boolean;
     startBoundElement: NonDeleted<ExcalidrawBindableElement> | null;
-    suggestedBinding: NonDeleted<ExcalidrawBindableElement> | null;
+    suggestedBinding: {
+        element: NonDeleted<ExcalidrawBindableElement>;
+        midPoint?: GlobalPoint;
+    } | null;
     frameToHighlight: NonDeleted<ExcalidrawFrameLikeElement> | null;
     frameRendering: {
         enabled: boolean;
@@ -230,7 +245,7 @@ export interface AppState {
     /**
      * set when a new text is created or when an existing text is being edited
      */
-    editingTextElement: NonDeletedExcalidrawElement | null;
+    editingTextElement: ExcalidrawTextElement | null;
     activeTool: {
         /**
          * indicates a previous tool we should revert back to if we deselect the
@@ -289,6 +304,10 @@ export interface AppState {
     } | {
         name: "elementLinkSelector";
         sourceElementId: ExcalidrawElement["id"];
+    } | {
+        name: "charts";
+        data: Spreadsheet;
+        rawText: string;
     };
     /**
      * Reflects user preference for whether the default sidebar should be docked.
@@ -311,7 +330,7 @@ export interface AppState {
     selectedElementsAreBeingDragged: boolean;
     shouldCacheIgnoreZoom: boolean;
     toast: {
-        message: string;
+        message: React.ReactNode;
         closable?: boolean;
         duration?: number;
     } | null;
@@ -333,21 +352,13 @@ export interface AppState {
     height: number;
     offsetTop: number;
     offsetLeft: number;
-    fileHandle: FileSystemHandle | null;
+    fileHandle: FileSystemFileHandle | null;
     collaborators: Map<SocketId, Collaborator>;
     stats: {
         open: boolean;
         /** bitmap. Use `STATS_PANELS` bit values */
         panels: number;
     };
-    currentChartType: ChartType;
-    pasteDialog: {
-        shown: false;
-        data: null;
-    } | {
-        shown: true;
-        data: Spreadsheet;
-    };
     showHyperlinkPopup: false | "info" | "editor";
     selectedLinearElement: LinearElementEditor | null;
     snapLines: readonly SnapLine[];
@@ -434,11 +445,36 @@ export type OnUserFollowedPayload = {
     userToFollow: UserToFollow;
     action: "FOLLOW" | "UNFOLLOW";
 };
+export type OnExportProgress = {
+    type: "progress";
+    message?: React.ReactNode;
+    /** 0-1 range */
+    progress?: number;
+};
 export interface ExcalidrawProps {
     onChange?: (elements: readonly OrderedExcalidrawElement[], appState: AppState, files: BinaryFiles) => void;
+    /**
+     * note: only subscribes if the props.onIncrement is defined on initial render
+     */
     onIncrement?: (event: DurableIncrement | EphemeralIncrement) => void;
     initialData?: (() => MaybePromise<ExcalidrawInitialDataState | null>) | MaybePromise<ExcalidrawInitialDataState | null>;
-    excalidrawAPI?: (api: ExcalidrawImperativeAPI) => void;
+    /**
+     * Invoked as soon as the Excalidraw API is available
+     * NOTE editor is not yet mounted, and state is not yet initialized
+     */
+    onExcalidrawAPI?: (api: ExcalidrawImperativeAPI | null) => void;
+    /**
+     * Invoked once the editor root is mounted.
+     */
+    onMount?: (payload: ExcalidrawMountPayload) => void;
+    /**
+     * Invoked when the editor root is unmounted.
+     */
+    onUnmount?: () => void;
+    /**
+     * Invoked once the initial scene is loaded.
+     */
+    onInitialize?: (api: ExcalidrawImperativeAPI) => void;
     isCollaborating?: boolean;
     onPointerUpdate?: (payload: {
         pointer: {
@@ -497,6 +533,29 @@ export interface ExcalidrawProps {
     strokeColorTopPicks?: ColorTuple;
     backgroundColorTopPicks?: ColorTuple;
     renderScrollbars?: boolean;
+    /**
+     * Called before exporting to a file.
+     *
+     * Allows the host app to intercept and delay saving until async operations
+     * (e.g., images are loaded) complete.
+     *
+     * If Promise/AsyncGenerator is returned, a progress toast will be shown
+     * until the operation completes. Generator can yield progress updates.
+     */
+    onExport?: (
+    /** type of export. Currently we only call for JSON exports or
+     * JSON-embedded PNG (which is also identified as `json` type here)*/
+    type: "json", data: {
+        elements: readonly ExcalidrawElement[];
+        appState: AppState;
+        files: BinaryFiles;
+    }, options: {
+        /** signal that gets aborted if user cancels the export (e.g. closes
+         * the native file picker dialog). In that case, you can either
+         * return immediately, or throw AbortError.
+         */
+        signal: AbortSignal;
+    }) => MaybePromise<void> | AsyncGenerator<OnExportProgress, void>;
 }
 export type SceneData = {
     elements?: ImportedDataState["elements"];
@@ -548,6 +607,8 @@ export type AppProps = Merge<ExcalidrawProps, {
 export type AppClassProperties = {
     props: AppProps;
     state: AppState;
+    api: App["api"];
+    sessionExportThemeOverride: App["sessionExportThemeOverride"];
     interactiveCanvas: HTMLCanvasElement | null;
     /** static canvas */
     canvas: HTMLCanvasElement;
@@ -588,7 +649,11 @@ export type AppClassProperties = {
     onPointerUpEmitter: App["onPointerUpEmitter"];
     updateEditorAtom: App["updateEditorAtom"];
     onPointerDownEmitter: App["onPointerDownEmitter"];
+    onEvent: App["onEvent"];
+    onStateChange: App["onStateChange"];
+    lastPointerMoveCoords: App["lastPointerMoveCoords"];
     bindModeHandler: App["bindModeHandler"];
+    setAppState: App["setAppState"];
 };
 export type PointerDownState = Readonly<{
     origin: Readonly<{
@@ -649,7 +714,18 @@ export type PointerDownState = Readonly<{
     };
 }>;
 export type UnsubscribeCallback = () => void;
+export type ExcalidrawMountPayload = {
+    excalidrawAPI: ExcalidrawImperativeAPI;
+    container: HTMLDivElement | null;
+};
+export type ExcalidrawImperativeAPIEventMap = {
+    "editor:mount": [payload: ExcalidrawMountPayload];
+    "editor:initialize": [api: ExcalidrawImperativeAPI];
+    "editor:unmount": [];
+};
 export interface ExcalidrawImperativeAPI {
+    /** Whether the editor has been unmounted and the API is no longer usable. */
+    isDestroyed: boolean;
     updateScene: InstanceType<typeof App>["updateScene"];
     applyDeltas: InstanceType<typeof App>["applyDeltas"];
     mutateElement: InstanceType<typeof App>["mutateElement"];
@@ -688,6 +764,8 @@ export interface ExcalidrawImperativeAPI {
     onPointerUp: (callback: (activeTool: AppState["activeTool"], pointerDownState: PointerDownState, event: PointerEvent) => void) => UnsubscribeCallback;
     onScrollChange: (callback: (scrollX: number, scrollY: number, zoom: Zoom) => void) => UnsubscribeCallback;
     onUserFollow: (callback: (payload: OnUserFollowedPayload) => void) => UnsubscribeCallback;
+    onStateChange: InstanceType<typeof App>["onStateChange"];
+    onEvent: InstanceType<typeof App>["onEvent"];
 }
 export type FrameNameBounds = {
     x: number;
@@ -728,4 +806,3 @@ export type Offsets = Partial<{
     bottom: number;
     left: number;
 }>;
-export {};

package/dist/types/excalidraw/wysiwyg/textWysiwyg.d.ts

@@ -1,7 +1,7 @@
 import type { ExcalidrawElement, ExcalidrawTextElement } from "@excalidraw/element/types";
 import type App from "../components/App";
 type SubmitHandler = () => void;
-export declare const textWysiwyg: ({ id, onChange, onSubmit, getViewportCoords, element, canvas, excalidrawContainer, app, autoSelect, }: {
+export declare const textWysiwyg: ({ id, onChange, onSubmit, getViewportCoords, element, canvas, excalidrawContainer, app, autoSelect, initialCaretSceneCoords, }: {
     id: ExcalidrawElement["id"];
     /**
      * textWysiwyg only deals with `originalText`
@@ -20,5 +20,9 @@ export declare const textWysiwyg: ({ id, onChange, onSubmit, getViewportCoords,
     excalidrawContainer: HTMLDivElement | null;
     app: App;
     autoSelect?: boolean;
+    initialCaretSceneCoords?: {
+        x: number;
+        y: number;
+    } | null;
 }) => SubmitHandler;
 export {};

package/dist/types/math/src/point.d.ts

@@ -1,4 +1,4 @@
-import type { LocalPoint, GlobalPoint, Radians, Degrees, Vector } from "./types";
+import type { LocalPoint, GlobalPoint, Radians, Degrees, Vector, GlobalCoord, LocalCoord } from "./types";
 /**
  * Create a properly typed Point instance from the X and Y coordinates.
  *
@@ -7,6 +7,11 @@ import type { LocalPoint, GlobalPoint, Radians, Degrees, Vector } from "./types"
  * @returns The branded and created point
  */
 export declare function pointFrom<Point extends GlobalPoint | LocalPoint>(x: number, y: number): Point;
+export declare function pointFrom<Coord extends GlobalCoord | LocalCoord>(coords: Coord): Coord extends GlobalCoord ? GlobalPoint : LocalPoint;
+export declare function pointFrom<Point extends GlobalPoint | LocalPoint>(coords: {
+    x: number;
+    y: number;
+}): Point;
 /**
  * Converts and remaps an array containing a pair of numbers to Point.
  *
@@ -52,7 +57,7 @@ export declare function pointsEqual<Point extends GlobalPoint | LocalPoint>(a: P
  * @param angle The radians to rotate the point by
  * @returns The rotated point
  */
-export declare function pointRotateRads<Point extends GlobalPoint | LocalPoint>([x, y]: Point, [cx, cy]: Point, angle: Radians): Point;
+export declare function pointRotateRads<Point extends GlobalPoint | LocalPoint>(point: Point, center: Point, angle: Radians): Point;
 /**
  * Rotate a point by [angle] degree.
  *