@excalidraw/common 0.18.0-063e025 → 0.18.0-1acf66e

package/dist/types/excalidraw/components/{ToolButton.d.ts → IconButton.d.ts}

@@ -2,48 +2,45 @@ import React from "react";
 import type { PointerType } from "@excalidraw/element/types";
 import "./ToolIcon.scss";
 import type { CSSProperties } from "react";
-export type ToolButtonSize = "small" | "medium";
-type ToolButtonBaseProps = {
+export type IconButtonSize = "small" | "medium";
+type IconButtonBaseProps = {
     icon?: React.ReactNode;
     "aria-label": string;
     "aria-keyshortcuts"?: string;
     "data-testid"?: string;
     label?: string;
     title?: string;
-    name?: string;
-    id?: string;
-    size?: ToolButtonSize;
+    size?: IconButtonSize;
     keyBindingLabel?: string | null;
     showAriaLabel?: boolean;
     hidden?: boolean;
     visible?: boolean;
-    selected?: boolean;
     disabled?: boolean;
     className?: string;
     style?: CSSProperties;
     isLoading?: boolean;
 };
-type ToolButtonProps = (ToolButtonBaseProps & {
+type IconButtonProps = (IconButtonBaseProps & {
     type: "button";
     children?: React.ReactNode;
     onClick?(event: React.MouseEvent): void;
-}) | (ToolButtonBaseProps & {
-    type: "submit";
-    children?: React.ReactNode;
-    onClick?(event: React.MouseEvent): void;
-}) | (ToolButtonBaseProps & {
+}) | (IconButtonBaseProps & {
     type: "icon";
     children?: React.ReactNode;
     onClick?(): void;
-}) | (ToolButtonBaseProps & {
-    type: "radio";
+}) | (IconButtonBaseProps & {
+    type: "toggle";
     checked: boolean;
-    onChange?(data: {
+    /**
+     * Fired on activation — a completed pointer gesture (via `click`, so a
+     * press canceled by sliding off the button doesn't select) or
+     * keyboard/AT activation, in which case pointerType is null.
+     * pointerType is captured on pointer-down, where it's reliable
+     * (unlike the click event's own pointerType on iOS).
+     */
+    onSelect?(data: {
         pointerType: PointerType | null;
     }): void;
-    onPointerDown?(data: {
-        pointerType: PointerType;
-    }): void;
 });
-export declare const ToolButton: React.ForwardRefExoticComponent<ToolButtonProps & React.RefAttributes<unknown>>;
+export declare const IconButton: React.ForwardRefExoticComponent<IconButtonProps & React.RefAttributes<unknown>>;
 export {};

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

@@ -1,10 +1,8 @@
-import "./ToolIcon.scss";
-type LaserPointerIconProps = {
+type LaserPointerButtonProps = {
     title?: string;
-    name?: string;
     checked: boolean;
     onChange?(): void;
     isMobile?: boolean;
 };
-export declare const LaserPointerButton: (props: LaserPointerIconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const LaserPointerButton: (props: LaserPointerButtonProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -13,7 +13,6 @@ interface LayerUIProps {
     setAppState: React.Component<any, AppState>["setState"];
     elements: readonly NonDeletedExcalidrawElement[];
     onLockToggle: () => void;
-    onHandToolToggle: () => void;
     onPenModeToggle: AppClassProperties["togglePenMode"];
     showExitZenModeBtn: boolean;
     langCode: Language["code"];
@@ -25,8 +24,11 @@ interface LayerUIProps {
     renderWelcomeScreen: boolean;
     children?: React.ReactNode;
     app: AppClassProperties;
+    defaultUIEnabled: boolean;
+    zoomUIEnabled: boolean;
+    scrollBackToContentUIEnabled: boolean;
     isCollaborating: boolean;
     generateLinkForSelection?: AppProps["generateLinkForSelection"];
 }
-declare const _default: React.MemoExoticComponent<({ actionManager, appState, files, setAppState, elements, canvas, onLockToggle, onHandToolToggle, onPenModeToggle, showExitZenModeBtn, renderTopLeftUI, renderTopRightUI, renderCustomStats, UIOptions, onExportImage, renderWelcomeScreen, children, app, isCollaborating, generateLinkForSelection, }: LayerUIProps) => import("react/jsx-runtime").JSX.Element>;
+declare const _default: React.MemoExoticComponent<({ actionManager, appState, files, setAppState, elements, canvas, onLockToggle, onPenModeToggle, showExitZenModeBtn, renderTopLeftUI, renderTopRightUI, renderCustomStats, UIOptions, onExportImage, renderWelcomeScreen, children, app, defaultUIEnabled, zoomUIEnabled, scrollBackToContentUIEnabled, isCollaborating, generateLinkForSelection, }: LayerUIProps) => import("react/jsx-runtime").JSX.Element>;
 export default _default;

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

@@ -1,10 +1,9 @@
-import "./ToolIcon.scss";
-type LockIconProps = {
+type LockButtonProps = {
     title?: string;
-    name?: string;
     checked: boolean;
     onChange?(): void;
     isMobile?: boolean;
+    disabled?: boolean;
 };
-export declare const LockButton: (props: LockIconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const LockButton: (props: LockButtonProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -1,9 +1,7 @@
-import "./ToolIcon.scss";
 import type { JSX } from "react";
 export declare const ElementCanvasButton: (props: {
     title?: string;
     icon: JSX.Element;
-    name?: string;
     checked: boolean;
     onChange?(): void;
     isMobile?: boolean;

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

@@ -1,7 +1,7 @@
 import React from "react";
 import type { NonDeletedExcalidrawElement } from "@excalidraw/element/types";
 import type { ActionManager } from "../actions/manager";
-import type { AppClassProperties, AppProps, AppState, UIAppState } from "../types";
+import type { AppClassProperties, AppState, UIAppState } from "../types";
 import type { JSX } from "react";
 type MobileMenuProps = {
     appState: UIAppState;
@@ -10,14 +10,14 @@ type MobileMenuProps = {
     renderImageExportDialog: () => React.ReactNode;
     setAppState: React.Component<any, AppState>["setState"];
     elements: readonly NonDeletedExcalidrawElement[];
-    onHandToolToggle: () => void;
     onPenModeToggle: AppClassProperties["togglePenMode"];
     renderTopRightUI?: (isMobile: boolean, appState: UIAppState) => JSX.Element | null;
     renderTopLeftUI?: (isMobile: boolean, appState: UIAppState) => JSX.Element | null;
     renderSidebars: () => JSX.Element | null;
     renderWelcomeScreen: boolean;
-    UIOptions: AppProps["UIOptions"];
+    defaultUIEnabled: boolean;
+    scrollBackToContentUIEnabled: boolean;
     app: AppClassProperties;
 };
-export declare const MobileMenu: ({ appState, elements, actionManager, setAppState, onHandToolToggle, renderTopLeftUI, renderTopRightUI, renderSidebars, renderWelcomeScreen, UIOptions, app, onPenModeToggle, }: MobileMenuProps) => import("react/jsx-runtime").JSX.Element;
+export declare const MobileMenu: ({ appState, elements, actionManager, setAppState, renderTopLeftUI, renderTopRightUI, renderSidebars, renderWelcomeScreen, defaultUIEnabled, scrollBackToContentUIEnabled, app, onPenModeToggle, }: MobileMenuProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -0,0 +1,9 @@
+import "./ToolIcon.scss";
+import "./MobileToolbar.scss";
+import type { AppClassProperties, UIAppState } from "../types";
+type MobileToolbarProps = {
+    app: AppClassProperties;
+    setAppState: React.Component<any, UIAppState>["setState"];
+};
+export declare const MobileToolbar: ({ app, setAppState }: MobileToolbarProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -1,12 +1,9 @@
-import "./ToolIcon.scss";
-type PenModeIconProps = {
+type PenModeButtonProps = {
     title?: string;
-    name?: string;
     checked: boolean;
     onChange?(): void;
-    zenModeEnabled?: boolean;
     isMobile?: boolean;
     penDetected: boolean;
 };
-export declare const PenModeButton: (props: PenModeIconProps) => import("react/jsx-runtime").JSX.Element | null;
+export declare const PenModeButton: (props: PenModeButtonProps) => import("react/jsx-runtime").JSX.Element | null;
 export {};

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

@@ -6,11 +6,9 @@ type Props = {
     children?: React.ReactNode;
     onCloseRequest?(event: PointerEvent): void;
     fitInViewport?: boolean;
-    offsetLeft?: number;
-    offsetTop?: number;
     viewportWidth?: number;
     viewportHeight?: number;
     className?: string;
 };
-export declare const Popover: ({ children, left, top, onCloseRequest, fitInViewport, offsetLeft, offsetTop, viewportWidth, viewportHeight, className, }: Props) => import("react/jsx-runtime").JSX.Element;
+export declare const Popover: ({ children, left, top, onCloseRequest, fitInViewport, viewportWidth, viewportHeight, className, }: Props) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/excalidraw/components/{ButtonIcon.d.ts → RadioButton.d.ts}

@@ -1,16 +1,13 @@
-import "./ButtonIcon.scss";
 import type { JSX } from "react";
-interface ButtonIconProps {
+interface RadioButtonProps {
     icon: JSX.Element;
     title: string;
     className?: string;
     testId?: string;
     /** if not supplied, defaults to value identity check */
     active?: boolean;
-    /** 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 declare const RadioButton: import("react").ForwardRefExoticComponent<RadioButtonProps & import("react").RefAttributes<HTMLButtonElement>>;
 export {};

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

@@ -4,7 +4,8 @@ import type { AppClassProperties } from "../types";
 type ToolOption = {
     type: string;
     icon: React.ReactNode;
-    title?: string;
+    title: string;
+    fillable?: boolean;
 };
 type ToolPopoverProps = {
     app: AppClassProperties;
@@ -13,13 +14,9 @@ type ToolPopoverProps = {
         type: string;
     };
     defaultOption: string;
-    className?: string;
-    namePrefix: string;
-    title: string;
     "data-testid": string;
     onToolChange: (type: string) => void;
     displayedOption: ToolOption;
-    fillable?: boolean;
 };
-export declare const ToolPopover: ({ app, options, activeTool, defaultOption, className, namePrefix, title, "data-testid": dataTestId, onToolChange, displayedOption, fillable, }: ToolPopoverProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ToolPopover: ({ app, options, activeTool, defaultOption, "data-testid": dataTestId, onToolChange, displayedOption, }: ToolPopoverProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -0,0 +1,11 @@
+import type { AppClassProperties, AppProps, AppState, UIAppState } from "../types";
+/** the main (desktop/tablet) toolbar island */
+export declare const Toolbar: ({ app, appState, setAppState, UIOptions, onPenModeToggle, onLockToggle, heading, }: {
+    app: AppClassProperties;
+    appState: UIAppState;
+    setAppState: React.Component<any, AppState>["setState"];
+    UIOptions: AppProps["UIOptions"];
+    onPenModeToggle: AppClassProperties["togglePenMode"];
+    onLockToggle: () => void;
+    heading: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,145 @@
+import type { AppClassProperties, AppState, ToolType, UIAppState } from "../types";
+export type ToolConfig = {
+    icon: React.ReactNode;
+    /** letter shortcut(s) — the first one is shown in tooltips */
+    letterKey?: string | readonly string[];
+    /** whether `letterKey` requires Shift to be held (e.g. Shift+X) */
+    shiftKey?: boolean;
+    numericKey?: string;
+    /** whether the tool's shapes can be filled — fills the icon when active */
+    fillable?: boolean;
+    /**
+     * re-activating the tool switches back to the previously active tool
+     * (via the keyboard shortcut or ESC — see `setActiveTool`'s `toggle`
+     * option)
+     */
+    toggle?: boolean;
+};
+/**
+ * Tool data — the single source of truth for tool buttons, keyboard
+ * shortcuts (`findShapeByKey`), and the command palette. Toolbar placement
+ * is not defined here: toolbars compose the `*ToolButton` components below
+ * manually, so entries without a toolbar slot (e.g. laser) are data-only.
+ */
+export declare const TOOLS: {
+    hand: ToolConfig;
+    selection: ToolConfig;
+    rectangle: ToolConfig;
+    diamond: ToolConfig;
+    ellipse: ToolConfig;
+    arrow: ToolConfig;
+    line: ToolConfig;
+    freedraw: ToolConfig;
+    text: ToolConfig;
+    image: ToolConfig;
+    eraser: ToolConfig;
+    frame: ToolConfig;
+    autoshape: ToolConfig;
+    embeddable: ToolConfig;
+    laser: ToolConfig;
+    lasso: ToolConfig;
+};
+export type ToolbarToolType = keyof typeof TOOLS;
+/**
+ * tools that, when activated while already active, switch back to the
+ * previously active tool (see `setActiveTool`'s `toggle` option)
+ */
+export declare const TOGGLE_TOOLS: readonly (ToolType | "custom")[];
+export declare const getToolLetter: (type: ToolbarToolType) => string | undefined;
+/** human-readable shortcut hint, e.g. "R or 2", used in tooltips & aria */
+export declare const getToolShortcut: (type: ToolbarToolType) => string;
+export declare const findShapeByKey: (key: string, app: AppClassProperties, shiftKey?: boolean) => "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "embeddable" | "image" | "frame" | "freedraw" | "lasso" | "eraser" | "hand" | "laser" | "autoshape" | null;
+/**
+ * Whether a toolbar entry activating the given tool renders disabled — true
+ * when the active tool is host-controlled (`props.activeTool`) and the entry
+ * doesn't activate the forced tool (`setActiveTool` refuses it).
+ */
+export declare const isToolButtonDisabled: (app: AppClassProperties, type: string) => boolean;
+export type ToolButtonComponentProps = {
+    app: AppClassProperties;
+    activeTool: UIAppState["activeTool"];
+    /** hide the keybinding badge rendered in the button's corner */
+    hideKeyBinding?: boolean;
+    /**
+     * hide all shortcut affordances (tooltip hint, aria-keyshortcuts, and the
+     * keybinding badge) — used on mobile where there's no keyboard
+     */
+    hideShortcut?: boolean;
+};
+export declare const HandToolButton: {
+    ({ app, activeTool, hideKeyBinding, hideShortcut, }: ToolButtonComponentProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export declare const RectangleToolButton: {
+    ({ app, activeTool, hideKeyBinding, hideShortcut, }: ToolButtonComponentProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export declare const DiamondToolButton: {
+    ({ app, activeTool, hideKeyBinding, hideShortcut, }: ToolButtonComponentProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export declare const EllipseToolButton: {
+    ({ app, activeTool, hideKeyBinding, hideShortcut, }: ToolButtonComponentProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export declare const ArrowToolButton: {
+    ({ app, activeTool, hideKeyBinding, hideShortcut, }: ToolButtonComponentProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export declare const LineToolButton: {
+    ({ app, activeTool, hideKeyBinding, hideShortcut, }: ToolButtonComponentProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export declare const FreedrawToolButton: {
+    ({ app, activeTool, hideKeyBinding, hideShortcut, }: ToolButtonComponentProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export declare const TextToolButton: {
+    ({ app, activeTool, hideKeyBinding, hideShortcut, }: ToolButtonComponentProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export declare const ImageToolButton: {
+    ({ app, activeTool, hideKeyBinding, hideShortcut, }: ToolButtonComponentProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export declare const EraserToolButton: {
+    ({ app, activeTool, hideKeyBinding, hideShortcut, }: ToolButtonComponentProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export declare const FrameToolButton: {
+    ({ app, activeTool, hideKeyBinding, hideShortcut, }: ToolButtonComponentProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+/**
+ * The selection tool button — pointer-clicking it while the selection tool
+ * is active switches to lasso.
+ */
+export declare const SelectionToolButton: {
+    ({ app, activeTool, hideKeyBinding, hideShortcut, }: ToolButtonComponentProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+/**
+ * Rendered in place of the selection button when lasso is the preferred
+ * selection tool; the selection shortcut activates it then.
+ */
+export declare const LassoToolButton: {
+    ({ app, activeTool, hideKeyBinding, hideShortcut, }: ToolButtonComponentProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+/**
+ * The selection ⇄ lasso popover used in compact (tablet) and mobile
+ * toolbars; picking an option also makes it the preferred selection tool.
+ */
+export declare const SelectionToolPopover: ({ app, activeTool, setAppState, }: {
+    app: AppClassProperties;
+    activeTool: UIAppState["activeTool"];
+    setAppState: React.Component<any, AppState>["setState"];
+}) => import("react/jsx-runtime").JSX.Element;
+/**
+ * The freedraw ⇄ draw-shape popover used in compact (tablet) and mobile
+ * toolbars. The trigger remembers and displays the most recently used option.
+ */
+export declare const FreedrawToolPopover: ({ app, activeTool, }: {
+    app: AppClassProperties;
+    activeTool: UIAppState["activeTool"];
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/types/excalidraw/components/canvases/InteractiveCanvas.d.ts

@@ -18,6 +18,8 @@ type InteractiveCanvasProps = {
     renderScrollbars: boolean;
     editorInterface: EditorInterface;
     app: AppClassProperties;
+    interactionEnabled: boolean;
+    navigationEnabled: boolean;
     renderInteractiveSceneCallback: (data: RenderInteractiveSceneCallback) => void;
     handleCanvasRef: (canvas: HTMLCanvasElement | null) => void;
     onContextMenu: Exclude<DOMAttributes<HTMLCanvasElement | HTMLDivElement>["onContextMenu"], undefined>;

package/dist/types/excalidraw/components/footer/Footer.d.ts

@@ -1,11 +1,13 @@
 import type { ActionManager } from "../../actions/manager";
 import type { UIAppState } from "../../types";
 declare const Footer: {
-    ({ appState, actionManager, showExitZenModeBtn, renderWelcomeScreen, }: {
+    ({ appState, actionManager, showExitZenModeBtn, renderWelcomeScreen, defaultUIEnabled, zoomUIEnabled, }: {
         appState: UIAppState;
         actionManager: ActionManager;
         showExitZenModeBtn: boolean;
         renderWelcomeScreen: boolean;
+        defaultUIEnabled: boolean;
+        zoomUIEnabled: boolean;
     }): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };

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

@@ -197,12 +197,12 @@ export declare const playerStopFilledIcon: import("react/jsx-runtime").JSX.Eleme
 export declare const tablerCheckIcon: import("react/jsx-runtime").JSX.Element;
 export declare const alertTriangleIcon: import("react/jsx-runtime").JSX.Element;
 export declare const eyeDropperIcon: import("react/jsx-runtime").JSX.Element;
-export declare const extraToolsIcon: import("react/jsx-runtime").JSX.Element;
 export declare const frameToolIcon: import("react/jsx-runtime").JSX.Element;
 export declare const mermaidLogoIcon: import("react/jsx-runtime").JSX.Element;
 export declare const RetryIcon: import("react/jsx-runtime").JSX.Element;
 export declare const stackPushIcon: import("react/jsx-runtime").JSX.Element;
 export declare const ArrowRightIcon: import("react/jsx-runtime").JSX.Element;
+export declare const drawShapeToolIcon: import("react/jsx-runtime").JSX.Element;
 export declare const laserPointerToolIcon: import("react/jsx-runtime").JSX.Element;
 export declare const MagicIcon: import("react/jsx-runtime").JSX.Element;
 export declare const MagicIconThin: import("react/jsx-runtime").JSX.Element;

package/dist/types/excalidraw/components/main-menu/DefaultItems.d.ts

@@ -79,7 +79,7 @@ export declare const Preferences: {
     ToggleMidpointSnapping: () => import("react/jsx-runtime").JSX.Element;
     ToggleGridMode: () => import("react/jsx-runtime").JSX.Element;
     ToggleZenMode: () => import("react/jsx-runtime").JSX.Element;
-    ToggleViewMode: () => import("react/jsx-runtime").JSX.Element;
+    ToggleViewMode: () => import("react/jsx-runtime").JSX.Element | null;
     ToggleElementProperties: () => import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };

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

@@ -0,0 +1,26 @@
+/**
+ * Positions an element beside a cursor within a container, flipping the
+ * element to the other side of the cursor when it would overflow the
+ * container, resolved independently on each axis.
+ *
+ * Takes the cursor in client (viewport) coordinates and returns
+ * container-local coordinates.
+ */
+export declare const positionElementBesideCursor: ({ cursor, element, container, gap, }: {
+    /** client (viewport) coordinates */
+    cursor: {
+        x: number;
+        y: number;
+    };
+    element: {
+        width: number;
+        height: number;
+    };
+    /** the container's bounding client rect */
+    container: Pick<DOMRect, "left" | "top" | "width" | "height">;
+    /** distance between the cursor and the positioned element */
+    gap: number;
+}) => {
+    left: number;
+    top: number;
+};

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

@@ -0,0 +1,39 @@
+import type { ExcalidrawElement, NonDeletedElementsMap, NonDeletedSceneElementsMap } from "@excalidraw/element/types";
+import type { AppClassProperties, UIAppState } from "../types";
+export declare const canChangeStrokeColor: (appState: UIAppState, targetElements: ExcalidrawElement[]) => boolean;
+export declare const canChangeBackgroundColor: (appState: UIAppState, targetElements: ExcalidrawElement[]) => boolean;
+/**
+ * Single source of truth for "which shape-action controls are relevant right
+ * now". Each flag answers whether a given control should be shown, given the
+ * active tool and the current selection. All three styles-panel layouts
+ * (full / compact / mobile) and the compact popovers consume these flags so
+ * that visibility logic lives in one place and layout stays pure.
+ */
+export declare const getShapeActionPredicates: (appState: UIAppState, targetElements: ExcalidrawElement[], elementsMap: NonDeletedElementsMap | NonDeletedSceneElementsMap, app: AppClassProperties) => {
+    /** some element(s) selected */
+    hasSelection: boolean;
+    /** actions on selected elements (delete/duplicate/...) */
+    showExtraActions: boolean;
+    strokeColor: boolean;
+    backgroundColor: boolean;
+    fill: boolean;
+    strokeWidth: boolean;
+    freedrawMode: boolean;
+    strokeStyle: boolean;
+    sloppiness: boolean;
+    roundness: boolean;
+    arrowType: boolean;
+    arrowheads: boolean;
+    text: boolean;
+    textAlign: boolean;
+    verticalAlign: boolean;
+    opacity: boolean;
+    layers: boolean;
+    align: boolean;
+    distribute: boolean;
+    link: boolean;
+    linkSingleOnly: boolean;
+    cropEditor: boolean;
+    lineEditor: boolean;
+};
+export type ShapeActionPredicates = ReturnType<typeof getShapeActionPredicates>;

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

@@ -21,6 +21,11 @@ fileHandle?: FileSystemFileHandle | null) => Promise<{
         elements: import("@excalidraw/element/types").OrderedExcalidrawElement[];
         appState: {
             viewModeEnabled: boolean;
+            activeTool: {
+                lastActiveTool: import("../types").ActiveTool | null;
+                locked: boolean;
+                fromSelection: boolean;
+            } & import("../types").ActiveTool;
             zenModeEnabled: boolean;
             gridModeEnabled: boolean;
             objectsSnapModeEnabled: boolean;
@@ -28,11 +33,6 @@ fileHandle?: FileSystemFileHandle | null) => Promise<{
             name: string | null;
             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;
@@ -57,6 +57,10 @@ fileHandle?: FileSystemFileHandle | null) => Promise<{
                 element: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawBindableElement>;
                 midPoint?: import("@excalidraw/math").GlobalPoint;
             } | null;
+            hoveredArrowTextAnchor: {
+                elementId: import("@excalidraw/element/types").ExcalidrawArrowElement["id"];
+                anchor: "start" | "end" | "label";
+            } | null;
             frameToHighlight: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawFrameLikeElement> | null;
             frameRendering: {
                 enabled: boolean;
@@ -64,7 +68,7 @@ fileHandle?: FileSystemFileHandle | null) => Promise<{
                 outline: boolean;
                 clip: boolean;
             };
-            editingFrame: string | null;
+            editingFrame: import("@excalidraw/element/types").ExcalidrawFrameLikeElement["id"] | null;
             elementsToHighlight: readonly import("@excalidraw/element/types").NonDeletedExcalidrawElement[] | null;
             editingTextElement: import("@excalidraw/element/types").ExcalidrawTextElement | null;
             preferredSelectionTool: {
@@ -188,6 +192,11 @@ fileHandle?: FileSystemFileHandle | null) => Promise<{
     elements: import("@excalidraw/element/types").OrderedExcalidrawElement[];
     appState: {
         viewModeEnabled: boolean;
+        activeTool: {
+            lastActiveTool: import("../types").ActiveTool | null;
+            locked: boolean;
+            fromSelection: boolean;
+        } & import("../types").ActiveTool;
         zenModeEnabled: boolean;
         gridModeEnabled: boolean;
         objectsSnapModeEnabled: boolean;
@@ -195,11 +204,6 @@ fileHandle?: FileSystemFileHandle | null) => Promise<{
         name: string | null;
         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;
@@ -224,6 +228,10 @@ fileHandle?: FileSystemFileHandle | null) => Promise<{
             element: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawBindableElement>;
             midPoint?: import("@excalidraw/math").GlobalPoint;
         } | null;
+        hoveredArrowTextAnchor: {
+            elementId: import("@excalidraw/element/types").ExcalidrawArrowElement["id"];
+            anchor: "start" | "end" | "label";
+        } | null;
         frameToHighlight: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawFrameLikeElement> | null;
         frameRendering: {
             enabled: boolean;
@@ -231,7 +239,7 @@ fileHandle?: FileSystemFileHandle | null) => Promise<{
             outline: boolean;
             clip: boolean;
         };
-        editingFrame: string | null;
+        editingFrame: import("@excalidraw/element/types").ExcalidrawFrameLikeElement["id"] | null;
         elementsToHighlight: readonly import("@excalidraw/element/types").NonDeletedExcalidrawElement[] | null;
         editingTextElement: import("@excalidraw/element/types").ExcalidrawTextElement | null;
         preferredSelectionTool: {

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

@@ -19,6 +19,11 @@ export declare const loadFromJSON: (localAppState: AppState, localElements: read
     elements: import("@excalidraw/element/types").OrderedExcalidrawElement[];
     appState: {
         viewModeEnabled: boolean;
+        activeTool: {
+            lastActiveTool: import("../types").ActiveTool | null;
+            locked: boolean;
+            fromSelection: boolean;
+        } & import("../types").ActiveTool;
         zenModeEnabled: boolean;
         gridModeEnabled: boolean;
         objectsSnapModeEnabled: boolean;
@@ -26,11 +31,6 @@ export declare const loadFromJSON: (localAppState: AppState, localElements: read
         name: string | null;
         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;
@@ -55,6 +55,10 @@ export declare const loadFromJSON: (localAppState: AppState, localElements: read
             element: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawBindableElement>;
             midPoint?: import("@excalidraw/math").GlobalPoint;
         } | null;
+        hoveredArrowTextAnchor: {
+            elementId: import("@excalidraw/element/types").ExcalidrawArrowElement["id"];
+            anchor: "start" | "end" | "label";
+        } | null;
         frameToHighlight: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawFrameLikeElement> | null;
         frameRendering: {
             enabled: boolean;
@@ -62,7 +66,7 @@ export declare const loadFromJSON: (localAppState: AppState, localElements: read
             outline: boolean;
             clip: boolean;
         };
-        editingFrame: string | null;
+        editingFrame: import("@excalidraw/element/types").ExcalidrawFrameLikeElement["id"] | null;
         elementsToHighlight: readonly import("@excalidraw/element/types").NonDeletedExcalidrawElement[] | null;
         editingTextElement: import("@excalidraw/element/types").ExcalidrawTextElement | null;
         preferredSelectionTool: {