@zsviczian/excalidraw 0.17.6-24 → 0.17.6-26

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

@@ -1,39 +1,39 @@
-import type { ExcalidrawLinearElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, NonDeleted, ExcalidrawElement, ElementsMap, SceneElementsMap } from "./types";
-import type { BoundingBox } from "./bounds";
-import type { MaybeTransformHandleType, TransformHandleDirection } from "./transformHandles";
-import type { PointerDownState } from "../types";
-import type Scene from "../scene/Scene";
-import { type LocalPoint } from "../../math";
-export declare const transformElements: (originalElements: PointerDownState["originalElements"], transformHandleType: MaybeTransformHandleType, selectedElements: readonly NonDeletedExcalidrawElement[], elementsMap: SceneElementsMap, 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[];
-} | {
-    points?: undefined;
-};
-export declare const measureFontSizeFromWidth: (element: NonDeleted<ExcalidrawTextElement>, elementsMap: ElementsMap, nextWidth: number) => {
-    size: number;
-} | null;
-export declare const getResizeOffsetXY: (transformHandleType: MaybeTransformHandleType, selectedElements: NonDeletedExcalidrawElement[], elementsMap: ElementsMap, x: number, y: number) => [number, number];
-export declare const getResizeArrowDirection: (transformHandleType: MaybeTransformHandleType, element: NonDeleted<ExcalidrawLinearElement>) => "origin" | "end";
-export declare const resizeSingleElement: (nextWidth: number, nextHeight: number, latestElement: ExcalidrawElement, origElement: ExcalidrawElement, elementsMap: ElementsMap, originalElementsMap: ElementsMap, handleDirection: TransformHandleDirection, { shouldInformMutation, shouldMaintainAspectRatio, shouldResizeFromCenter, }?: {
-    shouldMaintainAspectRatio?: boolean | undefined;
-    shouldResizeFromCenter?: boolean | undefined;
-    shouldInformMutation?: boolean | undefined;
-}) => void;
-export declare const getNextSingleWidthAndHeightFromPointer: (latestElement: ExcalidrawElement, origElement: ExcalidrawElement, elementsMap: ElementsMap, originalElementsMap: ElementsMap, handleDirection: TransformHandleDirection, pointerX: number, pointerY: number, { shouldMaintainAspectRatio, shouldResizeFromCenter, }?: {
-    shouldMaintainAspectRatio?: boolean | undefined;
-    shouldResizeFromCenter?: boolean | undefined;
-}) => {
-    nextWidth: number;
-    nextHeight: number;
-};
-export declare const resizeMultipleElements: (selectedElements: readonly NonDeletedExcalidrawElement[], elementsMap: ElementsMap, handleDirection: TransformHandleDirection, scene: Scene, { shouldMaintainAspectRatio, shouldResizeFromCenter, flipByX, flipByY, nextHeight, nextWidth, originalElementsMap, originalBoundingBox, }?: {
-    nextWidth?: number | undefined;
-    nextHeight?: number | undefined;
-    shouldMaintainAspectRatio?: boolean | undefined;
-    shouldResizeFromCenter?: boolean | undefined;
-    flipByX?: boolean | undefined;
-    flipByY?: boolean | undefined;
-    originalElementsMap?: ElementsMap | undefined;
-    originalBoundingBox?: BoundingBox | undefined;
-}) => void;
+import type { ExcalidrawLinearElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, NonDeleted, ExcalidrawElement, ElementsMap, SceneElementsMap } from "./types";
+import type { BoundingBox } from "./bounds";
+import type { MaybeTransformHandleType, TransformHandleDirection } from "./transformHandles";
+import type { PointerDownState } from "../types";
+import type Scene from "../scene/Scene";
+import { type LocalPoint } from "../../math";
+export declare const transformElements: (originalElements: PointerDownState["originalElements"], transformHandleType: MaybeTransformHandleType, selectedElements: readonly NonDeletedExcalidrawElement[], elementsMap: SceneElementsMap, 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[];
+} | {
+    points?: undefined;
+};
+export declare const measureFontSizeFromWidth: (element: NonDeleted<ExcalidrawTextElement>, elementsMap: ElementsMap, nextWidth: number) => {
+    size: number;
+} | null;
+export declare const getResizeOffsetXY: (transformHandleType: MaybeTransformHandleType, selectedElements: NonDeletedExcalidrawElement[], elementsMap: ElementsMap, x: number, y: number) => [number, number];
+export declare const getResizeArrowDirection: (transformHandleType: MaybeTransformHandleType, element: NonDeleted<ExcalidrawLinearElement>) => "origin" | "end";
+export declare const resizeSingleElement: (nextWidth: number, nextHeight: number, latestElement: ExcalidrawElement, origElement: ExcalidrawElement, elementsMap: ElementsMap, originalElementsMap: ElementsMap, handleDirection: TransformHandleDirection, { shouldInformMutation, shouldMaintainAspectRatio, shouldResizeFromCenter, }?: {
+    shouldMaintainAspectRatio?: boolean | undefined;
+    shouldResizeFromCenter?: boolean | undefined;
+    shouldInformMutation?: boolean | undefined;
+}) => void;
+export declare const getNextSingleWidthAndHeightFromPointer: (latestElement: ExcalidrawElement, origElement: ExcalidrawElement, elementsMap: ElementsMap, originalElementsMap: ElementsMap, handleDirection: TransformHandleDirection, pointerX: number, pointerY: number, { shouldMaintainAspectRatio, shouldResizeFromCenter, }?: {
+    shouldMaintainAspectRatio?: boolean | undefined;
+    shouldResizeFromCenter?: boolean | undefined;
+}) => {
+    nextWidth: number;
+    nextHeight: number;
+};
+export declare const resizeMultipleElements: (selectedElements: readonly NonDeletedExcalidrawElement[], elementsMap: ElementsMap, handleDirection: TransformHandleDirection, scene: Scene, { shouldMaintainAspectRatio, shouldResizeFromCenter, flipByX, flipByY, nextHeight, nextWidth, originalElementsMap, originalBoundingBox, }?: {
+    nextWidth?: number | undefined;
+    nextHeight?: number | undefined;
+    shouldMaintainAspectRatio?: boolean | undefined;
+    shouldResizeFromCenter?: boolean | undefined;
+    flipByX?: boolean | undefined;
+    flipByY?: boolean | undefined;
+    originalElementsMap?: ElementsMap | undefined;
+    originalBoundingBox?: BoundingBox | undefined;
+}) => void;

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

