@zsviczian/excalidraw 0.18.0-18 → 0.18.0-19

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

@@ -1,17 +1,17 @@
-import { type GlobalPoint, type LocalPoint } from "@excalidraw/math";
-import { type ElementUpdate } from "./mutateElement";
-import { type ExcalidrawElbowArrowElement, type NonDeletedSceneElementsMap } from "./types";
-import type { FixedPointBinding, FixedSegment } from "./types";
-export declare const BASE_PADDING = 40;
-/**
- *
- */
-export declare const updateElbowArrowPoints: (arrow: Readonly<ExcalidrawElbowArrowElement>, elementsMap: NonDeletedSceneElementsMap, updates: {
-    points?: readonly LocalPoint[];
-    fixedSegments?: readonly FixedSegment[] | null;
-    startBinding?: FixedPointBinding | null;
-    endBinding?: FixedPointBinding | null;
-}, options?: {
-    isDragging?: boolean;
-}) => ElementUpdate<ExcalidrawElbowArrowElement>;
-export declare const validateElbowPoints: <P extends GlobalPoint | LocalPoint>(points: readonly P[], tolerance?: number) => boolean;
+import { type GlobalPoint, type LocalPoint } from "@excalidraw/math";
+import { type ElementUpdate } from "./mutateElement";
+import { type ExcalidrawElbowArrowElement, type NonDeletedSceneElementsMap } from "./types";
+import type { FixedPointBinding, FixedSegment } from "./types";
+export declare const BASE_PADDING = 40;
+/**
+ *
+ */
+export declare const updateElbowArrowPoints: (arrow: Readonly<ExcalidrawElbowArrowElement>, elementsMap: NonDeletedSceneElementsMap, updates: {
+    points?: readonly LocalPoint[];
+    fixedSegments?: readonly FixedSegment[] | null;
+    startBinding?: FixedPointBinding | null;
+    endBinding?: FixedPointBinding | null;
+}, options?: {
+    isDragging?: boolean;
+}) => ElementUpdate<ExcalidrawElbowArrowElement>;
+export declare const validateElbowPoints: <P extends GlobalPoint | LocalPoint>(points: readonly P[], tolerance?: number) => boolean;

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

@@ -1,13 +1,13 @@
-/**
- * Create and link between shapes.
- */
-import type { AppProps, AppState } from "@excalidraw/excalidraw/types";
-import type { ExcalidrawElement } from "./types";
-export declare const defaultGetElementLinkFromSelection: Exclude<AppProps["generateLinkForSelection"], undefined>;
-export declare const getLinkIdAndTypeFromSelection: (selectedElements: ExcalidrawElement[], appState: AppState) => {
-    id: string;
-    type: "element" | "group";
-} | null;
-export declare const canCreateLinkFromElements: (selectedElements: ExcalidrawElement[]) => boolean;
-export declare const isElementLink: (url: string) => boolean;
-export declare const parseElementLinkFromURL: (url: string) => string | null;
+/**
+ * Create and link between shapes.
+ */
+import type { AppProps, AppState } from "@excalidraw/excalidraw/types";
+import type { ExcalidrawElement } from "./types";
+export declare const defaultGetElementLinkFromSelection: Exclude<AppProps["generateLinkForSelection"], undefined>;
+export declare const getLinkIdAndTypeFromSelection: (selectedElements: ExcalidrawElement[], appState: AppState) => {
+    id: string;
+    type: "element" | "group";
+} | null;
+export declare const canCreateLinkFromElements: (selectedElements: ExcalidrawElement[]) => boolean;
+export declare const isElementLink: (url: string) => boolean;
+export declare const parseElementLinkFromURL: (url: string) => string | null;

package/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";
-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 maybeParseEmbedSrc: (str: string) => string;
-export declare const embeddableURLValidator: (url: string | null | undefined, validateEmbeddable: ExcalidrawProps["validateEmbeddable"]) => boolean;
-export {};
+import type { ExcalidrawProps } from "@excalidraw/excalidraw/types";
+import type { MarkRequired } from "@excalidraw/common/utility-types";
+import type { ExcalidrawElement, ExcalidrawIframeLikeElement, IframeData } 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 maybeParseEmbedSrc: (str: string) => string;
+export declare const embeddableURLValidator: (url: string | null | undefined, validateEmbeddable: ExcalidrawProps["validateEmbeddable"]) => boolean;
+export {};

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

