@excalidraw/excalidraw 0.15.2 → 0.16.0

package/types/packages/excalidraw/dist/excalidraw-assets-dev/locales/zh-CN-json-09003f959f8d8d9ee650.d.ts

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

package/types/packages/excalidraw/dist/excalidraw-assets-dev/locales/zh-CN-json-8a2394a4129f40872d71.d.ts

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

package/types/packages/excalidraw/dist/excalidraw-assets-dev/locales/zh-HK-json-2f278ce98daca1c37501.d.ts

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

package/types/packages/excalidraw/dist/excalidraw-assets-dev/locales/zh-HK-json-79ea857f9fc00efa982e.d.ts

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

package/types/packages/excalidraw/dist/excalidraw-assets-dev/locales/zh-TW-json-e4eb1416e4564d3a1fd9.d.ts

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

package/types/packages/excalidraw/dist/excalidraw-assets-dev/locales/zh-TW-json-fa855c8136cdf8c637e0.d.ts

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

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

@@ -6,7 +6,7 @@ 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";
-declare type PublicExcalidrawProps = Omit<ExcalidrawProps, "forwardedRef">;
+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, useI18n, languages } from "../../i18n";
@@ -24,3 +24,6 @@ export { MainMenu };
 export { useDevice } from "../../components/App";
 export { WelcomeScreen };
 export { LiveCollaborationTrigger };
+export { DefaultSidebar } from "../../components/DefaultSidebar";
+export { normalizeLink } from "../../data/url";
+export { convertToExcalidrawElements } from "../../data/transform";

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

@@ -2,7 +2,7 @@ import { AppState, BinaryFiles } from "../types";
 import { ExcalidrawElement, NonDeleted } from "../element/types";
 import { MIME_TYPES } from "../constants";
 export { MIME_TYPES };
