@zsviczian/excalidraw 0.15.2-obsidian-12 → 0.15.2-obsidian-13

package/types/renderer/renderElement.d.ts

@@ -1,37 +1,25 @@
-import { ExcalidrawElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, ExcalidrawFreeDrawElement } from "../element/types";
-import { RoughCanvas } from "roughjs/bin/canvas";
-import { Drawable, Options } from "roughjs/bin/core";
-import { RoughSVG } from "roughjs/bin/svg";
-import { RenderConfig } from "../scene/types";
-import { AppState, BinaryFiles } from "../types";
-export interface ExcalidrawElementWithCanvas {
-    element: ExcalidrawElement | ExcalidrawTextElement;
-    canvas: HTMLCanvasElement;
-    theme: RenderConfig["theme"];
-    scale: number;
-    zoomValue: RenderConfig["zoom"]["value"];
-    canvasOffsetX: number;
-    canvasOffsetY: number;
-    boundTextElementVersion: number | null;
-    containingFrameOpacity: number;
-}
-export declare const DEFAULT_LINK_SIZE = 14;
-type ElementShape = Drawable | Drawable[] | null;
-type ElementShapes = {
-    freedraw: Drawable | null;
-    arrow: Drawable[];
-    line: Drawable[];
-    text: null;
-    image: null;
-};
-export declare const getShapeForElement: <T extends ExcalidrawElement>(element: T) => T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] | undefined : Drawable | null | undefined;
-export declare const setShapeForElement: <T extends ExcalidrawElement>(element: T, shape: T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] : Drawable) => WeakMap<ExcalidrawElement, ElementShape>;
-export declare const invalidateShapeForElement: (element: ExcalidrawElement) => boolean;
-export declare const generateRoughOptions: (element: ExcalidrawElement, continuousPath?: boolean, isExporting?: boolean) => Options;
-export declare const renderElement: (element: NonDeletedExcalidrawElement, rc: RoughCanvas, context: CanvasRenderingContext2D, renderConfig: RenderConfig, appState: AppState) => void;
-export declare const renderElementToSvg: (element: NonDeletedExcalidrawElement, rsvg: RoughSVG, svgRoot: SVGElement, files: BinaryFiles, offsetX: number, offsetY: number, exportWithDarkMode?: boolean, exportingFrameId?: string | null, renderEmbeddables?: boolean) => void;
-export declare const pathsCache: WeakMap<ExcalidrawFreeDrawElement, Path2D>;
-export declare function generateFreeDrawShape(element: ExcalidrawFreeDrawElement): Path2D;
-export declare function getFreeDrawPath2D(element: ExcalidrawFreeDrawElement): Path2D | undefined;
-export declare function getFreeDrawSvgPath(element: ExcalidrawFreeDrawElement): string;
-export {};
+import { ExcalidrawElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, ExcalidrawFreeDrawElement } from "../element/types";
+import type { RoughCanvas } from "roughjs/bin/canvas";
+import type { RoughSVG } from "roughjs/bin/svg";
+import { StaticCanvasRenderConfig } from "../scene/types";
+import { AppState, StaticCanvasAppState, BinaryFiles, InteractiveCanvasAppState } from "../types";
+export interface ExcalidrawElementWithCanvas {
+    element: ExcalidrawElement | ExcalidrawTextElement;
+    canvas: HTMLCanvasElement;
+    theme: AppState["theme"];
+    scale: number;
+    zoomValue: AppState["zoom"]["value"];
+    canvasOffsetX: number;
+    canvasOffsetY: number;
+    boundTextElementVersion: number | null;
+    containingFrameOpacity: number;
+}
+export declare const DEFAULT_LINK_SIZE = 14;
+export declare const elementWithCanvasCache: WeakMap<ExcalidrawElement, ExcalidrawElementWithCanvas>;
+export declare const renderSelectionElement: (element: NonDeletedExcalidrawElement, context: CanvasRenderingContext2D, appState: InteractiveCanvasAppState) => void;
+export declare const renderElement: (element: NonDeletedExcalidrawElement, rc: RoughCanvas, context: CanvasRenderingContext2D, renderConfig: StaticCanvasRenderConfig, appState: StaticCanvasAppState) => void;
+export declare const renderElementToSvg: (element: NonDeletedExcalidrawElement, rsvg: RoughSVG, svgRoot: SVGElement, files: BinaryFiles, offsetX: number, offsetY: number, exportWithDarkMode?: boolean, exportingFrameId?: string | null, renderEmbeddables?: boolean) => void;
+export declare const pathsCache: WeakMap<ExcalidrawFreeDrawElement, Path2D>;
+export declare function generateFreeDrawShape(element: ExcalidrawFreeDrawElement): Path2D;
+export declare function getFreeDrawPath2D(element: ExcalidrawFreeDrawElement): Path2D | undefined;
+export declare function getFreeDrawSvgPath(element: ExcalidrawFreeDrawElement): string;