@@ -1,15 +1,15 @@
-import type { ExcalidrawElement, PointerType, NonDeletedExcalidrawElement, ElementsMap } from "./types";
-import type { MaybeTransformHandleType } from "./transformHandles";
-import type { AppState, Device, Zoom } from "../types";
-import type { Bounds } from "./bounds";
-import type { GlobalPoint, LocalPoint } from "../../math";
-export declare const resizeTest: <Point extends GlobalPoint | LocalPoint>(element: NonDeletedExcalidrawElement, elementsMap: ElementsMap, appState: AppState, x: number, y: number, zoom: Zoom, pointerType: PointerType, device: Device) => MaybeTransformHandleType;
-export declare const getElementWithTransformHandleType: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState, scenePointerX: number, scenePointerY: number, zoom: Zoom, pointerType: PointerType, elementsMap: ElementsMap, device: Device) => {
-    element: NonDeletedExcalidrawElement;
-    transformHandleType: MaybeTransformHandleType;
-} | null;
-export declare const getTransformHandleTypeFromCoords: <Point extends GlobalPoint | LocalPoint>([x1, y1, x2, y2]: Bounds, scenePointerX: number, scenePointerY: number, zoom: Zoom, pointerType: PointerType, device: Device) => MaybeTransformHandleType;
-export declare const getCursorForResizingElement: (resizingElement: {
-    element?: ExcalidrawElement;
-    transformHandleType: MaybeTransformHandleType;
-}) => string;
+import type { ExcalidrawElement, PointerType, NonDeletedExcalidrawElement, ElementsMap } from "./types";
+import type { MaybeTransformHandleType } from "./transformHandles";
+import type { AppState, Device, Zoom } from "../types";
+import type { Bounds } from "./bounds";
+import type { GlobalPoint, LocalPoint } from "../../math";
+export declare const resizeTest: <Point extends GlobalPoint | LocalPoint>(element: NonDeletedExcalidrawElement, elementsMap: ElementsMap, appState: AppState, x: number, y: number, zoom: Zoom, pointerType: PointerType, device: Device) => MaybeTransformHandleType;
+export declare const getElementWithTransformHandleType: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState, scenePointerX: number, scenePointerY: number, zoom: Zoom, pointerType: PointerType, elementsMap: ElementsMap, device: Device) => {
+    element: NonDeletedExcalidrawElement;
+    transformHandleType: MaybeTransformHandleType;
+} | null;
+export declare const getTransformHandleTypeFromCoords: <Point extends GlobalPoint | LocalPoint>([x1, y1, x2, y2]: Bounds, scenePointerX: number, scenePointerY: number, zoom: Zoom, pointerType: PointerType, device: Device) => MaybeTransformHandleType;
+export declare const getCursorForResizingElement: (resizingElement: {
+    element?: ExcalidrawElement;
+    transformHandleType: MaybeTransformHandleType;
+}) => string;

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

