@excalidraw/excalidraw 0.3.0 → 0.3.78-nocustom

package/types/distribute.d.ts

@@ -0,0 +1,6 @@
+import { ExcalidrawElement } from "./element/types";
+export interface Distribution {
+    space: "between";
+    axis: "x" | "y";
+}
+export declare const distributeElements: (selectedElements: ExcalidrawElement[], distribution: Distribution) => ExcalidrawElement[];

package/types/element/Hyperlink.d.ts

@@ -0,0 +1,135 @@
+/// <reference types="react" />
+import { AppState, ExcalidrawProps } from "../types";
+import { NonDeletedExcalidrawElement } from "./types";
+import { Bounds } from "./bounds";
+import "./Hyperlink.scss";
+export declare const EXTERNAL_LINK_IMG: HTMLImageElement;
+export declare const Hyperlink: ({ element, appState, setAppState, onLinkOpen, }: {
+    element: NonDeletedExcalidrawElement;
+    appState: AppState;
+    setAppState: React.Component<any, AppState>["setState"];
+    onLinkOpen: ExcalidrawProps["onLinkOpen"];
+}) => JSX.Element | null;
+export declare const normalizeLink: (link: string) => string;
+export declare const isLocalLink: (link: string | null) => boolean;
+export declare const actionLink: {
+    name: "hyperlink";
+    perform: (elements: readonly import("./types").ExcalidrawElement[], appState: Readonly<AppState>) => false | {
+        elements: readonly import("./types").ExcalidrawElement[];
+        appState: {
+            showHyperlinkPopup: "editor";
+            openMenu: null;
+            isLoading: boolean;
+            errorMessage: string | null;
+            draggingElement: NonDeletedExcalidrawElement | null;
+            resizingElement: NonDeletedExcalidrawElement | null;
+            multiElement: import("./types").NonDeleted<import("./types").ExcalidrawLinearElement> | null;
+            selectionElement: NonDeletedExcalidrawElement | null;
+            isBindingEnabled: boolean;
+            startBoundElement: import("./types").NonDeleted<import("./types").ExcalidrawBindableElement> | null;
+            suggestedBindings: import("./binding").SuggestedBinding[];
+            editingElement: NonDeletedExcalidrawElement | null;
+            editingLinearElement: import("./linearElementEditor").LinearElementEditor | null;
+            activeTool: {
+                type: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "freedraw" | "eraser";
+                lastActiveToolBeforeEraser: import("../types").LastActiveToolBeforeEraser;
+                locked: boolean;
+                customType: null;
+            } | {
+                type: "custom";
+                customType: string;
+                lastActiveToolBeforeEraser: import("../types").LastActiveToolBeforeEraser;
+                locked: boolean;
+            };
+            penMode: boolean;
+            penDetected: 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;
+            }>;
+            openPopup: "canvasColorPicker" | "backgroundColorPicker" | "strokeColorPicker" | null;
+            lastPointerDownWith: import("./types").PointerType;
+            selectedElementIds: {
+                [id: string]: boolean;
+            };
+            previousSelectedElementIds: {
+                [id: string]: boolean;
+            };
+            shouldCacheIgnoreZoom: boolean;
+            showHelpDialog: boolean;
+            toast: {
+                message: string;
+                closable?: boolean | undefined;
+                duration?: number | undefined;
+            } | 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;
+            isLibraryMenuDocked: 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;
+            };
+            pendingImageElementId: string | null;
+        };
+        commitToHistory: true;
+    };
+    trackEvent: {
+        category: "hyperlink";
+        action: string;
+    };
+    keyTest: (event: KeyboardEvent | import("react").KeyboardEvent<Element>) => boolean;
+    contextItemLabel: (elements: readonly import("./types").ExcalidrawElement[], appState: Readonly<AppState>) => "labels.link.edit" | "labels.link.create";
+    contextItemPredicate: (elements: readonly import("./types").ExcalidrawElement[], appState: AppState) => boolean;
+    PanelComponent: ({ elements, appState, updateData }: import("react").PropsWithChildren<import("../actions/types").PanelComponentProps>) => JSX.Element;
+} & {
+    keyTest?: ((event: KeyboardEvent | import("react").KeyboardEvent<Element>) => boolean) | undefined;
+};
+export declare const getContextMenuLabel: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState) => "labels.link.edit" | "labels.link.create";
+export declare const getLinkHandleFromCoords: ([x1, y1, x2, y2]: Bounds, angle: number, appState: AppState) => [x: number, y: number, width: number, height: number];
+export declare const isPointHittingLinkIcon: (element: NonDeletedExcalidrawElement, appState: AppState, [x, y]: readonly [number, number], isMobile: boolean) => boolean;
+export declare const showHyperlinkTooltip: (element: NonDeletedExcalidrawElement, appState: AppState) => void;
+export declare const hideHyperlinkToolip: () => void;
+export declare const shouldHideLinkPopup: (element: NonDeletedExcalidrawElement, appState: AppState, [clientX, clientY]: readonly [number, number]) => Boolean;

