@myoc/excalidraw 0.18.5 → 0.18.6

package/dist/prod/locales/{en-RF5UZHGV.js → en-3XEBA2ZW.js}

@@ -1 +1 @@
-import{A,B,C,D,E,F,G,H,I,J,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z}from"../chunk-6NO4X5TH.js";import"../chunk-SRAX5OIU.js";export{f as alerts,e as buttons,l as canvasError,s as clearCanvasDialog,C as colorPicker,A as colors,I as commandPalette,v as confirmDialog,J as default,i as element,b as elementLink,x as encrypted,p as errorDialog,m as errorSplash,g as errors,q as exportDialog,G as fontList,j as headings,r as helpDialog,k as hints,w as imageExportDialog,a as labels,c as library,E as mermaid,D as overwriteConfirm,t as publishDialog,u as publishSuccessDialog,F as quickSearch,o as roomDialog,d as search,n as shareDialog,y as stats,z as toast,h as toolBar,H as userList,B as welcomeScreen};
+import{A,B,C,D,E,F,G,H,I,J,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z}from"../chunk-HYYBIWRU.js";import"../chunk-SRAX5OIU.js";export{f as alerts,e as buttons,l as canvasError,s as clearCanvasDialog,C as colorPicker,A as colors,I as commandPalette,v as confirmDialog,J as default,i as element,b as elementLink,x as encrypted,p as errorDialog,m as errorSplash,g as errors,q as exportDialog,G as fontList,j as headings,r as helpDialog,k as hints,w as imageExportDialog,a as labels,c as library,E as mermaid,D as overwriteConfirm,t as publishDialog,u as publishSuccessDialog,F as quickSearch,o as roomDialog,d as search,n as shareDialog,y as stats,z as toast,h as toolBar,H as userList,B as welcomeScreen};

package/dist/prod/subset-shared.chunk.js

@@ -1 +1 @@
-import{a,b,c,d}from"./chunk-LS7FJGPW.js";import"./chunk-44FCZ7FO.js";import"./chunk-SRAX5OIU.js";export{a as Commands,b as subsetToBase64,c as subsetToBinary,d as toBase64};
+import{a,b,c,d}from"./chunk-LS7FJGPW.js";import"./chunk-SNPKQ4QJ.js";import"./chunk-SRAX5OIU.js";export{a as Commands,b as subsetToBase64,c as subsetToBinary,d as toBase64};

package/dist/prod/subset-worker.chunk.js

@@ -1 +1 @@
-import{a as r,c as t}from"./chunk-LS7FJGPW.js";import"./chunk-44FCZ7FO.js";import"./chunk-SRAX5OIU.js";var s=import.meta.url?new URL(import.meta.url):void 0;typeof window>"u"&&typeof self<"u"&&(self.onmessage=async e=>{switch(e.data.command){case r.Subset:let a=await t(e.data.arrayBuffer,e.data.codePoints);self.postMessage(a,{transfer:[a]});break}});export{s as WorkerUrl};
+import{a as r,c as t}from"./chunk-LS7FJGPW.js";import"./chunk-SNPKQ4QJ.js";import"./chunk-SRAX5OIU.js";var s=import.meta.url?new URL(import.meta.url):void 0;typeof window>"u"&&typeof self<"u"&&(self.onmessage=async e=>{switch(e.data.command){case r.Subset:let a=await t(e.data.arrayBuffer,e.data.codePoints);self.postMessage(a,{transfer:[a]});break}});export{s as WorkerUrl};

package/dist/types/common/src/utils.d.ts

@@ -251,4 +251,7 @@ export declare const safelyParseJSON: (json: string) => Record<string, any> | nu
 export declare const escapeDoubleQuotes: (str: string) => string;
 export declare const castArray: <T>(value: T | T[]) => T[];
 export declare const elementCenterPoint: (element: ExcalidrawElement, xOffset?: number, yOffset?: number) => GlobalPoint;
+/** hack for Array.isArray type guard not working with readonly value[] */
+export declare const isReadonlyArray: (value?: any) => value is readonly any[];
+export declare const sizeOf: (value: readonly number[] | Readonly<Map<any, any>> | Record<any, any>) => number;
 export {};

package/dist/types/element/src/arrange-algorithms/packer.d.ts

