@excalidraw/excalidraw 0.17.1-550a388 → 0.17.1-62228e0

package/dist/excalidraw/components/MobileMenu.js

@@ -11,8 +11,6 @@ import { Section } from "./Section";
 import { SCROLLBAR_WIDTH, SCROLLBAR_MARGIN } from "../scene/scrollbars";
 import { LockButton } from "./LockButton";
 import { PenModeButton } from "./PenModeButton";
-import { Stats } from "./Stats";
-import { actionToggleStats } from "../actions";
 import { HandButton } from "./HandButton";
 import { isHandToolActive } from "../appState";
 import { useTunnels } from "../context/tunnels";
@@ -27,9 +25,7 @@ export const MobileMenu = ({ appState, elements, actionManager, setAppState, onL
         }
         return (_jsxs("div", { className: "App-toolbar-content", children: [_jsx(MainMenuTunnel.Out, {}), actionManager.renderAction("toggleEditMenu"), actionManager.renderAction("undo"), actionManager.renderAction("redo"), actionManager.renderAction(appState.multiElement ? "finalize" : "duplicateSelection"), actionManager.renderAction("deleteSelectedElements")] }));
     };
-    return (_jsxs(_Fragment, { children: [renderSidebars(), !appState.viewModeEnabled && renderToolbar(), !appState.openMenu && appState.showStats && (_jsx(Stats, { appState: appState, setAppState: setAppState, elements: elements, onClose: () => {
-                    actionManager.executeAction(actionToggleStats);
-                }, renderCustomStats: renderCustomStats })), _jsx("div", { className: "App-bottom-bar", style: {
+    return (_jsxs(_Fragment, { children: [renderSidebars(), !appState.viewModeEnabled && renderToolbar(), _jsx("div", { className: "App-bottom-bar", style: {
                     marginBottom: SCROLLBAR_WIDTH + SCROLLBAR_MARGIN * 2,
                     marginLeft: SCROLLBAR_WIDTH + SCROLLBAR_MARGIN * 2,
                     marginRight: SCROLLBAR_WIDTH + SCROLLBAR_MARGIN * 2,
@@ -37,7 +33,7 @@ export const MobileMenu = ({ appState, elements, actionManager, setAppState, onL
                             !appState.viewModeEnabled &&
                             showSelectedShapeActions(appState, elements) ? (_jsx(Section, { className: "App-mobile-menu", heading: "selectedShapeActions", children: _jsx(SelectedShapeActions, { appState: appState, elementsMap: app.scene.getNonDeletedElementsMap(), renderAction: actionManager.renderAction }) })) : null, _jsxs("footer", { className: "App-toolbar", children: [renderAppToolbar(), appState.scrolledOutside &&
                                     !appState.openMenu &&
-                                    !appState.openSidebar && (_jsx("button", { className: "scroll-back-to-content", onClick: () => {
+                                    !appState.openSidebar && (_jsx("button", { type: "button", className: "scroll-back-to-content", onClick: () => {
                                         setAppState((appState) => ({
                                             ...calculateScrollCenter(elements, appState),
                                         }));

package/dist/excalidraw/components/Modal.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="react" />
 import "./Modal.scss";
-import { AppState } from "../types";
+import type { AppState } from "../types";
 export declare const Modal: React.FC<{
     className?: string;
     children: React.ReactNode;

package/dist/excalidraw/components/OverwriteConfirm/OverwriteConfirmState.d.ts

@@ -1,4 +1,4 @@
-import React from "react";
+import type React from "react";
 export type OverwriteConfirmState = {
     active: true;
     title: string;

package/dist/excalidraw/components/PasteChartDialog.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-import { UIAppState } from "../types";
+import type { UIAppState } from "../types";
 import "./PasteChartDialog.scss";
 export declare const PasteChartDialog: ({ setAppState, appState, onClose, }: {
     appState: UIAppState;

package/dist/excalidraw/components/PasteChartDialog.js

@@ -35,7 +35,7 @@ const ChartPreviewBtn = (props) => {
             previewNode.replaceChildren();
         };
     }, [props.spreadsheet, props.chartType, props.selected]);
-    return (_jsx("button", { className: "ChartPreview", onClick: () => {
+    return (_jsx("button", { type: "button", className: "ChartPreview", onClick: () => {
             if (chartElements) {
                 props.onClick(props.chartType, chartElements);
             }

package/dist/excalidraw/components/PropertiesPopover.d.ts

@@ -0,0 +1,15 @@
+import React, { type ReactNode } from "react";
+import * as Popover from "@radix-ui/react-popover";
+interface PropertiesPopoverProps {
+    className?: string;
+    container: HTMLDivElement | null;
+    children: ReactNode;
+    style?: object;
+    onClose: () => void;
+    onKeyDown?: React.KeyboardEventHandler<HTMLDivElement>;
+    onPointerLeave?: React.PointerEventHandler<HTMLDivElement>;
+    onFocusOutside?: Popover.DismissableLayerProps["onFocusOutside"];
+    onPointerDownOutside?: Popover.DismissableLayerProps["onPointerDownOutside"];
+}
+export declare const PropertiesPopover: React.ForwardRefExoticComponent<PropertiesPopoverProps & React.RefAttributes<HTMLDivElement>>;
+export {};

package/dist/excalidraw/components/PropertiesPopover.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from "react";
+import clsx from "clsx";
+import * as Popover from "@radix-ui/react-popover";
+import { useDevice } from "./App";
+import { Island } from "./Island";
+import { isInteractive } from "../utils";
+export const PropertiesPopover = React.forwardRef(({ className, container, children, style, onClose, onKeyDown, onFocusOutside, onPointerLeave, onPointerDownOutside, }, ref) => {
+    const device = useDevice();
+    return (_jsx(Popover.Portal, { container: container, children: _jsxs(Popover.Content, { ref: ref, className: clsx("focus-visible-none", className), "data-prevent-outside-click": true, side: device.editor.isMobile && !device.viewport.isLandscape
+                ? "bottom"
+                : "right", align: device.editor.isMobile && !device.viewport.isLandscape
+                ? "center"
+                : "start", alignOffset: -16, sideOffset: 20, style: {
+                zIndex: "var(--zIndex-popup)",
+            }, onPointerLeave: onPointerLeave, onKeyDown: onKeyDown, onFocusOutside: onFocusOutside, onPointerDownOutside: onPointerDownOutside, onCloseAutoFocus: (e) => {
+                e.stopPropagation();
+                // prevents focusing the trigger
+                e.preventDefault();
+                // return focus to excalidraw container unless
+                // user focuses an interactive element, such as a button, or
+                // enters the text editor by clicking on canvas with the text tool
+                if (container && !isInteractive(document.activeElement)) {
+                    container.focus();
+                }
+                onClose();
+            }, children: [_jsx(Island, { padding: 3, style: style, children: children }), _jsx(Popover.Arrow, { width: 20, height: 10, style: {
+                        fill: "var(--popup-bg-color)",
+                        filter: "drop-shadow(rgba(0, 0, 0, 0.05) 0px 3px 2px)",
+                    } })] }) }));
+});

package/dist/excalidraw/components/PublishLibrary.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="react" />
-import { LibraryItems, UIAppState } from "../types";
+import type { LibraryItems, UIAppState } from "../types";
 import "./PublishLibrary.scss";
 declare const PublishLibrary: ({ onClose, libraryItems, appState, onSuccess, onError, updateItemsInStorage, onRemove, }: {
     onClose: () => void;

package/dist/excalidraw/components/QuickSearch.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import "./QuickSearch.scss";
+interface QuickSearchProps {
+    className?: string;
+    placeholder: string;
+    onChange: (term: string) => void;
+}
+export declare const QuickSearch: React.ForwardRefExoticComponent<QuickSearchProps & React.RefAttributes<HTMLInputElement>>;
+export {};

package/dist/excalidraw/components/QuickSearch.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import clsx from "clsx";
+import React from "react";
+import { searchIcon } from "./icons";
+import "./QuickSearch.scss";
+export const QuickSearch = React.forwardRef(({ className, placeholder, onChange }, ref) => {
+    return (_jsxs("div", { className: clsx("QuickSearch__wrapper", className), children: [searchIcon, _jsx("input", { ref: ref, className: "QuickSearch__input", type: "text", placeholder: placeholder, onChange: (e) => onChange(e.target.value.trim().toLowerCase()) })] }));
+});

package/dist/excalidraw/components/RadioGroup.d.ts

@@ -2,7 +2,8 @@
 import "./RadioGroup.scss";
 export type RadioGroupChoice<T> = {
     value: T;
-    label: string;
+    label: React.ReactNode;
+    ariaLabel?: string;
 };
 export type RadioGroupProps<T> = {
     choices: RadioGroupChoice<T>[];

package/dist/excalidraw/components/RadioGroup.js

@@ -4,5 +4,5 @@ import "./RadioGroup.scss";
 export const RadioGroup = function ({ onChange, value, choices, name, }) {
     return (_jsx("div", { className: "RadioGroup", children: choices.map((choice) => (_jsxs("div", { className: clsx("RadioGroup__choice", {
                 active: choice.value === value,
-            }), children: [_jsx("input", { name: name, type: "radio", checked: choice.value === value, onChange: () => onChange(choice.value) }), choice.label] }, choice.label))) }));
+            }), title: choice.ariaLabel, children: [_jsx("input", { name: name, type: "radio", checked: choice.value === value, onChange: () => onChange(choice.value), "aria-label": choice.ariaLabel }), choice.label] }, String(choice.value)))) }));
 };

package/dist/excalidraw/components/SVGLayer.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="react" />
-import { Trail } from "../animated-trail";
+import type { Trail } from "../animated-trail";
 import "./SVGLayer.scss";
 type SVGLayerProps = {
     trails: Trail[];

package/dist/excalidraw/components/ScrollableList.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import "./ScrollableList.scss";
+interface ScrollableListProps {
+    className?: string;
+    placeholder: string;
+    children: React.ReactNode;
+}
+export declare const ScrollableList: ({ className, placeholder, children, }: ScrollableListProps) => JSX.Element;
+export {};

package/dist/excalidraw/components/ScrollableList.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import clsx from "clsx";
+import { Children } from "react";
+import "./ScrollableList.scss";
+export const ScrollableList = ({ className, placeholder, children, }) => {
+    const isEmpty = !Children.count(children);
+    return (_jsx("div", { className: clsx("ScrollableList__wrapper", className), role: "menu", children: isEmpty ? _jsx("div", { className: "empty", children: placeholder }) : children }));
+};

package/dist/excalidraw/components/Sidebar/Sidebar.d.ts

@@ -11,7 +11,7 @@ import "./Sidebar.scss";
 export declare const isSidebarDockedAtom: import("jotai").PrimitiveAtom<boolean> & {
     init: boolean;
 };
-export declare const SidebarInner: React.ForwardRefExoticComponent<Pick<{
+export declare const SidebarInner: React.ForwardRefExoticComponent<Omit<{
     name: string;
     children: React.ReactNode;
     onStateChange?: ((state: {
@@ -22,7 +22,7 @@ export declare const SidebarInner: React.ForwardRefExoticComponent<Pick<{
     docked?: boolean | undefined;
     className?: string | undefined;
     __fallback?: boolean | undefined;
-} & Omit<React.RefAttributes<HTMLDivElement>, "onSelect">, "name" | "children" | "key" | "className" | "onDock" | "docked" | "onStateChange" | "__fallback"> & React.RefAttributes<HTMLDivElement>>;
+} & Omit<React.RefAttributes<HTMLDivElement>, "onSelect">, "ref"> & React.RefAttributes<HTMLDivElement>>;
 export declare const Sidebar: React.ForwardRefExoticComponent<{
     name: string;
     children: React.ReactNode;

package/dist/excalidraw/components/Sidebar/Sidebar.js

@@ -4,7 +4,7 @@ import { useEffect, useLayoutEffect, useRef, useState, forwardRef, useImperative
 import { Island } from "../Island";
 import { atom, useSetAtom } from "jotai";
 import { jotaiScope } from "../../jotai";
-import { SidebarPropsContext, } from "./common";
+import { SidebarPropsContext } from "./common";
 import { SidebarHeader } from "./SidebarHeader";
 import clsx from "clsx";
 import { useDevice, useExcalidrawSetAppState } from "../App";

package/dist/excalidraw/components/Sidebar/SidebarTab.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="react" />
-import { SidebarTabName } from "../../types";
+import type { SidebarTabName } from "../../types";
 export declare const SidebarTab: {
     ({ tab, children, ...rest }: {
         tab: SidebarTabName;

package/dist/excalidraw/components/Sidebar/SidebarTabTrigger.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="react" />
-import { SidebarTabName } from "../../types";
+import type { SidebarTabName } from "../../types";
 export declare const SidebarTabTrigger: {
     ({ children, tab, onSelect, ...rest }: {
         children: React.ReactNode;

package/dist/excalidraw/components/Sidebar/SidebarTrigger.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="react" />
-import { SidebarTriggerProps } from "./common";
+import type { SidebarTriggerProps } from "./common";
 import "./SidebarTrigger.scss";
 export declare const SidebarTrigger: {
     ({ name, tab, icon, title, children, onToggle, className, style, }: SidebarTriggerProps): JSX.Element;

package/dist/excalidraw/components/Sidebar/common.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-import { AppState, SidebarName, SidebarTabName } from "../../types";
+import type { AppState, SidebarName, SidebarTabName } from "../../types";
 export type SidebarTriggerProps = {
     name: SidebarName;
     tab?: SidebarTabName;

package/dist/excalidraw/components/Stack.d.ts

@@ -10,7 +10,7 @@ type StackProps = {
     ref: React.RefObject<HTMLDivElement>;
 };
 declare const _default: {
-    Row: React.ForwardRefExoticComponent<Pick<StackProps, "children" | "style" | "gap" | "className" | "align" | "justifyContent"> & React.RefAttributes<HTMLDivElement>>;
-    Col: React.ForwardRefExoticComponent<Pick<StackProps, "children" | "style" | "gap" | "className" | "align" | "justifyContent"> & React.RefAttributes<HTMLDivElement>>;
+    Row: React.ForwardRefExoticComponent<Omit<StackProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    Col: React.ForwardRefExoticComponent<Omit<StackProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
 };
 export default _default;

package/dist/excalidraw/components/Stats/Angle.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import type { ExcalidrawElement } from "../../element/types";
+import type Scene from "../../scene/Scene";
+import type { AppState } from "../../types";
+interface AngleProps {
+    element: ExcalidrawElement;
+    scene: Scene;
+    appState: AppState;
+    property: "angle";
+}
+declare const Angle: ({ element, scene, appState, property }: AngleProps) => JSX.Element;
+export default Angle;

package/dist/excalidraw/components/Stats/Angle.js

@@ -0,0 +1,52 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { mutateElement } from "../../element/mutateElement";
+import { getBoundTextElement } from "../../element/textElement";
+import { isArrowElement } from "../../element/typeChecks";
+import { degreeToRadian, radianToDegree } from "../../math";
+import { angleIcon } from "../icons";
+import DragInput from "./DragInput";
+import { getStepSizedValue, isPropertyEditable, updateBindings } from "./utils";
+const STEP_SIZE = 15;
+const handleDegreeChange = ({ accumulatedChange, originalElements, shouldChangeByStepSize, nextValue, scene, }) => {
+    const elementsMap = scene.getNonDeletedElementsMap();
+    const origElement = originalElements[0];
+    if (origElement) {
+        const latestElement = elementsMap.get(origElement.id);
+        if (!latestElement) {
+            return;
+        }
+        if (nextValue !== undefined) {
+            const nextAngle = degreeToRadian(nextValue);
+            mutateElement(latestElement, {
+                angle: nextAngle,
+            });
+            updateBindings(latestElement, elementsMap);
+            const boundTextElement = getBoundTextElement(latestElement, elementsMap);
+            if (boundTextElement && !isArrowElement(latestElement)) {
+                mutateElement(boundTextElement, { angle: nextAngle });
+            }
+            return;
+        }
+        const originalAngleInDegrees = Math.round(radianToDegree(origElement.angle) * 100) / 100;
+        const changeInDegrees = Math.round(accumulatedChange);
+        let nextAngleInDegrees = (originalAngleInDegrees + changeInDegrees) % 360;
+        if (shouldChangeByStepSize) {
+            nextAngleInDegrees = getStepSizedValue(nextAngleInDegrees, STEP_SIZE);
+        }
+        nextAngleInDegrees =
+            nextAngleInDegrees < 0 ? nextAngleInDegrees + 360 : nextAngleInDegrees;
+        const nextAngle = degreeToRadian(nextAngleInDegrees);
+        mutateElement(latestElement, {
+            angle: nextAngle,
+        });
+        updateBindings(latestElement, elementsMap);
+        const boundTextElement = getBoundTextElement(latestElement, elementsMap);
+        if (boundTextElement && !isArrowElement(latestElement)) {
+            mutateElement(boundTextElement, { angle: nextAngle });
+        }
+    }
+};
+const Angle = ({ element, scene, appState, property }) => {
+    return (_jsx(DragInput, { label: "A", icon: angleIcon, value: Math.round((radianToDegree(element.angle) % 360) * 100) / 100, elements: [element], dragInputCallback: handleDegreeChange, editable: isPropertyEditable(element, "angle"), scene: scene, appState: appState, property: property }));
+};
+export default Angle;

package/dist/excalidraw/components/Stats/Collapsible.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+interface CollapsibleProps {
+    label: React.ReactNode;
+    open: boolean;
+    openTrigger: () => void;
+    children: React.ReactNode;
+}
+declare const Collapsible: ({ label, open, openTrigger, children, }: CollapsibleProps) => JSX.Element;
+export default Collapsible;

package/dist/excalidraw/components/Stats/Collapsible.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { InlineIcon } from "../InlineIcon";
+import { collapseDownIcon, collapseUpIcon } from "../icons";
+const Collapsible = ({ label, open, openTrigger, children, }) => {
+    return (_jsxs(_Fragment, { children: [_jsxs("div", { style: {
+                    cursor: "pointer",
+                    display: "flex",
+                    justifyContent: "space-between",
+                    alignItems: "center",
+                }, onClick: openTrigger, children: [label, _jsx(InlineIcon, { icon: open ? collapseUpIcon : collapseDownIcon })] }), open && _jsx(_Fragment, { children: children })] }));
+};
+export default Collapsible;

package/dist/excalidraw/components/Stats/Dimension.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import type { ExcalidrawElement } from "../../element/types";
+import type Scene from "../../scene/Scene";
+import type { AppState } from "../../types";
+interface DimensionDragInputProps {
+    property: "width" | "height";
+    element: ExcalidrawElement;
+    scene: Scene;
+    appState: AppState;
+}
+declare const DimensionDragInput: ({ property, element, scene, appState, }: DimensionDragInputProps) => JSX.Element;
+export default DimensionDragInput;

package/dist/excalidraw/components/Stats/Dimension.js

@@ -0,0 +1,67 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import DragInput from "./DragInput";
+import { getStepSizedValue, isPropertyEditable, resizeElement } from "./utils";
+import { MIN_WIDTH_OR_HEIGHT } from "../../constants";
+const STEP_SIZE = 10;
+const _shouldKeepAspectRatio = (element) => {
+    return element.type === "image";
+};
+const handleDimensionChange = ({ accumulatedChange, originalElements, originalElementsMap, shouldKeepAspectRatio, shouldChangeByStepSize, nextValue, property, scene, }) => {
+    const elementsMap = scene.getNonDeletedElementsMap();
+    const origElement = originalElements[0];
+    if (origElement) {
+        const keepAspectRatio = shouldKeepAspectRatio || _shouldKeepAspectRatio(origElement);
+        const aspectRatio = origElement.width / origElement.height;
+        if (nextValue !== undefined) {
+            const nextWidth = Math.max(property === "width"
+                ? nextValue
+                : keepAspectRatio
+                    ? nextValue * aspectRatio
+                    : origElement.width, MIN_WIDTH_OR_HEIGHT);
+            const nextHeight = Math.max(property === "height"
+                ? nextValue
+                : keepAspectRatio
+                    ? nextValue / aspectRatio
+                    : origElement.height, MIN_WIDTH_OR_HEIGHT);
+            resizeElement(nextWidth, nextHeight, keepAspectRatio, origElement, elementsMap);
+            return;
+        }
+        const changeInWidth = property === "width" ? accumulatedChange : 0;
+        const changeInHeight = property === "height" ? accumulatedChange : 0;
+        let nextWidth = Math.max(0, origElement.width + changeInWidth);
+        if (property === "width") {
+            if (shouldChangeByStepSize) {
+                nextWidth = getStepSizedValue(nextWidth, STEP_SIZE);
+            }
+            else {
+                nextWidth = Math.round(nextWidth);
+            }
+        }
+        let nextHeight = Math.max(0, origElement.height + changeInHeight);
+        if (property === "height") {
+            if (shouldChangeByStepSize) {
+                nextHeight = getStepSizedValue(nextHeight, STEP_SIZE);
+            }
+            else {
+                nextHeight = Math.round(nextHeight);
+            }
+        }
+        if (keepAspectRatio) {
+            if (property === "width") {
+                nextHeight = Math.round((nextWidth / aspectRatio) * 100) / 100;
+            }
+            else {
+                nextWidth = Math.round(nextHeight * aspectRatio * 100) / 100;
+            }
+        }
+        nextHeight = Math.max(MIN_WIDTH_OR_HEIGHT, nextHeight);
+        nextWidth = Math.max(MIN_WIDTH_OR_HEIGHT, nextWidth);
+        resizeElement(nextWidth, nextHeight, keepAspectRatio, origElement, elementsMap);
+    }
+};
+const DimensionDragInput = ({ property, element, scene, appState, }) => {
+    const value = Math.round((property === "width" ? element.width : element.height) * 100) /
+        100;
+    return (_jsx(DragInput, { label: property === "width" ? "W" : "H", elements: [element], dragInputCallback: handleDimensionChange, value: value, editable: isPropertyEditable(element, property), scene: scene, appState: appState, property: property }));
+};
+export default DimensionDragInput;

package/dist/excalidraw/components/Stats/DragInput.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="react" />
+import type { ElementsMap, ExcalidrawElement } from "../../element/types";
+import type { StatsInputProperty } from "./utils";
+import type Scene from "../../scene/Scene";
+import "./DragInput.scss";
+import type { AppState } from "../../types";
+export type DragInputCallbackType<P extends StatsInputProperty, E = ExcalidrawElement> = (props: {
+    accumulatedChange: number;
+    instantChange: number;
+    originalElements: readonly E[];
+    originalElementsMap: ElementsMap;
+    shouldKeepAspectRatio: boolean;
+    shouldChangeByStepSize: boolean;
+    nextValue?: number;
+    property: P;
+    scene: Scene;
+    originalAppState: AppState;
+}) => void;
+interface StatsDragInputProps<T extends StatsInputProperty, E = ExcalidrawElement> {
+    label: string | React.ReactNode;
+    icon?: React.ReactNode;
+    value: number | "Mixed";
+    elements: readonly E[];
+    editable?: boolean;
+    shouldKeepAspectRatio?: boolean;
+    dragInputCallback: DragInputCallbackType<T, E>;
+    property: T;
+    scene: Scene;
+    appState: AppState;
+}
+declare const StatsDragInput: <T extends StatsInputProperty, E extends ExcalidrawElement = ExcalidrawElement>({ label, icon, dragInputCallback, value, elements, editable, shouldKeepAspectRatio, property, scene, appState, }: StatsDragInputProps<T, E>) => JSX.Element | null;
+export default StatsDragInput;