package/types/renderer/renderScene.d.ts

@@ -1,51 +1,31 @@
-import { RoughCanvas } from "roughjs/bin/canvas";
-import { RoughSVG } from "roughjs/bin/svg";
-import { AppState, BinaryFiles, Zoom } from "../types";
-import { ExcalidrawElement, NonDeletedExcalidrawElement } from "../element/types";
-import { RenderConfig } from "../scene/types";
-import "canvas-roundrect-polyfill";
-export declare const DEFAULT_SPACING = 2;
-export declare const _renderScene: ({ elements, appState, scale, rc, canvas, renderConfig, }: {
-    elements: readonly NonDeletedExcalidrawElement[];
-    appState: AppState;
-    scale: number;
-    rc: RoughCanvas;
-    canvas: HTMLCanvasElement;
-    renderConfig: RenderConfig;
-}) => {
-    atLeastOneVisibleElement: boolean;
-    scrollBars?: undefined;
-} | {
-    atLeastOneVisibleElement: boolean;
-    scrollBars: import("../scene/types").ScrollBars | undefined;
-};
-/** renderScene throttled to animation framerate */
-export declare const renderScene: <T extends boolean = false>(config: {
-    elements: readonly NonDeletedExcalidrawElement[];
-    appState: AppState;
-    scale: number;
-    rc: RoughCanvas;
-    canvas: HTMLCanvasElement;
-    renderConfig: RenderConfig;
-    callback?: ((data: ReturnType<typeof _renderScene>) => void) | undefined;
-}, throttle?: T | undefined) => T extends true ? void : {
-    atLeastOneVisibleElement: boolean;
-    scrollBars?: undefined;
-} | {
-    atLeastOneVisibleElement: boolean;
-    scrollBars: import("../scene/types").ScrollBars | undefined;
-};
-export declare const isVisibleElement: (element: ExcalidrawElement, canvasWidth: number, canvasHeight: number, viewTransformations: {
-    zoom: Zoom;
-    offsetLeft: number;
-    offsetTop: number;
-    scrollX: number;
-    scrollY: number;
-}) => boolean;
-export declare const renderSceneToSvg: (elements: readonly NonDeletedExcalidrawElement[], rsvg: RoughSVG, svgRoot: SVGElement, files: BinaryFiles, { offsetX, offsetY, exportWithDarkMode, exportingFrameId, renderEmbeddables, }?: {
-    offsetX?: number | undefined;
-    offsetY?: number | undefined;
-    exportWithDarkMode?: boolean | undefined;
-    exportingFrameId?: string | null | undefined;
-    renderEmbeddables?: boolean | undefined;
-}) => void;
+import { RoughSVG } from "roughjs/bin/svg";
+import { BinaryFiles } from "../types";
+import { NonDeletedExcalidrawElement } from "../element/types";
+import { InteractiveSceneRenderConfig, StaticSceneRenderConfig } from "../scene/types";
+import "canvas-roundrect-polyfill";
+export declare const DEFAULT_SPACING = 2;
+/**
+ * Interactive scene is the ui-canvas where we render boundinb boxes, selections
+ * and other ui stuff.
+ */
+export declare const renderInteractiveScene: <U extends ({ canvas, elements, visibleElements, selectedElements, scale, appState, renderConfig, }: InteractiveSceneRenderConfig) => {
+    atLeastOneVisibleElement: boolean;
+    elements: readonly NonDeletedExcalidrawElement[];
+    scrollBars?: undefined;
+} | {
+    scrollBars: import("../scene/types").ScrollBars | undefined;
+    atLeastOneVisibleElement: boolean;
+    elements: readonly NonDeletedExcalidrawElement[];
+}, T extends boolean = false>(renderConfig: InteractiveSceneRenderConfig, throttle?: T | undefined) => T extends true ? void : ReturnType<U>;
+/**
+ * Static scene is the non-ui canvas where we render elements.
+ */
+export declare const renderStaticScene: (renderConfig: StaticSceneRenderConfig, throttle?: boolean) => void;
+export declare const cancelRender: () => void;
+export declare const renderSceneToSvg: (elements: readonly NonDeletedExcalidrawElement[], rsvg: RoughSVG, svgRoot: SVGElement, files: BinaryFiles, { offsetX, offsetY, exportWithDarkMode, exportingFrameId, renderEmbeddables, }?: {
+    offsetX?: number | undefined;
+    offsetY?: number | undefined;
+    exportWithDarkMode?: boolean | undefined;
+    exportingFrameId?: string | null | undefined;
+    renderEmbeddables?: boolean | undefined;
+}) => void;