@@ -0,0 +1,30 @@
+export interface Block {
+    w: number;
+    h: number;
+    fit?: TreeNode | null;
+}
+export interface TreeNode {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    used?: boolean;
+    down?: TreeNode;
+    right?: TreeNode;
+}
+/**
+ * Growth packer based on https://github.com/jakesgordon/bin-packing/tree/master
+ *
+ * Added support to adding gaps to the packing by @feng94
+ */
+export declare class GrowingPacker {
+    root: TreeNode | null;
+    gap: number;
+    constructor(gap?: number);
+    fit(blocks: Block[]): void;
+    private findNode;
+    private splitNode;
+    private growNode;
+    private growRight;
+    private growDown;
+}

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

@@ -0,0 +1,3 @@
+import type { ElementsMap, ExcalidrawElement, ArrangeAlgorithms } from "./types";
+declare const arrangeElements: (selectedElements: ExcalidrawElement[], elementsMap: ElementsMap, algorithm: ArrangeAlgorithms, gap: number) => ExcalidrawElement[];
+export { arrangeElements };

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

@@ -45,8 +45,7 @@ export declare const snapToMid: (element: ExcalidrawBindableElement, p: GlobalPo
 export declare const calculateFixedPointForElbowArrowBinding: (linearElement: NonDeleted<ExcalidrawElbowArrowElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap) => {
     fixedPoint: FixedPoint;
 };
-export declare const fixDuplicatedBindingsAfterDuplication: (newElements: ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>, duplicatedElementsMap: NonDeletedSceneElementsMap) => void;
-export declare const fixReversedBindings: (originalElements: Map<string, ExcalidrawElement>, elementsWithClones: ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
+export declare const fixDuplicatedBindingsAfterDuplication: (duplicatedElements: ExcalidrawElement[], origIdToDuplicateId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>, duplicateElementsMap: NonDeletedSceneElementsMap) => void;
 export declare const fixBindingsAfterDeletion: (sceneElements: readonly ExcalidrawElement[], deletedElements: readonly ExcalidrawElement[]) => void;
 export declare const bindingBorderTest: (element: NonDeleted<ExcalidrawBindableElement>, { x, y }: {
     x: number;

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

@@ -1,6 +1,6 @@
 import type { Degrees, GlobalPoint, LineSegment } from "@excalidraw/math";
 import type { AppState } from "@excalidraw/excalidraw/types";
-import type { ExcalidrawElement, ExcalidrawLinearElement, Arrowhead, ExcalidrawFreeDrawElement, NonDeleted, ElementsMap } from "./types";
+import type { ExcalidrawElement, ExcalidrawLinearElement, Arrowhead, ExcalidrawFreeDrawElement, NonDeleted, ElementsMap, ElementsMapOrArray } from "./types";
 import type { Drawable, Op } from "roughjs/bin/core";
 export type RectangleBox = {
     x: number;
@@ -51,7 +51,7 @@ export declare const getArrowheadSize: (arrowhead: Arrowhead) => number;
 export declare const getArrowheadAngle: (arrowhead: Arrowhead) => Degrees;
 export declare const getArrowheadPoints: (element: ExcalidrawLinearElement, shape: Drawable[], position: "start" | "end", arrowhead: Arrowhead) => number[] | null;
 export declare const getElementBounds: (element: ExcalidrawElement, elementsMap: ElementsMap) => Bounds;
-export declare const getCommonBounds: (elements: readonly ExcalidrawElement[], elementsMap?: ElementsMap) => Bounds;
+export declare const getCommonBounds: (elements: ElementsMapOrArray, elementsMap?: ElementsMap) => Bounds;
 export declare const getDraggedElementsBounds: (elements: ExcalidrawElement[], dragOffset: {
     x: number;
     y: number;

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

@@ -13,13 +13,16 @@ import type { ExcalidrawElement, GroupId } from "./types";
  *                               multiple elements at once, share this map
  *                               amongst all of them
  * @param element Element to duplicate
- * @param overrides Any element properties to override
  */
-export declare const duplicateElement: <TElement extends ExcalidrawElement>(editingGroupId: AppState["editingGroupId"], groupIdMapForOperation: Map<GroupId, GroupId>, element: TElement, overrides?: Partial<TElement> | undefined, randomizeSeed?: boolean) => Readonly<TElement>;
+export declare const duplicateElement: <TElement extends ExcalidrawElement>(editingGroupId: AppState["editingGroupId"], groupIdMapForOperation: Map<GroupId, GroupId>, element: TElement, randomizeSeed?: boolean) => Readonly<TElement>;
 export declare const duplicateElements: (opts: {
     elements: readonly ExcalidrawElement[];
     randomizeSeed?: boolean | undefined;
-    overrides?: ((originalElement: ExcalidrawElement) => Partial<ExcalidrawElement>) | undefined;
+    overrides?: ((data: {
+        duplicateElement: ExcalidrawElement;
+        origElement: ExcalidrawElement;
+        origIdToDuplicateId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>;
+    }) => Partial<ExcalidrawElement>) | undefined;
 } & ({
     /**
      * Duplicates all elements in array.
@@ -42,17 +45,11 @@ export declare const duplicateElements: (opts: {
         editingGroupId: AppState["editingGroupId"];
         selectedGroupIds: AppState["selectedGroupIds"];
     };
-    /**
-     * If true, duplicated elements are inserted _before_ specified
-     * elements. Case: alt-dragging elements to duplicate them.
-     *
-     * TODO: remove this once (if) we stop replacing the original element
-     * with the duplicated one in the scene array.
-     */
-    reverseOrder: boolean;
 })) => {
-    newElements: ExcalidrawElement[];
-    elementsWithClones: ExcalidrawElement[];
+    duplicatedElements: ExcalidrawElement[];
+    duplicateElementsMap: Map<string, ExcalidrawElement>;
+    elementsWithDuplicates: ExcalidrawElement[];
+    origIdToDuplicateId: Map<string, string>;
 };
 /**
  * Clones ExcalidrawElement data structure. Does not regenerate id, nonce, or

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

@@ -2,7 +2,7 @@ import type { ExcalidrawElementsIncludingDeleted } from "@excalidraw/excalidraw/
 import type { AppClassProperties, AppState, StaticCanvasAppState } from "@excalidraw/excalidraw/types";
 import type { ReadonlySetLike } from "@excalidraw/common/utility-types";
 import type { ElementsMap, ElementsMapOrArray, ExcalidrawElement, ExcalidrawFrameLikeElement, NonDeleted, NonDeletedExcalidrawElement } from "./types";
-export declare const bindElementsToFramesAfterDuplication: (nextElements: readonly ExcalidrawElement[], oldElements: readonly ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
+export declare const bindElementsToFramesAfterDuplication: (nextElements: readonly ExcalidrawElement[], origElements: readonly ExcalidrawElement[], origIdToDuplicateId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
 export declare function isElementIntersectingFrame(element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap): boolean;
 export declare const getElementsCompletelyInFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => ExcalidrawElement[];
 export declare const isElementContainingFrame: (element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => boolean;

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

@@ -1,4 +1,5 @@
 import type { AppState, InteractiveCanvasAppState } from "@excalidraw/excalidraw/types";
+import { LinearElementEditor } from "./linearElementEditor";
 import type { ElementsMap, ElementsMapOrArray, ExcalidrawElement, NonDeletedExcalidrawElement } from "./types";
 /**
  * Frames and their containing elements are not to be selected at the same time.
@@ -30,3 +31,13 @@ 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 ExcalidrawElement[], allElements: readonly NonDeletedExcalidrawElement[], appState: AppState) => {
+    editingGroupId: string | null;
+    selectedElementIds: Readonly<{
+        [id: string]: true;
+    }>;
+    selectedGroupIds: {
+        [groupId: string]: boolean;
+    };
+    selectedLinearElement: LinearElementEditor | null;
+};

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

@@ -279,4 +279,5 @@ export type SceneElementsMap = Map<ExcalidrawElement["id"], Ordered<ExcalidrawEl
  */
 export type NonDeletedSceneElementsMap = Map<ExcalidrawElement["id"], Ordered<NonDeletedExcalidrawElement>> & MakeBrand<"NonDeletedSceneElementsMap">;
 export type ElementsMapOrArray = readonly ExcalidrawElement[] | Readonly<ElementsMap>;
+export type ArrangeAlgorithms = "bin-packing";
 export {};

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

@@ -20,6 +20,10 @@ export declare const actionAddToLibrary: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             errorMessage: import("react").ReactNode;
             activeEmbeddable: {
                 element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
@@ -195,6 +199,10 @@ export declare const actionAddToLibrary: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             activeEmbeddable: {
                 element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
                 state: "hover" | "active";
@@ -374,6 +382,10 @@ export declare const actionAddToLibrary: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             activeEmbeddable: {
                 element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
                 state: "hover" | "active";

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

@@ -0,0 +1,30 @@
+/// <reference types="react" />
+import type { ExcalidrawElement } from "@excalidraw/element/types";
+import type { AppClassProperties, AppState } from "../types";
+export declare const arrangeElementsPredicate: (appState: import("../types").UIAppState, app: AppClassProperties) => boolean;
+/**
+ * Arranges selected elements in to be positioned nicely next to each
+ * other.
+ *
+ * Takes into account the current state's gap setting or selected algorithm
+ */
+export declare const actionArrangeElements: {
+    name: "arrangeElements";
+    label: string;
+    keywords: string[];
+    icon: import("react/jsx-runtime").JSX.Element;
+    trackEvent: {
+        category: "element";
+    };
+    viewMode: false;
+    predicate: (_elements: readonly ExcalidrawElement[], appState: AppState, _appProps: import("../types").ExcalidrawProps, app: AppClassProperties) => boolean;
+    perform: (elements: readonly import("@excalidraw/element/types").OrderedExcalidrawElement[], appState: Readonly<AppState>, _value: any, app: AppClassProperties) => {
+        appState: Readonly<AppState>;
+        elements: ExcalidrawElement[];
+        captureUpdate: "IMMEDIATELY";
+    };
+    keyTest: (event: KeyboardEvent | import("react").KeyboardEvent<Element>) => boolean;
+    PanelComponent: ({ updateData }: import("./types").PanelComponentProps) => import("react/jsx-runtime").JSX.Element;
+} & {
+    keyTest?: ((event: KeyboardEvent | import("react").KeyboardEvent<Element>) => boolean) | undefined;
+};

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

@@ -40,6 +40,10 @@ export declare const actionBindText: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             errorMessage: import("react").ReactNode;
             activeEmbeddable: {
                 element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
@@ -231,6 +235,10 @@ export declare const actionWrapTextInContainer: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             errorMessage: import("react").ReactNode;
             activeEmbeddable: {
                 element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;

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

@@ -41,6 +41,10 @@ export declare const actionZoomIn: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             errorMessage: import("react").ReactNode;
             activeEmbeddable: {
                 element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
@@ -234,6 +238,10 @@ export declare const actionZoomOut: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             errorMessage: import("react").ReactNode;
             activeEmbeddable: {
                 element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
@@ -427,6 +435,10 @@ export declare const actionResetZoom: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             errorMessage: import("react").ReactNode;
             activeEmbeddable: {
                 element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
@@ -626,6 +638,10 @@ export declare const zoomToFitBounds: ({ bounds, appState, canvasOffsets, fitToV
         myocSimplifiedMode: boolean;
         hideMainMenus: boolean;
         wheelZoomsOnDefault?: boolean | undefined;
+        arrangeConfiguration: {
+            algorithm: "bin-packing";
+            gap: number;
+        };
         errorMessage: import("react").ReactNode;
         activeEmbeddable: {
             element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
@@ -821,6 +837,10 @@ export declare const zoomToFit: ({ canvasOffsets, targetElements, appState, fitT
         myocSimplifiedMode: boolean;
         hideMainMenus: boolean;
         wheelZoomsOnDefault?: boolean | undefined;
+        arrangeConfiguration: {
+            algorithm: "bin-packing";
+            gap: number;
+        };
         errorMessage: import("react").ReactNode;
         activeEmbeddable: {
             element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
@@ -1008,6 +1028,10 @@ export declare const actionZoomToFitSelectionInViewport: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             errorMessage: import("react").ReactNode;
             activeEmbeddable: {
                 element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
@@ -1199,6 +1223,10 @@ export declare const actionZoomToFitSelection: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             errorMessage: import("react").ReactNode;
             activeEmbeddable: {
                 element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
@@ -1391,6 +1419,10 @@ export declare const actionZoomToFit: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             errorMessage: import("react").ReactNode;
             activeEmbeddable: {
                 element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
@@ -1580,6 +1612,10 @@ export declare const actionToggleTheme: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             errorMessage: import("react").ReactNode;
             activeEmbeddable: {
                 element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
@@ -1778,6 +1814,10 @@ export declare const actionToggleEraserTool: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             errorMessage: import("react").ReactNode;
             newElement: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawNonSelectionElement> | null;
             resizingElement: import("@excalidraw/element/types").NonDeletedExcalidrawElement | null;
@@ -1962,6 +2002,10 @@ export declare const actionToggleLassoTool: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             errorMessage: import("react").ReactNode;
             newElement: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawNonSelectionElement> | null;
             resizingElement: import("@excalidraw/element/types").NonDeletedExcalidrawElement | null;
@@ -2146,6 +2190,10 @@ export declare const actionToggleHandTool: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             errorMessage: import("react").ReactNode;
             newElement: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawNonSelectionElement> | null;
             resizingElement: import("@excalidraw/element/types").NonDeletedExcalidrawElement | null;

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

@@ -20,6 +20,10 @@ export declare const actionCopy: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             activeEmbeddable: {
                 element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
                 state: "hover" | "active";
@@ -213,6 +217,10 @@ export declare const actionPaste: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             activeEmbeddable: {
                 element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
                 state: "hover" | "active";
@@ -407,6 +415,10 @@ export declare const actionCut: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             errorMessage: import("react").ReactNode;
             activeEmbeddable: {
                 element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
@@ -617,6 +629,10 @@ export declare const actionCut: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             errorMessage: import("react").ReactNode;
             activeEmbeddable: {
                 element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
@@ -811,6 +827,10 @@ export declare const actionCut: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             errorMessage: import("react").ReactNode;
             newElement: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawNonSelectionElement> | null;
             resizingElement: import("@excalidraw/element/types").NonDeletedExcalidrawElement | null;
@@ -1018,6 +1038,10 @@ export declare const actionCopyAsPng: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             activeEmbeddable: {
                 element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
                 state: "hover" | "active";

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

@@ -22,6 +22,10 @@ export declare const actionToggleCropEditor: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             errorMessage: import("react").ReactNode;
             activeEmbeddable: {
                 element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;

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

@@ -24,6 +24,10 @@ export declare const actionDeleteSelected: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             errorMessage: import("react").ReactNode;
             activeEmbeddable: {
                 element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
@@ -234,6 +238,10 @@ export declare const actionDeleteSelected: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             errorMessage: import("react").ReactNode;
             activeEmbeddable: {
                 element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
@@ -428,6 +436,10 @@ export declare const actionDeleteSelected: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             errorMessage: import("react").ReactNode;
             newElement: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawNonSelectionElement> | null;
             resizingElement: import("@excalidraw/element/types").NonDeletedExcalidrawElement | null;

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

@@ -51,6 +51,10 @@ export declare const actionLinkToElement: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             errorMessage: import("react").ReactNode;
             activeEmbeddable: {
                 element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;

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

@@ -22,6 +22,10 @@ export declare const actionToggleElementLock: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             errorMessage: import("react").ReactNode;
             activeEmbeddable: {
                 element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
@@ -217,6 +221,10 @@ export declare const actionUnlockAllElements: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             errorMessage: import("react").ReactNode;
             activeEmbeddable: {
                 element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;

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

@@ -24,6 +24,10 @@ export declare const actionSetEmbeddableAsActiveTool: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             errorMessage: import("react").ReactNode;
             activeEmbeddable: {
                 element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;

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

@@ -18,6 +18,10 @@ export declare const actionChangeProjectName: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             errorMessage: import("react").ReactNode;
             activeEmbeddable: {
                 element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
@@ -209,6 +213,10 @@ export declare const actionChangeExportScale: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             errorMessage: import("react").ReactNode;
             activeEmbeddable: {
                 element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
@@ -400,6 +408,10 @@ export declare const actionChangeExportBackground: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             errorMessage: import("react").ReactNode;
             activeEmbeddable: {
                 element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
@@ -591,6 +603,10 @@ export declare const actionChangeExportEmbedScene: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             errorMessage: import("react").ReactNode;
             activeEmbeddable: {
                 element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
@@ -787,6 +803,10 @@ export declare const actionSaveToActiveFile: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             errorMessage: import("react").ReactNode;
             activeEmbeddable: {
                 element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
@@ -981,6 +1001,10 @@ export declare const actionSaveFileToDisk: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             errorMessage: import("react").ReactNode;
             activeEmbeddable: {
                 element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
@@ -1252,6 +1276,10 @@ export declare const actionLoadScene: {
             isLoading: boolean;
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             errorMessage: import("react").ReactNode;
             newElement: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawNonSelectionElement> | null;
             resizingElement: import("@excalidraw/element/types").NonDeletedExcalidrawElement | null;
@@ -1337,6 +1365,10 @@ export declare const actionLoadScene: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             activeEmbeddable: {
                 element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
                 state: "hover" | "active";
@@ -1529,6 +1561,10 @@ export declare const actionExportWithDarkMode: {
             myocSimplifiedMode: boolean;
             hideMainMenus: boolean;
             wheelZoomsOnDefault?: boolean | undefined;
+            arrangeConfiguration: {
+                algorithm: "bin-packing";
+                gap: number;
+            };
             errorMessage: import("react").ReactNode;
             activeEmbeddable: {
                 element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;