@zsviczian/excalidraw 0.17.6-25 → 0.17.6-27

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

@@ -1,6 +1,6 @@
-import type { NonDeleted, ExcalidrawLinearElement, ExcalidrawElement, PointBinding, ExcalidrawBindableElement, ExcalidrawTextElementWithContainer, ElementsMap, NonDeletedSceneElementsMap, OrderedExcalidrawElement, SceneElementsMap } from "./types";
+import type { NonDeleted, ExcalidrawLinearElement, ExcalidrawElement, PointBinding, ExcalidrawBindableElement, ExcalidrawTextElementWithContainer, ElementsMap, NonDeletedSceneElementsMap, SceneElementsMap, ExcalidrawElbowArrowElement } from "./types";
 import type { Bounds } from "./bounds";
-import type { AppState, PointerCoords, InteractiveCanvasAppState, AppClassProperties, NullableGridSize } from "../types";
+import type { AppState, PointerCoords, InteractiveCanvasAppState, AppClassProperties, NullableGridSize, Zoom } from "../types";
 import type { Store } from "../store";
 import type Scene from "../scene/Scene";
 import { type GlobalPoint, type LocalPoint } from "../../math";
@@ -48,7 +48,7 @@ export declare class LinearElementEditor {
      * @param id the `elementId` from the instance of this class (so that we can
      *  statically guarantee this method returns an ExcalidrawLinearElement)
      */
-    static getElement(id: InstanceType<typeof LinearElementEditor>["elementId"], elementsMap: ElementsMap): NonDeleted<ExcalidrawLinearElement> | null;
+    static getElement<T extends ExcalidrawLinearElement>(id: InstanceType<typeof LinearElementEditor>["elementId"], elementsMap: ElementsMap): T | null;
     static handleBoxSelection(event: PointerEvent, appState: AppState, setState: React.Component<any, AppState>["setState"], elementsMap: NonDeletedSceneElementsMap): false | undefined;
     /** @returns whether point was dragged */
     static handlePointDragging(event: PointerEvent, app: AppClassProperties, scenePointerX: number, scenePointerY: number, maybeSuggestBinding: (element: NonDeleted<ExcalidrawLinearElement>, pointSceneCoords: {
@@ -62,7 +62,7 @@ export declare class LinearElementEditor {
         x: number;
         y: number;
     }, appState: AppState, elementsMap: ElementsMap) => GlobalPoint | null;
-    static isSegmentTooShort(element: NonDeleted<ExcalidrawLinearElement>, startPoint: GlobalPoint | LocalPoint, endPoint: GlobalPoint | LocalPoint, zoom: AppState["zoom"]): boolean;
+    static isSegmentTooShort<P extends GlobalPoint | LocalPoint>(element: NonDeleted<ExcalidrawLinearElement>, startPoint: P, endPoint: P, index: number, zoom: Zoom): boolean;
     static getSegmentMidPoint(element: NonDeleted<ExcalidrawLinearElement>, startPoint: GlobalPoint, endPoint: GlobalPoint, endPointIndex: number, elementsMap: ElementsMap): GlobalPoint;
     static getSegmentMidPointIndex(linearElementEditor: LinearElementEditor, appState: AppState, midPoint: GlobalPoint, elementsMap: ElementsMap): number;
     static handlePointerDown(event: React.PointerEvent<HTMLElement>, app: AppClassProperties, store: Store, scenePointer: {
@@ -96,21 +96,17 @@ export declare class LinearElementEditor {
     };
     static normalizePoints(element: NonDeleted<ExcalidrawLinearElement>): void;
     static duplicateSelectedPoints(appState: AppState, elementsMap: NonDeletedSceneElementsMap | SceneElementsMap): AppState;
-    static deletePoints(element: NonDeleted<ExcalidrawLinearElement>, pointIndices: readonly number[], elementsMap: NonDeletedSceneElementsMap | SceneElementsMap, zoom: AppState["zoom"]): void;
+    static deletePoints(element: NonDeleted<ExcalidrawLinearElement>, pointIndices: readonly number[]): void;
     static addPoints(element: NonDeleted<ExcalidrawLinearElement>, targetPoints: {
         point: LocalPoint;
-    }[], elementsMap: NonDeletedSceneElementsMap | SceneElementsMap, zoom: AppState["zoom"]): void;
+    }[]): void;
     static movePoints(element: NonDeleted<ExcalidrawLinearElement>, targetPoints: {
         index: number;
         point: LocalPoint;
         isDragging?: boolean;
-    }[], elementsMap: NonDeletedSceneElementsMap | SceneElementsMap, otherUpdates?: {
+    }[], otherUpdates?: {
         startBinding?: PointBinding | null;
         endBinding?: PointBinding | null;
-    }, options?: {
-        changedElements?: Map<string, OrderedExcalidrawElement>;
-        isDragging?: boolean;
-        zoom?: AppState["zoom"];
     }): void;
     static shouldAddMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, appState: AppState, elementsMap: ElementsMap): boolean;
     static addMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, app: AppClassProperties, snapToGrid: boolean, elementsMap: ElementsMap): {
@@ -125,5 +121,7 @@ export declare class LinearElementEditor {
     };
     static getMinMaxXYWithBoundText: (element: ExcalidrawLinearElement, elementsMap: ElementsMap, elementBounds: Bounds, boundTextElement: ExcalidrawTextElementWithContainer) => [number, number, number, number, number, number];
     static getElementAbsoluteCoords: (element: ExcalidrawLinearElement, elementsMap: ElementsMap, includeBoundText?: boolean) => [number, number, number, number, number, number];
+    static moveFixedSegment(linearElement: LinearElementEditor, index: number, x: number, y: number, elementsMap: ElementsMap): LinearElementEditor;
+    static deleteFixedSegment(element: ExcalidrawElbowArrowElement, index: number): void;
 }
 export {};

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

@@ -1,7 +1,9 @@
 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 mutateElement: <TElement extends Mutable<ExcalidrawElement>>(element: TElement, updates: ElementUpdate<TElement>, informMutation?: boolean, options?: {
+    isDragging?: boolean;
+}) => TElement;
 export declare const newElementWith: <TElement extends ExcalidrawElement>(element: TElement, updates: ElementUpdate<TElement>, force?: boolean) => TElement;
 /**
  * Mutates element, bumping `version`, `versionNonce`, and `updated`.

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

@@ -1,4 +1,4 @@
-import type { ExcalidrawElement, ExcalidrawImageElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawGenericElement, NonDeleted, TextAlign, GroupId, VerticalAlign, Arrowhead, ExcalidrawFreeDrawElement, FontFamilyValues, ExcalidrawTextContainer, ExcalidrawFrameElement, ExcalidrawEmbeddableElement, ExcalidrawMagicFrameElement, ExcalidrawIframeElement, ElementsMap, ExcalidrawArrowElement } from "./types";
+import type { ExcalidrawElement, ExcalidrawImageElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawGenericElement, NonDeleted, TextAlign, GroupId, VerticalAlign, Arrowhead, ExcalidrawFreeDrawElement, FontFamilyValues, ExcalidrawTextContainer, ExcalidrawFrameElement, ExcalidrawEmbeddableElement, ExcalidrawMagicFrameElement, ExcalidrawIframeElement, ElementsMap, ExcalidrawArrowElement, FixedSegment, ExcalidrawElbowArrowElement } from "./types";
 import type { AppState } from "../types";
 import type { MarkOptional, Mutable } from "../utility-types";
 export type ElementConstructorOpts = MarkOptional<Omit<ExcalidrawGenericElement, "id" | "type" | "isDeleted" | "updated">, "width" | "height" | "angle" | "groupIds" | "frameId" | "index" | "boundElements" | "seed" | "version" | "versionNonce" | "link" | "strokeStyle" | "fillStyle" | "strokeColor" | "backgroundColor" | "roughness" | "strokeWidth" | "roundness" | "locked" | "opacity" | "customData">;
@@ -46,13 +46,14 @@ export declare const newLinearElement: (opts: {
     type: ExcalidrawLinearElement["type"];
     points?: ExcalidrawLinearElement["points"];
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawLinearElement>;
-export declare const newArrowElement: (opts: {
+export declare const newArrowElement: <T extends boolean>(opts: {
     type: ExcalidrawArrowElement["type"];
-    startArrowhead?: Arrowhead | null;
-    endArrowhead?: Arrowhead | null;
-    points?: ExcalidrawArrowElement["points"];
-    elbowed?: boolean;
-} & ElementConstructorOpts) => NonDeleted<ExcalidrawArrowElement>;
+    startArrowhead?: Arrowhead | null | undefined;
+    endArrowhead?: Arrowhead | null | undefined;
+    points?: readonly import("../../math").LocalPoint[] | undefined;
+    elbowed?: T | undefined;
+    fixedSegments?: FixedSegment[] | null | undefined;
+} & Omit<Omit<ExcalidrawGenericElement, "id" | "isDeleted" | "updated" | "type">, "angle" | "link" | "width" | "height" | "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" | "link" | "width" | "height" | "backgroundColor" | "strokeColor" | "fillStyle" | "strokeWidth" | "strokeStyle" | "roundness" | "roughness" | "opacity" | "seed" | "version" | "versionNonce" | "index" | "groupIds" | "frameId" | "boundElements" | "locked" | "customData">>) => T extends true ? NonDeleted<ExcalidrawElbowArrowElement> : NonDeleted<ExcalidrawArrowElement>;
 export declare const newImageElement: (opts: {
     type: ExcalidrawImageElement["type"];
     status?: ExcalidrawImageElement["status"];

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

@@ -27,13 +27,12 @@ export declare const getNextSingleWidthAndHeightFromPointer: (latestElement: Exc
     nextWidth: number;
     nextHeight: number;
 };
-export declare const resizeMultipleElements: (selectedElements: readonly NonDeletedExcalidrawElement[], elementsMap: ElementsMap, handleDirection: TransformHandleDirection, scene: Scene, { shouldMaintainAspectRatio, shouldResizeFromCenter, flipByX, flipByY, nextHeight, nextWidth, originalElementsMap, originalBoundingBox, }?: {
+export declare const resizeMultipleElements: (selectedElements: readonly NonDeletedExcalidrawElement[], elementsMap: ElementsMap, handleDirection: TransformHandleDirection, scene: Scene, originalElementsMap: ElementsMap, { shouldMaintainAspectRatio, shouldResizeFromCenter, flipByX, flipByY, nextHeight, nextWidth, originalBoundingBox, }?: {
     nextWidth?: number | undefined;
     nextHeight?: number | undefined;
     shouldMaintainAspectRatio?: boolean | undefined;
     shouldResizeFromCenter?: boolean | undefined;
     flipByX?: boolean | undefined;
     flipByY?: boolean | undefined;
-    originalElementsMap?: ElementsMap | undefined;
     originalBoundingBox?: BoundingBox | undefined;
 }) => void;

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

@@ -208,7 +208,7 @@ export type PointBinding = {
 export type FixedPointBinding = Merge<PointBinding, {
     fixedPoint: FixedPoint;
 }>;
-export type Arrowhead = "arrow" | "bar" | "dot" | "circle" | "circle_outline" | "triangle" | "triangle_outline" | "diamond" | "diamond_outline";
+export type Arrowhead = "arrow" | "bar" | "dot" | "circle" | "circle_outline" | "triangle" | "triangle_outline" | "diamond" | "diamond_outline" | "crowfoot_one" | "crowfoot_many" | "crowfoot_one_or_many";
 export type ExcalidrawLinearElement = _ExcalidrawElementBase & Readonly<{
     type: "line" | "arrow";
     points: readonly LocalPoint[];
@@ -218,6 +218,11 @@ export type ExcalidrawLinearElement = _ExcalidrawElementBase & Readonly<{
     startArrowhead: Arrowhead | null;
     endArrowhead: Arrowhead | null;
 }>;
+export type FixedSegment = {
+    start: LocalPoint;
+    end: LocalPoint;
+    index: number;
+};
 export type ExcalidrawArrowElement = ExcalidrawLinearElement & Readonly<{
     type: "arrow";
     elbowed: boolean;
@@ -226,6 +231,23 @@ export type ExcalidrawElbowArrowElement = Merge<ExcalidrawArrowElement, {
     elbowed: true;
     startBinding: FixedPointBinding | null;
     endBinding: FixedPointBinding | null;
+    fixedSegments: 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
+     * the data from the points array. It allows creating the expected arrow
+     * path when the arrow with fixed segments is bound on a horizontal side and
+     * moved to a vertical and vica versa.
+     */
+    startIsSpecial: boolean | null;
+    /**
+     * Marks that the 3rd point backwards from the end should be used as the 2nd
+     * point of the arrow in order to temporarily hide the last segment of the
+     * arrow without losing the data from the points array. It allows creating
+     * the expected arrow path when the arrow with fixed segments is bound on a
+     * horizontal side and moved to a vertical and vica versa.
+     */
+    endIsSpecial: boolean | null;
 }>;
 export type ExcalidrawFreeDrawElement = _ExcalidrawElementBase & Readonly<{
     type: "freedraw";

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

@@ -1,6 +1,6 @@
 import type { LibraryItem } from "../types";
 export type SvgCache = Map<LibraryItem["id"], SVGSVGElement>;
-export declare const libraryItemSvgsCache: import("jotai").PrimitiveAtom<SvgCache> & {
+export declare const libraryItemSvgsCache: import("jotai/vanilla/atom").PrimitiveAtom<SvgCache> & {
     init: SvgCache;
 };
 export declare const useLibraryItemSvg: (id: LibraryItem["id"] | null, elements: LibraryItem["elements"] | undefined, svgCache: SvgCache) => SVGSVGElement | undefined;

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

@@ -27,4 +27,11 @@ export declare const exportToSvg: (elements: readonly NonDeletedExcalidrawElemen
     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/types/excalidraw/utils.d.ts

@@ -246,4 +246,5 @@ export declare class PromisePool<T> {
     constructor(source: IterableIterator<Promise<void | readonly [number, T]>>, concurrency: number);
     all(): PromiseLike<T[]>;
 }
+export declare const sanitizeHTMLAttribute: (html: string) => string;
 export {};

package/types/excalidraw/visualdebug.d.ts

@@ -1,4 +1,4 @@
-import { type GlobalPoint } from "../math";
+import { type GlobalPoint, type LocalPoint } from "../math";
 import type { LineSegment } from "../utils";
 import type { BoundingBox, Bounds } from "./element/bounds";
 declare global {
@@ -7,6 +7,8 @@ declare global {
             data: DebugElement[][];
             currentFrame?: number;
         };
+        debugDrawPoint: typeof debugDrawPoint;
+        debugDrawLine: typeof debugDrawLine;
     }
 }
 export type DebugElement = {
@@ -31,5 +33,10 @@ export declare const debugDrawBounds: (box: Bounds | Bounds[], opts?: {
     color?: string;
     permanent?: boolean;
 }) => void;
+export declare const debugDrawPoints: ({ x, y, points, }: {
+    x: number;
+    y: number;
+    points: LocalPoint[];
+}, options?: any) => void;
 export declare const debugCloseFrame: () => void;
 export declare const debugClear: () => void;

package/types/math/line.d.ts

@@ -23,4 +23,23 @@ export declare function lineFromPointPair<P extends GlobalPoint | LocalPoint>([a
  * @returns
  */
 export declare function lineFromPointArray<P extends GlobalPoint | LocalPoint>(pointArray: P[]): Line<P> | undefined;
+/**
+ * Return the coordinates resulting from rotating the given line about an
+ * origin by an angle in degrees note that when the origin is not given,
+ * the midpoint of the given line is used as the origin
+ *
+ * @param l
+ * @param angle
+ * @param origin
+ * @returns
+ */
 export declare const lineRotate: <Point extends GlobalPoint | LocalPoint>(l: Line<Point>, angle: Radians, origin?: Point | undefined) => Line<Point>;
+/**
+ * Determines the intersection point (unless the lines are parallel) of two
+ * lines
+ *
+ * @param a
+ * @param b
+ * @returns
+ */
+export declare const linesIntersectAt: <Point extends GlobalPoint | LocalPoint>(a: Line<Point>, b: Line<Point>) => Point | null;

package/types/math/point.d.ts

@@ -28,6 +28,16 @@ export declare function pointFromPair<Point extends GlobalPoint | LocalPoint>(pa
  * @returns The point the vector points at with origin 0,0
  */
 export declare function pointFromVector<P extends GlobalPoint | LocalPoint>(v: Vector): P;
+/**
+ * Convert the coordiante object to a point.
+ *
+ * @param coords The coordinate object with x and y properties
+ * @returns
+ */
+export declare function pointFromCoords<Point extends GlobalPoint | LocalPoint>({ x, y, }: {
+    x: number;
+    y: number;
+}): Point;
 /**
  * Checks if the provided value has the shape of a Point.
  *