@dwelle/excalidraw 0.6.0-rc.1 → 0.6.0-rc.3

package/dist/types/excalidraw/components/welcome-screen/WelcomeScreen.d.ts

@@ -3,61 +3,61 @@ import "./WelcomeScreen.scss";
 declare const WelcomeScreen: {
     (props: {
         children?: React.ReactNode;
-    }): JSX.Element;
+    }): import("react/jsx-runtime").JSX.Element;
     displayName: string;
     Center: {
         ({ children }: {
             children?: import("react").ReactNode;
-        }): JSX.Element;
+        }): import("react/jsx-runtime").JSX.Element;
         displayName: string;
         Logo: {
             ({ children }: {
                 children?: import("react").ReactNode;
-            }): JSX.Element;
+            }): import("react/jsx-runtime").JSX.Element;
             displayName: string;
         };
         Heading: {
             ({ children }: {
                 children: import("react").ReactNode;
-            }): JSX.Element;
+            }): import("react/jsx-runtime").JSX.Element;
             displayName: string;
         };
         Menu: {
             ({ children }: {
                 children?: import("react").ReactNode;
-            }): JSX.Element;
+            }): import("react/jsx-runtime").JSX.Element;
             displayName: string;
         };
         MenuItem: {
             ({ onSelect, children, icon, shortcut, className, ...props }: {
                 onSelect: () => void;
                 children: import("react").ReactNode;
-                icon?: JSX.Element | undefined;
+                icon?: import("react").JSX.Element | undefined;
                 shortcut?: string | null | undefined;
-            } & import("react").ButtonHTMLAttributes<HTMLButtonElement>): JSX.Element;
+            } & import("react").ButtonHTMLAttributes<HTMLButtonElement>): import("react/jsx-runtime").JSX.Element;
             displayName: string;
         };
         MenuItemLink: {
             ({ children, href, icon, shortcut, className, ...props }: {
                 children: import("react").ReactNode;
                 href: string;
-                icon?: JSX.Element | undefined;
+                icon?: import("react").JSX.Element | undefined;
                 shortcut?: string | null | undefined;
-            } & import("react").AnchorHTMLAttributes<HTMLAnchorElement>): JSX.Element;
+            } & import("react").AnchorHTMLAttributes<HTMLAnchorElement>): import("react/jsx-runtime").JSX.Element;
             displayName: string;
         };
         MenuItemHelp: {
-            (): JSX.Element;
+            (): import("react/jsx-runtime").JSX.Element;
             displayName: string;
         };
         MenuItemLoadScene: {
-            (): JSX.Element | null;
+            (): import("react/jsx-runtime").JSX.Element | null;
             displayName: string;
         };
         MenuItemLiveCollaborationTrigger: {
             ({ onSelect, }: {
                 onSelect: () => any;
-            }): JSX.Element;
+            }): import("react/jsx-runtime").JSX.Element;
             displayName: string;
         };
     };
@@ -65,19 +65,19 @@ declare const WelcomeScreen: {
         MenuHint: {
             ({ children }: {
                 children?: import("react").ReactNode;
-            }): JSX.Element;
+            }): import("react/jsx-runtime").JSX.Element;
             displayName: string;
         };
         ToolbarHint: {
             ({ children }: {
                 children?: import("react").ReactNode;
-            }): JSX.Element;
+            }): import("react/jsx-runtime").JSX.Element;
             displayName: string;
         };
         HelpHint: {
             ({ children }: {
                 children?: import("react").ReactNode;
-            }): JSX.Element;
+            }): import("react/jsx-runtime").JSX.Element;
             displayName: string;
         };
     };

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

@@ -146,6 +146,7 @@ export declare const COLOR_WHITE = "#ffffff";
 export declare const COLOR_CHARCOAL_BLACK = "#1e1e1e";
 export declare const COLOR_TRANSPARENT = "transparent";
 export declare const SIDE_RESIZING_THRESHOLD: number;
+export declare const EPSILON = 0.00001;
 export declare const DEFAULT_COLLISION_THRESHOLD: number;
 export declare const COLOR_VOICE_CALL = "#a2f1a6";
 export declare const CANVAS_ONLY_ACTIONS: string[];

package/dist/types/excalidraw/data/blob.d.ts

