@misenkashari/excalidraw-common 1.0.0 → 1.0.3

package/dist/types/excalidraw/i18n.d.ts

@@ -0,0 +1,24 @@
+import type { NestedKeyOf } from "@excalidraw/common/utility-types";
+import fallbackLangData from "./locales/en.json";
+export interface Language {
+    code: string;
+    label: string;
+    rtl?: boolean;
+}
+export type TranslationKeys = NestedKeyOf<typeof fallbackLangData>;
+export declare const defaultLang: {
+    code: string;
+    label: string;
+};
+export declare const languages: Language[];
+export declare const setLanguage: (lang: Language) => Promise<void>;
+export declare const getLanguage: () => Language;
+export declare const t: (path: NestedKeyOf<typeof fallbackLangData>, replacement?: {
+    [key: string]: string | number;
+} | null, fallback?: string) => string;
+export declare const useI18n: () => {
+    t: (path: NestedKeyOf<typeof fallbackLangData>, replacement?: {
+        [key: string]: string | number;
+    } | null, fallback?: string) => string;
+    langCode: string;
+};

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

@@ -0,0 +1,44 @@
+import React from "react";
+import Footer from "./components/footer/FooterCenter";
+import LiveCollaborationTrigger from "./components/live-collaboration/LiveCollaborationTrigger";
+import MainMenu from "./components/main-menu/MainMenu";
+import WelcomeScreen from "./components/welcome-screen/WelcomeScreen";
+import "./css/app.scss";
+import "./css/styles.scss";
+import "./fonts/fonts.css";
+import type { ExcalidrawProps } from "./types";
+export declare const Excalidraw: React.MemoExoticComponent<(props: ExcalidrawProps) => import("react/jsx-runtime").JSX.Element>;
+export { getSceneVersion, hashElementsVersion, hashString, getNonDeletedElements, } from "@excalidraw/element";
+export { getTextFromElements } from "@excalidraw/element";
+export { isInvisiblySmallElement } from "@excalidraw/element";
+export { defaultLang, useI18n, languages } from "./i18n";
+export { restoreAppState, restoreElement, restoreElements, restoreLibraryItems, } from "./data/restore";
+export { reconcileElements } from "./data/reconcile";
+export { exportToCanvas, exportToBlob, exportToSvg, exportToClipboard, } from "@excalidraw/utils/export";
+export { serializeAsJSON, serializeLibraryAsJSON } from "./data/json";
+export { loadFromBlob, loadSceneOrLibraryFromBlob, loadLibraryFromBlob, } from "./data/blob";
+export { mergeLibraryItems, getLibraryItemsHash } from "./data/library";
+export { isLinearElement } from "@excalidraw/element";
+export { FONT_FAMILY, THEME, MIME_TYPES, ROUNDNESS, DEFAULT_LASER_COLOR, UserIdleState, normalizeLink, sceneCoordsToViewportCoords, viewportCoordsToSceneCoords, getFormFactor, } from "@excalidraw/common";
+export { mutateElement, newElementWith, bumpVersion, } from "@excalidraw/element";
+export { CaptureUpdateAction } from "@excalidraw/element";
+export { parseLibraryTokensFromUrl, useHandleLibrary } from "./data/library";
+export { Sidebar } from "./components/Sidebar/Sidebar";
+export { Button } from "./components/Button";
+export { Footer };
+export { MainMenu };
+export { Ellipsify } from "./components/Ellipsify";
+export { useEditorInterface, useStylesPanelMode } from "./components/App";
+export { WelcomeScreen };
+export { LiveCollaborationTrigger };
+export { Stats } from "./components/Stats";
+export { DefaultSidebar } from "./components/DefaultSidebar";
+export { TTDDialog } from "./components/TTDDialog/TTDDialog";
+export { TTDDialogTrigger } from "./components/TTDDialog/TTDDialogTrigger";
+export { zoomToFitBounds } from "./actions/actionCanvas";
+export { getCommonBounds, getVisibleSceneBounds, convertToExcalidrawElements, } from "@excalidraw/element";
+export { elementsOverlappingBBox, isElementInsideBBox, elementPartiallyOverlapsWithOrContainsBBox, } from "@excalidraw/utils/withinBounds";
+export { DiagramToCodePlugin } from "./components/DiagramToCodePlugin/DiagramToCodePlugin";
+export { getDataURL } from "./data/blob";
+export { isElementLink } from "@excalidraw/element";
+export { setCustomTextMetricsProvider } from "@excalidraw/element";

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

