@dwelle/excalidraw 0.5.0-e05a141 → 0.5.0-e2a82c4d8

package/dist/prod/locales/en-QQWGF6XN.js

@@ -0,0 +1 @@
+import{A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z}from"../chunk-QHCRJDAB.js";import"../chunk-SRAX5OIU.js";export{N as ai,f as alerts,e as buttons,l as canvasError,H as chat,t as clearCanvasDialog,D as colorPicker,B as colors,L as commandPalette,w as confirmDialog,O as default,i as element,b as elementLink,y as encrypted,p as errorDialog,m as errorSplash,g as errors,r as exportDialog,J as fontList,j as headings,s as helpDialog,k as hints,x as imageExportDialog,M as keys,a as labels,c as library,F as mermaid,E as overwriteConfirm,q as progressDialog,u as publishDialog,v as publishSuccessDialog,I as quickSearch,o as roomDialog,d as search,n as shareDialog,z as stats,A as toast,h as toolBar,G as ttd,K as userList,C as welcomeScreen};

package/dist/prod/subset-shared.chunk.js

@@ -1 +1 @@
-import{a,b,c,d}from"./chunk-Z5NKEFVG.js";import"./chunk-KDBB3MAO.js";import"./chunk-SRAX5OIU.js";export{a as Commands,b as subsetToBase64,c as subsetToBinary,d as toBase64};
+import{a,b,c,d}from"./chunk-Z5NKEFVG.js";import"./chunk-XXRJJHWR.js";import"./chunk-SRAX5OIU.js";export{a as Commands,b as subsetToBase64,c as subsetToBinary,d as toBase64};

package/dist/prod/subset-worker.chunk.js

@@ -1 +1 @@
-import{a as r,c as t}from"./chunk-Z5NKEFVG.js";import"./chunk-KDBB3MAO.js";import"./chunk-SRAX5OIU.js";var s=import.meta.url?new URL(import.meta.url):void 0;typeof window>"u"&&typeof self<"u"&&(self.onmessage=async e=>{switch(e.data.command){case r.Subset:let a=await t(e.data.arrayBuffer,e.data.codePoints);self.postMessage(a,{transfer:[a]});break}});export{s as WorkerUrl};
+import{a as r,c as t}from"./chunk-Z5NKEFVG.js";import"./chunk-XXRJJHWR.js";import"./chunk-SRAX5OIU.js";var s=import.meta.url?new URL(import.meta.url):void 0;typeof window>"u"&&typeof self<"u"&&(self.onmessage=async e=>{switch(e.data.command){case r.Subset:let a=await t(e.data.arrayBuffer,e.data.codePoints);self.postMessage(a,{transfer:[a]});break}});export{s as WorkerUrl};

package/dist/types/common/src/utils.d.ts

@@ -6,6 +6,10 @@ import type { EVENT } from "./constants";
 export declare const setDateTimeForTests: (dateTime: string) => void;
 export declare const getDateTime: () => string;
 export declare const capitalizeString: (str: string) => string;
+export declare const formatTimeToHourMinute: (value: Date | number, opts?: {
+    locale?: string | string[];
+    hour12?: boolean;
+}) => string;
 export declare const isToolIcon: (target: Element | EventTarget | null) => target is HTMLElement;
 export declare const isInputLike: (target: Element | EventTarget | null) => target is HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | HTMLBRElement | HTMLDivElement;
 export declare const isInteractive: (target: Element | EventTarget | null) => boolean;
@@ -25,9 +29,7 @@ export declare const debounce: <T extends any[]>(fn: (...args: T) => void, timeo
     flush(): void;
     cancel(): void;
 };
