@dwelle/excalidraw 0.4.0-e1bdbb6 → 0.4.0-e587816

package/types/math.d.ts

@@ -1,5 +1,5 @@
 import { Point, Zoom } from "./types";
-import { ExcalidrawLinearElement, NonDeleted } from "./element/types";
+import { ExcalidrawElement, ExcalidrawLinearElement, NonDeleted } from "./element/types";
 export declare const rotate: (x1: number, y1: number, x2: number, y2: number, angle: number) => [number, number];
 export declare const rotatePoint: (point: readonly [number, number], center: readonly [number, number], angle: number) => [number, number];
 export declare const adjustXYWithRotation: (sides: {
@@ -17,7 +17,9 @@ export declare const distance2d: (x1: number, y1: number, x2: number, y2: number
 export declare const centerPoint: (a: readonly [number, number], b: readonly [number, number]) => readonly [number, number];
 export declare const isPathALoop: (points: ExcalidrawLinearElement["points"], zoomValue?: Zoom["value"]) => boolean;
 export declare const isPointInPolygon: (points: Point[], x: number, y: number) => boolean;
+export declare const isPointWithinBounds: (p: readonly [number, number], q: readonly [number, number], r: readonly [number, number]) => boolean;
 export declare const getGridPoint: (x: number, y: number, gridSize: number | null) => [number, number];
+export declare const getCornerRadius: (x: number, element: ExcalidrawElement) => number;
 export declare const getControlPointsForBezierCurve: (element: NonDeleted<ExcalidrawLinearElement>, endPoint: readonly [number, number]) => [number, number][] | null;
 export declare const getBezierXY: (p0: readonly [number, number], p1: readonly [number, number], p2: readonly [number, number], p3: readonly [number, number], t: number) => number[];
 export declare const getPointsInBezierCurve: (element: NonDeleted<ExcalidrawLinearElement>, endPoint: readonly [number, number]) => [number, number][];
@@ -25,3 +27,7 @@ export declare const getBezierCurveArcLengths: (element: NonDeleted<ExcalidrawLi
 export declare const getBezierCurveLength: (element: NonDeleted<ExcalidrawLinearElement>, endPoint: readonly [number, number]) => number;
 export declare const mapIntervalToBezierT: (element: NonDeleted<ExcalidrawLinearElement>, endPoint: readonly [number, number], interval: number) => number;
 export declare const arePointsEqual: (p1: readonly [number, number], p2: readonly [number, number]) => boolean;
+export declare const isRightAngle: (angle: number) => boolean;
+export declare const rangesOverlap: ([a0, a1]: [number, number], [b0, b1]: [number, number]) => boolean;
+export declare const rangeIntersection: (rangeA: [number, number], rangeB: [number, number]) => [number, number] | null;
+export declare const isValueInRange: (value: number, min: number, max: number) => boolean;

package/types/packages/bbox.d.ts

@@ -0,0 +1,11 @@
+import { Bounds } from "../element/bounds";
+import { Point } from "../types";
+export type LineSegment = [Point, Point];
+export declare function getBBox(line: LineSegment): Bounds;
+export declare function crossProduct(a: Point, b: Point): number;
+export declare function doBBoxesIntersect(a: Bounds, b: Bounds): boolean;
+export declare function translate(a: Point, b: Point): Point;
+export declare function isPointOnLine(l: LineSegment, p: Point): boolean;
+export declare function isPointRightOfLine(l: LineSegment, p: Point): boolean;
+export declare function isLineSegmentTouchingOrCrossingLine(a: LineSegment, b: LineSegment): boolean;
+export declare function doLineSegmentsIntersect(a: LineSegment, b: LineSegment): boolean;

package/types/packages/excalidraw/example/App.d.ts

@@ -1,8 +1,14 @@
 import type * as TExcalidraw from "../index";
 import "./App.scss";
+import { ExcalidrawImperativeAPI } from "../../../types";
 declare global {
     interface Window {
         ExcalidrawLib: typeof TExcalidraw;
     }
 }
-export default function App(): JSX.Element;
+export interface AppProps {
+    appTitle: string;
+    useCustom: (api: ExcalidrawImperativeAPI | null, customArgs?: any[]) => void;
+    customArgs?: any[];
+}
+export default function App({ appTitle, useCustom, customArgs }: AppProps): JSX.Element;

package/types/packages/excalidraw/example/CustomFooter.d.ts

@@ -0,0 +1,5 @@
+import { ExcalidrawImperativeAPI } from "../../../types";
+declare const CustomFooter: ({ excalidrawAPI, }: {
+    excalidrawAPI: ExcalidrawImperativeAPI;
+}) => JSX.Element;
+export default CustomFooter;

package/types/packages/excalidraw/example/MobileFooter.d.ts

@@ -0,0 +1,5 @@
+import { ExcalidrawImperativeAPI } from "../../../types";
+declare const MobileFooter: ({ excalidrawAPI, }: {
+    excalidrawAPI: ExcalidrawImperativeAPI;
+}) => JSX.Element | null;
+export default MobileFooter;

package/types/packages/excalidraw/example/initialData.d.ts

@@ -1,10 +1,42 @@
-declare namespace _default {
-    const elements: ({
+import { ExcalidrawElementSkeleton } from "../../../data/transform";
+declare const _default: {
+    elements: ExcalidrawElementSkeleton[];
+    appState: {
+        viewBackgroundColor: string;
+        currentItemFontFamily: number;
+    };
+    scrollToContent: boolean;
+    libraryItems: ({
+        type: string;
+        x: number;
+        y: number;
+        strokeColor: string;
+        backgroundColor: string;
+        width: number;
+        height: number;
+        strokeSharpness: string;
+        points: number[][];
+    }[] | ({
+        type: string;
+        fillStyle: string;
+        strokeWidth: number;
+        strokeStyle: string;
+        x: number;
+        y: number;
+        strokeColor: string;
+        backgroundColor: string;
+        width: number;
+        height: number;
+        groupIds: string[];
+        points: number[][];
+        roughness?: undefined;
+        opacity?: undefined;
+        angle?: undefined;
+        seed?: undefined;
+        strokeSharpness?: undefined;
+        boundElementIds?: undefined;
+    } | {
         type: string;
-        version: number;
-        versionNonce: number;
-        isDeleted: boolean;
-        id: string;
         fillStyle: string;
         strokeWidth: number;
         strokeStyle: string;
@@ -18,48 +50,72 @@ declare namespace _default {
         width: number;
         height: number;
         seed: number;
-        groupIds: never[];
-        fileId?: undefined;
-        strokeSharpness?: undefined;
-        boundElements?: undefined;
-        updated?: undefined;
-        link?: undefined;
-        status?: undefined;
-        scale?: undefined;
+        groupIds: string[];
+        strokeSharpness: string;
+        points: number[][];
+        boundElementIds?: undefined;
     } | {
-        fileId: string;
         type: string;
+        fillStyle: string;
+        strokeWidth: number;
+        strokeStyle: string;
+        roughness: number;
+        opacity: number;
+        angle: number;
         x: number;
         y: number;
+        strokeColor: string;
+        backgroundColor: string;
         width: number;
         height: number;
+        seed: number;
+        groupIds: string[];
+        strokeSharpness: string;
+        boundElementIds: string[];
+        points?: undefined;
+    } | {
+        type: string;
+        fillStyle: string;
+        strokeWidth: number;
+        strokeStyle: string;
+        roughness: number;
+        opacity: number;
         angle: number;
+        x: number;
+        y: number;
         strokeColor: string;
         backgroundColor: string;
+        width: number;
+        height: number;
+        seed: number;
+        groupIds: string[];
+        strokeSharpness: string;
+        points?: undefined;
+        boundElementIds?: undefined;
+    })[] | ({
+        type: string;
         fillStyle: string;
         strokeWidth: number;
         strokeStyle: string;
         roughness: number;
         opacity: number;
-        groupIds: never[];
-        strokeSharpness: string;
+        angle: number;
+        x: number;
+        y: number;
+        strokeColor: string;
+        backgroundColor: string;
+        width: number;
+        height: number;
         seed: number;
-        version: number;
-        versionNonce: number;
-        isDeleted: boolean;
-        boundElements: null;
-        updated: number;
-        link: null;
-        status: string;
-        scale: number[];
+        groupIds: string[];
+        strokeSharpness: string;
+        points: number[][];
+        version?: undefined;
+        versionNonce?: undefined;
+        isDeleted?: undefined;
         id?: undefined;
-    })[];
-    namespace appState {
-        const viewBackgroundColor: string;
-        const currentItemFontFamily: number;
-    }
-    const scrollToContent: boolean;
-    const libraryItems: (({
+        boundElementIds?: undefined;
+    } | {
         type: string;
         version: number;
         versionNonce: number;
@@ -80,19 +136,10 @@ declare namespace _default {
         seed: number;
         groupIds: string[];
         strokeSharpness: string;
-        boundElementIds: never[];
-        startBinding: null;
-        endBinding: null;
         points: number[][];
-        lastCommittedPoint: null;
-        startArrowhead: null;
-        endArrowhead: null;
+        boundElementIds?: undefined;
     } | {
         type: string;
-        version: number;
-        versionNonce: number;
-        isDeleted: boolean;
-        id: string;
         fillStyle: string;
         strokeWidth: number;
         strokeStyle: string;
@@ -109,18 +156,13 @@ declare namespace _default {
         groupIds: string[];
         strokeSharpness: string;
         boundElementIds: string[];
-        startBinding?: undefined;
-        endBinding?: undefined;
         points?: undefined;
-        lastCommittedPoint?: undefined;
-        startArrowhead?: undefined;
-        endArrowhead?: undefined;
+        version?: undefined;
+        versionNonce?: undefined;
+        isDeleted?: undefined;
+        id?: undefined;
     })[] | ({
         type: string;
-        version: number;
-        versionNonce: number;
-        isDeleted: boolean;
-        id: string;
         fillStyle: string;
         strokeWidth: number;
         strokeStyle: string;
@@ -136,17 +178,9 @@ declare namespace _default {
         seed: number;
         groupIds: string[];
         strokeSharpness: string;
-        boundElementIds: string[];
         points?: undefined;
-        lastCommittedPoint?: undefined;
-        startArrowhead?: undefined;
-        endArrowhead?: undefined;
     } | {
         type: string;
-        version: number;
-        versionNonce: number;
-        isDeleted: boolean;
-        id: string;
         fillStyle: string;
         strokeWidth: number;
         strokeStyle: string;
@@ -162,11 +196,95 @@ declare namespace _default {
         seed: number;
         groupIds: string[];
         strokeSharpness: string;
-        boundElementIds: never[];
         points: number[][];
-        lastCommittedPoint: null;
-        startArrowhead: null;
-        endArrowhead: null;
+    } | {
+        type: string;
+        fillStyle: string;
+        strokeWidth: number;
+        strokeStyle: string;
+        x: number;
+        y: number;
+        strokeColor: string;
+        backgroundColor: string;
+        width: number;
+        height: number;
+        groupIds: string[];
+        strokeSharpness: string;
+        points: number[][];
+        roughness?: undefined;
+        opacity?: undefined;
+        angle?: undefined;
+        seed?: undefined;
+    } | {
+        type: string;
+        fillStyle: string;
+        strokeWidth: number;
+        strokeStyle: string;
+        roughness: number;
+        opacity: number;
+        angle: number;
+        x: number;
+        y: number;
+        strokeColor: string;
+        backgroundColor: string;
+        width: number;
+        height: number;
+        groupIds: string[];
+        strokeSharpness: string;
+        points: number[][];
+        seed?: undefined;
+    } | {
+        type: string;
+        fillStyle: string;
+        strokeWidth: number;
+        strokeStyle: string;
+        opacity: number;
+        x: number;
+        y: number;
+        strokeColor: string;
+        backgroundColor: string;
+        width: number;
+        height: number;
+        seed: number;
+        groupIds: string[];
+        strokeSharpness: string;
+        points: number[][];
+        roughness?: undefined;
+        angle?: undefined;
+    })[] | ({
+        type: string;
+        fillStyle: string;
+        strokeWidth: number;
+        strokeStyle: string;
+        roughness: number;
+        opacity: number;
+        angle: number;
+        x: number;
+        y: number;
+        strokeColor: string;
+        backgroundColor: string;
+        width: number;
+        height: number;
+        seed: number;
+        groupIds: string[];
+        strokeSharpness: string;
+    } | {
+        type: string;
+        fillStyle: string;
+        strokeWidth: number;
+        strokeStyle: string;
+        x: number;
+        y: number;
+        strokeColor: string;
+        backgroundColor: string;
+        width: number;
+        height: number;
+        seed: number;
+        groupIds: string[];
+        strokeSharpness: string;
+        roughness?: undefined;
+        opacity?: undefined;
+        angle?: undefined;
     })[])[];
-}
+};
 export default _default;

package/types/packages/excalidraw/index.d.ts

@@ -2,18 +2,36 @@ import React from "react";
 import "../../css/app.scss";
 import "../../css/styles.scss";
 import { ExcalidrawAPIRefValue, ExcalidrawProps } from "../../types";
-declare type PublicExcalidrawProps = Omit<ExcalidrawProps, "forwardedRef">;
+import Footer from "../../components/footer/FooterCenter";
+import MainMenu from "../../components/main-menu/MainMenu";
+import WelcomeScreen from "../../components/welcome-screen/WelcomeScreen";
+import LiveCollaborationTrigger from "../../components/live-collaboration/LiveCollaborationTrigger";
+type PublicExcalidrawProps = Omit<ExcalidrawProps, "forwardedRef">;
 export declare const Excalidraw: React.MemoExoticComponent<React.ForwardRefExoticComponent<PublicExcalidrawProps & React.RefAttributes<ExcalidrawAPIRefValue>>>;
 export { getSceneVersion, isInvisiblySmallElement, getNonDeletedElements, } from "../../element";
-export { defaultLang, languages } from "../../i18n";
+export { defaultLang, useI18n, languages } from "../../i18n";
 export { restore, restoreAppState, restoreElements, restoreLibraryItems, } from "../../data/restore";
-export { exportToCanvas, exportToBlob, exportToSvg, serializeAsJSON, serializeLibraryAsJSON, loadLibraryFromBlob, loadFromBlob, loadSceneOrLibraryFromBlob, getFreeDrawSvgPath, exportToClipboard, mergeLibraryItems, } from "../../packages/utils";
+export { exportToBlob, exportToSvg, serializeAsJSON, serializeLibraryAsJSON, loadLibraryFromBlob, loadFromBlob, loadSceneOrLibraryFromBlob, getFreeDrawSvgPath, exportToClipboard, mergeLibraryItems, } from "../../packages/utils";
 export { isLinearElement } from "../../element/typeChecks";
-export { FONT_FAMILY, THEME, MIME_TYPES } from "../../constants";
+export { FONT_FAMILY, THEME, MIME_TYPES, DEFAULT_LASER_COLOR, } from "../../constants";
 export { mutateElement, newElementWith, bumpVersion, } from "../../element/mutateElement";
 export { parseLibraryTokensFromUrl, useHandleLibrary, } from "../../data/library";
 export { sceneCoordsToViewportCoords, viewportCoordsToSceneCoords, } from "../../utils";
 export { Sidebar } from "../../components/Sidebar/Sidebar";
+export { Button } from "../../components/Button";
+export { Footer };
+export { MainMenu };
+export { useDevice } from "../../components/App";
+export { WelcomeScreen };
+export { LiveCollaborationTrigger };
+export { DefaultSidebar } from "../../components/DefaultSidebar";
+export { exportToCanvas } from "../../scene/export";
+export { normalizeLink } from "../../data/url";
+export { convertToExcalidrawElements } from "../../data/transform";
+export { elementsOverlappingBBox, isElementInsideBBox, elementPartiallyOverlapsWithOrContainsBBox, } from "../withinBounds";
 export { getDefaultAppState, cleanAppStateForExport, clearAppStateForLocalStorage, } from "../../appState";
 export { jotaiScope, jotaiStore } from "../../jotai";
 export { libraryItemsAtom } from "../../data/library";
+export * as icons from "../../components/icons";
+export * as actions from "../../actions/index";
+export { duplicateElements, duplicateElement } from "../../element/newElement";

package/types/packages/excalidraw/main.d.ts

@@ -1,2 +1,4 @@
-declare const _exports: any;
+declare const _exports: {
+    ExcalidrawLib: {};
+};
 export = _exports;

package/types/packages/excalidraw/webpack.dev.config.d.ts

@@ -36,13 +36,16 @@ export namespace module {
     } | {
         test: RegExp;
         exclude: RegExp;
-        use: {
+        use: ({
+            loader: string;
+            options?: undefined;
+        } | {
             loader: string;
             options: {
                 transpileOnly: boolean;
                 configFile: string;
             };
-        }[];
+        })[];
         type?: undefined;
     } | {
         test: RegExp;

package/types/packages/excalidraw/webpack.prod.config.d.ts

@@ -36,6 +36,9 @@ export namespace module {
         test: RegExp;
         exclude: RegExp;
         use: ({
+            loader: string;
+            options?: undefined;
+        } | {
             loader: string;
             options: {
                 transpileOnly: boolean;

package/types/packages/utils.d.ts

@@ -1,34 +1,40 @@
-import { AppState, BinaryFiles } from "../types";
-import { ExcalidrawElement, NonDeleted } from "../element/types";
+import { ExportToCanvasConfig, ExportToCanvasData } from "../scene/export";
 import { MIME_TYPES } from "../constants";
 export { MIME_TYPES };
-declare type ExportOpts = {
-    elements: readonly NonDeleted<ExcalidrawElement>[];
-    appState?: Partial<Omit<AppState, "offsetTop" | "offsetLeft">>;
-    files: BinaryFiles | null;
-    maxWidthOrHeight?: number;
-    getDimensions?: (width: number, height: number) => {
-        width: number;
-        height: number;
-        scale?: number;
-    };
-};
-export declare const exportToCanvas: ({ elements, appState, files, maxWidthOrHeight, getDimensions, exportPadding, }: ExportOpts & {
-    exportPadding?: number | undefined;
-}) => Promise<HTMLCanvasElement>;
-export declare const exportToBlob: (opts: ExportOpts & {
+type ExportToBlobConfig = ExportToCanvasConfig & {
     mimeType?: string;
     quality?: number;
+};
+type ExportToSvgConfig = Pick<ExportToCanvasConfig, "canvasBackgroundColor" | "padding" | "theme"> & {
     exportPadding?: number;
+    renderEmbeddables?: boolean;
+};
+export declare const exportToBlob: ({ data, config, }: {
+    data: ExportToCanvasData;
+    config?: ExportToBlobConfig | undefined;
 }) => Promise<Blob>;
-export declare const exportToSvg: ({ elements, appState, files, exportPadding, }: Omit<ExportOpts, "getDimensions"> & {
-    exportPadding?: number | undefined;
+export declare const exportToSvg: ({ data, config, }: {
+    data: ExportToCanvasData;
+    config?: ExportToSvgConfig | undefined;
 }) => Promise<SVGSVGElement>;
-export declare const exportToClipboard: (opts: ExportOpts & {
-    mimeType?: string;
-    quality?: number;
-    type: "png" | "svg" | "json";
-}) => Promise<void>;
+export declare const exportToCanvas: ({ data, config, }: {
+    data: ExportToCanvasData;
+    config?: ExportToCanvasConfig | undefined;
+}) => Promise<HTMLCanvasElement>;
+export declare const exportToClipboard: ({ type, data, config, }: {
+    data: ExportToCanvasData;
+} & ({
+    type: "png";
+    config?: ExportToBlobConfig | undefined;
+} | {
+    type: "svg";
+    config?: ExportToSvgConfig | undefined;
+} | {
+    type: "json";
+    config?: undefined;
+})) => Promise<void>;
+export * from "./bbox";
+export { elementsOverlappingBBox, isElementInsideBBox, elementPartiallyOverlapsWithOrContainsBBox, } from "./withinBounds";
 export { serializeAsJSON, serializeLibraryAsJSON } from "../data/json";
 export { loadFromBlob, loadSceneOrLibraryFromBlob, loadLibraryFromBlob, } from "../data/blob";
 export { getFreeDrawSvgPath } from "../renderer/renderElement";

package/types/packages/withinBounds.d.ts

@@ -0,0 +1,19 @@
+import type { NonDeletedExcalidrawElement } from "../element/types";
+import { Bounds } from "../element/bounds";
+type Element = NonDeletedExcalidrawElement;
+type Elements = readonly NonDeletedExcalidrawElement[];
+export declare const isElementInsideBBox: (element: Element, bbox: Bounds, eitherDirection?: boolean) => boolean;
+export declare const elementPartiallyOverlapsWithOrContainsBBox: (element: Element, bbox: Bounds) => boolean;
+export declare const elementsOverlappingBBox: ({ elements, bounds, type, errorMargin, }: {
+    elements: Elements;
+    bounds: Bounds;
+    /** safety offset. Defaults to 0. */
+    errorMargin?: number | undefined;
+    /**
+     * - overlap: elements overlapping or inside bounds
+     * - contain: elements inside bounds or bounds inside elements
+     * - inside: elements inside bounds
+     **/
+    type: "overlap" | "contain" | "inside";
+}) => NonDeletedExcalidrawElement[];
+export {};

package/types/renderer/renderElement.d.ts

@@ -1,35 +1,26 @@
 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 { BinaryFiles, Zoom } from "../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: RenderConfig["theme"];
-    canvasZoom: Zoom["value"];
+    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;
-declare type ElementShape = Drawable | Drawable[] | null;
-declare 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 let elementWithCanvasCache: WeakMap<ExcalidrawElement, ExcalidrawElementWithCanvas>;
 export declare const clearRenderCache: () => void;
-export declare const generateRoughOptions: (element: ExcalidrawElement, continuousPath?: boolean) => Options;
-export declare const renderElement: (element: NonDeletedExcalidrawElement, rc: RoughCanvas, context: CanvasRenderingContext2D, renderConfig: RenderConfig) => void;
-export declare const renderElementToSvg: (element: NonDeletedExcalidrawElement, rsvg: RoughSVG, svgRoot: SVGElement, files: BinaryFiles, offsetX?: number, offsetY?: number, exportWithDarkMode?: boolean) => void;
+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 let 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 {};

package/types/renderer/renderScene.d.ts

@@ -1,41 +1,31 @@
-import { RoughCanvas } from "roughjs/bin/canvas";
 import { RoughSVG } from "roughjs/bin/svg";
-import { AppState, BinaryFiles } from "../types";
+import { BinaryFiles } from "../types";
 import { NonDeletedExcalidrawElement } from "../element/types";
-import { RenderConfig } from "../scene/types";
+import { InteractiveSceneRenderConfig, StaticSceneRenderConfig } 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;
-}) => {
+/**
+ * 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;
-    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 renderSceneToSvg: (elements: readonly NonDeletedExcalidrawElement[], rsvg: RoughSVG, svgRoot: SVGElement, files: BinaryFiles, { offsetX, offsetY, exportWithDarkMode, }?: {
+    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/renderSnaps.d.ts

@@ -0,0 +1,2 @@
+import { InteractiveCanvasAppState } from "../types";
+export declare const renderSnaps: (context: CanvasRenderingContext2D, appState: InteractiveCanvasAppState) => void;

package/types/renderer/roundRect.d.ts

@@ -8,4 +8,4 @@
  * @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) => void;
+export declare const roundRect: (context: CanvasRenderingContext2D, x: number, y: number, width: number, height: number, radius: number, strokeColor?: string) => void;