@zsviczian/excalidraw 0.10.0-obsidian-18 → 0.10.0-obsidian-22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zsviczian/excalidraw",
-  "version": "0.10.0-obsidian-18",
+  "version": "0.10.0-obsidian-22",
   "main": "main.js",
   "types": "types/packages/excalidraw/index.d.ts",
   "files": [
@@ -57,14 +57,13 @@
     "babel-plugin-transform-class-properties": "6.24.1",
     "cross-env": "7.0.3",
     "css-loader": "6.5.1",
-    "file-loader": "6.2.0",
     "mini-css-extract-plugin": "2.4.5",
     "postcss-loader": "6.2.1",
-    "sass-loader": "12.3.0",
+    "sass-loader": "12.4.0",
     "terser-webpack-plugin": "5.2.5",
     "ts-loader": "9.2.6",
-    "typescript": "4.5.2",
-    "webpack": "5.64.4",
+    "typescript": "4.5.3",
+    "webpack": "5.65.0",
     "webpack-bundle-analyzer": "4.5.0",
     "webpack-cli": "4.9.1"
   },

package/types/actions/actionCanvas.d.ts

@@ -27,7 +27,7 @@ export declare const zoomToFitElements: (elements: readonly ExcalidrawElement[],
         suggestedBindings: import("../element/binding").SuggestedBinding[];
         editingElement: import("../element/types").NonDeletedExcalidrawElement | null;
         editingLinearElement: import("../element/linearElementEditor").LinearElementEditor | null;
-        elementType: "line" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "text" | "arrow" | "freedraw";
+        elementType: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "freedraw";
         elementLocked: boolean;
         exportBackground: boolean;
         exportEmbedScene: boolean;

package/types/appState.d.ts

@@ -14,7 +14,7 @@ export declare const clearAppStateForLocalStorage: (appState: Partial<AppState>)
     shouldCacheIgnoreZoom?: boolean | undefined;
     theme?: string | undefined;
     name?: string | undefined;
-    elementType?: "line" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "text" | "arrow" | "freedraw" | undefined;
+    elementType?: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "freedraw" | undefined;
     elementLocked?: boolean | undefined;
     exportBackground?: boolean | undefined;
     exportEmbedScene?: boolean | undefined;

package/types/components/App.d.ts

@@ -141,7 +141,7 @@ declare class App extends React.Component<AppProps, AppState> {
     private scheduleImageRefresh;
     private updateBindingEnabledOnPointerMove;
     private maybeSuggestBindingAtCursor;
-    private maybeSuggestBindingForLinearElementAtCursor;
+    private maybeSuggestBindingsForLinearElementAtCoords;
     private maybeSuggestBindingForAll;
     private clearSelection;
     private handleCanvasRef;

package/types/components/Card.d.ts

@@ -2,5 +2,5 @@
 import OpenColor from "open-color";
 import "./Card.scss";
 export declare const Card: React.FC<{
-    color: keyof OpenColor;
+    color: keyof OpenColor | "primary";
 }>;

package/types/components/LayerUI.d.ts

@@ -3,8 +3,9 @@ import { ActionManager } from "../actions/manager";
 import { NonDeletedExcalidrawElement } from "../element/types";
 import { Language } from "../i18n";
 import { AppProps, AppState, ExcalidrawProps, BinaryFiles } from "../types";
-import "./LayerUI.scss";
 import Library from "../data/library";
+import "./LayerUI.scss";
+import "./Toolbar.scss";
 interface LayerUIProps {
     actionManager: ActionManager;
     appState: AppState;

package/types/components/LibraryButton.d.ts

@@ -3,4 +3,5 @@ import { AppState } from "../types";
 export declare const LibraryButton: React.FC<{
     appState: AppState;
     setAppState: React.Component<any, AppState>["setState"];
+    isMobile?: boolean;
 }>;

package/types/components/LockButton.d.ts

@@ -6,6 +6,7 @@ declare type LockIconProps = {
     checked: boolean;
     onChange?(): void;
     zenModeEnabled?: boolean;
+    isMobile?: boolean;
 };
 export declare const LockButton: (props: LockIconProps) => JSX.Element;
 export {};

package/types/constants.d.ts

@@ -130,3 +130,4 @@ export declare const VERSIONS: {
     readonly excalidraw: 2;
     readonly excalidrawLibrary: 2;
 };
+export declare const PADDING = 30;

package/types/element/collision.d.ts

@@ -4,6 +4,7 @@ import { Point } from "../types";
 import { AppState } from "../types";
 export declare const hitTest: (element: NonDeletedExcalidrawElement, appState: AppState, x: number, y: number) => boolean;
 export declare const isHittingElementBoundingBoxWithoutHittingElement: (element: NonDeletedExcalidrawElement, appState: AppState, x: number, y: number) => boolean;
+export declare const isHittingElementNotConsideringBoundingBox: (element: NonDeletedExcalidrawElement, appState: AppState, point: readonly [number, number]) => boolean;
 export declare const bindingBorderTest: (element: NonDeleted<ExcalidrawBindableElement>, { x, y }: {
     x: number;
     y: number;

package/types/element/dragElements.d.ts

@@ -1,7 +1,6 @@
 import { SHAPES } from "../shapes";
-import Scene from "../scene/Scene";
 import { NonDeletedExcalidrawElement } from "./types";
 import { PointerDownState } from "../types";
-export declare const dragSelectedElements: (pointerDownState: PointerDownState, selectedElements: NonDeletedExcalidrawElement[], pointerX: number, pointerY: number, scene: Scene, lockDirection?: boolean, distanceX?: number, distanceY?: number) => void;
+export declare const dragSelectedElements: (pointerDownState: PointerDownState, selectedElements: NonDeletedExcalidrawElement[], pointerX: number, pointerY: number, lockDirection?: boolean, distanceX?: number, distanceY?: number) => void;
 export declare const getDragOffsetXY: (selectedElements: NonDeletedExcalidrawElement[], x: number, y: number) => [number, number];
 export declare const dragNewElement: (draggingElement: NonDeletedExcalidrawElement, elementType: typeof SHAPES[number]["value"], originX: number, originY: number, x: number, y: number, width: number, height: number, shouldMaintainAspectRatio: boolean, shouldResizeFromCenter: boolean, widthAspectRatio?: number | null | undefined) => void;

package/types/element/linearElementEditor.d.ts

@@ -7,14 +7,20 @@ export declare class LinearElementEditor {
     elementId: ExcalidrawElement["id"] & {
         _brand: "excalidrawLinearElementId";
     };
-    activePointIndex: number | null;
+    /** indices */
+    selectedPointsIndices: readonly number[] | null;
+    pointerDownState: Readonly<{
+        prevSelectedPointsIndices: readonly number[] | null;
+        /** index */
+        lastClickedPoint: number;
+    }>;
     /** whether you're dragging a point */
     isDragging: boolean;
     lastUncommittedPoint: Point | null;
-    pointerOffset: {
+    pointerOffset: Readonly<{
         x: number;
         y: number;
-    };
+    }>;
     startBindingElement: ExcalidrawBindableElement | null | "keep";
     endBindingElement: ExcalidrawBindableElement | null | "keep";
     constructor(element: NonDeleted<ExcalidrawLinearElement>, scene: Scene);
@@ -24,8 +30,12 @@ export declare class LinearElementEditor {
      *  statically guarantee this method returns an ExcalidrawLinearElement)
      */
     static getElement(id: InstanceType<typeof LinearElementEditor>["elementId"]): NonDeleted<ExcalidrawLinearElement> | null;
+    static handleBoxSelection(event: PointerEvent, appState: AppState, setState: React.Component<any, AppState>["setState"]): false | undefined;
     /** @returns whether point was dragged */
-    static handlePointDragging(appState: AppState, setState: React.Component<any, AppState>["setState"], scenePointerX: number, scenePointerY: number, maybeSuggestBinding: (element: NonDeleted<ExcalidrawLinearElement>, startOrEnd: "start" | "end") => void): boolean;
+    static handlePointDragging(appState: AppState, setState: React.Component<any, AppState>["setState"], scenePointerX: number, scenePointerY: number, maybeSuggestBinding: (element: NonDeleted<ExcalidrawLinearElement>, pointSceneCoords: {
+        x: number;
+        y: number;
+    }[]) => void): boolean;
     static handlePointerUp(event: PointerEvent, editingLinearElement: LinearElementEditor, appState: AppState): LinearElementEditor;
     static handlePointerDown(event: React.PointerEvent<HTMLCanvasElement>, appState: AppState, setState: React.Component<any, AppState>["setState"], history: History, scenePointer: {
         x: number;
@@ -35,6 +45,9 @@ export declare class LinearElementEditor {
         hitElement: NonDeleted<ExcalidrawElement> | null;
     };
     static handlePointerMove(event: React.PointerEvent<HTMLCanvasElement>, scenePointerX: number, scenePointerY: number, editingLinearElement: LinearElementEditor, gridSize: number | null): LinearElementEditor;
+    /** scene coords */
+    static getPointGlobalCoordinates(element: NonDeleted<ExcalidrawLinearElement>, point: Point): readonly [number, number];
+    /** scene coords */
     static getPointsGlobalCoordinates(element: NonDeleted<ExcalidrawLinearElement>): number[][];
     static getPointAtIndexGlobalCoordinates(element: NonDeleted<ExcalidrawLinearElement>, indexMaybeFromEnd: number): Point;
     static pointFromAbsoluteCoords(element: NonDeleted<ExcalidrawLinearElement>, absoluteCoords: Point): Point;
@@ -51,12 +64,123 @@ export declare class LinearElementEditor {
         y: number;
     };
     static normalizePoints(element: NonDeleted<ExcalidrawLinearElement>): void;
-    static movePointByOffset(element: NonDeleted<ExcalidrawLinearElement>, pointIndex: number, offset: {
-        x: number;
-        y: number;
-    }): void;
-    static movePoint(element: NonDeleted<ExcalidrawLinearElement>, pointIndex: number | "new", targetPosition: Point | "delete", otherUpdates?: {
+    static duplicateSelectedPoints(appState: AppState): false | {
+        appState: {
+            editingLinearElement: {
+                selectedPointsIndices: number[];
+                elementId: string & {
+                    _brand: "excalidrawLinearElementId";
+                };
+                pointerDownState: Readonly<{
+                    prevSelectedPointsIndices: readonly number[] | null;
+                    /** index */
+                    lastClickedPoint: number;
+                }>;
+                /** whether you're dragging a point */
+                isDragging: boolean;
+                lastUncommittedPoint: readonly [number, number] | null;
+                pointerOffset: Readonly<{
+                    x: number;
+                    y: number;
+                }>;
+                startBindingElement: ExcalidrawBindableElement | "keep" | null;
+                endBindingElement: ExcalidrawBindableElement | "keep" | null;
+            };
+            isLoading: boolean;
+            errorMessage: string | null;
+            draggingElement: import("./types").NonDeletedExcalidrawElement | null;
+            resizingElement: import("./types").NonDeletedExcalidrawElement | null;
+            multiElement: NonDeleted<ExcalidrawLinearElement> | null;
+            selectionElement: import("./types").NonDeletedExcalidrawElement | null;
+            isBindingEnabled: boolean;
+            startBoundElement: NonDeleted<ExcalidrawBindableElement> | null;
+            suggestedBindings: import("./binding").SuggestedBinding[];
+            editingElement: import("./types").NonDeletedExcalidrawElement | null;
+            elementType: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "freedraw";
+            elementLocked: boolean;
+            exportBackground: boolean;
+            exportEmbedScene: boolean;
+            exportWithDarkMode: boolean;
+            exportScale: number;
+            currentItemStrokeColor: string;
+            currentItemBackgroundColor: string;
+            currentItemFillStyle: import("./types").FillStyle;
+            currentItemStrokeWidth: number;
+            currentItemStrokeStyle: import("./types").StrokeStyle;
+            currentItemRoughness: number;
+            currentItemOpacity: number;
+            currentItemFontFamily: number;
+            currentItemFontSize: number;
+            currentItemTextAlign: import("./types").TextAlign;
+            currentItemStrokeSharpness: import("./types").StrokeSharpness;
+            currentItemStartArrowhead: import("./types").Arrowhead | null;
+            currentItemEndArrowhead: import("./types").Arrowhead | null;
+            currentItemLinearStrokeSharpness: import("./types").StrokeSharpness;
+            viewBackgroundColor: string;
+            scrollX: number;
+            scrollY: number;
+            cursorButton: "up" | "down";
+            scrolledOutside: boolean;
+            name: string;
+            isResizing: boolean;
+            isRotating: boolean;
+            zoom: Readonly<{
+                value: import("../types").NormalizedZoomValue;
+                translation: Readonly<{
+                    x: number;
+                    y: number;
+                }>;
+            }>;
+            openMenu: "canvas" | "shape" | null;
+            openPopup: "canvasColorPicker" | "backgroundColorPicker" | "strokeColorPicker" | null;
+            lastPointerDownWith: import("./types").PointerType;
+            selectedElementIds: {
+                [id: string]: boolean;
+            };
+            previousSelectedElementIds: {
+                [id: string]: boolean;
+            };
+            shouldCacheIgnoreZoom: boolean;
+            showHelpDialog: boolean;
+            toastMessage: string | null;
+            zenModeEnabled: boolean;
+            theme: string;
+            gridSize: number | null;
+            viewModeEnabled: boolean;
+            selectedGroupIds: {
+                [groupId: string]: boolean;
+            };
+            editingGroupId: string | null;
+            width: number;
+            height: number;
+            offsetTop: number;
+            offsetLeft: number;
+            isLibraryOpen: boolean;
+            fileHandle: import("browser-fs-access").FileSystemHandle | null;
+            collaborators: Map<string, import("../types").Collaborator>;
+            showStats: boolean;
+            currentChartType: import("./types").ChartType;
+            pasteDialog: {
+                shown: false;
+                data: null;
+            } | {
+                shown: true;
+                data: import("../charts").Spreadsheet;
+            };
+            pendingImageElement: NonDeleted<import("./types").ExcalidrawImageElement> | null;
+        };
+    };
+    static deletePoints(element: NonDeleted<ExcalidrawLinearElement>, pointIndices: readonly number[]): void;
+    static addPoints(element: NonDeleted<ExcalidrawLinearElement>, targetPoints: {
+        point: Point;
+    }[]): void;
+    static movePoints(element: NonDeleted<ExcalidrawLinearElement>, targetPoints: {
+        index: number;
+        point: Point;
+        isDragging?: boolean;
+    }[], otherUpdates?: {
         startBinding?: PointBinding;
         endBinding?: PointBinding;
     }): void;
+    private static _updatePoints;
 }

package/types/element/newElement.d.ts

@@ -1,6 +1,6 @@
-import { ExcalidrawElement, ExcalidrawImageElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawGenericElement, NonDeleted, TextAlign, GroupId, VerticalAlign, Arrowhead, ExcalidrawFreeDrawElement, FontFamilyValues } from "../element/types";
+import { ExcalidrawElement, ExcalidrawImageElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawGenericElement, NonDeleted, TextAlign, GroupId, VerticalAlign, Arrowhead, ExcalidrawFreeDrawElement, FontFamilyValues, ExcalidrawRectangleElement } from "../element/types";
 import { AppState } from "../types";
-declare type ElementConstructorOpts = MarkOptional<Omit<ExcalidrawGenericElement, "id" | "type" | "isDeleted" | "updated">, "width" | "height" | "angle" | "groupIds" | "boundElementIds" | "seed" | "version" | "versionNonce">;
+declare type ElementConstructorOpts = MarkOptional<Omit<ExcalidrawGenericElement, "id" | "type" | "isDeleted" | "updated">, "width" | "height" | "angle" | "groupIds" | "boundElements" | "seed" | "version" | "versionNonce">;
 export declare const newElement: (opts: {
     type: ExcalidrawGenericElement["type"];
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawGenericElement>;
@@ -11,12 +11,14 @@ export declare const newTextElement: (opts: {
     fontFamily: FontFamilyValues;
     textAlign: TextAlign;
     verticalAlign: VerticalAlign;
+    containerId?: ExcalidrawRectangleElement["id"];
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawTextElement>;
-export declare const updateTextElement: (element: ExcalidrawTextElement, { text, rawText, isDeleted, }: {
+export declare const updateTextElement: (element: ExcalidrawTextElement, { text, isDeleted, originalText, rawText, }: {
     text: string;
-    rawText?: string | undefined;
     isDeleted?: boolean | undefined;
-}) => ExcalidrawTextElement;
+    originalText: string;
+    rawText?: string | undefined;
+}, updateDimensions: boolean) => ExcalidrawTextElement;
 export declare const newFreeDrawElement: (opts: {
     type: "freedraw";
     points?: ExcalidrawFreeDrawElement["points"];

package/types/element/textElement.d.ts

@@ -1,2 +1,23 @@
-import { ExcalidrawTextElement } from "./types";
+import { ExcalidrawElement, ExcalidrawTextElement, FontString, NonDeletedExcalidrawElement } from "./types";
+import { MaybeTransformHandleType } from "./transformHandles";
 export declare const redrawTextBoundingBox: (element: ExcalidrawTextElement) => void;
+export declare const bindTextToShapeAfterDuplication: (sceneElements: ExcalidrawElement[], oldElements: ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
+export declare const handleBindTextResize: (elements: readonly NonDeletedExcalidrawElement[], transformHandleType: MaybeTransformHandleType) => void;
+export declare const measureText: (text: string, font: FontString, maxWidth?: number | null | undefined) => {
+    width: number;
+    height: number;
+    baseline: number;
+};
+export declare const getApproxLineHeight: (font: FontString) => number;
+export declare const wrapText: (text: string, font: FontString, containerWidth: number) => string;
+export declare const charWidth: {
+    calculate: (char: string, font: FontString) => number;
+    updateCache: (char: string, font: FontString) => void;
+    clearCacheforFont: (font: FontString) => void;
+    getCache: (font: FontString) => number[];
+};
+export declare const getApproxMinLineWidth: (font: FontString) => number;
+export declare const getApproxMinLineHeight: (font: FontString) => number;
+export declare const getMinCharWidth: (font: FontString) => number;
+export declare const getApproxCharsToFitInWidth: (font: FontString, width: number) => number;
+export declare const getBoundTextElementId: (container: ExcalidrawElement | null) => string | undefined;

package/types/element/textWysiwyg.d.ts

@@ -7,6 +7,7 @@ export declare const textWysiwyg: ({ id, appState, onChange, onSubmit, getViewpo
     onSubmit: (data: {
         text: string;
         viaKeyboard: boolean;
+        originalText: string;
     }) => void;
     getViewportCoords: (x: number, y: number) => [number, number];
     element: ExcalidrawElement;

package/types/element/typeChecks.d.ts

@@ -1,4 +1,4 @@
-import { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawBindableElement, ExcalidrawGenericElement, ExcalidrawFreeDrawElement, InitializedExcalidrawImageElement, ExcalidrawImageElement } from "./types";
+import { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawBindableElement, ExcalidrawGenericElement, ExcalidrawFreeDrawElement, InitializedExcalidrawImageElement, ExcalidrawImageElement, ExcalidrawTextElementWithContainer } from "./types";
 export declare const isGenericElement: (element: ExcalidrawElement | null) => element is ExcalidrawGenericElement;
 export declare const isInitializedImageElement: (element: ExcalidrawElement | null) => element is InitializedExcalidrawImageElement;
 export declare const isImageElement: (element: ExcalidrawElement | null) => element is ExcalidrawImageElement;
@@ -10,4 +10,7 @@ export declare const isLinearElementType: (elementType: ExcalidrawElement["type"
 export declare const isBindingElement: (element?: ExcalidrawElement | null | undefined) => element is ExcalidrawLinearElement;
 export declare const isBindingElementType: (elementType: ExcalidrawElement["type"]) => boolean;
 export declare const isBindableElement: (element: ExcalidrawElement | null) => element is ExcalidrawBindableElement;
+export declare const isTextBindableContainer: (element: ExcalidrawElement | null) => boolean;
 export declare const isExcalidrawElement: (element: any) => boolean;
+export declare const hasBoundTextElement: (element: ExcalidrawElement | null) => element is ExcalidrawBindableElement;
+export declare const isBoundToContainer: (element: ExcalidrawElement | null) => element is ExcalidrawTextElementWithContainer;

package/types/element/types.d.ts

@@ -43,8 +43,11 @@ declare type _ExcalidrawElementBase = Readonly<{
     /** List of groups the element belongs to.
         Ordered from deepest to shallowest. */
     groupIds: readonly GroupId[];
-    /** Ids of (linear) elements that are bound to this element. */
-    boundElementIds: readonly ExcalidrawLinearElement["id"][] | null;
+    /** other elements that are bound to this element */
+    boundElements: readonly Readonly<{
+        id: ExcalidrawLinearElement["id"];
+        type: "arrow" | "text";
+    }>[] | null;
     /** epoch (ms) timestamp of last element update */
     updated: number;
 }>;
@@ -92,8 +95,13 @@ export declare type ExcalidrawTextElement = _ExcalidrawElementBase & Readonly<{
     baseline: number;
     textAlign: TextAlign;
     verticalAlign: VerticalAlign;
+    containerId: ExcalidrawGenericElement["id"] | null;
+    originalText: string;
 }>;
 export declare type ExcalidrawBindableElement = ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawEllipseElement | ExcalidrawTextElement | ExcalidrawImageElement;
+export declare type ExcalidrawTextElementWithContainer = {
+    containerId: ExcalidrawGenericElement["id"];
+} & ExcalidrawTextElement;
 export declare type PointBinding = {
     elementId: ExcalidrawBindableElement["id"];
     focus: number;

package/types/packages/excalidraw/index.d.ts

@@ -9,7 +9,7 @@ export default _default;
 export { getSceneVersion, isInvisiblySmallElement, getNonDeletedElements, } from "../../element";
 export { defaultLang, languages } from "../../i18n";
 export { restore, restoreAppState, restoreElements } from "../../data/restore";
-export { exportToCanvas, exportToBlob, exportToSvg, serializeAsJSON, loadLibraryFromBlob, loadFromBlob, getFreeDrawSvgPath, getCommonBoundingBox, getMaximumGroups, intersectElementWithLine, determineFocusDistance } from "../../packages/utils";
+export { exportToCanvas, exportToBlob, exportToSvg, serializeAsJSON, loadLibraryFromBlob, loadFromBlob, getFreeDrawSvgPath, getCommonBoundingBox, getMaximumGroups, intersectElementWithLine, determineFocusDistance, } from "../../packages/utils";
 export { isLinearElement } from "../../element/typeChecks";
 export { FONT_FAMILY, THEME } from "../../constants";
 export { mutateElement, newElementWith, bumpVersion, } from "../../element/mutateElement";

package/types/packages/excalidraw/webpack.dev.config.d.ts

@@ -9,6 +9,7 @@ export namespace output {
     const libraryTarget: string;
     const filename: string;
     const chunkFilename: string;
+    const assetModuleFilename: string;
     const publicPath: string;
 }
 export namespace resolve {

package/types/packages/excalidraw/webpack.prod.config.d.ts

@@ -9,6 +9,7 @@ export namespace output {
     const libraryTarget: string;
     const filename: string;
     const chunkFilename: string;
+    const assetModuleFilename: string;
     const publicPath: string;
 }
 export namespace resolve {

package/types/scene/comparisons.d.ts

@@ -8,4 +8,4 @@ export declare const hasText: (type: string) => boolean;
 export declare const canHaveArrowheads: (type: string) => boolean;
 export declare const getElementAtPosition: (elements: readonly NonDeletedExcalidrawElement[], isAtPositionFn: (element: NonDeletedExcalidrawElement) => boolean) => NonDeletedExcalidrawElement | null;
 export declare const getElementsAtPosition: (elements: readonly NonDeletedExcalidrawElement[], isAtPositionFn: (element: NonDeletedExcalidrawElement) => boolean) => NonDeletedExcalidrawElement[];
-export declare const getElementContainingPosition: (elements: readonly ExcalidrawElement[], x: number, y: number) => ExcalidrawElement | null;
+export declare const getElementContainingPosition: (elements: readonly ExcalidrawElement[], x: number, y: number, excludedType?: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "freedraw" | undefined) => ExcalidrawElement | null;

package/types/scene/selection.d.ts

@@ -7,5 +7,5 @@ export declare const isSomeElementSelected: (elements: readonly NonDeletedExcali
  *  elements. If elements don't share the same value, returns `null`.
  */
 export declare const getCommonAttributeOfSelectedElements: <T>(elements: readonly NonDeletedExcalidrawElement[], appState: AppState, getAttribute: (element: ExcalidrawElement) => T) => T | null;
-export declare const getSelectedElements: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState) => NonDeletedExcalidrawElement[];
+export declare const getSelectedElements: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState, includeBoundTextElement?: boolean) => NonDeletedExcalidrawElement[];
 export declare const getTargetElements: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState) => NonDeletedExcalidrawElement[];

package/types/shapes.d.ts

@@ -36,4 +36,4 @@ export declare const SHAPES: readonly [{
     readonly value: "image";
     readonly key: null;
 }];
-export declare const findShapeByKey: (key: string) => "line" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "text" | "arrow" | "freedraw" | null;
+export declare const findShapeByKey: (key: string) => "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "freedraw" | null;

package/types/types.d.ts

@@ -290,6 +290,7 @@ export declare type PointerDownState = Readonly<{
         wasAddedToSelection: boolean;
         hasBeenDuplicated: boolean;
         hasHitCommonBoundingBoxOfSelectedElements: boolean;
+        hasHitElementInside: boolean;
     };
     withCmdOrCtrl: boolean;
     drag: {
@@ -305,6 +306,9 @@ export declare type PointerDownState = Readonly<{
         onKeyDown: null | ((event: KeyboardEvent) => void);
         onKeyUp: null | ((event: KeyboardEvent) => void);
     };
+    boxSelection: {
+        hasOccurred: boolean;
+    };
 }>;
 export declare type ExcalidrawImperativeAPI = {
     updateScene: InstanceType<typeof App>["updateScene"];

package/types/utils.d.ts

@@ -14,11 +14,6 @@ export declare const getFontString: ({ fontSize, fontFamily, }: {
     fontSize: number;
     fontFamily: FontFamilyValues;
 }) => FontString;
-export declare const measureText: (text: string, font: FontString) => {
-    width: number;
-    height: number;
-    baseline: number;
-};
 export declare const debounce: <T extends any[]>(fn: (...args: T) => void, timeout: number) => {
     (...args: T): void;
     flush(): void;