@excalidraw/math 0.18.0-143b5b6 → 0.18.0-17d8904

package/dist/types/element/src/bounds.d.ts

@@ -81,7 +81,7 @@ export declare const boundsContainBounds: (outerBounds: Bounds, innerBounds: Bou
  * It can be used to get elements overlapping a selection box, for example.
  *
  */
-export declare const elementsOverlappingBBox: <T extends ExcalidrawElement>({ elements, elementsMap, bounds, type, excludeElementsInFrames, shouldIgnoreElementFromSelection, }: {
+export declare const elementsOverlappingBBox: <T extends ExcalidrawElement>({ elements, elementsMap, bounds, type, excludeElementsInFrames, shouldIgnoreElementFromSelection, includeStroke, }: {
     elements: readonly T[];
     elementsMap?: ElementsMap;
     bounds: Bounds | ExcalidrawElement;
@@ -92,5 +92,7 @@ export declare const elementsOverlappingBBox: <T extends ExcalidrawElement>({ el
     type: "contain" | "overlap";
     excludeElementsInFrames?: boolean;
     shouldIgnoreElementFromSelection?: (element: T) => boolean;
+    /** whether elements extend by their stroke, as they render */
+    includeStroke?: boolean;
 }) => T[];
 export declare const elementCenterPoint: (element: ExcalidrawElement, elementsMap: ElementsMap, xOffset?: number, yOffset?: number) => GlobalPoint;

package/dist/types/element/src/cropElement.d.ts

@@ -1,13 +1,45 @@
-import type { TransformHandleType } from "./transformHandles";
-import type { ElementsMap, ExcalidrawImageElement, ImageCrop } from "./types";
+import type { TransformHandleDirection } from "./transformHandles";
+import type { ElementsMap, ExcalidrawImageElement } from "./types";
 export declare const MINIMAL_CROP_SIZE = 10;
-export declare const cropElement: (element: ExcalidrawImageElement, elementsMap: ElementsMap, transformHandle: TransformHandleType, naturalWidth: number, naturalHeight: number, pointerX: number, pointerY: number, widthAspectRatio?: number) => {
+/**
+ * Crops the image (as it was at the drag's start) as resizing it would
+ * resize it, as far as the image reaches.
+ */
+export declare const cropElement: (element: ExcalidrawImageElement, elementsMap: ElementsMap, transformHandle: TransformHandleDirection, naturalWidth: number, naturalHeight: number, pointerX: number, pointerY: number, { shouldMaintainAspectRatio, shouldResizeFromCenter, }?: {
+    shouldMaintainAspectRatio?: boolean;
+    shouldResizeFromCenter?: boolean;
+}) => {
     x: number;
     y: number;
     width: number;
     height: number;
-    crop: ImageCrop | null;
+    crop: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        naturalWidth: number;
+        naturalHeight: number;
+    } | null;
 };
+/**
+ * Uncrops the image on the handle's side (a corner's two); mirrored, on the
+ * opposite side(s) too.
+ */
+export declare const uncropElementSides: (element: ExcalidrawImageElement, elementsMap: ElementsMap, handle: TransformHandleDirection, mirrored?: boolean) => {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    crop: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        naturalWidth: number;
+        naturalHeight: number;
+    } | null;
+} | null;
 export declare const getUncroppedImageElement: (element: ExcalidrawImageElement, elementsMap: ElementsMap) => ExcalidrawImageElement;
 export declare const getUncroppedWidthAndHeight: (element: ExcalidrawImageElement) => {
     width: number;

package/dist/types/element/src/groups.d.ts

@@ -1,11 +1,6 @@
-import type { AppClassProperties, AppState, InteractiveCanvasAppState } from "@excalidraw/excalidraw/types";
-import type { Mutable } from "@excalidraw/common/utility-types";
+import type { AppState, InteractiveCanvasAppState } from "@excalidraw/excalidraw/types";
 import type { GroupId, ExcalidrawElement, NonDeleted, ElementsMapOrArray, ElementsMap, NonDeletedExcalidrawElement, NonDeletedElementsMapOrArray } from "./types";
 export declare const selectGroup: (groupId: GroupId, appState: InteractiveCanvasAppState, elements: readonly NonDeletedExcalidrawElement[]) => Pick<InteractiveCanvasAppState, "selectedGroupIds" | "selectedElementIds" | "editingGroupId">;
-export declare const selectGroupsForSelectedElements: {
-    (appState: Pick<AppState, "selectedElementIds" | "editingGroupId">, elements: readonly NonDeletedExcalidrawElement[], prevAppState: InteractiveCanvasAppState, app: AppClassProperties | null): Mutable<Pick<InteractiveCanvasAppState, "selectedGroupIds" | "editingGroupId" | "selectedElementIds">>;
-    clearCache(): void;
-};
 /**
  * If the element's group is selected, don't render an individual
  * selection border around it.

package/dist/types/element/src/resizeElements.d.ts

@@ -3,7 +3,7 @@ import type { PointerDownState } from "@excalidraw/excalidraw/types";
 import type { Scene } from "./Scene";
 import type { BoundingBox } from "./bounds";
 import type { MaybeTransformHandleType, TransformHandleDirection } from "./transformHandles";
-import type { ExcalidrawLinearElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, NonDeleted, ElementsMap } from "./types";
+import type { ExcalidrawLinearElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, NonDeleted, ExcalidrawElement, ElementsMap } from "./types";
 export declare const transformElements: (originalElements: PointerDownState["originalElements"], transformHandleType: MaybeTransformHandleType, selectedElements: readonly NonDeletedExcalidrawElement[], scene: Scene, shouldRotateWithDiscreteAngle: boolean, shouldResizeFromCenter: boolean, shouldMaintainAspectRatio: boolean, pointerX: number, pointerY: number, centerX: number, centerY: number) => boolean;
 export declare const rescalePointsInElement: (element: NonDeletedExcalidrawElement, width: number, height: number, normalizePoints: boolean) => {
     points: LocalPoint[];
@@ -21,6 +21,13 @@ export declare const resizeSingleElement: (nextWidth: number, nextHeight: number
     shouldResizeFromCenter?: boolean;
     shouldInformMutation?: boolean;
 }) => void;
+export declare const getNextSingleWidthAndHeightFromPointer: (latestElement: ExcalidrawElement, origElement: ExcalidrawElement, handleDirection: TransformHandleDirection, pointerX: number, pointerY: number, { shouldMaintainAspectRatio, shouldResizeFromCenter, }?: {
+    shouldMaintainAspectRatio?: boolean;
+    shouldResizeFromCenter?: boolean;
+}) => {
+    nextWidth: number;
+    nextHeight: number;
+};
 export declare const resizeMultipleElements: (selectedElements: readonly NonDeletedExcalidrawElement[], elementsMap: ElementsMap, handleDirection: TransformHandleDirection, scene: Scene, originalElementsMap: ElementsMap, { shouldMaintainAspectRatio, shouldResizeFromCenter, flipByX, flipByY, nextHeight, nextWidth, originalBoundingBox, }?: {
     nextWidth?: number;
     nextHeight?: number;

package/dist/types/element/src/selection.d.ts

@@ -1,6 +1,6 @@
 import type { AppState, BoxSelectionMode, InteractiveCanvasAppState } from "@excalidraw/excalidraw/types";
-import { LinearElementEditor } from "./linearElementEditor";
 import type { ElementsMap, ElementsMapOrArray, ExcalidrawElement, NonDeleted, NonDeletedExcalidrawElement } from "./types";
+export declare const shouldIgnoreElementFromSelection: (element: ExcalidrawElement) => boolean;
 /**
  * Frames and their containing elements are not to be selected at the same time.
  * Given an array of selected elements, if there are frames and their containing elements
@@ -26,12 +26,6 @@ export declare const getTargetElements: (elements: ElementsMapOrArray, appState:
 export declare const makeNextSelectedElementIds: (nextSelectedElementIds: AppState["selectedElementIds"], prevState: Pick<AppState, "selectedElementIds">) => Readonly<{
     [id: string]: true;
 }>;
-export declare const getSelectionStateForElements: (targetElements: readonly NonDeletedExcalidrawElement[], allElements: readonly NonDeletedExcalidrawElement[], appState: AppState) => {
-    editingGroupId: AppState["editingGroupId"];
-    selectedElementIds: AppState["selectedElementIds"];
-    selectedGroupIds: AppState["selectedGroupIds"];
-    selectedLinearElement: LinearElementEditor | null;
-};
 /**
  * Returns editing or single-selected text element, if any.
  */

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

@@ -1,34 +1,26 @@
-import type { ExcalidrawElement, ExcalidrawLinearElement, ExcalidrawTextElement } from "@excalidraw/element/types";
-import type { Mutable } from "@excalidraw/common/utility-types";
-import type { AppState } from "../types";
+import type { Scene } from "@excalidraw/element";
+import type { ExcalidrawElement, ExcalidrawLinearElement, ExcalidrawTextContainer, ExcalidrawTextElement, ExcalidrawTextElementWithContainer, NonDeleted, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
+import type { ActionResult } from "./types";
+import type { AppClassProperties, AppState } from "../types";
+/**
+ * Frees the container's text as it rendered: wrapped the same, at a fixed
+ * width.
+ */
+export declare const unbindTextFromContainer: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElementWithContainer, scene: Scene) => void;
 export declare const actionUnbindText: {
     name: "unbindText";
     label: string;
     trackEvent: {
         category: "element";
     };
-    predicate: (elements: readonly ExcalidrawElement[], appState: AppState, _: import("../types").ExcalidrawProps, app: import("../types").AppClassProperties) => boolean;
-    perform: (elements: readonly import("@excalidraw/element/types").OrderedExcalidrawElement[], appState: Readonly<AppState>, _: unknown, app: import("../types").AppClassProperties) => {
+    predicate: (elements: readonly ExcalidrawElement[], appState: AppState, _: import("../types").ExcalidrawProps, app: AppClassProperties) => boolean;
+    perform: (elements: readonly import("@excalidraw/element/types").OrderedExcalidrawElement[], appState: Readonly<AppState>, _: unknown, app: AppClassProperties) => {
         elements: readonly import("@excalidraw/element/types").OrderedExcalidrawElement[];
-        appState: Readonly<AppState>;
-        captureUpdate: "IMMEDIATELY";
-    };
-} & {
-    keyTest?: undefined;
-};
-export declare const actionBindText: {
-    name: "bindText";
-    label: string;
-    trackEvent: {
-        category: "element";
-    };
-    predicate: (elements: readonly ExcalidrawElement[], appState: AppState, _: import("../types").ExcalidrawProps, app: import("../types").AppClassProperties) => boolean;
-    perform: (elements: readonly import("@excalidraw/element/types").OrderedExcalidrawElement[], appState: Readonly<AppState>, _: unknown, app: import("../types").AppClassProperties) => {
-        elements: ExcalidrawElement[];
         appState: {
-            selectedElementIds: {
-                [x: string]: true;
-            };
+            selectedElementIds: AppState["selectedElementIds"];
+            editingGroupId: AppState["editingGroupId"];
+            selectedGroupIds: AppState["selectedGroupIds"];
+            selectedLinearElement: import("@excalidraw/element").LinearElementEditor | null;
             contextMenu: {
                 items: import("../components/ContextMenu").ContextMenuItems;
                 top: number;
@@ -38,13 +30,13 @@ export declare const actionBindText: {
             isLoading: boolean;
             errorMessage: React.ReactNode;
             activeEmbeddable: {
-                element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
+                element: NonDeletedExcalidrawElement;
                 state: "hover" | "active";
             } | null;
-            newElement: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawNonSelectionElement> | null;
-            resizingElement: import("@excalidraw/element/types").NonDeletedExcalidrawElement | null;
-            multiElement: import("@excalidraw/element/types").NonDeleted<ExcalidrawLinearElement> | null;
-            selectionElement: import("@excalidraw/element/types").NonDeletedExcalidrawElement | null;
+            newElement: NonDeleted<import("@excalidraw/element/types").ExcalidrawNonSelectionElement> | null;
+            resizingElement: NonDeletedExcalidrawElement | null;
+            multiElement: NonDeleted<ExcalidrawLinearElement> | null;
+            selectionElement: NonDeletedExcalidrawElement | null;
             isBindingEnabled: boolean;
             boxSelectionMode: import("../types").BoxSelectionMode;
             bindingPreference: "enabled" | "disabled";
@@ -52,7 +44,7 @@ export declare const actionBindText: {
             showHints: boolean;
             inputDevice: import("../types").InputDevice;
             suggestedBinding: {
-                element: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawBindableElement>;
+                element: NonDeleted<import("@excalidraw/element/types").ExcalidrawBindableElement>;
                 midPoint?: import("@excalidraw/math").GlobalPoint;
             } | null;
             textToolHover: {
@@ -66,7 +58,7 @@ export declare const actionBindText: {
                 elementId: import("@excalidraw/element/types").ExcalidrawArrowElement["id"];
                 anchor: "start" | "end" | "label";
             } | null;
-            frameToHighlight: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawFrameLikeElement> | null;
+            frameToHighlight: NonDeleted<import("@excalidraw/element/types").ExcalidrawFrameLikeElement> | null;
             frameRendering: {
                 enabled: boolean;
                 name: boolean;
@@ -74,7 +66,7 @@ export declare const actionBindText: {
                 clip: boolean;
             };
             editingFrame: import("@excalidraw/element/types").ExcalidrawFrameLikeElement["id"] | null;
-            elementsToHighlight: readonly import("@excalidraw/element/types").NonDeletedExcalidrawElement[] | null;
+            elementsToHighlight: readonly NonDeletedExcalidrawElement[] | null;
             editingTextElement: ExcalidrawTextElement | null;
             activeTool: {
                 lastActiveTool: import("../types").ActiveTool | null;
@@ -163,10 +155,6 @@ export declare const actionBindText: {
             gridStep: number;
             gridModeEnabled: boolean;
             viewModeEnabled: boolean;
-            selectedGroupIds: {
-                [groupId: string]: boolean;
-            };
-            editingGroupId: import("@excalidraw/element/types").GroupId | null;
             width: number;
             height: number;
             offsetTop: number;
@@ -178,7 +166,6 @@ export declare const actionBindText: {
                 panels: number;
             };
             showHyperlinkPopup: false | "info" | "editor";
-            selectedLinearElement: import("@excalidraw/element").LinearElementEditor | null;
             snapLines: readonly import("../snapping").SnapLine[];
             originSnapOffset: {
                 x: number;
@@ -210,197 +197,35 @@ export declare const actionBindText: {
 } & {
     keyTest?: undefined;
 };
+export declare const actionBindText: {
+    name: "bindText";
+    label: string;
+    trackEvent: {
+        category: "element";
+    };
+    predicate: (elements: readonly ExcalidrawElement[], appState: AppState, _: import("../types").ExcalidrawProps, app: AppClassProperties) => boolean;
+    perform: (elements: readonly import("@excalidraw/element/types").OrderedExcalidrawElement[], appState: Readonly<AppState>, _: unknown, app: AppClassProperties) => ActionResult;
+} & {
+    keyTest?: undefined;
+};
+/**
+ * A note and its label share one ink: the text the user styled wins, unless it
+ * is transparent (a note's label never is).
+ */
+export declare const getStickyNoteInk: (textElement: ExcalidrawTextElement, container: ExcalidrawElement) => string | null;
+/** binds the text to the (label-less) container, selecting the container */
+export declare const bindTextToContainer: (elements: readonly ExcalidrawElement[], appState: Readonly<AppState>, textElement: ExcalidrawTextElement, container: NonDeleted<ExcalidrawTextContainer>, app: AppClassProperties) => ActionResult;
+export declare const pushContainerBelowText: (elements: readonly ExcalidrawElement[], container: ExcalidrawElement, textElement: ExcalidrawTextElement) => ExcalidrawElement[];
 export declare const actionWrapTextInContainer: {
     name: "wrapTextInContainer";
     label: string;
     trackEvent: {
         category: "element";
     };
-    predicate: (elements: readonly ExcalidrawElement[], appState: AppState, _: import("../types").ExcalidrawProps, app: import("../types").AppClassProperties) => boolean;
-    perform: (elements: readonly import("@excalidraw/element/types").OrderedExcalidrawElement[], appState: Readonly<AppState>, _: unknown, app: import("../types").AppClassProperties) => {
-        elements: readonly ExcalidrawElement[];
-        appState: {
-            selectedElementIds: Mutable<Readonly<{
-                [id: string]: true;
-            }>>;
-            contextMenu: {
-                items: import("../components/ContextMenu").ContextMenuItems;
-                top: number;
-                left: number;
-            } | null;
-            showWelcomeScreen: boolean;
-            isLoading: boolean;
-            errorMessage: React.ReactNode;
-            activeEmbeddable: {
-                element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
-                state: "hover" | "active";
-            } | null;
-            newElement: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawNonSelectionElement> | null;
-            resizingElement: import("@excalidraw/element/types").NonDeletedExcalidrawElement | null;
-            multiElement: import("@excalidraw/element/types").NonDeleted<ExcalidrawLinearElement> | null;
-            selectionElement: import("@excalidraw/element/types").NonDeletedExcalidrawElement | null;
-            isBindingEnabled: boolean;
-            boxSelectionMode: import("../types").BoxSelectionMode;
-            bindingPreference: "enabled" | "disabled";
-            isMidpointSnappingEnabled: boolean;
-            showHints: boolean;
-            inputDevice: import("../types").InputDevice;
-            suggestedBinding: {
-                element: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawBindableElement>;
-                midPoint?: import("@excalidraw/math").GlobalPoint;
-            } | null;
-            textToolHover: {
-                type: "text";
-                elementId: ExcalidrawElement["id"];
-            } | {
-                type: "container";
-                elementId: ExcalidrawElement["id"];
-            } | {
-                type: "arrow";
-                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;
-                name: boolean;
-                outline: boolean;
-                clip: boolean;
-            };
-            editingFrame: import("@excalidraw/element/types").ExcalidrawFrameLikeElement["id"] | null;
-            elementsToHighlight: readonly import("@excalidraw/element/types").NonDeletedExcalidrawElement[] | null;
-            editingTextElement: ExcalidrawTextElement | null;
-            activeTool: {
-                lastActiveTool: import("../types").ActiveTool | null;
-                locked: boolean;
-                fromSelection: boolean;
-            } & import("../types").ActiveTool;
-            preferredSelectionTool: {
-                type: "selection" | "lasso";
-                initialized: boolean;
-            };
-            penMode: boolean;
-            penDetected: boolean;
-            exportBackground: boolean;
-            exportEmbedScene: boolean;
-            exportWithDarkMode: boolean;
-            exportScale: number;
-            currentItemStrokeColor: string;
-            currentItemStickynoteStrokeColor: string;
-            currentItemStickynoteBackgroundColor: string;
-            currentItemBackgroundColor: string;
-            currentItemFillStyle: ExcalidrawElement["fillStyle"];
-            currentItemStrokeWidthKey: import("@excalidraw/common").StrokeWidthKey;
-            currentItemStrokeStyle: ExcalidrawElement["strokeStyle"];
-            currentItemRoughness: number;
-            currentItemStrokeVariability: import("@excalidraw/element/types").StrokeVariability;
-            currentItemOpacity: number;
-            currentItemFontFamily: import("@excalidraw/element/types").FontFamilyValues;
-            currentItemFontSize: number;
-            currentItemTextAlign: import("@excalidraw/element/types").TextAlign;
-            currentItemStartArrowhead: import("@excalidraw/element/types").Arrowhead | null;
-            currentItemEndArrowhead: import("@excalidraw/element/types").Arrowhead | null;
-            currentHoveredFontFamily: import("@excalidraw/element/types").FontFamilyValues | null;
-            currentItemRoundness: import("@excalidraw/element/types").StrokeRoundness;
-            currentItemArrowType: "sharp" | "round" | "elbow";
-            viewBackgroundColor: string;
-            scrollX: number;
-            scrollY: number;
-            scrollConstraints: import("../types").ScrollConstraints | null;
-            cursorButton: "up" | "down";
-            scrolledOutside: boolean;
-            name: string | null;
-            isResizing: boolean;
-            isRotating: boolean;
-            zoom: import("../types").Zoom;
-            openMenu: "canvas" | null;
-            openPopup: "canvasBackground" | "elementBackground" | "elementStroke" | "fontFamily" | "compactTextProperties" | "compactStrokeStyles" | "compactOtherProperties" | "compactArrowProperties" | null;
-            openSidebar: {
-                name: import("../types").SidebarName;
-                tab?: import("../types").SidebarTabName;
-            } | null;
-            openDialog: null | {
-                name: "imageExport" | "help" | "jsonExport";
-            } | {
-                name: "ttd";
-                tab: "text-to-diagram" | "mermaid";
-            } | {
-                name: "commandPalette";
-            } | {
-                name: "settings";
-            } | {
-                name: "elementLinkSelector";
-                sourceElementId: ExcalidrawElement["id"];
-            } | {
-                name: "charts";
-                data: import("../charts").Spreadsheet;
-                rawText: string;
-            };
-            defaultSidebarDockedPreference: boolean;
-            lastPointerDownWith: import("@excalidraw/element/types").PointerType;
-            hoveredElementIds: Readonly<{
-                [id: string]: true;
-            }>;
-            previousSelectedElementIds: {
-                [id: string]: true;
-            };
-            selectedElementsAreBeingDragged: boolean;
-            shouldCacheIgnoreZoom: boolean;
-            toast: {
-                message: React.ReactNode;
-                closable?: boolean;
-                duration?: number;
-            } | null;
-            zenModeEnabled: boolean;
-            theme: import("@excalidraw/element/types").Theme;
-            gridSize: number;
-            gridStep: number;
-            gridModeEnabled: boolean;
-            viewModeEnabled: boolean;
-            selectedGroupIds: {
-                [groupId: string]: boolean;
-            };
-            editingGroupId: import("@excalidraw/element/types").GroupId | null;
-            width: number;
-            height: number;
-            offsetTop: number;
-            offsetLeft: number;
-            fileHandle: FileSystemFileHandle | null;
-            collaborators: Map<import("../types").SocketId, import("../types").Collaborator>;
-            stats: {
-                open: boolean;
-                panels: number;
-            };
-            showHyperlinkPopup: false | "info" | "editor";
-            selectedLinearElement: import("@excalidraw/element").LinearElementEditor | null;
-            snapLines: readonly import("../snapping").SnapLine[];
-            originSnapOffset: {
-                x: number;
-                y: number;
-            } | null;
-            objectsSnapModeEnabled: boolean;
-            isCropping: boolean;
-            croppingElementId: ExcalidrawElement["id"] | null;
-            searchMatches: Readonly<{
-                focusedId: ExcalidrawElement["id"] | null;
-                matches: readonly import("../types").SearchMatch[];
-            }> | null;
-            activeLockedId: string | null;
-            lockedMultiSelections: {
-                [groupId: string]: true;
-            };
-            bindMode: import("@excalidraw/element/types").BindMode;
-            colorTopPicks: {
-                elementStroke: readonly string[] | null;
-                elementBackground: readonly string[] | null;
-                bucketFill: readonly string[] | null;
-                stickyNoteStroke: readonly string[] | null;
-                stickyNoteBackground: readonly string[] | null;
-            };
-            fontTopPicks: readonly import("@excalidraw/element/types").FontFamilyValues[] | null;
-        };
-        captureUpdate: "IMMEDIATELY";
-    };
+    predicate: (elements: readonly ExcalidrawElement[], appState: AppState, _: import("../types").ExcalidrawProps, app: AppClassProperties) => boolean;
+    perform: (elements: readonly import("@excalidraw/element/types").OrderedExcalidrawElement[], appState: Readonly<AppState>, _: unknown, app: AppClassProperties) => ActionResult;
 } & {
     keyTest?: undefined;
 };
+/** wraps each (unbound) text in a new container, selecting the containers */
+export declare const wrapTextsInContainers: (elements: readonly ExcalidrawElement[], appState: Readonly<AppState>, textElements: readonly ExcalidrawTextElement[], app: AppClassProperties) => ActionResult;

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

@@ -48,6 +48,11 @@ export declare const actionClearCanvas: {
             };
             name: string | null;
             zoom: import("../types").Zoom;
+            isBindingEnabled: boolean;
+            isMidpointSnappingEnabled: boolean;
+            selectedElementIds: Readonly<{
+                [id: string]: true;
+            }>;
             scrollX: number;
             scrollY: number;
             viewModeEnabled: boolean;
@@ -69,9 +74,6 @@ export declare const actionClearCanvas: {
                 rawText: string;
             };
             editingGroupId: import("@excalidraw/element/types").GroupId | null;
-            selectedElementIds: Readonly<{
-                [id: string]: true;
-            }>;
             frameToHighlight: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawFrameLikeElement> | null;
             activeEmbeddable: {
                 element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
@@ -84,8 +86,6 @@ export declare const actionClearCanvas: {
             selectedLinearElement: import("@excalidraw/element").LinearElementEditor | null;
             multiElement: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawLinearElement> | null;
             newElement: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawNonSelectionElement> | null;
-            isBindingEnabled: boolean;
-            isMidpointSnappingEnabled: boolean;
             suggestedBinding: {
                 element: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawBindableElement>;
                 midPoint?: import("@excalidraw/math").GlobalPoint;
@@ -120,7 +120,6 @@ export declare const actionClearCanvas: {
             shouldCacheIgnoreZoom: boolean;
             exportScale: number;
             currentItemArrowType: "sharp" | "round" | "elbow";
-            bindMode: import("@excalidraw/element/types").BindMode;
             contextMenu: {
                 items: import("../components/ContextMenu").ContextMenuItems;
                 top: number;
@@ -188,6 +187,7 @@ export declare const actionClearCanvas: {
             lockedMultiSelections: {
                 [groupId: string]: true;
             };
+            bindMode: import("@excalidraw/element/types").BindMode;
         };
         captureUpdate: "IMMEDIATELY";
     };