@@ -1,26 +1,26 @@
-import type { AppState, PendingExcalidrawElements } from "@excalidraw/excalidraw/types";
-import { type ElementsMap, type ExcalidrawBindableElement, type ExcalidrawElement, type ExcalidrawFlowchartNodeElement } 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 declare class FlowChartNavigator {
-    isExploring: boolean;
-    private sameLevelNodes;
-    private sameLevelIndex;
-    private direction;
-    private visitedNodes;
-    clear(): void;
-    exploreByDirection(element: ExcalidrawElement, elementsMap: ElementsMap, direction: LinkDirection): ExcalidrawElement["id"] | null;
-}
-export declare class FlowChartCreator {
-    isCreatingChart: boolean;
-    private numberOfNodes;
-    private direction;
-    pendingNodes: PendingExcalidrawElements | null;
-    createNodes(startNode: ExcalidrawFlowchartNodeElement, appState: AppState, direction: LinkDirection, scene: Scene): void;
-    clear(): void;
-}
-export declare const isNodeInFlowchart: (element: ExcalidrawFlowchartNodeElement, elementsMap: ElementsMap) => boolean;
-export {};
+import type { AppState, PendingExcalidrawElements } from "@excalidraw/excalidraw/types";
+import { type ElementsMap, type ExcalidrawBindableElement, type ExcalidrawElement, type ExcalidrawFlowchartNodeElement } 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 declare class FlowChartNavigator {
+    isExploring: boolean;
+    private sameLevelNodes;
+    private sameLevelIndex;
+    private direction;
+    private visitedNodes;
+    clear(): void;
+    exploreByDirection(element: ExcalidrawElement, elementsMap: ElementsMap, direction: LinkDirection): ExcalidrawElement["id"] | null;
+}
+export declare class FlowChartCreator {
+    isCreatingChart: boolean;
+    private numberOfNodes;
+    private direction;
+    pendingNodes: PendingExcalidrawElements | null;
+    createNodes(startNode: ExcalidrawFlowchartNodeElement, appState: AppState, direction: LinkDirection, scene: Scene): void;
+    clear(): void;
+}
+export declare const isNodeInFlowchart: (element: ExcalidrawFlowchartNodeElement, elementsMap: ElementsMap) => boolean;
+export {};

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