package/types/renderer/roundRect.d.ts

@@ -1,11 +1,11 @@
-/**
- * https://stackoverflow.com/a/3368118
- * Draws a rounded rectangle using the current state of the canvas.
- * @param {CanvasRenderingContext2D} context
- * @param {Number} x The top left x coordinate
- * @param {Number} y The top left y coordinate
- * @param {Number} width The width of the rectangle
- * @param {Number} height The height of the rectangle
- * @param {Number} radius The corner radius
- */
-export declare const roundRect: (context: CanvasRenderingContext2D, x: number, y: number, width: number, height: number, radius: number, strokeColor?: string) => void;
+/**
+ * https://stackoverflow.com/a/3368118
+ * Draws a rounded rectangle using the current state of the canvas.
+ * @param {CanvasRenderingContext2D} context
+ * @param {Number} x The top left x coordinate
+ * @param {Number} y The top left y coordinate
+ * @param {Number} width The width of the rectangle
+ * @param {Number} height The height of the rectangle
+ * @param {Number} radius The corner radius
+ */
+export declare const roundRect: (context: CanvasRenderingContext2D, x: number, y: number, width: number, height: number, radius: number, strokeColor?: string) => void;

package/types/scene/Fonts.d.ts

@@ -1,21 +1,21 @@
-import { ExcalidrawElement } from "../element/types";
-import type Scene from "./Scene";
-export declare class Fonts {
-    private scene;
-    private onSceneUpdated;
-    constructor({ scene, onSceneUpdated, }: {
-        scene: Scene;
-        onSceneUpdated: () => void;
-    });
-    private static loadedFontFaces;
-    /**
-     * if we load a (new) font, it's likely that text elements using it have
-     * already been rendered using a fallback font. Thus, we want invalidate
-     * their shapes and rerender. See #637.
-     *
-     * Invalidates text elements and rerenders scene, provided that at least one
-     * of the supplied fontFaces has not already been processed.
-     */
-    onFontsLoaded: (fontFaces: readonly FontFace[]) => false | undefined;
-    loadFontsForElements: (elements: readonly ExcalidrawElement[]) => Promise<void>;
-}
+import { ExcalidrawElement } from "../element/types";
+import type Scene from "./Scene";
+export declare class Fonts {
+    private scene;
+    private onSceneUpdated;
+    constructor({ scene, onSceneUpdated, }: {
+        scene: Scene;
+        onSceneUpdated: () => void;
+    });
+    private static loadedFontFaces;
+    /**
+     * if we load a (new) font, it's likely that text elements using it have
+     * already been rendered using a fallback font. Thus, we want invalidate
+     * their shapes and rerender. See #637.
+     *
+     * Invalidates text elements and rerenders scene, provided that at least one
+     * of the supplied fontFaces has not already been processed.
+     */
+    onFontsLoaded: (fontFaces: readonly FontFace[]) => false | undefined;
+    loadFontsForElements: (elements: readonly ExcalidrawElement[]) => Promise<void>;
+}

package/types/scene/Renderer.d.ts

@@ -0,0 +1,25 @@
+import { NonDeletedExcalidrawElement } from "../element/types";
+import { AppState } from "../types";
+import Scene from "./Scene";
+export declare class Renderer {
+    private scene;
+    constructor(scene: Scene);
+    getRenderableElements: ((opts: {
+        zoom: AppState["zoom"];
+        offsetLeft: AppState["offsetLeft"];
+        offsetTop: AppState["offsetTop"];
+        scrollX: AppState["scrollX"];
+        scrollY: AppState["scrollY"];
+        height: AppState["height"];
+        width: AppState["width"];
+        editingElement: AppState["editingElement"];
+        pendingImageElementId: AppState["pendingImageElementId"];
+        versionNonce: ReturnType<InstanceType<typeof Scene>["getVersionNonce"]>;
+    }) => {
+        canvasElements: NonDeletedExcalidrawElement[];
+        visibleElements: readonly NonDeletedExcalidrawElement[];
+    }) & {
+        clear: () => void;
+    };
+    destroy(): void;
+}

