@zsviczian/excalidraw 0.10.0-textfix-17 → 0.11.0-obsidian-2

package/types/actions/shortcuts.d.ts

@@ -1,2 +1,3 @@
-export declare type ShortcutName = "cut" | "copy" | "paste" | "copyStyles" | "pasteStyles" | "selectAll" | "deleteSelectedElements" | "duplicateSelection" | "sendBackward" | "bringForward" | "sendToBack" | "bringToFront" | "copyAsPng" | "copyAsSvg" | "group" | "ungroup" | "gridMode" | "zenMode" | "stats" | "addToLibrary" | "viewMode" | "flipHorizontal" | "flipVertical";
+import { ActionName } from "./types";
+export declare type ShortcutName = SubtypeOf<ActionName, "cut" | "copy" | "paste" | "copyStyles" | "pasteStyles" | "selectAll" | "deleteSelectedElements" | "duplicateSelection" | "sendBackward" | "bringForward" | "sendToBack" | "bringToFront" | "copyAsPng" | "copyAsSvg" | "group" | "ungroup" | "gridMode" | "zenMode" | "stats" | "addToLibrary" | "viewMode" | "flipHorizontal" | "flipVertical" | "hyperlink">;
 export declare const getShortcutFromShortcutName: (name: ShortcutName) => string;

package/types/actions/types.d.ts

