@zsviczian/excalidraw 0.18.0-2 → 0.18.0-3

package/types/excalidraw/publicPath.d.ts

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

package/types/excalidraw/queue.d.ts

@@ -1,9 +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 {};
+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

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

@@ -1,14 +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;
+/**
+ * @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

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

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

@@ -1,13 +1,13 @@
-import type { StaticCanvasRenderConfig } from "../scene/types";
-import type { StaticCanvasAppState, AppState } from "../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;
+import type { StaticCanvasRenderConfig } from "../scene/types";
+import type { StaticCanvasAppState, AppState } from "../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

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

@@ -1,28 +1,28 @@
-import type { ExcalidrawElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, ExcalidrawFreeDrawElement, ExcalidrawImageElement, ExcalidrawFrameLikeElement, NonDeletedSceneElementsMap } from "../element/types";
-import type { StaticCanvasRenderConfig, RenderableElementsMap, InteractiveCanvasRenderConfig } from "../scene/types";
-import type { AppState, StaticCanvasAppState, InteractiveCanvasAppState, ElementsPendingErasure, PendingExcalidrawElements } from "../types";
-import type { RoughCanvas } from "roughjs/bin/canvas";
-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;
+import type { ExcalidrawElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, ExcalidrawFreeDrawElement, ExcalidrawImageElement, ExcalidrawFrameLikeElement, NonDeletedSceneElementsMap } from "../element/types";
+import type { StaticCanvasRenderConfig, RenderableElementsMap, InteractiveCanvasRenderConfig } from "../scene/types";
+import type { AppState, StaticCanvasAppState, InteractiveCanvasAppState, ElementsPendingErasure, PendingExcalidrawElements } from "../types";
+import type { RoughCanvas } from "roughjs/bin/canvas";
+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

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

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

package/types/excalidraw/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/excalidraw/renderer/staticScene.d.ts

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

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

@@ -1,28 +1,28 @@
-import type Scene from "./Scene";
-import type { ExcalidrawElement, NonDeletedExcalidrawElement } from "../element/types";
-import type { AppState } from "../types";
-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;
-}
+import type Scene from "./Scene";
+import type { ExcalidrawElement, NonDeletedExcalidrawElement } from "../element/types";
+import type { AppState } from "../types";
+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

@@ -1,79 +1,79 @@
-import type { LinearElementEditor } from "../element/linearElementEditor";
-import type { ExcalidrawElement, NonDeletedExcalidrawElement, NonDeleted, ExcalidrawFrameLikeElement, ElementsMapOrArray, OrderedExcalidrawElement, Ordered } from "../element/types";
-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").ExcalidrawLinearElement | import("../element/types").ExcalidrawSelectionElement | import("../element/types").ExcalidrawRectangleElement | import("../element/types").ExcalidrawDiamondElement | import("../element/types").ExcalidrawEllipseElement | import("../element/types").ExcalidrawEmbeddableElement | import("../element/types").ExcalidrawIframeElement | import("../element/types").ExcalidrawImageElement | import("../element/types").ExcalidrawFrameElement | import("../element/types").ExcalidrawMagicFrameElement | import("../element/types").ExcalidrawTextElement | import("../element/types").ExcalidrawFreeDrawElement | null;
-    getElementsFromId: (id: string) => ExcalidrawElement[];
-}
-export default Scene;
+import type { LinearElementEditor } from "../element/linearElementEditor";
+import type { ExcalidrawElement, NonDeletedExcalidrawElement, NonDeleted, ExcalidrawFrameLikeElement, ElementsMapOrArray, OrderedExcalidrawElement, Ordered } from "../element/types";
+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").ExcalidrawLinearElement | import("../element/types").ExcalidrawSelectionElement | import("../element/types").ExcalidrawRectangleElement | import("../element/types").ExcalidrawDiamondElement | import("../element/types").ExcalidrawEllipseElement | import("../element/types").ExcalidrawEmbeddableElement | import("../element/types").ExcalidrawIframeElement | import("../element/types").ExcalidrawImageElement | import("../element/types").ExcalidrawFrameElement | import("../element/types").ExcalidrawMagicFrameElement | import("../element/types").ExcalidrawTextElement | import("../element/types").ExcalidrawFreeDrawElement | null;
+    getElementsFromId: (id: string) => ExcalidrawElement[];
+}
+export default Scene;

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

@@ -1,17 +1,17 @@
-import type { ExcalidrawElement, NonDeletedExcalidrawElement, ExcalidrawSelectionElement } from "../element/types";
-import type { EmbedsValidationStatus } from "../types";
-import type { Drawable, Options } from "roughjs/bin/core";
-import type { RoughGenerator } from "roughjs/bin/generator";
-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;
+import type { ExcalidrawElement, NonDeletedExcalidrawElement, ExcalidrawSelectionElement } from "../element/types";
+import type { EmbedsValidationStatus } from "../types";
+import type { Drawable, Options } from "roughjs/bin/core";
+import type { RoughGenerator } from "roughjs/bin/generator";
+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

@@ -1,25 +1,25 @@
-import type { ExcalidrawElement } from "../element/types";
-import type { AppState, EmbedsValidationStatus } from "../types";
-import type { ElementShape, ElementShapes } from "./types";
-import type { Drawable } from "roughjs/bin/core";
-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").ExcalidrawIframeElement | import("../element/types").ExcalidrawImageElement | import("../element/types").ExcalidrawFrameElement | import("../element/types").ExcalidrawMagicFrameElement | import("../element/types").ExcalidrawTextElement | import("../element/types").ExcalidrawFreeDrawElement | import("../element/types").ExcalidrawArrowElement>(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);
-}
+import type { ExcalidrawElement } from "../element/types";
+import type { AppState, EmbedsValidationStatus } from "../types";
+import type { ElementShape, ElementShapes } from "./types";
+import type { Drawable } from "roughjs/bin/core";
+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").ExcalidrawIframeElement | import("../element/types").ExcalidrawImageElement | import("../element/types").ExcalidrawFrameElement | import("../element/types").ExcalidrawMagicFrameElement | import("../element/types").ExcalidrawTextElement | import("../element/types").ExcalidrawFreeDrawElement | import("../element/types").ExcalidrawArrowElement>(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);
+}

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

@@ -1,8 +1,8 @@
-import type { ElementOrToolType } from "../types";
-export declare const hasBackground: (type: ElementOrToolType) => boolean;
-export declare const hasStrokeColor: (type: ElementOrToolType) => boolean;
-export declare const hasStrokeWidth: (type: ElementOrToolType) => boolean;
-export declare const hasStrokeStyle: (type: ElementOrToolType) => boolean;
-export declare const canChangeRoundness: (type: ElementOrToolType) => boolean;
-export declare const toolIsArrow: (type: ElementOrToolType) => boolean;
-export declare const canHaveArrowheads: (type: ElementOrToolType) => boolean;
+import type { ElementOrToolType } from "../types";
+export declare const hasBackground: (type: ElementOrToolType) => boolean;
+export declare const hasStrokeColor: (type: ElementOrToolType) => boolean;
+export declare const hasStrokeWidth: (type: ElementOrToolType) => boolean;
+export declare const hasStrokeStyle: (type: ElementOrToolType) => boolean;
+export declare const canChangeRoundness: (type: ElementOrToolType) => boolean;
+export declare const toolIsArrow: (type: ElementOrToolType) => boolean;
+export declare const canHaveArrowheads: (type: ElementOrToolType) => boolean;