@@ -6,7 +6,7 @@ import type { FileSystemHandle } from "./filesystem";
 import type { ImportedLibraryData } from "./types";
 export declare const getMimeType: (blob: Blob | string) => string;
 export declare const getFileHandleType: (handle: FileSystemHandle | null) => string | null;
-export declare const isImageFileHandleType: (type: string | null) => type is "png" | "svg";
+export declare const isImageFileHandleType: (type: string | null) => type is "svg" | "png";
 export declare const isImageFileHandle: (handle: FileSystemHandle | null) => boolean;
 export declare const isSupportedImageFileType: (type: string | null | undefined) => boolean;
 export declare const isSupportedImageFile: (blob: Blob | null | undefined) => blob is Blob & {

package/dist/types/excalidraw/element/ElementCanvasButtons.d.ts

@@ -1,8 +1,7 @@
-/// <reference types="react" />
 import type { ElementsMap, NonDeletedExcalidrawElement } from "./types";
 import "./ElementCanvasButtons.scss";
 export declare const ElementCanvasButtons: ({ children, element, elementsMap, }: {
     children: React.ReactNode;
     element: NonDeletedExcalidrawElement;
     elementsMap: ElementsMap;
-}) => JSX.Element | null;
+}) => import("react/jsx-runtime").JSX.Element | null;

package/dist/types/excalidraw/element/binding.d.ts

@@ -39,7 +39,7 @@ export declare const updateBoundElements: (changedElement: NonDeletedExcalidrawE
     changedElements?: Map<string, OrderedExcalidrawElement>;
 }) => void;
 export declare const getHeadingForElbowArrowSnap: (p: Readonly<GlobalPoint>, otherPoint: Readonly<GlobalPoint>, bindableElement: ExcalidrawBindableElement | undefined | null, aabb: Bounds | undefined | null, elementsMap: ElementsMap, origPoint: GlobalPoint, zoom?: AppState["zoom"]) => Heading;
-export declare const bindPointToSnapToElementOutline: (p: Readonly<GlobalPoint>, otherPoint: Readonly<GlobalPoint>, bindableElement: ExcalidrawBindableElement | undefined, elementsMap: ElementsMap) => GlobalPoint;
+export declare const bindPointToSnapToElementOutline: (arrow: ExcalidrawElbowArrowElement, bindableElement: ExcalidrawBindableElement | undefined, startOrEnd: "start" | "end") => GlobalPoint;
 export declare const avoidRectangularCorner: (element: ExcalidrawBindableElement, p: GlobalPoint) => GlobalPoint;
 export declare const snapToMid: (element: ExcalidrawBindableElement, p: GlobalPoint, tolerance?: number) => GlobalPoint;
 export declare const calculateFixedPointForElbowArrowBinding: (linearElement: NonDeleted<ExcalidrawElbowArrowElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap) => {
@@ -52,7 +52,6 @@ export declare const bindingBorderTest: (element: NonDeleted<ExcalidrawBindableE
     y: number;
 }, elementsMap: NonDeletedSceneElementsMap, zoom?: AppState["zoom"], fullShape?: boolean) => boolean;
 export declare const maxBindingGap: (element: ExcalidrawElement, elementWidth: number, elementHeight: number, zoom?: AppState["zoom"]) => number;
-export declare const distanceToBindableElement: (element: ExcalidrawBindableElement, point: GlobalPoint, elementsMap: ElementsMap) => number;
 export declare const bindingProperties: Set<BindableProp | BindingProp>;
 export type BindableProp = "boundElements";
 export type BindingProp = "frameId" | "containerId" | "startBinding" | "endBinding";

package/dist/types/excalidraw/element/collision.d.ts

@@ -1,7 +1,7 @@
 import type { ElementsMap, ExcalidrawElement } from "./types";
 import type { FrameNameBounds } from "../types";
 import type { GeometricShape } from "@excalidraw/utils/geometry/shape";