@@ -1,15 +1,15 @@
-import { type LocalPoint, type Vector } from "../../math";
-import type { AppState } from "../types";
-import type { ElementUpdate } from "./mutateElement";
-import type { ExcalidrawElbowArrowElement, NonDeletedSceneElementsMap, SceneElementsMap } from "./types";
-export declare const mutateElbowArrow: (arrow: ExcalidrawElbowArrowElement, elementsMap: NonDeletedSceneElementsMap | SceneElementsMap, nextPoints: readonly LocalPoint[], offset?: Vector, otherUpdates?: Omit<ElementUpdate<ExcalidrawElbowArrowElement>, "angle" | "x" | "y" | "width" | "height" | "elbowed" | "points">, options?: {
-    isDragging?: boolean;
-    informMutation?: boolean;
-    zoom?: AppState["zoom"];
-}) => void;
-export declare const updateElbowArrow: (arrow: ExcalidrawElbowArrowElement, elementsMap: NonDeletedSceneElementsMap | SceneElementsMap, nextPoints: readonly LocalPoint[], offset?: Vector, options?: {
-    isDragging?: boolean;
-    disableBinding?: boolean;
-    informMutation?: boolean;
-    zoom?: AppState["zoom"];
-}) => ElementUpdate<ExcalidrawElbowArrowElement> | null;
+import { type LocalPoint, type Vector } from "../../math";
+import type { AppState } from "../types";
+import type { ElementUpdate } from "./mutateElement";
+import type { ExcalidrawElbowArrowElement, NonDeletedSceneElementsMap, SceneElementsMap } from "./types";
+export declare const mutateElbowArrow: (arrow: ExcalidrawElbowArrowElement, elementsMap: NonDeletedSceneElementsMap | SceneElementsMap, nextPoints: readonly LocalPoint[], offset?: Vector, otherUpdates?: Omit<ElementUpdate<ExcalidrawElbowArrowElement>, "angle" | "x" | "y" | "width" | "height" | "elbowed" | "points">, options?: {
+    isDragging?: boolean;
+    informMutation?: boolean;
+    zoom?: AppState["zoom"];
+}) => void;
+export declare const updateElbowArrow: (arrow: ExcalidrawElbowArrowElement, elementsMap: NonDeletedSceneElementsMap | SceneElementsMap, nextPoints: readonly LocalPoint[], offset?: Vector, options?: {
+    isDragging?: boolean;
+    disableBinding?: boolean;
+    informMutation?: boolean;
+    zoom?: AppState["zoom"];
+}) => ElementUpdate<ExcalidrawElbowArrowElement> | null;

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

@@ -1,3 +1,3 @@
-import type { NonDeletedExcalidrawElement } from "./types";
-import type { UIAppState } from "../types";
-export declare const showSelectedShapeActions: (appState: UIAppState, elements: readonly NonDeletedExcalidrawElement[]) => boolean;
+import type { NonDeletedExcalidrawElement } from "./types";
+import type { UIAppState } from "../types";
+export declare const showSelectedShapeActions: (appState: UIAppState, elements: readonly NonDeletedExcalidrawElement[]) => boolean;

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

