@excalidraw/common 0.18.0-4ce38fb → 0.18.0-4ce8305

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

@@ -16,4 +16,9 @@ export declare const updateElbowArrowPoints: (arrow: Readonly<ExcalidrawElbowArr
     isBindingEnabled?: boolean;
     isMidpointSnappingEnabled?: boolean;
 }) => ElementUpdate<ExcalidrawElbowArrowElement>;
+/**
+ * The update routing an elbow arrow again where it is, e.g. once its
+ * arrowheads change, as its route makes room for them
+ */
+export declare const updateElbowArrowRoute: <T extends ExcalidrawElbowArrowElement>(arrow: Readonly<T>, elementsMap: NonDeletedSceneElementsMap) => ElementUpdate<T>;
 export declare const validateElbowPoints: <P extends GlobalPoint | LocalPoint>(points: readonly P[], tolerance?: number) => boolean;

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

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

package/dist/types/element/src/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/image.d.ts

@@ -1,12 +1,15 @@
 import type { AppClassProperties, DataURL, BinaryFiles } from "@excalidraw/excalidraw/types";
 import type { ExcalidrawElement, FileId, InitializedExcalidrawImageElement } from "./types";
-export declare const loadHTMLImageElement: (dataURL: DataURL) => Promise<HTMLImageElement>;
+export declare const loadHTMLImageElement: (dataURL: DataURL, createImage?: () => HTMLImageElement) => 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, }: {
+export declare const updateImageCache: ({ fileIds, files, imageCache, createImage, }: {
     fileIds: FileId[];
     files: BinaryFiles;
     imageCache: AppClassProperties["imageCache"];
+    /** creates images in the owner window so cross-document scenes keep
+     * runtime ownership of their HTMLImageElements */
+    createImage?: () => HTMLImageElement;
 }) => Promise<{
     imageCache: Map<FileId, {
         image: HTMLImageElement | Promise<HTMLImageElement>;

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

@@ -41,6 +41,7 @@ export * from "./mutateElement";
 export * from "./newElement";
 export * from "./positionElementsOnGrid";
 export * from "./renderElement";
+export * from "./renderEnvironment";
 export * from "./resizeElements";
 export * from "./resizeTest";
 export * from "./Scene";

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

@@ -103,10 +103,10 @@ export declare class LinearElementEditor {
     static movePoints(element: NonDeleted<ExcalidrawLinearElement>, scene: Scene, pointUpdates: PointsPositionUpdates, otherUpdates?: {
         startBinding?: FixedPointBinding | null;
         endBinding?: FixedPointBinding | null;
-        moveMidPointsWithElement?: boolean | null;
     }, options?: {
         isBindingEnabled?: boolean;
         isMidpointSnappingEnabled?: boolean;
+        moveMidPointsWithElement?: boolean;
     }): void;
     static shouldAddMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, appState: AppState, elementsMap: ElementsMap): boolean;
     static addMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, app: AppClassProperties, snapToGrid: boolean, scene: Scene): {
@@ -122,6 +122,9 @@ export declare class LinearElementEditor {
      */
     static getBoundTextElementCenter: (element: ExcalidrawLinearElement, elementsMap: ElementsMap) => GlobalPoint;
     static handleBoundTextDragging(linearElementEditor: LinearElementEditor, scene: Scene, pointerX: number, pointerY: number): LinearElementEditor | null;
+    static getPathLength(element: ExcalidrawLinearElement, elementsMap: ElementsMap): number;
+    /** the path parameter (0-1) of the point on the path closest to `point` */
+    static getPathParameterAtPoint(element: ExcalidrawLinearElement, point: GlobalPoint, elementsMap: ElementsMap): number | null;
     static getPointAtPathParameter(container: ExcalidrawLinearElement, pathParameter: number, elementsMap: ElementsMap): GlobalPoint | null;
     static getBoundTextElementPosition: (element: ExcalidrawLinearElement, boundTextElement: ExcalidrawTextElementWithContainer, elementsMap: ElementsMap) => {
         x: number;

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

@@ -1,3 +1,4 @@
+import type { RenderEnvironment } from "./renderEnvironment";
 import type { Scene } from "./Scene";
 import type { ExcalidrawElement, ExcalidrawTextElement } from "./types";
 /** a list marker advanced by duplication, to go back and forth */
@@ -27,8 +28,12 @@ export type ListMarkerAdvance = {
  * 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[];
+export declare const advanceDuplicatedListMarkers: (duplicatedElements: readonly ExcalidrawElement[], scene: Scene, 
+/** measures the re-numbered texts */
+renderEnvironment?: RenderEnvironment) => 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;
+export declare const applyListMarkerAdvances: (advances: readonly ListMarkerAdvance[], direction: "prev" | "next", scene: Scene, 
+/** measures the re-numbered texts */
+renderEnvironment?: RenderEnvironment) => void;

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

@@ -1,4 +1,5 @@
 import type { MarkOptional } from "@excalidraw/common/utility-types";
+import type { RenderEnvironment } from "./renderEnvironment";
 import type { ExcalidrawImageElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawGenericElement, NonDeleted, TextAlign, VerticalAlign, Arrowhead, ExcalidrawFreeDrawElement, FontFamilyValues, ExcalidrawTextContainer, ExcalidrawFrameElement, ExcalidrawEmbeddableElement, ExcalidrawMagicFrameElement, ExcalidrawIframeElement, ElementsMap, ExcalidrawArrowElement, ExcalidrawElbowArrowElement, ExcalidrawLineElement, ExcalidrawStickyNoteElement } from "./types";
 export type ElementConstructorOpts = MarkOptional<Omit<ExcalidrawGenericElement, "id" | "type" | "isDeleted" | "updated">, "width" | "height" | "angle" | "groupIds" | "frameId" | "index" | "boundElements" | "seed" | "version" | "versionNonce" | "link" | "strokeStyle" | "fillStyle" | "strokeColor" | "backgroundColor" | "roughness" | "strokeWidth" | "roundness" | "locked" | "opacity" | "customData" | "created">;
 export declare const newElement: (opts: {
@@ -61,6 +62,7 @@ export declare const newTextElement: (opts: {
     autoResize?: ExcalidrawTextElement["autoResize"];
     labelPosition?: ExcalidrawTextElement["labelPosition"];
     baseFontSize?: ExcalidrawTextElement["baseFontSize"];
+    renderEnvironment?: RenderEnvironment;
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawTextElement>;
 export declare const refreshTextDimensions: (textElement: ExcalidrawTextElement, container: ExcalidrawTextContainer | null, elementsMap: ElementsMap, text?: string, 
 /**
@@ -69,7 +71,7 @@ export declare const refreshTextDimensions: (textElement: ExcalidrawTextElement,
  * width from then on (`autoResize: false`), anchored as its growth was. A
  * text that is already wider keeps growing.
  */
-maxWidth?: number) => {
+maxWidth?: number, renderEnvironment?: RenderEnvironment) => {
     x: number;
     y: number;
     width: number;

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

@@ -1,6 +1,7 @@
 import { type GlobalPoint } from "@excalidraw/math";
 import type { AppState, StaticCanvasAppState, InteractiveCanvasAppState, ElementRenderOverrides } from "@excalidraw/excalidraw/types";
 import type { StaticCanvasRenderConfig, RenderableElementsMap, InteractiveCanvasRenderConfig } from "@excalidraw/excalidraw/scene/types";
+import type { RenderEnvironment } from "./renderEnvironment";
 import type { ExcalidrawElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, ExcalidrawFreeDrawElement, ExcalidrawImageElement, NonDeletedSceneElementsMap, ElementsMap } from "./types";
 import type { RoughCanvas } from "roughjs/bin/canvas";
 export type RenderPositionOffset = Readonly<{
@@ -22,6 +23,9 @@ export interface ExcalidrawElementWithCanvas {
     canvas: HTMLCanvasElement;
     theme: AppState["theme"];
     scale: number;
+    /** backing-store scale the bitmap was rasterized at, see StaticCanvasRenderConfig["scale"] */
+    deviceScale: number;
+    environment: RenderEnvironment;
     zoomValue: AppState["zoom"]["value"];
     canvasOffsetX: number;
     canvasOffsetY: number;
@@ -29,6 +33,12 @@ export interface ExcalidrawElementWithCanvas {
     containingFrameOpacity: number;
 }
 export declare const DEFAULT_LINK_SIZE = 14;
+/**
+ * `save()`s the context around `draw`, restoring it even when `draw` throws:
+ * the scene renderer logs a failing element and carries on, and the element
+ * mustn't leave its transforms and clips behind for the next one.
+ */
+export declare const withSavedContext: (context: CanvasRenderingContext2D, draw: () => void) => void;
 export declare const elementWithCanvasCache: WeakMap<ExcalidrawElement, ExcalidrawElementWithCanvas>;
 export declare const renderSelectionElement: (element: NonDeletedExcalidrawElement, context: CanvasRenderingContext2D, appState: InteractiveCanvasAppState, selectionColor: InteractiveCanvasRenderConfig["selectionColor"]) => void;
 export declare const renderElement: (element: NonDeletedExcalidrawElement, elementsMap: RenderableElementsMap, allElementsMap: NonDeletedSceneElementsMap, rc: RoughCanvas, context: CanvasRenderingContext2D, renderConfig: StaticCanvasRenderConfig, appState: StaticCanvasAppState | InteractiveCanvasAppState, renderState?: Readonly<{

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

@@ -0,0 +1,66 @@
+/**
+ * Host environment used by the renderer and export pipeline.
+ *
+ * The default is the browser's. An explicit environment (see
+ * `StaticCanvasRenderConfig["renderEnvironment"]`) scopes canvas and image
+ * creation to one render target -- e.g. the editor's owner window, so that
+ * one process can host editors in multiple realms (popouts, multi-tenant
+ * embeds), or an export running where `document`/`window` don't exist (Node
+ * with `node-canvas` / `@napi-rs/canvas`, passed in `config.environment`).
+ * There is deliberately no process-wide override: every render and export
+ * takes its environment explicitly.
+ *
+ * `document` is the DOM side of the same host: what SVG exports are built in
+ * (a DOM implementation such as `linkedom` under Node).
+ */
+import type { TextMetricsProvider } from "./textMeasurements";
+export type RenderEnvironment = {
+    /** Creates a blank canvas. Callers set `width`/`height` themselves. */
+    createCanvas: () => HTMLCanvasElement;
+    /**
+     * Creates an image to be decoded from a data URL and later used as a
+     * `drawImage` source.
+     *
+     * NOTE: typed as `HTMLImageElement` because the renderer is typed against
+     * the DOM lib throughout. Non-DOM implementations (node-canvas et al) need
+     * to cast; they must support `src`, `onload`, `onerror`, `naturalWidth`,
+     * `naturalHeight` and be accepted by their canvas' `drawImage`.
+     */
+    createImage: () => HTMLImageElement;
+    /**
+     * Creates a fillable path from an SVG path string -- freedraw elements are
+     * filled through one.
+     *
+     * Optional, because browsers always have the global `Path2D` this falls back
+     * to. A Node host MUST supply it (e.g. `@napi-rs/canvas`'s `Path2D`) or
+     * install `globalThis.Path2D` itself: Node has no such global, and without
+     * one every freedraw element fails to render.
+     */
+    createPath?: (svgPath: string) => Path2D;
+    /**
+     * The document SVG exports are built in: the editor's owner document, or
+     * outside the browser a DOM implementation's (e.g. `linkedom`).
+     *
+     * Optional; falls back to the global `document`.
+     */
+    document?: Document;
+    /**
+     * Measures text (line widths, for wrapping and layout).
+     *
+     * Optional; falls back to the global provider set with
+     * `setCustomTextMetricsProvider`, else to measuring on a canvas from
+     * `createCanvas`.
+     */
+    textMetrics?: TextMetricsProvider;
+};
+/**
+ * Resolves the host environment for a render: the explicitly scoped one (e.g.
+ * the editor's owner window, or an export's), else the browser default.
+ */
+export declare const getRenderEnvironment: (env?: RenderEnvironment) => RenderEnvironment;
+/**
+ * Resolves the path factory for a render. `createPath` is the one optional
+ * member of the contract, so this fills in the global-`Path2D` default for
+ * environments that omit it.
+ */
+export declare const getCreatePath: (env?: RenderEnvironment) => ((svgPath: string) => Path2D);

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

@@ -1,10 +1,11 @@
 import { type LocalPoint } from "@excalidraw/math";
 import type { PointerDownState } from "@excalidraw/excalidraw/types";
+import type { RenderEnvironment } from "./renderEnvironment";
 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";
-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;
+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, renderEnvironment?: RenderEnvironment) => boolean;
 export declare const rescalePointsInElement: (element: NonDeletedExcalidrawElement, width: number, height: number, normalizePoints: boolean) => {
     points: LocalPoint[];
 } | {
@@ -13,15 +14,23 @@ export declare const rescalePointsInElement: (element: NonDeletedExcalidrawEleme
 export declare const measureFontSizeFromWidth: (element: NonDeleted<ExcalidrawTextElement>, elementsMap: ElementsMap, nextWidth: number) => {
     size: number;
 } | null;
-export declare const resizeSingleTextElement: (origElement: NonDeleted<ExcalidrawTextElement>, element: NonDeleted<ExcalidrawTextElement>, scene: Scene, transformHandleType: TransformHandleDirection, shouldResizeFromCenter: boolean, nextWidth: number, nextHeight: number) => void;
+export declare const resizeSingleTextElement: (origElement: NonDeleted<ExcalidrawTextElement>, element: NonDeleted<ExcalidrawTextElement>, scene: Scene, transformHandleType: TransformHandleDirection, shouldResizeFromCenter: boolean, nextWidth: number, nextHeight: number, renderEnvironment?: RenderEnvironment) => void;
 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: NonDeletedExcalidrawElement, origElement: NonDeletedExcalidrawElement, originalElementsMap: ElementsMap, scene: Scene, handleDirection: TransformHandleDirection, { shouldInformMutation, shouldMaintainAspectRatio, shouldResizeFromCenter, }?: {
+export declare const resizeSingleElement: (nextWidth: number, nextHeight: number, latestElement: NonDeletedExcalidrawElement, origElement: NonDeletedExcalidrawElement, originalElementsMap: ElementsMap, scene: Scene, handleDirection: TransformHandleDirection, { shouldInformMutation, shouldMaintainAspectRatio, shouldResizeFromCenter, renderEnvironment, }?: {
     shouldMaintainAspectRatio?: boolean;
     shouldResizeFromCenter?: boolean;
     shouldInformMutation?: boolean;
+    renderEnvironment?: RenderEnvironment;
 }) => void;
-export declare const resizeMultipleElements: (selectedElements: readonly NonDeletedExcalidrawElement[], elementsMap: ElementsMap, handleDirection: TransformHandleDirection, scene: Scene, originalElementsMap: ElementsMap, { shouldMaintainAspectRatio, shouldResizeFromCenter, flipByX, flipByY, nextHeight, nextWidth, originalBoundingBox, }?: {
+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, renderEnvironment, }?: {
     nextWidth?: number;
     nextHeight?: number;
     shouldMaintainAspectRatio?: boolean;
@@ -29,4 +38,5 @@ export declare const resizeMultipleElements: (selectedElements: readonly NonDele
     flipByX?: boolean;
     flipByY?: boolean;
     originalBoundingBox?: BoundingBox;
+    renderEnvironment?: RenderEnvironment;
 }) => void;

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) => {
-    selectedElementIds: AppState["selectedElementIds"];
-    selectedGroupIds: AppState["selectedGroupIds"];
-    editingGroupId: AppState["editingGroupId"];
-    selectedLinearElement: LinearElementEditor | null;
-};
 /**
  * Returns editing or single-selected text element, if any.
  */

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

@@ -36,6 +36,8 @@ export declare const generateLinearCollisionShape: (element: ExcalidrawLinearEle
     op: string;
     data: number[];
 }[];
+export declare const ELBOW_ARROW_CORNER_RADIUS = 16;
+export declare const generateElbowArrowShape: (routePoints: readonly LocalPoint[], radius: number) => string;
 /**
  * get the pure geometric shape of an excalidraw elementw
  * which is then used for hit detection

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

@@ -1,3 +1,4 @@
+import type { RenderEnvironment } from "./renderEnvironment";
 import type { Scene } from "./Scene";
 import type { VerticalResizeAnchor } from "./sizeHelpers";
 import type { TransformHandleDirection } from "./transformHandles";
@@ -124,6 +125,12 @@ export type StickyNoteLayoutOpts = {
     baseFontSize?: number;
     /** the edge that stays put when the content correction changes the height */
     anchor?: StickyNoteLayoutAnchor;
+    /**
+     * the host whose text metrics the fit measures with; omitted = the global
+     * environment. An editor passes its own so a note laid out in one window
+     * (or headlessly) is measured with that realm's fonts and canvas.
+     */
+    renderEnvironment?: RenderEnvironment;
 };
 export type StickyNoteLayout = {
     container: Pick<ExcalidrawStickyNoteElement, "x" | "y" | "width" | "height" | "baseHeight">;
@@ -180,4 +187,5 @@ export declare const updateStickyNoteLayout: (container: ExcalidrawStickyNoteEle
  */
 export declare const relayoutStickyNotes: <T extends ExcalidrawElement>(elements: readonly T[], affectedIds: ReadonlySet<ExcalidrawElement["id"]>, opts?: {
     prevElementsMap?: ElementsMap;
+    renderEnvironment?: RenderEnvironment;
 }) => readonly T[];

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

@@ -1,10 +1,11 @@
 import { type Radians } from "@excalidraw/math";
 import type { ExtractSetType } from "@excalidraw/common/utility-types";
+import type { RenderEnvironment } from "./renderEnvironment";
 import type { Scene } from "./Scene";
 import type { MaybeTransformHandleType } from "./transformHandles";
 import type { ElementsMap, ExcalidrawElement, ExcalidrawElementType, ExcalidrawTextContainer, ExcalidrawTextElement, ExcalidrawTextElementWithContainer, NonDeleted } from "./types";
-export declare const redrawTextBoundingBox: (textElement: ExcalidrawTextElement, container: ExcalidrawElement | null, scene: Scene) => void;
-export declare const handleBindTextResize: (container: ExcalidrawElement, scene: Scene, transformHandleType: MaybeTransformHandleType, shouldMaintainAspectRatio?: boolean, shouldResizeFromCenter?: boolean, flipByY?: boolean) => void;
+export declare const redrawTextBoundingBox: (textElement: ExcalidrawTextElement, container: ExcalidrawElement | null, scene: Scene, renderEnvironment?: RenderEnvironment) => void;
+export declare const handleBindTextResize: (container: ExcalidrawElement, scene: Scene, transformHandleType: MaybeTransformHandleType, shouldMaintainAspectRatio?: boolean, shouldResizeFromCenter?: boolean, flipByY?: boolean, renderEnvironment?: RenderEnvironment) => void;
 export declare const computeBoundTextPosition: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElementWithContainer, elementsMap: ElementsMap) => {
     x: number;
     y: number;

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

@@ -1,10 +1,11 @@
+import type { RenderEnvironment } from "./renderEnvironment";
 import type { FontString, ExcalidrawTextElement } from "./types";
-export declare const measureText: (text: string, font: FontString, lineHeight: ExcalidrawTextElement["lineHeight"]) => {
+export declare const measureText: (text: string, font: FontString, lineHeight: ExcalidrawTextElement["lineHeight"], env?: RenderEnvironment) => {
     width: number;
     height: number;
 };
-export declare const getApproxMinLineWidth: (font: FontString, lineHeight: ExcalidrawTextElement["lineHeight"]) => number;
-export declare const getMinTextElementWidth: (font: FontString, lineHeight: ExcalidrawTextElement["lineHeight"]) => number;
+export declare const getApproxMinLineWidth: (font: FontString, lineHeight: ExcalidrawTextElement["lineHeight"], env?: RenderEnvironment) => number;
+export declare const getMinTextElementWidth: (font: FontString, lineHeight: ExcalidrawTextElement["lineHeight"], env?: RenderEnvironment) => number;
 export declare const isMeasureTextSupported: () => boolean;
 export declare const normalizeText: (text: string) => string;
 /**
@@ -19,21 +20,24 @@ export declare const detectLineHeight: (textElement: ExcalidrawTextElement) => E
 export declare const getLineHeightInPx: (fontSize: ExcalidrawTextElement["fontSize"], lineHeight: ExcalidrawTextElement["lineHeight"]) => number;
 export declare const getApproxMinLineHeight: (fontSize: ExcalidrawTextElement["fontSize"], lineHeight: ExcalidrawTextElement["lineHeight"]) => number;
 /**
- * Set a custom text metrics provider.
+ * Set a custom text metrics provider, for all text measured in an environment
+ * without its own (`RenderEnvironment["textMetrics"]`) -- e.g. elements
+ * created outside the editor, on a server. Pass `undefined` to go back to
+ * measuring on a canvas.
  *
  * Useful for overriding the width calculation algorithm where canvas API is not available / desired.
  */
-export declare const setCustomTextMetricsProvider: (provider: TextMetricsProvider) => void;
+export declare const setCustomTextMetricsProvider: (provider: TextMetricsProvider | undefined) => void;
 export interface TextMetricsProvider {
     getLineWidth(text: string, fontString: FontString): number;
 }
-export declare const getLineWidth: (text: string, font: FontString) => number;
-export declare const getTextWidth: (text: string, font: FontString) => number;
+export declare const getLineWidth: (text: string, font: FontString, env?: RenderEnvironment) => number;
+export declare const getTextWidth: (text: string, font: FontString, env?: RenderEnvironment) => 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[];
+    calculate: (char: string, font: FontString, env?: RenderEnvironment) => number;
+    getCache: (font: FontString, env?: RenderEnvironment) => number[] | undefined;
     clearCache: (font: FontString) => void;
 };
-export declare const getMinCharWidth: (font: FontString) => number;
-export declare const getMaxCharWidth: (font: FontString) => number;
+export declare const getMinCharWidth: (font: FontString, env?: RenderEnvironment) => number;
+export declare const getMaxCharWidth: (font: FontString, env?: RenderEnvironment) => number;

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

@@ -1,3 +1,4 @@
+import type { RenderEnvironment } from "./renderEnvironment";
 import type { FontString } from "./types";
 /**
  * Test if a given text contains any CJK characters (including symbols, punctuation, etc,).
@@ -17,7 +18,7 @@ export declare const parseTokens: (line: string) => string[];
  * This is a convenience adapter over `getWrappedTextLines()` for call sites
  * that only need the rendered wrapped string and not the source offsets.
  */
-export declare const wrapText: (text: string, font: FontString, maxWidth: number) => string;
+export declare const wrapText: (text: string, font: FontString, maxWidth: number, env?: RenderEnvironment) => string;
 /**
  * A single rendered visual line produced from the original text.
  *
@@ -36,4 +37,4 @@ export type WrappedTextLine = {
  * This is the source-of-truth wrapping pipeline for callers that need more than the
  * final wrapped string, for example caret placement or future editor/rich-text mapping.
  */
-export declare const getWrappedTextLines: (text: string, font: FontString, maxWidth: number) => WrappedTextLine[];
+export declare const getWrappedTextLines: (text: string, font: FontString, maxWidth: number, env?: RenderEnvironment) => WrappedTextLine[];

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

@@ -1,5 +1,6 @@
 import type { MarkOptional } from "@excalidraw/common/utility-types";
 import { type ElementConstructorOpts } from "./newElement";
+import type { RenderEnvironment } from "./renderEnvironment";
 import type { ExcalidrawBindableElement, ExcalidrawElement, ExcalidrawFrameElement, ExcalidrawFreeDrawElement, ExcalidrawGenericElement, ExcalidrawIframeLikeElement, ExcalidrawImageElement, ExcalidrawLinearElement, ExcalidrawMagicFrameElement, ExcalidrawSelectionElement, ExcalidrawTextElement, FileId, FontFamilyValues, NonDeletedExcalidrawElement, Ordered, TextAlign, VerticalAlign, ExcalidrawStickyNoteElement } from "./types";
 /**
  * Options for elements generated from a skeleton fragment (bound labels and
@@ -17,6 +18,8 @@ export type ValidLinearElement = {
         fontFamily?: FontFamilyValues;
         textAlign?: TextAlign;
         verticalAlign?: VerticalAlign;
+        /** where along an arrow's path (0-1) the label is centered */
+        labelPosition?: ExcalidrawTextElement["labelPosition"];
     } & FragmentConstructorOpts;
     end?: (({
         type: Exclude<ExcalidrawBindableElement["type"], "image" | "text" | "frame" | "magicframe" | "embeddable" | "iframe">;
@@ -95,6 +98,7 @@ export type ExcalidrawElementSkeleton = Extract<Exclude<ExcalidrawElement, Excal
     name?: string;
 } & Partial<ExcalidrawMagicFrameElement>);
 export declare const convertToExcalidrawElements: (elementsSkeleton: ExcalidrawElementSkeleton[] | null, opts?: {
-    regenerateIds: boolean;
+    regenerateIds?: boolean;
+    renderEnvironment?: RenderEnvironment;
 }) => Ordered<NonDeletedExcalidrawElement>[];
 export {};