@excalidraw/math 0.18.0-1118751 → 0.18.0-17d8904

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

@@ -4,6 +4,8 @@ export { DEFAULT_STICKY_NOTE_BG } from "./colors";
 export declare const supportsResizeObserver: boolean;
 export declare const APP_NAME = "Excalidraw";
 export declare const TEXT_AUTOWRAP_THRESHOLD = 36;
+export declare const TEXT_VIEWPORT_PADDING = 20;
+export declare const TEXT_MAX_WRAP_WIDTH = 800;
 export declare const DRAGGING_THRESHOLD = 10;
 export declare const MINIMUM_ARROW_SIZE = 20;
 export declare const LINE_CONFIRM_THRESHOLD = 8;
@@ -272,6 +274,7 @@ export declare const TOUCH_CTX_MENU_TIMEOUT = 500;
 export declare const TITLE_TIMEOUT = 10000;
 export declare const VERSION_TIMEOUT = 30000;
 export declare const SCROLL_TIMEOUT = 100;
+export declare const ZEN_MODE_TRANSITION_DURATION = 250;
 export declare const ZOOM_STEP = 0.1;
 export declare const MIN_ZOOM = 0.1;
 export declare const MAX_ZOOM = 30;

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

@@ -87,6 +87,11 @@ export declare const getGlobalCSSVariable: (name: string) => string;
  * See https://github.com/excalidraw/excalidraw/pull/1722#discussion_r436340171
  */
 export declare const isRTL: (text: string) => boolean;
+/**
+ * Checks whether the text has any RTL character, i.e. whether it may be laid
+ * out bidirectionally.
+ */
+export declare const hasRTLChars: (text: string) => boolean;
 export declare const tupleToCoors: (xyTuple: readonly [number, number]) => {
     x: number;
     y: number;

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

@@ -58,6 +58,7 @@ export declare const bindBindingElement: (arrow: NonDeleted<ExcalidrawArrowEleme
 export declare const unbindBindingElement: (arrow: ExcalidrawArrowElement, startOrEnd: "start" | "end", scene: Scene) => ExcalidrawBindableElement["id"] | null;
 export declare const reanchorBindingsToOutline: (changedElement: NonDeleted<ExcalidrawBindableElement>, scene: Scene, zoom: AppState["zoom"]) => void;
 export declare const updateBoundElements: (changedElement: NonDeletedExcalidrawElement, scene: Scene, options?: {
+    /** see `getSimultaneouslyUpdatedElementIds` for how to pass it */
     simultaneouslyUpdated?: readonly NonDeletedExcalidrawElement[];
     changedElements?: Map<string, ExcalidrawElement>;
 }) => void;
@@ -68,6 +69,13 @@ export declare const updateBindings: (latestElement: NonDeletedExcalidrawElement
         height: number;
     };
 }) => void;
+/**
+ * The id set of `simultaneouslyUpdated`, shared by every `updateBoundElements()`
+ * call given the same array. Pass one array instance for all elements of an
+ * operation, and don't change its membership after the first lookup, or the
+ * cached ids go stale.
+ */
+export declare const getSimultaneouslyUpdatedElementIds: (simultaneouslyUpdated: readonly ExcalidrawElement[] | undefined) => ReadonlySet<ExcalidrawElement["id"]>;
 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, zoom: AppState["zoom"], customIntersector?: LineSegment<GlobalPoint>, isMidpointSnappingEnabled?: boolean) => GlobalPoint;
 export declare const avoidRectangularCorner: (arrowElement: ExcalidrawArrowElement, bindTarget: ExcalidrawBindableElement, elementsMap: ElementsMap, p: GlobalPoint) => GlobalPoint;

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