-export declare const throttleRAF: <T extends any[]>(fn: (...args: T) => void, opts?: {
-    trailing?: boolean;
-}) => {
+export declare const throttleRAF: <T extends any[]>(fn: (...args: T) => void) => {
     (...args: T): void;
     flush(): void;
     cancel(): void;

package/dist/types/element/src/Scene.d.ts

@@ -75,6 +75,8 @@ export declare class Scene {
     mutateElement<TElement extends Mutable<ExcalidrawElement>>(element: TElement, updates: ElementUpdate<TElement>, options?: {
         informMutation: boolean;
         isDragging: boolean;
+        isBindingEnabled?: boolean;
+        isMidpointSnappingEnabled?: boolean;
     }): TElement;
 }
 export {};

package/dist/types/element/src/arrowheads.d.ts

@@ -0,0 +1,3 @@
+import type { Arrowhead, AnyArrowhead } from "./types";
+export declare const normalizeArrowhead: (arrowhead: AnyArrowhead | null | undefined) => Arrowhead | null;
+export declare const getArrowheadForPicker: (arrowhead: AnyArrowhead | null | undefined) => Arrowhead | null;

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

@@ -30,7 +30,6 @@ export declare const BASE_ARROW_MIN_LENGTH = 10;
 export declare const FOCUS_POINT_SIZE: number;
 export declare const getBindingGap: (bindTarget: ExcalidrawBindableElement, opts: Pick<ExcalidrawArrowElement, "elbowed">) => number;
 export declare const maxBindingDistance_simple: (zoom?: AppState["zoom"]) => number;
-export declare const shouldEnableBindingForPointerEvent: (event: React.PointerEvent<HTMLElement>) => boolean;
 export declare const isBindingEnabled: (appState: {
     isBindingEnabled: AppState["isBindingEnabled"];
 }) => boolean;
@@ -55,7 +54,7 @@ export declare const getBindingStrategyForDraggingBindingElementEndpoints: (arro
     end: BindingStrategy;
 };
 export declare const bindOrUnbindBindingElements: (selectedArrows: NonDeleted<ExcalidrawArrowElement>[], scene: Scene, appState: AppState) => void;
-export declare const bindBindingElement: (arrow: NonDeleted<ExcalidrawArrowElement>, hoveredElement: ExcalidrawBindableElement, mode: BindMode, startOrEnd: "start" | "end", scene: Scene, focusPoint?: GlobalPoint) => void;
+export declare const bindBindingElement: (arrow: NonDeleted<ExcalidrawArrowElement>, hoveredElement: ExcalidrawBindableElement, mode: BindMode, startOrEnd: "start" | "end", scene: Scene, focusPoint?: GlobalPoint, shouldSnapToOutline?: boolean) => void;
 export declare const unbindBindingElement: (arrow: NonDeleted<ExcalidrawArrowElement>, startOrEnd: "start" | "end", scene: Scene) => ExcalidrawBindableElement["id"] | null;
 export declare const updateBoundElements: (changedElement: NonDeletedExcalidrawElement, scene: Scene, options?: {
     simultaneouslyUpdated?: readonly ExcalidrawElement[];
@@ -69,17 +68,19 @@ export declare const updateBindings: (latestElement: ExcalidrawElement, scene: S
     };
 }) => void;
 export declare const getHeadingForElbowArrowSnap: (p: Readonly<GlobalPoint>, otherPoint: Readonly<GlobalPoint>, bindableElement: ExcalidrawBindableElement | undefined | null, aabb: Bounds | undefined | null, origPoint: GlobalPoint, elementsMap: ElementsMap, zoom?: AppState["zoom"]) => Heading;
-export declare const bindPointToSnapToElementOutline: (arrowElement: ExcalidrawArrowElement, bindableElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap, customIntersector?: LineSegment<GlobalPoint>) => GlobalPoint;
+export declare const bindPointToSnapToElementOutline: (arrowElement: ExcalidrawArrowElement, bindableElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap, customIntersector?: LineSegment<GlobalPoint>, isMidpointSnappingEnabled?: boolean) => GlobalPoint;
 export declare const avoidRectangularCorner: (arrowElement: ExcalidrawArrowElement, bindTarget: ExcalidrawBindableElement, elementsMap: ElementsMap, p: GlobalPoint) => GlobalPoint;
 export declare const snapToMid: (bindTarget: ExcalidrawBindableElement, elementsMap: ElementsMap, p: GlobalPoint, tolerance?: number, arrowElement?: ExcalidrawArrowElement) => GlobalPoint | undefined;
 export declare const updateBoundPoint: (arrow: NonDeleted<ExcalidrawArrowElement>, startOrEnd: "startBinding" | "endBinding", binding: FixedPointBinding | null | undefined, bindableElement: ExcalidrawBindableElement, elementsMap: ElementsMap, dragging?: boolean) => LocalPoint | null;
-export declare const calculateFixedPointForElbowArrowBinding: (linearElement: NonDeleted<ExcalidrawElbowArrowElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap) => {
+export declare const calculateFixedPointForElbowArrowBinding: (linearElement: NonDeleted<ExcalidrawElbowArrowElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap, shouldSnapToOutline?: boolean, isMidpointSnappingEnabled?: boolean) => {
     fixedPoint: FixedPoint;
 };
 export declare const calculateFixedPointForNonElbowArrowBinding: (linearElement: NonDeleted<ExcalidrawArrowElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap, focusPoint?: GlobalPoint) => {
     fixedPoint: FixedPoint;
 };
 export declare const fixDuplicatedBindingsAfterDuplication: (duplicatedElements: ExcalidrawElement[], origIdToDuplicateId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>, duplicateElementsMap: NonDeletedSceneElementsMap) => void;
+export declare const normalizeElbowArrow: (arrow: ExcalidrawElbowArrowElement, elementsMap: NonDeletedSceneElementsMap) => ElementUpdate<ExcalidrawElbowArrowElement>;
+export declare const normalizeElbowArrows: <T extends ExcalidrawElement>(elements: readonly T[], elementsMap?: NonDeletedSceneElementsMap) => T[];
 export declare const fixBindingsAfterDeletion: (sceneElements: readonly ExcalidrawElement[], deletedElements: readonly ExcalidrawElement[]) => void;
 export declare const bindingProperties: Set<BindableProp | BindingProp>;
 export type BindableProp = "boundElements";

package/dist/types/element/src/bounds.d.ts

@@ -2,7 +2,7 @@ import { type Bounds } from "@excalidraw/common";
 import type { Degrees, GlobalPoint, LineSegment, LocalPoint } from "@excalidraw/math";
 import type { AppState } from "@excalidraw/excalidraw/types";
 import type { Drawable, Op } from "roughjs/bin/core";
-import type { Arrowhead, ElementsMap, ElementsMapOrArray, ExcalidrawElement, ExcalidrawFreeDrawElement, ExcalidrawLinearElement, NonDeleted } from "./types";
+import type { Arrowhead, ElementsMap, ElementsMapOrArray, ExcalidrawElement, ExcalidrawLinearElement, NonDeleted } from "./types";
 export type RectangleBox = {
     x: number;
     y: number;
@@ -38,12 +38,12 @@ export declare const getRectangleBoxAbsoluteCoords: (boxSceneCoords: RectangleBo
 export declare const getDiamondPoints: (element: ExcalidrawElement) => number[];
 export declare const getCubicBezierCurveBound: (p0: GlobalPoint, p1: GlobalPoint, p2: GlobalPoint, p3: GlobalPoint) => Bounds;
 export declare const getMinMaxXYFromCurvePathOps: (ops: Op[], transformXY?: (p: GlobalPoint) => GlobalPoint) => Bounds;
-export declare const getBoundsFromPoints: (points: ExcalidrawFreeDrawElement["points"]) => Bounds;
+export declare const getBoundsFromPoints: <P extends GlobalPoint | LocalPoint>(points: readonly P[], padding?: number) => Bounds;
 /** @returns number in pixels */
 export declare const getArrowheadSize: (arrowhead: Arrowhead) => number;
 /** @returns number in degrees */
 export declare const getArrowheadAngle: (arrowhead: Arrowhead) => Degrees;
-export declare const getArrowheadPoints: (element: ExcalidrawLinearElement, shape: Drawable[], position: "start" | "end", arrowhead: Arrowhead) => number[] | null;
+export declare const getArrowheadPoints: (element: ExcalidrawLinearElement, shape: Drawable[], position: "start" | "end", arrowhead: Arrowhead, offsetMultiplier?: number) => number[] | null;
 export declare const getElementBounds: (element: ExcalidrawElement, elementsMap: ElementsMap, nonRotated?: boolean) => Bounds;
 export declare const getCommonBounds: (elements: ElementsMapOrArray, elementsMap?: ElementsMap) => Bounds;
 export declare const getDraggedElementsBounds: (elements: ExcalidrawElement[], dragOffset: {
@@ -77,5 +77,7 @@ export declare const getCenterForBounds: (bounds: Bounds) => GlobalPoint;
  */
 export declare const aabbForElement: (element: Readonly<ExcalidrawElement>, elementsMap: ElementsMap, offset?: [number, number, number, number]) => Bounds;
 export declare const pointInsideBounds: <P extends GlobalPoint | LocalPoint>(p: P, bounds: Bounds) => boolean;
+export declare const pointInsideBoundsInclusive: <P extends GlobalPoint | LocalPoint>(p: P, bounds: Bounds) => boolean;
 export declare const doBoundsIntersect: (bounds1: Bounds | null, bounds2: Bounds | null) => boolean;
+export declare const boundsContainBounds: (outerBounds: Bounds, innerBounds: Bounds) => boolean;
 export declare const elementCenterPoint: (element: ExcalidrawElement, elementsMap: ElementsMap, xOffset?: number, yOffset?: number) => GlobalPoint;

package/dist/types/element/src/elbowArrow.d.ts

@@ -13,5 +13,7 @@ export declare const updateElbowArrowPoints: (arrow: Readonly<ExcalidrawElbowArr
     endBinding?: FixedPointBinding | null;
 }, options?: {
     isDragging?: boolean;
+    isBindingEnabled?: boolean;
+    isMidpointSnappingEnabled?: boolean;
 }) => ElementUpdate<ExcalidrawElbowArrowElement>;
 export declare const validateElbowPoints: <P extends GlobalPoint | LocalPoint>(points: readonly P[], tolerance?: number) => boolean;

package/dist/types/element/src/frame.d.ts

@@ -70,5 +70,5 @@ export declare const isElementInFrame: (element: ExcalidrawElement, allElementsM
 export declare const shouldApplyFrameClip: (element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement, appState: StaticCanvasAppState, elementsMap: ElementsMap, checkedGroups?: Map<string, boolean>) => boolean;
 export declare const getDefaultFrameName: (element: ExcalidrawFrameLikeElement) => "Frame" | "AI Frame";
 export declare const getFrameLikeTitle: (element: ExcalidrawFrameLikeElement) => string;
-export declare const getElementsOverlappingFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement) => NonDeletedExcalidrawElement[];
+export declare const getElementsOverlappingFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => ExcalidrawElement[];
 export declare const frameAndChildrenSelectedTogether: (selectedElements: readonly ExcalidrawElement[]) => boolean;

package/dist/types/element/src/index.d.ts

@@ -56,3 +56,4 @@ export * from "./typeChecks";
 export * from "./utils";
 export * from "./zindex";
 export * from "./arrows/helpers";
+export * from "./arrowheads";

package/dist/types/element/src/linearElementEditor.d.ts

@@ -55,8 +55,8 @@ export declare class LinearElementEditor {
         x: number;
         y: number;
     }, appState: AppState, elementsMap: ElementsMap) => GlobalPoint | null;
-    static isSegmentTooShort<P extends GlobalPoint | LocalPoint>(element: NonDeleted<ExcalidrawLinearElement>, startPoint: P, endPoint: P, index: number, zoom: Zoom): boolean;
-    static getSegmentMidPoint(element: NonDeleted<ExcalidrawLinearElement>, index: number): GlobalPoint;
+    static isSegmentTooShort<P extends GlobalPoint | LocalPoint>(element: NonDeleted<ExcalidrawLinearElement>, startPoint: P, endPoint: P, index: number, zoom: Zoom, elementsMap: ElementsMap): boolean;
+    static getSegmentMidPoint(element: NonDeleted<ExcalidrawLinearElement>, index: 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: {
         x: number;
@@ -96,6 +96,9 @@ export declare class LinearElementEditor {
         startBinding?: FixedPointBinding | null;
         endBinding?: FixedPointBinding | null;
         moveMidPointsWithElement?: boolean | null;
+    }, options?: {
+        isBindingEnabled?: boolean;
+        isMidpointSnappingEnabled?: boolean;
     }): void;
     static shouldAddMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, appState: AppState, elementsMap: ElementsMap): boolean;
     static addMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, app: AppClassProperties, snapToGrid: boolean, scene: Scene): {

package/dist/types/element/src/mutateElement.d.ts

@@ -11,6 +11,8 @@ export type ElementUpdate<TElement extends ExcalidrawElement> = Omit<Partial<TEl
  */
 export declare const mutateElement: <TElement extends Mutable<ExcalidrawElement>>(element: TElement, elementsMap: ElementsMap, updates: ElementUpdate<TElement>, options?: {
     isDragging?: boolean;
+    isBindingEnabled?: boolean;
+    isMidpointSnappingEnabled?: boolean;
 }) => TElement;
 export declare const newElementWith: <TElement extends ExcalidrawElement>(element: TElement, updates: ElementUpdate<TElement>, 
 /** pass `true` to always regenerate */

package/dist/types/element/src/selection.d.ts

@@ -1,6 +1,6 @@
-import type { AppState, InteractiveCanvasAppState } from "@excalidraw/excalidraw/types";
+import type { AppState, BoxSelectionMode, InteractiveCanvasAppState } from "@excalidraw/excalidraw/types";
 import { LinearElementEditor } from "./linearElementEditor";
-import type { ElementsMap, ElementsMapOrArray, ExcalidrawElement, NonDeletedExcalidrawElement } from "./types";
+import type { ElementsMap, ElementsMapOrArray, ExcalidrawElement, NonDeleted, NonDeletedExcalidrawElement } from "./types";
 /**
  * Frames and their containing elements are not to be selected at the same time.
  * Given an array of selected elements, if there are frames and their containing elements
@@ -8,7 +8,7 @@ import type { ElementsMap, ElementsMapOrArray, ExcalidrawElement, NonDeletedExca
  * @param selectedElements
  */
 export declare const excludeElementsInFramesFromSelection: <T extends ExcalidrawElement>(selectedElements: readonly T[]) => T[];
-export declare const getElementsWithinSelection: (elements: readonly NonDeletedExcalidrawElement[], selection: NonDeletedExcalidrawElement, elementsMap: ElementsMap, excludeElementsInFrames?: boolean) => NonDeletedExcalidrawElement[];
+export declare const getElementsWithinSelection: (elements: readonly NonDeletedExcalidrawElement[], selection: NonDeletedExcalidrawElement, elementsMap: ElementsMap, excludeElementsInFrames?: boolean, boxSelectionMode?: BoxSelectionMode) => NonDeletedExcalidrawElement[];
 export declare const getVisibleAndNonSelectedElements: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: readonly NonDeletedExcalidrawElement[], appState: AppState, elementsMap: ElementsMap) => NonDeletedExcalidrawElement[];
 export declare const isSomeElementSelected: {
     (elements: readonly NonDeletedExcalidrawElement[], appState: Pick<AppState, "selectedElementIds">): boolean;
@@ -32,3 +32,7 @@ export declare const getSelectionStateForElements: (targetElements: readonly Exc
     editingGroupId: AppState["editingGroupId"];
     selectedLinearElement: LinearElementEditor | null;
 };
+/**
+ * Returns editing or single-selected text element, if any.
+ */
+export declare const getActiveTextElement: (selectedElements: readonly NonDeleted<ExcalidrawElement>[], appState: Pick<AppState, "editingTextElement">) => import("./types").ExcalidrawTextElement | null;

package/dist/types/element/src/shape.d.ts

@@ -27,7 +27,7 @@ export declare class ShapeCache {
     } | null) => ((T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] | undefined : ElementShape | undefined) & {}) | (T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] : Drawable | null);
 }
 export declare const generateRoughOptions: (element: ExcalidrawElement, continuousPath?: boolean, isDarkMode?: boolean) => Options;
-export declare const generateLinearCollisionShape: (element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement) => {
+export declare const generateLinearCollisionShape: (element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement, elementsMap: ElementsMap) => {
     op: string;
     data: number[];
 }[];

package/dist/types/element/src/textElement.d.ts

@@ -31,7 +31,7 @@ export declare const suppportsHorizontalAlign: (selectedElements: NonDeletedExca
 declare const VALID_CONTAINER_TYPES: Set<string>;
 export declare const isValidTextContainer: (element: {
     type: ExcalidrawElementType;
-}) => boolean;
+}) => element is ExcalidrawTextContainer;
 export declare const computeContainerDimensionForBoundText: (dimension: number, containerType: ExtractSetType<typeof VALID_CONTAINER_TYPES>) => number;
 export declare const getBoundTextMaxWidth: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElement | null) => number;
 export declare const getBoundTextMaxHeight: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElementWithContainer) => number;