@@ -0,0 +1,20 @@
+import { AnimatedTrail } from "./animated-trail";
+import type { Trail } 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/dist/types/excalidraw/lasso/index.d.ts

@@ -0,0 +1,16 @@
+import { type AnimationFrameHandler } from "../animation-frame-handler";
+import { AnimatedTrail } from "../animated-trail";
+import type App from "../components/App";
+export declare class LassoTrail extends AnimatedTrail {
+    private intersectedElements;
+    private enclosedElements;
+    private elementsSegments;
+    private canvasTranslate;
+    private keepPreviousSelection;
+    constructor(animationFrameHandler: AnimationFrameHandler, app: App);
+    startPath(x: number, y: number, keepPreviousSelection?: boolean): void;
+    selectElementsFromIds: (ids: string[]) => void;
+    addPointToPath: (x: number, y: number, keepPreviousSelection?: boolean) => void;
+    private updateSelection;
+    endPath(): void;
+}

package/dist/types/excalidraw/lasso/utils.d.ts

@@ -0,0 +1,13 @@
+import type { ElementsSegmentsMap, GlobalPoint } from "@excalidraw/math/types";
+import type { ElementsMap, ExcalidrawElement } from "@excalidraw/element/types";
+export declare const getLassoSelectedElementIds: (input: {
+    lassoPath: GlobalPoint[];
+    elements: readonly ExcalidrawElement[];
+    elementsMap: ElementsMap;
+    elementsSegments: ElementsSegmentsMap;
+    intersectedElements: Set<ExcalidrawElement["id"]>;
+    enclosedElements: Set<ExcalidrawElement["id"]>;
+    simplifyDistance?: number;
+}) => {
+    selectedElementIds: string[];
+};

package/dist/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/dist/types/excalidraw/polyfill.d.ts

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

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

@@ -0,0 +1,12 @@
+export type Animation<R extends object> = (params: {
+    deltaTime: number;
+    state?: R;
+}) => R | null | undefined;
+export declare class AnimationController {
+    private static isRunning;
+    private static animations;
+    static start<R extends object>(key: string, animation: Animation<R>): void;
+    private static tick;
+    static running(key: string): boolean;
+    static cancel(key: string): void;
+}

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

@@ -0,0 +1,16 @@
+import type { StaticCanvasRenderConfig } from "../scene/types";
+import type { AppState, StaticCanvasAppState } from "../types";
+export declare const fillCircle: (context: CanvasRenderingContext2D, cx: number, cy: number, radius: number, stroke: boolean, fill?: 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?: AppState["theme"];
+    isExporting?: StaticCanvasRenderConfig["isExporting"];
+    viewBackgroundColor?: StaticCanvasAppState["viewBackgroundColor"];
+}) => CanvasRenderingContext2D;
+export declare const strokeRectWithRotation_simple: (context: CanvasRenderingContext2D, x: number, y: number, width: number, height: number, cx: number, cy: number, angle: number, fill?: boolean, 
+/** should account for zoom */
+radius?: number) => void;

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

@@ -0,0 +1,14 @@
+import { getScrollBars } from "../scene/scrollbars";
+import type { InteractiveSceneRenderConfig, RenderableElementsMap } from "../scene/types";
+declare const _renderInteractiveScene: ({ app, canvas, elementsMap, visibleElements, selectedElements, allElementsMap, scale, appState, renderConfig, editorInterface, animationState, deltaTime, }: InteractiveSceneRenderConfig) => {
+    scrollBars?: ReturnType<typeof getScrollBars>;
+    atLeastOneVisibleElement: boolean;
+    elementsMap: RenderableElementsMap;
+    animationState?: typeof animationState;
+};
+/**
+ * Interactive scene is the ui-canvas where we render bounding boxes, selections
+ * and other ui stuff.
+ */
+export declare const renderInteractiveScene: <U extends typeof _renderInteractiveScene>(renderConfig: InteractiveSceneRenderConfig) => ReturnType<U>;
+export {};

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

