@excalidraw/common 0.18.0-3bdaafe → 0.18.0-3c916c5

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

@@ -1,31 +1,299 @@
-import type { ExcalidrawFrameLikeElement, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
+import { MIME_TYPES } from "@excalidraw/common";
+import type { RenderEnvironment } from "@excalidraw/element";
+import type { ExcalidrawFrameLikeElement, NonDeleted, NonDeletedExcalidrawElement, Theme } from "@excalidraw/element/types";
+import { cleanAppStateForExport } from "../appState";
 import type { AppState, BinaryFiles } from "../types";
-export declare const exportToCanvas: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState, files: BinaryFiles, { exportBackground, exportPadding, viewBackgroundColor, exportingFrame, }: {
-    exportBackground: boolean;
-    exportPadding?: number | undefined;
-    viewBackgroundColor: string;
-    exportingFrame?: ExcalidrawFrameLikeElement | null | undefined;
-}, createCanvas?: (width: number, height: number) => {
-    canvas: HTMLCanvasElement;
+export type ExportSceneData = {
+    elements: readonly NonDeletedExcalidrawElement[];
+    /**
+     * The scene settings a `.excalidraw` file stores (`viewBackgroundColor`,
+     * grid settings) — not editor state. Used as the default background
+     * (`canvasBackgroundColor`) and embedded with the scene (`embedScene`).
+     * Anything else passed in is ignored; rendering options go to `config`.
+     */
+    appState?: ReturnType<typeof cleanAppStateForExport>;
+    files?: BinaryFiles | null;
+};
+/**
+ * The host capabilities an export uses, shared by every format: e.g. for test
+ * environments, Node.js or another window.
+ *
+ * Unlike the editor's `renderEnvironment` prop, this needn't be the same
+ * object across exports (e.g. on a server): exports draw without the element
+ * caches keyed by an environment, and measure little text. Passing a complete
+ * one (`createCanvas` and `createImage`) as-is, as the editor does, only keeps
+ * its measuring caches warm.
+ */
+type ExportEnvironment = {
+    /**
+     * Creates the canvas a canvas/PNG/JPEG export renders into, and any canvas
+     * the export measures text with (e.g. frame labels, embed placeholders).
+     *
+     * Do not set `canvas.width/height` or modify the canvas context as that's
+     * handled by Excalidraw.
+     *
+     * Defaults to `document.createElement("canvas")`.
+     */
+    createCanvas?: RenderEnvironment["createCanvas"];
+    /**
+     * Creates the images that image elements are decoded into.
+     *
+     * Defaults to `new Image()`.
+     */
+    createImage?: RenderEnvironment["createImage"];
+    /**
+     * Creates the paths that freedraw elements are filled through.
+     *
+     * Defaults to the global `Path2D`.
+     */
+    createPath?: RenderEnvironment["createPath"];
+    /**
+     * The document an SVG export is built in, e.g. a popout window's or,
+     * outside the browser, a DOM implementation's (such as `linkedom`).
+     *
+     * Defaults to the global `document`.
+     */
+    document?: RenderEnvironment["document"];
+    /**
+     * Measures text (frame labels, embed placeholders), e.g. where there is no
+     * canvas to measure on.
+     *
+     * Defaults to the global provider set with `setCustomTextMetricsProvider`,
+     * else to measuring on a canvas from `createCanvas`.
+     */
+    textMetrics?: RenderEnvironment["textMetrics"];
+    /**
+     * Loads the fonts the exported elements use, before rendering.
+     *
+     * Defaults to loading them through the browser's
+     * [FontFace API](https://developer.mozilla.org/en-US/docs/Web/API/FontFace).
+     */
+    loadFonts?: () => Promise<void>;
+};
+type ExportSceneBaseConfig = {
+    /**
+     * @default "light"
+     */
+    theme?: Theme;
+    /**
+     * Canvas background. Valid values are:
+     *
+     * - `undefined` - the background of "appState.viewBackgroundColor" is used.
+     * - `false` - no background is used (transparent). Not supported for JPEG,
+     *   which falls back to the default.
+     * - `string` - should be a valid CSS color.
+     *
+     * Specified in light-theme terms: `theme: "dark"` transforms it like any
+     * other scene color. Only affects the rendered image, not the embedded
+     * scene (`embedScene`).
+     *
+     * @default undefined
+     */
+    canvasBackgroundColor?: string | false;
+    /**
+     * Canvas padding in pixels. Affected by `scale`.
+     *
+     * When `fit` is `none`, padding is added around the content bounding box,
+     * or around the `width`/`height` frame if set — in which case the content
+     * may overflow the frame, thus right or bottom padding may be ignored.
+     *
+     * When `fit` is `contain`, or `maxWidthOrHeight`/`widthOrHeight` is set,
+     * padding is subtracted from the target size (so the export doesn't exceed
+     * it, `scale` aside), and serves as a minimum distance between the content
+     * and the canvas edges — it may be exceeded on one axis to maintain the
+     * aspect ratio. It is recommended to set `position` to `center` when using
+     * `fit: "contain"`.
+     *
+     * @default 10
+     */
+    padding?: number;
+    /**
+     * A multiplier to increase/decrease the frame dimensions
+     * (content resolution).
+     *
+     * For example, if your canvas is 300x150 and you set scale to 2, the
+     * resulting size will be 600x300.
+     *
+     * Can be a function, which receives the export dimensions at scale 1
+     * (padding included) and returns the multiplier — e.g. to cap the output
+     * by a pixel budget.
+     *
+     * @default 1
+     */
+    scale?: number | ((width: number, height: number) => number);
+    /**
+     * Host environment overrides, e.g. for test environments or Node.js.
+     */
+    environment?: ExportEnvironment;
+    exportingFrame?: NonDeleted<ExcalidrawFrameLikeElement> | null;
+    /**
+     * Which frame decorations to render. Ignored when exporting a single frame
+     * (`exportingFrame`), which renders neither its name nor outline, and clips
+     * to it.
+     *
+     * @default { name: true, outline: true, clip: true }
+     */
+    frames?: {
+        name?: boolean;
+        outline?: boolean;
+        clip?: boolean;
+    };
+};
+/**
+ * The ways to size the export — only one can be used. The positioning options
+ * (`fit`, `position`, `x`, `y`, `origin`) belong to `width`/`height` (or no
+ * size option).
+ */
+type ExportSizeOptions = {
+    /**
+     * Makes sure the canvas content fits into a frame of width/height no larger
+     * than this value, while maintaining the aspect ratio.
+     *
+     * Final dimensions can get smaller/larger if used in conjunction with
+     * `scale`.
+     *
+     * Can't be combined with `width`/`height`, `widthOrHeight`, or the
+     * positioning options (`fit`, `position`, `x`, `y`, `origin`).
+     */
+    maxWidthOrHeight?: number;
+    /**
+     * Scale the canvas content to be exactly this many pixels wide/tall,
+     * maintaining the aspect ratio.
+     *
+     * Final dimensions can get smaller/larger if used in conjunction with
+     * `scale`.
+     *
+     * Can't be combined with `width`/`height`, `maxWidthOrHeight`, or the
+     * positioning options (`fit`, `position`, `x`, `y`, `origin`).
+     */
+    widthOrHeight?: number;
+    /**
+     * Width of the frame. Supply `x` or `y` if you want to offset the canvas
+     * content.
+     *
+     * If `width` omitted but `height` supplied, `width` is calculated from the
+     * content's aspect ratio when `fit` is `contain` (the default), or is the
+     * content bounding box width when `fit` is `none`.
+     *
+     * Defaults to the content bounding box width when both `width` and `height`
+     * are omitted.
+     *
+     * Can't be combined with `maxWidthOrHeight` or `widthOrHeight`.
+     */
+    width?: number;
+    /**
+     * Height of the frame.
+     *
+     * If `height` omitted but `width` supplied, `height` is calculated from the
+     * content's aspect ratio when `fit` is `contain` (the default), or is the
+     * content bounding box height when `fit` is `none`.
+     *
+     * Defaults to the content bounding box height when both `width` and `height`
+     * are omitted.
+     *
+     * Can't be combined with `maxWidthOrHeight` or `widthOrHeight`.
+     */
+    height?: number;
+    /**
+     * Left edge of the exported region (`padding` is added around it). By
+     * default the coordinate is relative to the canvas. You can switch to
+     * content coordinates by setting `origin` to `content`.
+     *
+     * Defaults to the `x` position of the content bounding box.
+     *
+     * Can't be combined with `maxWidthOrHeight` or `widthOrHeight`, and is
+     * ignored with `fit: "contain"`, so setting `x` or `y` makes `fit` default
+     * to `none` (cropping the region).
+     */
+    x?: number;
+    /**
+     * Top edge of the exported region (`padding` is added around it). By
+     * default the coordinate is relative to the canvas. You can switch to
+     * content coordinates by setting `origin` to `content`.
+     *
+     * Defaults to the `y` position of the content bounding box.
+     *
+     * Can't be combined with `maxWidthOrHeight` or `widthOrHeight`, and is
+     * ignored with `fit: "contain"`, so setting `x` or `y` makes `fit` default
+     * to `none` (cropping the region).
+     */
+    y?: number;
+    /**
+     * Indicates the coordinate system of the `x` and `y` values.
+     *
+     * - `canvas` - `x` and `y` are relative to the canvas [0, 0] position.
+     * - `content` - `x` and `y` are relative to the content bounding box.
+     *
+     * Can't be combined with `maxWidthOrHeight` or `widthOrHeight`.
+     *
+     * @default "canvas"
+     */
+    origin?: "canvas" | "content";
+    /**
+     * How the content should be scaled into the `width`/`height` frame.
+     *
+     * Behavior aligns with the `object-fit` CSS property.
+     *
+     * - `none`    - no scaling.
+     * - `contain` - scale to fit the frame. Includes `padding`.
+     *
+     * Can't be combined with `maxWidthOrHeight` or `widthOrHeight`.
+     *
+     * @default "contain" if `width` or `height` is set (and `x`/`y` aren't),
+     * otherwise "none"
+     */
+    fit?: "none" | "contain";
+    /**
+     * When either `x` or `y` are not specified, indicates how the canvas should
+     * be aligned on the respective axis.
+     *
+     * - `topLeft` - canvas aligned to top left.
+     * - `center`  - canvas is centered on the axis which is not specified
+     *               (or both).
+     *
+     * Can't be combined with `maxWidthOrHeight` or `widthOrHeight`.
+     *
+     * @default "center"
+     */
+    position?: "center" | "topLeft";
+};
+type ExportSizeOption<K extends keyof ExportSizeOptions> = Pick<ExportSizeOptions, K> & {
+    [P in keyof ExportSizeOptions as P extends K ? never : P]?: never;
+};
+type ExportSizeConfig = ExportSizeOption<"width" | "height" | "fit" | "position" | "x" | "y" | "origin"> | ExportSizeOption<"maxWidthOrHeight"> | ExportSizeOption<"widthOrHeight">;
+export type ExportSceneConfig = ExportSceneBaseConfig & ExportSizeConfig;
+/**
+ * The export config the editor's export settings translate to. Internal: hosts
+ * pass their own config.
+ */
+export declare const getExportConfigFromAppState: (appState: Pick<AppState, "exportWithDarkMode" | "exportBackground" | "viewBackgroundColor" | "exportScale" | "frameRendering">) => {
+    theme: "light" | "dark";
+    canvasBackgroundColor: string | false;
     scale: number;
-}, loadFonts?: () => Promise<void>) => Promise<HTMLCanvasElement>;
-export declare const exportToSvg: (elements: readonly NonDeletedExcalidrawElement[], appState: {
-    exportBackground: boolean;
-    exportPadding?: number;
-    exportScale?: number;
-    viewBackgroundColor: string;
-    exportWithDarkMode?: boolean;
-    exportEmbedScene?: boolean;
-    frameRendering?: AppState["frameRendering"];
-}, files: BinaryFiles | null, opts?: {
+    frames: {
+        enabled: boolean;
+        name: boolean;
+        outline: boolean;
+        clip: boolean;
+    } | {
+        name: boolean;
+        outline: boolean;
+        clip: boolean;
+    };
+};
+type ExportToSvgConfig = Pick<ExportSceneBaseConfig, "canvasBackgroundColor" | "padding" | "theme" | "exportingFrame" | "scale" | "frames" | "environment"> & ExportSizeConfig & {
     /**
      * if true, all embeddables passed in will be rendered when possible.
      */
     renderEmbeddables?: boolean;
-    exportingFrame?: ExcalidrawFrameLikeElement | null;
     skipInliningFonts?: true;
     reuseImages?: boolean;
-}) => Promise<SVGSVGElement>;
+    /**
+     * Embeds the scene into the SVG, so that it can be imported back into
+     * Excalidraw.
+     */
+    embedScene?: boolean;
+};
 export declare const encodeSvgBase64Payload: ({ payload, metadataElement, }: {
     payload: string;
     metadataElement: SVGMetadataElement;
@@ -33,4 +301,59 @@ export declare const encodeSvgBase64Payload: ({ payload, metadataElement, }: {
 export declare const decodeSvgBase64Payload: ({ svg }: {
     svg: string;
 }) => string;
-export declare const getExportSize: (elements: readonly NonDeletedExcalidrawElement[], exportPadding: number, scale: number) => [number, number];
+export { MIME_TYPES };
+type ExportToPngConfig = ExportSceneConfig & {
+    /**
+     * Embeds the scene into the PNG metadata, so that it can be imported back
+     * into Excalidraw.
+     */
+    embedScene?: boolean;
+};
+type ExportToJpegConfig = ExportSceneConfig & {
+    /**
+     * Encoding quality between 0 and 1.
+     *
+     * @default 0.92
+     */
+    quality?: number;
+};
+export type ExportSceneOptions = {
+    data: ExportSceneData;
+} & ({
+    type: "canvas";
+    config?: ExportSceneConfig;
+} | {
+    type: "png";
+    config?: ExportToPngConfig;
+} | {
+    type: "jpeg";
+    config?: ExportToJpegConfig;
+} | {
+    type: "svg";
+    config?: ExportToSvgConfig;
+});
+/**
+ * Exports the scene to a canvas, a PNG or JPEG blob, or an SVG element.
+ */
+export declare function exportScene(opts: Extract<ExportSceneOptions, {
+    type: "canvas";
+}>): Promise<HTMLCanvasElement>;
+export declare function exportScene(opts: Extract<ExportSceneOptions, {
+    type: "png" | "jpeg";
+}>): Promise<Blob>;
+export declare function exportScene(opts: Extract<ExportSceneOptions, {
+    type: "svg";
+}>): Promise<SVGSVGElement>;
+export declare function exportScene(opts: ExportSceneOptions): Promise<HTMLCanvasElement | Blob | SVGSVGElement>;
+export declare const exportToClipboard: (opts: {
+    data: ExportSceneData;
+} & ({
+    type: "png";
+    config?: ExportToPngConfig;
+} | {
+    type: "svg";
+    config?: ExportToSvgConfig;
+} | {
+    type: "json";
+    config?: never;
+})) => Promise<void>;

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

@@ -1,4 +1,4 @@
 export { isSomeElementSelected, getElementsWithinSelection, getSelectedElements, getTargetElements, } from "@excalidraw/element";
-export { calculateScrollCenter } from "./scroll";
-export { hasBackground, hasStrokeWidth, hasStrokeStyle, canHaveArrowheads, canChangeRoundness, } from "@excalidraw/element";
+export { getScrollToContentState } from "../viewport";
+export { hasBackground, hasFillStyle, hasRoughness, hasStrokeWidth, hasStrokeStyle, hasFreedrawMode, canHaveArrowheads, canChangeRoundness, } from "@excalidraw/element";
 export { getNormalizedZoom, getNormalizedGridSize, getNormalizedGridStep, } from "./normalize";

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

@@ -1,22 +1,49 @@
-import type { UserIdleState } from "@excalidraw/common";
-import type { ExcalidrawElement, NonDeletedElementsMap, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap } from "@excalidraw/element/types";
+import type { UserIdleState, EditorInterface } from "@excalidraw/common";
+import type { ExcalidrawElement, ExcalidrawFrameLikeElement, NonDeletedElementsMap, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap } from "@excalidraw/element/types";
 import type { MakeBrand } from "@excalidraw/common/utility-types";
-import type { AppClassProperties, AppState, EmbedsValidationStatus, ElementsPendingErasure, InteractiveCanvasAppState, StaticCanvasAppState, SocketId, Device, PendingExcalidrawElements } from "../types";
+import type { RenderEnvironment } from "@excalidraw/element/renderEnvironment";
+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">;
 export type StaticCanvasRenderConfig = {
     canvasBackgroundColor: AppState["viewBackgroundColor"];
+    /**
+     * Backing-store scale the target canvas was bootstrapped with -- the owner
+     * window's devicePixelRatio when rendering into the editor, exportScale when
+     * exporting. Element caches are built and blitted at this ratio, so it must
+     * be the same value passed as `StaticSceneRenderConfig["scale"]`.
+     */
+    scale: number;
+    /**
+     * Host environment that creates the canvases and images this render
+     * rasterizes (per-editor owner window in the app; the export's
+     * `config.environment` when exporting). Defaults to the browser's.
+     */
+    renderEnvironment?: RenderEnvironment;
+    /** export only: clips everything drawn to this frame (square corners) */
+    clipToFrame?: ExcalidrawFrameLikeElement | null;
     imageCache: AppClassProperties["imageCache"];
     renderGrid: boolean;
+    /** whether to render link icons on elements with links (never rendered
+     when exporting). @default true */
+    renderLinks?: boolean;
     /** when exporting the behavior is slightly different (e.g. we can't use
      CSS filters), and we disable render optimizations for best output */
     isExporting: boolean;
     embedsValidationStatus: EmbedsValidationStatus;
     elementsPendingErasure: ElementsPendingErasure;
     pendingFlowchartNodes: PendingExcalidrawElements | null;
+    theme: AppState["theme"];
+    elementRenderOverrides?: ElementRenderOverrides;
 };
 export type SVGRenderConfig = {
+    /**
+     * Host environment used for the text measurements this render needs (the
+     * SVG itself is built through `exportToSvg`'s owner document). Defaults to
+     * the browser's.
+     */
+    renderEnvironment?: RenderEnvironment;
     offsetX: number;
     offsetY: number;
     isExporting: boolean;
@@ -32,6 +59,7 @@ export type SVGRenderConfig = {
      * @default true
      */
     reuseImages: boolean;
+    theme: AppState["theme"];
 };
 export type InteractiveCanvasRenderConfig = {
     remoteSelectedElementIds: Map<ExcalidrawElement["id"], SocketId[]>;
@@ -43,11 +71,13 @@ export type InteractiveCanvasRenderConfig = {
     remotePointerUsernames: Map<SocketId, string>;
     remotePointerButton: Map<SocketId, string | undefined>;
     selectionColor: string;
+    lastViewportPosition: {
+        x: number;
+        y: number;
+    };
     renderScrollbars?: boolean;
 };
 export type RenderInteractiveSceneCallback = {
-    atLeastOneVisibleElement: boolean;
-    elementsMap: RenderableElementsMap;
     scrollBars?: ScrollBars;
 };
 export type StaticSceneRenderConfig = {
@@ -60,7 +90,13 @@ export type StaticSceneRenderConfig = {
     appState: StaticCanvasAppState;
     renderConfig: StaticCanvasRenderConfig;
 };
+export type InteractiveSceneRenderAnimationState = {
+    bindingHighlight: {
+        runtime: number;
+    } | undefined;
+};
 export type InteractiveSceneRenderConfig = {
+    app: AppClassProperties;
     canvas: HTMLCanvasElement | null;
     elementsMap: RenderableElementsMap;
     visibleElements: readonly NonDeletedExcalidrawElement[];
@@ -69,13 +105,15 @@ export type InteractiveSceneRenderConfig = {
     scale: number;
     appState: InteractiveCanvasAppState;
     renderConfig: InteractiveCanvasRenderConfig;
-    device: Device;
+    editorInterface: EditorInterface;
     callback: (data: RenderInteractiveSceneCallback) => void;
+    animationState?: InteractiveSceneRenderAnimationState;
+    deltaTime: number;
 };
 export type NewElementSceneRenderConfig = {
     canvas: HTMLCanvasElement | null;
     rc: RoughCanvas;
-    newElement: ExcalidrawElement | null;
+    newElement: NonDeletedExcalidrawElement | null;
     elementsMap: RenderableElementsMap;
     allElementsMap: NonDeletedSceneElementsMap;
     scale: number;
@@ -103,17 +141,21 @@ export type ScrollBars = {
         deltaMultiplier: number;
     } | null;
 };
-export type ElementShape = Drawable | Drawable[] | null;
+export type SVGPathString = string & {
+    __brand: "SVGPathString";
+};
+export type ElementShape = Drawable | Drawable[] | Path2D | (Drawable | SVGPathString)[] | null;
 export type ElementShapes = {
     rectangle: Drawable;
     ellipse: Drawable;
     diamond: Drawable;
     iframe: Drawable;
     embeddable: Drawable;
-    freedraw: Drawable | null;
+    freedraw: (Drawable | SVGPathString)[];
     arrow: Drawable[];
     line: Drawable[];
     text: null;
+    stickynote: null;
     image: null;
     frame: null;
     magicframe: null;

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

@@ -0,0 +1 @@
+export declare const getShortcutKey: (shortcut: string) => string;

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

@@ -1,6 +1,6 @@
 import { type GlobalPoint } from "@excalidraw/math";
 import type { InclusiveRange } from "@excalidraw/math";
-import type { Bounds } from "@excalidraw/element";
+import type { Bounds } from "@excalidraw/common";
 import type { MaybeTransformHandleType } from "@excalidraw/element";
 import type { ElementsMap, ExcalidrawElement, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
 import type { AppClassProperties, AppState, KeyboardModifiersObject } from "./types";
@@ -66,19 +66,19 @@ export declare const isGridModeEnabled: (app: AppClassProperties) => boolean;
 export declare const isSnappingEnabled: ({ event, app, selectedElements, }: {
     app: AppClassProperties;
     event: KeyboardModifiersObject;
-    selectedElements: NonDeletedExcalidrawElement[];
+    selectedElements: readonly NonDeletedExcalidrawElement[];
 }) => boolean;
 export declare const areRoughlyEqual: (a: number, b: number, precision?: number) => boolean;
-export declare const getElementsCorners: (elements: ExcalidrawElement[], elementsMap: ElementsMap, { omitCenter, boundingBoxCorners, dragOffset, }?: {
-    omitCenter?: boolean | undefined;
-    boundingBoxCorners?: boolean | undefined;
-    dragOffset?: Vector2D | undefined;
+export declare const getElementsCorners: (elements: readonly NonDeletedExcalidrawElement[], elementsMap: ElementsMap, { omitCenter, boundingBoxCorners, dragOffset, }?: {
+    omitCenter?: boolean;
+    boundingBoxCorners?: boolean;
+    dragOffset?: Vector2D;
 }) => GlobalPoint[];
-export declare const getVisibleGaps: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: ExcalidrawElement[], appState: AppState, elementsMap: ElementsMap) => {
+export declare const getVisibleGaps: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: readonly NonDeletedExcalidrawElement[], appState: AppState, elementsMap: ElementsMap) => {
     horizontalGaps: Gap[];
     verticalGaps: Gap[];
 };
-export declare const getReferenceSnapPoints: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: ExcalidrawElement[], appState: AppState, elementsMap: ElementsMap) => GlobalPoint[];
+export declare const getReferenceSnapPoints: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: readonly NonDeletedExcalidrawElement[], appState: AppState, elementsMap: ElementsMap) => GlobalPoint[];
 export declare const snapDraggedElements: (elements: ExcalidrawElement[], dragOffset: Vector2D, app: AppClassProperties, event: KeyboardModifiersObject, elementsMap: ElementsMap) => {
     snapOffset: {
         x: number;
@@ -86,26 +86,26 @@ export declare const snapDraggedElements: (elements: ExcalidrawElement[], dragOf
     };
     snapLines: (PointSnapLine | GapSnapLine)[];
 };
-export declare const snapResizingElements: (selectedElements: ExcalidrawElement[], selectedOriginalElements: ExcalidrawElement[], app: AppClassProperties, event: KeyboardModifiersObject, dragOffset: Vector2D, transformHandle: MaybeTransformHandleType) => {
+export declare const snapResizingElements: (selectedElements: readonly NonDeletedExcalidrawElement[], selectedOriginalElements: readonly NonDeletedExcalidrawElement[], app: AppClassProperties, event: KeyboardModifiersObject, dragOffset: Vector2D, transformHandle: MaybeTransformHandleType) => {
     snapOffset: {
         x: number;
         y: number;
     };
     snapLines: PointSnapLine[];
 };
-export declare const snapNewElement: (newElement: ExcalidrawElement, app: AppClassProperties, event: KeyboardModifiersObject, origin: Vector2D, dragOffset: Vector2D, elementsMap: ElementsMap) => {
+export declare const snapNewElement: (newElement: NonDeletedExcalidrawElement, app: AppClassProperties, event: KeyboardModifiersObject, origin: Vector2D, dragOffset: Vector2D, elementsMap: ElementsMap) => {
     snapOffset: {
         x: number;
         y: number;
     };
     snapLines: PointSnapLine[];
 };
-export declare const getSnapLinesAtPointer: (elements: readonly ExcalidrawElement[], app: AppClassProperties, pointer: Vector2D, event: KeyboardModifiersObject, elementsMap: ElementsMap) => {
+export declare const getSnapLinesAtPointer: (elements: readonly NonDeletedExcalidrawElement[], app: AppClassProperties, pointer: Vector2D, event: KeyboardModifiersObject, elementsMap: ElementsMap) => {
     originOffset: {
         x: number;
         y: number;
     };
     snapLines: PointerSnapLine[];
 };
-export declare const isActiveToolNonLinearSnappable: (activeToolType: AppState["activeTool"]["type"]) => boolean;
+export declare const isActiveToolNonLinearSnappable: (activeToolType: AppState["activeTool"]["type"]) => activeToolType is "text" | "rectangle" | "diamond" | "ellipse" | "image" | "frame" | "magicframe";
 export {};

package/dist/types/excalidraw/subset/harfbuzz/harfbuzz-bindings.d.ts

@@ -38,7 +38,7 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-declare function subset(hbSubsetWasm: any, heapu8: Uint8Array, font: ArrayBuffer, codePoints: ReadonlySet<number>): Uint8Array;
+declare function subset(hbSubsetWasm: any, heapu8: Uint8Array, font: ArrayBuffer, codePoints: ReadonlySet<number>): Uint8Array<ArrayBuffer>;
 declare const _default: {
     subset: typeof subset;
 };

package/dist/types/excalidraw/subset/harfbuzz/harfbuzz-loader.d.ts

@@ -7,7 +7,7 @@
  * In the future consider separating common utils into a separate shared chunk.
  */
 declare const load: () => Promise<{
-    subset: (fontBuffer: ArrayBuffer, codePoints: ReadonlySet<number>) => Uint8Array;
+    subset: (fontBuffer: ArrayBuffer, codePoints: ReadonlySet<number>) => Uint8Array<ArrayBuffer>;
 }>;
 declare const _default: () => ReturnType<typeof load>;
 export default _default;

package/dist/types/excalidraw/subset/harfbuzz/harfbuzz-wasm.d.ts

@@ -1,2 +1,2 @@
-declare const _default: Uint8Array;
+declare const _default: Uint8Array<ArrayBuffer>;
 export default _default;

package/dist/types/excalidraw/subset/woff2/woff2-loader.d.ts

@@ -7,8 +7,8 @@
  * In the future consider separating common utils into a separate shared chunk.
  */
 declare const load: () => Promise<{
-    compress: (buffer: ArrayBuffer) => Uint8Array;
-    decompress: (buffer: ArrayBuffer) => Uint8Array;
+    compress: (buffer: ArrayBuffer) => Uint8Array<ArrayBuffer>;
+    decompress: (buffer: ArrayBuffer) => Uint8Array<ArrayBuffer>;
 }>;
 declare const _default: () => ReturnType<typeof load>;
 export default _default;

package/dist/types/excalidraw/subset/woff2/woff2-wasm.d.ts

@@ -1,2 +1,2 @@
-declare const _default: Uint8Array;
+declare const _default: Uint8Array<ArrayBuffer>;
 export default _default;

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

@@ -0,0 +1,15 @@
+import { type GlobalPoint } from "@excalidraw/math";
+import type { EditorInterface } from "@excalidraw/common";
+import type { ExcalidrawTextElement } from "@excalidraw/element/types";
+export declare const getTextBoxPadding: (zoomValue: number) => number;
+export declare const getTextAutoResizeHandle: (textElement: ExcalidrawTextElement, zoomValue: number, formFactor: EditorInterface["formFactor"]) => {
+    center: GlobalPoint | import("@excalidraw/math").LocalPoint;
+    start: GlobalPoint;
+    end: GlobalPoint;
+    hitboxWidth: number;
+    hitboxHeight: number;
+} | null;
+export declare const isPointHittingTextAutoResizeHandle: (point: Readonly<{
+    x: number;
+    y: number;
+}>, textElement: ExcalidrawTextElement, zoomValue: number, formFactor: EditorInterface["formFactor"]) => boolean;