@excalidraw/math 0.18.0-4ce38fb → 0.18.0-4ce8305

package/dist/types/excalidraw/components/App.selection.d.ts

@@ -0,0 +1,265 @@
+import { LinearElementEditor } from "@excalidraw/element";
+import type { ExcalidrawElement, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
+import type { Mutable } from "@excalidraw/common/utility-types";
+import type { CaptureUpdateActionType } from "@excalidraw/element";
+import type { AppClassProperties, AppState, InteractiveCanvasAppState } from "../types";
+import type App from "./App";
+export declare const selectGroupsForSelectedElements: {
+    (appState: Pick<AppState, "selectedElementIds" | "editingGroupId">, elements: readonly NonDeletedExcalidrawElement[], prevAppState: InteractiveCanvasAppState, app: AppClassProperties | null): Mutable<Pick<InteractiveCanvasAppState, "selectedGroupIds" | "editingGroupId" | "selectedElementIds">>;
+    clearCache(): void;
+};
+/**
+ * The selection of the given elements alone, with their groups (within the
+ * edited group): a frame wins over its children, bound text is left to its
+ * container, and a lone line or arrow gets its line editor.
+ *
+ * @param allElements the (non-deleted) elements the selection is in
+ * @param deep select the elements themselves rather than their groups,
+ *   editing their innermost group if they share it (and no group otherwise)
+ *   — as Ctrl+click does
+ */
+export declare const getSelectionStateForElements: (targetElements: readonly NonDeletedExcalidrawElement[], allElements: readonly NonDeletedExcalidrawElement[], appState: AppState, deep?: boolean) => Mutable<Pick<Readonly<{
+    zoom: AppState["zoom"];
+    scrollX: AppState["scrollX"];
+    scrollY: AppState["scrollY"];
+    width: AppState["width"];
+    height: AppState["height"];
+    viewModeEnabled: AppState["viewModeEnabled"];
+    openDialog: AppState["openDialog"];
+    editingGroupId: AppState["editingGroupId"];
+    selectedElementIds: AppState["selectedElementIds"];
+    frameToHighlight: AppState["frameToHighlight"];
+    offsetLeft: AppState["offsetLeft"];
+    offsetTop: AppState["offsetTop"];
+    theme: AppState["theme"];
+} & {
+    activeTool: AppState["activeTool"];
+    activeEmbeddable: AppState["activeEmbeddable"];
+    selectionElement: AppState["selectionElement"];
+    selectedGroupIds: AppState["selectedGroupIds"];
+    selectedLinearElement: AppState["selectedLinearElement"];
+    multiElement: AppState["multiElement"];
+    newElement: AppState["newElement"];
+    isBindingEnabled: AppState["isBindingEnabled"];
+    isMidpointSnappingEnabled: AppState["isMidpointSnappingEnabled"];
+    gridModeEnabled: AppState["gridModeEnabled"];
+    suggestedBinding: AppState["suggestedBinding"];
+    textToolHover: AppState["textToolHover"];
+    isRotating: AppState["isRotating"];
+    elementsToHighlight: AppState["elementsToHighlight"];
+    collaborators: AppState["collaborators"];
+    snapLines: AppState["snapLines"];
+    zenModeEnabled: AppState["zenModeEnabled"];
+    editingTextElement: AppState["editingTextElement"];
+    isCropping: AppState["isCropping"];
+    croppingElementId: AppState["croppingElementId"];
+    searchMatches: AppState["searchMatches"];
+    activeLockedId: AppState["activeLockedId"];
+    hoveredElementIds: AppState["hoveredElementIds"];
+    frameRendering: AppState["frameRendering"];
+    shouldCacheIgnoreZoom: AppState["shouldCacheIgnoreZoom"];
+    exportScale: AppState["exportScale"];
+    currentItemArrowType: AppState["currentItemArrowType"];
+}>, "selectedElementIds" | "editingGroupId" | "selectedGroupIds">> & {
+    selectedLinearElement: LinearElementEditor | null;
+};
+/**
+ * The selection with the given elements added, with their groups (within the
+ * edited group) — and the line editor of a lone selected line or arrow.
+ *
+ * A frame and its children aren't selected at the same time: an added frame
+ * deselects its children, an added child of a selected (or added) frame is
+ * left out, and adding elements grouped with frames deselects those frames'
+ * children (and leaves the added ones out). In the element link selector, the
+ * added elements replace the selection (unless one's group is selected).
+ *
+ * @param allElements the (non-deleted) elements the selection is in
+ */
+export declare const getSelectionStateAddingElements: (targetElements: readonly NonDeletedExcalidrawElement[], allElements: readonly NonDeletedExcalidrawElement[], appState: AppState) => Mutable<Pick<Readonly<{
+    zoom: AppState["zoom"];
+    scrollX: AppState["scrollX"];
+    scrollY: AppState["scrollY"];
+    width: AppState["width"];
+    height: AppState["height"];
+    viewModeEnabled: AppState["viewModeEnabled"];
+    openDialog: AppState["openDialog"];
+    editingGroupId: AppState["editingGroupId"];
+    selectedElementIds: AppState["selectedElementIds"];
+    frameToHighlight: AppState["frameToHighlight"];
+    offsetLeft: AppState["offsetLeft"];
+    offsetTop: AppState["offsetTop"];
+    theme: AppState["theme"];
+} & {
+    activeTool: AppState["activeTool"];
+    activeEmbeddable: AppState["activeEmbeddable"];
+    selectionElement: AppState["selectionElement"];
+    selectedGroupIds: AppState["selectedGroupIds"];
+    selectedLinearElement: AppState["selectedLinearElement"];
+    multiElement: AppState["multiElement"];
+    newElement: AppState["newElement"];
+    isBindingEnabled: AppState["isBindingEnabled"];
+    isMidpointSnappingEnabled: AppState["isMidpointSnappingEnabled"];
+    gridModeEnabled: AppState["gridModeEnabled"];
+    suggestedBinding: AppState["suggestedBinding"];
+    textToolHover: AppState["textToolHover"];
+    isRotating: AppState["isRotating"];
+    elementsToHighlight: AppState["elementsToHighlight"];
+    collaborators: AppState["collaborators"];
+    snapLines: AppState["snapLines"];
+    zenModeEnabled: AppState["zenModeEnabled"];
+    editingTextElement: AppState["editingTextElement"];
+    isCropping: AppState["isCropping"];
+    croppingElementId: AppState["croppingElementId"];
+    searchMatches: AppState["searchMatches"];
+    activeLockedId: AppState["activeLockedId"];
+    hoveredElementIds: AppState["hoveredElementIds"];
+    frameRendering: AppState["frameRendering"];
+    shouldCacheIgnoreZoom: AppState["shouldCacheIgnoreZoom"];
+    exportScale: AppState["exportScale"];
+    currentItemArrowType: AppState["currentItemArrowType"];
+}>, "selectedElementIds" | "editingGroupId" | "selectedGroupIds">> & {
+    selectedLinearElement: LinearElementEditor | null;
+};
+/**
+ * The selection with the given elements removed — with the group they're
+ * selected via (if any) — and a lone remaining line or arrow getting its
+ * line editor.
+ *
+ * @param allElements the (non-deleted) elements the selection is in
+ */
+export declare const getSelectionStateRemovingElements: (targetElements: readonly NonDeletedExcalidrawElement[], allElements: readonly NonDeletedExcalidrawElement[], appState: AppState) => Mutable<Pick<Readonly<{
+    zoom: AppState["zoom"];
+    scrollX: AppState["scrollX"];
+    scrollY: AppState["scrollY"];
+    width: AppState["width"];
+    height: AppState["height"];
+    viewModeEnabled: AppState["viewModeEnabled"];
+    openDialog: AppState["openDialog"];
+    editingGroupId: AppState["editingGroupId"];
+    selectedElementIds: AppState["selectedElementIds"];
+    frameToHighlight: AppState["frameToHighlight"];
+    offsetLeft: AppState["offsetLeft"];
+    offsetTop: AppState["offsetTop"];
+    theme: AppState["theme"];
+} & {
+    activeTool: AppState["activeTool"];
+    activeEmbeddable: AppState["activeEmbeddable"];
+    selectionElement: AppState["selectionElement"];
+    selectedGroupIds: AppState["selectedGroupIds"];
+    selectedLinearElement: AppState["selectedLinearElement"];
+    multiElement: AppState["multiElement"];
+    newElement: AppState["newElement"];
+    isBindingEnabled: AppState["isBindingEnabled"];
+    isMidpointSnappingEnabled: AppState["isMidpointSnappingEnabled"];
+    gridModeEnabled: AppState["gridModeEnabled"];
+    suggestedBinding: AppState["suggestedBinding"];
+    textToolHover: AppState["textToolHover"];
+    isRotating: AppState["isRotating"];
+    elementsToHighlight: AppState["elementsToHighlight"];
+    collaborators: AppState["collaborators"];
+    snapLines: AppState["snapLines"];
+    zenModeEnabled: AppState["zenModeEnabled"];
+    editingTextElement: AppState["editingTextElement"];
+    isCropping: AppState["isCropping"];
+    croppingElementId: AppState["croppingElementId"];
+    searchMatches: AppState["searchMatches"];
+    activeLockedId: AppState["activeLockedId"];
+    hoveredElementIds: AppState["hoveredElementIds"];
+    frameRendering: AppState["frameRendering"];
+    shouldCacheIgnoreZoom: AppState["shouldCacheIgnoreZoom"];
+    exportScale: AppState["exportScale"];
+    currentItemArrowType: AppState["currentItemArrowType"];
+}>, "selectedElementIds" | "editingGroupId" | "selectedGroupIds">> & {
+    selectedLinearElement: LinearElementEditor | null;
+};
+/** elements, or their ids — one or many */
+export type ElementsOrIds = ExcalidrawElement | ExcalidrawElement["id"] | readonly (ExcalidrawElement | ExcalidrawElement["id"])[];
+type SelectionChangeOptions = {
+    /**
+     * how the change is recorded for undo (see `updateScene()`) — by default,
+     * along with the next undoable change
+     */
+    captureUpdate?: CaptureUpdateActionType;
+};
+type AddOptions = SelectionChangeOptions & {
+    /**
+     * select locked elements too — e.g. for the context menu to offer unlocking
+     * them
+     */
+    includeLocked?: boolean;
+};
+type SelectOptions = AddOptions & {
+    /**
+     * select the elements themselves rather than their groups, editing their
+     * innermost group (if they share it) — as Ctrl+click does
+     */
+    deep?: boolean;
+};
+/**
+ * The selection: selecting elements, adding them to or removing them from
+ * the selection, and clearing it — keeping its rules: an element is selected
+ * with its group (but within the edited group), a frame and its children
+ * aren't selected at the same time, locked elements aren't selected, and a
+ * lone line or arrow gets its line editor (see the `getSelectionState*()`
+ * functions above).
+ *
+ * What hangs on the selection follows it: the link popup shows for a lone
+ * selected element with a link (or an embeddable), an embed stays active only
+ * while selected, cropping ends (unless the cropped image is selected again),
+ * and selecting (or adding) anything but the edited text ends text editing,
+ * submitting the text. The line editor ends once its line is deselected (see
+ * `componentDidUpdate()`).
+ *
+ * Elements are taken by id from the scene: missing and deleted ones are
+ * skipped.
+ */
+export declare class AppSelection {
+    private app;
+    constructor(app: App);
+    /**
+     * Selects the elements alone (with their groups, unless `deep`).
+     */
+    select: (elementsOrIds: ElementsOrIds, opts?: SelectOptions) => void;
+    /**
+     * Adds the elements (with their groups) to the selection.
+     */
+    add: (elementsOrIds: ElementsOrIds, opts?: AddOptions) => void;
+    /**
+     * Removes the elements from the selection — with the group they're
+     * selected via.
+     */
+    remove: (elementsOrIds: ElementsOrIds, opts?: SelectionChangeOptions) => void;
+    /**
+     * Clears the selection, leaving the edited group and ending cropping.
+     *
+     * (Doesn't end text editing: starting it clears the selection.)
+     */
+    clear: (opts?: SelectionChangeOptions) => void;
+    /**
+     * Ends what changing the selection ends — cropping (unless
+     * `keepsCroppedImage`), and text editing (unless selecting the edited text,
+     * or its container) — and records the change for undo as asked.
+     *
+     * @param elements the elements being selected (or added) — none for a
+     *   change that leaves text editing be
+     */
+    private beforeChange;
+    /**
+     * The next selection state with what follows it: the link popup — shown for
+     * a lone selected element with a link (or an embeddable), the link editor
+     * staying open if it's the same element, and hidden otherwise — and the
+     * active embed, which stays active only while selected.
+     */
+    private withFollowingState;
+    isASelectedElement(hitElement: ExcalidrawElement | null): boolean;
+    isHittingCommonBoundingBoxOfSelectedElements(point: Readonly<{
+        x: number;
+        y: number;
+    }>, selectedElements: readonly ExcalidrawElement[]): boolean;
+    /**
+     * The scene's (non-deleted) elements, by id, once each — but locked ones,
+     * unless `includeLocked`
+     */
+    private resolve;
+}
+export {};

package/dist/types/excalidraw/components/App.selectionTool.d.ts

@@ -0,0 +1,93 @@
+import type { TransformHandleType } from "@excalidraw/element";
+import type { ExcalidrawElement, ExcalidrawImageElement, NonDeleted, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap, PointerType } from "@excalidraw/element/types";
+import type React from "react";
+import type { PointerDownState } from "../types";
+import type App from "./App";
+/**
+ * The selection tool's (and the lasso's) selection: what a pointer down
+ * selects, what a click (a pointer up without a drag) does to the selection —
+ * including alt-click cycling through the overlapping elements — and the
+ * selection's transform handles (resizing, rotating, cropping).
+ */
+export declare class AppSelectionTool {
+    private app;
+    constructor(app: App);
+    clearSelectionIfNotUsingSelection: () => void;
+    /**
+     * @returns whether the pointer event has been completely handled
+     */
+    handleSelectionOnPointerDown: (event: React.PointerEvent<HTMLElement>, pointerDownState: PointerDownState) => boolean;
+    maybeHandleCrop: (pointerDownState: PointerDownState, event: MouseEvent | KeyboardEvent) => boolean;
+    /**
+     * In the crop editor, a double-click on a handle uncrops its side (a
+     * corner's two), and mirrored, the opposite side(s) too.
+     *
+     * @returns whether the double-click has been handled
+     */
+    maybeUncropSides: (image: NonDeleted<ExcalidrawImageElement>, sceneX: number, sceneY: number, mirrored: boolean) => boolean;
+    maybeHandleResize: (pointerDownState: PointerDownState, event: MouseEvent | KeyboardEvent) => boolean;
+    /**
+     * Drags the selection (or, in the crop editor, the image within its crop) —
+     * duplicating it on an alt-drag past the drag threshold.
+     *
+     * @returns whether the pointer event has been completely handled
+     */
+    handleSelectionDragOnPointerMove: (event: PointerEvent, pointerDownState: PointerDownState, pointerCoords: {
+        x: number;
+        y: number;
+    }, elementsMap: NonDeletedSceneElementsMap) => boolean;
+    /**
+     * Box-selects with the selection tool — the line editor's points, while
+     * editing a line.
+     */
+    handleBoxSelectionOnPointerMove: (event: PointerEvent, pointerDownState: PointerDownState) => void;
+    /**
+     * After dragging the selection: the dragged elements join the frame they're
+     * dropped in, or leave theirs (and the edited group, if they leave it).
+     */
+    handleSelectionDragOnPointerUp: (childEvent: PointerEvent) => void;
+    /**
+     * The selection's transform handle at the scene point, if any — with its
+     * element, for a lone selected element.
+     *
+     * A lone selected element has none while the line editor is open or one of
+     * its line points is hovered, nor does an elbow arrow, a two-point line or
+     * arrow, or (on mobile devices) any line or arrow. The selection has none in
+     * the element link selector.
+     */
+    getTransformHandleAt(selectedElements: readonly NonDeletedExcalidrawElement[], sceneX: number, sceneY: number, pointerType: PointerType): {
+        element?: NonDeletedExcalidrawElement;
+        transformHandleType: TransformHandleType;
+    } | null;
+    /**
+     * Updates the selection on a click (no drag): the element below the
+     * selected one on an alt-click, the clicked element added to or removed
+     * from the selection with shift, or selected, and the selection cleared
+     * by a click hitting only a bounding box.
+     *
+     * @returns whether the pointer event has been completely handled
+     */
+    handleSelectionOnPointerUp: (childEvent: PointerEvent, pointerDownState: PointerDownState, elementsMap: NonDeletedSceneElementsMap) => boolean;
+    clearSelection(hitElement: ExcalidrawElement | null): void;
+    /** whether an alt-click on the selection (over other elements) cycles it */
+    canCycleSelection: () => boolean;
+    /**
+     * The selectable unit (an element, or the group a click would select) an
+     * element belongs to. Inside an edited group, its elements are units of
+     * their own.
+     */
+    private getSelectableUnit;
+    /**
+     * The selected unit, if an alt-click can cycle away from it: exactly one
+     * is selected, and neither the linear nor the crop editor is open.
+     */
+    private getCyclableSelectedUnit;
+    /**
+     * The element an alt-click selects: the selectable unit below the selected
+     * one among the hit elements, wrapping around to the topmost — or `null`
+     * unless it's an alt-click, the selection can cycle, and it's under the
+     * pointer. Inside an edited group, it cycles through the group's elements
+     * only, never leaving the group.
+     */
+    private getSelectionCycleTarget;
+}

package/dist/types/excalidraw/components/App.viewport.d.ts

@@ -1,10 +1,16 @@
 import { type StylesPanelMode } from "@excalidraw/common";
 import type { NonDeletedSceneElementsMap } from "@excalidraw/element/types";
+import { type AnimationKey, type AnimationScheduler } from "../renderer/animation";
 import { type SetViewportOptions } from "../viewport";
 import type { AppProps, AppState, Offsets, ScrollConstraints, ViewportOffsets, ViewportOffsetsOptions, ViewportUIName } from "../types";
 import type App from "./App";
-export declare const SCROLL_TO_CONTENT_ANIMATION_KEY = "animateScrollToContent";
-export declare const SCROLL_CONSTRAINTS_SNAP_BACK_ANIMATION_KEY = "animateScrollConstraintsSnapBack";
+/** The AnimationController keys a viewport uses, unique per AppViewport so
+ * concurrent editors in the same window never share (or cancel) each
+ * other's animations. */
+export type ViewportAnimationKeys = {
+    scrollToContent: AnimationKey;
+    snapBack: AnimationKey;
+};
 /** single source of truth for the `--right-sidebar-width` CSS variable */
 export declare const RIGHT_SIDEBAR_WIDTH = 302;
 type Viewport = Pick<AppState, "scrollX" | "scrollY" | "zoom">;
@@ -19,7 +25,7 @@ type AppViewportDependencies = {
  * AnimationController. No-op when already within the hard bounds (or when
  * there is no lock).
  */
-export declare const snapBackToConstraints: (state: Pick<AppState, "scrollX" | "scrollY" | "zoom" | "width" | "height" | "scrollConstraints">, onFrame: (updater: (state: Pick<AppState, "scrollX" | "scrollY" | "zoom" | "width" | "height" | "scrollConstraints">) => Viewport | null) => void, duration?: number) => void;
+export declare const snapBackToConstraints: (state: Pick<AppState, "scrollX" | "scrollY" | "zoom" | "width" | "height" | "scrollConstraints">, onFrame: (updater: (state: Pick<AppState, "scrollX" | "scrollY" | "zoom" | "width" | "height" | "scrollConstraints">) => Viewport | null) => void, keys: ViewportAnimationKeys, scheduler?: AnimationScheduler, duration?: number) => void;
 /**
  * Owns viewport state transitions and App-bound viewport concerns. Pure
  * viewport geometry remains in `viewport.ts` so actions and public helpers can
@@ -34,6 +40,10 @@ export declare class AppViewport {
     };
     private activeTransition;
     private uiLastMeasured;
+    /** Unique per instance (see `ViewportAnimationKeys`); exposed for tests
+     * observing the animations. */
+    readonly scrollToContentAnimationKey: symbol;
+    readonly snapBackAnimationKey: symbol;
     constructor(app: App, dependencies: AppViewportDependencies);
     get isAnimating(): boolean;
     /** Whether a programmatic transition into a locked viewport currently owns

package/dist/types/excalidraw/components/App.wrap.d.ts

@@ -0,0 +1,31 @@
+import type { ExcalidrawElement } from "@excalidraw/element/types";
+import type { ActionResult } from "../actions/types";
+import type { AppState } from "../types";
+import type App from "./App";
+/**
+ * Wraps the selection in what fits it, or unwraps it, preferring containers
+ * over frames:
+ *
+ * 1. a text and a container without one: binds the text to the container
+ * 2. texts, with any labeled containers: wraps each text in a container
+ * 3. labeled containers: unwraps their texts, removing the containers
+ * 4. a frame with any of its children, or all of a frame's children: removes
+ *    the frame
+ * 5. anything else without a frame: wraps it in a frame
+ *
+ * The containers (3) removed come back in place of new ones while the
+ * selection it left stands, so diamonds, notes and arrows survive a toggle.
+ */
+export declare class AppWrap {
+    private app;
+    private unwrapped;
+    constructor(app: App);
+    toggle: (elements: readonly ExcalidrawElement[], appState: Readonly<AppState>) => ActionResult;
+    /** frees the containers' texts, moving the containers' arrows onto them */
+    private unwrap;
+    /**
+     * puts the unwrapped texts back into their containers, along with the
+     * containers' arrows — `null` when any of them is gone
+     */
+    private rewrap;
+}

package/dist/types/excalidraw/components/ConvertElementTypePopup.d.ts

@@ -1,5 +1,6 @@
 import type { ConvertibleTypes, ExcalidrawElement, ExcalidrawTextContainer, ExcalidrawTextElementWithContainer } from "@excalidraw/element/types";
 import type { Scene } from "@excalidraw/element";
+import type { RenderEnvironment } from "@excalidraw/element/renderEnvironment";
 import "./ConvertElementTypePopup.scss";
 import type App from "./App";
 export declare const convertElementTypePopupAtom: import("jotai").PrimitiveAtom<{
@@ -12,7 +13,7 @@ export declare const convertElementTypePopupAtom: import("jotai").PrimitiveAtom<
 declare const ConvertElementTypePopup: ({ app }: {
     app: App;
 }) => import("react/jsx-runtime").JSX.Element;
-export declare const adjustBoundTextSize: (container: ExcalidrawTextContainer, boundText: ExcalidrawTextElementWithContainer, scene: Scene) => void;
+export declare const adjustBoundTextSize: (container: ExcalidrawTextContainer, boundText: ExcalidrawTextElementWithContainer, scene: Scene, renderEnvironment?: RenderEnvironment) => void;
 type ConversionType = "generic" | "linear" | null;
 export declare const convertElementTypes: (app: App, { conversionType, nextType, direction, }: {
     conversionType: ConversionType;

package/dist/types/excalidraw/components/Stats/utils.d.ts

@@ -1,5 +1,5 @@
 import type { ElementsMap, ExcalidrawElement, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
-import type { Scene } from "@excalidraw/element";
+import type { RenderEnvironment, Scene } from "@excalidraw/element";
 import type { AppState } from "../../types";
 export type StatsInputProperty = "x" | "y" | "width" | "height" | "angle" | "fontSize" | "gridStep";
 export declare const SMALLEST_DELTA = 0.01;
@@ -15,5 +15,7 @@ export declare const newOrigin: (x1: number, y1: number, w1: number, h1: number,
     x: number;
     y: number;
 };
-export declare const moveElement: (newTopLeftX: number, newTopLeftY: number, originalElement: NonDeletedExcalidrawElement, scene: Scene, appState: AppState, originalElementsMap: ElementsMap, shouldInformMutation?: boolean) => void;
+export declare const moveElement: (newTopLeftX: number, newTopLeftY: number, originalElement: NonDeletedExcalidrawElement, scene: Scene, appState: AppState, originalElementsMap: ElementsMap, shouldInformMutation?: boolean, 
+/** measures the labels of the bound arrows the move moves */
+renderEnvironment?: RenderEnvironment) => void;
 export declare const getAtomicUnits: (targetElements: readonly ExcalidrawElement[], appState: AppState) => AtomicUnit[];

package/dist/types/excalidraw/components/TTDDialog/MermaidToExcalidraw.d.ts

@@ -1,7 +1,8 @@
 import "./MermaidToExcalidraw.scss";
 import type { MermaidToExcalidrawLibProps } from "./types";
-declare const MermaidToExcalidraw: ({ mermaidToExcalidrawLib, isActive, }: {
+declare const MermaidToExcalidraw: ({ mermaidToExcalidrawLib, onRetryLoad, isActive, }: {
     mermaidToExcalidrawLib: MermaidToExcalidrawLibProps;
+    onRetryLoad?: () => void;
     isActive?: boolean;
 }) => import("react/jsx-runtime").JSX.Element;
 export default MermaidToExcalidraw;

package/dist/types/excalidraw/components/TTDDialog/TTDDialogOutput.d.ts

@@ -1,11 +1,14 @@
+import type { MermaidToExcalidrawLibProps } from "./types";
 interface TTDDialogOutputProps {
     error: Error | null;
     canvasRef: React.RefObject<HTMLDivElement | null>;
-    loaded: boolean;
+    loadStatus: MermaidToExcalidrawLibProps["status"];
+    loadErrorReloadRequired?: boolean;
+    onRetryLoad?: () => void;
     hideErrorDetails?: boolean;
     sourceText?: string;
     autoFixAvailable?: boolean;
     onApplyAutoFix?: () => void;
 }
-export declare const TTDDialogOutput: ({ error, canvasRef, loaded, hideErrorDetails, sourceText, autoFixAvailable, onApplyAutoFix, }: TTDDialogOutputProps) => import("react/jsx-runtime").JSX.Element;
+export declare const TTDDialogOutput: ({ error, canvasRef, loadStatus, loadErrorReloadRequired, onRetryLoad, hideErrorDetails, sourceText, autoFixAvailable, onApplyAutoFix, }: TTDDialogOutputProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/excalidraw/components/TTDDialog/TTDPreviewPanel.d.ts

@@ -1,9 +1,12 @@
+import type { MermaidToExcalidrawLibProps } from "./types";
 interface TTDPreviewPanelProps {
     canvasRef: React.RefObject<HTMLDivElement | null>;
     error: Error | null;
-    loaded: boolean;
+    loadStatus: MermaidToExcalidrawLibProps["status"];
+    loadErrorReloadRequired?: boolean;
+    onRetryLoad?: () => void;
     onInsert: () => void;
     hideErrorDetails?: boolean;
 }
-export declare const TTDPreviewPanel: ({ canvasRef, error, loaded, onInsert, hideErrorDetails, }: TTDPreviewPanelProps) => import("react/jsx-runtime").JSX.Element;
+export declare const TTDPreviewPanel: ({ canvasRef, error, loadStatus, loadErrorReloadRequired, onRetryLoad, onInsert, hideErrorDetails, }: TTDPreviewPanelProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/excalidraw/components/TTDDialog/TextToDiagram.d.ts

@@ -1,6 +1,7 @@
 import type { MermaidToExcalidrawLibProps, TTDPersistenceAdapter, TTTDDialog } from "./types";
-export declare const TextToDiagram: ({ mermaidToExcalidrawLib, onTextSubmit, renderWelcomeScreen, renderWarning, persistenceAdapter, }: {
+export declare const TextToDiagram: ({ mermaidToExcalidrawLib, onRetryLoad, onTextSubmit, renderWelcomeScreen, renderWarning, persistenceAdapter, }: {
     mermaidToExcalidrawLib: MermaidToExcalidrawLibProps;
+    onRetryLoad?: () => void;
     onTextSubmit(props: TTTDDialog.OnTextSubmitProps): Promise<TTTDDialog.OnTextSubmitRetValue>;
     renderWelcomeScreen?: TTTDDialog.renderWelcomeScreen;
     renderWarning?: TTTDDialog.renderWarning;

package/dist/types/excalidraw/components/TTDDialog/common.d.ts

@@ -1,3 +1,4 @@
+import type { RenderEnvironment } from "@excalidraw/element";
 import type { NonDeletedExcalidrawElement, Theme } from "@excalidraw/element/types";
 import type { MermaidToExcalidrawLibProps } from "./types";
 import type { AppClassProperties, BinaryFiles } from "../../types";
@@ -5,7 +6,7 @@ export declare const resetPreview: ({ canvasRef, setError, }: {
     canvasRef: React.RefObject<HTMLDivElement | null>;
     setError: (error: Error | null) => void;
 }) => void;
-export declare const convertMermaidToExcalidraw: ({ canvasRef, mermaidToExcalidrawLib, mermaidDefinition, setError, data, theme, }: {
+export declare const convertMermaidToExcalidraw: ({ canvasRef, mermaidToExcalidrawLib, mermaidDefinition, setError, data, theme, renderEnvironment, }: {
     canvasRef: React.RefObject<HTMLDivElement | null>;
     mermaidToExcalidrawLib: MermaidToExcalidrawLibProps;
     mermaidDefinition: string;
@@ -15,6 +16,8 @@ export declare const convertMermaidToExcalidraw: ({ canvasRef, mermaidToExcalidr
         files: BinaryFiles | null;
     }>;
     theme: Theme;
+    /** the host's environment (`app.renderEnvironment`), to measure labels with */
+    renderEnvironment?: RenderEnvironment;
 }) => Promise<{
     success: true;
 } | {

package/dist/types/excalidraw/components/TTDDialog/hooks/useTextGeneration.d.ts

@@ -1,6 +1,7 @@
-import type { TTTDDialog } from "../types";
-export declare const useTextGeneration: ({ onTextSubmit, }: {
+import type { MermaidToExcalidrawLibProps, TTTDDialog } from "../types";
+export declare const useTextGeneration: ({ onTextSubmit, mermaidToExcalidrawLib, }: {
     onTextSubmit: (props: TTTDDialog.OnTextSubmitProps) => Promise<TTTDDialog.OnTextSubmitRetValue>;
+    mermaidToExcalidrawLib: MermaidToExcalidrawLibProps;
 }) => {
     onGenerate: TTTDDialog.OnGenerate;
     handleAbort: () => void;

package/dist/types/excalidraw/components/TTDDialog/types.d.ts

@@ -27,6 +27,12 @@ export declare namespace TChat {
         type: "user" | "assistant" | "warning";
         warningType?: /* daily rate limit */ "messageLimitExceeded" | /* general 429 */ "rateLimitExceeded";
         content?: string;
+        /**
+         * What an assistant's diagram was rendered with: Pele, since
+         * `@excalidraw/mermaid-to-excalidraw` v3. Not set on (saved) messages
+         * from before, which were rendered with Mermaid.
+         */
+        renderer?: "pele";
     };
     type ChatHistory = {
         id: string;
@@ -57,7 +63,14 @@ export interface TTDPersistenceAdapter {
     saveChats(chats: SavedChats): Promise<void>;
 }
 export interface MermaidToExcalidrawLibProps {
-    loaded: boolean;
+    /** loading state of the (lazy) lib. "error" e.g. while offline */
+    status: "loading" | "loaded" | "error";
+    /**
+     * set when loading failed while online (e.g. stale app version after
+     * a deploy, or the browser cached the failed fetch), i.e. only a page
+     * reload will likely recover
+     */
+    reloadRequired?: boolean;
     api: Promise<{
         parseMermaidToExcalidraw: (definition: string, config?: MermaidConfig) => Promise<MermaidToExcalidrawResult>;
     }>;

package/dist/types/excalidraw/components/TTDDialog/utils/mermaidError.d.ts

@@ -1,10 +1,36 @@
+/** a lazy-loaded chunk (e.g. one of mermaid's diagram chunks) failed to load */
+export declare const isModuleLoadError: (error: unknown) => boolean;
 export declare const isMermaidParseSyntaxError: (message: string) => boolean;
+/** the definition doesn't start with a (known) diagram type */
+export declare const isMermaidUnknownDiagramError: (message: string) => boolean;
 export declare const isMermaidAutoFixableError: (message: string) => boolean;
+export type MermaidDiagramType = "flowchart" | "sequence" | "class" | "state" | "er";
+/**
+ * Index of the line that declares the diagram type: the first one that isn't
+ * empty, a comment, a directive (`%%{...}%%`) or front matter (`---` block).
+ */
+export declare const getMermaidHeaderLineIndex: (sourceText: string) => number | null;
+/** The diagram type the definition declares (of those Excalidraw converts). */
+export declare const getMermaidDiagramType: (sourceText: string) => MermaidDiagramType | null;
 export declare const isMermaidCaretLine: (line: string) => boolean;
 export declare const getMermaidInactiveParticipant: (message: string) => string | null;
 export declare const getMermaidErrorLineNumber: (message: string, sourceText?: string) => number | null;
+/**
+ * The line of the source an error Mermaid (or Pele) reports on `line` is on:
+ * errors past its end (e.g. a missing `end`) are on its last non-empty line.
+ */
+export declare const getMermaidSourceLineNumber: (line: number, sourceText: string) => number;
+/** A line closing a block that `end`s */
+export declare const MERMAID_END_LINE: RegExp;
+export declare const getMermaidEndBlockOpener: (type: MermaidDiagramType | null) => RegExp | null;
 export declare const getMermaidSyntaxErrorGuidance: (message: string, sourceText?: string) => {
     summary: string;
     likelyCauses: string[];
 } | null;
-export declare const formatMermaidParseErrorMessage: (message: string) => string;
+/** The error, reported on its line of `sourceText` (see `getMermaidSourceLineNumber`) */
+export declare const withMermaidSourceLineNumber: (message: string, sourceText: string) => string;
+/**
+ * The parse error, without the tokens it expected, and if given the source,
+ * on its line of it.
+ */
+export declare const formatMermaidParseErrorMessage: (message: string, sourceText?: string) => string;

package/dist/types/excalidraw/components/Tooltip.d.ts

@@ -1,12 +1,22 @@
 import React from "react";
 import "./Tooltip.scss";
-export declare const getTooltipDiv: () => HTMLDivElement;
+export declare const TOOLTIP_CLASS = "excalidraw-tooltip";
+export declare const TOOLTIP_VISIBLE_CLASS = "excalidraw-tooltip--visible";
+export declare const getTooltipDiv: (ownerDocument: Document) => HTMLDivElement;
+/**
+ * Hides `ownerDocument`'s tooltip, for tooltips not shown through
+ * `showTooltip` (see `hideTooltip`).
+ */
+export declare const hideDocumentTooltip: (ownerDocument: Document) => void;
 export declare const updateTooltipPosition: (tooltip: HTMLDivElement, item: {
     left: number;
     top: number;
     width: number;
     height: number;
 }, position?: "bottom" | "top") => void;
+/** ms before a `delay`ed tooltip shows */
+export declare const TOOLTIP_DELAY = 500;
+/** Hides the tooltip `showTooltip` shows, and cancels a pending one. */
 export declare const hideTooltip: () => void;
 /**
  * Shows the tooltip for `item`. For elements that can't be wrapped