@@ -0,0 +1,14 @@
+import type { ExcalidrawFrameLikeElement } from "@excalidraw/element/types";
+import type { StaticCanvasRenderConfig, StaticSceneRenderConfig } from "../scene/types";
+import type { StaticCanvasAppState } from "../types";
+export declare const frameClip: (frame: ExcalidrawFrameLikeElement, context: CanvasRenderingContext2D, renderConfig: StaticCanvasRenderConfig, appState: StaticCanvasAppState) => void;
+/** 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/dist/types/excalidraw/renderer/staticSvgScene.d.ts

@@ -0,0 +1,5 @@
+import type { NonDeletedExcalidrawElement } from "@excalidraw/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/dist/types/excalidraw/scene/Renderer.d.ts

@@ -0,0 +1,30 @@
+import type { ExcalidrawElement, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
+import type { Scene } from "@excalidraw/element";
+import type { RenderableElementsMap } from "./types";
+import type { AppState } from "../types";
+export declare class Renderer {
+    private scene;
+    constructor(scene: Scene);
+    getRenderableElements: ((opts: {
+        zoom: Readonly<{
+            value: import("../types").NormalizedZoomValue;
+        }>;
+        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;
+        sceneNonce: ReturnType<InstanceType<typeof Scene>["getSceneNonce"]>;
+    }) => {
+        elementsMap: RenderableElementsMap;
+        visibleElements: readonly NonDeletedExcalidrawElement[];
+    }) & {
+        clear: () => void;
+    };
+    destroy(): void;
+}

package/dist/types/excalidraw/scene/export.d.ts

@@ -0,0 +1,36 @@
+import type { ExcalidrawFrameLikeElement, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
+import type { AppState, BinaryFiles } from "../types";
+export declare const exportToCanvas: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState, files: BinaryFiles, { exportBackground, exportPadding, viewBackgroundColor, exportingFrame, }: {
+    exportBackground: boolean;
+    exportPadding?: number;
+    viewBackgroundColor: string;
+    exportingFrame?: ExcalidrawFrameLikeElement | null;
+}, createCanvas?: (width: number, height: number) => {
+    canvas: HTMLCanvasElement;
+    scale: number;
+}, loadFonts?: () => Promise<void>) => Promise<HTMLCanvasElement>;
+export declare const exportToSvg: (elements: readonly NonDeletedExcalidrawElement[], appState: {
+    exportBackground: boolean;
+    exportPadding?: number;
+    exportScale?: number;
+    viewBackgroundColor: string;
+    exportWithDarkMode?: boolean;
+    exportEmbedScene?: boolean;
+    frameRendering?: AppState["frameRendering"];
+}, files: BinaryFiles | null, opts?: {
+    /**
+     * if true, all embeddables passed in will be rendered when possible.
+     */
+    renderEmbeddables?: boolean;
+    exportingFrame?: ExcalidrawFrameLikeElement | null;
+    skipInliningFonts?: true;
+    reuseImages?: boolean;
+}) => Promise<SVGSVGElement>;
+export declare const encodeSvgBase64Payload: ({ payload, metadataElement, }: {
+    payload: string;
+    metadataElement: SVGMetadataElement;
+}) => void;
+export declare const decodeSvgBase64Payload: ({ svg }: {
+    svg: string;
+}) => string;
+export declare const getExportSize: (elements: readonly NonDeletedExcalidrawElement[], exportPadding: number, scale: number) => [number, number];

package/dist/types/excalidraw/scene/index.d.ts

@@ -0,0 +1,4 @@
+export { isSomeElementSelected, getElementsWithinSelection, getSelectedElements, getTargetElements, } from "@excalidraw/element";
+export { calculateScrollCenter } from "./scroll";
+export { hasBackground, hasStrokeWidth, hasStrokeStyle, canHaveArrowheads, canChangeRoundness, } from "@excalidraw/element";
+export { getNormalizedZoom, getNormalizedGridSize, getNormalizedGridStep, } from "./normalize";

package/dist/types/excalidraw/scene/normalize.d.ts

@@ -0,0 +1,4 @@
+import type { NormalizedZoomValue } from "../types";
+export declare const getNormalizedZoom: (zoom: number) => NormalizedZoomValue;
+export declare const getNormalizedGridSize: (gridStep: number) => number;
+export declare const getNormalizedGridStep: (gridStep: number) => number;

package/dist/types/excalidraw/scene/scroll.d.ts