package/types/element/binding.d.ts

@@ -0,0 +1,33 @@
+import { ExcalidrawLinearElement, ExcalidrawBindableElement, NonDeleted, NonDeletedExcalidrawElement, ExcalidrawElement } from "./types";
+import { AppState } from "../types";
+import Scene from "../scene/Scene";
+export declare type SuggestedBinding = NonDeleted<ExcalidrawBindableElement> | SuggestedPointBinding;
+export declare type SuggestedPointBinding = [
+    NonDeleted<ExcalidrawLinearElement>,
+    "start" | "end" | "both",
+    NonDeleted<ExcalidrawBindableElement>
+];
+export declare const shouldEnableBindingForPointerEvent: (event: React.PointerEvent<HTMLCanvasElement>) => boolean;
+export declare const isBindingEnabled: (appState: AppState) => boolean;
+export declare const bindOrUnbindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, startBindingElement: ExcalidrawBindableElement | null | "keep", endBindingElement: ExcalidrawBindableElement | null | "keep") => void;
+export declare const bindOrUnbindSelectedElements: (elements: NonDeleted<ExcalidrawElement>[]) => void;
+export declare const maybeBindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, appState: AppState, scene: Scene, pointerCoords: {
+    x: number;
+    y: number;
+}) => void;
+export declare const isLinearElementSimpleAndAlreadyBound: (linearElement: NonDeleted<ExcalidrawLinearElement>, alreadyBoundToId: ExcalidrawBindableElement["id"] | undefined, bindableElement: ExcalidrawBindableElement) => boolean;
+export declare const unbindLinearElements: (elements: NonDeleted<ExcalidrawElement>[]) => void;
+export declare const getHoveredElementForBinding: (pointerCoords: {
+    x: number;
+    y: number;
+}, scene: Scene) => NonDeleted<ExcalidrawBindableElement> | null;
+export declare const updateBoundElements: (changedElement: NonDeletedExcalidrawElement, options?: {
+    simultaneouslyUpdated?: readonly ExcalidrawElement[];
+    newSize?: {
+        width: number;
+        height: number;
+    };
+}) => void;
+export declare const getEligibleElementsForBinding: (elements: NonDeleted<ExcalidrawElement>[]) => SuggestedBinding[];
+export declare const fixBindingsAfterDuplication: (sceneElements: readonly ExcalidrawElement[], oldElements: readonly ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>, duplicatesServeAsOld?: "duplicatesServeAsOld" | undefined) => void;
+export declare const fixBindingsAfterDeletion: (sceneElements: readonly ExcalidrawElement[], deletedElements: readonly ExcalidrawElement[]) => void;

package/types/element/bounds.d.ts