package/types/scene/Scene.d.ts

@@ -1,60 +1,62 @@
-import { ExcalidrawElement, NonDeletedExcalidrawElement, NonDeleted, ExcalidrawFrameElement } from "../element/types";
-import { LinearElementEditor } from "../element/linearElementEditor";
-import { AppState } from "../types";
-type ElementIdKey = InstanceType<typeof LinearElementEditor>["elementId"];
-type ElementKey = ExcalidrawElement | ElementIdKey;
-type SceneStateCallback = () => void;
-type SceneStateCallbackRemover = () => void;
-export type ExcalidrawElementsIncludingDeleted = readonly ExcalidrawElement[];
-declare class Scene {
-    private static sceneMapByElement;
-    private static sceneMapById;
-    static mapElementToScene(elementKey: ElementKey, scene: Scene): void;
-    static getScene(elementKey: ElementKey): Scene | null;
-    private callbacks;
-    private nonDeletedElements;
-    private elements;
-    private nonDeletedFrames;
-    private frames;
-    private elementsMap;
-    private selectedElementsCache;
-    getElementsIncludingDeleted(): readonly ExcalidrawElement[];
-    getNonDeletedElements(): readonly NonDeletedExcalidrawElement[];
-    getFramesIncludingDeleted(): readonly ExcalidrawFrameElement[];
-    getSelectedElements(opts: {
-        selectedElementIds: AppState["selectedElementIds"];
-        /**
-         * for specific cases where you need to use elements not from current
-         * scene state. This in effect will likely result in cache-miss, and
-         * the cache won't be updated in this case.
-         */
-        elements?: readonly ExcalidrawElement[];
-        includeBoundTextElement?: boolean;
-        includeElementsInFrames?: boolean;
-    }): NonDeleted<ExcalidrawElement>[];
-    getNonDeletedFrames(): readonly NonDeleted<ExcalidrawFrameElement>[];
-    getElement<T extends ExcalidrawElement>(id: T["id"]): T | null;
-    getNonDeletedElement(id: ExcalidrawElement["id"]): NonDeleted<ExcalidrawElement> | null;
-    /**
-     * A utility method to help with updating all scene elements, with the added
-     * performance optimization of not renewing the array if no change is made.
-     *
-     * Maps all current excalidraw elements, invoking the callback for each
-     * element. The callback should either return a new mapped element, or the
-     * original element if no changes are made. If no changes are made to any
-     * element, this results in a no-op. Otherwise, the newly mapped elements
-     * are set as the next scene's elements.
-     *
-     * @returns whether a change was made
-     */
-    mapElements(iteratee: (element: ExcalidrawElement) => ExcalidrawElement): boolean;
-    replaceAllElements(nextElements: readonly ExcalidrawElement[]): void;
-    informMutation(): void;
-    addCallback(cb: SceneStateCallback): SceneStateCallbackRemover;
-    destroy(): void;
-    insertElementAtIndex(element: ExcalidrawElement, index: number): void;
-    insertElementsAtIndex(elements: ExcalidrawElement[], index: number): void;
-    addNewElement: (element: ExcalidrawElement) => void;
-    getElementIndex(elementId: string): number;
-}
-export default Scene;
+import { ExcalidrawElement, NonDeletedExcalidrawElement, NonDeleted, ExcalidrawFrameElement } from "../element/types";
+import { LinearElementEditor } from "../element/linearElementEditor";
+import { AppState } from "../types";
+type ElementIdKey = InstanceType<typeof LinearElementEditor>["elementId"];
+type ElementKey = ExcalidrawElement | ElementIdKey;
+type SceneStateCallback = () => void;
+type SceneStateCallbackRemover = () => void;
+export type ExcalidrawElementsIncludingDeleted = readonly ExcalidrawElement[];
+declare class Scene {
+    private static sceneMapByElement;
+    private static sceneMapById;
+    static mapElementToScene(elementKey: ElementKey, scene: Scene): void;
+    static getScene(elementKey: ElementKey): Scene | null;
+    private callbacks;
+    private nonDeletedElements;
+    private elements;
+    private nonDeletedFrames;
+    private frames;
+    private elementsMap;
+    private selectedElementsCache;
+    private versionNonce;
+    getElementsIncludingDeleted(): readonly ExcalidrawElement[];
+    getNonDeletedElements(): readonly NonDeletedExcalidrawElement[];
+    getFramesIncludingDeleted(): readonly ExcalidrawFrameElement[];
+    getSelectedElements(opts: {
+        selectedElementIds: AppState["selectedElementIds"];
+        /**
+         * for specific cases where you need to use elements not from current
+         * scene state. This in effect will likely result in cache-miss, and
+         * the cache won't be updated in this case.
+         */
+        elements?: readonly ExcalidrawElement[];
+        includeBoundTextElement?: boolean;
+        includeElementsInFrames?: boolean;
+    }): NonDeleted<ExcalidrawElement>[];
+    getNonDeletedFrames(): readonly NonDeleted<ExcalidrawFrameElement>[];
+    getElement<T extends ExcalidrawElement>(id: T["id"]): T | null;
+    getVersionNonce(): number | undefined;
+    getNonDeletedElement(id: ExcalidrawElement["id"]): NonDeleted<ExcalidrawElement> | null;
+    /**
+     * A utility method to help with updating all scene elements, with the added
+     * performance optimization of not renewing the array if no change is made.
+     *
+     * Maps all current excalidraw elements, invoking the callback for each
+     * element. The callback should either return a new mapped element, or the
+     * original element if no changes are made. If no changes are made to any
+     * element, this results in a no-op. Otherwise, the newly mapped elements
+     * are set as the next scene's elements.
+     *
+     * @returns whether a change was made
+     */
+    mapElements(iteratee: (element: ExcalidrawElement) => ExcalidrawElement): boolean;
+    replaceAllElements(nextElements: readonly ExcalidrawElement[]): void;
+    informMutation(): void;
+    addCallback(cb: SceneStateCallback): SceneStateCallbackRemover;
+    destroy(): void;
+    insertElementAtIndex(element: ExcalidrawElement, index: number): void;
+    insertElementsAtIndex(elements: ExcalidrawElement[], index: number): void;
+    addNewElement: (element: ExcalidrawElement) => void;
+    getElementIndex(elementId: string): number;
+}
+export default Scene;

