@excalidraw/excalidraw 0.12.0-e4aff04 → 0.12.0-e9067de

package/types/element/linearElementEditor.d.ts

@@ -3,26 +3,33 @@ import { NonDeleted, ExcalidrawLinearElement, ExcalidrawElement, PointBinding, E
 import { Point, AppState } from "../types";
 import History from "../history";
 import Scene from "../scene/Scene";
+declare const editorMidPointsCache: {
+    version: number | null;
+    points: (Point | null)[];
+    zoom: number | null;
+};
 export declare class LinearElementEditor {
-    elementId: ExcalidrawElement["id"] & {
+    readonly elementId: ExcalidrawElement["id"] & {
         _brand: "excalidrawLinearElementId";
     };
     /** indices */
-    selectedPointsIndices: readonly number[] | null;
-    pointerDownState: Readonly<{
+    readonly selectedPointsIndices: readonly number[] | null;
+    readonly pointerDownState: Readonly<{
         prevSelectedPointsIndices: readonly number[] | null;
         /** index */
         lastClickedPoint: number;
     }>;
     /** whether you're dragging a point */
-    isDragging: boolean;
-    lastUncommittedPoint: Point | null;
-    pointerOffset: Readonly<{
+    readonly isDragging: boolean;
+    readonly lastUncommittedPoint: Point | null;
+    readonly pointerOffset: Readonly<{
         x: number;
         y: number;
     }>;
-    startBindingElement: ExcalidrawBindableElement | null | "keep";
-    endBindingElement: ExcalidrawBindableElement | null | "keep";
+    readonly startBindingElement: ExcalidrawBindableElement | null | "keep";
+    readonly endBindingElement: ExcalidrawBindableElement | null | "keep";
+    readonly hoverPointIndex: number;
+    readonly segmentMidPointHoveredCoords: Point | null;
     constructor(element: NonDeleted<ExcalidrawLinearElement>, scene: Scene);
     static POINT_HANDLE_SIZE: number;
     /**
@@ -32,23 +39,35 @@ export declare class LinearElementEditor {
     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: {
+    static handlePointDragging(event: PointerEvent, appState: AppState, scenePointerX: number, scenePointerY: number, maybeSuggestBinding: (element: NonDeleted<ExcalidrawLinearElement>, pointSceneCoords: {
         x: number;
         y: number;
-    }[]) => void): boolean;
+    }[]) => void, linearElementEditor: LinearElementEditor): 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: {
+    static getEditorMidPoints: (element: NonDeleted<ExcalidrawLinearElement>, appState: AppState) => (typeof editorMidPointsCache)["points"];
+    static updateEditorMidPointsCache: (element: NonDeleted<ExcalidrawLinearElement>, appState: AppState) => void;
+    static getSegmentMidpointHitCoords: (linearElementEditor: LinearElementEditor, scenePointer: {
         x: number;
         y: number;
-    }): {
+    }, appState: AppState) => readonly [number, number] | null;
+    static isSegmentTooShort(element: NonDeleted<ExcalidrawLinearElement>, startPoint: Point, endPoint: Point, zoom: AppState["zoom"]): boolean;
+    static getSegmentMidPoint(element: NonDeleted<ExcalidrawLinearElement>, startPoint: Point, endPoint: Point, endPointIndex: number): readonly [number, number];
+    static getSegmentMidPointIndex(linearElementEditor: LinearElementEditor, appState: AppState, midPoint: Point): number;
+    static handlePointerDown(event: React.PointerEvent<HTMLCanvasElement>, appState: AppState, history: History, scenePointer: {
+        x: number;
+        y: number;
+    }, linearElementEditor: LinearElementEditor): {
         didAddPoint: boolean;
         hitElement: NonDeleted<ExcalidrawElement> | null;
+        linearElementEditor: LinearElementEditor | null;
+        isMidPoint: boolean;
     };
-    static handlePointerMove(event: React.PointerEvent<HTMLCanvasElement>, scenePointerX: number, scenePointerY: number, editingLinearElement: LinearElementEditor, gridSize: number | null): LinearElementEditor;
+    static arePointsEqual(point1: Point | null, point2: Point | null): boolean;
+    static handlePointerMove(event: React.PointerEvent<HTMLCanvasElement>, scenePointerX: number, scenePointerY: number, appState: AppState): LinearElementEditor | null;
     /** scene coords */
     static getPointGlobalCoordinates(element: NonDeleted<ExcalidrawLinearElement>, point: Point): readonly [number, number];
     /** scene coords */
-    static getPointsGlobalCoordinates(element: NonDeleted<ExcalidrawLinearElement>): number[][];
+    static getPointsGlobalCoordinates(element: NonDeleted<ExcalidrawLinearElement>): Point[];
     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;
@@ -76,7 +95,6 @@ export declare class LinearElementEditor {
                     /** index */
                     lastClickedPoint: number;
                 }>;
-                /** whether you're dragging a point */
                 isDragging: boolean;
                 lastUncommittedPoint: readonly [number, number] | null;
                 pointerOffset: Readonly<{
@@ -85,6 +103,8 @@ export declare class LinearElementEditor {
                 }>;
                 startBindingElement: ExcalidrawBindableElement | "keep" | null;
                 endBindingElement: ExcalidrawBindableElement | "keep" | null;
+                hoverPointIndex: number;
+                segmentMidPointHoveredCoords: readonly [number, number] | null;
             };
             isLoading: boolean;
             errorMessage: string | null;
@@ -122,7 +142,7 @@ export declare class LinearElementEditor {
             currentItemOpacity: number;
             currentItemFontFamily: number;
             currentItemFontSize: number;
-            currentItemTextAlign: import("./types").TextAlign;
+            currentItemTextAlign: string;
             currentItemStrokeSharpness: import("./types").StrokeSharpness;
             currentItemStartArrowhead: import("./types").Arrowhead | null;
             currentItemEndArrowhead: import("./types").Arrowhead | null;
@@ -140,6 +160,8 @@ export declare class LinearElementEditor {
             }>;
             openMenu: "canvas" | "shape" | null;
             openPopup: "canvasColorPicker" | "backgroundColorPicker" | "strokeColorPicker" | null;
+            openSidebar: "library" | "customSidebar" | null;
+            isSidebarDocked: boolean;
             lastPointerDownWith: import("./types").PointerType;
             selectedElementIds: {
                 [id: string]: boolean;
@@ -166,8 +188,6 @@ export declare class LinearElementEditor {
             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;
@@ -181,10 +201,11 @@ export declare class LinearElementEditor {
             };
             pendingImageElementId: string | null;
             showHyperlinkPopup: false | "info" | "editor";
+            selectedLinearElement: LinearElementEditor | null;
         };
     };
     static deletePoints(element: NonDeleted<ExcalidrawLinearElement>, pointIndices: readonly number[]): void;
-    static addPoints(element: NonDeleted<ExcalidrawLinearElement>, targetPoints: {
+    static addPoints(element: NonDeleted<ExcalidrawLinearElement>, appState: AppState, targetPoints: {
         point: Point;
     }[]): void;
     static movePoints(element: NonDeleted<ExcalidrawLinearElement>, targetPoints: {
@@ -196,4 +217,6 @@ export declare class LinearElementEditor {
         endBinding?: PointBinding;
     }): void;
     private static _updatePoints;
+    private static _getShiftLockedDelta;
 }
+export {};

package/types/element/mutateElement.d.ts

@@ -7,5 +7,5 @@ export declare const newElementWith: <TElement extends ExcalidrawElement>(elemen
  *
  * NOTE: does not trigger re-render.
  */
-export declare const bumpVersion: (element: Mutable<ExcalidrawElement>, version?: number | undefined) => Mutable<ExcalidrawElement>;
+export declare const bumpVersion: (element: Mutable<ExcalidrawElement>, version?: ExcalidrawElement["version"]) => Mutable<ExcalidrawElement>;
 export {};

package/types/element/newElement.d.ts

@@ -12,7 +12,9 @@ export declare const newTextElement: (opts: {
     verticalAlign: VerticalAlign;
     containerId?: ExcalidrawRectangleElement["id"];
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawTextElement>;
-export declare const updateTextElement: (element: ExcalidrawTextElement, { text, isDeleted, originalText, }: {
+export declare const getMaxContainerWidth: (container: ExcalidrawElement) => number;
+export declare const getMaxContainerHeight: (container: ExcalidrawElement) => number;
+export declare const updateTextElement: (textElement: ExcalidrawTextElement, { text, isDeleted, originalText, }: {
     text: string;
     isDeleted?: boolean | undefined;
     originalText: string;
@@ -30,6 +32,9 @@ export declare const newLinearElement: (opts: {
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawLinearElement>;
 export declare const newImageElement: (opts: {
     type: ExcalidrawImageElement["type"];
+    status?: ExcalidrawImageElement["status"];
+    fileId?: ExcalidrawImageElement["fileId"];
+    scale?: ExcalidrawImageElement["scale"];
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawImageElement>;
 export declare const deepCopyElement: (val: any, depth?: number) => any;
 /**

package/types/element/sizeHelpers.d.ts

@@ -8,6 +8,10 @@ export declare const getPerfectElementSize: (elementType: AppState["activeTool"]
     width: number;
     height: number;
 };
+export declare const getLockedLinearCursorAlignSize: (originX: number, originY: number, x: number, y: 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"];

package/types/element/textElement.d.ts

@@ -1,15 +1,15 @@
 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 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 measureText: (text: string, font: FontString, maxWidth?: number | null | undefined) => {
+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 wrapText: (text: string, font: FontString, maxWidth: number) => string;
 export declare const charWidth: {
     calculate: (char: string, font: FontString) => number;
     getCache: (font: FontString) => number[];
@@ -24,3 +24,7 @@ export declare const getBoundTextElement: (element: ExcalidrawElement | null) =>
 export declare const getContainerElement: (element: (ExcalidrawElement & {
     containerId: ExcalidrawElement["id"] | null;
 }) | null) => ExcalidrawElement | null;
+export declare const getContainerDims: (element: ExcalidrawElement) => {
+    width: number;
+    height: number;
+};

package/types/element/transformHandles.d.ts

@@ -1,6 +1,6 @@
-import { ExcalidrawElement, PointerType } from "./types";
+import { ExcalidrawElement, NonDeletedExcalidrawElement, PointerType } from "./types";
 import { Bounds } from "./bounds";
-import { Zoom } from "../types";
+import { AppState, Zoom } from "../types";
 export declare type TransformHandleDirection = "n" | "s" | "w" | "e" | "nw" | "ne" | "sw" | "se";
 export declare type TransformHandleType = TransformHandleDirection | "rotation";
 export declare type TransformHandle = [number, number, number, number];
@@ -17,12 +17,13 @@ export declare const OMIT_SIDES_FOR_MULTIPLE_ELEMENTS: {
 export declare const getTransformHandlesFromCoords: ([x1, y1, x2, y2]: Bounds, angle: number, zoom: Zoom, pointerType: PointerType, omitSides?: {
     e?: boolean | undefined;
     s?: boolean | undefined;
-    n?: boolean | undefined;
     w?: boolean | undefined;
+    n?: boolean | undefined;
     nw?: boolean | undefined;
     ne?: boolean | undefined;
     sw?: boolean | undefined;
     se?: boolean | undefined;
     rotation?: boolean | undefined;
-}) => TransformHandles;
+}, margin?: number) => TransformHandles;
 export declare const getTransformHandles: (element: ExcalidrawElement, zoom: Zoom, pointerType?: PointerType) => TransformHandles;
+export declare const shouldShowBoundingBox: (elements: NonDeletedExcalidrawElement[], appState: AppState) => boolean;

package/types/element/typeChecks.d.ts

@@ -4,11 +4,11 @@ export declare const isGenericElement: (element: ExcalidrawElement | null) => el
 export declare const isInitializedImageElement: (element: ExcalidrawElement | null) => element is InitializedExcalidrawImageElement;
 export declare const isImageElement: (element: ExcalidrawElement | null) => element is ExcalidrawImageElement;
 export declare const isTextElement: (element: ExcalidrawElement | null) => element is ExcalidrawTextElement;
-export declare const isFreeDrawElement: (element?: ExcalidrawElement | null | undefined) => element is ExcalidrawFreeDrawElement;
+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 | undefined) => element is ExcalidrawLinearElement;
+export declare const isLinearElement: (element?: ExcalidrawElement | null) => element is ExcalidrawLinearElement;
 export declare const isLinearElementType: (elementType: AppState["activeTool"]["type"]) => boolean;
-export declare const isBindingElement: (element?: ExcalidrawElement | null | undefined, includeLocked?: boolean) => element is ExcalidrawLinearElement;
+export declare const isBindingElement: (element?: ExcalidrawElement | null, includeLocked?: boolean) => element is ExcalidrawLinearElement;
 export declare const isBindingElementType: (elementType: AppState["activeTool"]["type"]) => boolean;
 export declare const isBindableElement: (element: ExcalidrawElement | null, includeLocked?: boolean) => element is ExcalidrawBindableElement;
 export declare const isTextBindableContainer: (element: ExcalidrawElement | null, includeLocked?: boolean) => element is ExcalidrawTextContainer;

package/types/element/types.d.ts

@@ -1,5 +1,5 @@
 import { Point } from "../types";
-import { FONT_FAMILY, THEME, VERTICAL_ALIGN } from "../constants";
+import { FONT_FAMILY, 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;
@@ -12,7 +12,7 @@ export declare type GroupId = string;
 export declare type PointerType = "mouse" | "pen" | "touch";
 export declare type StrokeSharpness = "round" | "sharp";
 export declare type StrokeStyle = "solid" | "dashed" | "dotted";
-export declare type TextAlign = "left" | "center" | "right";
+export declare type TextAlign = typeof TEXT_ALIGN[keyof typeof TEXT_ALIGN];
 declare type VerticalAlignKeys = keyof typeof VERTICAL_ALIGN;
 export declare type VerticalAlign = typeof VERTICAL_ALIGN[VerticalAlignKeys];
 declare type _ExcalidrawElementBase = Readonly<{
@@ -53,6 +53,7 @@ declare type _ExcalidrawElementBase = Readonly<{
     updated: number;
     link: string | null;
     locked: boolean;
+    customData?: Record<string, any>;
 }>;
 export declare type ExcalidrawSelectionElement = _ExcalidrawElementBase & {
     type: "selection";

package/types/keys.d.ts

@@ -65,4 +65,4 @@ export declare type Key = keyof typeof KEYS;
 export declare const isArrowKey: (key: string) => boolean;
 export declare const shouldResizeFromCenter: (event: MouseEvent | KeyboardEvent) => boolean;
 export declare const shouldMaintainAspectRatio: (event: MouseEvent | KeyboardEvent) => boolean;
-export declare const shouldRotateWithDiscreteAngle: (event: MouseEvent | KeyboardEvent) => boolean;
+export declare const shouldRotateWithDiscreteAngle: (event: MouseEvent | KeyboardEvent | React.PointerEvent<HTMLCanvasElement>) => boolean;

package/types/math.d.ts

@@ -1,5 +1,5 @@
 import { Point, Zoom } from "./types";
-import { ExcalidrawLinearElement } from "./element/types";
+import { 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,3 +18,10 @@ 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 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][];
+export declare const getBezierCurveArcLengths: (element: NonDeleted<ExcalidrawLinearElement>, endPoint: readonly [number, number]) => number[];
+export declare const getBezierCurveLength: (element: NonDeleted<ExcalidrawLinearElement>, endPoint: readonly [number, number]) => number;
+export declare const mapIntervalToBezierT: (element: NonDeleted<ExcalidrawLinearElement>, endPoint: readonly [number, number], interval: number) => number;
+export declare const arePointsEqual: (p1: readonly [number, number], p2: readonly [number, number]) => boolean;

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

@@ -1,8 +1,8 @@
-/// <reference types="react" />
+import type * as TExcalidraw from "../index";
 import "./App.scss";
 declare global {
     interface Window {
-        ExcalidrawLib: any;
+        ExcalidrawLib: typeof TExcalidraw;
     }
 }
 export default function App(): JSX.Element;

package/types/packages/excalidraw/example/sidebar/{Sidebar.d.ts → ExampleSidebar.d.ts}

@@ -1,5 +1,5 @@
 import React from "react";
-import "./Sidebar.scss";
+import "./ExampleSidebar.scss";
 export default function Sidebar({ children }: {
     children: React.ReactNode;
 }): JSX.Element;

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

@@ -13,3 +13,4 @@ export { FONT_FAMILY, THEME, MIME_TYPES } from "../../constants";
 export { mutateElement, newElementWith, bumpVersion, } from "../../element/mutateElement";
 export { parseLibraryTokensFromUrl, useHandleLibrary, } from "../../data/library";
 export { sceneCoordsToViewportCoords, viewportCoordsToSceneCoords, } from "../../utils";
+export { Sidebar } from "../../components/Sidebar/Sidebar";