@zsviczian/excalidraw 0.13.0-obsidian-1 → 0.14.0-obsidian

package/types/element/linearElementEditor.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="react" />
-import { NonDeleted, ExcalidrawLinearElement, ExcalidrawElement, PointBinding, ExcalidrawBindableElement } from "./types";
-import { Point, AppState } from "../types";
+import { NonDeleted, ExcalidrawLinearElement, ExcalidrawElement, PointBinding, ExcalidrawBindableElement, ExcalidrawTextElementWithContainer } from "./types";
+import { Point, AppState, PointerCoords } from "../types";
 import History from "../history";
 import Scene from "../scene/Scene";
 declare const editorMidPointsCache: {
@@ -18,6 +18,15 @@ export declare class LinearElementEditor {
         prevSelectedPointsIndices: readonly number[] | null;
         /** index */
         lastClickedPoint: number;
+        origin: Readonly<{
+            x: number;
+            y: number;
+        }> | null;
+        segmentMidpoint: {
+            value: Point | null;
+            index: number | null;
+            added: boolean;
+        };
     }>;
     /** whether you're dragging a point */
     readonly isDragging: boolean;
@@ -60,7 +69,6 @@ export declare class LinearElementEditor {
         didAddPoint: boolean;
         hitElement: NonDeleted<ExcalidrawElement> | null;
         linearElementEditor: LinearElementEditor | null;
-        isMidPoint: boolean;
     };
     static arePointsEqual(point1: Point | null, point2: Point | null): boolean;
     static handlePointerMove(event: React.PointerEvent<HTMLCanvasElement>, scenePointerX: number, scenePointerY: number, appState: AppState): LinearElementEditor | null;
@@ -94,6 +102,15 @@ export declare class LinearElementEditor {
                     prevSelectedPointsIndices: readonly number[] | null;
                     /** index */
                     lastClickedPoint: number;
+                    origin: Readonly<{
+                        x: number;
+                        y: number;
+                    }> | null;
+                    segmentMidpoint: {
+                        value: readonly [number, number] | null;
+                        index: number | null;
+                        added: boolean;
+                    };
                 }>;
                 isDragging: boolean;
                 lastUncommittedPoint: readonly [number, number] | null;
@@ -106,6 +123,11 @@ export declare class LinearElementEditor {
                 hoverPointIndex: number;
                 segmentMidPointHoveredCoords: readonly [number, number] | null;
             };
+            contextMenu: {
+                items: import("../components/ContextMenu").ContextMenuItems;
+                top: number;
+                left: number;
+            } | null;
             showWelcomeScreen: boolean;
             isLoading: boolean;
             errorMessage: string | null;
@@ -144,10 +166,9 @@ export declare class LinearElementEditor {
             currentItemFontFamily: number;
             currentItemFontSize: number;
             currentItemTextAlign: string;
-            currentItemStrokeSharpness: import("./types").StrokeSharpness;
             currentItemStartArrowhead: import("./types").Arrowhead | null;
             currentItemEndArrowhead: import("./types").Arrowhead | null;
-            currentItemLinearStrokeSharpness: import("./types").StrokeSharpness;
+            currentItemRoundness: import("./types").StrokeRoundness;
             viewBackgroundColor: string;
             scrollX: number;
             scrollY: number;
@@ -162,7 +183,7 @@ export declare class LinearElementEditor {
             openMenu: "canvas" | "shape" | null;
             openPopup: "canvasColorPicker" | "backgroundColorPicker" | "strokeColorPicker" | null;
             openSidebar: "library" | "customSidebar" | null;
-            openDialog: "imageExport" | "help" | null;
+            openDialog: "imageExport" | "help" | "jsonExport" | null;
             isSidebarDocked: boolean;
             lastPointerDownWith: import("./types").PointerType;
             selectedElementIds: {
@@ -224,7 +245,18 @@ export declare class LinearElementEditor {
         startBinding?: PointBinding;
         endBinding?: PointBinding;
     }): void;
+    static shouldAddMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, appState: AppState): boolean;
+    static addMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, appState: AppState): {
+        pointerDownState: LinearElementEditor["pointerDownState"];
+        selectedPointsIndices: LinearElementEditor["selectedPointsIndices"];
+    } | undefined;
     private static _updatePoints;
     private static _getShiftLockedDelta;
+    static getBoundTextElementPosition: (element: ExcalidrawLinearElement, boundTextElement: ExcalidrawTextElementWithContainer) => {
+        x: number;
+        y: number;
+    };
+    static getMinMaxXYWithBoundText: (element: ExcalidrawLinearElement, elementBounds: [number, number, number, number], boundTextElement: ExcalidrawTextElementWithContainer) => [number, number, number, number, number, number];
+    static getElementAbsoluteCoords: (element: ExcalidrawLinearElement, includeBoundText?: boolean) => [number, number, number, number, number, number];
 }
 export {};