-import type { GlobalPoint, LocalPoint } from "@excalidraw/math";
+import type { GlobalPoint, LineSegment, LocalPoint } from "@excalidraw/math";
 export declare const shouldTestInside: (element: ExcalidrawElement) => boolean;
 export type HitTestArgs<Point extends GlobalPoint | LocalPoint> = {
     x: number;
@@ -15,3 +15,12 @@ export declare const hitElementItself: <Point extends GlobalPoint | LocalPoint>(
 export declare const hitElementBoundingBox: (x: number, y: number, element: ExcalidrawElement, elementsMap: ElementsMap, tolerance?: number) => boolean;
 export declare const hitElementBoundingBoxOnly: <Point extends GlobalPoint | LocalPoint>(hitArgs: HitTestArgs<Point>, elementsMap: ElementsMap) => boolean;
 export declare const hitElementBoundText: <Point extends GlobalPoint | LocalPoint>(x: number, y: number, textShape: GeometricShape<Point> | null) => boolean;
+/**
+ * Intersect a line with an element for binding test
+ *
+ * @param element
+ * @param line
+ * @param offset
+ * @returns
+ */
+export declare const intersectElementWithLineSegment: (element: ExcalidrawElement, line: LineSegment<GlobalPoint>, offset?: number) => GlobalPoint[];

package/dist/types/excalidraw/element/distance.d.ts

@@ -0,0 +1,3 @@
+import type { GlobalPoint } from "@excalidraw/math";
+import type { ExcalidrawBindableElement } from "./types";
+export declare const distanceToBindableElement: (element: ExcalidrawBindableElement, p: GlobalPoint) => number;

package/dist/types/excalidraw/element/embeddable.d.ts

@@ -188,7 +188,7 @@ export declare const actionSetEmbeddableAsActiveTool: {
                 }[];
             }[];
         };