@@ -14,7 +14,7 @@ export declare type ActionResult = {
 declare type ActionFn = (elements: readonly ExcalidrawElement[], appState: Readonly<AppState>, formData: any, app: AppClassProperties) => ActionResult | Promise<ActionResult>;
 export declare type UpdaterFn = (res: ActionResult) => void;
 export declare type ActionFilterFn = (action: Action) => void;
-export declare type ActionName = "copy" | "cut" | "paste" | "copyAsPng" | "copyAsSvg" | "sendBackward" | "bringForward" | "sendToBack" | "bringToFront" | "copyStyles" | "selectAll" | "pasteStyles" | "gridMode" | "zenMode" | "stats" | "changeStrokeColor" | "changeBackgroundColor" | "changeFillStyle" | "changeStrokeWidth" | "changeStrokeShape" | "changeSloppiness" | "changeStrokeStyle" | "changeArrowhead" | "changeOpacity" | "changeFontSize" | "toggleCanvasMenu" | "toggleEditMenu" | "undo" | "redo" | "finalize" | "changeProjectName" | "changeExportBackground" | "changeExportEmbedScene" | "changeExportScale" | "saveToActiveFile" | "saveFileToDisk" | "loadScene" | "duplicateSelection" | "deleteSelectedElements" | "changeViewBackgroundColor" | "clearCanvas" | "zoomIn" | "zoomOut" | "resetZoom" | "zoomToFit" | "zoomToSelection" | "changeFontFamily" | "changeTextAlign" | "toggleFullScreen" | "toggleShortcuts" | "group" | "ungroup" | "goToCollaborator" | "addToLibrary" | "changeSharpness" | "alignTop" | "alignBottom" | "alignLeft" | "alignRight" | "alignVerticallyCentered" | "alignHorizontallyCentered" | "distributeHorizontally" | "distributeVertically" | "flipHorizontal" | "flipVertical" | "viewMode" | "exportWithDarkMode" | "toggleTheme";
+export declare type ActionName = "copy" | "cut" | "paste" | "copyAsPng" | "copyAsSvg" | "sendBackward" | "bringForward" | "sendToBack" | "bringToFront" | "copyStyles" | "selectAll" | "pasteStyles" | "gridMode" | "zenMode" | "stats" | "changeStrokeColor" | "changeBackgroundColor" | "changeFillStyle" | "changeStrokeWidth" | "changeStrokeShape" | "changeSloppiness" | "changeStrokeStyle" | "changeArrowhead" | "changeOpacity" | "changeFontSize" | "toggleCanvasMenu" | "toggleEditMenu" | "undo" | "redo" | "finalize" | "changeProjectName" | "changeExportBackground" | "changeExportEmbedScene" | "changeExportScale" | "saveToActiveFile" | "saveFileToDisk" | "loadScene" | "duplicateSelection" | "deleteSelectedElements" | "changeViewBackgroundColor" | "clearCanvas" | "zoomIn" | "zoomOut" | "resetZoom" | "zoomToFit" | "zoomToSelection" | "changeFontFamily" | "changeTextAlign" | "toggleFullScreen" | "toggleShortcuts" | "group" | "ungroup" | "goToCollaborator" | "addToLibrary" | "changeSharpness" | "alignTop" | "alignBottom" | "alignLeft" | "alignRight" | "alignVerticallyCentered" | "alignHorizontallyCentered" | "distributeHorizontally" | "distributeVertically" | "flipHorizontal" | "flipVertical" | "viewMode" | "exportWithDarkMode" | "toggleTheme" | "increaseFontSize" | "decreaseFontSize" | "unbindText" | "hyperlink";
 export declare type PanelComponentProps = {
     elements: readonly ExcalidrawElement[];
     appState: AppState;
@@ -31,9 +31,10 @@ export interface Action {
     perform: ActionFn;
     keyPriority?: number;
     keyTest?: (event: React.KeyboardEvent | KeyboardEvent, appState: AppState, elements: readonly ExcalidrawElement[]) => boolean;
-    contextItemLabel?: string;
+    contextItemLabel?: string | ((elements: readonly ExcalidrawElement[], appState: Readonly<AppState>) => string);
     contextItemPredicate?: (elements: readonly ExcalidrawElement[], appState: AppState) => boolean;
     checked?: (appState: Readonly<AppState>) => boolean;
+    trackEvent?: boolean | ((action: Action, type: "ui" | "keyboard" | "api", value: any) => void);
 }
 export interface ActionsManagerInterface {
     actions: Record<ActionName, Action>;

package/types/align.d.ts

@@ -4,4 +4,3 @@ export interface Alignment {
     axis: "x" | "y";
 }
 export declare const alignElements: (selectedElements: ExcalidrawElement[], alignment: Alignment) => ExcalidrawElement[];
-export declare const getMaximumGroups: (elements: ExcalidrawElement[]) => ExcalidrawElement[][];

package/types/analytics.d.ts

@@ -1 +1 @@
-export declare const trackEvent: (category: string, name: string, label?: string | undefined, value?: number | undefined) => void;
+export declare const trackEvent: (category: string, action: string, label?: string | undefined, value?: number | undefined) => void;

package/types/appState.d.ts

@@ -6,10 +6,6 @@ export declare const clearAppStateForLocalStorage: (appState: Partial<AppState>)
     viewBackgroundColor?: string | undefined;
     zoom?: Readonly<{
         value: NormalizedZoomValue;
-        translation: Readonly<{
-            x: number;
-            y: number;
-        }>;
     }> | undefined;
     shouldCacheIgnoreZoom?: boolean | undefined;
     theme?: string | undefined;

package/types/components/App.d.ts

@@ -1,9 +1,10 @@
 import React from "react";
 import { RoughCanvas } from "roughjs/bin/canvas";
 import { ActionManager } from "../actions/manager";
-import { ExcalidrawElement } from "../element/types";
+import { ExcalidrawElement, NonDeletedExcalidrawElement } from "../element/types";
 import History from "../history";
 import { AppClassProperties, AppProps, AppState, ExcalidrawImperativeAPI, BinaryFiles, LibraryItems, SceneData } from "../types";
+export declare let showFourthFont: boolean;
 export declare const useIsMobile: () => boolean;
 export declare const useExcalidrawContainer: () => {
     container: HTMLDivElement | null;
@@ -28,12 +29,16 @@ declare class App extends React.Component<AppProps, AppState> {
     private excalidrawContainerValue;
     files: BinaryFiles;
     imageCache: AppClassProperties["imageCache"];
+    hitLinkElement?: NonDeletedExcalidrawElement;
+    lastPointerDown: React.PointerEvent<HTMLCanvasElement> | null;
+    lastPointerUp: React.PointerEvent<HTMLElement> | PointerEvent | null;
+    contextMenuOpen: boolean;
     constructor(props: AppProps);
     private renderCanvas;
     render(): JSX.Element;
     focusContainer: AppClassProperties["focusContainer"];
     getSceneElementsIncludingDeleted: () => readonly ExcalidrawElement[];
-    getSceneElements: () => readonly import("../element/types").NonDeletedExcalidrawElement[];
+    getSceneElements: () => readonly NonDeletedExcalidrawElement[];
     private syncActionResult;
     private onBlur;
     private onUnload;
@@ -67,19 +72,29 @@ declare class App extends React.Component<AppProps, AppState> {
     setAppState: (obj: any) => void;
     removePointer: (event: React.PointerEvent<HTMLElement> | PointerEvent) => void;
     toggleLock: () => void;
+    togglePenMode: () => void;
     toggleZenMode: () => void;
     toggleStats: () => void;
     scrollToContent: (target?: ExcalidrawElement | readonly ExcalidrawElement[]) => void;
+    zoomToFit: (target?: readonly ExcalidrawElement[], maxZoom?: number, margin?: number) => void;
+    updateContainerSize: (containers: NonDeletedExcalidrawElement[]) => void;
     clearToast: () => void;
     setToastMessage: (toastMessage: string) => void;
     restoreFileFromShare: () => Promise<void>;
     /** adds supplied files to existing files in the appState */
     addFiles: ExcalidrawImperativeAPI["addFiles"];
+    setLocalFont: ExcalidrawImperativeAPI["setLocalFont"];
+    selectElements: ExcalidrawImperativeAPI["selectElements"];
+    bringToFront: ExcalidrawImperativeAPI["bringToFront"];
+    bringForward: ExcalidrawImperativeAPI["bringForward"];
+    sendToBack: ExcalidrawImperativeAPI["sendToBack"];
+    sendBackward: ExcalidrawImperativeAPI["sendBackward"];
     updateScene: <K extends keyof AppState>(sceneData: {
         elements?: SceneData["elements"];
         appState?: Pick<AppState, K> | null | undefined;
         collaborators?: SceneData["collaborators"];
         commitToHistory?: SceneData["commitToHistory"];
+        libraryItems?: SceneData["libraryItems"];
     }) => void;
     private onSceneUpdated;
     private updateCurrentCursorPosition;
@@ -96,10 +111,14 @@ declare class App extends React.Component<AppProps, AppState> {
     private getElementsAtPosition;
     private startTextEditing;
     private handleCanvasDoubleClick;
+    private getElementLinkAtPosition;
+    private redirectToLink;
     private handleCanvasPointerMove;
     private handleTouchMove;
     private handleCanvasPointerDown;
+    private handleCanvasPointerUp;
     private maybeOpenContextMenuAfterPointerDownOnTouchDevices;
+    private resetContextMenuTimer;
     private maybeCleanupAfterMissingPointerUp;
     private handleCanvasPanUsingWheelOrSpaceDrag;
     private updateGestureOnPointerDown;

package/types/components/ButtonIconSelect.d.ts

@@ -4,6 +4,7 @@ export declare const ButtonIconSelect: <T extends Object>({ options, value, onCh
         value: T;
         text: string;
         icon: JSX.Element;
+        testId?: string | undefined;
     }[];
     value: T | null;
     onChange: (value: T) => void;

package/types/components/ColorPicker.d.ts

@@ -1,10 +1,15 @@
 /// <reference types="react" />
 import "./ColorPicker.scss";
-export declare const ColorPicker: ({ type, color, onChange, label, isActive, setActive, }: {
+export declare const ColorPicker: ({ type, color, onChange, label, isActive, setActive, colorPalette, }: {
     type: "canvasBackground" | "elementBackground" | "elementStroke";
     color: string | null;
     onChange: (color: string) => void;
     label: string;
     isActive: boolean;
     setActive: (active: boolean) => void;
+    colorPalette: {
+        canvasBackground?: string[];
+        elementBackground?: string[];
+        elementStroke?: string[];
+    };
 }) => JSX.Element;

package/types/components/ContextMenu.d.ts

@@ -2,6 +2,7 @@ import "./ContextMenu.scss";
 import { Action } from "../actions/types";
 import { ActionManager } from "../actions/manager";
 import { AppState } from "../types";
+import { NonDeletedExcalidrawElement } from "../element/types";
 export declare type ContextMenuOption = "separator" | Action;
 declare type ContextMenuProps = {
     options: ContextMenuOption[];
@@ -10,6 +11,7 @@ declare type ContextMenuProps = {
     left: number;
     actionManager: ActionManager;
     appState: Readonly<AppState>;
+    elements: readonly NonDeletedExcalidrawElement[];
 };
 declare type ContextMenuParams = {
     options: (ContextMenuOption | false | null | undefined)[];
@@ -18,6 +20,7 @@ declare type ContextMenuParams = {
     actionManager: ContextMenuProps["actionManager"];
     appState: Readonly<AppState>;
     container: HTMLElement;
+    elements: readonly NonDeletedExcalidrawElement[];
 };
 declare const _default: {
     push(params: ContextMenuParams): void;

package/types/components/LayerUI.d.ts

@@ -15,6 +15,7 @@ interface LayerUIProps {
     elements: readonly NonDeletedExcalidrawElement[];
     onCollabButtonClick?: () => void;
     onLockToggle: () => void;
+    onPenModeToggle: () => void;
     onInsertElements: (elements: readonly NonDeletedExcalidrawElement[]) => void;
     zenModeEnabled: boolean;
     showExitZenModeBtn: boolean;
@@ -34,5 +35,5 @@ interface LayerUIProps {
         insertOnCanvasDirectly: boolean;
     }) => void;
 }
-declare const _default: React.MemoExoticComponent<({ actionManager, appState, files, setAppState, canvas, elements, onCollabButtonClick, onLockToggle, onInsertElements, zenModeEnabled, showExitZenModeBtn, showThemeBtn, toggleZenMode, isCollaborating, renderTopRightUI, renderCustomFooter, viewModeEnabled, libraryReturnUrl, UIOptions, focusContainer, library, id, onImageAction, }: LayerUIProps) => JSX.Element>;
+declare const _default: React.MemoExoticComponent<({ actionManager, appState, files, setAppState, canvas, elements, onCollabButtonClick, onLockToggle, onPenModeToggle, onInsertElements, zenModeEnabled, showExitZenModeBtn, showThemeBtn, toggleZenMode, isCollaborating, renderTopRightUI, renderCustomFooter, viewModeEnabled, libraryReturnUrl, UIOptions, focusContainer, library, id, onImageAction, }: LayerUIProps) => JSX.Element>;
 export default _default;

package/types/components/MobileMenu.d.ts

@@ -12,6 +12,7 @@ declare type MobileMenuProps = {
     libraryMenu: JSX.Element | null;
     onCollabButtonClick?: () => void;
     onLockToggle: () => void;
+    onPenModeToggle: () => void;
     canvas: HTMLCanvasElement | null;
     isCollaborating: boolean;
     renderCustomFooter?: (isMobile: boolean, appState: AppState) => JSX.Element;
@@ -22,5 +23,5 @@ declare type MobileMenuProps = {
     }) => void;
     renderTopRightUI?: (isMobile: boolean, appState: AppState) => JSX.Element | null;
 };
-export declare const MobileMenu: ({ appState, elements, libraryMenu, actionManager, renderJSONExportDialog, renderImageExportDialog, setAppState, onCollabButtonClick, onLockToggle, canvas, isCollaborating, renderCustomFooter, viewModeEnabled, showThemeBtn, onImageAction, renderTopRightUI, }: MobileMenuProps) => JSX.Element;
+export declare const MobileMenu: ({ appState, elements, libraryMenu, actionManager, renderJSONExportDialog, renderImageExportDialog, setAppState, onCollabButtonClick, onLockToggle, onPenModeToggle, canvas, isCollaborating, renderCustomFooter, viewModeEnabled, showThemeBtn, onImageAction, renderTopRightUI, }: MobileMenuProps) => JSX.Element;
 export {};

package/types/components/PenModeButton.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import "./ToolIcon.scss";
+declare type PenModeIconProps = {
+    title?: string;
+    name?: string;
+    checked: boolean;
+    onChange?(): void;
+    zenModeEnabled?: boolean;
+    isMobile?: boolean;
+    penDetected: boolean;
+};
+export declare const PenModeButton: (props: PenModeIconProps) => JSX.Element | null;
+export {};

package/types/components/Popover.d.ts

@@ -6,6 +6,10 @@ declare type Props = {
     children?: React.ReactNode;
     onCloseRequest?(event: PointerEvent): void;
     fitInViewport?: boolean;
+    offsetLeft?: number;
+    offsetTop?: number;
+    viewportWidth?: number;
+    viewportHeight?: number;
 };
-export declare const Popover: ({ children, left, top, onCloseRequest, fitInViewport, }: Props) => JSX.Element;
+export declare const Popover: ({ children, left, top, onCloseRequest, fitInViewport, offsetLeft, offsetTop, viewportWidth, viewportHeight, }: Props) => JSX.Element;
 export {};

package/types/components/Tooltip.d.ts

@@ -1,5 +1,12 @@
 import "./Tooltip.scss";
 import React from "react";
+export declare const getTooltipDiv: () => HTMLDivElement;
+export declare const updateTooltipPosition: (tooltip: HTMLDivElement, item: {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}, position?: "bottom" | "top") => void;
 declare type TooltipProps = {
     children: React.ReactNode;
     label: string;

package/types/components/icons.d.ts

@@ -149,6 +149,9 @@ export declare const FontSizeExtraLargeIcon: React.MemoExoticComponent<({ theme
 export declare const FontFamilyHandDrawnIcon: React.MemoExoticComponent<({ theme }: {
     theme: Theme;
 }) => JSX.Element>;
+export declare const FontFamilyLocalFontIcon: React.MemoExoticComponent<({ theme }: {
+    theme: Theme;
+}) => JSX.Element>;
 export declare const FontFamilyNormalIcon: React.MemoExoticComponent<({ theme }: {
     theme: Theme;
 }) => JSX.Element>;
@@ -165,4 +168,5 @@ export declare const TextAlignRightIcon: React.MemoExoticComponent<({ theme }: {
     theme: Theme;
 }) => JSX.Element>;
 export declare const publishIcon: JSX.Element;
+export declare const editIcon: JSX.Element;
 export {};

package/types/constants.d.ts

@@ -17,10 +17,10 @@ export declare const CURSOR_TYPE: {
     AUTO: string;
 };
 export declare const POINTER_BUTTON: {
-    MAIN: number;
-    WHEEL: number;
-    SECONDARY: number;
-    TOUCH: number;
+    readonly MAIN: 0;
+    readonly WHEEL: 1;
+    readonly SECONDARY: 2;
+    readonly TOUCH: -1;
 };
 export declare enum EVENT {
     COPY = "copy",
@@ -47,7 +47,8 @@ export declare enum EVENT {
     TOUCH_END = "touchend",
     HASHCHANGE = "hashchange",
     VISIBILITY_CHANGE = "visibilitychange",
-    SCROLL = "scroll"
+    SCROLL = "scroll",
+    EXCALIDRAW_LINK = "excalidraw-link"
 }
 export declare const ENV: {
     TEST: string;
@@ -60,6 +61,7 @@ export declare const FONT_FAMILY: {
     Virgil: number;
     Helvetica: number;
     Cascadia: number;
+    LocalFont: number;
 };
 export declare const THEME: {
     LIGHT: string;
@@ -89,9 +91,6 @@ export declare const EXPORT_DATA_TYPES: {
     readonly excalidrawLibrary: "excalidrawlib";
 };
 export declare const EXPORT_SOURCE: string;
-export declare const STORAGE_KEYS: {
-    readonly LOCAL_STORAGE_LIBRARY: "excalidraw-library";
-};
 export declare const IMAGE_RENDER_TIMEOUT = 500;
 export declare const TAP_TWICE_TIMEOUT = 300;
 export declare const TOUCH_CTX_MENU_TIMEOUT = 500;
@@ -100,6 +99,7 @@ export declare const TOAST_TIMEOUT = 5000;
 export declare const VERSION_TIMEOUT = 30000;
 export declare const SCROLL_TIMEOUT = 100;
 export declare const ZOOM_STEP = 0.1;
+export declare const HYPERLINK_TOOLTIP_DELAY = 300;
 export declare const IDLE_THRESHOLD = 60000;
 export declare const ACTIVE_THRESHOLD = 3000;
 export declare const MODES: {
@@ -130,4 +130,4 @@ export declare const VERSIONS: {
     readonly excalidraw: 2;
     readonly excalidrawLibrary: 2;
 };
-export declare const PADDING = 30;
+export declare const BOUND_TEXT_PADDING = 5;

package/types/disitrubte.d.ts

@@ -4,4 +4,3 @@ export interface Distribution {
     axis: "x" | "y";
 }
 export declare const distributeElements: (selectedElements: ExcalidrawElement[], distribution: Distribution) => ExcalidrawElement[];
-export declare const getMaximumGroups: (elements: ExcalidrawElement[]) => ExcalidrawElement[][];

package/types/element/Hyperlink.d.ts

@@ -0,0 +1,125 @@
+/// <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;
+            elementType: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "freedraw";
+            elementLocked: 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;
+            toastMessage: string | null;
+            zenModeEnabled: boolean;
+            theme: string;
+            gridSize: number | null;
+            viewModeEnabled: boolean;
+            selectedGroupIds: {
+                [groupId: string]: boolean;
+            };
+            editingGroupId: string | null;
+            width: number;
+            height: number;
+            offsetTop: number;
+            offsetLeft: number;
+            isLibraryOpen: boolean;
+            fileHandle: import("browser-fs-access").FileSystemHandle | null;
+            collaborators: Map<string, import("../types").Collaborator>;
+            showStats: boolean;
+            currentChartType: import("./types").ChartType;
+            pasteDialog: {
+                shown: false;
+                data: null;
+            } | {
+                shown: true;
+                data: import("../charts").Spreadsheet;
+            };
+            pendingImageElement: import("./types").NonDeleted<import("./types").ExcalidrawImageElement> | null;
+            linkOpacity: number;
+            trayModeEnabled: boolean;
+            colorPalette: {
+                canvasBackground?: string[] | undefined;
+                elementBackground?: string[] | undefined;
+                elementStroke?: string[] | undefined;
+            };
+        };
+        commitToHistory: true;
+    };
+    trackEvent: (action: import("../actions/types").Action, source: "ui" | "keyboard" | "api") => void;
+    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/bounds.d.ts

@@ -19,5 +19,9 @@ export interface Box {
     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

@@ -5,6 +5,7 @@ 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;

package/types/element/dragElements.d.ts

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

package/types/element/linearElementEditor.d.ts

@@ -98,6 +98,8 @@ export declare class LinearElementEditor {
             editingElement: import("./types").NonDeletedExcalidrawElement | null;
             elementType: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "freedraw";
             elementLocked: boolean;
+            penMode: boolean;
+            penDetected: boolean;
             exportBackground: boolean;
             exportEmbedScene: boolean;
             exportWithDarkMode: boolean;
@@ -126,10 +128,6 @@ export declare class LinearElementEditor {
             isRotating: boolean;
             zoom: Readonly<{
                 value: import("../types").NormalizedZoomValue;
-                translation: Readonly<{
-                    x: number;
-                    y: number;
-                }>;
             }>;
             openMenu: "canvas" | "shape" | null;
             openPopup: "canvasColorPicker" | "backgroundColorPicker" | "strokeColorPicker" | null;
@@ -168,6 +166,14 @@ export declare class LinearElementEditor {
                 data: import("../charts").Spreadsheet;
             };
             pendingImageElement: NonDeleted<import("./types").ExcalidrawImageElement> | null;
+            showHyperlinkPopup: false | "info" | "editor";
+            linkOpacity: number;
+            trayModeEnabled: boolean;
+            colorPalette: {
+                canvasBackground?: string[] | undefined;
+                elementBackground?: string[] | undefined;
+                elementStroke?: string[] | undefined;
+            };
         };
     };
     static deletePoints(element: NonDeleted<ExcalidrawLinearElement>, pointIndices: readonly number[]): void;

package/types/element/newElement.d.ts

@@ -1,22 +1,25 @@
 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">;
+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;
+    rawText: string;
     fontSize: number;
     fontFamily: FontFamilyValues;
     textAlign: TextAlign;
     verticalAlign: VerticalAlign;
     containerId?: ExcalidrawRectangleElement["id"];
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawTextElement>;
-export declare const updateTextElement: (element: ExcalidrawTextElement, { text, isDeleted, originalText, }: {
+export declare const updateTextElement: (element: ExcalidrawTextElement, { text, isDeleted, originalText, rawText, link, }: {
     text: string;
     isDeleted?: boolean | undefined;
     originalText: string;
-}, updateDimensions: boolean) => ExcalidrawTextElement;
+    rawText?: string | undefined;
+    link?: string | undefined;
+}) => ExcalidrawTextElement;
 export declare const newFreeDrawElement: (opts: {
     type: "freedraw";
     points?: ExcalidrawFreeDrawElement["points"];

package/types/element/resizeElements.d.ts

@@ -4,6 +4,6 @@ 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: (stateAtResizeStart: NonDeletedExcalidrawElement, shouldMaintainAspectRatio: boolean, element: NonDeletedExcalidrawElement, transformHandleDirection: TransformHandleDirection, shouldResizeFromCenter: 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,8 +1,9 @@
-import { ExcalidrawElement, ExcalidrawTextElement, FontString, NonDeletedExcalidrawElement } from "./types";
+import { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawTextElementWithContainer, FontString, NonDeletedExcalidrawElement } from "./types";
 import { MaybeTransformHandleType } from "./transformHandles";
-export declare const redrawTextBoundingBox: (element: ExcalidrawTextElement) => void;
+import { AppState } from "../types";
+export declare const redrawTextBoundingBox: (element: ExcalidrawTextElement, container: ExcalidrawElement | null, appState: AppState) => void;
 export declare const bindTextToShapeAfterDuplication: (sceneElements: ExcalidrawElement[], oldElements: ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
-export declare const handleBindTextResize: (elements: readonly NonDeletedExcalidrawElement[], transformHandleType: MaybeTransformHandleType) => void;
+export declare const handleBindTextResize: (element: NonDeletedExcalidrawElement, transformHandleType: MaybeTransformHandleType) => void;
 export declare const measureText: (text: string, font: FontString, maxWidth?: number | null | undefined) => {
     width: number;
     height: number;
@@ -12,12 +13,15 @@ export declare const getApproxLineHeight: (font: FontString) => number;
 export declare const wrapText: (text: string, font: FontString, containerWidth: number) => string;
 export declare const charWidth: {
     calculate: (char: string, font: FontString) => number;
-    updateCache: (char: string, font: FontString) => void;
-    clearCacheforFont: (font: FontString) => void;
     getCache: (font: FontString) => number[];
 };
 export declare const getApproxMinLineWidth: (font: FontString) => number;
 export declare const getApproxMinLineHeight: (font: FontString) => number;
 export declare const getMinCharWidth: (font: FontString) => number;
+export declare const getMaxCharWidth: (font: FontString) => number;
 export declare const getApproxCharsToFitInWidth: (font: FontString, width: number) => number;
 export declare const getBoundTextElementId: (container: ExcalidrawElement | null) => string | undefined;
+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

@@ -1,8 +1,7 @@
-import { ExcalidrawElement } from "./types";
-import { AppState } from "../types";
-export declare const textWysiwyg: ({ id, appState, onChange, onSubmit, getViewportCoords, element, canvas, excalidrawContainer, }: {
+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"];
-    appState: AppState;
     onChange?: ((text: string) => void) | undefined;
     onSubmit: (data: {
         text: string;
@@ -10,7 +9,8 @@ export declare const textWysiwyg: ({ id, appState, onChange, onSubmit, getViewpo
         originalText: string;
     }) => void;
     getViewportCoords: (x: number, y: number) => [number, number];
-    element: ExcalidrawElement;
+    element: ExcalidrawTextElement;
     canvas: HTMLCanvasElement | null;
     excalidrawContainer: HTMLDivElement | null;
+    app: App;
 }) => void;