@@ -0,0 +1,27 @@
+import { ExcalidrawElement, ExcalidrawLinearElement, Arrowhead, NonDeleted } from "./types";
+import { Drawable, Op } from "roughjs/bin/core";
+export declare type Bounds = readonly [number, number, number, number];
+export declare const getElementAbsoluteCoords: (element: ExcalidrawElement) => Bounds;
+export declare const pointRelativeTo: (element: ExcalidrawElement, absoluteCoords: readonly [number, number]) => readonly [number, number];
+export declare const getDiamondPoints: (element: ExcalidrawElement) => number[];
+export declare const getCurvePathOps: (shape: Drawable) => Op[];
+export declare const getArrowheadPoints: (element: ExcalidrawLinearElement, shape: Drawable[], position: "start" | "end", arrowhead: Arrowhead) => number[] | null;
+export declare const getElementBounds: (element: ExcalidrawElement) => [number, number, number, number];
+export declare const getCommonBounds: (elements: readonly ExcalidrawElement[]) => [number, number, number, number];
+export declare const getResizedElementAbsoluteCoords: (element: ExcalidrawElement, nextWidth: number, nextHeight: number) => [number, number, number, number];
+export declare const getElementPointsCoords: (element: ExcalidrawLinearElement, points: readonly (readonly [number, number])[], sharpness: ExcalidrawElement["strokeSharpness"]) => [number, number, number, number];
+export declare const getClosestElementBounds: (elements: readonly ExcalidrawElement[], from: {
+    x: number;
+    y: number;
+}) => [number, number, number, number];
+export interface Box {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    midX: number;
+    midY: number;
+    width: number;
+    height: number;
+}
+export declare const getCommonBoundingBox: (elements: ExcalidrawElement[] | readonly NonDeleted<ExcalidrawElement>[]) => Box;

package/types/element/collision.d.ts

@@ -0,0 +1,21 @@
+import * as GA from "../ga";
+import { NonDeletedExcalidrawElement, ExcalidrawBindableElement, ExcalidrawElement, ExcalidrawRectangleElement, ExcalidrawDiamondElement, ExcalidrawTextElement, ExcalidrawEllipseElement, NonDeleted, ExcalidrawImageElement } from "./types";
+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 isPointHittingElementBoundingBox: (element: NonDeleted<ExcalidrawElement>, [x, y]: readonly [number, number], threshold: number) => boolean;
+export declare const bindingBorderTest: (element: NonDeleted<ExcalidrawBindableElement>, { x, y }: {
+    x: number;
+    y: number;
+}) => boolean;
+export declare const maxBindingGap: (element: ExcalidrawElement, elementWidth: number, elementHeight: number) => number;
+export declare const distanceToBindableElement: (element: ExcalidrawBindableElement, point: readonly [number, number]) => number;
+export declare const pointInAbsoluteCoords: (element: ExcalidrawElement, point: readonly [number, number]) => readonly [number, number];
+export declare const determineFocusDistance: (element: ExcalidrawBindableElement, a: readonly [number, number], b: readonly [number, number]) => number;
+export declare const determineFocusPoint: (element: ExcalidrawBindableElement, focus: number, adjecentPoint: readonly [number, number]) => readonly [number, number];
+export declare const intersectElementWithLine: (element: ExcalidrawBindableElement, a: readonly [number, number], b: readonly [number, number], gap?: number) => Point[];
+export declare const getCircleIntersections: (center: readonly [number, number, number, number, number, number, number, number], radius: number, line: readonly [number, number, number, number, number, number, number, number]) => GA.Point[];
+export declare const findFocusPointForEllipse: (ellipse: ExcalidrawEllipseElement, relativeDistance: number, point: readonly [number, number, number, number, number, number, number, number]) => readonly [number, number, number, number, number, number, number, number];
+export declare const findFocusPointForRectangulars: (element: ExcalidrawRectangleElement | ExcalidrawImageElement | ExcalidrawDiamondElement | ExcalidrawTextElement, relativeDistance: number, point: readonly [number, number, number, number, number, number, number, number]) => readonly [number, number, number, number, number, number, number, number];

