@zsviczian/excalidraw 0.18.0-6 → 0.18.0-60

package/types/excalidraw/clipboard.d.ts

@@ -1,5 +1,8 @@
 import { ALLOWED_PASTE_MIME_TYPES } from "@excalidraw/common";
+import type { ValueOf } from "@excalidraw/common/utility-types";
+import type { IMAGE_MIME_TYPES, STRING_MIME_TYPES } from "@excalidraw/common";
 import type { ExcalidrawElement, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
+import type { FileSystemHandle } from "./data/filesystem";
 import type { Spreadsheet } from "./charts";
 import type { BinaryFiles } from "./types";
 export type PastedMixedContent = {
@@ -21,9 +24,9 @@ export declare const probablySupportsClipboardWriteText: boolean;
 export declare const probablySupportsClipboardBlob: boolean;
 export declare const createPasteEvent: ({ types, files, }: {
     types?: {
-        "image/svg+xml"?: string | File | undefined;
-        "text/html"?: string | File | undefined;
         "text/plain"?: string | File | undefined;
+        "text/html"?: string | File | undefined;
+        "image/svg+xml"?: string | File | undefined;
         "image/png"?: string | File | undefined;
         "image/jpeg"?: string | File | undefined;
         "image/gif"?: string | File | undefined;
@@ -45,9 +48,9 @@ export declare const copyToClipboard: (elements: readonly NonDeletedExcalidrawEl
  * Will prompt user for permission if not granted.
  */
 export declare const readSystemClipboard: () => Promise<{
-    "image/svg+xml"?: string | File | undefined;
-    "text/html"?: string | File | undefined;
     "text/plain"?: string | File | undefined;
+    "text/html"?: string | File | undefined;
+    "image/svg+xml"?: string | File | undefined;
     "image/png"?: string | File | undefined;
     "image/jpeg"?: string | File | undefined;
     "image/gif"?: string | File | undefined;
@@ -57,10 +60,70 @@ export declare const readSystemClipboard: () => Promise<{
     "image/avif"?: string | File | undefined;
     "image/jfif"?: string | File | undefined;
 }>;
+type AllowedParsedDataTransferItem = {
+    type: ValueOf<typeof IMAGE_MIME_TYPES>;
+    kind: "file";
+    file: File;
+    fileHandle: FileSystemHandle | null;
+} | {
+    type: ValueOf<typeof STRING_MIME_TYPES>;
+    kind: "string";
+    value: string;
+};
+type ParsedDataTransferItem = {
+    type: string;
+    kind: "file";
+    file: File;
+    fileHandle: FileSystemHandle | null;
+} | {
+    type: string;
+    kind: "string";
+    value: string;
+};
+type ParsedDataTransferItemType<T extends AllowedParsedDataTransferItem["type"]> = AllowedParsedDataTransferItem & {
+    type: T;
+};
+export type ParsedDataTransferFile = Extract<AllowedParsedDataTransferItem, {
+    kind: "file";
+}>;
+type ParsedDataTranferList = ParsedDataTransferItem[] & {
+    /**
+     * Only allows filtering by known `string` data types, since `file`
+     * types can have multiple items of the same type (e.g. multiple image files)
+     * unlike `string` data transfer items.
+     */
+    findByType: typeof findDataTransferItemType;
+    /**
+     * Only allows filtering by known `string` data types, since `file`
+     * types can have multiple items of the same type (e.g. multiple image files)
+     * unlike `string` data transfer items.
+     */
+    getData: typeof getDataTransferItemData;
+    getFiles: typeof getDataTransferFiles;
+};
+declare const findDataTransferItemType: <T extends ValueOf<{
+    readonly text: "text/plain";
+    readonly html: "text/html";
+    readonly json: "application/json";
+    readonly excalidraw: "application/vnd.excalidraw+json";
+    readonly excalidrawlib: "application/vnd.excalidrawlib+json";
+    readonly excalidrawlibIds: "application/vnd.excalidrawlib.ids+json";
+}>>(this: ParsedDataTranferList, type: T) => ParsedDataTransferItemType<T> | null;
+declare const getDataTransferItemData: <T extends ValueOf<{
+    readonly text: "text/plain";
+    readonly html: "text/html";
+    readonly json: "application/json";
+    readonly excalidraw: "application/vnd.excalidraw+json";
+    readonly excalidrawlib: "application/vnd.excalidrawlib+json";
+    readonly excalidrawlibIds: "application/vnd.excalidrawlib.ids+json";
+}>>(this: ParsedDataTranferList, type: T) => ParsedDataTransferItemType<ValueOf<typeof STRING_MIME_TYPES>>["value"] | null;
+declare const getDataTransferFiles: (this: ParsedDataTranferList) => ParsedDataTransferFile[];
+export declare const parseDataTransferEvent: (event: ClipboardEvent | DragEvent | React.DragEvent<HTMLDivElement>) => Promise<ParsedDataTranferList>;
 /**
  * Attempts to parse clipboard event.
  */
-export declare const parseClipboard: (event: ClipboardEvent, isPlainPaste?: boolean) => Promise<ClipboardData>;
+export declare const parseClipboard: (dataList: ParsedDataTranferList, isPlainPaste?: boolean) => Promise<ClipboardData>;
 export declare const copyBlobToClipboardAsPng: (blob: Blob | Promise<Blob>) => Promise<void>;
 export declare const copyTextToSystemClipboard: (text: string | null, clipboardEvent?: ClipboardEvent | null) => Promise<void>;
+export declare const isClipboardEvent: (event: React.SyntheticEvent | Event) => event is ClipboardEvent;
 export {};

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

@@ -1,6 +1,6 @@
 import type { ExcalidrawElement, NonDeletedElementsMap, NonDeletedSceneElementsMap } from "@excalidraw/element/types";
 import "./Actions.scss";
-import type { AppClassProperties, AppProps, UIAppState, Zoom } from "../types";
+import type { AppClassProperties, AppProps, UIAppState, Zoom, AppState } from "../types";
 import type { ActionManager } from "../actions/manager";
 export declare const canChangeStrokeColor: (appState: UIAppState, targetElements: ExcalidrawElement[]) => boolean;
 export declare const canChangeBackgroundColor: (appState: UIAppState, targetElements: ExcalidrawElement[]) => boolean;
@@ -10,9 +10,23 @@ export declare const SelectedShapeActions: ({ appState, elementsMap, renderActio
     renderAction: ActionManager["renderAction"];
     app: AppClassProperties;
 }) => import("react/jsx-runtime").JSX.Element;
-export declare const ShapesSwitcher: ({ activeTool, appState, app, UIOptions, }: {
-    activeTool: UIAppState["activeTool"];
+export declare const CompactShapeActions: ({ appState, elementsMap, renderAction, app, setAppState, }: {
     appState: UIAppState;
+    elementsMap: NonDeletedElementsMap | NonDeletedSceneElementsMap;
+    renderAction: ActionManager["renderAction"];
+    app: AppClassProperties;
+    setAppState: React.Component<any, AppState>["setState"];
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const MobileShapeActions: ({ appState, elementsMap, renderAction, app, setAppState, }: {
+    appState: UIAppState;
+    elementsMap: NonDeletedElementsMap | NonDeletedSceneElementsMap;
+    renderAction: ActionManager["renderAction"];
+    app: AppClassProperties;
+    setAppState: React.Component<any, AppState>["setState"];
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const ShapesSwitcher: ({ activeTool, setAppState, app, UIOptions, }: {
+    activeTool: UIAppState["activeTool"];
+    setAppState: React.Component<any, AppState>["setState"];
     app: AppClassProperties;
     UIOptions: AppProps["UIOptions"];
 }) => import("react/jsx-runtime").JSX.Element;
@@ -25,11 +39,10 @@ export declare const UndoRedoActions: ({ renderAction, className, }: {
     renderAction: ActionManager["renderAction"];
     className?: string | undefined;
 }) => import("react/jsx-runtime").JSX.Element;
-export declare const ExitZenModeAction: ({ actionManager, showExitZenModeBtn, }: {
+export declare const ExitZenModeButton: ({ actionManager, showExitZenModeBtn, }: {
     actionManager: ActionManager;
     showExitZenModeBtn: boolean;
 }) => import("react/jsx-runtime").JSX.Element;
-export declare const FinalizeAction: ({ renderAction, className, }: {
-    renderAction: ActionManager["renderAction"];
-    className?: string | undefined;
+export declare const ExitViewModeButton: ({ actionManager, }: {
+    actionManager: ActionManager;
 }) => import("react/jsx-runtime").JSX.Element;

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

@@ -1,20 +1,19 @@
 import React from "react";
-import { type EXPORT_IMAGE_TYPES } from "@excalidraw/common";
-import { LinearElementEditor } from "@excalidraw/element/linearElementEditor";
-import { FlowChartCreator } from "@excalidraw/element/flowchart";
-import type { ExcalidrawElement, ExcalidrawLinearElement, NonDeleted, InitializedExcalidrawImageElement, ExcalidrawImageElement, NonDeletedExcalidrawElement, ExcalidrawFrameLikeElement, ExcalidrawIframeElement, ExcalidrawEmbeddableElement, Ordered } from "@excalidraw/element/types";
+import { type EXPORT_IMAGE_TYPES, Emitter, type EditorInterface, type StylesPanelMode } from "@excalidraw/common";
+import { LinearElementEditor, FlowChartCreator, Scene, type ElementUpdate, StoreDelta, type ApplyToOptions } from "@excalidraw/element";
+import type { ExcalidrawElement, ExcalidrawLinearElement, NonDeleted, NonDeletedExcalidrawElement, ExcalidrawFrameLikeElement, ExcalidrawIframeElement, ExcalidrawEmbeddableElement, Ordered, SceneElementsMap } from "@excalidraw/element/types";
+import type { Mutable } from "@excalidraw/common/utility-types";
 import { ActionManager } from "../actions/manager";
 import { AnimationFrameHandler } from "../animation-frame-handler";
-import Scene from "../scene/Scene";
 import { Fonts } from "../fonts";
+import { type WritableAtom } from "../editor-jotai";
 import { Renderer } from "../scene/Renderer";
-import { Emitter } from "../emitter";
 import { LaserTrails } from "../laser-trails";
 import { LassoTrail } from "../lasso";
 import { EraserTrail } from "../eraser";
 import type { ExportedElements } from "../data";
 import type { FileSystemHandle } from "../data/filesystem";
-import type { AppClassProperties, AppProps, AppState, ExcalidrawImperativeAPI, BinaryFiles, LibraryItems, SceneData, Device, FrameNameBoundsCache, SidebarName, SidebarTabName, ToolType, OnUserFollowedPayload, GenerateDiagramToCode, NullableGridSize, Offsets } from "../types";
+import type { AppClassProperties, AppProps, AppState, ExcalidrawImperativeAPI, BinaryFiles, LibraryItems, SceneData, FrameNameBoundsCache, SidebarName, SidebarTabName, ToolType, OnUserFollowedPayload, GenerateDiagramToCode, NullableGridSize, Offsets } from "../types";
 import type { RoughCanvas } from "roughjs/bin/canvas";
 import type { ActionResult } from "../actions/types";
 export declare const ExcalidrawContainerContext: React.Context<{
@@ -23,17 +22,19 @@ export declare const ExcalidrawContainerContext: React.Context<{
 }>;
 export declare const useApp: () => AppClassProperties;
 export declare const useAppProps: () => AppProps;
-export declare const useDevice: () => Readonly<{
-    viewport: {
-        isMobile: boolean;
-        isLandscape: boolean;
-    };
-    editor: {
-        isMobile: boolean;
-        canFitSidebar: boolean;
-    };
+export declare const useEditorInterface: () => Readonly<{
+    formFactor: "phone" | "tablet" | "desktop";
+    desktopUIMode: "tray" | "full" | "compact";
+    userAgent: Readonly<{
+        isMobileDevice: boolean;
+        platform: "other" | "unknown" | "ios" | "android";
+    }>;
     isTouchScreen: boolean;
+    canFitSidebar: boolean;
+    isLandscape: boolean;
+    preferTrayMode: boolean;
 }>;
+export declare const useStylesPanelMode: () => StylesPanelMode;
 export declare const useExcalidrawContainer: () => {
     container: HTMLDivElement | null;
     id: string | null;
@@ -48,19 +49,20 @@ declare class App extends React.Component<AppProps, AppState> {
     rc: RoughCanvas;
     unmounted: boolean;
     actionManager: ActionManager;
-    device: Device;
+    editorInterface: EditorInterface;
+    private stylesPanelMode;
     private excalidrawContainerRef;
     scene: Scene;
     fonts: Fonts;
     renderer: Renderer;
     visibleElements: readonly NonDeletedExcalidrawElement[];
     private resizeObserver;
-    private nearestScrollableContainer;
     library: AppClassProperties["library"];
     libraryItemsFromStorage: LibraryItems | undefined;
     id: string;
     private store;
     private history;
+    private shouldRenderAllEmbeddables;
     excalidrawContainerValue: {
         container: HTMLDivElement | null;
         id: string;
@@ -78,9 +80,11 @@ declare class App extends React.Component<AppProps, AppState> {
     /** embeds that have been inserted to DOM (as a perf optim, we don't want to
      * insert to DOM before user initially scrolls to them) */
     private initializedEmbeds;
+    private handleToastClose;
     private elementsPendingErasure;
     flowChartCreator: FlowChartCreator;
     private flowChartNavigator;
+    bindModeHandler: ReturnType<typeof setTimeout> | null;
     hitLinkElement?: NonDeletedExcalidrawElement;
     lastPointerDownEvent: React.PointerEvent<HTMLElement> | null;
     lastPointerUpEvent: React.PointerEvent<HTMLElement> | PointerEvent | null;
@@ -123,7 +127,7 @@ declare class App extends React.Component<AppProps, AppState> {
         };
         originalElements: Map<string, NonDeleted<ExcalidrawElement>>;
         resize: {
-            handleType: import("@excalidraw/element/transformHandles").MaybeTransformHandleType;
+            handleType: import("@excalidraw/element").MaybeTransformHandleType;
             isResizing: boolean;
             offset: {
                 x: number;
@@ -138,10 +142,6 @@ declare class App extends React.Component<AppProps, AppState> {
         hit: {
             element: NonDeleted<ExcalidrawElement> | null;
             allHitElements: NonDeleted<ExcalidrawElement>[];
-            /**
-             * Returns gridSize taking into account `gridModeEnabled`.
-             * If disabled, returns null.
-             */
             wasAddedToSelection: boolean;
             hasBeenDuplicated: boolean;
             hasHitCommonBoundingBoxOfSelectedElements: boolean;
@@ -153,6 +153,11 @@ declare class App extends React.Component<AppProps, AppState> {
                 x: number;
                 y: number;
             } | null;
+            origin: {
+                x: number;
+                y: number;
+            };
+            blockDragging: boolean;
         };
         eventListeners: {
             onMove: {
@@ -192,7 +197,7 @@ declare class App extends React.Component<AppProps, AppState> {
         };
         originalElements: Map<string, NonDeleted<ExcalidrawElement>>;
         resize: {
-            handleType: import("@excalidraw/element/transformHandles").MaybeTransformHandleType;
+            handleType: import("@excalidraw/element").MaybeTransformHandleType;
             isResizing: boolean;
             offset: {
                 x: number;
@@ -207,10 +212,6 @@ declare class App extends React.Component<AppProps, AppState> {
         hit: {
             element: NonDeleted<ExcalidrawElement> | null;
             allHitElements: NonDeleted<ExcalidrawElement>[];
-            /**
-             * Returns gridSize taking into account `gridModeEnabled`.
-             * If disabled, returns null.
-             */
             wasAddedToSelection: boolean;
             hasBeenDuplicated: boolean;
             hasHitCommonBoundingBoxOfSelectedElements: boolean;
@@ -222,6 +223,11 @@ declare class App extends React.Component<AppProps, AppState> {
                 x: number;
                 y: number;
             } | null;
+            origin: {
+                x: number;
+                y: number;
+            };
+            blockDragging: boolean;
         };
         eventListeners: {
             onMove: {
@@ -244,7 +250,12 @@ declare class App extends React.Component<AppProps, AppState> {
     missingPointerEventCleanupEmitter: Emitter<[event: PointerEvent | null]>;
     onRemoveEventListenersEmitter: Emitter<[]>;
     constructor(props: AppProps);
+    updateEditorAtom: <Value, Args extends unknown[], Result>(atom: WritableAtom<Value, Args, Result>, ...args: Args) => Result;
     private onWindowMessage;
+    private handleSkipBindMode;
+    private resetDelayedBindMode;
+    private previousHoveredBindableElement;
+    private handleDelayedBindModeChange;
     private cacheEmbeddableRef;
     /**
      * Returns gridSize taking into account `gridModeEnabled`.
@@ -265,6 +276,7 @@ declare class App extends React.Component<AppProps, AppState> {
     render(): import("react/jsx-runtime").JSX.Element;
     focusContainer: AppClassProperties["focusContainer"];
     getSceneElementsIncludingDeleted: () => readonly import("@excalidraw/element/types").OrderedExcalidrawElement[];
+    getSceneElementsMapIncludingDeleted: () => Map<string, Ordered<ExcalidrawElement>> & import("@excalidraw/common/utility-types").MakeBrand<"SceneElementsMap">;
     getSceneElements: () => readonly Ordered<NonDeletedExcalidrawElement>[];
     onInsertElements: (elements: readonly ExcalidrawElement[]) => void;
     onExportImage: (type: keyof typeof EXPORT_IMAGE_TYPES, elements: ExportedElements, opts: {
@@ -295,9 +307,14 @@ declare class App extends React.Component<AppProps, AppState> {
      */
     private resetScene;
     private initializeScene;
-    private isMobileBreakpoint;
-    private refreshViewportBreakpoints;
-    private refreshEditorBreakpoints;
+    private getFormFactor;
+    refreshEditorInterface: (preferTrayMode?: boolean) => void;
+    private reconcileStylesPanelMode;
+    /** TO BE USED LATER */
+    private setDesktopUIMode;
+    private isTouchScreen;
+    private setTrayModeEnabled;
+    isTrayModeEnabled: () => boolean;
     private clearImageShapeCache;
     componentDidMount(): Promise<void>;
     componentWillUnmount(): void;
@@ -314,6 +331,7 @@ declare class App extends React.Component<AppProps, AppState> {
     private static resetTapTwice;
     private onTouchStart;
     private onTouchEnd;
+    private insertClipboardContent;
     pasteFromClipboard: (event: ClipboardEvent) => Promise<void>;
     addElementsFromPasteOrLibrary: (opts: {
         elements: readonly ExcalidrawElement[];
@@ -335,6 +353,8 @@ declare class App extends React.Component<AppProps, AppState> {
         name: boolean;
         outline: boolean;
         clip: boolean;
+        markerName: boolean;
+        markerEnabled: boolean;
     }> | ((prevState: AppState["frameRendering"]) => Partial<AppState["frameRendering"]>)) => void;
     togglePenMode: (force: boolean | null) => void;
     onHandToolToggle: () => void;
@@ -366,6 +386,7 @@ declare class App extends React.Component<AppProps, AppState> {
     private maybeUnfollowRemoteUser;
     /** use when changing scrollX/scrollY/zoom based on user interaction */
     private translateCanvas;
+    setForceRenderAllEmbeddables: (force: boolean) => void;
     zoomToFit: (target?: readonly ExcalidrawElement[], maxZoom?: number, margin?: number) => void;
     getColorAtScenePoint: ({ sceneX, sceneY, }: {
         sceneX: number;
@@ -384,7 +405,7 @@ declare class App extends React.Component<AppProps, AppState> {
      * NOTE if file already exists in editor state, the file data is not updated
      * */
     addFiles: ExcalidrawImperativeAPI["addFiles"];
-    setMobileModeAllowed: ExcalidrawImperativeAPI["setMobileModeAllowed"];
+    setMobileModeAllowed: (allow: boolean) => void;
     private debounceClearHighlightSearchResults;
     selectElements: ExcalidrawImperativeAPI["selectElements"];
     bringToFront: ExcalidrawImperativeAPI["bringToFront"];
@@ -410,6 +431,8 @@ declare class App extends React.Component<AppProps, AppState> {
         captureUpdate?: SceneData["captureUpdate"];
         forceFlushSync?: boolean | undefined;
     }) => void;
+    applyDeltas: (deltas: StoreDelta[], options?: ApplyToOptions) => [SceneElementsMap, AppState, boolean];
+    mutateElement: <TElement extends Mutable<ExcalidrawElement>>(element: TElement, updates: ElementUpdate<TElement>, informMutation?: boolean) => TElement;
     private triggerRender;
     /**
      * @returns whether the menu was toggled on or off
@@ -424,12 +447,9 @@ declare class App extends React.Component<AppProps, AppState> {
     private onKeyDown;
     private onKeyUp;
     private isToolSupported;
-    setActiveTool: (tool: (({
-        type: Exclude<ToolType, "image">;
+    setActiveTool: (tool: ({
+        type: ToolType;
     } | {
-        type: Extract<ToolType, "image">;
-        insertOnCanvasDirectly?: boolean;
-    }) | {
         type: "custom";
         customType: string;
     }) & {
@@ -455,7 +475,7 @@ declare class App extends React.Component<AppProps, AppState> {
     private getTextElementAtPosition;
     private getElementAtPosition;
     private getElementsAtPosition;
-    getElementHitThreshold(): number;
+    getElementHitThreshold(element: ExcalidrawElement): number;
     private hitElement;
     private getTextBindableContainerAtPosition;
     private startTextEditing;
@@ -481,6 +501,7 @@ declare class App extends React.Component<AppProps, AppState> {
      */
     private maybeCleanupAfterMissingPointerUp;
     handleCanvasPanUsingWheelOrSpaceDrag: (event: React.PointerEvent<HTMLElement> | MouseEvent) => boolean;
+    private startRightClickPanning;
     private updateGestureOnPointerDown;
     private initialPointerDownState;
     private handleDraggingScrollBar;
@@ -504,7 +525,7 @@ declare class App extends React.Component<AppProps, AppState> {
         sceneY: number;
         link: string;
     }) => NonDeleted<ExcalidrawEmbeddableElement> | undefined;
-    private createImageElement;
+    private newImagePlaceholder;
     private handleLinearElementOnPointerDown;
     private getCurrentItemRoundness;
     private createGenericElementOnPointerDown;
@@ -520,12 +541,13 @@ declare class App extends React.Component<AppProps, AppState> {
     private eraseElements;
     private initializeImage;
     /**
-     * inserts image into elements array and rerenders
+     * use during async image initialization,
+     * when the placeholder image could have been modified in the meantime,
+     * and when you don't want to loose those modifications
      */
-    insertImageElement: (imageElement: ExcalidrawImageElement, imageFile: File, showCursorImagePreview?: boolean) => Promise<NonDeleted<InitializedExcalidrawImageElement> | null | undefined>;
-    private setImagePreviewCursor;
-    private onImageAction;
-    initializeImageDimensions: (imageElement: ExcalidrawImageElement, forceNaturalSize?: boolean) => void;
+    private getLatestInitializedImageElement;
+    private onImageToolbarButtonClick;
+    private getImageNaturalDimensions;
     /** updates image cache, refreshing updated elements and/or setting status
         to error for images that fail during <img> element creation */
     private updateImageCache;
@@ -535,11 +557,10 @@ declare class App extends React.Component<AppProps, AppState> {
      *  to render new images. This is just a failsafe  */
     private scheduleImageRefresh;
     private updateBindingEnabledOnPointerMove;
-    private maybeSuggestBindingAtCursor;
-    private maybeSuggestBindingsForLinearElementAtCoords;
     setSelection(elements: readonly NonDeletedExcalidrawElement[]): void;
     private clearSelection;
     private handleInteractiveCanvasRef;
+    private insertImages;
     private handleAppOnDrop;
     loadFileToCanvas: (file: File, fileHandle: FileSystemHandle | null) => Promise<void>;
     private handleCanvasContextMenu;
@@ -554,6 +575,7 @@ declare class App extends React.Component<AppProps, AppState> {
     private updateDOMRect;
     refresh: () => void;
     private getCanvasOffsets;
+    watchState: () => void;
     private updateLanguage;
 }
 export default App;

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

@@ -10,6 +10,7 @@ interface ButtonIconProps {
     /** include standalone style (could interfere with parent styles) */
     standalone?: boolean;
     onClick: (event: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
+    style?: React.CSSProperties;
 }
 export declare const ButtonIcon: import("react").ForwardRefExoticComponent<ButtonIconProps & import("react").RefAttributes<HTMLButtonElement>>;
 export {};

package/types/excalidraw/components/ColorPicker/ColorInput.d.ts

@@ -4,6 +4,7 @@ interface ColorInputProps {
     onChange: (color: string) => void;
     label: string;
     colorPickerType: ColorPickerType;
+    placeholder?: string;
 }
-export declare const ColorInput: ({ color, onChange, label, colorPickerType, }: ColorInputProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ColorInput: ({ color, onChange, label, colorPickerType, placeholder, }: ColorInputProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -6,7 +6,11 @@ import type { AppState } from "../../types";
 export declare const getColor: (color: string) => string | null;
 interface ColorPickerProps {
     type: ColorPickerType;
-    color: string;
+    /**
+     * null indicates no color should be displayed as active
+     * (e.g. when multiple shapes selected with different colors)
+     */
+    color: string | null;
     onChange: (color: string) => void;
     label: string;
     elements: readonly ExcalidrawElement[];

package/types/excalidraw/components/ColorPicker/CustomColorList.d.ts

@@ -1,6 +1,6 @@
 interface CustomColorListProps {
     colors: string[];
-    color: string;
+    color: string | null;
     onChange: (color: string) => void;
     label: string;
 }

package/types/excalidraw/components/ColorPicker/Picker.d.ts

@@ -3,16 +3,17 @@ import type { ExcalidrawElement } from "@excalidraw/element/types";
 import type { ColorPaletteCustom } from "@excalidraw/common";
 import type { ColorPickerType } from "./colorPickerUtils";
 interface PickerProps {
-    color: string;
+    color: string | null;
     onChange: (color: string) => void;
-    label: string;
     type: ColorPickerType;
     elements: readonly ExcalidrawElement[];
     palette: ColorPaletteCustom;
     updateData: (formData?: any) => void;
     children?: React.ReactNode;
+    showTitle?: boolean;
     onEyeDropperToggle: (force?: boolean) => void;
     onEscape: (event: React.KeyboardEvent | KeyboardEvent) => void;
+    showHotKey?: boolean;
 }
-export declare const Picker: ({ color, onChange, label, type, elements, palette, updateData, children, onEyeDropperToggle, onEscape, }: PickerProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Picker: React.ForwardRefExoticComponent<PickerProps & React.RefAttributes<unknown>>;
 export {};

package/types/excalidraw/components/ColorPicker/PickerColorList.d.ts

@@ -1,10 +1,10 @@
 import type { ColorPaletteCustom } from "@excalidraw/common";
 interface PickerColorListProps {
     palette: ColorPaletteCustom;
-    color: string;
+    color: string | null;
     onChange: (color: string) => void;
-    label: string;
     activeShade: number;
+    showHotKey?: boolean;
 }
-declare const PickerColorList: ({ palette, color, onChange, label, activeShade, }: PickerColorListProps) => import("react/jsx-runtime").JSX.Element;
+declare const PickerColorList: ({ palette, color, onChange, activeShade, showHotKey, }: PickerColorListProps) => import("react/jsx-runtime").JSX.Element;
 export default PickerColorList;

package/types/excalidraw/components/ColorPicker/ShadeList.d.ts

@@ -1,8 +1,9 @@
 import type { ColorPaletteCustom } from "@excalidraw/common";
 interface ShadeListProps {
-    hex: string;
+    color: string | null;
     onChange: (color: string) => void;
     palette: ColorPaletteCustom;
+    showHotKey?: boolean;
 }
-export declare const ShadeList: ({ hex, onChange, palette }: ShadeListProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ShadeList: ({ color, onChange, palette, showHotKey, }: ShadeListProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/types/excalidraw/components/ColorPicker/TopPicks.d.ts

@@ -2,7 +2,7 @@ import type { ColorPickerType } from "./colorPickerUtils";
 interface TopPicksProps {
     onChange: (color: string) => void;
     type: ColorPickerType;
-    activeColor: string;
+    activeColor: string | null;
     topPicks?: readonly string[];
 }
 export declare const TopPicks: ({ onChange, type, activeColor, topPicks, }: TopPicksProps) => import("react/jsx-runtime").JSX.Element | null;

package/types/excalidraw/components/ColorPicker/colorPickerUtils.d.ts

@@ -2,7 +2,7 @@ import type { ExcalidrawElement } from "@excalidraw/element/types";
 import type { ColorPickerColor, ColorPaletteCustom } from "@excalidraw/common";
 export declare const getColorNameAndShadeFromColor: ({ palette, color, }: {
     palette: ColorPaletteCustom;
-    color: string;
+    color: string | null;
 }) => {
     colorName: ColorPickerColor;
     shade: number | null;

package/types/excalidraw/components/ColorPicker/keyboardNavHandlers.d.ts

@@ -4,7 +4,7 @@ interface ColorPickerKeyNavHandlerProps {
     event: React.KeyboardEvent;
     activeColorPickerSection: ActiveColorPickerSectionAtomType;
     palette: ColorPaletteCustom;
-    color: string;
+    color: string | null;
     onChange: (color: string) => void;
     customColors: string[];
     setActiveColorPickerSection: (update: React.SetStateAction<ActiveColorPickerSectionAtomType>) => void;

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

@@ -8,6 +8,7 @@ export declare const DEFAULT_CATEGORIES: {
     editor: string;
     elements: string;
     links: string;
+    library: string;
 };
 type CommandPaletteProps = {
     customCommandPaletteItems?: CommandPaletteItem[];

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

@@ -1,6 +1,5 @@
 import type { ActionManager } from "../../actions/manager";
 import type { Action } from "../../actions/types";
-import type { UIAppState } from "../../types";
 export type CommandPaletteItem = {
     label: string;
     /** additional keywords to match against
@@ -11,7 +10,7 @@ export type CommandPaletteItem = {
      * (deburred name + keywords)
      */
     haystack?: string;
-    icon?: React.ReactNode | ((appState: UIAppState) => React.ReactNode);
+    icon?: Action["icon"];
     category: string;
     order?: number;
     predicate?: boolean | Action["predicate"];

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

@@ -0,0 +1,23 @@
+import type { ConvertibleTypes, ExcalidrawElement, ExcalidrawTextContainer, ExcalidrawTextElementWithContainer } from "@excalidraw/element/types";
+import type { Scene } from "@excalidraw/element";
+import "./ConvertElementTypePopup.scss";
+import type App from "./App";
+export declare const convertElementTypePopupAtom: import("jotai/vanilla/atom").PrimitiveAtom<{
+    type: "panel";
+} | null> & {
+    init: {
+        type: "panel";
+    } | null;
+};
+declare const ConvertElementTypePopup: ({ app }: {
+    app: App;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const adjustBoundTextSize: (container: ExcalidrawTextContainer, boundText: ExcalidrawTextElementWithContainer, scene: Scene) => void;
+type ConversionType = "generic" | "linear" | null;
+export declare const convertElementTypes: (app: App, { conversionType, nextType, direction, }: {
+    conversionType: ConversionType;
+    nextType?: ConvertibleTypes | undefined;
+    direction?: "left" | "right" | undefined;
+}) => boolean;
+export declare const getConversionTypeFromElements: (elements: ExcalidrawElement[]) => ConversionType;
+export default ConvertElementTypePopup;

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

@@ -1,10 +1,11 @@
-import type { ElementsMap, ExcalidrawElement } from "@excalidraw/element/types";
+import type { ExcalidrawElement } from "@excalidraw/element/types";
+import type { Scene } from "@excalidraw/element";
 import "./ElementLinkDialog.scss";
 import type { AppProps, UIAppState } from "../types";
-declare const ElementLinkDialog: ({ sourceElementId, onClose, elementsMap, appState, generateLinkForSelection, }: {
+declare const ElementLinkDialog: ({ sourceElementId, onClose, appState, scene, generateLinkForSelection, }: {
     sourceElementId: ExcalidrawElement["id"];
-    elementsMap: ElementsMap;
     appState: UIAppState;
+    scene: Scene;
     onClose?: (() => void) | undefined;
     generateLinkForSelection: AppProps["generateLinkForSelection"];
 }) => import("react/jsx-runtime").JSX.Element;