@@ -1,35 +1,35 @@
-import type { ElementsMap, ExcalidrawElement } from "./types";
-import type { AppState, Offsets, Zoom } from "../types";
-export declare const isInvisiblySmallElement: (element: ExcalidrawElement) => boolean;
-export declare const isElementInViewport: (element: ExcalidrawElement, width: number, height: number, viewTransformations: {
-    zoom: Zoom;
-    offsetLeft: number;
-    offsetTop: number;
-    scrollX: number;
-    scrollY: number;
-}, elementsMap: ElementsMap) => boolean;
-export declare const isElementCompletelyInViewport: (elements: ExcalidrawElement[], width: number, height: number, viewTransformations: {
-    zoom: Zoom;
-    offsetLeft: number;
-    offsetTop: number;
-    scrollX: number;
-    scrollY: number;
-}, elementsMap: ElementsMap, padding?: Offsets) => boolean;
-/**
- * Makes a perfect shape or diagonal/horizontal/vertical line
- */
-export declare const getPerfectElementSize: (elementType: AppState["activeTool"]["type"], width: number, height: number) => {
-    width: number;
-    height: number;
-};
-export declare const getLockedLinearCursorAlignSize: (originX: number, originY: number, x: number, y: number) => {
-    width: number;
-    height: number;
-};
-export declare const resizePerfectLineForNWHandler: (element: ExcalidrawElement, x: number, y: number) => void;
-export declare const getNormalizedDimensions: (element: Pick<ExcalidrawElement, "width" | "height" | "x" | "y">) => {
-    width: ExcalidrawElement["width"];
-    height: ExcalidrawElement["height"];
-    x: ExcalidrawElement["x"];
-    y: ExcalidrawElement["y"];
-};
+import type { ElementsMap, ExcalidrawElement } from "./types";
+import type { AppState, Offsets, Zoom } from "../types";
+export declare const isInvisiblySmallElement: (element: ExcalidrawElement) => boolean;
+export declare const isElementInViewport: (element: ExcalidrawElement, width: number, height: number, viewTransformations: {
+    zoom: Zoom;
+    offsetLeft: number;
+    offsetTop: number;
+    scrollX: number;
+    scrollY: number;
+}, elementsMap: ElementsMap) => boolean;
+export declare const isElementCompletelyInViewport: (elements: ExcalidrawElement[], width: number, height: number, viewTransformations: {
+    zoom: Zoom;
+    offsetLeft: number;
+    offsetTop: number;
+    scrollX: number;
+    scrollY: number;
+}, elementsMap: ElementsMap, padding?: Offsets) => boolean;
+/**
+ * Makes a perfect shape or diagonal/horizontal/vertical line
+ */
+export declare const getPerfectElementSize: (elementType: AppState["activeTool"]["type"], width: number, height: number) => {
+    width: number;
+    height: number;
+};
+export declare const getLockedLinearCursorAlignSize: (originX: number, originY: number, x: number, y: number) => {
+    width: number;
+    height: number;
+};
+export declare const resizePerfectLineForNWHandler: (element: ExcalidrawElement, x: number, y: number) => void;
+export declare const getNormalizedDimensions: (element: Pick<ExcalidrawElement, "width" | "height" | "x" | "y">) => {
+    width: ExcalidrawElement["width"];
+    height: ExcalidrawElement["height"];
+    x: ExcalidrawElement["x"];
+    y: ExcalidrawElement["y"];
+};

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

@@ -1,2 +1,2 @@
-import type { ExcalidrawElement } from "./types";
-export declare const normalizeElementOrder: (elements: readonly ExcalidrawElement[]) => readonly ExcalidrawElement[];
+import type { ExcalidrawElement } from "./types";
+export declare const normalizeElementOrder: (elements: readonly ExcalidrawElement[]) => readonly ExcalidrawElement[];

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

