@zsviczian/excalidraw 0.17.6-30 → 0.17.6-31

package/types/excalidraw/keys.d.ts

@@ -0,0 +1,189 @@
+import type { ValueOf } from "./utility-types";
+export declare const CODES: {
+    readonly EQUAL: "Equal";
+    readonly MINUS: "Minus";
+    readonly NUM_ADD: "NumpadAdd";
+    readonly NUM_SUBTRACT: "NumpadSubtract";
+    readonly NUM_ZERO: "Numpad0";
+    readonly BRACKET_RIGHT: "BracketRight";
+    readonly BRACKET_LEFT: "BracketLeft";
+    readonly ONE: "Digit1";
+    readonly TWO: "Digit2";
+    readonly THREE: "Digit3";
+    readonly NINE: "Digit9";
+    readonly QUOTE: "Quote";
+    readonly ZERO: "Digit0";
+    readonly SLASH: "Slash";
+    readonly C: "KeyC";
+    readonly D: "KeyD";
+    readonly H: "KeyH";
+    readonly V: "KeyV";
+    readonly Z: "KeyZ";
+    readonly Y: "KeyY";
+    readonly R: "KeyR";
+    readonly S: "KeyS";
+};
+export declare const KEYS: {
+    readonly ARROW_DOWN: "ArrowDown";
+    readonly ARROW_LEFT: "ArrowLeft";
+    readonly ARROW_RIGHT: "ArrowRight";
+    readonly ARROW_UP: "ArrowUp";
+    readonly PAGE_UP: "PageUp";
+    readonly PAGE_DOWN: "PageDown";
+    readonly BACKSPACE: "Backspace";
+    readonly ALT: "Alt";
+    readonly CTRL_OR_CMD: "metaKey" | "ctrlKey";
+    readonly DELETE: "Delete";
+    readonly ENTER: "Enter";
+    readonly ESCAPE: "Escape";
+    readonly QUESTION_MARK: "?";
+    readonly SPACE: " ";
+    readonly TAB: "Tab";
+    readonly CHEVRON_LEFT: "<";
+    readonly CHEVRON_RIGHT: ">";
+    readonly PERIOD: ".";
+    readonly COMMA: ",";
+    readonly SUBTRACT: "-";
+    readonly SLASH: "/";
+    readonly A: "a";
+    readonly C: "c";
+    readonly D: "d";
+    readonly E: "e";
+    readonly F: "f";
+    readonly G: "g";
+    readonly H: "h";
+    readonly I: "i";
+    readonly L: "l";
+    readonly O: "o";
+    readonly P: "p";
+    readonly Q: "q";
+    readonly R: "r";
+    readonly S: "s";
+    readonly T: "t";
+    readonly V: "v";
+    readonly X: "x";
+    readonly Y: "y";
+    readonly Z: "z";
+    readonly K: "k";
+    readonly W: "w";
+    readonly 0: "0";
+    readonly 1: "1";
+    readonly 2: "2";
+    readonly 3: "3";
+    readonly 4: "4";
+    readonly 5: "5";
+    readonly 6: "6";
+    readonly 7: "7";
+    readonly 8: "8";
+    readonly 9: "9";
+};
+export type Key = keyof typeof KEYS;
+export declare const KeyCodeMap: Map<ValueOf<{
+    readonly ARROW_DOWN: "ArrowDown";
+    readonly ARROW_LEFT: "ArrowLeft";
+    readonly ARROW_RIGHT: "ArrowRight";
+    readonly ARROW_UP: "ArrowUp";
+    readonly PAGE_UP: "PageUp";
+    readonly PAGE_DOWN: "PageDown";
+    readonly BACKSPACE: "Backspace";
+    readonly ALT: "Alt";
+    readonly CTRL_OR_CMD: "metaKey" | "ctrlKey";
+    readonly DELETE: "Delete";
+    readonly ENTER: "Enter";
+    readonly ESCAPE: "Escape";
+    readonly QUESTION_MARK: "?";
+    readonly SPACE: " ";
+    readonly TAB: "Tab";
+    readonly CHEVRON_LEFT: "<";
+    readonly CHEVRON_RIGHT: ">";
+    readonly PERIOD: ".";
+    readonly COMMA: ",";
+    readonly SUBTRACT: "-";
+    readonly SLASH: "/";
+    readonly A: "a";
+    readonly C: "c";
+    readonly D: "d";
+    readonly E: "e";
+    readonly F: "f";
+    readonly G: "g";
+    readonly H: "h";
+    readonly I: "i";
+    readonly L: "l";
+    readonly O: "o";
+    readonly P: "p";
+    readonly Q: "q";
+    readonly R: "r";
+    readonly S: "s";
+    readonly T: "t";
+    readonly V: "v";
+    readonly X: "x";
+    readonly Y: "y";
+    readonly Z: "z";
+    readonly K: "k";
+    readonly W: "w";
+    readonly 0: "0";
+    readonly 1: "1";
+    readonly 2: "2";
+    readonly 3: "3";
+    readonly 4: "4";
+    readonly 5: "5";
+    readonly 6: "6";
+    readonly 7: "7";
+    readonly 8: "8";
+    readonly 9: "9";
+}>, ValueOf<{
+    readonly EQUAL: "Equal";
+    readonly MINUS: "Minus";
+    readonly NUM_ADD: "NumpadAdd";
+    readonly NUM_SUBTRACT: "NumpadSubtract";
+    readonly NUM_ZERO: "Numpad0";
+    readonly BRACKET_RIGHT: "BracketRight";
+    readonly BRACKET_LEFT: "BracketLeft";
+    readonly ONE: "Digit1";
+    readonly TWO: "Digit2";
+    readonly THREE: "Digit3";
+    readonly NINE: "Digit9";
+    readonly QUOTE: "Quote";
+    readonly ZERO: "Digit0";
+    readonly SLASH: "Slash";
+    readonly C: "KeyC";
+    readonly D: "KeyD";
+    readonly H: "KeyH";
+    readonly V: "KeyV";
+    readonly Z: "KeyZ";
+    readonly Y: "KeyY";
+    readonly R: "KeyR";
+    readonly S: "KeyS";
+}>>;
+export declare const isLatinChar: (key: string) => boolean;
+/**
+ * Used to match key events for any keyboard layout, especially on Windows and Linux,
+ * where non-latin character with modified (CMD) is not substituted with latin-based alternative.
+ *
+ * Uses `event.key` when it's latin, otherwise fallbacks to `event.code` (if mapping exists).
+ *
+ * Example of pressing "z" on different layouts, with the chosen key or code highlighted in []:
+ *
+ * Layout                | Code  | Key | Comment
+ * --------------------- | ----- | --- | -------
+ * U.S.                  |  KeyZ  | [z] |
+ * Czech                 |  KeyY  | [z] |
+ * Turkish               |  KeyN  | [z] |
+ * French                |  KeyW  | [z] |
+ * Macedonian            | [KeyZ] |  з  | z with cmd; з is Cyrillic equivalent of z
+ * Russian               | [KeyZ] |  я  | z with cmd
+ * Serbian               | [KeyZ] |  ѕ  | z with cmd
+ * Greek                 | [KeyZ] |  ζ  | z with cmd; also ζ is Greek equivalent of z
+ * Hebrew                | [KeyZ] |  ז  | z with cmd; also ז is Hebrew equivalent of z
+ * Pinyin - Simplified   |  KeyZ  | [z] | due to IME
+ * Cangije - Traditional | [KeyZ] |  重 | z with cmd
+ * Japanese              | [KeyZ] |  つ | z with cmd
+ * 2-Set Korean          | [KeyZ] |  ㅋ | z with cmd
+ *
+ * More details in https://github.com/excalidraw/excalidraw/pull/5944
+ */
+export declare const matchKey: (event: KeyboardEvent | React.KeyboardEvent<Element>, key: ValueOf<typeof KEYS>) => boolean;
+export declare const isArrowKey: (key: string) => boolean;
+export declare const shouldResizeFromCenter: (event: MouseEvent | KeyboardEvent) => boolean;
+export declare const shouldMaintainAspectRatio: (event: MouseEvent | KeyboardEvent) => boolean;
+export declare const shouldRotateWithDiscreteAngle: (event: MouseEvent | KeyboardEvent | React.PointerEvent<HTMLCanvasElement>) => boolean;