package/types/element/dragElements.d.ts

@@ -0,0 +1,5 @@
+import { NonDeletedExcalidrawElement } from "./types";
+import { AppState, PointerDownState } from "../types";
+export declare const dragSelectedElements: (pointerDownState: PointerDownState, selectedElements: NonDeletedExcalidrawElement[], pointerX: number, pointerY: number, lockDirection: boolean | undefined, distanceX: number | undefined, distanceY: number | undefined, appState: AppState) => void;
+export declare const getDragOffsetXY: (selectedElements: NonDeletedExcalidrawElement[], x: number, y: number) => [number, number];
+export declare const dragNewElement: (draggingElement: NonDeletedExcalidrawElement, elementType: AppState["activeTool"]["type"], originX: number, originY: number, x: number, y: number, width: number, height: number, shouldMaintainAspectRatio: boolean, shouldResizeFromCenter: boolean, widthAspectRatio?: number | null) => void;

package/types/element/image.d.ts

@@ -0,0 +1,22 @@
+import { AppClassProperties, DataURL, BinaryFiles } from "../types";
+import { ExcalidrawElement, FileId, InitializedExcalidrawImageElement } from "./types";
+export declare const loadHTMLImageElement: (dataURL: DataURL) => Promise<HTMLImageElement>;
+/** NOTE: updates cache even if already populated with given image. Thus,
+ * you should filter out the images upstream if you want to optimize this. */
+export declare const updateImageCache: ({ fileIds, files, imageCache, }: {
+    fileIds: FileId[];
+    files: BinaryFiles;
+    imageCache: AppClassProperties["imageCache"];
+}) => Promise<{
+    imageCache: Map<FileId, {
+        image: HTMLImageElement | Promise<HTMLImageElement>;
+        mimeType: "image/svg+xml" | "image/png" | "image/jpeg" | "image/gif";
+    }>;
+    /** includes errored files because they cache was updated nonetheless */
+    updatedFiles: Map<FileId, true>;
+    /** files that failed when creating HTMLImageElement */
+    erroredFiles: Map<FileId, true>;
+}>;
+export declare const getInitializedImageElements: (elements: readonly ExcalidrawElement[]) => InitializedExcalidrawImageElement[];
+export declare const isHTMLSVGElement: (node: Node | null) => node is SVGElement;
+export declare const normalizeSVG: (SVGString: string) => Promise<string>;

package/types/element/index.d.ts

@@ -0,0 +1,20 @@
+import { ExcalidrawElement, NonDeletedExcalidrawElement, NonDeleted } from "./types";
+export { newElement, newTextElement, updateTextElement, newLinearElement, newImageElement, duplicateElement, } from "./newElement";
+export { getElementAbsoluteCoords, getElementBounds, getCommonBounds, getDiamondPoints, getArrowheadPoints, getClosestElementBounds, } from "./bounds";
+export { OMIT_SIDES_FOR_MULTIPLE_ELEMENTS, getTransformHandlesFromCoords, getTransformHandles, } from "./transformHandles";
+export { hitTest, isHittingElementBoundingBoxWithoutHittingElement, } from "./collision";
+export { resizeTest, getCursorForResizingElement, getElementWithTransformHandleType, getTransformHandleTypeFromCoords, } from "./resizeTest";
+export { transformElements, getResizeOffsetXY, getResizeArrowDirection, } from "./resizeElements";
+export { dragSelectedElements, getDragOffsetXY, dragNewElement, } from "./dragElements";
+export { isTextElement, isExcalidrawElement } from "./typeChecks";
+export { textWysiwyg } from "./textWysiwyg";
+export { redrawTextBoundingBox } from "./textElement";
+export { getPerfectElementSize, isInvisiblySmallElement, resizePerfectLineForNWHandler, getNormalizedDimensions, } from "./sizeHelpers";
+export { showSelectedShapeActions } from "./showSelectedShapeActions";
+export declare const getSceneVersion: (elements: readonly ExcalidrawElement[]) => number;
+export declare const getVisibleElements: (elements: readonly ExcalidrawElement[]) => readonly NonDeletedExcalidrawElement[];
+export declare const getNonDeletedElements: (elements: readonly ExcalidrawElement[]) => readonly NonDeletedExcalidrawElement[];
+export declare const isNonDeletedElement: <T extends ExcalidrawElement>(element: T) => element is NonDeleted<T>;
+export declare const clearElementsForDatabase: (elements: readonly ExcalidrawElement[]) => ExcalidrawElement[];
+export declare const clearElementsForExport: (elements: readonly ExcalidrawElement[]) => ExcalidrawElement[];
+export declare const clearElementsForLocalStorage: (elements: readonly ExcalidrawElement[]) => ExcalidrawElement[];