@@ -1,83 +1,83 @@
-import type { ElementsMap, ExcalidrawElement, ExcalidrawElementType, ExcalidrawTextContainer, ExcalidrawTextElement, ExcalidrawTextElementWithContainer, FontString, NonDeletedExcalidrawElement } from "./types";
-import type { MaybeTransformHandleType } from "./transformHandles";
-import type { AppState } from "../types";
-import type { ExtractSetType } from "../utility-types";
-export declare const normalizeText: (text: string) => string;
-export declare const redrawTextBoundingBox: (textElement: ExcalidrawTextElement, container: ExcalidrawElement | null, elementsMap: ElementsMap, informMutation?: boolean) => void;
-export declare const bindTextToShapeAfterDuplication: (newElements: ExcalidrawElement[], oldElements: ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
-export declare const handleBindTextResize: (container: NonDeletedExcalidrawElement, elementsMap: ElementsMap, transformHandleType: MaybeTransformHandleType, shouldMaintainAspectRatio?: boolean) => void;
-export declare const computeBoundTextPosition: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElementWithContainer, elementsMap: ElementsMap) => {
-    x: number;
-    y: number;
-};
-export declare const measureText: (text: string, font: FontString, lineHeight: ExcalidrawTextElement["lineHeight"], forceAdvanceWidth?: true) => {
-    width: number;
-    height: number;
-};
-/**
- * To get unitless line-height (if unknown) we can calculate it by dividing
- * height-per-line by fontSize.
- */
-export declare const detectLineHeight: (textElement: ExcalidrawTextElement) => number & {
-    _brand: "unitlessLineHeight";
-};
-/**
- * We calculate the line height from the font size and the unitless line height,
- * aligning with the W3C spec.
- */
-export declare const getLineHeightInPx: (fontSize: ExcalidrawTextElement["fontSize"], lineHeight: ExcalidrawTextElement["lineHeight"]) => number;
-export declare const getApproxMinLineHeight: (fontSize: ExcalidrawTextElement["fontSize"], lineHeight: ExcalidrawTextElement["lineHeight"]) => number;
-/**
- * @param forceAdvanceWidth use to force retrieve the "advance width" ~ `metrics.width`, instead of the actual boundind box width.
- *
- * > The advance width is the distance between the glyph's initial pen position and the next glyph's initial pen position.
- *
- * We need to use the advance width as that's the closest thing to the browser wrapping algo, hence using it for:
- * - text wrapping
- * - wysiwyg editor (+padding)
- *
- * Everything else should be based on the actual bounding box width.
- *
- * `Math.ceil` of the final width adds additional buffer which stabilizes slight wrapping incosistencies.
- */
-export declare const getLineWidth: (text: string, font: FontString, forceAdvanceWidth?: true) => number;
-export declare const getTextWidth: (text: string, font: FontString, forceAdvanceWidth?: true) => number;
-export declare const getTextHeight: (text: string, fontSize: number, lineHeight: ExcalidrawTextElement["lineHeight"]) => number;
-export declare const charWidth: {
-    calculate: (char: string, font: FontString) => number;
-    getCache: (font: FontString) => number[];
-    clearCache: (font: FontString) => void;
-};
-export declare const getApproxMinLineWidth: (font: FontString, lineHeight: ExcalidrawTextElement["lineHeight"]) => number;
-export declare const getMinCharWidth: (font: FontString) => number;
-export declare const getMaxCharWidth: (font: FontString) => number;
-export declare const getBoundTextElementId: (container: ExcalidrawElement | null) => string | null;
-export declare const getBoundTextElement: (element: ExcalidrawElement | null, elementsMap: ElementsMap) => ExcalidrawTextElementWithContainer | null;
-export declare const getContainerElement: (element: ExcalidrawTextElement | null, elementsMap: ElementsMap) => ExcalidrawTextContainer | null;
-export declare const getContainerCenter: (container: ExcalidrawElement, appState: AppState, elementsMap: ElementsMap) => {
-    x: number;
-    y: number;
-};
-export declare const getContainerCoords: (container: NonDeletedExcalidrawElement) => {
-    x: number;
-    y: number;
-};
-export declare const getTextElementAngle: (textElement: ExcalidrawTextElement, container: ExcalidrawTextContainer | null) => import("../../math").Radians;
-export declare const getBoundTextElementPosition: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElementWithContainer, elementsMap: ElementsMap) => {
-    x: number;
-    y: number;
-} | undefined;
-export declare const shouldAllowVerticalAlign: (selectedElements: NonDeletedExcalidrawElement[], elementsMap: ElementsMap) => boolean;
-export declare const suppportsHorizontalAlign: (selectedElements: NonDeletedExcalidrawElement[], elementsMap: ElementsMap) => boolean;
-declare const VALID_CONTAINER_TYPES: Set<string>;
-export declare const isValidTextContainer: (element: {
-    type: ExcalidrawElementType;
-}) => boolean;
-export declare const computeContainerDimensionForBoundText: (dimension: number, containerType: ExtractSetType<typeof VALID_CONTAINER_TYPES>, legacy?: boolean) => number;
-export declare const getBoundTextMaxWidth: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElement | null) => number;
-export declare const getBoundTextMaxHeight: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElementWithContainer) => number;
-export declare const isMeasureTextSupported: () => boolean;
-export declare const getMinTextElementWidth: (font: FontString, lineHeight: ExcalidrawTextElement["lineHeight"]) => number;
-/** retrieves text from text elements and concatenates to a single string */
-export declare const getTextFromElements: (elements: readonly ExcalidrawElement[], separator?: string) => string;
-export {};
+import type { ElementsMap, ExcalidrawElement, ExcalidrawElementType, ExcalidrawTextContainer, ExcalidrawTextElement, ExcalidrawTextElementWithContainer, FontString, NonDeletedExcalidrawElement } from "./types";
+import type { MaybeTransformHandleType } from "./transformHandles";
+import type { AppState } from "../types";
+import type { ExtractSetType } from "../utility-types";
+export declare const normalizeText: (text: string) => string;
+export declare const redrawTextBoundingBox: (textElement: ExcalidrawTextElement, container: ExcalidrawElement | null, elementsMap: ElementsMap, informMutation?: boolean) => void;
+export declare const bindTextToShapeAfterDuplication: (newElements: ExcalidrawElement[], oldElements: ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
+export declare const handleBindTextResize: (container: NonDeletedExcalidrawElement, elementsMap: ElementsMap, transformHandleType: MaybeTransformHandleType, shouldMaintainAspectRatio?: boolean) => void;
+export declare const computeBoundTextPosition: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElementWithContainer, elementsMap: ElementsMap) => {
+    x: number;
+    y: number;
+};
+export declare const measureText: (text: string, font: FontString, lineHeight: ExcalidrawTextElement["lineHeight"], forceAdvanceWidth?: true) => {
+    width: number;
+    height: number;
+};
+/**
+ * To get unitless line-height (if unknown) we can calculate it by dividing
+ * height-per-line by fontSize.
+ */
+export declare const detectLineHeight: (textElement: ExcalidrawTextElement) => number & {
+    _brand: "unitlessLineHeight";
+};
+/**
+ * We calculate the line height from the font size and the unitless line height,
+ * aligning with the W3C spec.
+ */
+export declare const getLineHeightInPx: (fontSize: ExcalidrawTextElement["fontSize"], lineHeight: ExcalidrawTextElement["lineHeight"]) => number;
+export declare const getApproxMinLineHeight: (fontSize: ExcalidrawTextElement["fontSize"], lineHeight: ExcalidrawTextElement["lineHeight"]) => number;
+/**
+ * @param forceAdvanceWidth use to force retrieve the "advance width" ~ `metrics.width`, instead of the actual boundind box width.
+ *
+ * > The advance width is the distance between the glyph's initial pen position and the next glyph's initial pen position.
+ *
+ * We need to use the advance width as that's the closest thing to the browser wrapping algo, hence using it for:
+ * - text wrapping
+ * - wysiwyg editor (+padding)
+ *
+ * Everything else should be based on the actual bounding box width.
+ *
+ * `Math.ceil` of the final width adds additional buffer which stabilizes slight wrapping incosistencies.
+ */
+export declare const getLineWidth: (text: string, font: FontString, forceAdvanceWidth?: true) => number;
+export declare const getTextWidth: (text: string, font: FontString, forceAdvanceWidth?: true) => number;
+export declare const getTextHeight: (text: string, fontSize: number, lineHeight: ExcalidrawTextElement["lineHeight"]) => number;
+export declare const charWidth: {
+    calculate: (char: string, font: FontString) => number;
+    getCache: (font: FontString) => number[];
+    clearCache: (font: FontString) => void;
+};
+export declare const getApproxMinLineWidth: (font: FontString, lineHeight: ExcalidrawTextElement["lineHeight"]) => number;
+export declare const getMinCharWidth: (font: FontString) => number;
+export declare const getMaxCharWidth: (font: FontString) => number;
+export declare const getBoundTextElementId: (container: ExcalidrawElement | null) => string | null;
+export declare const getBoundTextElement: (element: ExcalidrawElement | null, elementsMap: ElementsMap) => ExcalidrawTextElementWithContainer | null;
+export declare const getContainerElement: (element: ExcalidrawTextElement | null, elementsMap: ElementsMap) => ExcalidrawTextContainer | null;
+export declare const getContainerCenter: (container: ExcalidrawElement, appState: AppState, elementsMap: ElementsMap) => {
+    x: number;
+    y: number;
+};
+export declare const getContainerCoords: (container: NonDeletedExcalidrawElement) => {
+    x: number;
+    y: number;
+};
+export declare const getTextElementAngle: (textElement: ExcalidrawTextElement, container: ExcalidrawTextContainer | null) => import("../../math").Radians;
+export declare const getBoundTextElementPosition: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElementWithContainer, elementsMap: ElementsMap) => {
+    x: number;
+    y: number;
+} | undefined;
+export declare const shouldAllowVerticalAlign: (selectedElements: NonDeletedExcalidrawElement[], elementsMap: ElementsMap) => boolean;
+export declare const suppportsHorizontalAlign: (selectedElements: NonDeletedExcalidrawElement[], elementsMap: ElementsMap) => boolean;
+declare const VALID_CONTAINER_TYPES: Set<string>;
+export declare const isValidTextContainer: (element: {
+    type: ExcalidrawElementType;
+}) => boolean;
+export declare const computeContainerDimensionForBoundText: (dimension: number, containerType: ExtractSetType<typeof VALID_CONTAINER_TYPES>, legacy?: boolean) => number;
+export declare const getBoundTextMaxWidth: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElement | null) => number;
+export declare const getBoundTextMaxHeight: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElementWithContainer) => number;
+export declare const isMeasureTextSupported: () => boolean;
+export declare const getMinTextElementWidth: (font: FontString, lineHeight: ExcalidrawTextElement["lineHeight"]) => number;
+/** retrieves text from text elements and concatenates to a single string */
+export declare const getTextFromElements: (elements: readonly ExcalidrawElement[], separator?: string) => string;
+export {};

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