package/types/excalidraw/laser-trails.d.ts

@@ -0,0 +1,20 @@
+import type { Trail } from "./animated-trail";
+import { AnimatedTrail } from "./animated-trail";
+import type { AnimationFrameHandler } from "./animation-frame-handler";
+import type App from "./components/App";
+export declare class LaserTrails implements Trail {
+    private animationFrameHandler;
+    private app;
+    localTrail: AnimatedTrail;
+    private collabTrails;
+    private container?;
+    constructor(animationFrameHandler: AnimationFrameHandler, app: App);
+    private getTrailOptions;
+    startPath(x: number, y: number): void;
+    addPointToPath(x: number, y: number): void;
+    endPath(): void;
+    start(container: SVGSVGElement): void;
+    stop(): void;
+    onFrame(): void;
+    private updateCollabTrails;
+}

package/types/excalidraw/main.d.ts

@@ -0,0 +1,2 @@
+declare const _exports: any;
+export = _exports;

package/types/excalidraw/mermaid.d.ts

@@ -0,0 +1,2 @@
+/** heuristically checks whether the text may be a mermaid diagram definition */
+export declare const isMaybeMermaidDefinition: (text: string) => boolean;

package/types/excalidraw/obsidianUtils.d.ts

@@ -0,0 +1,26 @@
+import type { MermaidToExcalidrawLibProps } from "./components/TTDDialog/common";
+import type { NonDeletedExcalidrawElement } from "./element/types";
+import type { FontMetadata } from "./fonts/FontMetadata";
+import type { AppState } from "./types";
+export declare let hostPlugin: any;
+export declare function destroyObsidianUtils(): void;
+export declare function initializeObsidianUtils(): void;
+export declare function getAreaLimit(): any;
+export declare function getWidthHeightLimit(): any;
+export declare function allowDoubleTapEraser(): any;
+export declare function getMaxZoom(): number;
+export declare function isExcaliBrainView(): any;
+export declare function getExcalidrawContentEl(): HTMLElement;
+export declare function hideFreedrawPenmodeCursor(): boolean;
+export declare function getOpenAIDefaultVisionModel(): any;
+export declare function registerLocalFont(fontMetrics: FontMetadata & {
+    name: string;
+}, uri: string): void;
+export declare function getFontFamilies(): string[];
+export declare function registerFontsInCSS(): Promise<void>;
+export declare function getCSSFontDefinition(fontFamily: number): Promise<string>;
+export declare function loadSceneFonts(elements: NonDeletedExcalidrawElement[]): Promise<FontFace[]>;
+export declare function fetchFontFromVault(url: string | URL): Promise<ArrayBuffer | undefined>;
+export declare function isTouchInPenMode(appState: AppState, event: React.PointerEvent<HTMLElement> | MouseEvent): boolean;
+export declare function getSharedMermaidInstance(): Promise<MermaidToExcalidrawLibProps>;
+export declare function loadMermaid(): Promise<MermaidToExcalidrawLibProps>;