package/types/element/linearElementEditor.d.ts

@@ -0,0 +1,199 @@
+/// <reference types="react" />
+import { NonDeleted, ExcalidrawLinearElement, ExcalidrawElement, PointBinding, ExcalidrawBindableElement } from "./types";
+import { Point, AppState } from "../types";
+import History from "../history";
+import Scene from "../scene/Scene";
+export declare class LinearElementEditor {
+    elementId: ExcalidrawElement["id"] & {
+        _brand: "excalidrawLinearElementId";
+    };
+    /** 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: Readonly<{
+        x: number;
+        y: number;
+    }>;
+    startBindingElement: ExcalidrawBindableElement | null | "keep";
+    endBindingElement: ExcalidrawBindableElement | null | "keep";
+    constructor(element: NonDeleted<ExcalidrawLinearElement>, scene: Scene);
+    static POINT_HANDLE_SIZE: number;
+    /**
+     * @param id the `elementId` from the instance of this class (so that we can
+     *  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>, 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;
+        y: number;
+    }): {
+        didAddPoint: boolean;
+        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;
+    static getPointIndexUnderCursor(element: NonDeleted<ExcalidrawLinearElement>, zoom: AppState["zoom"], x: number, y: number): number;
+    static createPointAt(element: NonDeleted<ExcalidrawLinearElement>, scenePointerX: number, scenePointerY: number, gridSize: number | null): Point;
+    /**
+     * Normalizes line points so that the start point is at [0,0]. This is
+     * expected in various parts of the codebase. Also returns new x/y to account
+     * for the potential normalization.
+     */
+    static getNormalizedPoints(element: ExcalidrawLinearElement): {
+        points: (readonly [number, number])[];
+        x: number;
+        y: number;
+    };
+    static normalizePoints(element: NonDeleted<ExcalidrawLinearElement>): void;
+    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;
+            activeTool: {
+                type: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "freedraw" | "eraser";
+                lastActiveToolBeforeEraser: import("../types").LastActiveToolBeforeEraser;
+                locked: boolean;
+                customType: null;
+            } | {
+                type: "custom";
+                customType: string;
+                lastActiveToolBeforeEraser: import("../types").LastActiveToolBeforeEraser;
+                locked: boolean;
+            };
+            penMode: boolean;
+            penDetected: 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;
+            }>;
+            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;
+            toast: {
+                message: string;
+                closable?: boolean | undefined;
+                duration?: number | undefined;
+            } | 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;
+            isLibraryMenuDocked: 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;
+            };
+            pendingImageElementId: string | null;
+            showHyperlinkPopup: false | "info" | "editor";
+        };
+    };
+    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/mutateElement.d.ts