package/types/scene/Shape.d.ts

@@ -0,0 +1,12 @@
+import type { Drawable, Options } from "roughjs/bin/core";
+import type { RoughGenerator } from "roughjs/bin/generator";
+import type { ExcalidrawElement, NonDeletedExcalidrawElement, ExcalidrawSelectionElement } from "../element/types";
+export declare const generateRoughOptions: (element: ExcalidrawElement, continuousPath?: boolean) => Options;
+/**
+ * Generates the roughjs shape for given element.
+ *
+ * Low-level. Use `ShapeCache.generateElementShape` instead.
+ *
+ * @private
+ */
+export declare const _generateElementShape: (element: Exclude<NonDeletedExcalidrawElement, ExcalidrawSelectionElement>, generator: RoughGenerator, isExporting?: boolean) => Drawable | Drawable[] | null;

package/types/scene/ShapeCache.d.ts

@@ -0,0 +1,20 @@
+import { Drawable } from "roughjs/bin/core";
+import { ExcalidrawElement } from "../element/types";
+import { ElementShape, ElementShapes } from "./types";
+export declare class ShapeCache {
+    private static rg;
+    private static cache;
+    /**
+     * Retrieves shape from cache if available. Use this only if shape
+     * is optional and you have a fallback in case it's not cached.
+     */
+    static get: <T extends ExcalidrawElement>(element: T) => T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] | undefined : ElementShape | undefined;
+    static set: <T extends ExcalidrawElement>(element: T, shape: T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] : Drawable) => WeakMap<ExcalidrawElement, ElementShape>;
+    static delete: (element: ExcalidrawElement) => boolean;
+    static destroy: () => void;
+    /**
+     * Generates & caches shape for element if not already cached, otherwise
+     * returns cached shape.
+     */
+    static generateElementShape: <T extends import("../element/types").ExcalidrawLinearElement | import("../element/types").ExcalidrawRectangleElement | import("../element/types").ExcalidrawDiamondElement | import("../element/types").ExcalidrawEllipseElement | import("../element/types").ExcalidrawEmbeddableElement | import("../element/types").ExcalidrawImageElement | import("../element/types").ExcalidrawFrameElement | import("../element/types").ExcalidrawTextElement | import("../element/types").ExcalidrawFreeDrawElement>(element: T, isExporting?: boolean) => ((T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] | undefined : ElementShape | undefined) & ({} | null)) | (T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] : Drawable | null);
+}