package/types/excalidraw/points.d.ts

@@ -0,0 +1,7 @@
+import { type GlobalPoint, type LocalPoint } from "../math";
+export declare const getSizeFromPoints: (points: readonly (GlobalPoint | LocalPoint)[]) => {
+    width: number;
+    height: number;
+};
+/** @arg dimension, 0 for rescaling only x, 1 for y */
+export declare const rescalePoints: <Point extends GlobalPoint | LocalPoint>(dimension: 0 | 1, newSize: number, points: readonly Point[], normalize: boolean) => Point[];

package/types/excalidraw/polyfill.d.ts

@@ -0,0 +1,2 @@
+declare const polyfill: () => void;
+export default polyfill;

package/types/excalidraw/publicPath.d.ts

@@ -0,0 +1 @@
+export {};

package/types/excalidraw/queue.d.ts

@@ -0,0 +1,9 @@
+import type { MaybePromise } from "./utility-types";
+type Job<T, TArgs extends unknown[]> = (...args: TArgs) => MaybePromise<T>;
+export declare class Queue {
+    private jobs;
+    private running;
+    private tick;
+    push<TValue, TArgs extends unknown[]>(jobFactory: Job<TValue, TArgs>, ...args: TArgs): Promise<TValue>;
+}
+export {};

package/types/excalidraw/random.d.ts

@@ -0,0 +1,4 @@
+export declare const randomInteger: () => number;
+export declare const reseed: (seed: number) => void;
+export declare const randomId: () => string;
+export declare const obsidianId: (size?: number | undefined) => string;