@@ -1,13 +1,13 @@
-import type { FontString } from "./types";
-/**
- * Test if a given text contains any CJK characters (including symbols, punctuation, etc,).
- */
-export declare const containsCJK: (text: string) => boolean;
-/**
- * Breaks the line into the tokens based on the found line break opporutnities.
- */
-export declare const parseTokens: (line: string) => string[];
-/**
- * Wraps the original text into the lines based on the given width.
- */
-export declare const wrapText: (text: string, font: FontString, maxWidth: number) => string;
+import type { FontString } from "./types";
+/**
+ * Test if a given text contains any CJK characters (including symbols, punctuation, etc,).
+ */
+export declare const containsCJK: (text: string) => boolean;
+/**
+ * Breaks the line into the tokens based on the found line break opporutnities.
+ */
+export declare const parseTokens: (line: string) => string[];
+/**
+ * Wraps the original text into the lines based on the given width.
+ */
+export declare const wrapText: (text: string, font: FontString, maxWidth: number) => string;

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

@@ -1,22 +1,22 @@
-import type { ExcalidrawElement, ExcalidrawTextElement } from "./types";
-import type App from "../components/App";
-export declare const textWysiwyg: ({ id, onChange, onSubmit, getViewportCoords, element, canvas, excalidrawContainer, app, autoSelect, }: {
-    id: ExcalidrawElement["id"];
-    /**
-     * textWysiwyg only deals with `originalText`
-     *
-     * Note: `text`, which can be wrapped and therefore different from `originalText`,
-     *       is derived from `originalText`
-     */
-    onChange?: ((nextOriginalText: string) => void) | undefined;
-    onSubmit: (data: {
-        viaKeyboard: boolean;
-        nextOriginalText: string;
-    }) => void;
-    getViewportCoords: (x: number, y: number) => [number, number];
-    element: ExcalidrawTextElement;
-    canvas: HTMLCanvasElement;
-    excalidrawContainer: HTMLDivElement | null;
-    app: App;
-    autoSelect?: boolean | undefined;
-}) => void;
+import type { ExcalidrawElement, ExcalidrawTextElement } from "./types";
+import type App from "../components/App";
+export declare const textWysiwyg: ({ id, onChange, onSubmit, getViewportCoords, element, canvas, excalidrawContainer, app, autoSelect, }: {
+    id: ExcalidrawElement["id"];
+    /**
+     * textWysiwyg only deals with `originalText`
+     *
+     * Note: `text`, which can be wrapped and therefore different from `originalText`,
+     *       is derived from `originalText`
+     */
+    onChange?: ((nextOriginalText: string) => void) | undefined;
+    onSubmit: (data: {
+        viaKeyboard: boolean;
+        nextOriginalText: string;
+    }) => void;
+    getViewportCoords: (x: number, y: number) => [number, number];
+    element: ExcalidrawTextElement;
+    canvas: HTMLCanvasElement;
+    excalidrawContainer: HTMLDivElement | null;
+    app: App;
+    autoSelect?: boolean | undefined;
+}) => void;

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