@@ -0,0 +1,11 @@
+import { ExcalidrawElement } from "./types";
+declare type ElementUpdate<TElement extends ExcalidrawElement> = Omit<Partial<TElement>, "id" | "version" | "versionNonce">;
+export declare const mutateElement: <TElement extends Mutable<ExcalidrawElement>>(element: TElement, updates: ElementUpdate<TElement>, informMutation?: boolean) => TElement;
+export declare const newElementWith: <TElement extends ExcalidrawElement>(element: TElement, updates: ElementUpdate<TElement>) => TElement;
+/**
+ * Mutates element, bumping `version`, `versionNonce`, and `updated`.
+ *
+ * NOTE: does not trigger re-render.
+ */
+export declare const bumpVersion: (element: Mutable<ExcalidrawElement>, version?: ExcalidrawElement["version"]) => Mutable<ExcalidrawElement>;
+export {};

package/types/element/newElement.d.ts

@@ -0,0 +1,50 @@
+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" | "boundElements" | "seed" | "version" | "versionNonce" | "link">;
+export declare const newElement: (opts: {
+    type: ExcalidrawGenericElement["type"];
+} & ElementConstructorOpts) => NonDeleted<ExcalidrawGenericElement>;
+export declare const newTextElement: (opts: {
+    text: string;
+    fontSize: number;
+    fontFamily: FontFamilyValues;
+    textAlign: TextAlign;
+    verticalAlign: VerticalAlign;
+    containerId?: ExcalidrawRectangleElement["id"];
+} & ElementConstructorOpts) => NonDeleted<ExcalidrawTextElement>;
+export declare const updateTextElement: (element: ExcalidrawTextElement, { text, isDeleted, originalText, }: {
+    text: string;
+    isDeleted?: boolean | undefined;
+    originalText: string;
+}) => ExcalidrawTextElement;
+export declare const newFreeDrawElement: (opts: {
+    type: "freedraw";
+    points?: ExcalidrawFreeDrawElement["points"];
+    simulatePressure: boolean;
+} & ElementConstructorOpts) => NonDeleted<ExcalidrawFreeDrawElement>;
+export declare const newLinearElement: (opts: {
+    type: ExcalidrawLinearElement["type"];
+    startArrowhead: Arrowhead | null;
+    endArrowhead: Arrowhead | null;
+    points?: ExcalidrawLinearElement["points"];
+} & ElementConstructorOpts) => NonDeleted<ExcalidrawLinearElement>;
+export declare const newImageElement: (opts: {
+    type: ExcalidrawImageElement["type"];
+} & ElementConstructorOpts) => NonDeleted<ExcalidrawImageElement>;
+export declare const deepCopyElement: (val: any, depth?: number) => any;
+/**
+ * Duplicate an element, often used in the alt-drag operation.
+ * Note that this method has gotten a bit complicated since the
+ * introduction of gruoping/ungrouping elements.
+ * @param editingGroupId The current group being edited. The new
+ *                       element will inherit this group and its
+ *                       parents.
+ * @param groupIdMapForOperation A Map that maps old group IDs to
+ *                               duplicated ones. If you are duplicating
+ *                               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 Mutable<ExcalidrawElement>>(editingGroupId: AppState["editingGroupId"], groupIdMapForOperation: Map<GroupId, GroupId>, element: TElement, overrides?: Partial<TElement> | undefined) => TElement;
+export {};

package/types/element/resizeElements.d.ts

@@ -0,0 +1,9 @@
+import { ExcalidrawLinearElement, NonDeletedExcalidrawElement, NonDeleted } from "./types";
+import { MaybeTransformHandleType, TransformHandleDirection } from "./transformHandles";
+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/resizeTest.d.ts

@@ -0,0 +1,13 @@
+import { ExcalidrawElement, PointerType, NonDeletedExcalidrawElement } from "./types";
+import { MaybeTransformHandleType } from "./transformHandles";
+import { AppState, Zoom } from "../types";
+export declare const resizeTest: (element: NonDeletedExcalidrawElement, appState: AppState, x: number, y: number, zoom: Zoom, pointerType: PointerType) => MaybeTransformHandleType;
+export declare const getElementWithTransformHandleType: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState, scenePointerX: number, scenePointerY: number, zoom: Zoom, pointerType: PointerType) => {
+    element: NonDeletedExcalidrawElement;
+    transformHandleType: MaybeTransformHandleType;
+} | null;
+export declare const getTransformHandleTypeFromCoords: ([x1, y1, x2, y2]: readonly [number, number, number, number], scenePointerX: number, scenePointerY: number, zoom: Zoom, pointerType: PointerType) => MaybeTransformHandleType;
+export declare const getCursorForResizingElement: (resizingElement: {
+    element?: ExcalidrawElement;
+    transformHandleType: MaybeTransformHandleType;
+}) => string;

package/types/element/showSelectedShapeActions.d.ts

@@ -0,0 +1,3 @@
+import { AppState } from "../types";
+import { NonDeletedExcalidrawElement } from "./types";
+export declare const showSelectedShapeActions: (appState: AppState, elements: readonly NonDeletedExcalidrawElement[]) => boolean;

package/types/element/sizeHelpers.d.ts

@@ -0,0 +1,17 @@
+import { ExcalidrawElement } from "./types";
+import { AppState } from "../types";
+export declare const isInvisiblySmallElement: (element: ExcalidrawElement) => boolean;
+/**
+ * Makes a perfect shape or diagonal/horizontal/vertical line
+ */
+export declare const getPerfectElementSize: (elementType: AppState["activeTool"]["type"], width: number, height: number) => {
+    width: number;
+    height: number;
+};
+export declare const resizePerfectLineForNWHandler: (element: ExcalidrawElement, x: number, y: number) => void;
+export declare const getNormalizedDimensions: (element: Pick<ExcalidrawElement, "width" | "height" | "x" | "y">) => {
+    width: ExcalidrawElement["width"];
+    height: ExcalidrawElement["height"];
+    x: ExcalidrawElement["x"];
+    y: ExcalidrawElement["y"];
+};