package/types/excalidraw/reactUtils.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @param func handler taking at most single parameter (event).
+ */
+export declare const withBatchedUpdates: <TFunction extends ((event: any) => void) | (() => void)>(func: Parameters<TFunction>["length"] extends 0 | 1 ? TFunction : never) => TFunction;
+/**
+ * barches React state updates and throttles the calls to a single call per
+ * animation frame
+ */
+export declare const withBatchedUpdatesThrottled: <TFunction extends ((event: any) => void) | (() => void)>(func: Parameters<TFunction>["length"] extends 0 | 1 ? TFunction : never) => {
+    (...args: Parameters<TFunction>): void;
+    flush(): void;
+    cancel(): void;
+};
+export declare const isRenderThrottlingEnabled: () => boolean;

package/types/excalidraw/renderer/easingFunctions.d.ts

@@ -0,0 +1,6 @@
+type EasingFunction = (progress: number) => number;
+interface EasingDictionary {
+    [easing: string]: EasingFunction;
+}
+declare const easingsFunctions: EasingDictionary;
+export default easingsFunctions;

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

@@ -0,0 +1,13 @@
+import type { StaticCanvasAppState, AppState } from "../types";
+import type { StaticCanvasRenderConfig } from "../scene/types";
+export declare const fillCircle: (context: CanvasRenderingContext2D, cx: number, cy: number, radius: number, stroke?: boolean) => void;
+export declare const getNormalizedCanvasDimensions: (canvas: HTMLCanvasElement, scale: number) => [number, number];
+export declare const bootstrapCanvas: ({ canvas, scale, normalizedWidth, normalizedHeight, theme, isExporting, viewBackgroundColor, }: {
+    canvas: HTMLCanvasElement;
+    scale: number;
+    normalizedWidth: number;
+    normalizedHeight: number;
+    theme?: import("../element/types").Theme | undefined;
+    isExporting?: boolean | undefined;
+    viewBackgroundColor?: string | null | undefined;
+}) => CanvasRenderingContext2D;

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

@@ -0,0 +1,20 @@
+import type { InteractiveSceneRenderConfig, RenderableElementsMap } from "../scene/types";
+/** throttled to animation framerate */
+export declare const renderInteractiveSceneThrottled: {
+    (config: InteractiveSceneRenderConfig): void;
+    flush(): void;
+    cancel(): void;
+};
+/**
+ * Interactive scene is the ui-canvas where we render bounding boxes, selections
+ * and other ui stuff.
+ */
+export declare const renderInteractiveScene: <U extends ({ canvas, elementsMap, visibleElements, selectedElements, allElementsMap, scale, appState, renderConfig, device, }: InteractiveSceneRenderConfig) => {
+    atLeastOneVisibleElement: boolean;
+    elementsMap: RenderableElementsMap;
+    scrollBars?: undefined;
+} | {
+    scrollBars: import("../scene/types").ScrollBars | undefined;
+    atLeastOneVisibleElement: boolean;
+    elementsMap: RenderableElementsMap;
+}, T extends boolean = false>(renderConfig: InteractiveSceneRenderConfig, throttle?: T | undefined) => T extends true ? void : ReturnType<U>;

package/types/excalidraw/renderer/renderElement.d.ts

@@ -0,0 +1,28 @@
+import type { ExcalidrawElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, ExcalidrawFreeDrawElement, ExcalidrawImageElement, ExcalidrawFrameLikeElement, NonDeletedSceneElementsMap } from "../element/types";
+import type { RoughCanvas } from "roughjs/bin/canvas";
+import type { StaticCanvasRenderConfig, RenderableElementsMap, InteractiveCanvasRenderConfig } from "../scene/types";
+import type { AppState, StaticCanvasAppState, InteractiveCanvasAppState, ElementsPendingErasure, PendingExcalidrawElements } from "../types";
+export declare const IMAGE_INVERT_FILTER = "invert(100%) hue-rotate(180deg) saturate(1.25)";
+export declare const getRenderOpacity: (element: ExcalidrawElement, containingFrame: ExcalidrawFrameLikeElement | null, elementsPendingErasure: ElementsPendingErasure, pendingNodes: Readonly<PendingExcalidrawElements> | null, globalAlpha?: number) => number;
+export interface ExcalidrawElementWithCanvas {
+    element: ExcalidrawElement | ExcalidrawTextElement;
+    canvas: HTMLCanvasElement;
+    theme: AppState["theme"];
+    scale: number;
+    angle: number;
+    zoomValue: AppState["zoom"]["value"];
+    canvasOffsetX: number;
+    canvasOffsetY: number;
+    boundTextElementVersion: number | null;
+    imageCrop: ExcalidrawImageElement["crop"] | null;
+    containingFrameOpacity: number;
+    boundTextCanvas: HTMLCanvasElement;
+}
+export declare const DEFAULT_LINK_SIZE = 14;
+export declare const elementWithCanvasCache: WeakMap<ExcalidrawElement, ExcalidrawElementWithCanvas>;
+export declare const renderSelectionElement: (element: NonDeletedExcalidrawElement, context: CanvasRenderingContext2D, appState: InteractiveCanvasAppState, selectionColor: InteractiveCanvasRenderConfig["selectionColor"]) => void;
+export declare const renderElement: (element: NonDeletedExcalidrawElement, elementsMap: RenderableElementsMap, allElementsMap: NonDeletedSceneElementsMap, rc: RoughCanvas, context: CanvasRenderingContext2D, renderConfig: StaticCanvasRenderConfig, appState: StaticCanvasAppState) => 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/excalidraw/renderer/renderNewElementScene.d.ts

