@zsviczian/excalidraw 0.17.1-obsidian-29 → 0.17.1-obsidian-30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zsviczian/excalidraw",
-  "version": "0.17.1-obsidian-29",
+  "version": "0.17.1-obsidian-30",
   "main": "main.js",
   "types": "types/excalidraw/index.d.ts",
   "files": [

package/types/excalidraw/components/App.d.ts

@@ -8,7 +8,6 @@ import { LinearElementEditor } from "../element/linearElementEditor";
 import type { ExcalidrawElement, ExcalidrawLinearElement, NonDeleted, NonDeletedExcalidrawElement, ExcalidrawFrameLikeElement, ExcalidrawIframeElement, ExcalidrawEmbeddableElement, Ordered } from "../element/types";
 import { History } from "../history";
 import Scene from "../scene/Scene";
-import type { GeometricShape } from "../../utils/geometry/shape";
 import type { AppClassProperties, AppProps, AppState, ExcalidrawImperativeAPI, BinaryFiles, LibraryItems, SceneData, Device, FrameNameBoundsCache, SidebarName, SidebarTabName, ToolType, OnUserFollowedPayload } from "../types";
 import type { FileSystemHandle } from "../data/filesystem";
 import { Renderer } from "../scene/Renderer";
@@ -43,7 +42,6 @@ export declare const useExcalidrawElements: () => readonly NonDeletedExcalidrawE
 export declare const useExcalidrawAppState: () => AppState;
 export declare const useExcalidrawSetAppState: () => <K extends keyof AppState>(state: AppState | ((prevState: Readonly<AppState>, props: Readonly<any>) => AppState | Pick<AppState, K> | null) | Pick<AppState, K> | null, callback?: (() => void) | undefined) => void;
 export declare const useExcalidrawActionManager: () => ActionManager;
-export declare let hostPlugin: any;
 declare class App extends React.Component<AppProps, AppState> {
     canvas: AppClassProperties["canvas"];
     interactiveCanvas: AppClassProperties["interactiveCanvas"];
@@ -403,11 +401,6 @@ declare class App extends React.Component<AppProps, AppState> {
     private handleTextWysiwyg;
     private deselectElements;
     private getTextElementAtPosition;
-    /**
-     * get the pure geometric shape of an excalidraw element
-     * which is then used for hit detection
-     */
-    getElementShape(element: ExcalidrawElement): GeometricShape;
     private getBoundTextShape;
     private getElementAtPosition;
     private getElementsAtPosition;
@@ -521,5 +514,4 @@ declare global {
         };
     }
 }
-export declare const createTestHook: () => void;
 export default App;

package/types/excalidraw/components/Stats/Angle.d.ts

@@ -1,7 +1,11 @@
-import type { ElementsMap, ExcalidrawElement } from "../../element/types";
+import type { ExcalidrawElement } from "../../element/types";
+import type Scene from "../../scene/Scene";
+import type { AppState } from "../../types";
 interface AngleProps {
     element: ExcalidrawElement;
-    elementsMap: ElementsMap;
+    scene: Scene;
+    appState: AppState;
+    property: "angle";
 }
-declare const Angle: ({ element, elementsMap }: AngleProps) => import("react/jsx-runtime").JSX.Element;
+declare const Angle: ({ element, scene, appState, property }: AngleProps) => import("react/jsx-runtime").JSX.Element;
 export default Angle;

package/types/excalidraw/components/Stats/Dimension.d.ts

@@ -1,8 +1,11 @@
-import type { ElementsMap, ExcalidrawElement } from "../../element/types";
+import type { ExcalidrawElement } from "../../element/types";
+import type Scene from "../../scene/Scene";
+import type { AppState } from "../../types";
 interface DimensionDragInputProps {
     property: "width" | "height";
     element: ExcalidrawElement;
-    elementsMap: ElementsMap;
+    scene: Scene;
+    appState: AppState;
 }
-declare const DimensionDragInput: ({ property, element, elementsMap, }: DimensionDragInputProps) => import("react/jsx-runtime").JSX.Element;
+declare const DimensionDragInput: ({ property, element, scene, appState, }: DimensionDragInputProps) => import("react/jsx-runtime").JSX.Element;
 export default DimensionDragInput;

package/types/excalidraw/components/Stats/DragInput.d.ts

@@ -1,22 +1,31 @@
 import type { ElementsMap, ExcalidrawElement } from "../../element/types";
+import type { StatsInputProperty } from "./utils";
+import type Scene from "../../scene/Scene";
 import "./DragInput.scss";
-export type DragInputCallbackType = ({ accumulatedChange, instantChange, originalElements, originalElementsMap, shouldKeepAspectRatio, shouldChangeByStepSize, nextValue, }: {
+import type { AppState } from "../../types";
+export type DragInputCallbackType<P extends StatsInputProperty, E = ExcalidrawElement> = (props: {
     accumulatedChange: number;
     instantChange: number;
-    originalElements: readonly ExcalidrawElement[];
+    originalElements: readonly E[];
     originalElementsMap: ElementsMap;
     shouldKeepAspectRatio: boolean;
     shouldChangeByStepSize: boolean;
     nextValue?: number;
+    property: P;
+    scene: Scene;
+    originalAppState: AppState;
 }) => void;
-interface StatsDragInputProps {
+interface StatsDragInputProps<T extends StatsInputProperty, E = ExcalidrawElement> {
     label: string | React.ReactNode;
     icon?: React.ReactNode;
     value: number | "Mixed";
-    elements: readonly ExcalidrawElement[];
+    elements: readonly E[];
     editable?: boolean;
     shouldKeepAspectRatio?: boolean;
-    dragInputCallback: DragInputCallbackType;
+    dragInputCallback: DragInputCallbackType<T, E>;
+    property: T;
+    scene: Scene;
+    appState: AppState;
 }
-declare const StatsDragInput: ({ label, icon, dragInputCallback, value, elements, editable, shouldKeepAspectRatio, }: StatsDragInputProps) => import("react/jsx-runtime").JSX.Element;
+declare const StatsDragInput: <T extends StatsInputProperty, E extends ExcalidrawElement = ExcalidrawElement>({ label, icon, dragInputCallback, value, elements, editable, shouldKeepAspectRatio, property, scene, appState, }: StatsDragInputProps<T, E>) => import("react/jsx-runtime").JSX.Element | null;
 export default StatsDragInput;

package/types/excalidraw/components/Stats/FontSize.d.ts

@@ -1,7 +1,11 @@
-import type { ElementsMap, ExcalidrawTextElement } from "../../element/types";
+import type { ExcalidrawElement } from "../../element/types";
+import type Scene from "../../scene/Scene";
+import type { AppState } from "../../types";
 interface FontSizeProps {
-    element: ExcalidrawTextElement;
-    elementsMap: ElementsMap;
+    element: ExcalidrawElement;
+    scene: Scene;
+    appState: AppState;
+    property: "fontSize";
 }
-declare const FontSize: ({ element, elementsMap }: FontSizeProps) => import("react/jsx-runtime").JSX.Element;
+declare const FontSize: ({ element, scene, appState, property }: FontSizeProps) => import("react/jsx-runtime").JSX.Element | null;
 export default FontSize;

package/types/excalidraw/components/Stats/MultiAngle.d.ts

@@ -1,9 +1,11 @@
-import type { ElementsMap, ExcalidrawElement } from "../../element/types";
+import type { ExcalidrawElement } from "../../element/types";
 import type Scene from "../../scene/Scene";
+import type { AppState } from "../../types";
 interface MultiAngleProps {
     elements: readonly ExcalidrawElement[];
-    elementsMap: ElementsMap;
     scene: Scene;
+    appState: AppState;
+    property: "angle";
 }
-declare const MultiAngle: ({ elements, elementsMap, scene }: MultiAngleProps) => import("react/jsx-runtime").JSX.Element;
+declare const MultiAngle: ({ elements, scene, appState, property, }: MultiAngleProps) => import("react/jsx-runtime").JSX.Element;
 export default MultiAngle;

package/types/excalidraw/components/Stats/MultiDimension.d.ts

@@ -1,12 +1,14 @@
-import type { ElementsMap, ExcalidrawElement } from "../../element/types";
+import type { ExcalidrawElement, NonDeletedSceneElementsMap } from "../../element/types";
 import type Scene from "../../scene/Scene";
+import type { AppState } from "../../types";
 import type { AtomicUnit } from "./utils";
 interface MultiDimensionProps {
     property: "width" | "height";
     elements: readonly ExcalidrawElement[];
-    elementsMap: ElementsMap;
+    elementsMap: NonDeletedSceneElementsMap;
     atomicUnits: AtomicUnit[];
     scene: Scene;
+    appState: AppState;
 }
-declare const MultiDimension: ({ property, elements, elementsMap, atomicUnits, scene, }: MultiDimensionProps) => import("react/jsx-runtime").JSX.Element;
+declare const MultiDimension: ({ property, elements, elementsMap, atomicUnits, scene, appState, }: MultiDimensionProps) => import("react/jsx-runtime").JSX.Element;
 export default MultiDimension;

package/types/excalidraw/components/Stats/MultiFontSize.d.ts

@@ -1,9 +1,12 @@
-import type { ElementsMap, ExcalidrawElement } from "../../element/types";
+import type { ExcalidrawElement, NonDeletedSceneElementsMap } from "../../element/types";
 import type Scene from "../../scene/Scene";
+import type { AppState } from "../../types";
 interface MultiFontSizeProps {
     elements: readonly ExcalidrawElement[];
-    elementsMap: ElementsMap;
     scene: Scene;
+    elementsMap: NonDeletedSceneElementsMap;
+    appState: AppState;
+    property: "fontSize";
 }
-declare const MultiFontSize: ({ elements, elementsMap, scene, }: MultiFontSizeProps) => import("react/jsx-runtime").JSX.Element;
+declare const MultiFontSize: ({ elements, scene, appState, property, elementsMap, }: MultiFontSizeProps) => import("react/jsx-runtime").JSX.Element | null;
 export default MultiFontSize;

package/types/excalidraw/components/Stats/MultiPosition.d.ts

@@ -1,12 +1,14 @@
 import type { ElementsMap, ExcalidrawElement } from "../../element/types";
 import type Scene from "../../scene/Scene";
 import type { AtomicUnit } from "./utils";
+import type { AppState } from "../../types";
 interface MultiPositionProps {
     property: "x" | "y";
     elements: readonly ExcalidrawElement[];
     elementsMap: ElementsMap;
     atomicUnits: AtomicUnit[];
     scene: Scene;
+    appState: AppState;
 }
-declare const MultiPosition: ({ property, elements, elementsMap, atomicUnits, scene, }: MultiPositionProps) => import("react/jsx-runtime").JSX.Element;
+declare const MultiPosition: ({ property, elements, elementsMap, atomicUnits, scene, appState, }: MultiPositionProps) => import("react/jsx-runtime").JSX.Element;
 export default MultiPosition;

package/types/excalidraw/components/Stats/Position.d.ts

@@ -1,8 +1,12 @@
 import type { ElementsMap, ExcalidrawElement } from "../../element/types";
+import type Scene from "../../scene/Scene";
+import type { AppState } from "../../types";
 interface PositionProps {
     property: "x" | "y";
     element: ExcalidrawElement;
     elementsMap: ElementsMap;
+    scene: Scene;
+    appState: AppState;
 }
-declare const Position: ({ property, element, elementsMap }: PositionProps) => import("react/jsx-runtime").JSX.Element;
+declare const Position: ({ property, element, elementsMap, scene, appState, }: PositionProps) => import("react/jsx-runtime").JSX.Element;
 export default Position;

package/types/excalidraw/components/Stats/utils.d.ts

@@ -1,4 +1,6 @@
-import type { ElementsMap, ExcalidrawElement, NonDeletedExcalidrawElement } from "../../element/types";
+import type { ElementsMap, ExcalidrawElement, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap } from "../../element/types";
+import type { AppState } from "../../types";
+export type StatsInputProperty = "x" | "y" | "width" | "height" | "angle" | "fontSize";
 export declare const SMALLEST_DELTA = 0.01;
 export declare const isPropertyEditable: (element: ExcalidrawElement, property: keyof ExcalidrawElement) => boolean;
 export declare const getStepSizedValue: (value: number, stepSize: number) => number;
@@ -11,5 +13,13 @@ export declare const newOrigin: (x1: number, y1: number, w1: number, h1: number,
     x: number;
     y: number;
 };
-export declare const resizeElement: (nextWidth: number, nextHeight: number, keepAspectRatio: boolean, latestElement: ExcalidrawElement, origElement: ExcalidrawElement, elementsMap: ElementsMap, originalElementsMap: Map<string, ExcalidrawElement>, shouldInformMutation?: boolean) => void;
-export declare const moveElement: (newTopLeftX: number, newTopLeftY: number, latestElement: ExcalidrawElement, originalElement: ExcalidrawElement, elementsMap: ElementsMap, originalElementsMap: ElementsMap, shouldInformMutation?: boolean) => void;
+export declare const resizeElement: (nextWidth: number, nextHeight: number, keepAspectRatio: boolean, origElement: ExcalidrawElement, elementsMap: NonDeletedSceneElementsMap, shouldInformMutation?: boolean) => void;
+export declare const moveElement: (newTopLeftX: number, newTopLeftY: number, originalElement: ExcalidrawElement, elementsMap: NonDeletedSceneElementsMap, originalElementsMap: ElementsMap, shouldInformMutation?: boolean) => void;
+export declare const getAtomicUnits: (targetElements: readonly ExcalidrawElement[], appState: AppState) => AtomicUnit[];
+export declare const updateBindings: (latestElement: ExcalidrawElement, elementsMap: NonDeletedSceneElementsMap, options?: {
+    simultaneouslyUpdated?: readonly ExcalidrawElement[];
+    newSize?: {
+        width: number;
+        height: number;
+    };
+}) => void;

package/types/excalidraw/cursor.d.ts

@@ -1,5 +1,6 @@
 import type { AppState } from "./types";
 export declare const resetCursor: (interactiveCanvas: HTMLCanvasElement | null) => void;
 export declare const setCursor: (interactiveCanvas: HTMLCanvasElement | null, cursor: string) => void;
+export declare const clearEraserCanvasCache: () => void;
 export declare const setEraserCursor: (interactiveCanvas: HTMLCanvasElement | null, theme: AppState["theme"]) => void;
 export declare const setCursorForShape: (interactiveCanvas: HTMLCanvasElement | null, appState: Pick<AppState, "activeTool" | "theme">) => void;

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

@@ -1,5 +1,5 @@
 import type { ExcalidrawBindableElement, ExcalidrawElement, NonDeleted, ExcalidrawLinearElement, NonDeletedExcalidrawElement, ElementsMap, NonDeletedSceneElementsMap } from "./types";
-import type { AppClassProperties, AppState, Point } from "../types";
+import type { AppState, Point } from "../types";
 import type { ElementUpdate } from "./mutateElement";
 export type SuggestedBinding = NonDeleted<ExcalidrawBindableElement> | SuggestedPointBinding;
 export type SuggestedPointBinding = [
@@ -10,18 +10,18 @@ export type SuggestedPointBinding = [
 export declare const shouldEnableBindingForPointerEvent: (event: React.PointerEvent<HTMLElement>) => boolean;
 export declare const isBindingEnabled: (appState: AppState) => boolean;
 export declare const bindOrUnbindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, startBindingElement: ExcalidrawBindableElement | null | "keep", endBindingElement: ExcalidrawBindableElement | null | "keep", elementsMap: NonDeletedSceneElementsMap) => void;
-export declare const bindOrUnbindLinearElements: (selectedElements: NonDeleted<ExcalidrawLinearElement>[], app: AppClassProperties, isBindingEnabled: boolean, draggingPoints: readonly number[] | null) => void;
-export declare const getSuggestedBindingsForArrows: (selectedElements: NonDeleted<ExcalidrawElement>[], app: AppClassProperties) => SuggestedBinding[];
+export declare const bindOrUnbindLinearElements: (selectedElements: NonDeleted<ExcalidrawLinearElement>[], elementsMap: NonDeletedSceneElementsMap, isBindingEnabled: boolean, draggingPoints: readonly number[] | null) => void;
+export declare const getSuggestedBindingsForArrows: (selectedElements: NonDeleted<ExcalidrawElement>[], elementsMap: NonDeletedSceneElementsMap) => SuggestedBinding[];
 export declare const maybeBindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, appState: AppState, pointerCoords: {
     x: number;
     y: number;
-}, app: AppClassProperties) => void;
+}, elementsMap: NonDeletedSceneElementsMap) => void;
 export declare const bindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: NonDeletedSceneElementsMap) => void;
 export declare const isLinearElementSimpleAndAlreadyBound: (linearElement: NonDeleted<ExcalidrawLinearElement>, alreadyBoundToId: ExcalidrawBindableElement["id"] | undefined, bindableElement: ExcalidrawBindableElement) => boolean;
 export declare const getHoveredElementForBinding: (pointerCoords: {
     x: number;
     y: number;
-}, app: AppClassProperties) => NonDeleted<ExcalidrawBindableElement> | null;
+}, elementsMap: NonDeletedSceneElementsMap) => NonDeleted<ExcalidrawBindableElement> | null;
 export declare const updateBoundElements: (changedElement: NonDeletedExcalidrawElement, elementsMap: ElementsMap, options?: {
     simultaneouslyUpdated?: readonly ExcalidrawElement[];
     newSize?: {

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

@@ -2,7 +2,7 @@ import type { ExcalidrawElement } from "./types";
 import type { Mutable } from "../utility-types";
 export type ElementUpdate<TElement extends ExcalidrawElement> = Omit<Partial<TElement>, "id" | "version" | "versionNonce" | "updated">;
 export declare const mutateElement: <TElement extends Mutable<ExcalidrawElement>>(element: TElement, updates: ElementUpdate<TElement>, informMutation?: boolean) => TElement;
-export declare const newElementWith: <TElement extends ExcalidrawElement>(element: TElement, updates: ElementUpdate<TElement>, force?: boolean) => TElement;
+export declare const newElementWith: <TElement extends ExcalidrawElement>(element: TElement, updates: ElementUpdate<TElement>) => TElement;
 /**
  * Mutates element, bumping `version`, `versionNonce`, and `updated`.
  *

package/types/excalidraw/index.d.ts

@@ -21,7 +21,8 @@ getDefaultLineHeight, //zsviczian
 wrapText, //zsviczian
 getFontString, //zsviczian
 getBoundTextMaxWidth, //zsviczian
-mermaidToExcalidraw, } from "../utils/export";
+mermaidToExcalidraw, //zsviczian
+destroyObsidianUtils, } from "../utils/export";
 export { refreshTextDimensions, } from "./element/newElement";
 export { getContainerElement, } from "./element/textElement";
 export { serializeAsJSON, serializeLibraryAsJSON } from "./data/json";

package/types/excalidraw/obsidianUtils.d.ts

@@ -1,5 +1,8 @@
-export declare const getAreaLimit: () => any;
-export declare const getWidthHeightLimit: () => any;
-export declare const isExcaliBrainView: () => any;
-export declare const getExcalidrawContentEl: () => HTMLElement;
-export declare const hideFreedrawPenmodeCursor: () => boolean;
+export declare let hostPlugin: any;
+export declare function destroyObsidianUtils(): void;
+export declare function initializeObsidianUtils(obsidianPlugin: any): void;
+export declare function getAreaLimit(): any;
+export declare function getWidthHeightLimit(): any;
+export declare function isExcaliBrainView(): any;
+export declare function getExcalidrawContentEl(): HTMLElement;
+export declare function hideFreedrawPenmodeCursor(): boolean;

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

@@ -1,6 +1,6 @@
 import type { RoughCanvas } from "roughjs/bin/canvas";
 import type { Drawable } from "roughjs/bin/core";
-import type { ExcalidrawElement, ExcalidrawTextElement, NonDeletedElementsMap, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap } from "../element/types";
+import type { ExcalidrawElement, NonDeletedElementsMap, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap } from "../element/types";
 import type { AppClassProperties, AppState, EmbedsValidationStatus, ElementsPendingErasure, InteractiveCanvasAppState, StaticCanvasAppState, SocketId, UserIdleState, Device } from "../types";
 import type { MakeBrand } from "../utility-types";
 export type RenderableElementsMap = NonDeletedElementsMap & MakeBrand<"RenderableElementsMap">;
@@ -68,9 +68,6 @@ export type SceneScroll = {
     scrollX: number;
     scrollY: number;
 };
-export interface Scene {
-    elements: ExcalidrawTextElement[];
-}
 export type ExportType = "png" | "clipboard" | "clipboard-svg" | "backend" | "svg";
 export type ScrollBars = {
     horizontal: {

package/types/excalidraw/shapes.d.ts

@@ -1,3 +1,5 @@
+import { type GeometricShape } from "../utils/geometry/shape";
+import type { ElementsMap, ExcalidrawElement } from "./element/types";
 export declare const SHAPES: readonly [{
     readonly icon: import("react/jsx-runtime").JSX.Element;
     readonly value: "selection";
@@ -60,3 +62,8 @@ export declare const SHAPES: readonly [{
     readonly fillable: false;
 }];
 export declare const findShapeByKey: (key: string) => "text" | "image" | "selection" | "rectangle" | "diamond" | "ellipse" | "arrow" | "line" | "freedraw" | "eraser" | null;
+/**
+ * get the pure geometric shape of an excalidraw element
+ * which is then used for hit detection
+ */
+export declare const getElementShape: (element: ExcalidrawElement, elementsMap: ElementsMap) => GeometricShape;

package/types/excalidraw/types.d.ts

@@ -387,7 +387,7 @@ export type OnUserFollowedPayload = {
 };
 export interface ExcalidrawProps {
     onChange?: (elements: readonly OrderedExcalidrawElement[], appState: AppState, files: BinaryFiles) => void;
-    initialData?: MaybePromise<ExcalidrawInitialDataState | null>;
+    initialData?: (() => MaybePromise<ExcalidrawInitialDataState | null>) | MaybePromise<ExcalidrawInitialDataState | null>;
     excalidrawAPI?: (api: ExcalidrawImperativeAPI) => void;
     isCollaborating?: boolean;
     onPointerUpdate?: (payload: {
@@ -442,7 +442,7 @@ export interface ExcalidrawProps {
     renderMermaid?: boolean;
     onContextMenu?: (element: readonly NonDeletedExcalidrawElement[], appState: AppState, onClose: (callback?: () => void) => void) => JSX.Element | null;
     aiEnabled?: boolean;
-    obsidianHostPlugin?: any;
+    obsidianHostPlugin: WeakRef<any>;
 }
 export type SceneData = {
     elements?: ImportedDataState["elements"];
@@ -522,7 +522,6 @@ export type AppClassProperties = {
     setOpenDialog: App["setOpenDialog"];
     insertEmbeddableElement: App["insertEmbeddableElement"];
     onMagicframeToolSelect: App["onMagicframeToolSelect"];
-    getElementShape: App["getElementShape"];
     getName: App["getName"];
 };
 export type PointerDownState = Readonly<{

package/types/utils/export.d.ts

@@ -39,3 +39,4 @@ export { measureText, wrapText, getDefaultLineHeight, } from "../excalidraw/elem
 export { getFontString } from "../excalidraw/utils";
 export { getBoundTextMaxWidth } from "../excalidraw/element/textElement";
 export { mermaidToExcalidraw } from "../excalidraw/components/TTDDialog/MermaidToExcalidraw";
+export { destroyObsidianUtils } from "../excalidraw/obsidianUtils";