package/types/element/textElement.d.ts

@@ -0,0 +1,26 @@
+import { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawTextElementWithContainer, FontString, NonDeletedExcalidrawElement } from "./types";
+import { MaybeTransformHandleType } from "./transformHandles";
+export declare const redrawTextBoundingBox: (element: 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 measureText: (text: string, font: FontString, maxWidth?: number | null) => {
+    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;
+    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 getMaxCharWidth: (font: FontString) => number;
+export declare const getApproxCharsToFitInWidth: (font: FontString, width: number) => number;
+export declare const getBoundTextElementId: (container: ExcalidrawElement | null) => string | null;
+export declare const getBoundTextElement: (element: ExcalidrawElement | null) => ExcalidrawTextElementWithContainer | null;
+export declare const getContainerElement: (element: (ExcalidrawElement & {
+    containerId: ExcalidrawElement["id"] | null;
+}) | null) => ExcalidrawElement | null;

package/types/element/textWysiwyg.d.ts

@@ -0,0 +1,16 @@
+import { ExcalidrawElement, ExcalidrawTextElement } from "./types";
+import App from "../components/App";
+export declare const textWysiwyg: ({ id, onChange, onSubmit, getViewportCoords, element, canvas, excalidrawContainer, app, }: {
+    id: ExcalidrawElement["id"];
+    onChange?: ((text: string) => void) | undefined;
+    onSubmit: (data: {
+        text: string;
+        viaKeyboard: boolean;
+        originalText: string;
+    }) => void;
+    getViewportCoords: (x: number, y: number) => [number, number];
+    element: ExcalidrawTextElement;
+    canvas: HTMLCanvasElement | null;
+    excalidrawContainer: HTMLDivElement | null;
+    app: App;
+}) => void;