@excalidraw/math 0.18.0-4e758db → 0.18.0-4f68076

package/dist/types/excalidraw/components/TopPicksDnD/TopPicksTip.d.ts

@@ -0,0 +1,11 @@
+/**
+ * "drag to pin" hint shown in a picker popup whose top picks are
+ * customizable — with a reset link while the picks are customized
+ */
+export declare const TopPicksTip: ({ className, tip, onReset, resetTitle, }: {
+    className?: string;
+    tip: string;
+    /** present only while the top picks are customized */
+    onReset?: () => void;
+    resetTitle: string;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/types/excalidraw/components/TopPicksDnD/topPicksDnD.d.ts

@@ -0,0 +1,58 @@
+import "./TopPicksDnD.scss";
+type DragOrigin = {
+    kind: "source";
+} | {
+    kind: "pick";
+    index: number;
+};
+export type TopPicksDragState<T> = {
+    value: T;
+    origin: DragOrigin;
+    /** hovered strip slot — the slot to replace (source drags) or the final
+     * position (pick reorders). null while the pointer is outside the strip */
+    overIndex: number | null;
+    /** index of an already-pinned identical value that blocks the drop */
+    duplicateIndex: number | null;
+    /** signed distance between strip slot centers (for reorder preview) */
+    slotSpan: number;
+} | null;
+export type TopPicksGhost = {
+    /** the ghost's visual. Rendered into `document.body` — outside the
+     * editor's CSS scope, so theme-dependent styling must be resolved from the
+     * rendered DOM (computed styles) rather than CSS variables */
+    content: HTMLElement;
+    /** where the ghost spawns (its size) and flies back to on cancel */
+    rect: DOMRect;
+};
+/** called on pointerdown (the source may not stay mounted until the drag
+ * activates), for every potential drag — keep it cheap */
+export type CreateTopPicksGhost<T> = (args: {
+    value: T;
+    /** the element the drag started on */
+    sourceEl: HTMLElement;
+    /** the registered strip */
+    stripEl: HTMLElement;
+}) => TopPicksGhost;
+export type TopPicksDnD<T> = {
+    dragState: TopPicksDragState<T>;
+    startSourceDrag: (event: React.PointerEvent, value: T | null) => void;
+    startPickDrag: (event: React.PointerEvent, index: number, value: T) => void;
+    setStripEl: (el: HTMLDivElement | null) => void;
+};
+/**
+ * live preview of the reorder result — the translation (px) moving the pick
+ * at `index` to the slot it would occupy if dropped right now
+ */
+export declare const getTopPickReorderOffset: (dragState: TopPicksDragState<unknown>, index: number) => number;
+/** "marching ants" outline hinting that the strip accepts the drop — SVG
+ * because CSS dashed outlines/borders can't animate their dash offset */
+export declare const TopPicksDnDOutline: () => import("react/jsx-runtime").JSX.Element;
+export declare const useTopPicksDnD: <T>({ enabled, picks, onPicksChange, isSamePick, createGhost, }: {
+    enabled: boolean;
+    picks: readonly T[];
+    onPicksChange: (picks: T[]) => void;
+    /** value-equality — pins identical to an existing pick are refused */
+    isSamePick?: (a: T, b: T) => boolean;
+    createGhost: CreateTopPicksGhost<T>;
+}) => TopPicksDnD<T>;
+export {};

package/dist/types/excalidraw/components/main-menu/DefaultItems.d.ts

@@ -78,6 +78,7 @@ export declare const Preferences: {
     ToggleSnapMode: () => import("react/jsx-runtime").JSX.Element;
     ToggleArrowBinding: () => import("react/jsx-runtime").JSX.Element;
     ToggleMidpointSnapping: () => import("react/jsx-runtime").JSX.Element;
+    ToggleShowHints: () => import("react/jsx-runtime").JSX.Element;
     ToggleGridMode: () => import("react/jsx-runtime").JSX.Element;
     ToggleZenMode: () => import("react/jsx-runtime").JSX.Element;
     ToggleViewMode: () => import("react/jsx-runtime").JSX.Element | null;

package/dist/types/excalidraw/data/blob.d.ts

@@ -78,7 +78,14 @@ fileHandle?: FileSystemFileHandle | null) => Promise<{
                 element: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawBindableElement>;
                 midPoint?: import("@excalidraw/math").GlobalPoint;
             } | null;
-            hoveredArrowTextAnchor: {
+            textToolHover: {
+                type: "text";
+                elementId: ExcalidrawElement["id"];
+            } | {
+                type: "container";
+                elementId: ExcalidrawElement["id"];
+            } | {
+                type: "arrow";
                 elementId: import("@excalidraw/element/types").ExcalidrawArrowElement["id"];
                 anchor: "start" | "end" | "label";
             } | null;
@@ -114,6 +121,7 @@ fileHandle?: FileSystemFileHandle | null) => Promise<{
             resizingElement: import("@excalidraw/element/types").NonDeletedExcalidrawElement | null;
             boxSelectionMode: import("../types").BoxSelectionMode;
             bindingPreference: "enabled" | "disabled";
+            showHints: boolean;
             inputDevice: import("../types").InputDevice;
             editingFrame: import("@excalidraw/element/types").ExcalidrawFrameLikeElement["id"] | null;
             preferredSelectionTool: {
@@ -185,6 +193,7 @@ fileHandle?: FileSystemFileHandle | null) => Promise<{
                 stickyNoteStroke: readonly string[] | null;
                 stickyNoteBackground: readonly string[] | null;
             };
+            fontTopPicks: readonly import("@excalidraw/element/types").FontFamilyValues[] | null;
         };
         files: import("../types").BinaryFiles;
     };
@@ -257,7 +266,14 @@ fileHandle?: FileSystemFileHandle | null) => Promise<{
             element: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawBindableElement>;
             midPoint?: import("@excalidraw/math").GlobalPoint;
         } | null;