@@ -0,0 +1,18 @@
+import type { ExcalidrawElement } from "@excalidraw/element/types";
+import type { AppState, Offsets, PointerCoords, Zoom } from "../types";
+export declare const centerScrollOn: ({ scenePoint, viewportDimensions, zoom, offsets, }: {
+    scenePoint: PointerCoords;
+    viewportDimensions: {
+        height: number;
+        width: number;
+    };
+    zoom: Zoom;
+    offsets?: Offsets;
+}) => {
+    scrollX: number;
+    scrollY: number;
+};
+export declare const calculateScrollCenter: (elements: readonly ExcalidrawElement[], appState: AppState) => {
+    scrollX: number;
+    scrollY: number;
+};

package/dist/types/excalidraw/scene/scrollbars.d.ts

@@ -0,0 +1,11 @@
+import type { InteractiveCanvasAppState } from "../types";
+import type { RenderableElementsMap, ScrollBars } from "./types";
+export declare const SCROLLBAR_MARGIN = 4;
+export declare const SCROLLBAR_WIDTH = 6;
+export declare const SCROLLBAR_COLOR = "rgba(0,0,0,0.3)";
+export declare const getScrollBars: (elements: RenderableElementsMap, viewportWidth: number, viewportHeight: number, appState: InteractiveCanvasAppState) => ScrollBars;
+export declare const isOverScrollBars: (scrollBars: ScrollBars, x: number, y: number) => {
+    isOverEither: boolean;
+    isOverHorizontal: boolean;
+    isOverVertical: boolean;
+};

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

@@ -0,0 +1,141 @@
+import type { UserIdleState, EditorInterface } from "@excalidraw/common";
+import type { ExcalidrawElement, NonDeletedElementsMap, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap } from "@excalidraw/element/types";
+import type { MakeBrand } from "@excalidraw/common/utility-types";
+import type { AppClassProperties, AppState, EmbedsValidationStatus, ElementsPendingErasure, InteractiveCanvasAppState, StaticCanvasAppState, SocketId, PendingExcalidrawElements } from "../types";
+import type { RoughCanvas } from "roughjs/bin/canvas";
+import type { Drawable } from "roughjs/bin/core";
+export type RenderableElementsMap = NonDeletedElementsMap & MakeBrand<"RenderableElementsMap">;
+export type StaticCanvasRenderConfig = {
+    canvasBackgroundColor: AppState["viewBackgroundColor"];
+    imageCache: AppClassProperties["imageCache"];
+    renderGrid: boolean;
+    /** when exporting the behavior is slightly different (e.g. we can't use
+     CSS filters), and we disable render optimizations for best output */
+    isExporting: boolean;
+    embedsValidationStatus: EmbedsValidationStatus;
+    elementsPendingErasure: ElementsPendingErasure;
+    pendingFlowchartNodes: PendingExcalidrawElements | null;
+    theme: AppState["theme"];
+};
+export type SVGRenderConfig = {
+    offsetX: number;
+    offsetY: number;
+    isExporting: boolean;
+    exportWithDarkMode: boolean;
+    renderEmbeddables: boolean;
+    frameRendering: AppState["frameRendering"];
+    canvasBackgroundColor: AppState["viewBackgroundColor"];
+    embedsValidationStatus: EmbedsValidationStatus;
+    /**
+     * whether to attempt to reuse images as much as possible through symbols
+     * (reduces SVG size, but may be incompoatible with some SVG renderers)
+     *
+     * @default true
+     */
+    reuseImages: boolean;
+    theme: AppState["theme"];
+};
+export type InteractiveCanvasRenderConfig = {
+    remoteSelectedElementIds: Map<ExcalidrawElement["id"], SocketId[]>;
+    remotePointerViewportCoords: Map<SocketId, {
+        x: number;
+        y: number;
+    }>;
+    remotePointerUserStates: Map<SocketId, UserIdleState>;
+    remotePointerUsernames: Map<SocketId, string>;
+    remotePointerButton: Map<SocketId, string | undefined>;
+    selectionColor: string;
+    lastViewportPosition: {
+        x: number;
+        y: number;
+    };
+    renderScrollbars?: boolean;
+};
+export type RenderInteractiveSceneCallback = {
+    atLeastOneVisibleElement: boolean;
+    elementsMap: RenderableElementsMap;
+    scrollBars?: ScrollBars;
+};
+export type StaticSceneRenderConfig = {
+    canvas: HTMLCanvasElement;
+    rc: RoughCanvas;
+    elementsMap: RenderableElementsMap;
+    allElementsMap: NonDeletedSceneElementsMap;
+    visibleElements: readonly NonDeletedExcalidrawElement[];
+    scale: number;
+    appState: StaticCanvasAppState;
+    renderConfig: StaticCanvasRenderConfig;
+};
+export type InteractiveSceneRenderAnimationState = {
+    bindingHighlight: {
+        runtime: number;
+    } | undefined;
+};
+export type InteractiveSceneRenderConfig = {
+    app: AppClassProperties;
+    canvas: HTMLCanvasElement | null;
+    elementsMap: RenderableElementsMap;
+    visibleElements: readonly NonDeletedExcalidrawElement[];
+    selectedElements: readonly NonDeletedExcalidrawElement[];
+    allElementsMap: NonDeletedSceneElementsMap;
+    scale: number;
+    appState: InteractiveCanvasAppState;
+    renderConfig: InteractiveCanvasRenderConfig;
+    editorInterface: EditorInterface;
+    callback: (data: RenderInteractiveSceneCallback) => void;
+    animationState?: InteractiveSceneRenderAnimationState;
+    deltaTime: number;
+};
+export type NewElementSceneRenderConfig = {
+    canvas: HTMLCanvasElement | null;
+    rc: RoughCanvas;
+    newElement: ExcalidrawElement | null;
+    elementsMap: RenderableElementsMap;
+    allElementsMap: NonDeletedSceneElementsMap;
+    scale: number;
+    appState: AppState;
+    renderConfig: StaticCanvasRenderConfig;
+};
+export type SceneScroll = {
+    scrollX: number;
+    scrollY: number;
+};
+export type ExportType = "png" | "clipboard" | "clipboard-svg" | "backend" | "svg";
+export type ScrollBars = {
+    horizontal: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        deltaMultiplier: number;
+    } | null;
+    vertical: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        deltaMultiplier: number;
+    } | null;
+};
+export type SVGPathString = string & {
+    __brand: "SVGPathString";
+};
+export type ElementShape = Drawable | Drawable[] | Path2D | (Drawable | SVGPathString)[] | null;
+export type ElementShapes = {
+    rectangle: Drawable;
+    ellipse: Drawable;
+    diamond: Drawable;
+    triangle: Drawable;
+    hexagon: Drawable;
+    heart: Drawable;
+    star: Drawable;
+    iframe: Drawable;
+    embeddable: Drawable;
+    freedraw: (Drawable | SVGPathString)[];
+    arrow: Drawable[];
+    line: Drawable[];
+    text: null;
+    image: null;
+    frame: null;
+    magicframe: null;
+};