@@ -81,7 +81,7 @@ export declare const boundsContainBounds: (outerBounds: Bounds, innerBounds: Bou
  * It can be used to get elements overlapping a selection box, for example.
  *
  */
-export declare const elementsOverlappingBBox: <T extends ExcalidrawElement>({ elements, elementsMap, bounds, type, excludeElementsInFrames, shouldIgnoreElementFromSelection, }: {
+export declare const elementsOverlappingBBox: <T extends ExcalidrawElement>({ elements, elementsMap, bounds, type, excludeElementsInFrames, shouldIgnoreElementFromSelection, includeStroke, }: {
     elements: readonly T[];
     elementsMap?: ElementsMap;
     bounds: Bounds | ExcalidrawElement;
@@ -92,5 +92,7 @@ export declare const elementsOverlappingBBox: <T extends ExcalidrawElement>({ el
     type: "contain" | "overlap";
     excludeElementsInFrames?: boolean;
     shouldIgnoreElementFromSelection?: (element: T) => boolean;
+    /** whether elements extend by their stroke, as they render */
+    includeStroke?: boolean;
 }) => T[];
 export declare const elementCenterPoint: (element: ExcalidrawElement, elementsMap: ElementsMap, xOffset?: number, yOffset?: number) => GlobalPoint;

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

@@ -14,6 +14,12 @@ export declare const hitElementItself: ({ point, element, threshold, elementsMap
 export declare const hitElementBoundingBox: (point: GlobalPoint, element: ExcalidrawElement, elementsMap: ElementsMap, tolerance?: number) => boolean;
 export declare const hitElementBoundingBoxOnly: (hitArgs: HitTestArgs, elementsMap: ElementsMap) => boolean;
 export declare const hitElementBoundText: (point: GlobalPoint, element: ExcalidrawElement, elementsMap: ElementsMap) => boolean;
+/**
+ * Whether the element hides what is behind it from binding — an arrow's or a
+ * text label's. Images count as opaque, and frames once they support a
+ * background.
+ */
+export declare const isOpaqueForBinding: (element: ExcalidrawElement) => boolean;
 /**
  * All elements an arrow endpoint at the point could bind to. Always includes
  * the result of `getHoveredElementForBinding` for the same arguments.

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

@@ -1,13 +1,45 @@
-import type { TransformHandleType } from "./transformHandles";
-import type { ElementsMap, ExcalidrawImageElement, ImageCrop } from "./types";
+import type { TransformHandleDirection } from "./transformHandles";
+import type { ElementsMap, ExcalidrawImageElement } from "./types";
 export declare const MINIMAL_CROP_SIZE = 10;
-export declare const cropElement: (element: ExcalidrawImageElement, elementsMap: ElementsMap, transformHandle: TransformHandleType, naturalWidth: number, naturalHeight: number, pointerX: number, pointerY: number, widthAspectRatio?: number) => {
+/**
+ * Crops the image (as it was at the drag's start) as resizing it would
+ * resize it, as far as the image reaches.
+ */
+export declare const cropElement: (element: ExcalidrawImageElement, elementsMap: ElementsMap, transformHandle: TransformHandleDirection, naturalWidth: number, naturalHeight: number, pointerX: number, pointerY: number, { shouldMaintainAspectRatio, shouldResizeFromCenter, }?: {
+    shouldMaintainAspectRatio?: boolean;
+    shouldResizeFromCenter?: boolean;
+}) => {
     x: number;
     y: number;
     width: number;
     height: number;
-    crop: ImageCrop | null;
+    crop: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        naturalWidth: number;
+        naturalHeight: number;
+    } | null;
 };
+/**
+ * Uncrops the image on the handle's side (a corner's two); mirrored, on the
+ * opposite side(s) too.
+ */
+export declare const uncropElementSides: (element: ExcalidrawImageElement, elementsMap: ElementsMap, handle: TransformHandleDirection, mirrored?: boolean) => {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    crop: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        naturalWidth: number;
+        naturalHeight: number;
+    } | null;
+} | null;
 export declare const getUncroppedImageElement: (element: ExcalidrawImageElement, elementsMap: ElementsMap) => ExcalidrawImageElement;
 export declare const getUncroppedWidthAndHeight: (element: ExcalidrawImageElement) => {
     width: number;

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

@@ -1,11 +1,6 @@
-import type { AppClassProperties, AppState, InteractiveCanvasAppState } from "@excalidraw/excalidraw/types";
-import type { Mutable } from "@excalidraw/common/utility-types";
+import type { AppState, InteractiveCanvasAppState } from "@excalidraw/excalidraw/types";
 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;
-};
 /**
  * If the element's group is selected, don't render an individual
  * selection border around it.

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

@@ -36,6 +36,7 @@ export * from "./groups";
 export * from "./heading";
 export * from "./image";
 export * from "./linearElementEditor";
+export * from "./listMarker";
 export * from "./mutateElement";
 export * from "./newElement";
 export * from "./positionElementsOnGrid";

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

@@ -0,0 +1,34 @@
+import type { Scene } from "./Scene";
+import type { ExcalidrawElement, ExcalidrawTextElement } from "./types";
+/** a list marker advanced by duplication, to go back and forth */
+export type ListMarkerAdvance = {
+    elementId: ExcalidrawTextElement["id"];
+    prevOriginalText: string;
+    nextOriginalText: string;
+    /**
+     * where the item's text (after the marker and whitespace) starts in
+     * `nextOriginalText` (its length if there's none)
+     */
+    contentStart: number;
+    /** the label's container before the label (may have) grown it */
+    prevContainerSize: {
+        width: number;
+        height: number;
+    } | null;
+};
+/**
+ * Advances the list markers of the duplicated texts and labels, so that
+ * duplicating `1. foo` gives `2. foo` (and `1` gives `2`).
+ *
+ * Duplicating several list items at once continues the list from the
+ * highest of them: duplicating `1.`, `3.`, `5.` gives `6.`, `7.`, `8.` (only
+ * if they're just markers, i.e. without text).
+ *
+ * Only if nothing but list items (texts, or containers with list item labels)
+ * is duplicated.
+ */
+export declare const advanceDuplicatedListMarkers: (duplicatedElements: readonly ExcalidrawElement[], scene: Scene) => ListMarkerAdvance[];
+/**
+ * Sets the advanced list markers back (`"prev"`), or forth again (`"next"`).
+ */
+export declare const applyListMarkerAdvances: (advances: readonly ListMarkerAdvance[], direction: "prev" | "next", scene: Scene) => void;

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

@@ -62,7 +62,21 @@ export declare const newTextElement: (opts: {
     labelPosition?: ExcalidrawTextElement["labelPosition"];
     baseFontSize?: ExcalidrawTextElement["baseFontSize"];
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawTextElement>;
-export declare const refreshTextDimensions: (textElement: ExcalidrawTextElement, container: ExcalidrawTextContainer | null, elementsMap: ElementsMap, text?: string) => {
+export declare const refreshTextDimensions: (textElement: ExcalidrawTextElement, container: ExcalidrawTextContainer | null, elementsMap: ElementsMap, text?: string, 
+/**
+ * For a free text that grows with its content (`autoResize`): the widest
+ * it may grow to. Crossing it, the text stops growing and wraps at this
+ * width from then on (`autoResize: false`), anchored as its growth was. A
+ * text that is already wider keeps growing.
+ */
+maxWidth?: number) => {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    text: string;
+    autoResize: boolean;
+} | {
     x: number;
     y: number;
     width: number;

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

@@ -3,7 +3,7 @@ import type { PointerDownState } from "@excalidraw/excalidraw/types";
 import type { Scene } from "./Scene";
 import type { BoundingBox } from "./bounds";
 import type { MaybeTransformHandleType, TransformHandleDirection } from "./transformHandles";
-import type { ExcalidrawLinearElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, NonDeleted, ElementsMap } from "./types";
+import type { ExcalidrawLinearElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, NonDeleted, ExcalidrawElement, ElementsMap } from "./types";
 export declare const transformElements: (originalElements: PointerDownState["originalElements"], transformHandleType: MaybeTransformHandleType, selectedElements: readonly NonDeletedExcalidrawElement[], scene: Scene, shouldRotateWithDiscreteAngle: boolean, shouldResizeFromCenter: boolean, shouldMaintainAspectRatio: boolean, pointerX: number, pointerY: number, centerX: number, centerY: number) => boolean;
 export declare const rescalePointsInElement: (element: NonDeletedExcalidrawElement, width: number, height: number, normalizePoints: boolean) => {
     points: LocalPoint[];
@@ -21,6 +21,13 @@ export declare const resizeSingleElement: (nextWidth: number, nextHeight: number
     shouldResizeFromCenter?: boolean;
     shouldInformMutation?: boolean;
 }) => void;
+export declare const getNextSingleWidthAndHeightFromPointer: (latestElement: ExcalidrawElement, origElement: ExcalidrawElement, handleDirection: TransformHandleDirection, pointerX: number, pointerY: number, { shouldMaintainAspectRatio, shouldResizeFromCenter, }?: {
+    shouldMaintainAspectRatio?: boolean;
+    shouldResizeFromCenter?: boolean;
+}) => {
+    nextWidth: number;
+    nextHeight: number;
+};
 export declare const resizeMultipleElements: (selectedElements: readonly NonDeletedExcalidrawElement[], elementsMap: ElementsMap, handleDirection: TransformHandleDirection, scene: Scene, originalElementsMap: ElementsMap, { shouldMaintainAspectRatio, shouldResizeFromCenter, flipByX, flipByY, nextHeight, nextWidth, originalBoundingBox, }?: {
     nextWidth?: number;
     nextHeight?: number;

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

@@ -1,6 +1,6 @@
 import type { AppState, BoxSelectionMode, InteractiveCanvasAppState } from "@excalidraw/excalidraw/types";
-import { LinearElementEditor } from "./linearElementEditor";
 import type { ElementsMap, ElementsMapOrArray, ExcalidrawElement, NonDeleted, NonDeletedExcalidrawElement } from "./types";
+export declare const shouldIgnoreElementFromSelection: (element: ExcalidrawElement) => boolean;
 /**
  * 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
@@ -26,12 +26,6 @@ export declare const getTargetElements: (elements: ElementsMapOrArray, appState:
 export declare const makeNextSelectedElementIds: (nextSelectedElementIds: AppState["selectedElementIds"], prevState: Pick<AppState, "selectedElementIds">) => Readonly<{
     [id: string]: true;
 }>;
-export declare const getSelectionStateForElements: (targetElements: readonly NonDeletedExcalidrawElement[], allElements: readonly NonDeletedExcalidrawElement[], appState: AppState) => {
-    editingGroupId: AppState["editingGroupId"];
-    selectedElementIds: AppState["selectedElementIds"];
-    selectedGroupIds: AppState["selectedGroupIds"];
-    selectedLinearElement: LinearElementEditor | null;
-};
 /**
  * Returns editing or single-selected text element, if any.
  */

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

@@ -29,6 +29,13 @@ export declare const getBoundTextElementPosition: (container: ExcalidrawElement,
     x: number;
     y: number;
 } | undefined;
+/**
+ * Returns the text element with its accurate coords. An arrow label's
+ * position is derived from the arrow at render time rather than kept in
+ * sync on the element itself (see getBoundTextElementPosition), so
+ * consumers reading a label's coords directly must go through this helper.
+ */
+export declare const getTextElementWithAccuratePosition: <T extends ExcalidrawTextElement>(textElement: T, elementsMap: ElementsMap) => T;
 export declare const shouldAllowVerticalAlign: (selectedElements: readonly ExcalidrawElement[], elementsMap: ElementsMap) => boolean;
 export declare const suppportsHorizontalAlign: (selectedElements: readonly ExcalidrawElement[], elementsMap: ElementsMap) => boolean;
 declare const VALID_CONTAINER_TYPES: Set<string>;

package/dist/types/excalidraw/actions/actionAddToLibrary.d.ts

@@ -29,12 +29,20 @@ export declare const actionAddToLibrary: {
             boxSelectionMode: import("../types").BoxSelectionMode;
             bindingPreference: "enabled" | "disabled";
             isMidpointSnappingEnabled: boolean;
+            showHints: boolean;
             inputDevice: import("../types").InputDevice;
             suggestedBinding: {
                 element: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawBindableElement>;
                 midPoint?: import("@excalidraw/math").GlobalPoint;
             } | null;
-            hoveredArrowTextAnchor: {
+            textToolHover: {
+                type: "text";
+                elementId: import("@excalidraw/element/types").ExcalidrawElement["id"];
+            } | {
+                type: "container";
+                elementId: import("@excalidraw/element/types").ExcalidrawElement["id"];
+            } | {
+                type: "arrow";
                 elementId: import("@excalidraw/element/types").ExcalidrawArrowElement["id"];
                 anchor: "start" | "end" | "label";
             } | null;
@@ -198,12 +206,20 @@ export declare const actionAddToLibrary: {
             boxSelectionMode: import("../types").BoxSelectionMode;
             bindingPreference: "enabled" | "disabled";
             isMidpointSnappingEnabled: boolean;
+            showHints: boolean;
             inputDevice: import("../types").InputDevice;
             suggestedBinding: {
                 element: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawBindableElement>;
                 midPoint?: import("@excalidraw/math").GlobalPoint;
             } | null;
-            hoveredArrowTextAnchor: {
+            textToolHover: {
+                type: "text";
+                elementId: import("@excalidraw/element/types").ExcalidrawElement["id"];
+            } | {
+                type: "container";
+                elementId: import("@excalidraw/element/types").ExcalidrawElement["id"];
+            } | {
+                type: "arrow";
                 elementId: import("@excalidraw/element/types").ExcalidrawArrowElement["id"];
                 anchor: "start" | "end" | "label";
             } | null;
@@ -372,12 +388,20 @@ export declare const actionAddToLibrary: {
             boxSelectionMode: import("../types").BoxSelectionMode;
             bindingPreference: "enabled" | "disabled";
             isMidpointSnappingEnabled: boolean;
+            showHints: boolean;
             inputDevice: import("../types").InputDevice;
             suggestedBinding: {
                 element: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawBindableElement>;
                 midPoint?: import("@excalidraw/math").GlobalPoint;
             } | null;
-            hoveredArrowTextAnchor: {
+            textToolHover: {
+                type: "text";
+                elementId: import("@excalidraw/element/types").ExcalidrawElement["id"];
+            } | {
+                type: "container";
+                elementId: import("@excalidraw/element/types").ExcalidrawElement["id"];
+            } | {
+                type: "arrow";
                 elementId: import("@excalidraw/element/types").ExcalidrawArrowElement["id"];
                 anchor: "start" | "end" | "label";
             } | null;