package/types/scene/comparisons.d.ts

@@ -1,10 +1,10 @@
-import { NonDeletedExcalidrawElement } from "../element/types";
-export declare const hasBackground: (type: string) => boolean;
-export declare const hasStrokeColor: (type: string) => boolean;
-export declare const hasStrokeWidth: (type: string) => boolean;
-export declare const hasStrokeStyle: (type: string) => boolean;
-export declare const canChangeRoundness: (type: string) => boolean;
-export declare const hasText: (type: string) => boolean;
-export declare const canHaveArrowheads: (type: string) => boolean;
-export declare const getElementAtPosition: (elements: readonly NonDeletedExcalidrawElement[], isAtPositionFn: (element: NonDeletedExcalidrawElement) => boolean) => NonDeletedExcalidrawElement | null;
-export declare const getElementsAtPosition: (elements: readonly NonDeletedExcalidrawElement[], isAtPositionFn: (element: NonDeletedExcalidrawElement) => boolean) => NonDeletedExcalidrawElement[];
+import { NonDeletedExcalidrawElement } from "../element/types";
+export declare const hasBackground: (type: string) => boolean;
+export declare const hasStrokeColor: (type: string) => boolean;
+export declare const hasStrokeWidth: (type: string) => boolean;
+export declare const hasStrokeStyle: (type: string) => boolean;
+export declare const canChangeRoundness: (type: string) => boolean;
+export declare const hasText: (type: string) => boolean;
+export declare const canHaveArrowheads: (type: string) => boolean;
+export declare const getElementAtPosition: (elements: readonly NonDeletedExcalidrawElement[], isAtPositionFn: (element: NonDeletedExcalidrawElement) => boolean) => NonDeletedExcalidrawElement | null;
+export declare const getElementsAtPosition: (elements: readonly NonDeletedExcalidrawElement[], isAtPositionFn: (element: NonDeletedExcalidrawElement) => boolean) => NonDeletedExcalidrawElement[];

package/types/scene/export.d.ts

@@ -1,25 +1,25 @@
-import { NonDeletedExcalidrawElement } from "../element/types";
-import { AppState, BinaryFiles } from "../types";
-import { serializeAsJSON } from "../data/json";
-export declare const SVG_EXPORT_TAG = "<!-- svg-source:excalidraw -->";
-export declare const exportToCanvas: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState, files: BinaryFiles, { exportBackground, exportPadding, viewBackgroundColor, }: {
-    exportBackground: boolean;
-    exportPadding?: number | undefined;
-    viewBackgroundColor: string;
-}, createCanvas?: (width: number, height: number) => {
-    canvas: HTMLCanvasElement;
-    scale: number;
-}) => Promise<HTMLCanvasElement>;
-export declare const exportToSvg: (elements: readonly NonDeletedExcalidrawElement[], appState: {
-    exportBackground: boolean;
-    exportPadding?: number;
-    exportScale?: number;
-    viewBackgroundColor: string;
-    exportWithDarkMode?: boolean;
-    exportEmbedScene?: boolean;
-    renderFrame?: boolean;
-}, files: BinaryFiles | null, opts?: {
-    serializeAsJSON?: () => string;
-    renderEmbeddables?: boolean;
-}) => Promise<SVGSVGElement>;
-export declare const getExportSize: (elements: readonly NonDeletedExcalidrawElement[], exportPadding: number, scale: number) => [number, number];
+import { NonDeletedExcalidrawElement } from "../element/types";
+import { AppState, BinaryFiles } from "../types";
+import { serializeAsJSON } from "../data/json";
+export declare const SVG_EXPORT_TAG = "<!-- svg-source:excalidraw -->";
+export declare const exportToCanvas: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState, files: BinaryFiles, { exportBackground, exportPadding, viewBackgroundColor, }: {
+    exportBackground: boolean;
+    exportPadding?: number | undefined;
+    viewBackgroundColor: string;
+}, createCanvas?: (width: number, height: number) => {
+    canvas: HTMLCanvasElement;
+    scale: number;
+}) => Promise<HTMLCanvasElement>;
+export declare const exportToSvg: (elements: readonly NonDeletedExcalidrawElement[], appState: {
+    exportBackground: boolean;
+    exportPadding?: number;
+    exportScale?: number;
+    viewBackgroundColor: string;
+    exportWithDarkMode?: boolean;
+    exportEmbedScene?: boolean;
+    renderFrame?: boolean;
+}, files: BinaryFiles | null, opts?: {
+    serializeAsJSON?: () => string;
+    renderEmbeddables?: boolean;
+}) => Promise<SVGSVGElement>;
+export declare const getExportSize: (elements: readonly NonDeletedExcalidrawElement[], exportPadding: number, scale: number) => [number, number];

