@zsviczian/excalidraw 0.18.0-6 → 0.18.0-60

package/types/excalidraw/components/shapes.d.ts

@@ -1,3 +1,4 @@
+import type { AppClassProperties } from "../types";
 export declare const SHAPES: readonly [{
     readonly icon: import("react/jsx-runtime").JSX.Element;
     readonly value: "selection";
@@ -48,9 +49,58 @@ export declare const SHAPES: readonly [{
     readonly fillable: false;
 }, {
     readonly icon: import("react/jsx-runtime").JSX.Element;
-    readonly value: "image";
-    readonly key: null;
-    readonly numericKey: "9";
+    readonly value: "eraser";
+    readonly key: "e";
+    readonly numericKey: "0";
+    readonly fillable: false;
+}];
+export declare const getToolbarTools: (app: AppClassProperties) => readonly [{
+    readonly icon: import("react/jsx-runtime").JSX.Element;
+    readonly value: "selection";
+    readonly key: "v";
+    readonly numericKey: "1";
+    readonly fillable: true;
+}, {
+    readonly icon: import("react/jsx-runtime").JSX.Element;
+    readonly value: "rectangle";
+    readonly key: "r";
+    readonly numericKey: "2";
+    readonly fillable: true;
+}, {
+    readonly icon: import("react/jsx-runtime").JSX.Element;
+    readonly value: "diamond";
+    readonly key: "d";
+    readonly numericKey: "3";
+    readonly fillable: true;
+}, {
+    readonly icon: import("react/jsx-runtime").JSX.Element;
+    readonly value: "ellipse";
+    readonly key: "o";
+    readonly numericKey: "4";
+    readonly fillable: true;
+}, {
+    readonly icon: import("react/jsx-runtime").JSX.Element;
+    readonly value: "arrow";
+    readonly key: "a";
+    readonly numericKey: "5";
+    readonly fillable: true;
+}, {
+    readonly icon: import("react/jsx-runtime").JSX.Element;
+    readonly value: "line";
+    readonly key: "l";
+    readonly numericKey: "6";
+    readonly fillable: true;
+}, {
+    readonly icon: import("react/jsx-runtime").JSX.Element;
+    readonly value: "freedraw";
+    readonly key: readonly ["p", "x"];
+    readonly numericKey: "7";
+    readonly fillable: false;
+}, {
+    readonly icon: import("react/jsx-runtime").JSX.Element;
+    readonly value: "text";
+    readonly key: "t";
+    readonly numericKey: "8";
     readonly fillable: false;
 }, {
     readonly icon: import("react/jsx-runtime").JSX.Element;
@@ -58,5 +108,65 @@ export declare const SHAPES: readonly [{
     readonly key: "e";
     readonly numericKey: "0";
     readonly fillable: false;
-}];
-export declare const findShapeByKey: (key: string) => "line" | "ellipse" | "text" | "rectangle" | "diamond" | "image" | "selection" | "arrow" | "freedraw" | "eraser" | null;
+}] | readonly [{
+    readonly value: "lasso";
+    readonly icon: import("react/jsx-runtime").JSX.Element;
+    readonly key: "v";
+    readonly numericKey: "1";
+    readonly fillable: true;
+}, ...({
+    readonly icon: import("react/jsx-runtime").JSX.Element;
+    readonly value: "selection";
+    readonly key: "v";
+    readonly numericKey: "1";
+    readonly fillable: true;
+} | {
+    readonly icon: import("react/jsx-runtime").JSX.Element;
+    readonly value: "rectangle";
+    readonly key: "r";
+    readonly numericKey: "2";
+    readonly fillable: true;
+} | {
+    readonly icon: import("react/jsx-runtime").JSX.Element;
+    readonly value: "diamond";
+    readonly key: "d";
+    readonly numericKey: "3";
+    readonly fillable: true;
+} | {
+    readonly icon: import("react/jsx-runtime").JSX.Element;
+    readonly value: "ellipse";
+    readonly key: "o";
+    readonly numericKey: "4";
+    readonly fillable: true;
+} | {
+    readonly icon: import("react/jsx-runtime").JSX.Element;
+    readonly value: "arrow";
+    readonly key: "a";
+    readonly numericKey: "5";
+    readonly fillable: true;
+} | {
+    readonly icon: import("react/jsx-runtime").JSX.Element;
+    readonly value: "line";
+    readonly key: "l";
+    readonly numericKey: "6";
+    readonly fillable: true;
+} | {
+    readonly icon: import("react/jsx-runtime").JSX.Element;
+    readonly value: "freedraw";
+    readonly key: readonly ["p", "x"];
+    readonly numericKey: "7";
+    readonly fillable: false;
+} | {
+    readonly icon: import("react/jsx-runtime").JSX.Element;
+    readonly value: "text";
+    readonly key: "t";
+    readonly numericKey: "8";
+    readonly fillable: false;
+} | {
+    readonly icon: import("react/jsx-runtime").JSX.Element;
+    readonly value: "eraser";
+    readonly key: "e";
+    readonly numericKey: "0";
+    readonly fillable: false;
+})[]];
+export declare const findShapeByKey: (key: string, app: AppClassProperties) => "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "freedraw" | "lasso" | "eraser" | null;

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

@@ -2,7 +2,7 @@ import { IMAGE_MIME_TYPES, MIME_TYPES } from "@excalidraw/common";
 import type { ValueOf } from "@excalidraw/common/utility-types";
 import type { ExcalidrawElement, FileId } from "@excalidraw/element/types";
 import type { AppState, DataURL, LibraryItem } from "../types";
-import type { FileSystemHandle } from "./filesystem";
+import type { FileSystemHandle } from "browser-fs-access";
 import type { ImportedLibraryData } from "./types";
 export declare const getMimeType: (blob: Blob | string) => string;
 export declare const getFileHandleType: (handle: FileSystemHandle | null) => string | null;
@@ -40,12 +40,8 @@ export declare const SVGStringToFile: (SVGString: string, filename?: string) =>
     type: typeof MIME_TYPES.svg;
 };
 export declare const ImageURLToFile: (imageUrl: string, filename?: string) => Promise<File | undefined>;
-export declare const getFileFromEvent: (event: React.DragEvent<HTMLDivElement>) => Promise<{
-    file: File | null;
-    fileHandle: FileSystemHandle | null;
-}>;
-export declare const getFileHandle: (event: React.DragEvent<HTMLDivElement>) => Promise<FileSystemHandle | null>;
-export declare const createFile: (blob: File | Blob | ArrayBuffer, mimeType: ValueOf<typeof MIME_TYPES>, name: string | undefined) => File;
+export declare const getFileHandle: (event: DragEvent | React.DragEvent | DataTransferItem) => Promise<FileSystemHandle | null>;
+export declare const createFile: (blob: File | Blob | ArrayBuffer, mimeType: string, name: string | undefined) => File;
 /** attempts to detect correct mimeType if none is set, or if an image
  * has an incorrect extension.
  * Note: doesn't handle missing .excalidraw/.excalidrawlib extension  */

package/types/excalidraw/data/reconcile.d.ts

@@ -3,4 +3,5 @@ import type { MakeBrand } from "@excalidraw/common/utility-types";
 import type { AppState } from "../types";
 export type ReconciledExcalidrawElement = OrderedExcalidrawElement & MakeBrand<"ReconciledElement">;
 export type RemoteExcalidrawElement = OrderedExcalidrawElement & MakeBrand<"RemoteExcalidrawElement">;
+export declare const shouldDiscardRemoteElement: (localAppState: AppState, local: OrderedExcalidrawElement | undefined, remote: RemoteExcalidrawElement) => boolean;
 export declare const reconcileElements: (localElements: readonly OrderedExcalidrawElement[], remoteElements: readonly RemoteExcalidrawElement[], localAppState: AppState) => ReconciledExcalidrawElement[];

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

@@ -1,4 +1,4 @@
-import type { ExcalidrawElement, OrderedExcalidrawElement } from "@excalidraw/element/types";
+import type { ElementsMap, ExcalidrawArrowElement, ExcalidrawElement, ExcalidrawLinearElement, ExcalidrawSelectionElement, ExcalidrawTextElement, 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">;
@@ -8,14 +8,19 @@ export type RestoredDataState = {
     appState: RestoredAppState;
     files: BinaryFiles;
 };
-export declare const restoreElements: (elements: ImportedDataState["elements"], localElements: readonly ExcalidrawElement[] | null | undefined, opts?: {
+export declare const restoreElement: (element: Exclude<ExcalidrawElement, ExcalidrawSelectionElement>, elementsMap: Readonly<ElementsMap>, opts?: {
+    deleteInvisibleElements?: boolean;
+}) => ExcalidrawLinearElement | import("@excalidraw/element/types").ExcalidrawRectangleElement | import("@excalidraw/element/types").ExcalidrawDiamondElement | import("@excalidraw/element/types").ExcalidrawEllipseElement | import("@excalidraw/element/types").ExcalidrawEmbeddableElement | import("@excalidraw/element/types").ExcalidrawIframeElement | import("@excalidraw/element/types").ExcalidrawImageElement | import("@excalidraw/element/types").ExcalidrawFrameElement | import("@excalidraw/element/types").ExcalidrawMagicFrameElement | ExcalidrawTextElement | import("@excalidraw/element/types").ExcalidrawFreeDrawElement | ExcalidrawArrowElement | null;
+export declare const restoreElements: (targetElements: ImportedDataState["elements"], localElements: readonly ExcalidrawElement[] | null | undefined, opts?: {
     refreshDimensions?: boolean;
     repairBindings?: boolean;
+    deleteInvisibleElements?: boolean;
 } | undefined) => OrderedExcalidrawElement[];
 export declare const restoreAppState: (appState: ImportedDataState["appState"], localAppState: Partial<AppState> | null | undefined) => RestoredAppState;
 export declare const restore: (data: Pick<ImportedDataState, "appState" | "elements" | "files"> | null, localAppState: Partial<AppState> | null | undefined, localElements: readonly ExcalidrawElement[] | null | undefined, elementsConfig?: {
     refreshDimensions?: boolean;
     repairBindings?: boolean;
+    deleteInvisibleElements?: boolean;
 }) => RestoredDataState;
 export declare const restoreLibraryItems: (libraryItems: ImportedDataState["libraryItems"], defaultStatus: LibraryItem["status"]) => LibraryItem[];
 export {};

package/types/excalidraw/data/transform.d.ts

@@ -1,4 +1,4 @@
-import type { ElementConstructorOpts } from "@excalidraw/element/newElement";
+import type { ElementConstructorOpts } from "@excalidraw/element";
 import type { ExcalidrawBindableElement, ExcalidrawElement, ExcalidrawFrameElement, ExcalidrawFreeDrawElement, ExcalidrawGenericElement, ExcalidrawIframeLikeElement, ExcalidrawImageElement, ExcalidrawLinearElement, ExcalidrawMagicFrameElement, ExcalidrawSelectionElement, ExcalidrawTextElement, FileId, FontFamilyValues, TextAlign, VerticalAlign } from "@excalidraw/element/types";
 import type { MarkOptional } from "@excalidraw/common/utility-types";
 export type ValidLinearElement = {

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

@@ -1,7 +1,7 @@
 import type { VERSIONS } from "@excalidraw/common";
 import type { ExcalidrawElement } from "@excalidraw/element/types";
 import type { cleanAppStateForExport } from "../appState";
-import type { AppState, BinaryFiles, LibraryItems, LibraryItems_anyVersion } from "../types";
+import type { AppState, BinaryFiles, LibraryItem, LibraryItems, LibraryItems_anyVersion } from "../types";
 export interface ExportedDataState {
     type: string;
     version: number;
@@ -43,3 +43,6 @@ export interface ImportedLibraryData extends Partial<ExportedLibraryData> {
     /** @deprecated v1 */
     library?: LibraryItems;
 }
+export type ExcalidrawLibraryIds = {
+    itemIds: LibraryItem["id"][];
+};

package/types/excalidraw/editor-jotai.d.ts

@@ -1,14 +1,14 @@
-import { atom, createStore, type PrimitiveAtom } from "jotai";
+import { atom, createStore, type PrimitiveAtom, type WritableAtom } from "jotai";
 import { createIsolation } from "jotai-scope";
-export { atom, PrimitiveAtom };
+export { atom, PrimitiveAtom, WritableAtom };
 export declare const useAtom: typeof import("jotai").useAtom, useSetAtom: typeof import("jotai").useSetAtom, useAtomValue: typeof import("jotai").useAtomValue, useStore: (options?: {
     store?: {
         get: <Value>(atom: import("jotai").Atom<Value>) => Value;
-        set: <Value_1, Args extends unknown[], Result>(atom: import("jotai").WritableAtom<Value_1, Args, Result>, ...args: Args) => Result;
+        set: <Value_1, Args extends unknown[], Result>(atom: WritableAtom<Value_1, Args, Result>, ...args: Args) => Result;
         sub: (atom: import("jotai").Atom<unknown>, listener: () => void) => () => void;
     } | ({
         get: <Value_2>(atom: import("jotai").Atom<Value_2>) => Value_2;
-        set: <Value_1_1, Args_1 extends unknown[], Result_1>(atom: import("jotai").WritableAtom<Value_1_1, Args_1, Result_1>, ...args: Args_1) => Result_1;
+        set: <Value_1_1, Args_1 extends unknown[], Result_1>(atom: WritableAtom<Value_1_1, Args_1, Result_1>, ...args: Args_1) => Result_1;
         sub: (atom: import("jotai").Atom<unknown>, listener: () => void) => () => void;
     } & {
         dev4_get_internal_weak_map: () => WeakMap<import("jotai").Atom<unknown>, {
@@ -29,11 +29,11 @@ export declare const useAtom: typeof import("jotai").useAtom, useSetAtom: typeof
     }) | undefined;
 } | undefined) => {
     get: <Value_3>(atom: import("jotai").Atom<Value_3>) => Value_3;
-    set: <Value_1_2, Args_2 extends unknown[], Result_2>(atom: import("jotai").WritableAtom<Value_1_2, Args_2, Result_2>, ...args: Args_2) => Result_2;
+    set: <Value_1_2, Args_2 extends unknown[], Result_2>(atom: WritableAtom<Value_1_2, Args_2, Result_2>, ...args: Args_2) => Result_2;
     sub: (atom: import("jotai").Atom<unknown>, listener: () => void) => () => void;
 } | ({
     get: <Value_4>(atom: import("jotai").Atom<Value_4>) => Value_4;
-    set: <Value_1_3, Args_3 extends unknown[], Result_3>(atom: import("jotai").WritableAtom<Value_1_3, Args_3, Result_3>, ...args: Args_3) => Result_3;
+    set: <Value_1_3, Args_3 extends unknown[], Result_3>(atom: WritableAtom<Value_1_3, Args_3, Result_3>, ...args: Args_3) => Result_3;
     sub: (atom: import("jotai").Atom<unknown>, listener: () => void) => () => void;
 } & {
     dev4_get_internal_weak_map: () => WeakMap<import("jotai").Atom<unknown>, {

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

@@ -4,8 +4,6 @@ import type App from "../components/App";
 export declare class EraserTrail extends AnimatedTrail {
     private elementsToErase;
     private groupsToErase;
-    private segmentsCache;
-    private geometricShapesCache;
     constructor(animationFrameHandler: AnimationFrameHandler, app: App);
     startPath(x: number, y: number): void;
     addPointToPath(x: number, y: number, restore?: boolean): string[];

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

@@ -1,7 +1,7 @@
 import { type FontMetadata } from "@excalidraw/common";
 import type { ExcalidrawElement, ExcalidrawTextElement } from "@excalidraw/element/types";
+import type { Scene } from "@excalidraw/element";
 import { ExcalidrawFontFace } from "./ExcalidrawFontFace";
-import type Scene from "../scene/Scene";
 export declare class Fonts {
     static readonly loadedFontsCache: Set<string>;
     private static _registered;

package/types/excalidraw/history.d.ts

@@ -1,40 +1,48 @@
+import { Emitter } from "@excalidraw/common";
+import { StoreDelta } from "@excalidraw/element";
+import type { StoreSnapshot, Store } from "@excalidraw/element";
 import type { SceneElementsMap } from "@excalidraw/element/types";
-import { Emitter } from "./emitter";
-import type { AppStateChange, ElementsChange } from "./change";
-import type { Snapshot } from "./store";
 import type { AppState } from "./types";
+export declare class HistoryDelta extends StoreDelta {
+    /**
+     * Apply the delta to the passed elements and appState, does not modify the snapshot.
+     */
+    applyTo(elements: SceneElementsMap, appState: AppState, snapshot: StoreSnapshot): [SceneElementsMap, AppState, boolean];
+    /**
+     * Overriding once to avoid type casting everywhere.
+     */
+    static calculate(prevSnapshot: StoreSnapshot, nextSnapshot: StoreSnapshot): HistoryDelta;
+    /**
+     * Overriding once to avoid type casting everywhere.
+     */
+    static inverse(delta: StoreDelta): HistoryDelta;
+    /**
+     * Overriding once to avoid type casting everywhere.
+     */
+    static applyLatestChanges(delta: StoreDelta, prevElements: SceneElementsMap, nextElements: SceneElementsMap, modifierOptions?: "deleted" | "inserted"): HistoryDelta;
+}
 export declare class HistoryChangedEvent {
     readonly isUndoStackEmpty: boolean;
     readonly isRedoStackEmpty: boolean;
     constructor(isUndoStackEmpty?: boolean, isRedoStackEmpty?: boolean);
 }
 export declare class History {
+    private readonly store;
     readonly onHistoryChangedEmitter: Emitter<[HistoryChangedEvent]>;
-    private readonly undoStack;
-    private readonly redoStack;
+    readonly undoStack: HistoryDelta[];
+    readonly redoStack: HistoryDelta[];
     get isUndoStackEmpty(): boolean;
     get isRedoStackEmpty(): boolean;
+    constructor(store: Store);
     clear(): void;
     /**
-     * Record a local change which will go into the history
+     * Record a non-empty local durable increment, which will go into the undo stack..
+     * Do not re-record history entries, which were already pushed to undo / redo stack, as part of history action.
      */
-    record(elementsChange: ElementsChange, appStateChange: AppStateChange): void;
-    undo(elements: SceneElementsMap, appState: AppState, snapshot: Readonly<Snapshot>): void | [SceneElementsMap, AppState];
-    redo(elements: SceneElementsMap, appState: AppState, snapshot: Readonly<Snapshot>): void | [SceneElementsMap, AppState];
+    record(delta: StoreDelta): void;
+    undo(elements: SceneElementsMap, appState: AppState): void | [SceneElementsMap, AppState];
+    redo(elements: SceneElementsMap, appState: AppState): void | [SceneElementsMap, AppState];
     private perform;
     private static pop;
     private static push;
 }
-export declare class HistoryEntry {
-    readonly appStateChange: AppStateChange;
-    readonly elementsChange: ElementsChange;
-    private constructor();
-    static create(appStateChange: AppStateChange, elementsChange: ElementsChange): HistoryEntry;
-    inverse(): HistoryEntry;
-    applyTo(elements: SceneElementsMap, appState: AppState, snapshot: Readonly<Snapshot>): [SceneElementsMap, AppState, boolean];
-    /**
-     * Apply latest (remote) changes to the history entry, creates new instance of `HistoryEntry`.
-     */
-    applyLatestChanges(elements: SceneElementsMap): HistoryEntry;
-    isEmpty(): boolean;
-}

package/types/excalidraw/hooks/useEmitter.d.ts

@@ -1,2 +1,2 @@
-import type { Emitter } from "../emitter";
+import type { Emitter } from "@excalidraw/common";
 export declare const useEmitter: <TEvent extends unknown>(emitter: Emitter<[TEvent]>, initialState: TEvent) => TEvent;

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

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

package/types/excalidraw/hooks/useOutsideClick.d.ts

@@ -1,6 +1,8 @@
 export declare function useOutsideClick<T extends HTMLElement>(ref: React.RefObject<T | null>, 
 /** if performance is of concern, memoize the callback */
-callback: (event: Event) => void, 
+callback: (event: Event & {
+    target: T;
+}) => void, 
 /**
  * Optional callback which is called on every click.
  *

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

@@ -0,0 +1,14 @@
+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: () => {
+    saveCaretPosition: () => void;
+    restoreCaretPosition: () => void;
+    clearSavedPosition: () => void;
+    hasSavedPosition: boolean;
+};
+export declare const temporarilyDisableTextEditorBlur: (duration?: number) => void;

package/types/excalidraw/index.d.ts

@@ -9,40 +9,41 @@ import "./fonts/fonts.css";
 import type { ExcalidrawProps } from "./types";
 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/textElement";
-export { isInvisiblySmallElement } from "@excalidraw/element/sizeHelpers";
+export { getTextFromElements } from "@excalidraw/element";
+export { isInvisiblySmallElement } from "@excalidraw/element";
 export { defaultLang, useI18n, languages } from "./i18n";
-export { restore, restoreAppState, restoreElements, restoreLibraryItems, } from "./data/restore";
+export { restore, restoreAppState, restoreElement, restoreElements, restoreLibraryItems, } from "./data/restore";
 export { reconcileElements } from "./data/reconcile";
 export { exportToCanvas, exportToBlob, exportToSvg, exportToClipboard, } from "@excalidraw/utils/export";
 export { getCommonBoundingBox } from "@excalidraw/element/bounds";
 export { getMaximumGroups } from "@excalidraw/element/groups";
-export { determineFocusDistance } from "@excalidraw/element/binding";
 export { measureText } from "@excalidraw/element/textMeasurements";
 export { wrapText } from "@excalidraw/element/textWrapping";
 export { getLineHeight } from "@excalidraw/common";
 export { getFontString, getFontFamilyString } from "@excalidraw/common";
 export { getBoundTextMaxWidth } from "@excalidraw/element/textElement";
 export { mermaidToExcalidraw } from "./components/TTDDialog/MermaidToExcalidrawLib";
-export { destroyObsidianUtils, registerLocalFont, getFontFamilies, registerFontsInCSS, getCSSFontDefinition, loadSceneFonts, getSharedMermaidInstance, loadMermaid, intersectElementWithLine, } from "../excalidraw/obsidianUtils";
+export { registerLocalFont, getFontMetrics, getFontFamilies, registerFontsInCSS, getCSSFontDefinition, loadSceneFonts, getSharedMermaidInstance, loadMermaid, intersectElementWithLine, } from "../excalidraw/obsidianUtils";
 export { refreshTextDimensions } from "@excalidraw/element/newElement";
+export { syncMovedIndices, syncInvalidIndices } from "@excalidraw/element";
 export { getContainerElement } from "@excalidraw/element/textElement";
 export { serializeAsJSON, serializeLibraryAsJSON } from "./data/json";
 export { loadFromBlob, loadSceneOrLibraryFromBlob, loadLibraryFromBlob, } from "./data/blob";
-export { getFreeDrawSvgPath } from "@excalidraw/element/renderElement";
+export { getFreeDrawSvgPath } from "@excalidraw/element";
 export { mergeLibraryItems, getLibraryItemsHash } from "./data/library";
-export { isLinearElement } from "@excalidraw/element/typeChecks";
-export { FONT_FAMILY, THEME, MIME_TYPES, ROUNDNESS, DEFAULT_LASER_COLOR, UserIdleState, normalizeLink, } from "@excalidraw/common";
-export { mutateElement, newElementWith, bumpVersion, } from "@excalidraw/element/mutateElement";
-export { CaptureUpdateAction } from "./store";
+export { isLinearElement } from "@excalidraw/element";
+export { FONT_FAMILY, THEME, MIME_TYPES, ROUNDNESS, DEFAULT_LASER_COLOR, UserIdleState, normalizeLink, sceneCoordsToViewportCoords, viewportCoordsToSceneCoords, getFormFactor, safelyParseJSON, //zsviczian
+destroyObsidianUtils, } from "@excalidraw/common";
+export { mutateElement, newElementWith, bumpVersion, } from "@excalidraw/element";
+export { CaptureUpdateAction } from "@excalidraw/element";
 export { parseLibraryTokensFromUrl, useHandleLibrary } from "./data/library";
-export { sceneCoordsToViewportCoords, viewportCoordsToSceneCoords, safelyParseJSON, } from "@excalidraw/common";
 export { getEmbedLink } from "@excalidraw/element/embeddable";
 export { Sidebar } from "./components/Sidebar/Sidebar";
 export { Button } from "./components/Button";
 export { Footer };
 export { MainMenu };
-export { useDevice } from "./components/App";
+export { Ellipsify } from "./components/Ellipsify";
+export { useEditorInterface, useStylesPanelMode } from "./components/App";
 export { WelcomeScreen };
 export { LiveCollaborationTrigger };
 export { Stats } from "./components/Stats";
@@ -51,9 +52,9 @@ export { TTDDialog } from "./components/TTDDialog/TTDDialog";
 export { TTDDialogTrigger } from "./components/TTDDialog/TTDDialogTrigger";
 export { zoomToFitBounds } from "./actions/actionCanvas";
 export { convertToExcalidrawElements } from "./data/transform";
-export { getCommonBounds, getVisibleSceneBounds, } from "@excalidraw/element/bounds";
+export { getCommonBounds, getVisibleSceneBounds } from "@excalidraw/element";
 export { elementsOverlappingBBox, isElementInsideBBox, elementPartiallyOverlapsWithOrContainsBBox, } from "@excalidraw/utils/withinBounds";
 export { DiagramToCodePlugin } from "./components/DiagramToCodePlugin/DiagramToCodePlugin";
 export { getDataURL } from "./data/blob";
-export { isElementLink } from "@excalidraw/element/elementLink";
-export { setCustomTextMetricsProvider } from "@excalidraw/element/textMeasurements";
+export { isElementLink } from "@excalidraw/element";
+export { setCustomTextMetricsProvider } from "@excalidraw/element";

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

@@ -5,6 +5,7 @@ export declare class LassoTrail extends AnimatedTrail {
     private intersectedElements;
     private enclosedElements;
     private elementsSegments;
+    private canvasTranslate;
     private keepPreviousSelection;
     constructor(animationFrameHandler: AnimationFrameHandler, app: App);
     startPath(x: number, y: number, keepPreviousSelection?: boolean): void;

package/types/excalidraw/lasso/utils.d.ts

@@ -1,8 +1,9 @@
 import type { ElementsSegmentsMap, GlobalPoint } from "@excalidraw/math/types";
-import type { ExcalidrawElement } from "@excalidraw/element/types";
+import type { ElementsMap, ExcalidrawElement } from "@excalidraw/element/types";
 export declare const getLassoSelectedElementIds: (input: {
     lassoPath: GlobalPoint[];
     elements: readonly ExcalidrawElement[];
+    elementsMap: ElementsMap;
     elementsSegments: ElementsSegmentsMap;
     intersectedElements: Set<ExcalidrawElement["id"]>;
     enclosedElements: Set<ExcalidrawElement["id"]>;

package/types/excalidraw/obsidianUtils.d.ts

@@ -1,19 +1,23 @@
-import { GlobalPoint } from "@excalidraw/math/types";
-import type { MermaidToExcalidrawLibProps } from "./components/TTDDialog/common";
-import type { ElementsMap, ExcalidrawElement, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
+import { type GlobalPoint } from "@excalidraw/math/types";
 import type { FontMetadata } from "@excalidraw/common";
-import type { AppState } from "./types";
-export declare let hostPlugin: any;
-export declare function destroyObsidianUtils(): void;
-export declare function initializeObsidianUtils(): void;
-export declare function getAreaLimit(): any;
-export declare function getWidthHeightLimit(): any;
+import type { ElementsMap, ExcalidrawElement, ExcalidrawTextElement, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
+import type { AppClassProperties, AppState } from "./types";
+import type { MermaidToExcalidrawLibProps } from "./components/TTDDialog/common";
 export declare function allowDoubleTapEraser(): any;
+export declare function isPanWithRightMouseEnabled(): boolean;
 export declare function getMaxZoom(): number;
 export declare function isExcaliBrainView(): any;
 export declare function getExcalidrawContentEl(): HTMLElement;
 export declare function hideFreedrawPenmodeCursor(): boolean;
 export declare function getOpenAIDefaultVisionModel(): any;
+export declare function getFontMetrics(fontFamily: ExcalidrawTextElement["fontFamily"], fontSize?: number): {
+    unitsPerEm: number;
+    ascender: number;
+    descender: number;
+    lineHeight: number;
+    baseline: number;
+    fontString: string;
+};
 export declare function registerLocalFont(fontMetrics: FontMetadata & {
     name: string;
 }, uri: string): void;
@@ -26,3 +30,12 @@ export declare function isTouchInPenMode(appState: AppState, event: React.Pointe
 export declare function getSharedMermaidInstance(): Promise<MermaidToExcalidrawLibProps>;
 export declare function loadMermaid(): Promise<MermaidToExcalidrawLibProps>;
 export declare const intersectElementWithLine: (element: ExcalidrawElement, a: GlobalPoint, b: GlobalPoint, gap: number | undefined, elementsMap: ElementsMap) => GlobalPoint[] | undefined;
+export declare const disableDoubleClickTextEditing: () => any;
+export declare const getZoomStep: () => any;
+export declare const getZoomMin: () => any;
+export declare const getZoomMax: () => any;
+export declare const runAction: (action: string) => void;
+export declare const t2: (key: string) => string;
+export declare const shouldDisableZoom: (appState: AppState) => boolean;
+export declare const isFullPanelMode: (app: AppClassProperties) => boolean;
+export declare const isContextMenuDisabled: () => boolean;

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

@@ -0,0 +1,12 @@
+export type Animation<R extends object> = (params: {
+    deltaTime: number;
+    state?: R;
+}) => R | null | undefined;
+export declare class AnimationController {
+    private static isRunning;
+    private static animations;
+    static start<R extends object>(key: string, animation: Animation<R>): void;
+    private static tick;
+    static running(key: string): boolean;
+    static cancel(key: string): void;
+}

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

@@ -1,6 +1,6 @@
 import type { StaticCanvasRenderConfig } from "../scene/types";
-import type { StaticCanvasAppState, AppState } from "../types";
-export declare const fillCircle: (context: CanvasRenderingContext2D, cx: number, cy: number, radius: number, stroke?: boolean) => void;
+import type { AppState, StaticCanvasAppState } from "../types";
+export declare const fillCircle: (context: CanvasRenderingContext2D, cx: number, cy: number, radius: number, stroke: boolean, fill?: boolean) => void;
 export declare const getNormalizedCanvasDimensions: (canvas: HTMLCanvasElement, scale: number) => [number, number];
 export declare const bootstrapCanvas: ({ canvas, scale, normalizedWidth, normalizedHeight, theme, isExporting, viewBackgroundColor, }: {
     canvas: HTMLCanvasElement;
@@ -11,3 +11,4 @@ export declare const bootstrapCanvas: ({ canvas, scale, normalizedWidth, normali
     isExporting?: boolean | undefined;
     viewBackgroundColor?: string | null | undefined;
 }) => CanvasRenderingContext2D;
+export declare const strokeRectWithRotation_simple: (context: CanvasRenderingContext2D, x: number, y: number, width: number, height: number, cx: number, cy: number, angle: number, fill?: boolean, radius?: number) => void;

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

@@ -1,20 +1,12 @@
+import { getScrollBars } from "../scene/scrollbars";
 import type { InteractiveSceneRenderConfig, RenderableElementsMap } from "../scene/types";
-/** throttled to animation framerate */
-export declare const renderInteractiveSceneThrottled: {
-    (config: InteractiveSceneRenderConfig): void;
-    flush(): void;
-    cancel(): void;
-};
 /**
  * Interactive scene is the ui-canvas where we render bounding boxes, selections
  * and other ui stuff.
  */
-export declare const renderInteractiveScene: <U extends ({ canvas, elementsMap, visibleElements, selectedElements, allElementsMap, scale, appState, renderConfig, device, }: InteractiveSceneRenderConfig) => {
+export declare const renderInteractiveScene: <U extends ({ app, canvas, elementsMap, visibleElements, selectedElements, allElementsMap, scale, appState, renderConfig, editorInterface, animationState, deltaTime, }: InteractiveSceneRenderConfig) => {
+    scrollBars?: import("../scene/types").ScrollBars | undefined;
     atLeastOneVisibleElement: boolean;
     elementsMap: RenderableElementsMap;
-    scrollBars?: undefined;
-} | {
-    scrollBars: import("../scene/types").ScrollBars | undefined;
-    atLeastOneVisibleElement: boolean;
-    elementsMap: RenderableElementsMap;
-}, T extends boolean = false>(renderConfig: InteractiveSceneRenderConfig, throttle?: T | undefined) => T extends true ? void : ReturnType<U>;
+    animationState?: import("../scene/types").InteractiveSceneRenderAnimationState | undefined;
+}>(renderConfig: InteractiveSceneRenderConfig) => ReturnType<U>;

package/types/excalidraw/renderer/staticScene.d.ts

@@ -1,4 +1,7 @@
-import type { StaticSceneRenderConfig } from "../scene/types";
+import type { ExcalidrawFrameLikeElement } from "@excalidraw/element/types";
+import type { StaticCanvasRenderConfig, StaticSceneRenderConfig } from "../scene/types";
+import type { StaticCanvasAppState } from "../types";
+export declare const frameClip: (frame: ExcalidrawFrameLikeElement, context: CanvasRenderingContext2D, renderConfig: StaticCanvasRenderConfig, appState: StaticCanvasAppState) => void;
 /** throttled to animation framerate */
 export declare const renderStaticSceneThrottled: {
     (config: StaticSceneRenderConfig): void;

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

@@ -1,5 +1,5 @@
 import type { ExcalidrawElement, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
-import type Scene from "./Scene";
+import type { Scene } from "@excalidraw/element";
 import type { AppState } from "../types";
 export declare class Renderer {
     private scene;
@@ -16,7 +16,6 @@ export declare class Renderer {
         /** note: first render of newElement will always bust the cache
          * (we'd have to prefilter elements outside of this function) */
         newElementId: ExcalidrawElement["id"] | undefined;
-        pendingImageElementId: AppState["pendingImageElementId"];
         sceneNonce: ReturnType<InstanceType<typeof Scene>["getSceneNonce"]>;
     }) => {
         elementsMap: Map<string, NonDeletedExcalidrawElement> & import("@excalidraw/common/utility-types").MakeBrand<"NonDeletedElementsMap"> & import("@excalidraw/common/utility-types").MakeBrand<"RenderableElementsMap">;

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

@@ -1,4 +1,4 @@
-export { isSomeElementSelected, getElementsWithinSelection, getCommonAttributeOfSelectedElements, getSelectedElements, getTargetElements, } from "@excalidraw/element/selection";
+export { isSomeElementSelected, getElementsWithinSelection, getSelectedElements, getTargetElements, } from "@excalidraw/element";
 export { calculateScrollCenter } from "./scroll";
-export { hasBackground, hasStrokeWidth, hasStrokeStyle, canHaveArrowheads, canChangeRoundness, } from "@excalidraw/element/comparisons";
+export { hasBackground, hasStrokeWidth, hasStrokeStyle, canHaveArrowheads, canChangeRoundness, } from "@excalidraw/element";
 export { getNormalizedZoom, getNormalizedGridSize, getNormalizedGridStep, } from "./normalize";

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

@@ -1,10 +1,9 @@
-import type { ExcalidrawElement } from "@excalidraw/element/types";
 import type { InteractiveCanvasAppState } from "../types";
-import type { ScrollBars } from "./types";
+import type { RenderableElementsMap, ScrollBars } from "./types";
 export declare const SCROLLBAR_MARGIN = 4;
 export declare const SCROLLBAR_WIDTH = 6;
 export declare const SCROLLBAR_COLOR = "rgba(128,128,128,0.3)";
-export declare const getScrollBars: (elements: readonly ExcalidrawElement[], viewportWidth: number, viewportHeight: number, appState: InteractiveCanvasAppState) => ScrollBars;
+export declare const getScrollBars: (elements: RenderableElementsMap, viewportWidth: number, viewportHeight: number, appState: InteractiveCanvasAppState) => ScrollBars;
 export declare const isOverScrollBars: (scrollBars: ScrollBars, x: number, y: number) => {
     isOverEither: boolean;
     isOverHorizontal: boolean;