package/dist/types/excalidraw/scene/zoom.d.ts

@@ -0,0 +1,12 @@
+import type { AppState, NormalizedZoomValue } from "../types";
+export declare const getStateForZoom: ({ viewportX, viewportY, nextZoom, }: {
+    viewportX: number;
+    viewportY: number;
+    nextZoom: NormalizedZoomValue;
+}, appState: AppState) => {
+    scrollX: number;
+    scrollY: number;
+    zoom: {
+        value: NormalizedZoomValue;
+    };
+};

package/dist/types/excalidraw/shortcut.d.ts

@@ -0,0 +1 @@
+export declare const getShortcutKey: (shortcut: string) => string;

package/dist/types/excalidraw/snapping.d.ts

@@ -0,0 +1,111 @@
+import { type GlobalPoint } from "@excalidraw/math";
+import type { InclusiveRange } from "@excalidraw/math";
+import type { Bounds } from "@excalidraw/common";
+import type { MaybeTransformHandleType } from "@excalidraw/element";
+import type { ElementsMap, ExcalidrawElement, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
+import type { AppClassProperties, AppState, KeyboardModifiersObject } from "./types";
+export declare const getSnapDistance: (zoomValue: number) => number;
+type Vector2D = {
+    x: number;
+    y: number;
+};
+type PointPair = [GlobalPoint, GlobalPoint];
+export type PointSnap = {
+    type: "point";
+    points: PointPair;
+    offset: number;
+};
+export type Gap = {
+    startBounds: Bounds;
+    endBounds: Bounds;
+    startSide: [GlobalPoint, GlobalPoint];
+    endSide: [GlobalPoint, GlobalPoint];
+    overlap: InclusiveRange;
+    length: number;
+};
+export type GapSnap = {
+    type: "gap";
+    direction: "center_horizontal" | "center_vertical" | "side_left" | "side_right" | "side_top" | "side_bottom";
+    gap: Gap;
+    offset: number;
+};
+export type GapSnaps = GapSnap[];
+export type Snap = GapSnap | PointSnap;
+export type Snaps = Snap[];
+export type PointSnapLine = {
+    type: "points";
+    points: GlobalPoint[];
+};
+export type PointerSnapLine = {
+    type: "pointer";
+    points: PointPair;
+    direction: "horizontal" | "vertical";
+};
+export type GapSnapLine = {
+    type: "gap";
+    direction: "horizontal" | "vertical";
+    points: PointPair;
+};
+export type SnapLine = PointSnapLine | GapSnapLine | PointerSnapLine;
+export declare class SnapCache {
+    private static referenceSnapPoints;
+    private static visibleGaps;
+    static setReferenceSnapPoints: (snapPoints: GlobalPoint[] | null) => void;
+    static getReferenceSnapPoints: () => GlobalPoint[] | null;
+    static setVisibleGaps: (gaps: {
+        verticalGaps: Gap[];
+        horizontalGaps: Gap[];
+    } | null) => void;
+    static getVisibleGaps: () => {
+        verticalGaps: Gap[];
+        horizontalGaps: Gap[];
+    } | null;
+    static destroy: () => void;
+}
+export declare const isGridModeEnabled: (app: AppClassProperties) => boolean;
+export declare const isSnappingEnabled: ({ event, app, selectedElements, }: {
+    app: AppClassProperties;
+    event: KeyboardModifiersObject;
+    selectedElements: NonDeletedExcalidrawElement[];
+}) => boolean;
+export declare const areRoughlyEqual: (a: number, b: number, precision?: number) => boolean;
+export declare const getElementsCorners: (elements: ExcalidrawElement[], elementsMap: ElementsMap, { omitCenter, boundingBoxCorners, dragOffset, }?: {
+    omitCenter?: boolean;
+    boundingBoxCorners?: boolean;
+    dragOffset?: Vector2D;
+}) => GlobalPoint[];
+export declare const getVisibleGaps: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: ExcalidrawElement[], appState: AppState, elementsMap: ElementsMap) => {
+    horizontalGaps: Gap[];
+    verticalGaps: Gap[];
+};
+export declare const getReferenceSnapPoints: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: ExcalidrawElement[], appState: AppState, elementsMap: ElementsMap) => GlobalPoint[];
+export declare const snapDraggedElements: (elements: ExcalidrawElement[], dragOffset: Vector2D, app: AppClassProperties, event: KeyboardModifiersObject, elementsMap: ElementsMap) => {
+    snapOffset: {
+        x: number;
+        y: number;
+    };
+    snapLines: (PointSnapLine | GapSnapLine)[];
+};
+export declare const snapResizingElements: (selectedElements: ExcalidrawElement[], selectedOriginalElements: ExcalidrawElement[], app: AppClassProperties, event: KeyboardModifiersObject, dragOffset: Vector2D, transformHandle: MaybeTransformHandleType) => {
+    snapOffset: {
+        x: number;
+        y: number;
+    };
+    snapLines: PointSnapLine[];
+};
+export declare const snapNewElement: (newElement: ExcalidrawElement, app: AppClassProperties, event: KeyboardModifiersObject, origin: Vector2D, dragOffset: Vector2D, elementsMap: ElementsMap) => {
+    snapOffset: {
+        x: number;
+        y: number;
+    };
+    snapLines: PointSnapLine[];
+};
+export declare const getSnapLinesAtPointer: (elements: readonly ExcalidrawElement[], app: AppClassProperties, pointer: Vector2D, event: KeyboardModifiersObject, elementsMap: ElementsMap) => {
+    originOffset: {
+        x: number;
+        y: number;
+    };
+    snapLines: PointerSnapLine[];
+};
+export declare const isActiveToolNonLinearSnappable: (activeToolType: AppState["activeTool"]["type"]) => activeToolType is "text" | "rectangle" | "diamond" | "ellipse" | "triangle" | "hexagon" | "heart" | "star" | "image" | "frame" | "magicframe";
+export {};