package/types/scene/index.d.ts

@@ -1,5 +1,5 @@
-export { isOverScrollBars } from "./scrollbars";
-export { isSomeElementSelected, getElementsWithinSelection, getCommonAttributeOfSelectedElements, getSelectedElements, getTargetElements, } from "./selection";
-export { calculateScrollCenter } from "./scroll";
-export { hasBackground, hasStrokeWidth, hasStrokeStyle, canHaveArrowheads, canChangeRoundness, getElementAtPosition, hasText, getElementsAtPosition, } from "./comparisons";
-export { getNormalizedZoom } from "./zoom";
+export { isOverScrollBars } from "./scrollbars";
+export { isSomeElementSelected, getElementsWithinSelection, getCommonAttributeOfSelectedElements, getSelectedElements, getTargetElements, } from "./selection";
+export { calculateScrollCenter } from "./scroll";
+export { hasBackground, hasStrokeWidth, hasStrokeStyle, canHaveArrowheads, canChangeRoundness, getElementAtPosition, hasText, getElementsAtPosition, } from "./comparisons";
+export { getNormalizedZoom } from "./zoom";

package/types/scene/scroll.d.ts

@@ -1,17 +1,17 @@
-import { AppState, PointerCoords, Zoom } from "../types";
-import { ExcalidrawElement } from "../element/types";
-export declare const centerScrollOn: ({ scenePoint, viewportDimensions, zoom, }: {
-    scenePoint: PointerCoords;
-    viewportDimensions: {
-        height: number;
-        width: number;
-    };
-    zoom: Zoom;
-}) => {
-    scrollX: number;
-    scrollY: number;
-};
-export declare const calculateScrollCenter: (elements: readonly ExcalidrawElement[], appState: AppState, canvas: HTMLCanvasElement | null) => {
-    scrollX: number;
-    scrollY: number;
-};
+import { AppState, PointerCoords, Zoom } from "../types";
+import { ExcalidrawElement } from "../element/types";
+export declare const centerScrollOn: ({ scenePoint, viewportDimensions, zoom, }: {
+    scenePoint: PointerCoords;
+    viewportDimensions: {
+        height: number;
+        width: number;
+    };
+    zoom: Zoom;
+}) => {
+    scrollX: number;
+    scrollY: number;
+};
+export declare const calculateScrollCenter: (elements: readonly ExcalidrawElement[], appState: AppState) => {
+    scrollX: number;
+    scrollY: number;
+};

package/types/scene/scrollbars.d.ts

@@ -1,16 +1,12 @@
-import { ExcalidrawElement } from "../element/types";
-import { Zoom } from "../types";
-import { ScrollBars } from "./types";
-export declare const SCROLLBAR_MARGIN = 4;
-export declare const SCROLLBAR_WIDTH = 6;
-export declare const SCROLLBAR_COLOR = "rgba(128,128,128,0.3)";
-export declare const getScrollBars: (elements: readonly ExcalidrawElement[], viewportWidth: number, viewportHeight: number, { scrollX, scrollY, zoom, }: {
-    scrollX: number;
-    scrollY: number;
-    zoom: Zoom;
-}) => ScrollBars;
-export declare const isOverScrollBars: (scrollBars: ScrollBars, x: number, y: number) => {
-    isOverEither: boolean;
-    isOverHorizontal: boolean;
-    isOverVertical: boolean;
-};
+import { ExcalidrawElement } from "../element/types";
+import { InteractiveCanvasAppState } from "../types";
+import { ScrollBars } from "./types";
+export declare const SCROLLBAR_MARGIN = 4;
+export declare const SCROLLBAR_WIDTH = 6;
+export declare const SCROLLBAR_COLOR = "rgba(128,128,128,0.3)";
+export declare const getScrollBars: (elements: readonly ExcalidrawElement[], viewportWidth: number, viewportHeight: number, appState: InteractiveCanvasAppState) => ScrollBars;
+export declare const isOverScrollBars: (scrollBars: ScrollBars, x: number, y: number) => {
+    isOverEither: boolean;
+    isOverHorizontal: boolean;
+    isOverVertical: boolean;
+};