-        hoveredArrowTextAnchor: {
+        textToolHover: {
+            type: "text";
+            elementId: ExcalidrawElement["id"];
+        } | {
+            type: "container";
+            elementId: ExcalidrawElement["id"];
+        } | {
+            type: "arrow";
             elementId: import("@excalidraw/element/types").ExcalidrawArrowElement["id"];
             anchor: "start" | "end" | "label";
         } | null;
@@ -293,6 +309,7 @@ fileHandle?: FileSystemFileHandle | null) => Promise<{
         resizingElement: import("@excalidraw/element/types").NonDeletedExcalidrawElement | null;
         boxSelectionMode: import("../types").BoxSelectionMode;
         bindingPreference: "enabled" | "disabled";
+        showHints: boolean;
         inputDevice: import("../types").InputDevice;
         editingFrame: import("@excalidraw/element/types").ExcalidrawFrameLikeElement["id"] | null;
         preferredSelectionTool: {
@@ -364,6 +381,7 @@ fileHandle?: FileSystemFileHandle | null) => Promise<{
             stickyNoteStroke: readonly string[] | null;
             stickyNoteBackground: readonly string[] | null;
         };
+        fontTopPicks: readonly import("@excalidraw/element/types").FontFamilyValues[] | null;
     };
     files: import("../types").BinaryFiles;
 }>;

package/dist/types/excalidraw/data/json.d.ts

@@ -76,7 +76,14 @@ export declare const loadFromJSON: (localAppState: AppState, localElements: read
             element: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawBindableElement>;
             midPoint?: import("@excalidraw/math").GlobalPoint;
         } | null;