@@ -1,51 +1,51 @@
-import type { ElementsMap, ExcalidrawElement, OrderedExcalidrawElement } from "./types";
-export declare class InvalidFractionalIndexError extends Error {
-    code: "ELEMENT_HAS_INVALID_INDEX";
-}
-/**
- * Envisioned relation between array order and fractional indices:
- *
- * 1) Array (or array-like ordered data structure) should be used as a cache of elements order, hiding the internal fractional indices implementation.
- * - it's undesirable to perform reorder for each related operation, therefore it's necessary to cache the order defined by fractional indices into an ordered data structure
- * - it's easy enough to define the order of the elements from the outside (boundaries), without worrying about the underlying structure of fractional indices (especially for the host apps)
- * - it's necessary to always keep the array support for backwards compatibility (restore) - old scenes, old libraries, supporting multiple excalidraw versions etc.
- * - it's necessary to always keep the fractional indices in sync with the array order
- * - elements with invalid indices should be detected and synced, without altering the already valid indices
- *
- * 2) Fractional indices should be used to reorder the elements, whenever the cached order is expected to be invalidated.
- * - as the fractional indices are encoded as part of the elements, it opens up possibilities for incremental-like APIs
- * - re-order based on fractional indices should be part of (multiplayer) operations such as reconciliation & undo/redo
- * - technically all the z-index actions could perform also re-order based on fractional indices,but in current state it would not bring much benefits,
- *   as it's faster & more efficient to perform re-order based on array manipulation and later synchronisation of moved indices with the array order
- */
-/**
- * Ensure that all elements have valid fractional indices.
- *
- * @throws `InvalidFractionalIndexError` if invalid index is detected.
- */
-export declare const validateFractionalIndices: (elements: readonly ExcalidrawElement[], { shouldThrow, includeBoundTextValidation, ignoreLogs, reconciliationContext, }: {
-    shouldThrow: boolean;
-    includeBoundTextValidation: boolean;
-    ignoreLogs?: true | undefined;
-    reconciliationContext?: {
-        localElements: ReadonlyArray<ExcalidrawElement>;
-        remoteElements: ReadonlyArray<ExcalidrawElement>;
-    } | undefined;
-}) => void;
-/**
- * Order the elements based on the fractional indices.
- * - when fractional indices are identical, break the tie based on the element id
- * - when there is no fractional index in one of the elements, respect the order of the array
- */
-export declare const orderByFractionalIndex: (elements: OrderedExcalidrawElement[]) => OrderedExcalidrawElement[];
-/**
- * Synchronizes invalid fractional indices of moved elements with the array order by mutating passed elements.
- * If the synchronization fails or the result is invalid, it fallbacks to `syncInvalidIndices`.
- */
-export declare const syncMovedIndices: (elements: readonly ExcalidrawElement[], movedElements: ElementsMap) => OrderedExcalidrawElement[];
-/**
- * Synchronizes all invalid fractional indices with the array order by mutating passed elements.
- *
- * 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[];
+import type { ElementsMap, ExcalidrawElement, OrderedExcalidrawElement } from "./types";
+export declare class InvalidFractionalIndexError extends Error {
+    code: "ELEMENT_HAS_INVALID_INDEX";
+}
+/**
+ * Envisioned relation between array order and fractional indices:
+ *
+ * 1) Array (or array-like ordered data structure) should be used as a cache of elements order, hiding the internal fractional indices implementation.
+ * - it's undesirable to perform reorder for each related operation, therefore it's necessary to cache the order defined by fractional indices into an ordered data structure
+ * - it's easy enough to define the order of the elements from the outside (boundaries), without worrying about the underlying structure of fractional indices (especially for the host apps)
+ * - it's necessary to always keep the array support for backwards compatibility (restore) - old scenes, old libraries, supporting multiple excalidraw versions etc.
+ * - it's necessary to always keep the fractional indices in sync with the array order
+ * - elements with invalid indices should be detected and synced, without altering the already valid indices
+ *
+ * 2) Fractional indices should be used to reorder the elements, whenever the cached order is expected to be invalidated.
+ * - as the fractional indices are encoded as part of the elements, it opens up possibilities for incremental-like APIs
+ * - re-order based on fractional indices should be part of (multiplayer) operations such as reconciliation & undo/redo
+ * - technically all the z-index actions could perform also re-order based on fractional indices,but in current state it would not bring much benefits,
+ *   as it's faster & more efficient to perform re-order based on array manipulation and later synchronisation of moved indices with the array order
+ */
+/**
+ * Ensure that all elements have valid fractional indices.
+ *
+ * @throws `InvalidFractionalIndexError` if invalid index is detected.
+ */
+export declare const validateFractionalIndices: (elements: readonly ExcalidrawElement[], { shouldThrow, includeBoundTextValidation, ignoreLogs, reconciliationContext, }: {
+    shouldThrow: boolean;
+    includeBoundTextValidation: boolean;
+    ignoreLogs?: true | undefined;
+    reconciliationContext?: {
+        localElements: ReadonlyArray<ExcalidrawElement>;
+        remoteElements: ReadonlyArray<ExcalidrawElement>;
+    } | undefined;
+}) => void;
+/**
+ * Order the elements based on the fractional indices.
+ * - when fractional indices are identical, break the tie based on the element id
+ * - when there is no fractional index in one of the elements, respect the order of the array
+ */
+export declare const orderByFractionalIndex: (elements: OrderedExcalidrawElement[]) => OrderedExcalidrawElement[];
+/**
+ * Synchronizes invalid fractional indices of moved elements with the array order by mutating passed elements.
+ * If the synchronization fails or the result is invalid, it fallbacks to `syncInvalidIndices`.
+ */
+export declare const syncMovedIndices: (elements: readonly ExcalidrawElement[], movedElements: ElementsMap) => OrderedExcalidrawElement[];
+/**
+ * Synchronizes all invalid fractional indices with the array order by mutating passed elements.
+ *
+ * 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[];

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

@@ -1,70 +1,70 @@
-import type { AppClassProperties, AppState, StaticCanvasAppState } from "@excalidraw/excalidraw/types";
-import type { ReadonlySetLike } from "@excalidraw/common/utility-types";
-import type { ExcalidrawElementsIncludingDeleted } from "./Scene";
-import type { ElementsMap, ElementsMapOrArray, ExcalidrawElement, ExcalidrawFrameLikeElement, NonDeleted, NonDeletedExcalidrawElement } from "./types";
-export declare const bindElementsToFramesAfterDuplication: (nextElements: readonly ExcalidrawElement[], origElements: readonly ExcalidrawElement[], origIdToDuplicateId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
-export declare function isElementIntersectingFrame(element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap): boolean;
-export declare const getElementsCompletelyInFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => ExcalidrawElement[];
-export declare const isElementContainingFrame: (element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => boolean;
-export declare const getElementsIntersectingFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement) => ExcalidrawElement[];
-export declare const elementsAreInFrameBounds: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => boolean;
-export declare const elementOverlapsWithFrame: (element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => boolean;
-export declare const isCursorInFrame: (cursorCoords: {
-    x: number;
-    y: number;
-}, frame: NonDeleted<ExcalidrawFrameLikeElement>, elementsMap: ElementsMap) => boolean;
-export declare const groupsAreAtLeastIntersectingTheFrame: (elements: readonly NonDeletedExcalidrawElement[], groupIds: readonly string[], frame: ExcalidrawFrameLikeElement) => boolean;
-export declare const groupsAreCompletelyOutOfFrame: (elements: readonly NonDeletedExcalidrawElement[], groupIds: readonly string[], frame: ExcalidrawFrameLikeElement) => boolean;
-/**
- * Returns a map of frameId to frame elements. Includes empty frames.
- */
-export declare const groupByFrameLikes: (elements: readonly ExcalidrawElement[]) => Map<string, ExcalidrawElement[]>;
-export declare const getFrameChildren: (allElements: ElementsMapOrArray, frameId: string) => ExcalidrawElement[];
-export declare const getFrameLikeElements: (allElements: ExcalidrawElementsIncludingDeleted) => ExcalidrawFrameLikeElement[];
-/**
- * Returns ExcalidrawFrameElements and non-frame-children elements.
- *
- * Considers children as root elements if they point to a frame parent
- * non-existing in the elements set.
- *
- * Considers non-frame bound elements (container or arrow labels) as root.
- */
-export declare const getRootElements: (allElements: ExcalidrawElementsIncludingDeleted) => ExcalidrawElement[];
-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").ExcalidrawSelectionElement | import("./types").ExcalidrawRectangleElement | import("./types").ExcalidrawDiamondElement | import("./types").ExcalidrawEllipseElement | import("./types").ExcalidrawTextElement | import("./types").ExcalidrawLinearElement | import("./types").ExcalidrawFreeDrawElement | import("./types").ExcalidrawImageElement | import("./types").ExcalidrawFrameElement | import("./types").ExcalidrawMagicFrameElement | import("./types").ExcalidrawIframeElement | import("./types").ExcalidrawEmbeddableElement)[];
-export declare const omitPartialGroups: (elements: ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, allElementsMap: ElementsMap) => (import("./types").ExcalidrawSelectionElement | import("./types").ExcalidrawRectangleElement | import("./types").ExcalidrawDiamondElement | import("./types").ExcalidrawEllipseElement | import("./types").ExcalidrawTextElement | import("./types").ExcalidrawLinearElement | import("./types").ExcalidrawFreeDrawElement | import("./types").ExcalidrawImageElement | import("./types").ExcalidrawFrameElement | import("./types").ExcalidrawMagicFrameElement | import("./types").ExcalidrawIframeElement | import("./types").ExcalidrawEmbeddableElement)[];
-export declare const getContainingFrame: (element: ExcalidrawElement, elementsMap: ElementsMap) => ExcalidrawFrameLikeElement | null;
-/** */
-export declare const filterElementsEligibleAsFrameChildren: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement) => ExcalidrawElement[];
-/**
- * Retains (or repairs for target frame) the ordering invriant where children
- * elements come right before the parent frame:
- * [el, el, child, child, frame, el]
- *
- * @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 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[];
-/** 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[];
-/**
- * depending on the appState, return target frame, which is the frame the given element
- * is going to be added to or remove from
- */
-export declare const getTargetFrame: (element: ExcalidrawElement, elementsMap: ElementsMap, appState: StaticCanvasAppState) => ExcalidrawFrameLikeElement | null;
-export declare const isElementInFrame: (element: ExcalidrawElement, allElementsMap: ElementsMap, appState: StaticCanvasAppState, opts?: {
-    targetFrame?: ExcalidrawFrameLikeElement;
-    checkedGroups?: Map<string, boolean>;
-}) => boolean;
-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 frameAndChildrenSelectedTogether: (selectedElements: readonly ExcalidrawElement[]) => boolean;
+import type { AppClassProperties, AppState, StaticCanvasAppState } from "@excalidraw/excalidraw/types";
+import type { ReadonlySetLike } from "@excalidraw/common/utility-types";
+import type { ExcalidrawElementsIncludingDeleted } from "./Scene";
+import type { ElementsMap, ElementsMapOrArray, ExcalidrawElement, ExcalidrawFrameLikeElement, NonDeleted, NonDeletedExcalidrawElement } from "./types";
+export declare const bindElementsToFramesAfterDuplication: (nextElements: readonly ExcalidrawElement[], origElements: readonly ExcalidrawElement[], origIdToDuplicateId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
+export declare function isElementIntersectingFrame(element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap): boolean;
+export declare const getElementsCompletelyInFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => ExcalidrawElement[];
+export declare const isElementContainingFrame: (element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => boolean;
+export declare const getElementsIntersectingFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement) => ExcalidrawElement[];
+export declare const elementsAreInFrameBounds: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => boolean;
+export declare const elementOverlapsWithFrame: (element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => boolean;
+export declare const isCursorInFrame: (cursorCoords: {
+    x: number;
+    y: number;
+}, frame: NonDeleted<ExcalidrawFrameLikeElement>, elementsMap: ElementsMap) => boolean;
+export declare const groupsAreAtLeastIntersectingTheFrame: (elements: readonly NonDeletedExcalidrawElement[], groupIds: readonly string[], frame: ExcalidrawFrameLikeElement) => boolean;
+export declare const groupsAreCompletelyOutOfFrame: (elements: readonly NonDeletedExcalidrawElement[], groupIds: readonly string[], frame: ExcalidrawFrameLikeElement) => boolean;
+/**
+ * Returns a map of frameId to frame elements. Includes empty frames.
+ */
+export declare const groupByFrameLikes: (elements: readonly ExcalidrawElement[]) => Map<string, ExcalidrawElement[]>;
+export declare const getFrameChildren: (allElements: ElementsMapOrArray, frameId: string) => ExcalidrawElement[];
+export declare const getFrameLikeElements: (allElements: ExcalidrawElementsIncludingDeleted) => ExcalidrawFrameLikeElement[];
+/**
+ * Returns ExcalidrawFrameElements and non-frame-children elements.
+ *
+ * Considers children as root elements if they point to a frame parent
+ * non-existing in the elements set.
+ *
+ * Considers non-frame bound elements (container or arrow labels) as root.
+ */
+export declare const getRootElements: (allElements: ExcalidrawElementsIncludingDeleted) => ExcalidrawElement[];
+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").ExcalidrawSelectionElement | import("./types").ExcalidrawRectangleElement | import("./types").ExcalidrawDiamondElement | import("./types").ExcalidrawEllipseElement | import("./types").ExcalidrawTextElement | import("./types").ExcalidrawLinearElement | import("./types").ExcalidrawFreeDrawElement | import("./types").ExcalidrawImageElement | import("./types").ExcalidrawFrameElement | import("./types").ExcalidrawMagicFrameElement | import("./types").ExcalidrawIframeElement | import("./types").ExcalidrawEmbeddableElement)[];
+export declare const omitPartialGroups: (elements: ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, allElementsMap: ElementsMap) => (import("./types").ExcalidrawSelectionElement | import("./types").ExcalidrawRectangleElement | import("./types").ExcalidrawDiamondElement | import("./types").ExcalidrawEllipseElement | import("./types").ExcalidrawTextElement | import("./types").ExcalidrawLinearElement | import("./types").ExcalidrawFreeDrawElement | import("./types").ExcalidrawImageElement | import("./types").ExcalidrawFrameElement | import("./types").ExcalidrawMagicFrameElement | import("./types").ExcalidrawIframeElement | import("./types").ExcalidrawEmbeddableElement)[];
+export declare const getContainingFrame: (element: ExcalidrawElement, elementsMap: ElementsMap) => ExcalidrawFrameLikeElement | null;
+/** */
+export declare const filterElementsEligibleAsFrameChildren: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement) => ExcalidrawElement[];
+/**
+ * Retains (or repairs for target frame) the ordering invriant where children
+ * elements come right before the parent frame:
+ * [el, el, child, child, frame, el]
+ *
+ * @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 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[];
+/** 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[];
+/**
+ * depending on the appState, return target frame, which is the frame the given element
+ * is going to be added to or remove from
+ */
+export declare const getTargetFrame: (element: ExcalidrawElement, elementsMap: ElementsMap, appState: StaticCanvasAppState) => ExcalidrawFrameLikeElement | null;
+export declare const isElementInFrame: (element: ExcalidrawElement, allElementsMap: ElementsMap, appState: StaticCanvasAppState, opts?: {
+    targetFrame?: ExcalidrawFrameLikeElement;
+    checkedGroups?: Map<string, boolean>;
+}) => boolean;
+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 frameAndChildrenSelectedTogether: (selectedElements: readonly ExcalidrawElement[]) => boolean;

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

@@ -1,33 +1,33 @@
-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">;
-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;
-};
-/**
- * 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 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) => {
-    [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 getSelectedGroupIdForElement: (element: ExcalidrawElement, selectedGroupIds: {
-    [groupId: string]: boolean;
-}) => string | undefined;
-export declare const addToGroup: (prevGroupIds: ExcalidrawElement["groupIds"], newGroupId: GroupId, editingGroupId: AppState["editingGroupId"]) => string[];
-export declare const removeFromSelectedGroups: (groupIds: ExcalidrawElement["groupIds"], selectedGroupIds: {
-    [groupId: string]: boolean;
-}) => string[];
-export declare const getMaximumGroups: (elements: ExcalidrawElement[], elementsMap: ElementsMap) => ExcalidrawElement[][];
-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 getNewGroupIdsForDuplication: (groupIds: ExcalidrawElement["groupIds"], editingGroupId: AppState["editingGroupId"], mapper: (groupId: GroupId) => GroupId) => string[];
+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">;
+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;
+};
+/**
+ * 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 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) => {
+    [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 getSelectedGroupIdForElement: (element: ExcalidrawElement, selectedGroupIds: {
+    [groupId: string]: boolean;
+}) => string | undefined;
+export declare const addToGroup: (prevGroupIds: ExcalidrawElement["groupIds"], newGroupId: GroupId, editingGroupId: AppState["editingGroupId"]) => string[];
+export declare const removeFromSelectedGroups: (groupIds: ExcalidrawElement["groupIds"], selectedGroupIds: {
+    [groupId: string]: boolean;
+}) => string[];
+export declare const getMaximumGroups: (elements: ExcalidrawElement[], elementsMap: ElementsMap) => ExcalidrawElement[][];
+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 getNewGroupIdsForDuplication: (groupIds: ExcalidrawElement["groupIds"], editingGroupId: AppState["editingGroupId"], mapper: (groupId: GroupId) => GroupId) => string[];

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

@@ -1,15 +1,15 @@
-import type { LocalPoint, GlobalPoint, Vector } from "@excalidraw/math";
-import type { ExcalidrawBindableElement } from "./types";
-export declare const HEADING_RIGHT: Heading;
-export declare const HEADING_DOWN: Heading;
-export declare const HEADING_LEFT: Heading;
-export declare const HEADING_UP: Heading;
-export type Heading = [1, 0] | [0, 1] | [-1, 0] | [0, -1];
-export declare const vectorToHeading: (vec: Vector) => Heading;
-export declare const headingForPoint: <P extends GlobalPoint | LocalPoint>(p: P, o: P) => Heading;
-export declare const headingForPointIsHorizontal: <P extends GlobalPoint | LocalPoint>(p: P, o: P) => boolean;
-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 flipHeading: (h: Heading) => Heading;
+import type { LocalPoint, GlobalPoint, Vector } from "@excalidraw/math";
+import type { ExcalidrawBindableElement } from "./types";
+export declare const HEADING_RIGHT: Heading;
+export declare const HEADING_DOWN: Heading;
+export declare const HEADING_LEFT: Heading;
+export declare const HEADING_UP: Heading;
+export type Heading = [1, 0] | [0, 1] | [-1, 0] | [0, -1];
+export declare const vectorToHeading: (vec: Vector) => Heading;
+export declare const headingForPoint: <P extends GlobalPoint | LocalPoint>(p: P, o: P) => Heading;
+export declare const headingForPointIsHorizontal: <P extends GlobalPoint | LocalPoint>(p: P, o: P) => boolean;
+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 flipHeading: (h: Heading) => Heading;

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

@@ -1,32 +1,32 @@
-import type { AppClassProperties, DataURL, BinaryFiles } from "@excalidraw/excalidraw/types";
-import type { ExcalidrawElement, FileId, InitializedExcalidrawImageElement } from "./types";
-export declare const loadHTMLImageElement: (dataURL: DataURL) => Promise<HTMLImageElement>;
-/** NOTE: updates cache even if already populated with given image. Thus,
- * you should filter out the images upstream if you want to optimize this. */
-export declare const updateImageCache: ({ fileIds, files, imageCache, }: {
-    fileIds: FileId[];
-    files: BinaryFiles;
-    imageCache: AppClassProperties["imageCache"];
-}) => Promise<{
-    imageCache: Map<FileId, {
-        image: HTMLImageElement | Promise<HTMLImageElement>;
-        mimeType: import("../../common/src/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";
-        }>;
-    }>;
-    /** includes errored files because they cache was updated nonetheless */
-    updatedFiles: Map<FileId, true>;
-    /** files that failed when creating HTMLImageElement */
-    erroredFiles: Map<FileId, true>;
-}>;
-export declare const getInitializedImageElements: (elements: readonly ExcalidrawElement[]) => InitializedExcalidrawImageElement[];
-export declare const isHTMLSVGElement: (node: Node | null) => node is SVGElement;
-export declare const normalizeSVG: (SVGString: string) => string;
+import type { AppClassProperties, DataURL, BinaryFiles } from "@excalidraw/excalidraw/types";
+import type { ExcalidrawElement, FileId, InitializedExcalidrawImageElement } from "./types";
+export declare const loadHTMLImageElement: (dataURL: DataURL) => Promise<HTMLImageElement>;
+/** NOTE: updates cache even if already populated with given image. Thus,
+ * you should filter out the images upstream if you want to optimize this. */
+export declare const updateImageCache: ({ fileIds, files, imageCache, }: {
+    fileIds: FileId[];
+    files: BinaryFiles;
+    imageCache: AppClassProperties["imageCache"];
+}) => Promise<{
+    imageCache: Map<FileId, {
+        image: HTMLImageElement | Promise<HTMLImageElement>;
+        mimeType: import("../../common/src/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";
+        }>;
+    }>;
+    /** includes errored files because they cache was updated nonetheless */
+    updatedFiles: Map<FileId, true>;
+    /** files that failed when creating HTMLImageElement */
+    erroredFiles: Map<FileId, true>;
+}>;
+export declare const getInitializedImageElements: (elements: readonly ExcalidrawElement[]) => InitializedExcalidrawImageElement[];
+export declare const isHTMLSVGElement: (node: Node | null) => node is SVGElement;
+export declare const normalizeSVG: (SVGString: string) => string;