package/types/scene/selection.d.ts

@@ -1,31 +1,31 @@
-import { ExcalidrawElement, NonDeletedExcalidrawElement } from "../element/types";
-import { AppState } from "../types";
-/**
- * Frames and their containing elements are not to be selected at the same time.
- * Given an array of selected elements, if there are frames and their containing elements
- * we only keep the frames.
- * @param selectedElements
- */
-export declare const excludeElementsInFramesFromSelection: <T extends ExcalidrawElement>(selectedElements: readonly T[]) => T[];
-export declare const getElementsWithinSelection: (elements: readonly NonDeletedExcalidrawElement[], selection: NonDeletedExcalidrawElement, excludeElementsInFrames?: boolean) => NonDeletedExcalidrawElement[];
-export declare const isSomeElementSelected: {
-    (elements: readonly NonDeletedExcalidrawElement[], appState: Pick<AppState, "selectedElementIds">): boolean;
-    clearCache(): void;
-};
-/**
- * Returns common attribute (picked by `getAttribute` callback) of selected
- *  elements. If elements don't share the same value, returns `null`.
- */
-export declare const getCommonAttributeOfSelectedElements: <T>(elements: readonly NonDeletedExcalidrawElement[], appState: Pick<AppState, "selectedElementIds">, getAttribute: (element: ExcalidrawElement) => T) => T | null;
-export declare const getSelectedElements: (elements: readonly NonDeletedExcalidrawElement[], appState: Pick<AppState, "selectedElementIds">, opts?: {
-    includeBoundTextElement?: boolean;
-    includeElementsInFrames?: boolean;
-}) => ExcalidrawElement[];
-export declare const getTargetElements: (elements: readonly NonDeletedExcalidrawElement[], appState: Pick<AppState, "selectedElementIds" | "editingElement">) => ExcalidrawElement[];
-/**
- * returns prevState's selectedElementids if no change from previous, so as to
- * retain reference identity for memoization
- */
-export declare const makeNextSelectedElementIds: (nextSelectedElementIds: AppState["selectedElementIds"], prevState: Pick<AppState, "selectedElementIds">) => Readonly<{
-    [id: string]: true;
-}>;
+import { ExcalidrawElement, NonDeletedExcalidrawElement } from "../element/types";
+import { AppState, InteractiveCanvasAppState } from "../types";
+/**
+ * Frames and their containing elements are not to be selected at the same time.
+ * Given an array of selected elements, if there are frames and their containing elements
+ * we only keep the frames.
+ * @param selectedElements
+ */
+export declare const excludeElementsInFramesFromSelection: <T extends ExcalidrawElement>(selectedElements: readonly T[]) => T[];
+export declare const getElementsWithinSelection: (elements: readonly NonDeletedExcalidrawElement[], selection: NonDeletedExcalidrawElement, excludeElementsInFrames?: boolean) => NonDeletedExcalidrawElement[];
+export declare const isSomeElementSelected: {
+    (elements: readonly NonDeletedExcalidrawElement[], appState: Pick<AppState, "selectedElementIds">): boolean;
+    clearCache(): void;
+};
+/**
+ * Returns common attribute (picked by `getAttribute` callback) of selected
+ *  elements. If elements don't share the same value, returns `null`.
+ */
+export declare const getCommonAttributeOfSelectedElements: <T>(elements: readonly NonDeletedExcalidrawElement[], appState: Pick<AppState, "selectedElementIds">, getAttribute: (element: ExcalidrawElement) => T) => T | null;
+export declare const getSelectedElements: (elements: readonly NonDeletedExcalidrawElement[], appState: Pick<InteractiveCanvasAppState, "selectedElementIds">, opts?: {
+    includeBoundTextElement?: boolean;
+    includeElementsInFrames?: boolean;
+}) => ExcalidrawElement[];
+export declare const getTargetElements: (elements: readonly NonDeletedExcalidrawElement[], appState: Pick<AppState, "selectedElementIds" | "editingElement">) => ExcalidrawElement[];
+/**
+ * returns prevState's selectedElementids if no change from previous, so as to
+ * retain reference identity for memoization
+ */
+export declare const makeNextSelectedElementIds: (nextSelectedElementIds: AppState["selectedElementIds"], prevState: Pick<AppState, "selectedElementIds">) => Readonly<{
+    [id: string]: true;
+}>;