@zsviczian/excalidraw 0.17.1-obsidian-20 → 0.17.1-obsidian-21

package/types/excalidraw/history.d.ts

@@ -1,52 +1,40 @@
+import { AppStateChange, ElementsChange } from "./change";
+import { SceneElementsMap } from "./element/types";
+import { Emitter } from "./emitter";
+import { Snapshot } from "./store";
 import { AppState } from "./types";
-import { ExcalidrawElement } from "./element/types";
-export interface HistoryEntry {
-    appState: ReturnType<typeof clearAppStatePropertiesForHistory>;
-    elements: ExcalidrawElement[];
+export declare class HistoryChangedEvent {
+    readonly isUndoStackEmpty: boolean;
+    readonly isRedoStackEmpty: boolean;
+    constructor(isUndoStackEmpty?: boolean, isRedoStackEmpty?: boolean);
 }
-declare const clearAppStatePropertiesForHistory: (appState: AppState) => {
-    selectedElementIds: Readonly<{
-        [id: string]: true;
-    }>;
-    selectedGroupIds: {
-        [groupId: string]: boolean;
-    };
-    viewBackgroundColor: string;
-    editingLinearElement: import("./element/linearElementEditor").LinearElementEditor | null;
-    editingGroupId: string | null;
-    name: string | null;
-};
-declare class History {
-    private elementCache;
-    private recording;
-    private stateHistory;
-    private redoStack;
-    private lastEntry;
-    private hydrateHistoryEntry;
-    private dehydrateHistoryEntry;
-    getSnapshotForTest(): {
-        recording: boolean;
-        stateHistory: HistoryEntry[];
-        redoStack: HistoryEntry[];
-    };
+export declare class History {
+    readonly onHistoryChangedEmitter: Emitter<[HistoryChangedEvent]>;
+    private readonly undoStack;
+    private readonly redoStack;
+    get isUndoStackEmpty(): boolean;
+    get isRedoStackEmpty(): boolean;
     clear(): void;
-    private generateEntry;
-    shouldCreateEntry(nextEntry: HistoryEntry): boolean;
-    pushEntry(appState: AppState, elements: readonly ExcalidrawElement[]): void;
-    clearRedoStack(): void;
-    redoOnce(): HistoryEntry | null;
-    undoOnce(): HistoryEntry | null;
     /**
-     * Updates history's `lastEntry` to latest app state. This is necessary
-     *  when doing undo/redo which itself doesn't commit to history, but updates
-     *  app state in a way that would break `shouldCreateEntry` which relies on
-     *  `lastEntry` to reflect last comittable history state.
-     * We can't update `lastEntry` from within history when calling undo/redo
-     *  because the action potentially mutates appState/elements before storing
-     *  it.
+     * Record a local change which will go into the history
      */
-    setCurrentState(appState: AppState, elements: readonly ExcalidrawElement[]): void;
-    resumeRecording(): void;
-    record(state: AppState, elements: readonly ExcalidrawElement[]): void;
+    record(elementsChange: ElementsChange, appStateChange: AppStateChange): void;
+    undo(elements: SceneElementsMap, appState: AppState, snapshot: Readonly<Snapshot>): void | [SceneElementsMap, AppState];
+    redo(elements: SceneElementsMap, appState: AppState, snapshot: Readonly<Snapshot>): void | [SceneElementsMap, AppState];
+    private perform;
+    private static pop;
+    private static push;
+}
+export declare class HistoryEntry {
+    readonly appStateChange: AppStateChange;
+    readonly elementsChange: ElementsChange;
+    private constructor();
+    static create(appStateChange: AppStateChange, elementsChange: ElementsChange): HistoryEntry;
+    inverse(): HistoryEntry;
+    applyTo(elements: SceneElementsMap, appState: AppState, snapshot: Readonly<Snapshot>): [SceneElementsMap, AppState, boolean];
+    /**
+     * Apply latest (remote) changes to the history entry, creates new instance of `HistoryEntry`.
+     */
+    applyLatestChanges(elements: SceneElementsMap): HistoryEntry;
+    isEmpty(): boolean;
 }
-export default History;

package/types/excalidraw/hooks/useEmitter.d.ts

@@ -0,0 +1,2 @@
+import { Emitter } from "../emitter";
+export declare const useEmitter: <TEvent extends unknown>(emitter: Emitter<[TEvent]>, initialState: TEvent) => TEvent;

package/types/excalidraw/index.d.ts

@@ -11,6 +11,7 @@ export declare const Excalidraw: React.MemoExoticComponent<(props: ExcalidrawPro
 export { getSceneVersion, hashElementsVersion, hashString, isInvisiblySmallElement, getNonDeletedElements, } from "./element";
 export { defaultLang, useI18n, languages } from "./i18n";
 export { restore, restoreAppState, restoreElements, restoreLibraryItems, } from "./data/restore";
+export { reconcileElements } from "./data/reconcile";
 export { exportToCanvas, exportToBlob, exportToSvg, exportToClipboard, getCommonBoundingBox, //zsviczian
 getMaximumGroups, //zsviczian
 intersectElementWithLine, //zsviczian
@@ -28,6 +29,7 @@ export { mergeLibraryItems, getLibraryItemsHash } from "./data/library";
 export { isLinearElement } from "./element/typeChecks";
 export { FONT_FAMILY, THEME, MIME_TYPES, ROUNDNESS, DEFAULT_LASER_COLOR, } from "./constants";
 export { mutateElement, newElementWith, bumpVersion, } from "./element/mutateElement";
+export { StoreAction } from "./store";
 export { parseLibraryTokensFromUrl, useHandleLibrary } from "./data/library";
 export { sceneCoordsToViewportCoords, viewportCoordsToSceneCoords, } from "./utils";
 export { getEmbedLink } from "./element/embeddable";

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

@@ -9,7 +9,7 @@ export declare const renderInteractiveSceneThrottled: {
  * 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, scale, appState, renderConfig, }: InteractiveSceneRenderConfig) => {
+export declare const renderInteractiveScene: <U extends ({ canvas, elementsMap, visibleElements, selectedElements, scale, appState, renderConfig, device, }: InteractiveSceneRenderConfig) => {
     atLeastOneVisibleElement: boolean;
     elementsMap: RenderableElementsMap;
     scrollBars?: undefined;

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

@@ -1,4 +1,4 @@
-import { ExcalidrawElement, NonDeletedExcalidrawElement, NonDeleted, ExcalidrawFrameLikeElement, ElementsMapOrArray } from "../element/types";
+import { ExcalidrawElement, NonDeletedExcalidrawElement, NonDeleted, ExcalidrawFrameLikeElement, ElementsMapOrArray, OrderedExcalidrawElement, Ordered } from "../element/types";
 import { LinearElementEditor } from "../element/linearElementEditor";
 import { AppState } from "../types";
 type ElementIdKey = InstanceType<typeof LinearElementEditor>["elementId"];
@@ -20,10 +20,10 @@ declare class Scene {
     private elementsMap;
     private selectedElementsCache;
     private versionNonce;
-    getElementsMapIncludingDeleted(): Map<string, ExcalidrawElement> & import("../utility-types").MakeBrand<"SceneElementsMap">;
-    getNonDeletedElementsMap(): Map<string, NonDeletedExcalidrawElement> & import("../utility-types").MakeBrand<"NonDeletedSceneElementsMap">;
-    getElementsIncludingDeleted(): readonly ExcalidrawElement[];
-    getNonDeletedElements(): readonly NonDeletedExcalidrawElement[];
+    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"];
@@ -59,7 +59,8 @@ declare class Scene {
     destroy(): void;
     insertElementAtIndex(element: ExcalidrawElement, index: number): void;
     insertElementsAtIndex(elements: ExcalidrawElement[], index: number): void;
-    addNewElement: (element: ExcalidrawElement) => void;
+    insertElement: (element: ExcalidrawElement, idx?: number) => void;
+    insertElements: (elements: ExcalidrawElement[]) => void;
     getElementIndex(elementId: string): number;
     getContainerElement: (element: (ExcalidrawElement & {
         containerId: ExcalidrawElement["id"] | null;

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

@@ -1,7 +1,7 @@
 import type { RoughCanvas } from "roughjs/bin/canvas";
 import { Drawable } from "roughjs/bin/core";
 import { ExcalidrawElement, ExcalidrawTextElement, NonDeletedElementsMap, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap } from "../element/types";
-import { AppClassProperties, AppState, EmbedsValidationStatus, ElementsPendingErasure, InteractiveCanvasAppState, StaticCanvasAppState, SocketId, UserIdleState } from "../types";
+import { AppClassProperties, AppState, EmbedsValidationStatus, ElementsPendingErasure, InteractiveCanvasAppState, StaticCanvasAppState, SocketId, UserIdleState, Device } from "../types";
 import { MakeBrand } from "../utility-types";
 export type RenderableElementsMap = NonDeletedElementsMap & MakeBrand<"RenderableElementsMap">;
 export type StaticCanvasRenderConfig = {
@@ -60,6 +60,7 @@ export type InteractiveSceneRenderConfig = {
     scale: number;
     appState: InteractiveCanvasAppState;
     renderConfig: InteractiveCanvasRenderConfig;
+    device: Device;
     callback: (data: RenderInteractiveSceneCallback) => void;
 };
 export type SceneScroll = {

package/types/excalidraw/store.d.ts

@@ -0,0 +1,99 @@
+import { AppStateChange, ElementsChange } from "./change";
+import { OrderedExcalidrawElement } from "./element/types";
+import { Emitter } from "./emitter";
+import { AppState, ObservedAppState } from "./types";
+export declare const getObservedAppState: (appState: AppState) => ObservedAppState;
+export type StoreActionType = "capture" | "update" | "none";
+export declare const StoreAction: {
+    [K in Uppercase<StoreActionType>]: StoreActionType;
+};
+/**
+ * Represent an increment to the Store.
+ */
+declare class StoreIncrementEvent {
+    readonly elementsChange: ElementsChange;
+    readonly appStateChange: AppStateChange;
+    constructor(elementsChange: ElementsChange, appStateChange: AppStateChange);
+}
+/**
+ * Store which captures the observed changes and emits them as `StoreIncrementEvent` events.
+ *
+ * @experimental this interface is experimental and subject to change.
+ */
+export interface IStore {
+    onStoreIncrementEmitter: Emitter<[StoreIncrementEvent]>;
+    get snapshot(): Snapshot;
+    set snapshot(snapshot: Snapshot);
+    /**
+     * Use to schedule update of the snapshot, useful on updates for which we don't need to calculate increments (i.e. remote updates).
+     */
+    shouldUpdateSnapshot(): void;
+    /**
+     * Use to schedule calculation of a store increment.
+     */
+    shouldCaptureIncrement(): void;
+    /**
+     * Based on the scheduled operation, either only updates store snapshot or also calculates increment and emits the result as a `StoreIncrementEvent`.
+     *
+     * @emits StoreIncrementEvent when increment is calculated.
+     */
+    commit(elements: Map<string, OrderedExcalidrawElement> | undefined, appState: AppState | ObservedAppState | undefined): void;
+    /**
+     * Clears the store instance.
+     */
+    clear(): void;
+    /**
+     * Filters out yet uncomitted elements from `nextElements`, which are part of in-progress local async actions (ephemerals) and thus were not yet commited to the snapshot.
+     *
+     * This is necessary in updates in which we receive reconciled elements, already containing elements which were not yet captured by the local store (i.e. collab).
+     */
+    filterUncomittedElements(prevElements: Map<string, OrderedExcalidrawElement>, nextElements: Map<string, OrderedExcalidrawElement>): Map<string, OrderedExcalidrawElement>;
+}
+export declare class Store implements IStore {
+    readonly onStoreIncrementEmitter: Emitter<[StoreIncrementEvent]>;
+    private scheduledActions;
+    private _snapshot;
+    get snapshot(): Snapshot;
+    set snapshot(snapshot: Snapshot);
+    shouldCaptureIncrement: () => void;
+    shouldUpdateSnapshot: () => void;
+    private scheduleAction;
+    commit: (elements: Map<string, OrderedExcalidrawElement> | undefined, appState: AppState | ObservedAppState | undefined) => void;
+    captureIncrement: (elements: Map<string, OrderedExcalidrawElement> | undefined, appState: AppState | ObservedAppState | undefined) => void;
+    updateSnapshot: (elements: Map<string, OrderedExcalidrawElement> | undefined, appState: AppState | ObservedAppState | undefined) => void;
+    filterUncomittedElements: (prevElements: Map<string, OrderedExcalidrawElement>, nextElements: Map<string, OrderedExcalidrawElement>) => Map<string, OrderedExcalidrawElement>;
+    clear: () => void;
+    private satisfiesScheduledActionsInvariant;
+}
+export declare class Snapshot {
+    readonly elements: Map<string, OrderedExcalidrawElement>;
+    readonly appState: ObservedAppState;
+    readonly meta: {
+        didElementsChange: boolean;
+        didAppStateChange: boolean;
+        isEmpty?: boolean;
+    };
+    private constructor();
+    static empty(): Snapshot;
+    isEmpty(): boolean | undefined;
+    /**
+     * Efficiently clone the existing snapshot, only if we detected changes.
+     *
+     * @returns same instance if there are no changes detected, new instance otherwise.
+     */
+    maybeClone(elements: Map<string, OrderedExcalidrawElement> | undefined, appState: AppState | ObservedAppState | undefined): Snapshot;
+    private maybeCreateAppStateSnapshot;
+    private detectChangedAppState;
+    private maybeCreateElementsSnapshot;
+    /**
+     * Detect if there any changed elements.
+     *
+     * NOTE: we shouldn't just use `sceneVersionNonce` instead, as we need to call this before the scene updates.
+     */
+    private detectChangedElements;
+    /**
+     * Perform structural clone, cloning only elements that changed.
+     */
+    private createElementsSnapshot;
+}
+export {};

package/types/excalidraw/types.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-import { PointerType, ExcalidrawLinearElement, NonDeletedExcalidrawElement, NonDeleted, TextAlign, ExcalidrawElement, GroupId, ExcalidrawBindableElement, Arrowhead, ChartType, FontFamilyValues, ExcalidrawTextElement, FileId, ExcalidrawImageElement, Theme, StrokeRoundness, ExcalidrawEmbeddableElement, ExcalidrawMagicFrameElement, ExcalidrawFrameLikeElement, ExcalidrawElementType, ExcalidrawIframeLikeElement } from "./element/types";
+import { PointerType, ExcalidrawLinearElement, NonDeletedExcalidrawElement, NonDeleted, TextAlign, ExcalidrawElement, GroupId, ExcalidrawBindableElement, Arrowhead, ChartType, FontFamilyValues, ExcalidrawTextElement, FileId, ExcalidrawImageElement, Theme, StrokeRoundness, ExcalidrawEmbeddableElement, ExcalidrawMagicFrameElement, ExcalidrawFrameLikeElement, ExcalidrawElementType, ExcalidrawIframeLikeElement, OrderedExcalidrawElement } from "./element/types";
 import { Action } from "./actions/types";
 import { Point as RoughPoint } from "roughjs/bin/geometry";
 import { LinearElementEditor } from "./element/linearElementEditor";
@@ -19,6 +19,7 @@ import { ContextMenuItems } from "./components/ContextMenu";
 import { SnapLine } from "./snapping";
 import { Merge, MaybePromise, ValueOf } from "./utility-types";
 import { ColorPaletteCustom } from "./colors";
+import { StoreActionType } from "./store";
 export type Point = Readonly<RoughPoint>;
 export type SocketId = string & {
     _brand: "SocketId";
@@ -138,6 +139,18 @@ export type InteractiveCanvasAppState = Readonly<_CommonCanvasAppState & {
     snapLines: AppState["snapLines"];
     zenModeEnabled: AppState["zenModeEnabled"];
 }>;
+export type ObservedAppState = ObservedStandaloneAppState & ObservedElementsAppState;
+export type ObservedStandaloneAppState = {
+    name: AppState["name"];
+    viewBackgroundColor: AppState["viewBackgroundColor"];
+};
+export type ObservedElementsAppState = {
+    editingGroupId: AppState["editingGroupId"];
+    selectedElementIds: AppState["selectedElementIds"];
+    selectedGroupIds: AppState["selectedGroupIds"];
+    editingLinearElementId: LinearElementEditor["elementId"] | null;
+    selectedLinearElementId: LinearElementEditor["elementId"] | null;
+};
 export interface AppState {
     contextMenu: {
         items: ContextMenuItems;
@@ -368,7 +381,7 @@ export type OnUserFollowedPayload = {
     action: "FOLLOW" | "UNFOLLOW";
 };
 export interface ExcalidrawProps {
-    onChange?: (elements: readonly ExcalidrawElement[], appState: AppState, files: BinaryFiles) => void;
+    onChange?: (elements: readonly OrderedExcalidrawElement[], appState: AppState, files: BinaryFiles) => void;
     initialData?: MaybePromise<ExcalidrawInitialDataState | null>;
     excalidrawAPI?: (api: ExcalidrawImperativeAPI) => void;
     isCollaborating?: boolean;
@@ -426,7 +439,7 @@ export type SceneData = {
     elements?: ImportedDataState["elements"];
     appState?: ImportedDataState["appState"];
     collaborators?: Map<SocketId, Collaborator>;
-    commitToHistory?: boolean;
+    storeAction?: StoreActionType;
 };
 export declare enum UserIdleState {
     ACTIVE = "active",
@@ -499,6 +512,7 @@ export type AppClassProperties = {
     setOpenDialog: App["setOpenDialog"];
     insertEmbeddableElement: App["insertEmbeddableElement"];
     onMagicframeToolSelect: App["onMagicframeToolSelect"];
+    getElementShape: App["getElementShape"];
     getName: App["getName"];
 };
 export type PointerDownState = Readonly<{
@@ -611,7 +625,7 @@ export type Device = Readonly<{
     };
     isTouchScreen: boolean;
 }>;
-type FrameNameBounds = {
+export type FrameNameBounds = {
     x: number;
     y: number;
     width: number;

package/types/excalidraw/utils.d.ts

@@ -160,7 +160,14 @@ export declare const arrayToMap: <T extends string | {
 export declare const arrayToMapWithIndex: <T extends {
     id: string;
 }>(elements: readonly T[]) => Map<string, [element: T, index: number]>;
+/**
+ * Transform array into an object, use only when array order is irrelevant.
+ */
+export declare const arrayToObject: <T>(array: readonly T[], groupBy?: ((value: T) => string) | undefined) => {
+    [key: string]: T;
+};
 export declare const isTestEnv: () => boolean;
+export declare const isDevEnv: () => boolean;
 export declare const wrapEvent: <T extends Event>(name: EVENT, nativeEvent: T) => CustomEvent<{
     nativeEvent: T;
 }>;

package/types/excalidraw/webpack.prod.config.d.ts

@@ -78,7 +78,7 @@ export namespace module {
 }
 export namespace optimization {
     const minimize: boolean;
-    const minimizer: TerserPlugin<import("terser").MinifyOptions>[];
+    const minimizer: TerserPlugin<import("terser-webpack-plugin/node_modules/terser").MinifyOptions>[];
 }
 export const plugins: any[];
 export const externals: {

package/types/excalidraw/zindex.d.ts

@@ -1,6 +1,6 @@
 import { ExcalidrawElement } from "./element/types";
 import { AppState } from "./types";
-export declare const moveOneLeft: (allElements: readonly ExcalidrawElement[], appState: AppState) => ExcalidrawElement[];
-export declare const moveOneRight: (allElements: readonly ExcalidrawElement[], appState: AppState) => ExcalidrawElement[];
+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) => readonly ExcalidrawElement[] | ExcalidrawElement[];
 export declare const moveAllRight: (allElements: readonly ExcalidrawElement[], appState: AppState) => readonly ExcalidrawElement[] | ExcalidrawElement[];

package/types/utils/collision.d.ts

@@ -0,0 +1,4 @@
+import { Point, Polygon, GeometricShape } from "./geometry/shape";
+export declare const isPointOnShape: (point: Point, shape: GeometricShape, tolerance?: number) => boolean;
+export declare const isPointInShape: (point: Point, shape: GeometricShape) => boolean;
+export declare const isPointInBounds: (point: Point, bounds: Polygon) => boolean;

package/types/utils/export.d.ts

@@ -33,8 +33,8 @@ export declare const exportToClipboard: (opts: ExportOpts & {
 }) => Promise<void>;
 export { getCommonBoundingBox } from "../excalidraw/element/bounds";
 export { getMaximumGroups } from "../excalidraw/groups";
-export { intersectElementWithLine } from "../excalidraw/element/collision";
-export { determineFocusDistance } from "../excalidraw/element/collision";
+export { intersectElementWithLine } from "../excalidraw/element/binding";
+export { determineFocusDistance } from "../excalidraw/element/binding";
 export { measureText, wrapText, getDefaultLineHeight, } from "../excalidraw/element/textElement";
 export { getFontString } from "../excalidraw/utils";
 export { getBoundTextMaxWidth } from "../excalidraw/element/textElement";

package/types/utils/geometry/geometry.d.ts

@@ -0,0 +1,71 @@
+import { Point, Line, Polygon, Curve, Ellipse, Polycurve, Polyline } from "./shape";
+/**
+ * utils
+ */
+export declare const cross: (a: Point, b: Point, o: Point) => number;
+export declare const isClosed: (polygon: Polygon) => boolean;
+export declare const close: (polygon: Polygon) => Polygon;
+/**
+ * angles
+ */
+export declare const angleToDegrees: (angle: number) => number;
+export declare const angleToRadians: (angle: number) => number;
+export declare const angleReflect: (incidenceAngle: number, surfaceAngle: number) => number;
+export declare const pointRotate: (point: Point, angle: number, origin?: Point) => Point;
+export declare const pointTranslate: (point: Point, angle?: number, distance?: number) => Point;
+export declare const pointInverse: (point: Point) => Point;
+export declare const pointAdd: (pointA: Point, pointB: Point) => Point;
+export declare const distanceToPoint: (p1: Point, p2: Point) => number;
+/**
+ * lines
+ */
+export declare const lineAngle: (line: Line) => number;
+export declare const lineLength: (line: Line) => number;
+export declare const lineMidpoint: (line: Line) => Point;
+export declare const lineRotate: (line: Line, angle: number, origin?: Point) => Line;
+export declare const lineTranslate: (line: Line, angle: number, distance: number) => Point[];
+export declare const lineInterpolate: (line: Line, clamp?: boolean) => (t: number) => Point;
+export declare const curveToBezier: (pointsIn: readonly Point[], curveTightness?: number) => Point[];
+export declare const curveRotate: (curve: Curve, angle: number, origin: Point) => Point[];
+export declare const cubicBezierPoint: (t: number, controlPoints: Curve) => Point;
+export declare const cubicBezierDistance: (point: Point, controlPoints: Curve) => number;
+/**
+ * polygons
+ */
+export declare const polygonRotate: (polygon: Polygon, angle: number, origin: Point) => Point[];
+export declare const polygonBounds: (polygon: Polygon) => [Point, Point];
+export declare const polygonCentroid: (vertices: Point[]) => Point;
+export declare const polygonScale: (polygon: Polygon, scale: number, origin?: Point) => Polygon;
+export declare const polygonScaleX: (polygon: Polygon, scale: number, origin?: Point) => Polygon;
+export declare const polygonScaleY: (polygon: Polygon, scale: number, origin?: Point) => Polygon;
+export declare const polygonReflectX: (polygon: Polygon, reflectFactor?: number) => Point[];
+export declare const polygonReflectY: (polygon: Polygon, reflectFactor?: number) => Point[];
+export declare const polygonTranslate: (polygon: Polygon, angle: number, distance: number) => Point[];
+/**
+ * ellipses
+ */
+export declare const ellipseAxes: (ellipse: Ellipse) => {
+    majorAxis: number;
+    minorAxis: number;
+};
+export declare const ellipseFocusToCenter: (ellipse: Ellipse) => number;
+export declare const ellipseExtremes: (ellipse: Ellipse) => Point[];
+export declare const pointRelativeToCenter: (point: Point, center: Point, angle: number) => Point;
+export declare const pointLeftofLine: (point: Point, line: Line) => boolean;
+export declare const pointRightofLine: (point: Point, line: Line) => boolean;
+export declare const distanceToSegment: (point: Point, line: Line) => number;
+export declare const pointOnLine: (point: Point, line: Line, threshold?: number) => boolean;
+export declare const pointOnPolyline: (point: Point, polyline: Polyline, threshold?: number) => boolean;
+export declare const lineIntersectsLine: (lineA: Line, lineB: Line) => boolean;
+export declare const lineIntersectsPolygon: (line: Line, polygon: Polygon) => boolean;
+export declare const pointInBezierEquation: (p0: Point, p1: Point, p2: Point, p3: Point, [mx, my]: Point, lineThreshold: number) => boolean;
+export declare const cubicBezierEquation: (curve: Curve) => (t: number, idx: number) => number;
+export declare const polyLineFromCurve: (curve: Curve, segments?: number) => Polyline;
+export declare const pointOnCurve: (point: Point, curve: Curve, threshold?: number) => boolean;
+export declare const pointOnPolycurve: (point: Point, polycurve: Polycurve, threshold?: number) => boolean;
+export declare const pointInPolygon: (point: Point, polygon: Polygon) => boolean;
+export declare const pointOnPolygon: (point: Point, polygon: Polygon, threshold?: number) => boolean;
+export declare const polygonInPolygon: (polygonA: Polygon, polygonB: Polygon) => boolean;
+export declare const polygonIntersectPolygon: (polygonA: Polygon, polygonB: Polygon) => boolean;
+export declare const pointOnEllipse: (point: Point, ellipse: Ellipse, threshold?: number) => boolean;
+export declare const pointInEllipse: (point: Point, ellipse: Ellipse) => boolean;

package/types/utils/geometry/shape.d.ts

@@ -0,0 +1,56 @@
+/**
+ * this file defines pure geometric shapes
+ *
+ * for instance, a cubic bezier curve is specified by its four control points and
+ * an ellipse is defined by its center, angle, semi major axis and semi minor axis
+ * (but in semi-width and semi-height so it's more relevant to Excalidraw)
+ *
+ * the idea with pure shapes is so that we can provide collision and other geoemtric methods not depending on
+ * the specifics of roughjs or elements in Excalidraw; instead, we can focus on the pure shapes themselves
+ *
+ * also included in this file are methods for converting an Excalidraw element or a Drawable from roughjs
+ * to pure shapes
+ */
+import { ElementsMap, ExcalidrawDiamondElement, ExcalidrawElement, ExcalidrawEllipseElement, ExcalidrawEmbeddableElement, ExcalidrawFrameLikeElement, ExcalidrawFreeDrawElement, ExcalidrawIframeElement, ExcalidrawImageElement, ExcalidrawLinearElement, ExcalidrawRectangleElement, ExcalidrawSelectionElement, ExcalidrawTextElement } from "../../excalidraw/element/types";
+import type { Drawable, Op } from "roughjs/bin/core";
+export type Point = [number, number];
+export type Vector = Point;
+export type Line = [Point, Point];
+export type Polyline = Line[];
+export type Curve = [Point, Point, Point, Point];
+export type Polycurve = Curve[];
+export type Polygon = Point[];
+export type Ellipse = {
+    center: Point;
+    angle: number;
+    halfWidth: number;
+    halfHeight: number;
+};
+export type GeometricShape = {
+    type: "line";
+    data: Line;
+} | {
+    type: "polygon";
+    data: Polygon;
+} | {
+    type: "curve";
+    data: Curve;
+} | {
+    type: "ellipse";
+    data: Ellipse;
+} | {
+    type: "polyline";
+    data: Polyline;
+} | {
+    type: "polycurve";
+    data: Polycurve;
+};
+type RectangularElement = ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawFrameLikeElement | ExcalidrawEmbeddableElement | ExcalidrawImageElement | ExcalidrawIframeElement | ExcalidrawTextElement | ExcalidrawSelectionElement;
+export declare const getPolygonShape: (element: RectangularElement) => GeometricShape;
+export declare const getSelectionBoxShape: (element: ExcalidrawElement, elementsMap: ElementsMap, padding?: number) => GeometricShape;
+export declare const getEllipseShape: (element: ExcalidrawEllipseElement) => GeometricShape;
+export declare const getCurvePathOps: (shape: Drawable) => Op[];
+export declare const getCurveShape: (roughShape: Drawable, startingPoint: Point | undefined, angleInRadian: number, center: Point) => GeometricShape;
+export declare const getFreedrawShape: (element: ExcalidrawFreeDrawElement, center: Point, isClosed?: boolean) => GeometricShape;
+export declare const getClosedCurveShape: (element: ExcalidrawLinearElement, roughShape: Drawable, startingPoint: Point | undefined, angleInRadian: number, center: Point) => GeometricShape;
+export {};