package/types/element/newElement.d.ts

@@ -1,4 +1,4 @@
-import { ExcalidrawElement, ExcalidrawImageElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawGenericElement, NonDeleted, TextAlign, GroupId, VerticalAlign, Arrowhead, ExcalidrawFreeDrawElement, FontFamilyValues, ExcalidrawRectangleElement } from "../element/types";
+import { ExcalidrawElement, ExcalidrawImageElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawGenericElement, NonDeleted, TextAlign, GroupId, VerticalAlign, Arrowhead, ExcalidrawFreeDrawElement, FontFamilyValues, ExcalidrawTextContainer } from "../element/types";
 import { AppState } from "../types";
 declare type ElementConstructorOpts = MarkOptional<Omit<ExcalidrawGenericElement, "id" | "type" | "isDeleted" | "updated">, "width" | "height" | "angle" | "groupIds" | "boundElements" | "seed" | "version" | "versionNonce" | "link">;
 export declare const newElement: (opts: {
@@ -11,7 +11,7 @@ export declare const newTextElement: (opts: {
     fontFamily: FontFamilyValues;
     textAlign: TextAlign;
     verticalAlign: VerticalAlign;
-    containerId?: ExcalidrawRectangleElement["id"];
+    containerId?: ExcalidrawTextContainer["id"];
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawTextElement>;
 export declare const refreshTextDimensions: (textElement: ExcalidrawTextElement, text?: string) => {
     x: number;

package/types/element/resizeElements.d.ts

@@ -3,7 +3,6 @@ import { MaybeTransformHandleType, TransformHandleDirection } from "./transformH
 import { PointerDownState } from "../types";
 export declare const normalizeAngle: (angle: number) => number;
 export declare const transformElements: (pointerDownState: PointerDownState, transformHandleType: MaybeTransformHandleType, selectedElements: readonly NonDeletedExcalidrawElement[], resizeArrowDirection: "origin" | "end", shouldRotateWithDiscreteAngle: boolean, shouldResizeFromCenter: boolean, shouldMaintainAspectRatio: boolean, pointerX: number, pointerY: number, centerX: number, centerY: number) => boolean;
-export declare const reshapeSingleTwoPointElement: (element: NonDeleted<ExcalidrawLinearElement>, resizeArrowDirection: "origin" | "end", shouldRotateWithDiscreteAngle: boolean, pointerX: number, pointerY: number) => void;
 export declare const resizeSingleElement: (originalElements: PointerDownState["originalElements"], shouldMaintainAspectRatio: boolean, element: NonDeletedExcalidrawElement, transformHandleDirection: TransformHandleDirection, shouldResizeFromCenter: boolean, pointerX: number, pointerY: number) => void;
 export declare const getResizeOffsetXY: (transformHandleType: MaybeTransformHandleType, selectedElements: NonDeletedExcalidrawElement[], x: number, y: number) => [number, number];
 export declare const getResizeArrowDirection: (transformHandleType: MaybeTransformHandleType, element: NonDeleted<ExcalidrawLinearElement>) => "origin" | "end";

package/types/element/textElement.d.ts

@@ -1,14 +1,23 @@
-import { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawTextElementWithContainer, FontString, NonDeletedExcalidrawElement } from "./types";
+import { ExcalidrawElement, ExcalidrawTextContainer, ExcalidrawTextElement, ExcalidrawTextElementWithContainer, FontString, NonDeletedExcalidrawElement } from "./types";
 import { MaybeTransformHandleType } from "./transformHandles";
+import { AppState } from "../types";
+export declare const normalizeText: (text: string) => string;
 export declare const redrawTextBoundingBox: (textElement: ExcalidrawTextElement, container: ExcalidrawElement | null) => void;
 export declare const bindTextToShapeAfterDuplication: (sceneElements: ExcalidrawElement[], oldElements: ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
-export declare const handleBindTextResize: (element: NonDeletedExcalidrawElement, transformHandleType: MaybeTransformHandleType) => void;
+export declare const handleBindTextResize: (container: NonDeletedExcalidrawElement, transformHandleType: MaybeTransformHandleType) => void;
 export declare const measureText: (text: string, font: FontString, maxWidth?: number | null) => {
     width: number;
     height: number;
     baseline: number;
+    container: HTMLDivElement;
+} | {
+    width: number;
+    height: number;
+    baseline: number;
+    container?: undefined;
 };
 export declare const getApproxLineHeight: (font: FontString) => number;
+export declare const getTextWidth: (text: string, font: FontString) => number;
 export declare const wrapText: (text: string, font: FontString, maxWidth: number) => string;
 export declare const charWidth: {
     calculate: (char: string, font: FontString) => number;
@@ -28,3 +37,16 @@ export declare const getContainerDims: (element: ExcalidrawElement) => {
     width: number;
     height: number;
 };
+export declare const getContainerCenter: (container: ExcalidrawElement, appState: AppState) => {
+    x: number;
+    y: number;
+};
+export declare const getTextElementAngle: (textElement: ExcalidrawTextElement) => number;
+export declare const getBoundTextElementOffset: (boundTextElement: ExcalidrawTextElement | null) => number;
+export declare const getBoundTextElementPosition: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElementWithContainer) => {
+    x: number;
+    y: number;
+} | undefined;
+export declare const shouldAllowVerticalAlign: (selectedElements: NonDeletedExcalidrawElement[]) => boolean;
+export declare const getTextBindableContainerAtPosition: (elements: readonly ExcalidrawElement[], appState: AppState, x: number, y: number) => ExcalidrawTextContainer | null;
+export declare const isValidTextContainer: (element: ExcalidrawElement) => boolean;

package/types/element/textWysiwyg.d.ts

@@ -1,5 +1,10 @@
-import { ExcalidrawElement, ExcalidrawTextElement } from "./types";
+import { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawTextContainer } from "./types";
 import App from "../components/App";
+export declare const updateOriginalContainerCache: (id: ExcalidrawTextContainer["id"], height: ExcalidrawTextContainer["height"]) => {
+    height: ExcalidrawTextContainer["height"];
+};
+export declare const resetOriginalContainerCache: (id: ExcalidrawTextContainer["id"]) => void;
+export declare const getOriginalContainerHeightFromCache: (id: ExcalidrawTextContainer["id"]) => number | null;
 export declare const textWysiwyg: ({ id, onChange, onSubmit, getViewportCoords, element, canvas, excalidrawContainer, app, }: {
     id: ExcalidrawElement["id"];
     onChange?: ((text: string) => void) | undefined;

package/types/element/transformHandles.d.ts

@@ -1,5 +1,4 @@
 import { ExcalidrawElement, NonDeletedExcalidrawElement, PointerType } from "./types";
-import { Bounds } from "./bounds";
 import { AppState, Zoom } from "../types";
 export declare type TransformHandleDirection = "n" | "s" | "w" | "e" | "nw" | "ne" | "sw" | "se";
 export declare type TransformHandleType = TransformHandleDirection | "rotation";
@@ -14,11 +13,11 @@ export declare const OMIT_SIDES_FOR_MULTIPLE_ELEMENTS: {
     n: boolean;
     w: boolean;
 };
-export declare const getTransformHandlesFromCoords: ([x1, y1, x2, y2]: Bounds, angle: number, zoom: Zoom, pointerType: PointerType, omitSides?: {
+export declare const getTransformHandlesFromCoords: ([x1, y1, x2, y2, cx, cy]: [number, number, number, number, number, number], angle: number, zoom: Zoom, pointerType: PointerType, omitSides?: {
     s?: boolean | undefined;
     e?: boolean | undefined;
-    w?: boolean | undefined;
     n?: boolean | undefined;
+    w?: boolean | undefined;
     nw?: boolean | undefined;
     ne?: boolean | undefined;
     sw?: boolean | undefined;

package/types/element/typeChecks.d.ts

@@ -1,5 +1,5 @@
 import { AppState } from "../types";
-import { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawBindableElement, ExcalidrawGenericElement, ExcalidrawFreeDrawElement, InitializedExcalidrawImageElement, ExcalidrawImageElement, ExcalidrawTextElementWithContainer, ExcalidrawTextContainer } from "./types";
+import { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawBindableElement, ExcalidrawGenericElement, ExcalidrawFreeDrawElement, InitializedExcalidrawImageElement, ExcalidrawImageElement, ExcalidrawTextElementWithContainer, ExcalidrawTextContainer, RoundnessType } 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;
@@ -7,6 +7,7 @@ export declare const isTextElement: (element: ExcalidrawElement | null) => eleme
 export declare const isFreeDrawElement: (element?: ExcalidrawElement | null) => element is ExcalidrawFreeDrawElement;
 export declare const isFreeDrawElementType: (elementType: ExcalidrawElement["type"]) => boolean;
 export declare const isLinearElement: (element?: ExcalidrawElement | null) => element is ExcalidrawLinearElement;
+export declare const isArrowElement: (element?: ExcalidrawElement | null) => element is ExcalidrawLinearElement;
 export declare const isLinearElementType: (elementType: AppState["activeTool"]["type"]) => boolean;
 export declare const isBindingElement: (element?: ExcalidrawElement | null, includeLocked?: boolean) => element is ExcalidrawLinearElement;
 export declare const isBindingElementType: (elementType: AppState["activeTool"]["type"]) => boolean;
@@ -15,3 +16,11 @@ export declare const isTextBindableContainer: (element: ExcalidrawElement | null
 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;
+export declare const isUsingAdaptiveRadius: (type: string) => boolean;
+export declare const isUsingProportionalRadius: (type: string) => boolean;
+export declare const canApplyRoundnessTypeToElement: (roundnessType: RoundnessType, element: ExcalidrawElement) => boolean;
+export declare const getDefaultRoundnessTypeForElement: (element: ExcalidrawElement) => {
+    type: 2;
+} | {
+    type: 3;
+} | null;

package/types/element/types.d.ts

@@ -1,5 +1,5 @@
 import { Point } from "../types";
-import { FONT_FAMILY, TEXT_ALIGN, THEME, VERTICAL_ALIGN } from "../constants";
+import { FONT_FAMILY, ROUNDNESS, TEXT_ALIGN, THEME, VERTICAL_ALIGN } from "../constants";
 export declare type ChartType = "bar" | "line";
 export declare type FillStyle = "hachure" | "cross-hatch" | "solid";
 export declare type FontFamilyKeys = keyof typeof FONT_FAMILY;
@@ -10,7 +10,8 @@ export declare type FontString = string & {
 };
 export declare type GroupId = string;
 export declare type PointerType = "mouse" | "pen" | "touch";
-export declare type StrokeSharpness = "round" | "sharp";
+export declare type StrokeRoundness = "round" | "sharp";
+export declare type RoundnessType = ValueOf<typeof ROUNDNESS>;
 export declare type StrokeStyle = "solid" | "dashed" | "dotted";
 export declare type TextAlign = typeof TEXT_ALIGN[keyof typeof TEXT_ALIGN];
 declare type VerticalAlignKeys = keyof typeof VERTICAL_ALIGN;
@@ -24,7 +25,10 @@ declare type _ExcalidrawElementBase = Readonly<{
     fillStyle: FillStyle;
     strokeWidth: number;
     strokeStyle: StrokeStyle;
-    strokeSharpness: StrokeSharpness;
+    roundness: null | {
+        type: RoundnessType;
+        value?: number;
+    };
     roughness: number;
     opacity: number;
     width: number;
@@ -103,7 +107,7 @@ export declare type ExcalidrawTextElement = _ExcalidrawElementBase & Readonly<{
     originalText: string;
 }>;
 export declare type ExcalidrawBindableElement = ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawEllipseElement | ExcalidrawTextElement | ExcalidrawImageElement;
-export declare type ExcalidrawTextContainer = ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawEllipseElement | ExcalidrawImageElement;
+export declare type ExcalidrawTextContainer = ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawEllipseElement | ExcalidrawImageElement | ExcalidrawArrowElement;
 export declare type ExcalidrawTextElementWithContainer = {
     containerId: ExcalidrawTextContainer["id"];
 } & ExcalidrawTextElement;
@@ -122,6 +126,9 @@ export declare type ExcalidrawLinearElement = _ExcalidrawElementBase & Readonly<
     startArrowhead: Arrowhead | null;
     endArrowhead: Arrowhead | null;
 }>;
+export declare type ExcalidrawArrowElement = ExcalidrawLinearElement & Readonly<{
+    type: "arrow";
+}>;
 export declare type ExcalidrawFreeDrawElement = _ExcalidrawElementBase & Readonly<{
     type: "freedraw";
     points: readonly Point[];

package/types/excalidraw-app/data/index.d.ts

@@ -91,13 +91,11 @@ export declare const loadScene: (id: string | null, privateKey: string | null, l
             lastActiveToolBeforeEraser: import("../../types").LastActiveToolBeforeEraser;
             locked: boolean;
         };
-        scrollX: number;
-        scrollY: number;
-        viewBackgroundColor: string;
-        zoom: Readonly<{
-            value: import("../../types").NormalizedZoomValue;
-        }>;
-        shouldCacheIgnoreZoom: boolean;
+        contextMenu: {
+            items: import("../../components/ContextMenu").ContextMenuItems;
+            top: number;
+            left: number;
+        } | null;
         showWelcomeScreen: boolean;
         isLoading: boolean;
         errorMessage: string | null;
@@ -126,14 +124,19 @@ export declare const loadScene: (id: string | null, privateKey: string | null, l
         currentItemFontFamily: number;
         currentItemFontSize: number;
         currentItemTextAlign: string;
-        currentItemStrokeSharpness: import("../../element/types").StrokeSharpness;
         currentItemStartArrowhead: import("../../element/types").Arrowhead | null;
         currentItemEndArrowhead: import("../../element/types").Arrowhead | null;
-        currentItemLinearStrokeSharpness: import("../../element/types").StrokeSharpness;
+        currentItemRoundness: import("../../element/types").StrokeRoundness;
+        viewBackgroundColor: string;
+        scrollX: number;
+        scrollY: number;
         cursorButton: "up" | "down";
         scrolledOutside: boolean;
         isResizing: boolean;
         isRotating: boolean;
+        zoom: Readonly<{
+            value: import("../../types").NormalizedZoomValue;
+        }>;
         openMenu: "canvas" | "shape" | null;
         openPopup: "canvasColorPicker" | "backgroundColorPicker" | "strokeColorPicker" | null;
         openSidebar: "library" | "customSidebar" | null;
@@ -146,6 +149,7 @@ export declare const loadScene: (id: string | null, privateKey: string | null, l
         previousSelectedElementIds: {
             [id: string]: boolean;
         };
+        shouldCacheIgnoreZoom: boolean;
         toast: {
             message: string;
             closable?: boolean | undefined;

package/types/excalidraw-app/data/localStorage.d.ts

@@ -17,13 +17,6 @@ export declare const importFromLocalStorage: () => {
             lastActiveToolBeforeEraser: import("../../types").LastActiveToolBeforeEraser;
             locked: boolean;
         };
-        scrollX: number;
-        scrollY: number;
-        viewBackgroundColor: string;
-        zoom: Readonly<{
-            value: import("../../types").NormalizedZoomValue;
-        }>;
-        shouldCacheIgnoreZoom: boolean;
         showWelcomeScreen: boolean;
         penMode: boolean;
         penDetected: boolean;
@@ -41,12 +34,17 @@ export declare const importFromLocalStorage: () => {
         currentItemFontFamily: number;
         currentItemFontSize: number;
         currentItemTextAlign: string;
-        currentItemStrokeSharpness: import("../../element/types").StrokeSharpness;
         currentItemStartArrowhead: import("../../element/types").Arrowhead | null;
         currentItemEndArrowhead: import("../../element/types").Arrowhead | null;
-        currentItemLinearStrokeSharpness: import("../../element/types").StrokeSharpness;
+        currentItemRoundness: import("../../element/types").StrokeRoundness;
+        viewBackgroundColor: string;
+        scrollX: number;
+        scrollY: number;
         cursorButton: "up" | "down";
         scrolledOutside: boolean;
+        zoom: Readonly<{
+            value: import("../../types").NormalizedZoomValue;
+        }>;
         openMenu: "canvas" | "shape" | null;
         openSidebar: "library" | "customSidebar" | null;
         isSidebarDocked: boolean;
@@ -57,6 +55,7 @@ export declare const importFromLocalStorage: () => {
         previousSelectedElementIds: {
             [id: string]: boolean;
         };
+        shouldCacheIgnoreZoom: boolean;
         zenModeEnabled: boolean;
         gridSize: number | null;
         selectedGroupIds: {
@@ -66,6 +65,11 @@ export declare const importFromLocalStorage: () => {
         showStats: boolean;
         currentChartType: import("../../element/types").ChartType;
         selectedLinearElement: import("../../element/linearElementEditor").LinearElementEditor | null;
+        contextMenu: {
+            items: import("../../components/ContextMenu").ContextMenuItems;
+            top: number;
+            left: number;
+        } | null;
         isLoading: boolean;
         errorMessage: string | null;
         draggingElement: import("../../element/types").NonDeletedExcalidrawElement | null;

package/types/keys.d.ts

@@ -27,6 +27,8 @@ export declare const KEYS: {
     readonly ARROW_LEFT: "ArrowLeft";
     readonly ARROW_RIGHT: "ArrowRight";
     readonly ARROW_UP: "ArrowUp";
+    readonly PAGE_UP: "PageUp";
+    readonly PAGE_DOWN: "PageDown";
     readonly BACKSPACE: "Backspace";
     readonly ALT: "Alt";
     readonly CTRL_OR_CMD: "metaKey" | "ctrlKey";

package/types/math.d.ts

@@ -1,5 +1,5 @@
 import { Point, Zoom } from "./types";
-import { ExcalidrawLinearElement, NonDeleted } from "./element/types";
+import { ExcalidrawElement, ExcalidrawLinearElement, NonDeleted } from "./element/types";
 export declare const rotate: (x1: number, y1: number, x2: number, y2: number, angle: number) => [number, number];
 export declare const rotatePoint: (point: readonly [number, number], center: readonly [number, number], angle: number) => [number, number];
 export declare const adjustXYWithRotation: (sides: {
@@ -18,6 +18,7 @@ export declare const centerPoint: (a: readonly [number, number], b: readonly [nu
 export declare const isPathALoop: (points: ExcalidrawLinearElement["points"], zoomValue?: Zoom["value"]) => boolean;
 export declare const isPointInPolygon: (points: Point[], x: number, y: number) => boolean;
 export declare const getGridPoint: (x: number, y: number, gridSize: number | null) => [number, number];
+export declare const getCornerRadius: (x: number, element: ExcalidrawElement) => number;
 export declare const getControlPointsForBezierCurve: (element: NonDeleted<ExcalidrawLinearElement>, endPoint: readonly [number, number]) => [number, number][] | null;
 export declare const getBezierXY: (p0: readonly [number, number], p1: readonly [number, number], p2: readonly [number, number], p3: readonly [number, number], t: number) => number[];
 export declare const getPointsInBezierCurve: (element: NonDeleted<ExcalidrawLinearElement>, endPoint: readonly [number, number]) => [number, number][];

package/types/packages/excalidraw/example/CustomFooter.d.ts

@@ -0,0 +1,5 @@
+import { ExcalidrawImperativeAPI } from "../../../types";
+declare const CustomFooter: ({ excalidrawAPI, }: {
+    excalidrawAPI: ExcalidrawImperativeAPI;
+}) => JSX.Element;
+export default CustomFooter;

package/types/packages/excalidraw/example/MobileFooter.d.ts

@@ -0,0 +1,5 @@
+import { ExcalidrawImperativeAPI } from "../../../types";
+declare const MobileFooter: ({ excalidrawAPI, }: {
+    excalidrawAPI: ExcalidrawImperativeAPI;
+}) => JSX.Element | null;
+export default MobileFooter;

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

@@ -2,6 +2,10 @@ import React from "react";
 import "../../css/app.scss";
 import "../../css/styles.scss";
 import { ExcalidrawAPIRefValue, ExcalidrawProps } from "../../types";
+import Footer from "../../components/footer/FooterCenter";
+import MainMenu from "../../components/main-menu/MainMenu";
+import WelcomeScreen from "../../components/welcome-screen/WelcomeScreen";
+import LiveCollaborationTrigger from "../../components/live-collaboration/LiveCollaborationTrigger";
 declare type PublicExcalidrawProps = Omit<ExcalidrawProps, "forwardedRef">;
 export declare const Excalidraw: React.MemoExoticComponent<React.ForwardRefExoticComponent<PublicExcalidrawProps & React.RefAttributes<ExcalidrawAPIRefValue>>>;
 export { getSceneVersion, isInvisiblySmallElement, getNonDeletedElements, } from "../../element";
@@ -22,3 +26,9 @@ export { mutateElement, newElementWith, bumpVersion, } from "../../element/mutat
 export { parseLibraryTokensFromUrl, useHandleLibrary, } from "../../data/library";
 export { sceneCoordsToViewportCoords, viewportCoordsToSceneCoords, } from "../../utils";
 export { Sidebar } from "../../components/Sidebar/Sidebar";
+export { Button } from "../../components/Button";
+export { Footer };
+export { MainMenu };
+export { useDevice } from "../../components/App";
+export { WelcomeScreen };
+export { LiveCollaborationTrigger };

package/types/renderer/easingFunctions.d.ts

@@ -0,0 +1,6 @@
+declare type EasingFunction = (progress: number) => number;
+interface EasingDictionary {
+    [easing: string]: EasingFunction;
+}
+declare const easingsFunctions: EasingDictionary;
+export default easingsFunctions;

package/types/renderer/renderElement.d.ts

@@ -3,7 +3,7 @@ import { RoughCanvas } from "roughjs/bin/canvas";
 import { Drawable, Options } from "roughjs/bin/core";
 import { RoughSVG } from "roughjs/bin/svg";
 import { RenderConfig } from "../scene/types";
-import { BinaryFiles, Zoom } from "../types";
+import { AppState, BinaryFiles, Zoom } from "../types";
 export interface ExcalidrawElementWithCanvas {
     element: ExcalidrawElement | ExcalidrawTextElement;
     canvas: HTMLCanvasElement;
@@ -11,6 +11,7 @@ export interface ExcalidrawElementWithCanvas {
     canvasZoom: Zoom["value"];
     canvasOffsetX: number;
     canvasOffsetY: number;
+    boundTextElementVersion: number | null;
 }
 export declare const DEFAULT_LINK_SIZE = 14;
 declare type ElementShape = Drawable | Drawable[] | null;
@@ -25,8 +26,8 @@ export declare const getShapeForElement: <T extends ExcalidrawElement>(element:
 export declare const setShapeForElement: <T extends ExcalidrawElement>(element: T, shape: T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] : Drawable) => WeakMap<ExcalidrawElement, ElementShape>;
 export declare const invalidateShapeForElement: (element: ExcalidrawElement) => boolean;
 export declare const generateRoughOptions: (element: ExcalidrawElement, continuousPath?: boolean) => Options;
-export declare const renderElement: (element: NonDeletedExcalidrawElement, rc: RoughCanvas, context: CanvasRenderingContext2D, renderConfig: RenderConfig) => void;
-export declare const renderElementToSvg: (element: NonDeletedExcalidrawElement, rsvg: RoughSVG, svgRoot: SVGElement, files: BinaryFiles, offsetX?: number, offsetY?: number, exportWithDarkMode?: boolean) => void;
+export declare const renderElement: (element: NonDeletedExcalidrawElement, rc: RoughCanvas, context: CanvasRenderingContext2D, renderConfig: RenderConfig, appState: AppState) => void;
+export declare const renderElementToSvg: (element: NonDeletedExcalidrawElement, rsvg: RoughSVG, svgRoot: SVGElement, files: BinaryFiles, offsetX: number, offsetY: number, exportWithDarkMode?: boolean) => void;
 export declare const pathsCache: WeakMap<ExcalidrawFreeDrawElement, Path2D>;
 export declare function generateFreeDrawShape(element: ExcalidrawFreeDrawElement): Path2D;
 export declare function getFreeDrawPath2D(element: ExcalidrawFreeDrawElement): Path2D | undefined;

package/types/scene/Fonts.d.ts

@@ -0,0 +1,21 @@
+import { ExcalidrawElement } from "../element/types";
+import type Scene from "./Scene";
+export declare class Fonts {
+    private scene;
+    private onSceneUpdated;
+    constructor({ scene, onSceneUpdated, }: {
+        scene: Scene;
+        onSceneUpdated: () => void;
+    });
+    private static loadedFontFaces;
+    /**
+     * if we load a (new) font, it's likely that text elements using it have
+     * already been rendered using a fallback font. Thus, we want invalidate
+     * their shapes and rerender. See #637.
+     *
+     * Invalidates text elements and rerenders scene, provided that at least one
+     * of the supplied fontFaces has not already been processed.
+     */
+    onFontsLoaded: (fontFaces: readonly FontFace[]) => false | undefined;
+    loadFontsForElements: (elements: readonly ExcalidrawElement[]) => Promise<void>;
+}

package/types/scene/Scene.d.ts

@@ -17,9 +17,24 @@ declare class Scene {
     getNonDeletedElements(): readonly NonDeletedExcalidrawElement[];
     getElement<T extends ExcalidrawElement>(id: T["id"]): T | null;
     getNonDeletedElement(id: ExcalidrawElement["id"]): NonDeleted<ExcalidrawElement> | null;
+    /**
+     * A utility method to help with updating all scene elements, with the added
+     * performance optimization of not renewing the array if no change is made.
+     *
+     * Maps all current excalidraw elements, invoking the callback for each
+     * element. The callback should either return a new mapped element, or the
+     * original element if no changes are made. If no changes are made to any
+     * element, this results in a no-op. Otherwise, the newly mapped elements
+     * are set as the next scene's elements.
+     *
+     * @returns whether a change was made
+     */
+    mapElements(iteratee: (element: ExcalidrawElement) => ExcalidrawElement): boolean;
     replaceAllElements(nextElements: readonly ExcalidrawElement[]): void;
     informMutation(): void;
     addCallback(cb: SceneStateCallback): SceneStateCallbackRemover;
     destroy(): void;
+    insertElementAtIndex(element: ExcalidrawElement, index: number): void;
+    getElementIndex(elementId: string): number;
 }
 export default Scene;

package/types/scene/comparisons.d.ts

@@ -1,11 +1,10 @@
-import { ExcalidrawElement, ExcalidrawTextContainer, NonDeletedExcalidrawElement } from "../element/types";
+import { NonDeletedExcalidrawElement } from "../element/types";
 export declare const hasBackground: (type: string) => boolean;
 export declare const hasStrokeColor: (type: string) => boolean;
 export declare const hasStrokeWidth: (type: string) => boolean;
 export declare const hasStrokeStyle: (type: string) => boolean;
-export declare const canChangeSharpness: (type: string) => boolean;
+export declare const canChangeRoundness: (type: string) => boolean;
 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 getTextBindableContainerAtPosition: (elements: readonly ExcalidrawElement[], x: number, y: number) => ExcalidrawTextContainer | null;

package/types/scene/index.d.ts

@@ -1,5 +1,5 @@
 export { isOverScrollBars } from "./scrollbars";
 export { isSomeElementSelected, getElementsWithinSelection, getCommonAttributeOfSelectedElements, getSelectedElements, getTargetElements, } from "./selection";
 export { calculateScrollCenter } from "./scroll";
-export { hasBackground, hasStrokeWidth, hasStrokeStyle, canHaveArrowheads, canChangeSharpness, getElementAtPosition, getTextBindableContainerAtPosition, hasText, getElementsAtPosition, } from "./comparisons";
+export { hasBackground, hasStrokeWidth, hasStrokeStyle, canHaveArrowheads, canChangeRoundness, getElementAtPosition, hasText, getElementsAtPosition, } from "./comparisons";
 export { getNormalizedZoom } from "./zoom";