package/dist/types/element/src/textWrapping.d.ts

@@ -5,9 +5,35 @@ import type { FontString } from "./types";
 export declare const containsCJK: (text: string) => boolean;
 /**
  * Breaks the line into the tokens based on the found line break opporutnities.
+ *
+ * Note: tokenization normalizes to NFC first so decomposed graphemes are treated as
+ * their composed variants for wrapping. Any code that needs exact source offsets should
+ * keep in mind that this assumes the input text is already NFC-normalized.
  */
 export declare const parseTokens: (line: string) => string[];
 /**
  * Wraps the original text into the lines based on the given width.
+ *
+ * This is a convenience adapter over `getWrappedTextLines()` for call sites
+ * that only need the rendered wrapped string and not the source offsets.
  */
 export declare const wrapText: (text: string, font: FontString, maxWidth: number) => string;
+/**
+ * A single rendered visual line produced from the original text.
+ *
+ * `start` and `end` are end-exclusive code-unit offsets into the original text, and do
+ * not include synthetic soft line breaks inserted by this module. If trailing whitespace
+ * was trimmed away at a wrap boundary, `end` points to the last rendered character.
+ */
+export type WrappedTextLine = {
+    text: string;
+    start: number;
+    end: number;
+};
+/**
+ * Returns the rendered visual lines together with their source offsets.
+ *
+ * This is the source-of-truth wrapping pipeline for callers that need more than the
+ * final wrapped string, for example caret placement or future editor/rich-text mapping.
+ */
+export declare const getWrappedTextLines: (text: string, font: FontString, maxWidth: number) => WrappedTextLine[];

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

