@excalidraw/common 0.18.0-91c7748 → 0.18.0-a52cd20

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

@@ -192,7 +192,29 @@ export declare class ElementsDelta implements DeltaContainer<SceneElementsMap> {
     private static createGetter;
     private static applyDelta;
     /**
-     * Check for visible changes regardless of whether they were removed, added or updated.
+     * Whether an element looks different after the delta — and the layout that
+     * followed it — was applied. The input to history's "skip entries with no
+     * visible change" loop.
+     *
+     * Both sides are first reduced to what actually paints:
+     * - a missing or deleted element paints nothing;
+     * - an empty text element paints nothing either — unless it carries arrow
+     *   bindings (an arrow may end at it) or sits on an arrow (an empty label
+     *   still cuts the arrow's gap);
+     * so an empty label's deletion or restoration compares as nothing against
+     * nothing. Two painting elements are then compared property by property:
+     * - `version`, `versionNonce`, `updated`, `created` are metadata, and
+     *   `index` is covered by the separate z-order check (`reorderElements`);
+     * - `boundElements` is compared as `type:id` references with references to
+     *   empty labels dropped, so adding or removing an empty label's reference
+     *   is not visible on its own, and binding repair that rebuilt equal
+     *   objects is not either;
+     * - everything else counts. Nested arrays (`points`, binding fixed points)
+     *   compare by reference, which can only over-report a change — the safe
+     *   direction, where undo stops one entry early.
+     *
+     * `previousElements` holds only `idsToCheck` (see `applyTo`); the label
+     * lookups it serves are for elements whose labels are in that set.
      */
     private static checkForVisibleDifference;
     /**

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

@@ -1,7 +1,8 @@
 import type { AppState } from "@excalidraw/excalidraw/types";
-import type { ElementsMap, ExcalidrawElement } from "./types";
+import type { Scene } from "./Scene";
+import type { ElementsMap, NonDeletedExcalidrawElement } from "./types";
 export interface Distribution {
     space: "between";
     axis: "x" | "y";
 }
-export declare const distributeElements: (selectedElements: ExcalidrawElement[], elementsMap: ElementsMap, distribution: Distribution, appState: Readonly<AppState>) => ExcalidrawElement[];
+export declare const distributeElements: (selectedElements: NonDeletedExcalidrawElement[], elementsMap: ElementsMap, distribution: Distribution, appState: Readonly<AppState>, scene: Scene) => NonDeletedExcalidrawElement[];

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

@@ -1,6 +1,7 @@
 import type { AppState, NormalizedZoomValue, NullableGridSize, PointerDownState } from "@excalidraw/excalidraw/types";
 import type { NonDeletedExcalidrawElement } from "@excalidraw/element/types";
 import type { Scene } from "./Scene";
+import type { ExcalidrawTextElement } from "./types";
 export declare const dragSelectedElements: (pointerDownState: PointerDownState, _selectedElements: NonDeletedExcalidrawElement[], offset: {
     x: number;
     y: number;
@@ -9,6 +10,32 @@ export declare const dragSelectedElements: (pointerDownState: PointerDownState,
     y: number;
 }, gridSize: NullableGridSize) => void;
 export declare const getDragOffsetXY: (selectedElements: NonDeletedExcalidrawElement[], x: number, y: number) => [number, number];
+/**
+ * Sizes a text element as it is dragged out.
+ *
+ * A dragged text pins one point and grows away from it; `anchorRatio` says
+ * where along the box that point sits — 0 for its left edge, 1 for its right,
+ * 0.5 for its centre.
+ *
+ * A free text pins the point the drag started from and takes the ratio from
+ * the drag direction, so it can be pulled either way. A text bound to an arrow
+ * endpoint instead pins whatever the binding placed it against and takes the
+ * ratio from its alignment — which is also what keeps it from growing back
+ * over the arrow, since dragging that way makes no progress rather than
+ * flipping the box around.
+ */
+export declare const dragNewTextElement: ({ newElement, anchorX, anchorRatio, pointerX, nextY, zoom, scene, informMutation, }: {
+    newElement: ExcalidrawTextElement;
+    anchorX: number;
+    /** 0 = anchored by its left edge, 1 = by its right, 0.5 = by its centre */
+    anchorRatio: number;
+    pointerX: number;
+    /** free text re-tops itself to the drag origin; a bound one must not move */
+    nextY?: number;
+    zoom: NormalizedZoomValue;
+    scene: Scene;
+    informMutation?: boolean;
+}) => void;
 export declare const dragNewElement: ({ newElement, elementType, originX, originY, x, y, width, height, shouldMaintainAspectRatio, shouldResizeFromCenter, zoom, scene, widthAspectRatio, originOffset, informMutation, }: {
     newElement: NonDeletedExcalidrawElement;
     elementType: AppState["activeTool"]["type"];
@@ -24,10 +51,10 @@ export declare const dragNewElement: ({ newElement, elementType, originX, origin
     scene: Scene;
     /** whether to keep given aspect ratio when `isResizeWithSidesSameLength` is
         true */
-    widthAspectRatio?: number | null | undefined;
+    widthAspectRatio?: number | null;
     originOffset?: {
         x: number;
         y: number;
-    } | null | undefined;
-    informMutation?: boolean | undefined;
+    } | null;
+    informMutation?: boolean;
 }) => void;

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

@@ -1,6 +1,32 @@
 import type { Mutable } from "@excalidraw/common/utility-types";
 import type { AppState } from "@excalidraw/excalidraw/types";
-import type { ExcalidrawElement, GroupId } from "./types";
+import type { ExcalidrawElement, GroupId, NonDeletedExcalidrawElement } from "./types";
+/**
+ * Lookups supplied to the host's `props.onDuplicate`, covering just the
+ * elements taking part in the duplication.
+ */
+export type OnDuplicateData = {
+    /** the duplicates, by their id */
+    duplicateElements: ReadonlyMap<ExcalidrawElement["id"], ExcalidrawElement>;
+    /**
+     * The elements the duplicates were made from, by their id.
+     *
+     * On paste and library insert these are the inserted elements, which aren't
+     * part of the scene (though they may share ids with the scene elements they
+     * were copied from).
+     */
+    originalElements: ReadonlyMap<ExcalidrawElement["id"], ExcalidrawElement>;
+    /**
+     * id of an original -> id of its duplicate (e.g. to remap element ids you
+     * keep in `customData`, which the duplicate copied from its original)
+     */
+    origIdToDuplicateId: ReadonlyMap<ExcalidrawElement["id"], ExcalidrawElement["id"]>;
+    /**
+     * id of a duplicate -> id of its original (e.g. to look up the original in
+     * `originalElements` while modifying the duplicate)
+     */
+    duplicateIdToOrigId: ReadonlyMap<ExcalidrawElement["id"], ExcalidrawElement["id"]>;
+};
 /**
  * Duplicate an element, often used in the alt-drag operation.
  * Note that this method has gotten a bit complicated since the
@@ -17,12 +43,12 @@ import type { ExcalidrawElement, GroupId } from "./types";
 export declare const duplicateElement: <TElement extends ExcalidrawElement>(editingGroupId: AppState["editingGroupId"], groupIdMapForOperation: Map<GroupId, GroupId>, element: TElement, randomizeSeed?: boolean) => Readonly<TElement>;
 export declare const duplicateElements: (opts: {
     elements: readonly ExcalidrawElement[];
-    randomizeSeed?: boolean | undefined;
-    overrides?: ((data: {
+    randomizeSeed?: boolean;
+    overrides?: (data: {
         duplicateElement: ExcalidrawElement;
         origElement: ExcalidrawElement;
         origIdToDuplicateId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>;
-    }) => Partial<ExcalidrawElement>) | undefined;
+    }) => Partial<ExcalidrawElement>;
 } & ({
     /**
      * Duplicates all elements in array.
@@ -31,6 +57,7 @@ export declare const duplicateElements: (opts: {
      * user interaction.
      */
     type: "everything";
+    preserveFrameChildrenOrder?: boolean;
 } | {
     /**
      * Duplicates specified elements and inserts them back into the array
@@ -46,10 +73,44 @@ export declare const duplicateElements: (opts: {
         selectedGroupIds: AppState["selectedGroupIds"];
     };
 })) => {
-    duplicatedElements: ExcalidrawElement[];
-    duplicateElementsMap: Map<string, ExcalidrawElement>;
+    duplicatedElements: NonDeletedExcalidrawElement[];
+    duplicateElementsMap: Map<string, NonDeletedExcalidrawElement>;
+    origElementsMap: Map<string, ExcalidrawElement>;
     elementsWithDuplicates: ExcalidrawElement[];
     origIdToDuplicateId: Map<string, string>;
+    duplicateIdToOrigId: Map<string, string>;
+};
+/**
+ * Folds the elements returned by the host (`props.onDuplicate`) back into the
+ * duplicates the editor created, so that everything that follows (frame
+ * assignment, bound text redraw, selection, alt-drag handover) can keep
+ * working with the editor's own objects, whether the host mutated the
+ * duplicates or returned new objects for them.
+ *
+ * - A returned element with a duplicate's id is shallow-merged into that
+ *   duplicate, which takes its place in the returned array. Properties the
+ *   host omits are kept, so that a partial element can't invalidate the
+ *   duplicate. Safe only because the duplicates are fresh (not in the scene or
+ *   the store snapshot yet), which is why nothing but the passed duplicates is
+ *   ever merged into. Since the merge goes around `mutateElement`, what may
+ *   have been cached for the duplicate by then is invalidated here.
+ * - A duplicate missing from the returned array (or returned as deleted) is
+ *   vetoed. So is the bound text of a vetoed container. What the remaining
+ *   duplicates reference of the vetoed ones is cleared, as if those were never
+ *   part of the duplication (see `fixDuplicatedBindingsAfterDuplication`).
+ * - Any other returned element is used as is (existing elements must not be
+ *   mutated, so the host replaces them).
+ * - `false` vetoes all the duplicates.
+ *
+ * @returns next elements, and the duplicates that weren't vetoed
+ */
+export declare const reconcileDuplicatedElements: <TDuplicate extends ExcalidrawElement>(
+/** what the host returned from `props.onDuplicate`, if anything */
+hostElements: readonly ExcalidrawElement[] | void | false, 
+/** elements that were passed to the host */
+nextElements: ExcalidrawElement[], duplicatedElements: TDuplicate[]) => {
+    elements: ExcalidrawElement[];
+    duplicatedElements: TDuplicate[];
 };
 /**
  * Clones ExcalidrawElement data structure. Does not regenerate id, nonce, or

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/embeddable.d.ts

@@ -1,10 +1,10 @@
 import type { ExcalidrawProps } from "@excalidraw/excalidraw/types";
 import type { MarkRequired } from "@excalidraw/common/utility-types";
-import type { ExcalidrawElement, ExcalidrawIframeLikeElement, IframeData } from "./types";
+import type { ExcalidrawIframeLikeElement, IframeData, NonDeletedExcalidrawElement } from "./types";
 type IframeDataWithSandbox = MarkRequired<IframeData, "sandbox">;
 export declare const createSrcDoc: (body: string) => string;
 export declare const getEmbedLink: (link: string | null | undefined) => IframeDataWithSandbox | null;
-export declare const createPlaceholderEmbeddableLabel: (element: ExcalidrawIframeLikeElement) => ExcalidrawElement;
+export declare const createPlaceholderEmbeddableLabel: (element: ExcalidrawIframeLikeElement) => NonDeletedExcalidrawElement;
 export declare const maybeParseEmbedSrc: (str: string) => string;
 export declare const embeddableURLValidator: (url: string | null | undefined, validateEmbeddable: ExcalidrawProps["validateEmbeddable"]) => boolean;
 export {};

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

@@ -1,10 +1,11 @@
 import type { AppState, PendingExcalidrawElements } from "@excalidraw/excalidraw/types";
-import { type ElementsMap, type ExcalidrawBindableElement, type ExcalidrawElement, type ExcalidrawFlowchartNodeElement } from "./types";
+import { type NonDeleted, type ElementsMap, type ExcalidrawElement, type ExcalidrawFlowchartNodeElement, type NonDeletedExcalidrawElement } from "./types";
 import type { Scene } from "./Scene";
-type LinkDirection = "up" | "right" | "down" | "left";
-export declare const getLinkDirectionFromKey: (key: string) => LinkDirection;
-export declare const getPredecessors: (node: ExcalidrawBindableElement, elementsMap: ElementsMap, direction: LinkDirection) => ExcalidrawBindableElement[];
-export declare const addNewNodes: (startNode: ExcalidrawFlowchartNodeElement, appState: AppState, direction: LinkDirection, scene: Scene, numberOfNodes: number) => ExcalidrawElement[];
+export type LinkDirection = "up" | "right" | "down" | "left";
+export declare const addNewNodes: (startNode: NonDeleted<ExcalidrawFlowchartNodeElement>, appState: AppState, direction: LinkDirection, scene: Scene, numberOfNodes: number, stickyCrossStart?: number | null) => {
+    nodes: NonDeletedExcalidrawElement[];
+    crossStart: number;
+};
 export declare class FlowChartNavigator {
     isExploring: boolean;
     private sameLevelNodes;
@@ -13,14 +14,17 @@ export declare class FlowChartNavigator {
     private visitedNodes;
     clear(): void;
     exploreByDirection(element: ExcalidrawElement, elementsMap: ElementsMap, direction: LinkDirection): ExcalidrawElement["id"] | null;
+    private static getNodeRelatives;
+    private static getSuccessors;
+    private static getPredecessors;
 }
 export declare class FlowChartCreator {
     isCreatingChart: boolean;
     private numberOfNodes;
     private direction;
+    private clusterCrossStart;
     pendingNodes: PendingExcalidrawElements | null;
-    createNodes(startNode: ExcalidrawFlowchartNodeElement, appState: AppState, direction: LinkDirection, scene: Scene): void;
+    createNodes(startNode: NonDeleted<ExcalidrawFlowchartNodeElement>, appState: AppState, direction: LinkDirection, scene: Scene): void;
     clear(): void;
 }
 export declare const isNodeInFlowchart: (element: ExcalidrawFlowchartNodeElement, elementsMap: ElementsMap) => boolean;
-export {};

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

@@ -1,4 +1,4 @@
-import type { ElementsMap, ExcalidrawElement, OrderedExcalidrawElement, SceneElementsMap } from "./types";
+import type { ElementsMap, ExcalidrawElement, Ordered, OrderedExcalidrawElement, SceneElementsMap } from "./types";
 export declare class InvalidFractionalIndexError extends Error {
     code: "ELEMENT_HAS_INVALID_INDEX";
 }
@@ -26,11 +26,11 @@ export declare class InvalidFractionalIndexError extends Error {
 export declare const validateFractionalIndices: (elements: readonly ExcalidrawElement[], { shouldThrow, includeBoundTextValidation, ignoreLogs, reconciliationContext, }: {
     shouldThrow: boolean;
     includeBoundTextValidation: boolean;
-    ignoreLogs?: true | undefined;
+    ignoreLogs?: true;
     reconciliationContext?: {
         localElements: ReadonlyArray<ExcalidrawElement>;
         remoteElements: ReadonlyArray<ExcalidrawElement>;
-    } | undefined;
+    };
 }) => void;
 /**
  * Order the elements based on the fractional indices.
@@ -48,7 +48,7 @@ export declare const syncMovedIndices: (elements: readonly ExcalidrawElement[],
  *
  * WARN: in edge cases it could modify the elements which were not moved, as it's impossible to guess the actually moved elements from the elements array itself.
  */
-export declare const syncInvalidIndices: (elements: readonly ExcalidrawElement[]) => OrderedExcalidrawElement[];
+export declare const syncInvalidIndices: <T extends ExcalidrawElement>(elements: readonly T[]) => Ordered<T>[];
 /**
  * Synchronizes all invalid fractional indices within the array order by creating new instances of elements with corrected indices.
  *

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

@@ -29,31 +29,36 @@ export declare const getFrameLikeElements: (allElements: ExcalidrawElementsInclu
  *
  * Considers non-frame bound elements (container or arrow labels) as root.
  */
-export declare const getRootElements: (allElements: ExcalidrawElementsIncludingDeleted) => ExcalidrawElement[];
+export declare const getRootElements: <T extends ExcalidrawElement>(allElements: readonly T[]) => T[];
 export declare const getElementsInResizingFrame: (allElements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameLikeElement, appState: AppState, elementsMap: ElementsMap) => ExcalidrawElement[];
-export declare const getElementsInNewFrame: (elements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => (import("./types").ExcalidrawTextElement | import("./types").ExcalidrawRectangleElement | import("./types").ExcalidrawDiamondElement | import("./types").ExcalidrawFrameElement | import("./types").ExcalidrawMagicFrameElement | import("./types").ExcalidrawEmbeddableElement | import("./types").ExcalidrawImageElement | import("./types").ExcalidrawIframeElement | import("./types").ExcalidrawSelectionElement | import("./types").ExcalidrawEllipseElement | import("./types").ExcalidrawLinearElement | import("./types").ExcalidrawFreeDrawElement)[];
-export declare const omitPartialGroups: (elements: ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, allElementsMap: ElementsMap) => (import("./types").ExcalidrawTextElement | import("./types").ExcalidrawRectangleElement | import("./types").ExcalidrawDiamondElement | import("./types").ExcalidrawFrameElement | import("./types").ExcalidrawMagicFrameElement | import("./types").ExcalidrawEmbeddableElement | import("./types").ExcalidrawImageElement | import("./types").ExcalidrawIframeElement | import("./types").ExcalidrawSelectionElement | import("./types").ExcalidrawEllipseElement | import("./types").ExcalidrawLinearElement | import("./types").ExcalidrawFreeDrawElement)[];
+export declare const getElementsInNewFrame: (elements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => (import("./types").ExcalidrawLinearElement | import("./types").ExcalidrawSelectionElement | import("./types").ExcalidrawRectangleElement | import("./types").ExcalidrawStickyNoteElement | import("./types").ExcalidrawDiamondElement | import("./types").ExcalidrawEllipseElement | import("./types").ExcalidrawEmbeddableElement | import("./types").ExcalidrawIframeElement | import("./types").ExcalidrawImageElement | import("./types").ExcalidrawFrameElement | import("./types").ExcalidrawMagicFrameElement | import("./types").ExcalidrawTextElement | import("./types").ExcalidrawFreeDrawElement)[];
+export declare const omitPartialGroups: (elements: ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, allElementsMap: ElementsMap) => (import("./types").ExcalidrawLinearElement | import("./types").ExcalidrawSelectionElement | import("./types").ExcalidrawRectangleElement | import("./types").ExcalidrawStickyNoteElement | import("./types").ExcalidrawDiamondElement | import("./types").ExcalidrawEllipseElement | import("./types").ExcalidrawEmbeddableElement | import("./types").ExcalidrawIframeElement | import("./types").ExcalidrawImageElement | import("./types").ExcalidrawFrameElement | import("./types").ExcalidrawMagicFrameElement | import("./types").ExcalidrawTextElement | import("./types").ExcalidrawFreeDrawElement)[];
 export declare const getContainingFrame: (element: ExcalidrawElement, elementsMap: ElementsMap) => ExcalidrawFrameLikeElement | null;
 /** */
 export declare const filterElementsEligibleAsFrameChildren: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement) => ExcalidrawElement[];
+export declare const getCommonFrameId: (elements: readonly ExcalidrawElement[]) => string | null;
+export declare const getFrameChildrenInsertionIndex: (elements: readonly ExcalidrawElement[], frameId: ExcalidrawFrameLikeElement["id"]) => number | null;
 /**
- * Retains (or repairs for target frame) the ordering invriant where children
- * elements come right before the parent frame:
- * [el, el, child, child, frame, el]
+ * Adds elements and their bound elements to frame. Reorders added elements to
+ * be just below frame, or just above its highest child (whichever is higher).
  *
  * @returns mutated allElements (same data structure)
  */
-export declare const addElementsToFrame: <T extends ElementsMapOrArray>(allElements: T, elementsToAdd: NonDeletedExcalidrawElement[], frame: ExcalidrawFrameLikeElement, appState: AppState) => T;
-export declare const removeElementsFromFrame: (elementsToRemove: ReadonlySetLike<NonDeletedExcalidrawElement>, elementsMap: ElementsMap) => void;
+export declare const addElementsToFrame: <T extends ElementsMapOrArray>(allElements: T, elementsToAdd: ExcalidrawElement[], frame: ExcalidrawFrameLikeElement) => T;
+export declare const removeElementsFromFrame: (elementsToRemove: ReadonlySetLike<ExcalidrawElement>, elementsMap: ElementsMap) => void;
 export declare const removeAllElementsFromFrame: <T extends ExcalidrawElement>(allElements: readonly T[], frame: ExcalidrawFrameLikeElement) => readonly T[];
-export declare const replaceAllElementsInFrame: <T extends ExcalidrawElement>(allElements: readonly T[], nextElementsInFrame: ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, app: AppClassProperties) => T[];
+export declare const replaceAllElementsInFrame: <T extends ExcalidrawElement>(allElements: readonly T[], nextElementsInFrame: ExcalidrawElement[], frame: ExcalidrawFrameLikeElement) => T[];
 /** does not mutate elements, but returns new ones */
 export declare const updateFrameMembershipOfSelectedElements: <T extends ElementsMapOrArray>(allElements: T, appState: AppState, app: AppClassProperties) => T;
 /**
  * filters out elements that are inside groups that contain a frame element
  * anywhere in the group tree
  */
-export declare const omitGroupsContainingFrameLikes: (allElements: ElementsMapOrArray, selectedElements?: readonly ExcalidrawElement[]) => ExcalidrawElement[];
+export declare const omitGroupsContainingFrameLikes: (allElements: ElementsMapOrArray, 
+/** subset of elements you want to filter. Optional perf optimization so we
+ * don't have to filter all elements unnecessarily
+ */
+selectedElements?: readonly ExcalidrawElement[]) => ExcalidrawElement[];
 /**
  * depending on the appState, return target frame, which is the frame the given element
  * is going to be added to or remove from
@@ -66,5 +71,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: <T extends ExcalidrawElement>(elements: readonly T[], frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => T[];
 export declare const frameAndChildrenSelectedTogether: (selectedElements: readonly ExcalidrawElement[]) => boolean;

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

@@ -1,7 +1,7 @@
 import type { AppClassProperties, AppState, InteractiveCanvasAppState } from "@excalidraw/excalidraw/types";
 import type { Mutable } from "@excalidraw/common/utility-types";
-import type { GroupId, ExcalidrawElement, NonDeleted, NonDeletedExcalidrawElement, ElementsMapOrArray, ElementsMap } from "./types";
-export declare const selectGroup: (groupId: GroupId, appState: InteractiveCanvasAppState, elements: readonly NonDeleted<ExcalidrawElement>[]) => Pick<InteractiveCanvasAppState, "selectedGroupIds" | "selectedElementIds" | "editingGroupId">;
+import type { GroupId, ExcalidrawElement, NonDeleted, ElementsMapOrArray, ElementsMap, NonDeletedExcalidrawElement, NonDeletedElementsMapOrArray } from "./types";
+export declare const selectGroup: (groupId: GroupId, appState: InteractiveCanvasAppState, elements: readonly NonDeletedExcalidrawElement[]) => Pick<InteractiveCanvasAppState, "selectedGroupIds" | "selectedElementIds" | "editingGroupId">;
 export declare const selectGroupsForSelectedElements: {
     (appState: Pick<AppState, "selectedElementIds" | "editingGroupId">, elements: readonly NonDeletedExcalidrawElement[], prevAppState: InteractiveCanvasAppState, app: AppClassProperties | null): Mutable<Pick<InteractiveCanvasAppState, "selectedGroupIds" | "editingGroupId" | "selectedElementIds">>;
     clearCache(): void;
@@ -10,15 +10,15 @@ export declare const selectGroupsForSelectedElements: {
  * If the element's group is selected, don't render an individual
  * selection border around it.
  */
-export declare const isSelectedViaGroup: (appState: InteractiveCanvasAppState, element: ExcalidrawElement) => boolean;
+export declare const isSelectedViaGroup: (appState: Pick<InteractiveCanvasAppState, "editingGroupId" | "selectedGroupIds">, element: ExcalidrawElement) => boolean;
 export declare const getSelectedGroupForElement: (appState: Pick<InteractiveCanvasAppState, "editingGroupId" | "selectedGroupIds">, element: ExcalidrawElement) => string | undefined;
-export declare const getSelectedGroupIds: (appState: InteractiveCanvasAppState) => GroupId[];
-export declare const selectGroupsFromGivenElements: (elements: readonly NonDeleted<ExcalidrawElement>[], appState: InteractiveCanvasAppState) => {
+export declare const getSelectedGroupIds: (appState: Pick<InteractiveCanvasAppState, "selectedGroupIds">) => GroupId[];
+export declare const selectGroupsFromGivenElements: (elements: readonly NonDeletedExcalidrawElement[], appState: InteractiveCanvasAppState) => {
     [groupId: string]: boolean;
 };
 export declare const editGroupForSelectedElement: (appState: AppState, element: NonDeleted<ExcalidrawElement>) => AppState;
 export declare const isElementInGroup: (element: ExcalidrawElement, groupId: string) => boolean;
-export declare const getElementsInGroup: (elements: ElementsMapOrArray, groupId: string) => ExcalidrawElement[];
+export declare const getElementsInGroup: <P extends NonDeletedExcalidrawElement | ExcalidrawElement>(elements: P extends NonDeletedExcalidrawElement ? NonDeletedElementsMapOrArray : ElementsMapOrArray, groupId: string) => P[];
 export declare const getSelectedGroupIdForElement: (element: ExcalidrawElement, selectedGroupIds: {
     [groupId: string]: boolean;
 }) => string | undefined;
@@ -26,9 +26,9 @@ export declare const addToGroup: (prevGroupIds: ExcalidrawElement["groupIds"], n
 export declare const removeFromSelectedGroups: (groupIds: ExcalidrawElement["groupIds"], selectedGroupIds: {
     [groupId: string]: boolean;
 }) => string[];
-export declare const getMaximumGroups: (elements: ExcalidrawElement[], elementsMap: ElementsMap) => ExcalidrawElement[][];
+export declare const getMaximumGroups: <T extends NonDeletedExcalidrawElement | ExcalidrawElement>(elements: T[], elementsMap: ElementsMap) => T[][];
 export declare const getNonDeletedGroupIds: (elements: ElementsMap) => Set<string>;
 export declare const elementsAreInSameGroup: (elements: readonly ExcalidrawElement[]) => boolean;
-export declare const isInGroup: (element: NonDeletedExcalidrawElement) => boolean;
+export declare const isInGroup: (element: ExcalidrawElement) => boolean;
 export declare const getNewGroupIdsForDuplication: (groupIds: ExcalidrawElement["groupIds"], editingGroupId: AppState["editingGroupId"], mapper: (groupId: GroupId) => GroupId) => string[];
-export declare const getSelectedElementsByGroup: (selectedElements: ExcalidrawElement[], elementsMap: ElementsMap, appState: Readonly<AppState>) => ExcalidrawElement[][];
+export declare const getSelectedElementsByGroup: (selectedElements: NonDeletedExcalidrawElement[], elementsMap: ElementsMap, appState: Readonly<Pick<AppState, "selectedGroupIds" | "editingGroupId">>) => NonDeletedExcalidrawElement[][];

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

@@ -1,3 +1,4 @@
+import { type Bounds } from "@excalidraw/common";
 import type { LocalPoint, GlobalPoint, Vector } from "@excalidraw/math";
 import type { ExcalidrawBindableElement } from "./types";
 export declare const HEADING_RIGHT: Heading;
@@ -11,5 +12,5 @@ export declare const headingForPointIsHorizontal: <P extends GlobalPoint | Local
 export declare const compareHeading: (a: Heading, b: Heading) => boolean;
 export declare const headingIsHorizontal: (a: Heading) => boolean;
 export declare const headingIsVertical: (a: Heading) => boolean;
-export declare const headingForPointFromElement: <Point extends GlobalPoint>(element: Readonly<ExcalidrawBindableElement>, aabb: readonly [minX: number, minY: number, maxX: number, maxY: number], p: Readonly<Point>) => Heading;
+export declare const headingForPointFromElement: <Point extends GlobalPoint>(element: Readonly<ExcalidrawBindableElement>, aabb: Readonly<Bounds>, p: Readonly<Point>) => Heading;
 export declare const flipHeading: (h: Heading) => Heading;

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

@@ -10,17 +10,7 @@ export declare const updateImageCache: ({ fileIds, files, imageCache, }: {
 }) => Promise<{
     imageCache: Map<FileId, {
         image: HTMLImageElement | Promise<HTMLImageElement>;
-        mimeType: import("@excalidraw/common/utility-types").ValueOf<{
-            readonly svg: "image/svg+xml";
-            readonly png: "image/png";
-            readonly jpg: "image/jpeg";
-            readonly gif: "image/gif";
-            readonly webp: "image/webp";
-            readonly bmp: "image/bmp";
-            readonly ico: "image/x-icon";
-            readonly avif: "image/avif";
-            readonly jfif: "image/jfif";
-        }>;
+        mimeType: import("@excalidraw/common/utility-types").ValueOf<typeof import("@excalidraw/common").IMAGE_MIME_TYPES>;
     }>;
     /** includes errored files because they cache was updated nonetheless */
     updatedFiles: Map<FileId, true>;

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

@@ -8,15 +8,14 @@ export declare const getSceneVersion: (elements: readonly ExcalidrawElement[]) =
  */
 export declare const hashElementsVersion: (elements: ElementsMapOrArray) => number;
 export declare const hashString: (s: string) => number;
+export declare const isNonDeletedElement: <T extends ExcalidrawElement>(element: T) => element is NonDeleted<T>;
 export declare const getVisibleElements: (elements: readonly ExcalidrawElement[]) => readonly NonDeletedExcalidrawElement[];
 export declare const getNonDeletedElements: <T extends ExcalidrawElement>(elements: readonly T[]) => readonly NonDeleted<T>[];
-export declare const isNonDeletedElement: <T extends ExcalidrawElement>(element: T) => element is NonDeleted<T>;
-export declare const clearElementsForDatabase: (elements: readonly ExcalidrawElement[]) => ExcalidrawElement[];
-export declare const clearElementsForExport: (elements: readonly ExcalidrawElement[]) => ExcalidrawElement[];
-export declare const clearElementsForLocalStorage: (elements: readonly ExcalidrawElement[]) => ExcalidrawElement[];
 export * from "./align";
+export * from "./arrowEndpointText";
 export * from "./binding";
 export * from "./bounds";
+export * from "./bucketFill";
 export * from "./collision";
 export * from "./comparisons";
 export * from "./containerCache";
@@ -30,6 +29,7 @@ export * from "./elbowArrow";
 export * from "./elementLink";
 export * from "./embeddable";
 export * from "./flowchart";
+export * from "./arrows/focus";
 export * from "./fractionalIndex";
 export * from "./frame";
 export * from "./groups";
@@ -49,10 +49,15 @@ export * from "./showSelectedShapeActions";
 export * from "./sizeHelpers";
 export * from "./sortElements";
 export * from "./store";
+export * from "./stickyNote";
 export * from "./textElement";
 export * from "./textMeasurements";
 export * from "./textWrapping";
+export * from "./transform";
 export * from "./transformHandles";
 export * from "./typeChecks";
 export * from "./utils";
 export * from "./zindex";
+export * from "./arrows/helpers";
+export * from "./arrowheads";
+export * from "./convertToShape";