-declare type ExportOpts = {
+type ExportOpts = {
     elements: readonly NonDeleted<ExcalidrawElement>[];
     appState?: Partial<Omit<AppState, "offsetTop" | "offsetLeft">>;
     files: BinaryFiles | null;
@@ -21,8 +21,9 @@ export declare const exportToBlob: (opts: ExportOpts & {
     quality?: number;
     exportPadding?: number;
 }) => Promise<Blob>;
-export declare const exportToSvg: ({ elements, appState, files, exportPadding, }: Omit<ExportOpts, "getDimensions"> & {
+export declare const exportToSvg: ({ elements, appState, files, exportPadding, renderEmbeddables, }: Omit<ExportOpts, "getDimensions"> & {
     exportPadding?: number | undefined;
+    renderEmbeddables?: boolean | undefined;
 }) => Promise<SVGSVGElement>;
 export declare const exportToClipboard: (opts: ExportOpts & {
     mimeType?: string;

package/types/renderer/renderElement.d.ts

@@ -1,36 +1,25 @@
 import { ExcalidrawElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, ExcalidrawFreeDrawElement } from "../element/types";
-import { RoughCanvas } from "roughjs/bin/canvas";
-import { Drawable, Options } from "roughjs/bin/core";
-import { RoughSVG } from "roughjs/bin/svg";
-import { RenderConfig } from "../scene/types";
-import { AppState, BinaryFiles } from "../types";
+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"];
+    theme: AppState["theme"];
     scale: number;
-    zoomValue: RenderConfig["zoom"]["value"];
+    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 const generateRoughOptions: (element: ExcalidrawElement, continuousPath?: boolean) => Options;
-export declare const renderElement: (element: NonDeletedExcalidrawElement, rc: RoughCanvas, context: CanvasRenderingContext2D, renderConfig: RenderConfig, appState: AppState) => void;
-export declare const renderElementToSvg: (element: NonDeletedExcalidrawElement, rsvg: RoughSVG, svgRoot: SVGElement, files: BinaryFiles, offsetX: number, offsetY: number, exportWithDarkMode?: boolean) => void;
+export declare const elementWithCanvasCache: WeakMap<ExcalidrawElement, ExcalidrawElementWithCanvas>;
+export declare const renderSelectionElement: (element: NonDeletedExcalidrawElement, context: CanvasRenderingContext2D, appState: InteractiveCanvasAppState) => void;
+export declare const renderElement: (element: NonDeletedExcalidrawElement, rc: RoughCanvas, context: CanvasRenderingContext2D, renderConfig: StaticCanvasRenderConfig, appState: StaticCanvasAppState) => void;
+export declare const renderElementToSvg: (element: NonDeletedExcalidrawElement, rsvg: RoughSVG, svgRoot: SVGElement, files: BinaryFiles, offsetX: number, offsetY: number, exportWithDarkMode?: boolean, exportingFrameId?: string | null, renderEmbeddables?: boolean) => void;
 export declare const pathsCache: WeakMap<ExcalidrawFreeDrawElement, Path2D>;
 export declare function generateFreeDrawShape(element: ExcalidrawFreeDrawElement): Path2D;
 export declare function getFreeDrawPath2D(element: ExcalidrawFreeDrawElement): Path2D | undefined;
 export declare function getFreeDrawSvgPath(element: ExcalidrawFreeDrawElement): string;
-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/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;

package/types/scene/Renderer.d.ts

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

package/types/scene/Scene.d.ts

@@ -1,9 +1,11 @@
-import { ExcalidrawElement, NonDeletedExcalidrawElement, NonDeleted } from "../element/types";
+import { ExcalidrawElement, NonDeletedExcalidrawElement, NonDeleted, ExcalidrawFrameElement } from "../element/types";
 import { LinearElementEditor } from "../element/linearElementEditor";
-declare type ElementIdKey = InstanceType<typeof LinearElementEditor>["elementId"];
-declare type ElementKey = ExcalidrawElement | ElementIdKey;
-declare type SceneStateCallback = () => void;
-declare type SceneStateCallbackRemover = () => void;
+import { AppState } from "../types";
+type ElementIdKey = InstanceType<typeof LinearElementEditor>["elementId"];
+type ElementKey = ExcalidrawElement | ElementIdKey;
+type SceneStateCallback = () => void;
+type SceneStateCallbackRemover = () => void;
+export type ExcalidrawElementsIncludingDeleted = readonly ExcalidrawElement[];
 declare class Scene {
     private static sceneMapByElement;
     private static sceneMapById;
@@ -12,10 +14,28 @@ declare class Scene {
     private callbacks;
     private nonDeletedElements;
     private elements;
+    private nonDeletedFrames;
+    private frames;
     private elementsMap;
+    private selectedElementsCache;
+    private versionNonce;
     getElementsIncludingDeleted(): readonly ExcalidrawElement[];
     getNonDeletedElements(): readonly NonDeletedExcalidrawElement[];
+    getFramesIncludingDeleted(): readonly ExcalidrawFrameElement[];
+    getSelectedElements(opts: {
+        selectedElementIds: AppState["selectedElementIds"];
+        /**
+         * for specific cases where you need to use elements not from current
+         * scene state. This in effect will likely result in cache-miss, and
+         * the cache won't be updated in this case.
+         */
+        elements?: readonly ExcalidrawElement[];
+        includeBoundTextElement?: boolean;
+        includeElementsInFrames?: boolean;
+    }): NonDeleted<ExcalidrawElement>[];
+    getNonDeletedFrames(): readonly NonDeleted<ExcalidrawFrameElement>[];
     getElement<T extends ExcalidrawElement>(id: T["id"]): T | null;
+    getVersionNonce(): number | undefined;
     getNonDeletedElement(id: ExcalidrawElement["id"]): NonDeleted<ExcalidrawElement> | null;
     /**
      * A utility method to help with updating all scene elements, with the added
@@ -35,6 +55,8 @@ declare class Scene {
     addCallback(cb: SceneStateCallback): SceneStateCallbackRemover;
     destroy(): void;
     insertElementAtIndex(element: ExcalidrawElement, index: number): void;
+    insertElementsAtIndex(elements: ExcalidrawElement[], index: number): void;
+    addNewElement: (element: ExcalidrawElement) => void;
     getElementIndex(elementId: string): number;
 }
 export default Scene;

package/types/scene/Shape.d.ts

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

package/types/scene/ShapeCache.d.ts

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