@@ -208,7 +208,10 @@ export type PointsPositionUpdates = Map<Index, {
     point: LocalPoint;
     isDragging?: boolean;
 }>;
-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 CardinalityArrowhead = "cardinality_one" | "cardinality_many" | "cardinality_one_or_many" | "cardinality_exactly_one" | "cardinality_zero_or_one" | "cardinality_zero_or_many";
+export type ArrowheadLegacy = "dot" | "crowfoot_one" | "crowfoot_many" | "crowfoot_one_or_many";
+export type Arrowhead = "arrow" | "bar" | "circle" | "circle_outline" | "triangle" | "triangle_outline" | "diamond" | "diamond_outline" | CardinalityArrowhead;
+export type AnyArrowhead = Arrowhead | ArrowheadLegacy;
 export type ExcalidrawLinearElement = _ExcalidrawElementBase & Readonly<{
     type: "line" | "arrow";
     points: readonly LocalPoint[];

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

@@ -8,7 +8,7 @@ import type { ElementsMap, ExcalidrawArrowElement, ExcalidrawBindableElement, Ex
  * @param element The linear element to deconstruct
  * @returns The rotated in components.
  */
-export declare function deconstructLinearOrFreeDrawElement(element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement): [LineSegment<GlobalPoint>[], Curve<GlobalPoint>[]];
+export declare function deconstructLinearOrFreeDrawElement(element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement, elementsMap: ElementsMap): [LineSegment<GlobalPoint>[], Curve<GlobalPoint>[]];
 /**
  * Get the building components of a rectanguloid element in the form of
  * line segments and curves **unrotated**.
@@ -33,4 +33,4 @@ export declare const isPathALoop: (points: ExcalidrawLinearElement["points"],
 zoomValue?: Zoom["value"]) => boolean;
 export declare const getCornerRadius: (x: number, element: ExcalidrawElement) => number;
 export declare const getSnapOutlineMidPoint: (point: GlobalPoint, element: ExcalidrawBindableElement, elementsMap: ElementsMap, zoom: AppState["zoom"]) => GlobalPoint | undefined;
-export declare const projectFixedPointOntoDiagonal: (arrow: ExcalidrawArrowElement, point: GlobalPoint, element: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap, zoom: AppState["zoom"]) => GlobalPoint | null;
+export declare const projectFixedPointOntoDiagonal: (arrow: ExcalidrawArrowElement, point: GlobalPoint, element: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap, zoom: AppState["zoom"], isMidpointSnappingEnabled?: boolean) => GlobalPoint | null;

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

@@ -0,0 +1,7 @@
+import type { ChatConversation } from "./types";
+type TTAChatEmptyStateProps = {
+    latestHistoryChat: ChatConversation | null;
+    onSelectHistoryChat: (chat: ChatConversation) => void;
+};
+export declare const TTAChatEmptyState: ({ latestHistoryChat, onSelectHistoryChat, }: TTAChatEmptyStateProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,15 @@
+import React from "react";
+import type { ChatMessage as ChatMessageType, TTAChatScrollOptions, TTADialogRenderWarning } from "./types";
+export interface TTAChatMessageProps {
+    message: ChatMessageType;
+    onInsert: () => void;
+    onRetry: () => void;
+    showRetry?: boolean;
+    onDelete: () => void;
+    showDelete?: boolean;
+    onPreview: (url: string) => void;
+    scrollChatToBottom?: (options?: TTAChatScrollOptions) => void;
+    renderWarning?: TTADialogRenderWarning;
+    rateLimitRemaining?: number | null;
+}
+export declare const TTAChatMessage: React.FC<TTAChatMessageProps>;

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

@@ -0,0 +1,24 @@
+import React from "react";
+import "./TTAComposer.scss";
+export type TTAComposerImage = {
+    hash: string;
+    image: string;
+};
+interface TTAComposerProps {
+    onSend: (message: string, images?: string[]) => void;
+    onStop?: () => void;
+    isSending?: boolean;
+    value?: string;
+    onChange?: (value: string) => void;
+    images?: TTAComposerImage[];
+    onImagesChange?: (images: TTAComposerImage[]) => void;
+    maxImages?: number;
+    onMaxImages?: (maxImages: number) => React.ReactNode;
+    placeholder?: string;
+    allowImageUpload?: boolean;
+    rightActions?: React.ReactNode;
+    onPreviewImage?: (url: string) => void;
+    disabled?: boolean;
+}
+declare const TTAComposer: React.FC<TTAComposerProps>;
+export default TTAComposer;

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

@@ -0,0 +1,19 @@
+import React from "react";
+import "./TTADialog.scss";
+import type { ChatMessage, TTADialogRenderWarning, TTAPersistenceAdapter, TTARateLimits } from "./types";
+import type { TTATransportAdapter } from "./client";
+export declare const ttaChatMessagesAtom: import("jotai/vanilla/atom").PrimitiveAtom<ChatMessage[]> & {
+    init: ChatMessage[];
+};
+export declare const ttaRateLimitsAtom: import("jotai/vanilla/atom").PrimitiveAtom<TTARateLimits | null> & {
+    init: TTARateLimits | null;
+};
+export interface TTADialogProps {
+    maxImages?: number;
+    onMaxImages?: (maxImages: number) => React.ReactNode;
+    renderWarning?: TTADialogRenderWarning;
+    persistenceAdapter?: TTAPersistenceAdapter;
+    transportAdapter: TTATransportAdapter;
+}
+export declare const TTADialog: React.MemoExoticComponent<(props: TTADialogProps) => import("react/jsx-runtime").JSX.Element | null>;
+export default TTADialog;

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

@@ -0,0 +1,46 @@
+import type { ReactNode, RefObject } from "react";
+import type { ChatMessage, ChatConversation, TTAChatScrollOptions, TTADialogRenderWarning, TTARateLimits } from "./types";
+export type TTAPreviewModalState = {
+    image: string;
+    titleKey: "ai.chat.generatedResult" | "ai.chat.attachedImage";
+};
+export type TTADialogPanelView = {
+    hasConversation: boolean;
+    isSendingChat: boolean;
+    isHistoryVisible: boolean;
+    isPinned: boolean;
+    shouldShowSupportBanner: boolean;
+    composerInputValue: string;
+    composerImages: readonly unknown[];
+    previewModal: TTAPreviewModalState | null;
+    chatMessages: ChatMessage[];
+    chatHistory: ChatConversation[];
+    latestHistoryChat: ChatConversation | null;
+    latestRetryableAssistantMessageId: string | null;
+    rateLimits: TTARateLimits | null;
+};
+export type TTADialogPanelActions = {
+    onStartNewChat: () => void;
+    onToggleHistory: () => void;
+    onTogglePinned: () => void;
+    onClose: () => void;
+    onClosePreviewModal: () => void;
+    onOpenPreviewModal: (image: string, titleKey?: TTAPreviewModalState["titleKey"]) => void;
+    onInsertResult: (message: ChatMessage) => void;
+    onRetry: (messageId: string) => void;
+    onRequestDelete: (messageId: string) => void;
+    scrollChatToBottom: (options?: TTAChatScrollOptions) => void;
+    onDismissSupportBanner: () => void;
+    onSelectHistoryChat: (chat: ChatConversation) => void;
+    onDeleteHistoryChat: (chatId: string) => void;
+    onRenameHistoryChat: (chatId: string, newTitle: string) => void;
+    onHideHistory: () => void;
+};
+export type TTADialogPanelProps = {
+    view: TTADialogPanelView;
+    actions: TTADialogPanelActions;
+    chatHistoryRef: RefObject<HTMLDivElement | null>;
+    composer: ReactNode;
+    renderWarning?: TTADialogRenderWarning;
+};
+export declare const TTADialogPanel: ({ view, actions, chatHistoryRef, composer, renderWarning, }: TTADialogPanelProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,10 @@
+import type { ReactNode } from "react";
+type TTADialogTriggerProps = {
+    isOpen: boolean;
+    isPinned: boolean;
+    hasOpenSidebar: boolean;
+    onToggle: () => void;
+    children: ReactNode;
+};
+export declare const TTADialogTrigger: ({ isOpen, isPinned, hasOpenSidebar, onToggle, children, }: TTADialogTriggerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,11 @@
+import React from "react";
+import "./TTADialog.scss";
+import type { ChatConversation } from "./types";
+export interface TTAHistoryProps {
+    history: ChatConversation[];
+    onSelectChat: (chat: ChatConversation) => void;
+    onDeleteChat: (chatId: string) => void;
+    onRenameChat: (chatId: string, newTitle: string) => void;
+    onClose: () => void;
+}
+export declare const TTAHistory: React.FC<TTAHistoryProps>;

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

@@ -0,0 +1,5 @@
+import "./TTAWarningMessage.scss";
+import type { ReactNode } from "react";
+export declare const TTAWarningMessage: ({ children }: {
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element | null;

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

@@ -0,0 +1,13 @@
+import type { AI_ERROR_CODE } from "./types";
+export type AIChatRuntimeError = Error & {
+    code?: AI_ERROR_CODE | number;
+    handled?: boolean;
+    cause?: unknown;
+};
+export declare const withAIChatErrorMeta: (error: Error, options?: {
+    code?: AI_ERROR_CODE | number;
+    handled?: boolean;
+    cause?: unknown;
+}) => AIChatRuntimeError;
+export declare const getAIChatErrorCode: (error: unknown) => AI_ERROR_CODE | number | undefined;
+export declare const isAIChatErrorHandled: (error: unknown) => boolean;

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

@@ -0,0 +1,26 @@
+import type { NonDeletedExcalidrawElement } from "@excalidraw/element/types";
+import type { AssistantChatMessage, ChatConversation, ChatMessage, ChatTurn } from "./types";
+/**
+ * Deep clones messages to ensure no mutation reference issues.
+ */
+export declare const cloneMessages: (messages: ChatMessage[]) => ChatMessage[];
+export declare const messagesToTurns: (messages: ChatMessage[]) => ChatTurn[];
+export declare const turnsToMessages: (turns: ChatTurn[]) => ChatMessage[];
+export declare const getConversationMessages: (conversation: Pick<ChatConversation, "turns">) => ChatMessage[];
+export declare const compareConversationsByUpdatedAt: (a: Pick<ChatConversation, "updatedAt">, b: Pick<ChatConversation, "updatedAt">) => number;
+export declare const stopIncompleteAssistantMessages: (messages: ChatMessage[]) => ChatMessage[];
+export declare const getLatestAssistantTurnId: (messages: ChatMessage[]) => string | null;
+export declare const getLatestAssistantMessageId: (messages: ChatMessage[]) => string | null;
+export declare const getLatestRetryableAssistantMessage: (messages: ChatMessage[]) => Extract<ChatMessage, {
+    role: "assistant";
+}> | null;
+export declare const getLatestAssistantTurnIdBeforeIndex: (messages: ChatMessage[], beforeIndex: number) => string | null;
+export declare const getAssistantGenerationTags: (messages: ChatMessage[]) => string[];
+export declare const getTurnStartIndexForAssistantDelete: (messages: ChatMessage[], messageIndex: number) => number;
+export declare const getConversationTitle: (messages: ChatMessage[], defaultTitle?: string) => string;
+export declare const getConversationTitleFromTurns: (turns: ChatTurn[], defaultTitle?: string) => string;
+export declare const getConversationPreviewMessage: (messages: ChatMessage[]) => AssistantChatMessage | null;
+export declare const getElementsCenter: (elements: readonly NonDeletedExcalidrawElement[]) => {
+    x: number;
+    y: number;
+} | null;

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

@@ -0,0 +1,74 @@
+import type { AIAssistantLifecycleStatus, AIGenerateRequestPayload, AIStreamFinalPayload, AIStreamMessagePayload, AIStreamPartialPayload, AIStreamStartedPayload, AI_ERROR_CODE } from "./types";
+export declare const TTA_BASE_PATH = "/v1/ai/tta";
+export declare const TTA_GENERATE_STREAM_PATH = "/v1/ai/tta/generate/stream";
+export declare const TTA_TRUNCATE_PATH = "/v1/ai/tta/chat/truncate";
+export type AIChatTruncateRequest = {
+    chatId: string;
+    keepThroughTurnId?: string | null;
+};
+export type AIChatTruncateResponse = {
+    ok: boolean;
+    chatId: string;
+    revision: number;
+    updatedAt?: number;
+};
+export interface TTAStreamFetchRequest {
+    method: "POST";
+    headers: {
+        "Content-Type": "application/json";
+        Accept: "text/event-stream";
+    };
+    payload: AIGenerateRequestPayload;
+    signal?: AbortSignal;
+}
+export type TTAStreamResponseFetch = (request: TTAStreamFetchRequest) => Promise<Response>;
+export interface TTATruncateFetchRequest {
+    method: "POST";
+    headers: {
+        "Content-Type": "application/json";
+    };
+    payload: AIChatTruncateRequest;
+}
+export type TTATruncateResponseFetch = (request: TTATruncateFetchRequest) => Promise<Response>;
+export declare const truncateChat: (payload: AIChatTruncateRequest, options: {
+    fetch: TTATruncateResponseFetch;
+}) => Promise<AIChatTruncateResponse>;
+export interface TTAStreamFetchOptions {
+    payload: AIGenerateRequestPayload;
+    onStarted?: (payload: AIStreamStartedPayload) => void;
+    onMessage?: (payload: AIStreamMessagePayload) => void;
+    onChunk?: (payload: AIStreamPartialPayload) => void;
+    signal?: AbortSignal;
+    onStreamCreated?: () => void;
+    fetch: TTAStreamResponseFetch;
+}
+export type TTAStreamError = {
+    code?: AI_ERROR_CODE | number;
+    message: string;
+    lifecycleStatus?: Extract<AIAssistantLifecycleStatus, "failed" | "aborted">;
+};
+export type TTAStreamFetchResult = {
+    rateLimit?: number | null;
+    rateLimitRemaining?: number | null;
+} & ({
+    finalPayload: AIStreamFinalPayload;
+    error: null;
+} | {
+    error: TTAStreamError;
+    finalPayload?: null;
+});
+export interface TTATransportAdapter {
+    stream(options: Omit<TTAStreamFetchOptions, "fetch">): Promise<TTAStreamFetchResult>;
+    truncate(payload: AIChatTruncateRequest): Promise<AIChatTruncateResponse>;
+}
+export interface TTADefaultTransportAdapterConfig {
+    stream: TTAStreamResponseFetch;
+    truncate: TTATruncateResponseFetch;
+}
+export declare const TTAStreamFetch: (options: TTAStreamFetchOptions) => Promise<TTAStreamFetchResult>;
+export declare class TTADefaultTransportAdapter implements TTATransportAdapter {
+    private readonly config;
+    constructor(config: TTADefaultTransportAdapterConfig);
+    stream: TTATransportAdapter["stream"];
+    truncate: TTATransportAdapter["truncate"];
+}

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

@@ -0,0 +1,2 @@
+import type { TTAPersistenceAdapter } from "./types";
+export declare const TTAIndexedDBAdapter: TTAPersistenceAdapter;

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

@@ -0,0 +1,20 @@
+import { Scene } from "@excalidraw/element";
+import type { ExcalidrawElementSkeleton } from "@excalidraw/element";
+import type { NonDeletedExcalidrawElement } from "@excalidraw/element/types";
+import type { CaptureUpdateActionType } from "@excalidraw/element";
+import type { AppClassProperties } from "../types";
+export declare const AI_GENERATED_ELEMENTS_KEY = "aiSidebarGenerationId";
+interface InsertSkeletonsOptions {
+    targetCenter?: {
+        x: number;
+        y: number;
+    };
+    generationId?: string;
+    regenerateIds?: boolean;
+    selectInsertedElements?: boolean;
+    captureUpdate?: CaptureUpdateActionType;
+}
+export declare const fixBoundTextElements: (elements: readonly NonDeletedExcalidrawElement[], scene: Scene) => void;
+export declare const convertAISkeletonsToSceneElements: (skeletons: ReadonlyArray<ExcalidrawElementSkeleton>, app: AppClassProperties, options?: InsertSkeletonsOptions) => readonly NonDeletedExcalidrawElement[];
+export declare const insertAISkeletons: (app: AppClassProperties, skeletons: ReadonlyArray<ExcalidrawElementSkeleton>, options?: InsertSkeletonsOptions) => readonly NonDeletedExcalidrawElement[];
+export {};