-        hoveredArrowTextAnchor: {
+        textToolHover: {
+            type: "text";
+            elementId: ExcalidrawElement["id"];
+        } | {
+            type: "container";
+            elementId: ExcalidrawElement["id"];
+        } | {
+            type: "arrow";
             elementId: import("@excalidraw/element/types").ExcalidrawArrowElement["id"];
             anchor: "start" | "end" | "label";
         } | null;
@@ -112,6 +119,7 @@ export declare const loadFromJSON: (localAppState: AppState, localElements: read
         resizingElement: import("@excalidraw/element/types").NonDeletedExcalidrawElement | null;
         boxSelectionMode: import("../types").BoxSelectionMode;
         bindingPreference: "enabled" | "disabled";
+        showHints: boolean;
         inputDevice: import("../types").InputDevice;
         editingFrame: import("@excalidraw/element/types").ExcalidrawFrameLikeElement["id"] | null;
         preferredSelectionTool: {
@@ -183,6 +191,7 @@ export declare const loadFromJSON: (localAppState: AppState, localElements: read
             stickyNoteStroke: readonly string[] | null;
             stickyNoteBackground: readonly string[] | null;
         };
+        fontTopPicks: readonly import("@excalidraw/element/types").FontFamilyValues[] | null;
     };
     files: BinaryFiles;
 }>;

package/dist/types/excalidraw/renderOverrides.d.ts

@@ -0,0 +1,9 @@
+import type { ElementRenderOffsets, ElementRenderOverrides } from "./types";
+/** Validate and copy before publishing, so a rejected snapshot changes nothing. */
+export declare const copyElementRenderOverrides: (overrides: ElementRenderOverrides | null) => ElementRenderOverrides;
+/**
+ * Extracts the offsets of a snapshot, returning `previous` when they are the
+ * same. Visibility is memoized on this map's identity, so a snapshot that only
+ * changes opacities (a fade) never re-runs viewport geometry.
+ */
+export declare const getElementRenderOffsets: (overrides: ElementRenderOverrides, previous: ElementRenderOffsets) => ElementRenderOffsets;

package/dist/types/excalidraw/scene/Renderer.d.ts

@@ -1,7 +1,7 @@
 import type { NonDeletedExcalidrawElement } from "@excalidraw/element/types";
 import type { Scene } from "@excalidraw/element";
 import type { RenderableElementsMap } from "./types";
-import type { AppState } from "../types";
+import type { AppState, ElementRenderOffsets } from "../types";
 type GetRenderableElementsOpts = {
     zoom: AppState["zoom"];
     offsetLeft: AppState["offsetLeft"];
@@ -19,6 +19,19 @@ type GetRenderableElementsOpts = {
 export declare class Renderer {
     private scene;
     constructor(scene: Scene);
+    /**
+     * Adjusts the document-visible set for render-override translations: an
+     * element leaves it when its offset moves it out of view and enters it when
+     * its offset brings it in; everything else keeps its document visibility.
+     * Only translated elements go through viewport geometry. The result is
+     * memoized on the offsets' identity so that opacity-only snapshots don't
+     * reach it at all.
+     */
+    getVisibleElementsWithRenderOffsets(visibleElements: readonly NonDeletedExcalidrawElement[], elementsMap: RenderableElementsMap, appState: AppState, offsets: ElementRenderOffsets): readonly NonDeletedExcalidrawElement[];
+    private _getVisibleElementsWithRenderOffsets;
+    /** the document-visible elements as a set, cached per visible array */
+    private visibleSets;
+    private getVisibleSet;
     private getVisibleCanvasElements;
     private getRenderableElementsMap;
     private sortSelectedElementsIntoHighlightedFrame;

package/dist/types/excalidraw/scene/types.d.ts

@@ -1,7 +1,7 @@
 import type { UserIdleState, EditorInterface } from "@excalidraw/common";
 import type { ExcalidrawElement, NonDeletedElementsMap, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap } from "@excalidraw/element/types";
 import type { MakeBrand } from "@excalidraw/common/utility-types";
-import type { AppClassProperties, AppState, EmbedsValidationStatus, ElementsPendingErasure, InteractiveCanvasAppState, StaticCanvasAppState, SocketId, PendingExcalidrawElements } from "../types";
+import type { AppClassProperties, AppState, EmbedsValidationStatus, ElementRenderOverrides, ElementsPendingErasure, InteractiveCanvasAppState, StaticCanvasAppState, SocketId, PendingExcalidrawElements } from "../types";
 import type { RoughCanvas } from "roughjs/bin/canvas";
 import type { Drawable } from "roughjs/bin/core";
 export type RenderableElementsMap = NonDeletedElementsMap & MakeBrand<"RenderableElementsMap">;
@@ -19,6 +19,7 @@ export type StaticCanvasRenderConfig = {
     elementsPendingErasure: ElementsPendingErasure;
     pendingFlowchartNodes: PendingExcalidrawElements | null;
     theme: AppState["theme"];
+    elementRenderOverrides?: ElementRenderOverrides;
 };
 export type SVGRenderConfig = {
     offsetX: number;

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

@@ -1,9 +1,9 @@
 import type { IMAGE_MIME_TYPES, UserIdleState, throttleRAF, MIME_TYPES, EditorInterface, StrokeWidthKey } from "@excalidraw/common";
 import type { LinearElementEditor } from "@excalidraw/element";
-import type { MaybeTransformHandleType } from "@excalidraw/element";
+import type { ListMarkerAdvance, MaybeTransformHandleType } from "@excalidraw/element";
 import type { PointerType, ExcalidrawLinearElement, NonDeletedExcalidrawElement, NonDeleted, TextAlign, ExcalidrawElement, GroupId, ExcalidrawBindableElement, ExcalidrawArrowElement, Arrowhead, FontFamilyValues, FileId, Theme, StrokeRoundness, ExcalidrawEmbeddableElement, ExcalidrawMagicFrameElement, ExcalidrawFrameLikeElement, ExcalidrawElementType, ExcalidrawIframeLikeElement, OrderedExcalidrawElement, ExcalidrawNonSelectionElement, BindMode, ExcalidrawTextElement, StrokeVariability } from "@excalidraw/element/types";
 import type { Merge, MaybePromise, ValueOf, MakeBrand } from "@excalidraw/common/utility-types";
-import type { CaptureUpdateActionType, DurableIncrement, EphemeralIncrement } from "@excalidraw/element";
+import type { CaptureUpdateActionType, DurableIncrement, EphemeralIncrement, OnDuplicateData } from "@excalidraw/element";
 import type { GlobalPoint } from "@excalidraw/math";
 import type { Action } from "./actions/types";
 import type { Spreadsheet } from "./charts";
@@ -141,7 +141,7 @@ export type InteractiveCanvasAppState = Readonly<_CommonCanvasAppState & {
     isMidpointSnappingEnabled: AppState["isMidpointSnappingEnabled"];
     gridModeEnabled: AppState["gridModeEnabled"];
     suggestedBinding: AppState["suggestedBinding"];
-    hoveredArrowTextAnchor: AppState["hoveredArrowTextAnchor"];
+    textToolHover: AppState["textToolHover"];
     isRotating: AppState["isRotating"];
     elementsToHighlight: AppState["elementsToHighlight"];
     collaborators: AppState["collaborators"];
@@ -260,11 +260,14 @@ export interface AppState {
     bindingPreference: "enabled" | "disabled";
     /** user preference whether arrow snap to midpoints while binding */
     isMidpointSnappingEnabled: boolean;
+    /** user preference whether to show contextual hints above the toolbar */
+    showHints: boolean;
     /**
      * user preference for what the wheel does: with a `trackpad` a plain wheel
-     * pans and ctrl/cmd+wheel (how a pinch is delivered) zooms; with a `mouse`
-     * a plain wheel zooms and ctrl/cmd+wheel pans vertically. `auto` resolves
-     * to `trackpad` until device detection exists — see `resolveInputDevice`
+     * pans; with a `mouse` a plain wheel zooms. Ctrl/cmd+wheel (how a pinch is
+     * delivered) zooms with either device. Shift+wheel pans horizontally;
+     * ctrl/cmd+shift+wheel pans vertically. `auto` resolves to `trackpad` until
+     * device detection exists — see `resolveInputDevice`
      */
     inputDevice: InputDevice;
     /**
@@ -276,11 +279,20 @@ export interface AppState {
         midPoint?: GlobalPoint;
     } | null;
     /**
-     * Where on a hovered arrow the text tool would attach text if clicked —
-     * a free endpoint (binds the arrow to a new text element positioned against
-     * that endpoint) or the arrow's midpoint (adds a label bound to the arrow).
+     * What a text-tool click at the hovered position would act on — the text
+     * it would edit, the empty container it would label, or the arrow anchor
+     * (a free endpoint, or the midpoint for a label) it would attach text to.
+     * `null` when the click would create free text, or the tool isn't active.
+     * Drives the hover affordance only.
      */
-    hoveredArrowTextAnchor: {
+    textToolHover: {
+        type: "text";
+        elementId: ExcalidrawElement["id"];
+    } | {
+        type: "container";
+        elementId: ExcalidrawElement["id"];
+    } | {
+        type: "arrow";
         elementId: ExcalidrawArrowElement["id"];
         anchor: "start" | "end" | "label";
     } | null;
@@ -295,6 +307,10 @@ export interface AppState {
      * frame-like element whose name is currently being edited
      */
     editingFrame: ExcalidrawFrameLikeElement["id"] | null;
+    /**
+     * Elements the UI highlights with a bounding-box outline — those that
+     * would get added to a frame being dragged/resized.
+     */
     elementsToHighlight: readonly NonDeletedExcalidrawElement[] | null;
     /**
      * set when a new text is created or when an existing text is being edited
@@ -456,6 +472,9 @@ export interface AppState {
         stickyNoteStroke: readonly string[] | null;
         stickyNoteBackground: readonly string[] | null;
     };
+    /** user-customized font-picker top picks (pinned via drag & drop from the
+     * font picker popup). `null` means no customization (defaults are used) */
+    fontTopPicks: readonly FontFamilyValues[] | null;
 }
 export type SearchMatch = {
     id: string;
@@ -468,7 +487,7 @@ export type SearchMatch = {
         showOnCanvas: boolean;
     }[];
 };
-export type UIAppState = Omit<AppState, "cursorButton" | "scrollX" | "scrollY" | "zoom" | "shouldCacheIgnoreZoom" | "snapLines" | "originSnapOffset" | "suggestedBinding" | "hoveredArrowTextAnchor" | "frameToHighlight" | "elementsToHighlight">;
+export type UIAppState = Omit<AppState, "cursorButton" | "scrollX" | "scrollY" | "zoom" | "shouldCacheIgnoreZoom" | "snapLines" | "originSnapOffset" | "suggestedBinding" | "textToolHover" | "frameToHighlight" | "elementsToHighlight">;
 export type NormalizedZoomValue = number & {
     _brand: "normalizedZoom";
 };
@@ -647,6 +666,20 @@ export type UIConfig = {
         scrollBackToContent?: boolean;
     };
 };
+/** Supported visual changes. Geometry, content, bindings and styles are not overridable. */
+export type ElementRenderOverride = Readonly<{
+    /** Absolute render opacity (0–100, clamped). Omitted: use element.opacity. */
+    opacity?: number;
+    /** Translation in scene units. Bound labels inherit their container's offset and ignore this field. */
+    offset?: Readonly<{
+        x: number;
+        y: number;
+    }>;
+}>;
+/** see {@link ExcalidrawImperativeAPI.setElementRenderOverrides} for details */
+export type ElementRenderOverrides = ReadonlyMap<ExcalidrawElement["id"], ElementRenderOverride>;
+/** The translation part of a snapshot: only the entries that carry an offset. */
+export type ElementRenderOffsets = ReadonlyMap<ExcalidrawElement["id"], NonNullable<ElementRenderOverride["offset"]>>;
 export interface ExcalidrawProps {
     className?: string;
     /**
@@ -704,11 +737,27 @@ export interface ExcalidrawProps {
      *
      * Returned elements will be used in place of the next elements
      * (you should return all elements, including deleted, and not mutate
-     * the element if changes are made)
+     * the element if changes are made).
+     *
+     * The duplicates are the elements in `nextElements` which are not in
+     * `prevElements` (see also `data.duplicateElements`). When pasting or
+     * inserting onto a frame, their `frameId` is already set. To change a
+     * duplicate, return a new object with the same `id`. It is shallow-merged
+     * into the duplicate (omitted properties are kept), and your changes are
+     * part of the duplication itself (same undo entry, same durable increment).
+     *
+     * To prevent an element from being duplicated, omit its duplicate from the
+     * returned array. References to it from the remaining duplicates are
+     * cleared, and a bound text isn't duplicated without its container. To
+     * prevent the duplication as a whole, return `false`. If no duplicate
+     * remains, the duplication is cancelled and the returned elements are
+     * ignored (alt-drag then moves the original elements instead).
      */
     onDuplicate?: (nextElements: readonly ExcalidrawElement[], 
     /** excludes the duplicated elements */
-    prevElements: readonly ExcalidrawElement[]) => ExcalidrawElement[] | void;
+    prevElements: readonly ExcalidrawElement[], 
+    /** lookups covering just the elements taking part in the duplication */
+    data: OnDuplicateData) => ExcalidrawElement[] | void | false;
     renderTopLeftUI?: (isMobile: boolean, appState: UIAppState) => JSX.Element | null;
     renderTopRightUI?: (isMobile: boolean, appState: UIAppState) => JSX.Element | null;
     langCode?: Language["code"];
@@ -927,7 +976,7 @@ export type AppClassProperties = {
     scene: App["scene"];
     syncActionResult: App["syncActionResult"];
     fonts: App["fonts"];
-    pasteFromClipboard: App["pasteFromClipboard"];
+    clipboard: App["clipboard"];
     id: App["id"];
     onInsertElements: App["onInsertElements"];
     onExportImage: App["onExportImage"];
@@ -945,10 +994,14 @@ export type AppClassProperties = {
     flowchart: App["flowchart"];
     drawShape: App["drawShape"];
     arrowText: App["arrowText"];
+    textTool: App["textTool"];
     cursor: App["cursor"];
     bucketFill: App["bucketFill"];
+    duplicate: App["duplicate"];
     toolDrag: App["toolDrag"];
     activeResizeHandle: App["activeResizeHandle"];
+    selectionTool: App["selectionTool"];
+    modifiers: App["modifiers"];
     isToolLocked: App["isToolLocked"];
     getEffectiveGridSize: App["getEffectiveGridSize"];
     setPlugins: App["setPlugins"];
@@ -1001,7 +1054,10 @@ export type PointerDownState = Readonly<{
         element: NonDeleted<ExcalidrawElement> | null;
         allHitElements: NonDeleted<ExcalidrawElement>[];
         wasAddedToSelection: boolean;
+        cycleTarget: NonDeleted<ExcalidrawElement> | null;
         hasBeenDuplicated: boolean;
+        advancedListMarkers: readonly ListMarkerAdvance[];
+        editedTextId: ExcalidrawTextElement["id"] | null;
         hasHitCommonBoundingBoxOfSelectedElements: boolean;
         arrowLabel: boolean;
     };
@@ -1057,6 +1113,22 @@ export interface ExcalidrawImperativeAPI {
     getName: InstanceType<typeof App>["getName"];
     setViewport: InstanceType<typeof App>["viewport"]["setViewport"];
     getViewportOffsets: InstanceType<typeof App>["viewport"]["getOffsets"];
+    /**
+     * Atomically replaces all transient visual overrides. Values are copied;
+     * omitted IDs/fields use document values, except for inherited label offsets.
+     * null clears the snapshot.
+     * Repaints without document changes, history entries or onChange events;
+     * an equivalent snapshot may still repaint (clearing an already clear
+     * snapshot does not), so submit only when something changed.
+     * Finite opacity is clamped to 0–100; non-finite values reject the snapshot.
+     * Unknown/deleted IDs are ignored when rendering. Reset/unmount clears it.
+     * Bound labels inherit their container's offset; offsets targeting them are
+     * ignored. Label opacity remains independent. Target frame children explicitly.
+     * Frame opacity still multiplies child opacity. Decorations follow their owner.
+     * Exports and interactive geometry (hit tests, selection, editing) use document
+     * values, including while authoring an animation preview in edit mode.
+     */
+    setElementRenderOverrides: InstanceType<typeof App>["setElementRenderOverrides"];
     registerAction: (action: Action) => void;
     refresh: InstanceType<typeof App>["refresh"];
     setToast: InstanceType<typeof App>["setToast"];
@@ -1219,9 +1291,10 @@ export type ViewportOffsets = Offsets & {
 /**
  * Value of the `data-viewport-ui-name` attribute, identifying a
  * conditionally-rendered surface (marked with `data-viewport-ui`) so that
- * `getViewportOffsets` can reserve space for it while it's hidden (see the
- * `reserve` option). Whenever a named surface is rendered, its measured
- * footprint is remembered; reserving uses that remembered footprint, or an
- * approximate default if the surface hasn't been rendered yet.
+ * it can be measured on its own, and so that `getViewportOffsets` can
+ * reserve space for it while it's hidden (see the `reserve` option).
+ * Whenever a named surface is rendered, its measured footprint is
+ * remembered; reserving uses that remembered footprint, or an approximate
+ * default if the surface hasn't been rendered yet.
  */
-export type ViewportUIName = "sidebar" | "stylesPanel";
+export type ViewportUIName = "sidebar" | "stylesPanel" | "stats";

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

@@ -108,12 +108,20 @@ export declare const zoomToFitBounds: ({ bounds, appState, canvasOffsets, fit, m
         boxSelectionMode: import("./types").BoxSelectionMode;
         bindingPreference: "enabled" | "disabled";
         isMidpointSnappingEnabled: boolean;
+        showHints: boolean;
         inputDevice: import("./types").InputDevice;
         suggestedBinding: {
             element: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawBindableElement>;
             midPoint?: import("@excalidraw/math").GlobalPoint;
         } | null;
-        hoveredArrowTextAnchor: {
+        textToolHover: {
+            type: "text";
+            elementId: ExcalidrawElement["id"];
+        } | {
+            type: "container";
+            elementId: ExcalidrawElement["id"];
+        } | {
+            type: "arrow";
             elementId: import("@excalidraw/element/types").ExcalidrawArrowElement["id"];
             anchor: "start" | "end" | "label";
         } | null;
@@ -254,6 +262,7 @@ export declare const zoomToFitBounds: ({ bounds, appState, canvasOffsets, fit, m
             stickyNoteStroke: readonly string[] | null;
             stickyNoteBackground: readonly string[] | null;
         };
+        fontTopPicks: readonly import("@excalidraw/element/types").FontFamilyValues[] | null;
     };
     captureUpdate: "EVENTUALLY";
 };
@@ -273,6 +282,19 @@ export declare const centerScrollOn: ({ scenePoint, viewportDimensions, zoom, of
     scrollX: number;
     scrollY: number;
 };
+/**
+ * The scroll that brings `bounds` into the viewport — less `offsets` (screen
+ * px: UI covering its edges, room to leave) — by the least movement, keeping
+ * the zoom; `null` when they're in view already. Along an axis where they
+ * don't fit, their start (left / top) is brought in instead, or, with
+ * `tooLarge: "leave"`, that axis keeps its scroll.
+ */
+export declare const scrollBoundsIntoView: ({ bounds: [x1, y1, x2, y2], appState: { scrollX, scrollY, zoom, width, height }, offsets, tooLarge, }: {
+    bounds: Bounds;
+    appState: Pick<AppState, "scrollX" | "scrollY" | "zoom" | "width" | "height">;
+    offsets?: Offsets;
+    tooLarge?: "alignStart" | "leave";
+}) => Pick<AppState, "scrollX" | "scrollY"> | null;
 export declare const getScrollToContentState: (elements: readonly ExcalidrawElement[], appState: AppState) => {
     scrollX: number;
     scrollY: number;

package/dist/types/excalidraw/wysiwyg/textWysiwyg.d.ts

@@ -1,7 +1,13 @@
 import type { ExcalidrawTextElement } from "@excalidraw/element/types";
 import type App from "../components/App";
+/**
+ * How much further than the browser's caret reveal the canvas pans, in
+ * screen px: text typed past the viewport's edge comes back with this much
+ * room to spare, instead of flush against the edge.
+ */
+export declare const CARET_FOLLOW_PADDING = 5;
 type SubmitHandler = () => void;
-export declare const textWysiwyg: ({ onChange, onSubmit, getViewportCoords, element, canvas, excalidrawContainer, app, autoSelect, initialCaretSceneCoords, }: {
+export declare const textWysiwyg: ({ onChange, onSubmit, getViewportCoords, element, canvas, excalidrawContainer, app, autoSelect, initialCaretSceneCoords, initialSelection, }: {
     /**
      * textWysiwyg only deals with `originalText`
      *
@@ -23,5 +29,10 @@ export declare const textWysiwyg: ({ onChange, onSubmit, getViewportCoords, elem
         x: number;
         y: number;
     } | null;
+    /** range of `originalText` to select (takes precedence over the caret) */
+    initialSelection?: {
+        start: number;
+        end: number;
+    } | null;
 }) => SubmitHandler;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@excalidraw/math",
-  "version": "0.18.0-4e758db",
+  "version": "0.18.0-4f68076",
   "type": "module",
   "types": "./dist/types/math/src/index.d.ts",
   "main": "./dist/prod/index.js",
@@ -61,6 +61,6 @@
     "build:esm": "rimraf dist && node ../../scripts/buildBase.js && yarn gen:types"
   },
   "dependencies": {
-    "@excalidraw/common": "0.18.0-4e758db"
+    "@excalidraw/common": "0.18.0-4f68076"
   }
 }

package/dist/types/excalidraw/components/ColorPicker/topPicksDnD.d.ts

@@ -1,31 +0,0 @@
-type DragOrigin = {
-    kind: "swatch";
-} | {
-    kind: "pick";
-    index: number;
-};
-export type TopPicksDragState = {
-    color: string;
-    origin: DragOrigin;
-    /** hovered strip slot — the slot to replace (swatch drags) or the final
-     * position (pick reorders). null while the pointer is outside the strip */
-    overIndex: number | null;
-    /** index of an already-pinned identical color that blocks the drop */
-    duplicateIndex: number | null;
-    /** signed distance between strip slot centers (for reorder preview) */
-    slotSpan: number;
-} | null;
-export type ColorPickerDnD = {
-    dragState: TopPicksDragState;
-    startSwatchDrag: (event: React.PointerEvent, color: string | null) => void;
-    startPickDrag: (event: React.PointerEvent, index: number, color: string) => void;
-    setStripEl: (el: HTMLDivElement | null) => void;
-};
-export declare const ColorPickerDnDContext: import("react").Context<ColorPickerDnD | null>;
-export declare const useColorPickerDnD: () => ColorPickerDnD | null;
-export declare const useTopPicksDnD: ({ enabled, picks, onPicksChange, }: {
-    enabled: boolean;
-    picks: readonly string[];
-    onPicksChange: (picks: string[]) => void;
-}) => ColorPickerDnD;
-export {};