-        storeAction: "none";
+        captureUpdate: "EVENTUALLY";
     };
 } & {
     keyTest?: undefined;

package/dist/types/excalidraw/element/newElement.d.ts

@@ -52,7 +52,7 @@ export declare const newArrowElement: <T extends boolean>(opts: {
     points?: readonly import("@excalidraw/math").LocalPoint[] | undefined;
     elbowed?: T | undefined;
     fixedSegments?: FixedSegment[] | null | undefined;
-} & Omit<Omit<ExcalidrawGenericElement, "id" | "isDeleted" | "updated" | "type">, "angle" | "width" | "height" | "link" | "backgroundColor" | "strokeColor" | "fillStyle" | "strokeWidth" | "strokeStyle" | "roundness" | "roughness" | "opacity" | "seed" | "version" | "versionNonce" | "index" | "groupIds" | "frameId" | "boundElements" | "locked" | "customData"> & Partial<Pick<Omit<ExcalidrawGenericElement, "id" | "isDeleted" | "updated" | "type">, "angle" | "width" | "height" | "link" | "backgroundColor" | "strokeColor" | "fillStyle" | "strokeWidth" | "strokeStyle" | "roundness" | "roughness" | "opacity" | "seed" | "version" | "versionNonce" | "index" | "groupIds" | "frameId" | "boundElements" | "locked" | "customData">>) => T extends true ? NonDeleted<ExcalidrawElbowArrowElement> : NonDeleted<ExcalidrawArrowElement>;
+} & Omit<Omit<ExcalidrawGenericElement, "id" | "isDeleted" | "updated" | "type">, "strokeColor" | "backgroundColor" | "fillStyle" | "strokeWidth" | "strokeStyle" | "roundness" | "roughness" | "opacity" | "width" | "height" | "angle" | "seed" | "version" | "versionNonce" | "index" | "groupIds" | "frameId" | "boundElements" | "link" | "locked" | "customData"> & Partial<Pick<Omit<ExcalidrawGenericElement, "id" | "isDeleted" | "updated" | "type">, "strokeColor" | "backgroundColor" | "fillStyle" | "strokeWidth" | "strokeStyle" | "roundness" | "roughness" | "opacity" | "width" | "height" | "angle" | "seed" | "version" | "versionNonce" | "index" | "groupIds" | "frameId" | "boundElements" | "link" | "locked" | "customData">>) => T extends true ? NonDeleted<ExcalidrawElbowArrowElement> : NonDeleted<ExcalidrawArrowElement>;
 export declare const newImageElement: (opts: {
     type: ExcalidrawImageElement["type"];
     status?: ExcalidrawImageElement["status"];

package/dist/types/excalidraw/element/transformHandles.d.ts

@@ -31,8 +31,8 @@ export declare const OMIT_SIDES_FOR_FRAME: {
 export declare const canResizeFromSides: (device: Device) => boolean;
 export declare const getOmitSidesForDevice: (device: Device) => {};
 export declare const getTransformHandlesFromCoords: ([x1, y1, x2, y2, cx, cy]: [number, number, number, number, number, number], angle: Radians, zoom: Zoom, pointerType: PointerType, omitSides?: {
-    e?: boolean | undefined;
     s?: boolean | undefined;
+    e?: boolean | undefined;
     w?: boolean | undefined;
     n?: boolean | undefined;
     nw?: boolean | undefined;
@@ -42,8 +42,8 @@ export declare const getTransformHandlesFromCoords: ([x1, y1, x2, y2, cx, cy]: [
     rotation?: boolean | undefined;
 }, margin?: number, spacing?: number) => TransformHandles;
 export declare const getTransformHandles: (element: ExcalidrawElement, zoom: Zoom, elementsMap: ElementsMap, pointerType?: PointerType, omitSides?: {
-    e?: boolean | undefined;
     s?: boolean | undefined;
+    e?: boolean | undefined;
     w?: boolean | undefined;
     n?: boolean | undefined;
     nw?: boolean | undefined;

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

@@ -228,7 +228,7 @@ export type ExcalidrawElbowArrowElement = Merge<ExcalidrawArrowElement, {
     elbowed: true;
     startBinding: FixedPointBinding | null;
     endBinding: FixedPointBinding | null;
-    fixedSegments: FixedSegment[] | null;
+    fixedSegments: readonly FixedSegment[] | null;
     /**
      * Marks that the 3rd point should be used as the 2nd point of the arrow in
      * order to temporarily hide the first segment of the arrow without losing

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

@@ -0,0 +1,21 @@
+import type { Curve, LineSegment } from "@excalidraw/math";
+import { type GlobalPoint } from "@excalidraw/math";
+import type { ExcalidrawDiamondElement, ExcalidrawRectanguloidElement } from "./types";
+/**
+ * Get the building components of a rectanguloid element in the form of
+ * line segments and curves.
+ *
+ * @param element Target rectanguloid element
+ * @param offset Optional offset to expand the rectanguloid shape
+ * @returns Tuple of line segments (0) and curves (1)
+ */
+export declare function deconstructRectanguloidElement(element: ExcalidrawRectanguloidElement, offset?: number): [LineSegment<GlobalPoint>[], Curve<GlobalPoint>[]];
+/**
+ * Get the building components of a diamond element in the form of
+ * line segments and curves as a tuple, in this order.
+ *
+ * @param element The element to deconstruct
+ * @param offset An optional offset
+ * @returns Tuple of line segments (0) and curves (1)
+ */
+export declare function deconstructDiamondElement(element: ExcalidrawDiamondElement, offset?: number): [LineSegment<GlobalPoint>[], Curve<GlobalPoint>[]];

package/dist/types/excalidraw/fonts/FontMetadata.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="react" />
+import type { JSX } from "react";
 /**
  * Encapsulates font metrics with additional font metadata.
  * */

package/dist/types/excalidraw/hooks/useOutsideClick.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="react" />
-export declare function useOutsideClick<T extends HTMLElement>(ref: React.RefObject<T>, 
+export declare function useOutsideClick<T extends HTMLElement>(ref: React.RefObject<T | null>, 
 /** if performance is of concern, memoize the callback */
 callback: (event: Event) => void, 
 /**

package/dist/types/excalidraw/hooks/useScrollPosition.d.ts

@@ -1,2 +1,2 @@
 /// <reference types="react" />
-export declare const useScrollPosition: <T extends HTMLElement>(elementRef: import("react").RefObject<T>) => number;
+export declare const useScrollPosition: <T extends HTMLElement>(elementRef: import("react").RefObject<T | null>) => number;

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

@@ -3,12 +3,11 @@ import "./css/app.scss";
 import "./css/styles.scss";
 import "./fonts/fonts.css";
 import type { ExcalidrawProps } from "./types";
-import { editorJotaiStore } from "./editor-jotai";
 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";
-export declare const Excalidraw: React.MemoExoticComponent<(props: ExcalidrawProps) => JSX.Element>;
+export declare const Excalidraw: React.MemoExoticComponent<(props: ExcalidrawProps) => import("react/jsx-runtime").JSX.Element>;
 export { getSceneVersion, hashElementsVersion, hashString, isInvisiblySmallElement, getNonDeletedElements, getTextFromElements, } from "./element";
 export { defaultLang, useI18n, languages } from "./i18n";
 export { restore, restoreAppState, restoreElements, restoreLibraryItems, } from "./data/restore";
@@ -21,7 +20,7 @@ export { mergeLibraryItems, getLibraryItemsHash } from "./data/library";
 export { isLinearElement } from "./element/typeChecks";
 export { FONT_FAMILY, THEME, MIME_TYPES, ROUNDNESS, DEFAULT_LASER_COLOR, UserIdleState, } from "./constants";
 export { mutateElement, newElementWith, bumpVersion, } from "./element/mutateElement";
-export { StoreAction } from "./store";
+export { CaptureUpdateAction } from "./store";
 export { parseLibraryTokensFromUrl, useHandleLibrary } from "./data/library";
 export { sceneCoordsToViewportCoords, viewportCoordsToSceneCoords, } from "./utils";
 export { Sidebar } from "./components/Sidebar/Sidebar";
@@ -46,7 +45,6 @@ export { getDataURL } from "./data/blob";
 export { isElementLink } from "./element/elementLink";
 export { setCustomTextMetricsProvider } from "./element/textMeasurements";
 export { getDefaultAppState, cleanAppStateForExport, clearAppStateForLocalStorage, } from "./appState";
-export { editorJotaiStore };
 export { libraryItemsAtom } from "./data/library";
 export * as icons from "./components/icons";
 export * as actions from "./actions/index";

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

@@ -1,71 +1,70 @@
-/// <reference types="react" />
 import { type GlobalPoint, type LocalPoint } from "@excalidraw/math";
 import { type GeometricShape } from "@excalidraw/utils/geometry/shape";
 import type { Bounds } from "./element/bounds";
 import type { ElementsMap, ExcalidrawElement, ExcalidrawLinearElement, NonDeleted } from "./element/types";
 import type { Zoom } from "./types";
 export declare const SHAPES: readonly [{
-    readonly icon: JSX.Element;
+    readonly icon: import("react/jsx-runtime").JSX.Element;
     readonly value: "selection";
     readonly key: "v";
     readonly numericKey: "1";
     readonly fillable: true;
 }, {
-    readonly icon: JSX.Element;
+    readonly icon: import("react/jsx-runtime").JSX.Element;
     readonly value: "rectangle";
     readonly key: "r";
     readonly numericKey: "2";
     readonly fillable: true;
 }, {
-    readonly icon: JSX.Element;
+    readonly icon: import("react/jsx-runtime").JSX.Element;
     readonly value: "diamond";
     readonly key: "d";
     readonly numericKey: "3";
     readonly fillable: true;
 }, {
-    readonly icon: JSX.Element;
+    readonly icon: import("react/jsx-runtime").JSX.Element;
     readonly value: "ellipse";
     readonly key: "o";
     readonly numericKey: "4";
     readonly fillable: true;
 }, {
-    readonly icon: JSX.Element;
+    readonly icon: import("react/jsx-runtime").JSX.Element;
     readonly value: "arrow";
     readonly key: "a";
     readonly numericKey: "5";
     readonly fillable: true;
 }, {
-    readonly icon: JSX.Element;
+    readonly icon: import("react/jsx-runtime").JSX.Element;
     readonly value: "line";
     readonly key: "l";
     readonly numericKey: "6";
     readonly fillable: true;
 }, {
-    readonly icon: JSX.Element;
+    readonly icon: import("react/jsx-runtime").JSX.Element;
     readonly value: "freedraw";
     readonly key: readonly ["p", "x"];
     readonly numericKey: "7";
     readonly fillable: false;
 }, {
-    readonly icon: JSX.Element;
+    readonly icon: import("react/jsx-runtime").JSX.Element;
     readonly value: "text";
     readonly key: "t";
     readonly numericKey: "8";
     readonly fillable: false;
 }, {
-    readonly icon: JSX.Element;
+    readonly icon: import("react/jsx-runtime").JSX.Element;
     readonly value: "image";
     readonly key: null;
     readonly numericKey: "9";
     readonly fillable: false;
 }, {
-    readonly icon: JSX.Element;
+    readonly icon: import("react/jsx-runtime").JSX.Element;
     readonly value: "eraser";
     readonly key: "e";
     readonly numericKey: "0";
     readonly fillable: false;
 }];
-export declare const findShapeByKey: (key: string) => "line" | "text" | "arrow" | "diamond" | "selection" | "rectangle" | "ellipse" | "freedraw" | "image" | "eraser" | null;
+export declare const findShapeByKey: (key: string) => "text" | "line" | "arrow" | "image" | "selection" | "rectangle" | "diamond" | "ellipse" | "freedraw" | "eraser" | null;
 /**
  * get the pure geometric shape of an excalidraw element
  * which is then used for hit detection

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

@@ -4,7 +4,7 @@ import { Emitter } from "./emitter";
 import type { AppState, ObservedAppState } from "./types";
 import type { ValueOf } from "./utility-types";
 export declare const getObservedAppState: (appState: AppState) => ObservedAppState;
-export declare const StoreAction: {
+export declare const CaptureUpdateAction: {
     /**
      * Immediately undoable.
      *
@@ -13,7 +13,7 @@ export declare const StoreAction: {
      *
      * These updates will _immediately_ make it to the local undo / redo stacks.
      */
-    readonly CAPTURE: "capture";
+    readonly IMMEDIATELY: "IMMEDIATELY";
     /**
      * Never undoable.
      *
@@ -22,21 +22,21 @@ export declare const StoreAction: {
      *
      * These updates will _never_ make it to the local undo / redo stacks.
      */
-    readonly UPDATE: "update";
+    readonly NEVER: "NEVER";
     /**
      * Eventually undoable.
      *
      * Use for updates which should not be captured immediately - likely
      * exceptions which are part of some async multi-step process. Otherwise, all
      * such updates would end up being captured with the next
-     * `StoreAction.CAPTURE` - triggered either by the next `updateScene`
+     * `CaptureUpdateAction.IMMEDIATELY` - triggered either by the next `updateScene`
      * or internally by the editor.
      *
      * These updates will _eventually_ make it to the local undo / redo stacks.
      */
-    readonly NONE: "none";
+    readonly EVENTUALLY: "EVENTUALLY";
 };
-export type StoreActionType = ValueOf<typeof StoreAction>;
+export type CaptureUpdateActionType = ValueOf<typeof CaptureUpdateAction>;
 /**
  * Represent an increment to the Store.
  */

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

@@ -1,3 +1,4 @@
+import type { JSX } from "react";
 import type React from "react";
 import type { PointerType, ExcalidrawLinearElement, NonDeletedExcalidrawElement, NonDeleted, TextAlign, ExcalidrawElement, GroupId, ExcalidrawBindableElement, Arrowhead, ChartType, FontFamilyValues, FileId, ExcalidrawImageElement, Theme, StrokeRoundness, ExcalidrawEmbeddableElement, ExcalidrawMagicFrameElement, ExcalidrawFrameLikeElement, ExcalidrawElementType, ExcalidrawIframeLikeElement, OrderedExcalidrawElement, ExcalidrawNonSelectionElement } from "./element/types";
 import type { Action } from "./actions/types";
@@ -17,7 +18,7 @@ import type { IMAGE_MIME_TYPES, MIME_TYPES } from "./constants";
 import type { ContextMenuItems } from "./components/ContextMenu";
 import type { SnapLine } from "./snapping";
 import type { Merge, MaybePromise, ValueOf, MakeBrand } from "./utility-types";
-import type { StoreActionType } from "./store";
+import type { CaptureUpdateActionType } from "./store";
 import type { UserIdleState } from "./constants";
 export type SocketId = string & {
     _brand: "SocketId";
@@ -478,7 +479,7 @@ export type SceneData = {
     elements?: ImportedDataState["elements"];
     appState?: ImportedDataState["appState"];
     collaborators?: Map<SocketId, Collaborator>;
-    storeAction?: StoreActionType;
+    captureUpdate?: CaptureUpdateActionType;
 };
 export type ExportOpts = {
     saveFileToDisk?: boolean;

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

@@ -6,9 +6,9 @@ export declare const setDateTimeForTests: (dateTime: string) => void;
 export declare const getDateTime: () => string;
 export declare const capitalizeString: (str: string) => string;
 export declare const isToolIcon: (target: Element | EventTarget | null) => target is HTMLElement;
-export declare const isInputLike: (target: Element | EventTarget | null) => target is HTMLBRElement | HTMLDivElement | HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement;
+export declare const isInputLike: (target: Element | EventTarget | null) => target is HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | HTMLBRElement | HTMLDivElement;
 export declare const isInteractive: (target: Element | EventTarget | null) => boolean;
-export declare const isWritableElement: (target: Element | EventTarget | null) => target is HTMLBRElement | HTMLDivElement | HTMLInputElement | HTMLTextAreaElement;
+export declare const isWritableElement: (target: Element | EventTarget | null) => target is HTMLInputElement | HTMLTextAreaElement | HTMLBRElement | HTMLDivElement;
 export declare const getFontFamilyString: ({ fontFamily, }: {
     fontFamily: FontFamilyValues;
 }) => string;
@@ -184,7 +184,7 @@ export declare const wrapEvent: <T extends Event>(name: EVENT, nativeEvent: T) =
 }>;
 export declare const updateObject: <T extends Record<string, any>>(obj: T, updates: Partial<T>) => T;
 export declare const isPrimitive: (val: any) => boolean;
-export declare const getFrame: () => "iframe" | "top";
+export declare const getFrame: () => "top" | "iframe";
 export declare const isRunningInIframe: () => boolean;
 export declare const isPromiseLike: (value: any) => value is Promise<any>;
 export declare const queryFocusableElements: (container: HTMLElement | null) => HTMLElement[];

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

@@ -1,33 +1,32 @@
+import type { Curve } from "@excalidraw/math";
 import { type GlobalPoint, type LocalPoint } from "@excalidraw/math";
 import type { LineSegment } from "@excalidraw/utils";
-import type { BoundingBox, Bounds } from "./element/bounds";
+import type { Bounds } from "./element/bounds";
 declare global {
     interface Window {
         visualDebug?: {
             data: DebugElement[][];
             currentFrame?: number;
         };
-        debugDrawPoint: typeof debugDrawPoint;
-        debugDrawLine: typeof debugDrawLine;
     }
 }
 export type DebugElement = {
     color: string;
-    data: LineSegment<GlobalPoint>;
+    data: LineSegment<GlobalPoint> | Curve<GlobalPoint>;
     permanent: boolean;
 };
-export declare const debugDrawLine: (segment: LineSegment<GlobalPoint> | LineSegment<GlobalPoint>[], opts?: {
+export declare const debugDrawCubicBezier: (c: Curve<GlobalPoint>, opts?: {
     color?: string;
     permanent?: boolean;
 }) => void;
-export declare const debugDrawPoint: (p: GlobalPoint, opts?: {
+export declare const debugDrawLine: (segment: LineSegment<GlobalPoint> | LineSegment<GlobalPoint>[], opts?: {
     color?: string;
     permanent?: boolean;
-    fuzzy?: boolean;
 }) => void;
-export declare const debugDrawBoundingBox: (box: BoundingBox | BoundingBox[], opts?: {
+export declare const debugDrawPoint: (p: GlobalPoint, opts?: {
     color?: string;
     permanent?: boolean;
+    fuzzy?: boolean;
 }) => void;
 export declare const debugDrawBounds: (box: Bounds | Bounds[], opts?: {
     color?: string;

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

@@ -2,5 +2,5 @@ import type { ExcalidrawElement } from "./element/types";
 import type { AppState } from "./types";
 export declare const moveOneLeft: (allElements: readonly ExcalidrawElement[], appState: AppState) => readonly ExcalidrawElement[];
 export declare const moveOneRight: (allElements: readonly ExcalidrawElement[], appState: AppState) => readonly ExcalidrawElement[];
-export declare const moveAllLeft: (allElements: readonly ExcalidrawElement[], appState: AppState) => ExcalidrawElement[] | readonly ExcalidrawElement[];
-export declare const moveAllRight: (allElements: readonly ExcalidrawElement[], appState: AppState) => ExcalidrawElement[] | readonly ExcalidrawElement[];
+export declare const moveAllLeft: (allElements: readonly ExcalidrawElement[], appState: AppState) => readonly ExcalidrawElement[] | ExcalidrawElement[];
+export declare const moveAllRight: (allElements: readonly ExcalidrawElement[], appState: AppState) => readonly ExcalidrawElement[] | ExcalidrawElement[];

package/dist/types/math/curve.d.ts

@@ -1,4 +1,4 @@
-import type { Curve, GlobalPoint, LocalPoint, Radians } from "./types";
+import type { Curve, GlobalPoint, LineSegment, LocalPoint } from "./types";
 /**
  *
  * @param a
@@ -8,25 +8,33 @@ import type { Curve, GlobalPoint, LocalPoint, Radians } from "./types";
  * @returns
  */
 export declare function curve<Point extends GlobalPoint | LocalPoint>(a: Point, b: Point, c: Point, d: Point): Curve<Point>;
-export declare const curveRotate: <Point extends GlobalPoint | LocalPoint>(curve: Curve<Point>, angle: Radians, origin: Point) => Point[];
 /**
- *
- * @param pointsIn
- * @param curveTightness
- * @returns
+ * Computes the intersection between a cubic spline and a line segment.
  */
-export declare function curveToBezier<Point extends LocalPoint | GlobalPoint>(pointsIn: readonly Point[], curveTightness?: number): Point[];
+export declare function curveIntersectLineSegment<Point extends GlobalPoint | LocalPoint>(c: Curve<Point>, l: LineSegment<Point>): Point[];
 /**
+ * Finds the closest point on the Bezier curve from another point
  *
- * @param t
- * @param controlPoints
+ * @param x
+ * @param y
+ * @param P0
+ * @param P1
+ * @param P2
+ * @param P3
+ * @param tolerance
+ * @param maxLevel
  * @returns
  */
-export declare const cubicBezierPoint: <Point extends GlobalPoint | LocalPoint>(t: number, controlPoints: Curve<Point>) => Point;
+export declare function curveClosestPoint<Point extends GlobalPoint | LocalPoint>(c: Curve<Point>, p: Point, tolerance?: number): Point | null;
 /**
+ * Determines the distance between a point and the closest point on the
+ * Bezier curve.
  *
- * @param point
- * @param controlPoints
- * @returns
+ * @param c The curve to test
+ * @param p The point to measure from
+ */
+export declare function curvePointDistance<Point extends GlobalPoint | LocalPoint>(c: Curve<Point>, p: Point): number;
+/**
+ * Determines if the parameter is a Curve
  */
-export declare const cubicBezierDistance: <Point extends GlobalPoint | LocalPoint>(point: Point, controlPoints: Curve<Point>) => number;
+export declare function isCurve<P extends GlobalPoint | LocalPoint>(v: unknown): v is Curve<P>;

package/dist/types/math/ellipse.d.ts

@@ -0,0 +1,44 @@
+import type { Ellipse, GlobalPoint, Line, LineSegment, LocalPoint } from "./types";
+/**
+ * Construct an Ellipse object from the parameters
+ *
+ * @param center The center of the ellipse
+ * @param angle The slanting of the ellipse in radians
+ * @param halfWidth Half of the width of a non-slanted version of the ellipse
+ * @param halfHeight Half of the height of a non-slanted version of the ellipse
+ * @returns The constructed Ellipse object
+ */
+export declare function ellipse<Point extends GlobalPoint | LocalPoint>(center: Point, halfWidth: number, halfHeight: number): Ellipse<Point>;
+/**
+ * Determines if a point is inside or on the ellipse outline
+ *
+ * @param p The point to test
+ * @param ellipse The ellipse to compare against
+ * @returns TRUE if the point is inside or on the outline of the ellipse
+ */
+export declare const ellipseIncludesPoint: <Point extends GlobalPoint | LocalPoint>(p: Point, ellipse: Ellipse<Point>) => boolean;
+/**
+ * Tests whether a point lies on the outline of the ellipse within a given
+ * tolerance
+ *
+ * @param point The point to test
+ * @param ellipse The ellipse to compare against
+ * @param threshold The distance to consider a point close enough to be "on" the outline
+ * @returns TRUE if the point is on the ellise outline
+ */
+export declare const ellipseTouchesPoint: <Point extends GlobalPoint | LocalPoint>(point: Point, ellipse: Ellipse<Point>, threshold?: number) => boolean;
+/**
+ * Determine the shortest euclidean distance from a point to the
+ * outline of the ellipse
+ *
+ * @param p The point to consider
+ * @param ellipse The ellipse to calculate the distance to
+ * @returns The eucledian distance
+ */
+export declare const ellipseDistanceFromPoint: <Point extends GlobalPoint | LocalPoint>(p: Point, ellipse: Ellipse<Point>) => number;
+/**
+ * Calculate a maximum of two intercept points for a line going throug an
+ * ellipse.
+ */
+export declare function ellipseSegmentInterceptPoints<Point extends GlobalPoint | LocalPoint>(e: Readonly<Ellipse<Point>>, s: Readonly<LineSegment<Point>>): Point[];
+export declare function ellipseLineIntersectionPoints<Point extends GlobalPoint | LocalPoint>({ center, halfWidth, halfHeight }: Ellipse<Point>, [g, h]: Line<Point>): Point[];