@excalidraw/element 0.18.0-2a82821 → 0.18.0-2b1c2a9

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

@@ -15,7 +15,8 @@ export declare class Fonts {
         fontFaces: ExcalidrawFontFace[];
     }>;
     private readonly scene;
-    constructor(scene: Scene);
+    private readonly ownerDocument;
+    constructor(scene: Scene, ownerDocument?: Document);
     /**
      * Get all the font families for the given scene.
      */
@@ -36,7 +37,7 @@ export declare class Fonts {
     /**
      * Load font faces for passed elements - use when the scene is unavailable (i.e. export).
      */
-    static loadElementsFonts: (elements: readonly ExcalidrawElement[]) => Promise<FontFace[]>;
+    static loadElementsFonts: (elements: readonly ExcalidrawElement[], ownerDocument?: Document) => Promise<FontFace[]>;
     /**
      * Generate CSS @font-face declarations for the given elements.
      */

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

@@ -0,0 +1,29 @@
+import type { AppState } from "../types";
+/**
+ * Subscribes to specific appState changes. The component re-renders
+ * only when the specified prop(s) change — not on every appState update.
+ *
+ * Works both inside and outside the <Excalidraw> tree, as long as
+ * ExcalidrawAPIContext.Provider is an ancestor (automatically provided
+ * inside <Excalidraw>, or manually by the host app).
+ *
+ * Returns the narrowed value depending on prop form:
+ *  - `keyof AppState` → `AppState[K]`
+ *  - `(keyof AppState)[]` → whole `AppState`
+ *  - selector function → selector's return type `T`
+ *
+ * If excalidrawAPI is not ready yet (host apps), hook is rerendered with latest
+ * value once available.
+ */
+export declare function useAppStateValue<K extends keyof AppState>(prop: K, _internal?: boolean): AppState[K];
+export declare function useAppStateValue(props: (keyof AppState)[], _internal?: boolean): AppState;
+export declare function useAppStateValue<T>(selector: (appState: AppState) => T, _internal?: boolean): T;
+/**
+ * Subscribes to specific appState changes without causing component rerenders.
+ *
+ * The callback is called on every matching change, but also on initial render
+ * so you can initialize your state.
+ */
+export declare function useOnAppStateChange<K extends keyof AppState>(prop: K, callback: (value: AppState[K], appState: AppState) => void): undefined;
+export declare function useOnAppStateChange(props: (keyof AppState)[], callback: (props: AppState, appState: AppState) => void): undefined;
+export declare function useOnAppStateChange<T>(selector: (appState: AppState) => T, callback: (value: T, appState: AppState) => void): undefined;

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

@@ -2,13 +2,13 @@ export type CaretPosition = {
     start: number;
     end: number;
 };
-export declare const saveCaretPosition: () => CaretPosition | null;
-export declare const restoreCaretPosition: (position: CaretPosition | null) => void;
-export declare const withCaretPositionPreservation: (callback: () => void, isCompactMode: boolean, isEditingText: boolean, onPreventClose?: () => void) => void;
-export declare const useTextEditorFocus: () => {
+export declare const saveCaretPosition: (ownerDocument?: Document) => CaretPosition | null;
+export declare const restoreCaretPosition: (position: CaretPosition | null, ownerDocument?: Document) => void;
+export declare const withCaretPositionPreservation: (callback: () => void, isCompactMode: boolean, isEditingText: boolean, onPreventClose?: () => void, ownerDocument?: Document) => void;
+export declare const useTextEditorFocus: (ownerDocument?: Document) => {
     saveCaretPosition: () => void;
     restoreCaretPosition: () => void;
     clearSavedPosition: () => void;
     hasSavedPosition: boolean;
 };
-export declare const temporarilyDisableTextEditorBlur: (duration?: number) => void;
+export declare const temporarilyDisableTextEditorBlur: (ownerDocument?: Document, duration?: number) => void;

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

@@ -1,5 +1,6 @@
 import type { ElementsSegmentsMap, GlobalPoint } from "@excalidraw/math/types";
 import type { ElementsMap, ExcalidrawElement } from "@excalidraw/element/types";
+import type { BoxSelectionMode } from "../types";
 export declare const getLassoSelectedElementIds: (input: {
     lassoPath: GlobalPoint[];
     elements: readonly ExcalidrawElement[];
@@ -8,6 +9,7 @@ export declare const getLassoSelectedElementIds: (input: {
     intersectedElements: Set<ExcalidrawElement["id"]>;
     enclosedElements: Set<ExcalidrawElement["id"]>;
     simplifyDistance?: number;
+    mode?: BoxSelectionMode;
 }) => {
     selectedElementIds: string[];
 };

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

@@ -12,4 +12,5 @@ export declare class AnimationController {
     private static tick;
     static running(key: string): boolean;
     static cancel(key: string): void;
+    static reset(): void;
 }

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

@@ -1,5 +1,12 @@
 import type { StaticCanvasRenderConfig } from "../scene/types";
 import type { AppState, StaticCanvasAppState } from "../types";
+export declare const DEFAULT_SELECTION_COLOR = "#6965db";
+/**
+ * Returns the theme's selection color (`--color-selection`), read from the
+ * computed style of any element inside the editor container so that host
+ * overrides are respected. Falls back to the default when unavailable.
+ */
+export declare const getSelectionColor: (element: Element | null | undefined) => string;
 export declare const fillCircle: (context: CanvasRenderingContext2D, cx: number, cy: number, radius: number, stroke: boolean, fill?: boolean) => void;
 export declare const getNormalizedCanvasDimensions: (canvas: HTMLCanvasElement, scale: number) => [number, number];
 export declare const bootstrapCanvas: ({ canvas, scale, normalizedWidth, normalizedHeight, theme, isExporting, viewBackgroundColor, }: {

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

@@ -1,9 +1,7 @@
 import { getScrollBars } from "../scene/scrollbars";
-import type { InteractiveSceneRenderConfig, RenderableElementsMap } from "../scene/types";
+import type { InteractiveSceneRenderConfig } from "../scene/types";
 declare const _renderInteractiveScene: ({ app, canvas, elementsMap, visibleElements, selectedElements, allElementsMap, scale, appState, renderConfig, editorInterface, animationState, deltaTime, }: InteractiveSceneRenderConfig) => {
     scrollBars?: ReturnType<typeof getScrollBars>;
-    atLeastOneVisibleElement: boolean;
-    elementsMap: RenderableElementsMap;
     animationState?: typeof animationState;
 };
 /**

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

@@ -64,7 +64,7 @@ export declare class Renderer {
             startArrowhead: import("@excalidraw/element/types").Arrowhead | null;
             endArrowhead: import("@excalidraw/element/types").Arrowhead | null;
         }> & {
-            isDeleted: boolean;
+            isDeleted: false;
         }) | (Readonly<{
             id: string;
             x: number;
@@ -98,7 +98,7 @@ export declare class Renderer {
         }> & {
             type: "rectangle";
         } & {
-            isDeleted: boolean;
+            isDeleted: false;
         }) | (Readonly<{
             id: string;
             x: number;
@@ -132,7 +132,7 @@ export declare class Renderer {
         }> & {
             type: "diamond";
         } & {
-            isDeleted: boolean;
+            isDeleted: false;
         }) | (Readonly<{
             id: string;
             x: number;
@@ -166,7 +166,7 @@ export declare class Renderer {
         }> & {
             type: "ellipse";
         } & {
-            isDeleted: boolean;
+            isDeleted: false;
         }) | (Readonly<{
             id: string;
             x: number;
@@ -200,7 +200,7 @@ export declare class Renderer {
         }> & Readonly<{
             type: "embeddable";
         }> & {
-            isDeleted: boolean;
+            isDeleted: false;
         }) | (Readonly<{
             id: string;
             x: number;
@@ -237,7 +237,7 @@ export declare class Renderer {
                 generationData?: import("@excalidraw/element/types").MagicGenerationData;
             };
         }> & {
-            isDeleted: boolean;
+            isDeleted: false;
         }) | (Readonly<{
             id: string;
             x: number;
@@ -275,7 +275,7 @@ export declare class Renderer {
             scale: [number, number];
             crop: import("@excalidraw/element/types").ImageCrop | null;
         }> & {
-            isDeleted: boolean;
+            isDeleted: false;
         }) | (Readonly<{
             id: string;
             x: number;
@@ -310,7 +310,7 @@ export declare class Renderer {
             type: "frame";
             name: string | null;
         } & {
-            isDeleted: boolean;
+            isDeleted: false;
         }) | (Readonly<{
             id: string;
             x: number;
@@ -345,7 +345,7 @@ export declare class Renderer {
             type: "magicframe";
             name: string | null;
         } & {
-            isDeleted: boolean;
+            isDeleted: false;
         }) | (Readonly<{
             id: string;
             x: number;
@@ -389,8 +389,9 @@ export declare class Renderer {
             lineHeight: number & {
                 _brand: "unitlessLineHeight";
             };
+            labelPosition?: number | null;
         }> & {
-            isDeleted: boolean;
+            isDeleted: false;
         }) | (Readonly<{
             id: string;
             x: number;
@@ -428,7 +429,7 @@ export declare class Renderer {
             simulatePressure: boolean;
             strokeOptions: import("@excalidraw/element/types").StrokeOptions;
         }> & {
-            isDeleted: boolean;
+            isDeleted: false;
         }) | null;
         canvasNonce: string;
     };

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

@@ -1,10 +1,10 @@
-import type { ExcalidrawFrameLikeElement, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
+import type { ExcalidrawFrameLikeElement, NonDeleted, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
 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;
     viewBackgroundColor: string;
-    exportingFrame?: ExcalidrawFrameLikeElement | null;
+    exportingFrame?: NonDeleted<ExcalidrawFrameLikeElement> | null;
 }, createCanvas?: (width: number, height: number) => {
     canvas: HTMLCanvasElement;
     scale: number;
@@ -22,7 +22,7 @@ export declare const exportToSvg: (elements: readonly NonDeletedExcalidrawElemen
      * if true, all embeddables passed in will be rendered when possible.
      */
     renderEmbeddables?: boolean;
-    exportingFrame?: ExcalidrawFrameLikeElement | null;
+    exportingFrame?: NonDeleted<ExcalidrawFrameLikeElement> | null;
     skipInliningFonts?: true;
     reuseImages?: boolean;
 }) => Promise<SVGSVGElement>;

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 { getScrollToContentState } from "../viewport";
 export { hasBackground, hasStrokeWidth, hasStrokeStyle, hasFreedrawMode, canHaveArrowheads, canChangeRoundness, } from "@excalidraw/element";
 export { getNormalizedZoom, getNormalizedGridSize, getNormalizedGridStep, } from "./normalize";

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

@@ -9,6 +9,9 @@ export type StaticCanvasRenderConfig = {
     canvasBackgroundColor: AppState["viewBackgroundColor"];
     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;
@@ -52,8 +55,6 @@ export type InteractiveCanvasRenderConfig = {
     renderScrollbars?: boolean;
 };
 export type RenderInteractiveSceneCallback = {
-    atLeastOneVisibleElement: boolean;
-    elementsMap: RenderableElementsMap;
     scrollBars?: ScrollBars;
 };
 export type StaticSceneRenderConfig = {
@@ -89,7 +90,7 @@ export type InteractiveSceneRenderConfig = {
 export type NewElementSceneRenderConfig = {
     canvas: HTMLCanvasElement | null;
     rc: RoughCanvas;
-    newElement: ExcalidrawElement | null;
+    newElement: NonDeletedExcalidrawElement | null;
     elementsMap: RenderableElementsMap;
     allElementsMap: NonDeletedSceneElementsMap;
     scale: number;

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

@@ -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, }?: {
+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,21 +86,21 @@ 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;