@@ -0,0 +1,7 @@
+import type { NewElementSceneRenderConfig } from "../scene/types";
+export declare const renderNewElementSceneThrottled: {
+    (config: NewElementSceneRenderConfig): void;
+    flush(): void;
+    cancel(): void;
+};
+export declare const renderNewElementScene: (renderConfig: NewElementSceneRenderConfig, throttle?: boolean) => void;

package/types/excalidraw/renderer/renderSnaps.d.ts

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

package/types/excalidraw/renderer/roundRect.d.ts

@@ -0,0 +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;

package/types/excalidraw/renderer/staticScene.d.ts

@@ -0,0 +1,11 @@
+import type { StaticSceneRenderConfig } from "../scene/types";
+/** throttled to animation framerate */
+export declare const renderStaticSceneThrottled: {
+    (config: StaticSceneRenderConfig): void;
+    flush(): void;
+    cancel(): void;
+};
+/**
+ * Static scene is the non-ui canvas where we render elements.
+ */
+export declare const renderStaticScene: (renderConfig: StaticSceneRenderConfig, throttle?: boolean) => void;

package/types/excalidraw/renderer/staticSvgScene.d.ts

@@ -0,0 +1,5 @@
+import type { RoughSVG } from "roughjs/bin/svg";
+import type { NonDeletedExcalidrawElement } from "../element/types";
+import type { RenderableElementsMap, SVGRenderConfig } from "../scene/types";
+import type { BinaryFiles } from "../types";
+export declare const renderSceneToSvg: (elements: readonly NonDeletedExcalidrawElement[], elementsMap: RenderableElementsMap, rsvg: RoughSVG, svgRoot: SVGElement, files: BinaryFiles, renderConfig: SVGRenderConfig) => void;

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

@@ -0,0 +1,28 @@
+import type { ExcalidrawElement, NonDeletedExcalidrawElement } from "../element/types";
+import type { AppState } from "../types";
+import type 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"];
+        editingTextElement: AppState["editingTextElement"];
+        /** note: first render of newElement will always bust the cache
+         * (we'd have to prefilter elements outside of this function) */
+        newElementId: ExcalidrawElement["id"] | undefined;
+        pendingImageElementId: AppState["pendingImageElementId"];
+        sceneNonce: ReturnType<InstanceType<typeof Scene>["getSceneNonce"]>;
+    }) => {
+        elementsMap: Map<string, NonDeletedExcalidrawElement> & import("../utility-types").MakeBrand<"NonDeletedElementsMap"> & import("../utility-types").MakeBrand<"RenderableElementsMap">;
+        visibleElements: readonly NonDeletedExcalidrawElement[];
+    }) & {
+        clear: () => void;
+    };
+    destroy(): void;
+}

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