@@ -1,55 +1,55 @@
-import type { ElementsMap, ExcalidrawElement, NonDeletedExcalidrawElement, PointerType } from "./types";
-import type { Bounds } from "./bounds";
-import type { Device, InteractiveCanvasAppState, Zoom } from "../types";
-import type { Radians } from "../../math";
-export type TransformHandleDirection = "n" | "s" | "w" | "e" | "nw" | "ne" | "sw" | "se";
-export type TransformHandleType = TransformHandleDirection | "rotation";
-export type TransformHandle = Bounds;
-export type TransformHandles = Partial<{
-    [T in TransformHandleType]: TransformHandle;
-}>;
-export type MaybeTransformHandleType = TransformHandleType | false;
-export declare const DEFAULT_OMIT_SIDES: {
-    e: boolean;
-    s: boolean;
-    n: boolean;
-    w: boolean;
-};
-export declare const OMIT_SIDES_FOR_MULTIPLE_ELEMENTS: {
-    e: boolean;
-    s: boolean;
-    n: boolean;
-    w: boolean;
-};
-export declare const OMIT_SIDES_FOR_FRAME: {
-    e: boolean;
-    s: boolean;
-    n: boolean;
-    w: boolean;
-    rotation: boolean;
-};
-export declare const canResizeFromSides: (device: Device) => boolean;
-export declare const getOmitSidesForDevice: (device: Device) => {};
-export declare const getTransformHandlesFromCoords: ([x1, y1, x2, y2, cx, cy]: [number, number, number, number, number, number], angle: Radians, zoom: Zoom, pointerType: PointerType, omitSides?: {
-    e?: boolean | undefined;
-    s?: boolean | undefined;
-    w?: boolean | undefined;
-    n?: boolean | undefined;
-    nw?: boolean | undefined;
-    ne?: boolean | undefined;
-    sw?: boolean | undefined;
-    se?: boolean | undefined;
-    rotation?: boolean | undefined;
-}, margin?: number, spacing?: number) => TransformHandles;
-export declare const getTransformHandles: (element: ExcalidrawElement, zoom: Zoom, elementsMap: ElementsMap, pointerType?: PointerType, omitSides?: {
-    e?: boolean | undefined;
-    s?: boolean | undefined;
-    w?: boolean | undefined;
-    n?: boolean | undefined;
-    nw?: boolean | undefined;
-    ne?: boolean | undefined;
-    sw?: boolean | undefined;
-    se?: boolean | undefined;
-    rotation?: boolean | undefined;
-}) => TransformHandles;
-export declare const shouldShowBoundingBox: (elements: readonly NonDeletedExcalidrawElement[], appState: InteractiveCanvasAppState) => boolean;
+import type { ElementsMap, ExcalidrawElement, NonDeletedExcalidrawElement, PointerType } from "./types";
+import type { Bounds } from "./bounds";
+import type { Device, InteractiveCanvasAppState, Zoom } from "../types";
+import type { Radians } from "../../math";
+export type TransformHandleDirection = "n" | "s" | "w" | "e" | "nw" | "ne" | "sw" | "se";
+export type TransformHandleType = TransformHandleDirection | "rotation";
+export type TransformHandle = Bounds;
+export type TransformHandles = Partial<{
+    [T in TransformHandleType]: TransformHandle;
+}>;
+export type MaybeTransformHandleType = TransformHandleType | false;
+export declare const DEFAULT_OMIT_SIDES: {
+    e: boolean;
+    s: boolean;
+    n: boolean;
+    w: boolean;
+};
+export declare const OMIT_SIDES_FOR_MULTIPLE_ELEMENTS: {
+    e: boolean;
+    s: boolean;
+    n: boolean;
+    w: boolean;
+};
+export declare const OMIT_SIDES_FOR_FRAME: {
+    e: boolean;
+    s: boolean;
+    n: boolean;
+    w: boolean;
+    rotation: boolean;
+};
+export declare const canResizeFromSides: (device: Device) => boolean;
+export declare const getOmitSidesForDevice: (device: Device) => {};
+export declare const getTransformHandlesFromCoords: ([x1, y1, x2, y2, cx, cy]: [number, number, number, number, number, number], angle: Radians, zoom: Zoom, pointerType: PointerType, omitSides?: {
+    e?: boolean | undefined;
+    s?: boolean | undefined;
+    w?: boolean | undefined;
+    n?: boolean | undefined;
+    nw?: boolean | undefined;
+    ne?: boolean | undefined;
+    sw?: boolean | undefined;
+    se?: boolean | undefined;
+    rotation?: boolean | undefined;
+}, margin?: number, spacing?: number) => TransformHandles;
+export declare const getTransformHandles: (element: ExcalidrawElement, zoom: Zoom, elementsMap: ElementsMap, pointerType?: PointerType, omitSides?: {
+    e?: boolean | undefined;
+    s?: boolean | undefined;
+    w?: boolean | undefined;
+    n?: boolean | undefined;
+    nw?: boolean | undefined;
+    ne?: boolean | undefined;
+    sw?: boolean | undefined;
+    se?: boolean | undefined;
+    rotation?: boolean | undefined;
+}) => TransformHandles;
+export declare const shouldShowBoundingBox: (elements: readonly NonDeletedExcalidrawElement[], appState: InteractiveCanvasAppState) => boolean;