@@ -0,0 +1,79 @@
+import type { ExcalidrawElement, NonDeletedExcalidrawElement, NonDeleted, ExcalidrawFrameLikeElement, ElementsMapOrArray, OrderedExcalidrawElement, Ordered } from "../element/types";
+import type { LinearElementEditor } from "../element/linearElementEditor";
+import type { 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;
+    /**
+     * @deprecated pass down `app.scene` and use it directly
+     */
+    static getScene(elementKey: ElementKey): Scene | null;
+    private callbacks;
+    private nonDeletedElements;
+    private nonDeletedElementsMap;
+    private elements;
+    private nonDeletedFramesLikes;
+    private frames;
+    private elementsMap;
+    private selectedElementsCache;
+    /**
+     * Random integer regenerated each scene update.
+     *
+     * Does not relate to elements versions, it's only a renderer
+     * cache-invalidation nonce at the moment.
+     */
+    private sceneNonce;
+    getSceneNonce(): number | undefined;
+    getNonDeletedElementsMap(): Map<string, Ordered<NonDeletedExcalidrawElement>> & import("../utility-types").MakeBrand<"NonDeletedSceneElementsMap">;
+    getElementsIncludingDeleted(): readonly OrderedExcalidrawElement[];
+    getElementsMapIncludingDeleted(): Map<string, Ordered<ExcalidrawElement>> & import("../utility-types").MakeBrand<"SceneElementsMap">;
+    getNonDeletedElements(): readonly Ordered<NonDeletedExcalidrawElement>[];
+    getFramesIncludingDeleted(): readonly ExcalidrawFrameLikeElement[];
+    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?: ElementsMapOrArray;
+        includeBoundTextElement?: boolean;
+        includeElementsInFrames?: boolean;
+    }): NonDeleted<ExcalidrawElement>[];
+    getNonDeletedFramesLikes(): readonly NonDeleted<ExcalidrawFrameLikeElement>[];
+    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: ElementsMapOrArray): void;
+    triggerUpdate(): void;
+    onUpdate(cb: SceneStateCallback): SceneStateCallbackRemover;
+    destroy(): void;
+    insertElementAtIndex(element: ExcalidrawElement, index: number): void;
+    insertElementsAtIndex(elements: ExcalidrawElement[], index: number): void;
+    insertElement: (element: ExcalidrawElement, idx?: number) => void;
+    insertElements: (elements: ExcalidrawElement[]) => void;
+    getElementIndex(elementId: string): number;
+    getContainerElement: (element: (ExcalidrawElement & {
+        containerId: ExcalidrawElement["id"] | null;
+    }) | null) => import("../element/types").ExcalidrawSelectionElement | import("../element/types").ExcalidrawRectangleElement | import("../element/types").ExcalidrawDiamondElement | import("../element/types").ExcalidrawEllipseElement | import("../element/types").ExcalidrawTextElement | import("../element/types").ExcalidrawLinearElement | import("../element/types").ExcalidrawFreeDrawElement | import("../element/types").ExcalidrawImageElement | import("../element/types").ExcalidrawFrameElement | import("../element/types").ExcalidrawMagicFrameElement | import("../element/types").ExcalidrawIframeElement | import("../element/types").ExcalidrawEmbeddableElement | null;
+    getElementsFromId: (id: string) => ExcalidrawElement[];
+}
+export default Scene;

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

@@ -0,0 +1,17 @@
+import type { Drawable, Options } from "roughjs/bin/core";
+import type { RoughGenerator } from "roughjs/bin/generator";
+import type { ExcalidrawElement, NonDeletedExcalidrawElement, ExcalidrawSelectionElement } from "../element/types";
+import type { EmbedsValidationStatus } from "../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, canvasBackgroundColor, embedsValidationStatus, }: {
+    isExporting: boolean;
+    canvasBackgroundColor: string;
+    embedsValidationStatus: EmbedsValidationStatus | null;
+}) => Drawable | Drawable[] | null;

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

@@ -0,0 +1,25 @@
+import type { Drawable } from "roughjs/bin/core";
+import type { ExcalidrawElement } from "../element/types";
+import type { ElementShape, ElementShapes } from "./types";
+import type { AppState, EmbedsValidationStatus } 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").ExcalidrawRectangleElement | import("../element/types").ExcalidrawDiamondElement | import("../element/types").ExcalidrawEllipseElement | import("../element/types").ExcalidrawTextElement | import("../element/types").ExcalidrawLinearElement | import("../element/types").ExcalidrawArrowElement | import("../element/types").ExcalidrawFreeDrawElement | import("../element/types").ExcalidrawImageElement | import("../element/types").ExcalidrawFrameElement | import("../element/types").ExcalidrawMagicFrameElement | import("../element/types").ExcalidrawIframeElement | import("../element/types").ExcalidrawEmbeddableElement>(element: T, renderConfig: {
+        isExporting: boolean;
+        canvasBackgroundColor: AppState["viewBackgroundColor"];
+        embedsValidationStatus: EmbedsValidationStatus;
+    } | null) => ((T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] | undefined : ElementShape | undefined) & ({} | null)) | (T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] : Drawable | null);
+}