@zsviczian/excalidraw 0.17.6-3 → 0.17.6-30

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

@@ -1,12 +0,0 @@
-import type { LocalPoint, GlobalPoint, Vector } from "../../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 headingForDiamond: <Point extends GlobalPoint | LocalPoint>(a: Point, b: Point) => Heading;
-export declare const vectorToHeading: (vec: Vector) => Heading;
-export declare const compareHeading: (a: Heading, b: Heading) => boolean;
-export declare const headingForPointFromElement: <Point extends GlobalPoint | LocalPoint>(element: Readonly<ExcalidrawBindableElement>, aabb: readonly [minX: number, minY: number, maxX: number, maxY: number], p: Readonly<LocalPoint | GlobalPoint>) => Heading;
-export declare const flipHeading: (h: Heading) => Heading;

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

@@ -1,32 +0,0 @@
-import type { AppClassProperties, DataURL, BinaryFiles } from "../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("../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) => Promise<string>;

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

@@ -1,26 +0,0 @@
-import type { ExcalidrawElement, NonDeletedExcalidrawElement, NonDeleted } from "./types";
-export { newElement, newTextElement, refreshTextDimensions, newLinearElement, newArrowElement, newImageElement, duplicateElement, } from "./newElement";
-export { getElementAbsoluteCoords, getElementBounds, getCommonBounds, getDiamondPoints, getArrowheadPoints, getClosestElementBounds, } from "./bounds";
-export { OMIT_SIDES_FOR_MULTIPLE_ELEMENTS, getTransformHandlesFromCoords, getTransformHandles, } from "./transformHandles";
-export { resizeTest, getCursorForResizingElement, getElementWithTransformHandleType, getTransformHandleTypeFromCoords, } from "./resizeTest";
-export { transformElements, getResizeOffsetXY, getResizeArrowDirection, } from "./resizeElements";
-export { dragSelectedElements, getDragOffsetXY, dragNewElement, } from "./dragElements";
-export { isTextElement, isExcalidrawElement } from "./typeChecks";
-export { redrawTextBoundingBox, getTextFromElements } from "./textElement";
-export { getPerfectElementSize, getLockedLinearCursorAlignSize, isInvisiblySmallElement, resizePerfectLineForNWHandler, getNormalizedDimensions, } from "./sizeHelpers";
-export { showSelectedShapeActions } from "./showSelectedShapeActions";
-/**
- * @deprecated unsafe, use hashElementsVersion instead
- */
-export declare const getSceneVersion: (elements: readonly ExcalidrawElement[]) => number;
-/**
- * Hashes elements' versionNonce (using djb2 algo). Order of elements matters.
- */
-export declare const hashElementsVersion: (elements: readonly ExcalidrawElement[]) => number;
-export declare const hashString: (s: string) => number;
-export declare const getVisibleElements: (elements: readonly ExcalidrawElement[]) => readonly NonDeletedExcalidrawElement[];
-export declare const getNonDeletedElements: <T extends ExcalidrawElement>(elements: readonly T[]) => readonly NonDeleted<T>[];
-export declare const isNonDeletedElement: <T extends ExcalidrawElement>(element: T) => element is NonDeleted<T>;
-export declare const clearElementsForDatabase: (elements: readonly ExcalidrawElement[]) => ExcalidrawElement[];
-export declare const clearElementsForExport: (elements: readonly ExcalidrawElement[]) => ExcalidrawElement[];
-export declare const clearElementsForLocalStorage: (elements: readonly ExcalidrawElement[]) => ExcalidrawElement[];

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

@@ -1,128 +0,0 @@
-import type { NonDeleted, ExcalidrawLinearElement, ExcalidrawElement, PointBinding, ExcalidrawBindableElement, ExcalidrawTextElementWithContainer, ElementsMap, NonDeletedSceneElementsMap, OrderedExcalidrawElement, SceneElementsMap } from "./types";
-import type { Bounds } from "./bounds";
-import type { AppState, PointerCoords, InteractiveCanvasAppState, AppClassProperties, NullableGridSize } from "../types";
-import type { Store } from "../store";
-import type Scene from "../scene/Scene";
-import { type GlobalPoint, type LocalPoint } from "../../math";
-declare const editorMidPointsCache: {
-    version: number | null;
-    points: (GlobalPoint | null)[];
-    zoom: number | null;
-};
-export declare class LinearElementEditor {
-    readonly elementId: ExcalidrawElement["id"] & {
-        _brand: "excalidrawLinearElementId";
-    };
-    /** indices */
-    readonly selectedPointsIndices: readonly number[] | null;
-    readonly pointerDownState: Readonly<{
-        prevSelectedPointsIndices: readonly number[] | null;
-        /** index */
-        lastClickedPoint: number;
-        lastClickedIsEndPoint: boolean;
-        origin: Readonly<{
-            x: number;
-            y: number;
-        }> | null;
-        segmentMidpoint: {
-            value: GlobalPoint | null;
-            index: number | null;
-            added: boolean;
-        };
-    }>;
-    /** whether you're dragging a point */
-    readonly isDragging: boolean;
-    readonly lastUncommittedPoint: LocalPoint | null;
-    readonly pointerOffset: Readonly<{
-        x: number;
-        y: number;
-    }>;
-    readonly startBindingElement: ExcalidrawBindableElement | null | "keep";
-    readonly endBindingElement: ExcalidrawBindableElement | null | "keep";
-    readonly hoverPointIndex: number;
-    readonly segmentMidPointHoveredCoords: GlobalPoint | null;
-    readonly elbowed: boolean;
-    constructor(element: NonDeleted<ExcalidrawLinearElement>);
-    static POINT_HANDLE_SIZE: number;
-    /**
-     * @param id the `elementId` from the instance of this class (so that we can
-     *  statically guarantee this method returns an ExcalidrawLinearElement)
-     */
-    static getElement(id: InstanceType<typeof LinearElementEditor>["elementId"], elementsMap: ElementsMap): NonDeleted<ExcalidrawLinearElement> | null;
-    static handleBoxSelection(event: PointerEvent, appState: AppState, setState: React.Component<any, AppState>["setState"], elementsMap: NonDeletedSceneElementsMap): false | undefined;
-    /** @returns whether point was dragged */
-    static handlePointDragging(event: PointerEvent, app: AppClassProperties, scenePointerX: number, scenePointerY: number, maybeSuggestBinding: (element: NonDeleted<ExcalidrawLinearElement>, pointSceneCoords: {
-        x: number;
-        y: number;
-    }[]) => void, linearElementEditor: LinearElementEditor, scene: Scene): boolean;
-    static handlePointerUp(event: PointerEvent, editingLinearElement: LinearElementEditor, appState: AppState, scene: Scene): LinearElementEditor;
-    static getEditorMidPoints: (element: NonDeleted<ExcalidrawLinearElement>, elementsMap: ElementsMap, appState: InteractiveCanvasAppState) => (typeof editorMidPointsCache)["points"];
-    static updateEditorMidPointsCache: (element: NonDeleted<ExcalidrawLinearElement>, elementsMap: ElementsMap, appState: InteractiveCanvasAppState) => void;
-    static getSegmentMidpointHitCoords: (linearElementEditor: LinearElementEditor, scenePointer: {
-        x: number;
-        y: number;
-    }, appState: AppState, elementsMap: ElementsMap) => GlobalPoint | null;
-    static isSegmentTooShort(element: NonDeleted<ExcalidrawLinearElement>, startPoint: GlobalPoint | LocalPoint, endPoint: GlobalPoint | LocalPoint, zoom: AppState["zoom"]): boolean;
-    static getSegmentMidPoint(element: NonDeleted<ExcalidrawLinearElement>, startPoint: GlobalPoint, endPoint: GlobalPoint, endPointIndex: number, elementsMap: ElementsMap): GlobalPoint;
-    static getSegmentMidPointIndex(linearElementEditor: LinearElementEditor, appState: AppState, midPoint: GlobalPoint, elementsMap: ElementsMap): number;
-    static handlePointerDown(event: React.PointerEvent<HTMLElement>, app: AppClassProperties, store: Store, scenePointer: {
-        x: number;
-        y: number;
-    }, linearElementEditor: LinearElementEditor, scene: Scene): {
-        didAddPoint: boolean;
-        hitElement: NonDeleted<ExcalidrawElement> | null;
-        linearElementEditor: LinearElementEditor | null;
-    };
-    static arePointsEqual<Point extends LocalPoint | GlobalPoint>(point1: Point | null, point2: Point | null): boolean;
-    static handlePointerMove(event: React.PointerEvent<HTMLCanvasElement>, scenePointerX: number, scenePointerY: number, app: AppClassProperties, elementsMap: NonDeletedSceneElementsMap | SceneElementsMap): LinearElementEditor | null;
-    /** scene coords */
-    static getPointGlobalCoordinates(element: NonDeleted<ExcalidrawLinearElement>, p: LocalPoint, elementsMap: ElementsMap): GlobalPoint;
-    /** scene coords */
-    static getPointsGlobalCoordinates(element: NonDeleted<ExcalidrawLinearElement>, elementsMap: ElementsMap): GlobalPoint[];
-    static getPointAtIndexGlobalCoordinates(element: NonDeleted<ExcalidrawLinearElement>, indexMaybeFromEnd: number, // -1 for last element
-    elementsMap: ElementsMap): GlobalPoint;
-    static pointFromAbsoluteCoords(element: NonDeleted<ExcalidrawLinearElement>, absoluteCoords: GlobalPoint, elementsMap: ElementsMap): LocalPoint;
-    static getPointIndexUnderCursor(element: NonDeleted<ExcalidrawLinearElement>, elementsMap: ElementsMap, zoom: AppState["zoom"], x: number, y: number): number;
-    static createPointAt(element: NonDeleted<ExcalidrawLinearElement>, elementsMap: ElementsMap, scenePointerX: number, scenePointerY: number, gridSize: NullableGridSize): LocalPoint;
-    /**
-     * Normalizes line points so that the start point is at [0,0]. This is
-     * expected in various parts of the codebase. Also returns new x/y to account
-     * for the potential normalization.
-     */
-    static getNormalizedPoints(element: ExcalidrawLinearElement): {
-        points: LocalPoint[];
-        x: number;
-        y: number;
-    };
-    static normalizePoints(element: NonDeleted<ExcalidrawLinearElement>): void;
-    static duplicateSelectedPoints(appState: AppState, elementsMap: NonDeletedSceneElementsMap | SceneElementsMap): AppState;
-    static deletePoints(element: NonDeleted<ExcalidrawLinearElement>, pointIndices: readonly number[], elementsMap: NonDeletedSceneElementsMap | SceneElementsMap): void;
-    static addPoints(element: NonDeleted<ExcalidrawLinearElement>, targetPoints: {
-        point: LocalPoint;
-    }[], elementsMap: NonDeletedSceneElementsMap | SceneElementsMap): void;
-    static movePoints(element: NonDeleted<ExcalidrawLinearElement>, targetPoints: {
-        index: number;
-        point: LocalPoint;
-        isDragging?: boolean;
-    }[], elementsMap: NonDeletedSceneElementsMap | SceneElementsMap, otherUpdates?: {
-        startBinding?: PointBinding | null;
-        endBinding?: PointBinding | null;
-    }, options?: {
-        changedElements?: Map<string, OrderedExcalidrawElement>;
-        isDragging?: boolean;
-    }): void;
-    static shouldAddMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, appState: AppState, elementsMap: ElementsMap): boolean;
-    static addMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, app: AppClassProperties, snapToGrid: boolean, elementsMap: ElementsMap): {
-        pointerDownState: LinearElementEditor["pointerDownState"];
-        selectedPointsIndices: LinearElementEditor["selectedPointsIndices"];
-    } | undefined;
-    private static _updatePoints;
-    private static _getShiftLockedDelta;
-    static getBoundTextElementPosition: (element: ExcalidrawLinearElement, boundTextElement: ExcalidrawTextElementWithContainer, elementsMap: ElementsMap) => {
-        x: number;
-        y: number;
-    };
-    static getMinMaxXYWithBoundText: (element: ExcalidrawLinearElement, elementsMap: ElementsMap, elementBounds: Bounds, boundTextElement: ExcalidrawTextElementWithContainer) => [number, number, number, number, number, number];
-    static getElementAbsoluteCoords: (element: ExcalidrawLinearElement, elementsMap: ElementsMap, includeBoundText?: boolean) => [number, number, number, number, number, number];
-}
-export {};

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

@@ -1,11 +0,0 @@
-import type { ExcalidrawElement } from "./types";
-import type { Mutable } from "../utility-types";
-export type ElementUpdate<TElement extends ExcalidrawElement> = Omit<Partial<TElement>, "id" | "version" | "versionNonce" | "updated">;
-export declare const mutateElement: <TElement extends Mutable<ExcalidrawElement>>(element: TElement, updates: ElementUpdate<TElement>, informMutation?: boolean) => TElement;
-export declare const newElementWith: <TElement extends ExcalidrawElement>(element: TElement, updates: ElementUpdate<TElement>, force?: boolean) => TElement;
-/**
- * Mutates element, bumping `version`, `versionNonce`, and `updated`.
- *
- * NOTE: does not trigger re-render.
- */
-export declare const bumpVersion: <T extends Mutable<ExcalidrawElement>>(element: T, version?: ExcalidrawElement["version"]) => T;

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

@@ -1,105 +0,0 @@
-import type { ExcalidrawElement, ExcalidrawImageElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawGenericElement, NonDeleted, TextAlign, GroupId, VerticalAlign, Arrowhead, ExcalidrawFreeDrawElement, FontFamilyValues, ExcalidrawTextContainer, ExcalidrawFrameElement, ExcalidrawEmbeddableElement, ExcalidrawMagicFrameElement, ExcalidrawIframeElement, ElementsMap, ExcalidrawArrowElement } from "./types";
-import type { AppState } from "../types";
-import type { MarkOptional, Mutable } from "../utility-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">;
-export declare const newElement: (opts: {
-    type: ExcalidrawGenericElement["type"];
-} & ElementConstructorOpts) => NonDeleted<ExcalidrawGenericElement>;
-export declare const newEmbeddableElement: (opts: {
-    type: "embeddable";
-} & ElementConstructorOpts) => NonDeleted<ExcalidrawEmbeddableElement>;
-export declare const newIframeElement: (opts: {
-    type: "iframe";
-} & ElementConstructorOpts) => NonDeleted<ExcalidrawIframeElement>;
-export declare const newFrameElement: (opts: {
-    name?: string;
-} & ElementConstructorOpts) => NonDeleted<ExcalidrawFrameElement>;
-export declare const newMagicFrameElement: (opts: {
-    name?: string;
-} & ElementConstructorOpts) => NonDeleted<ExcalidrawMagicFrameElement>;
-export declare const newTextElement: (opts: {
-    text: string;
-    rawText: string;
-    originalText?: string;
-    fontSize?: number;
-    fontFamily?: FontFamilyValues;
-    textAlign?: TextAlign;
-    verticalAlign?: VerticalAlign;
-    containerId?: ExcalidrawTextContainer["id"] | null;
-    lineHeight?: ExcalidrawTextElement["lineHeight"];
-    autoResize?: ExcalidrawTextElement["autoResize"];
-} & ElementConstructorOpts) => NonDeleted<ExcalidrawTextElement>;
-export declare const refreshTextDimensions: (textElement: ExcalidrawTextElement, container: ExcalidrawTextContainer | null, elementsMap: ElementsMap, text?: string) => {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    text: string;
-} | undefined;
-export declare const newFreeDrawElement: (opts: {
-    type: "freedraw";
-    points?: ExcalidrawFreeDrawElement["points"];
-    simulatePressure: boolean;
-    pressures?: ExcalidrawFreeDrawElement["pressures"];
-} & ElementConstructorOpts) => NonDeleted<ExcalidrawFreeDrawElement>;
-export declare const newLinearElement: (opts: {
-    type: ExcalidrawLinearElement["type"];
-    points?: ExcalidrawLinearElement["points"];
-} & ElementConstructorOpts) => NonDeleted<ExcalidrawLinearElement>;
-export declare const newArrowElement: (opts: {
-    type: ExcalidrawArrowElement["type"];
-    startArrowhead?: Arrowhead | null;
-    endArrowhead?: Arrowhead | null;
-    points?: ExcalidrawArrowElement["points"];
-    elbowed?: boolean;
-} & ElementConstructorOpts) => NonDeleted<ExcalidrawArrowElement>;
-export declare const newImageElement: (opts: {
-    type: ExcalidrawImageElement["type"];
-    status?: ExcalidrawImageElement["status"];
-    fileId?: ExcalidrawImageElement["fileId"];
-    scale?: ExcalidrawImageElement["scale"];
-} & ElementConstructorOpts) => NonDeleted<ExcalidrawImageElement>;
-/**
- * Clones ExcalidrawElement data structure. Does not regenerate id, nonce, or
- * any value. The purpose is to to break object references for immutability
- * reasons, whenever we want to keep the original element, but ensure it's not
- * mutated.
- *
- * Only clones plain objects and arrays. Doesn't clone Date, RegExp, Map, Set,
- * Typed arrays and other non-null objects.
- */
-export declare const deepCopyElement: <T extends ExcalidrawElement>(val: T) => Mutable<T>;
-/**
- * utility wrapper to generate new id. In test env it reuses the old + postfix
- * for test assertions.
- */
-export declare const regenerateId: (previousId: string | null) => string;
-/**
- * Duplicate an element, often used in the alt-drag operation.
- * Note that this method has gotten a bit complicated since the
- * introduction of gruoping/ungrouping elements.
- * @param editingGroupId The current group being edited. The new
- *                       element will inherit this group and its
- *                       parents.
- * @param groupIdMapForOperation A Map that maps old group IDs to
- *                               duplicated ones. If you are duplicating
- *                               multiple elements at once, share this map
- *                               amongst all of them
- * @param element Element to duplicate
- * @param overrides Any element properties to override
- */
-export declare const duplicateElement: <TElement extends ExcalidrawElement>(editingGroupId: AppState["editingGroupId"], groupIdMapForOperation: Map<GroupId, GroupId>, element: TElement, overrides?: Partial<TElement> | undefined) => Readonly<TElement>;
-/**
- * Clones elements, regenerating their ids (including bindings) and group ids.
- *
- * If bindings don't exist in the elements array, they are removed. Therefore,
- * it's advised to supply the whole elements array, or sets of elements that
- * are encapsulated (such as library items), if the purpose is to retain
- * bindings to the cloned elements intact.
- *
- * NOTE by default does not randomize or regenerate anything except the id.
- */
-export declare const duplicateElements: (elements: readonly ExcalidrawElement[], opts?: {
-    /** NOTE also updates version flags and `updated` */
-    randomizeSeed: boolean;
-}) => ExcalidrawElement[];

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

@@ -1,16 +0,0 @@
-import type { ExcalidrawLinearElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, NonDeleted, ElementsMap, NonDeletedSceneElementsMap, SceneElementsMap } from "./types";
-import type { MaybeTransformHandleType, TransformHandleDirection } from "./transformHandles";
-import type { PointerDownState } from "../types";
-export declare const transformElements: (originalElements: PointerDownState["originalElements"], transformHandleType: MaybeTransformHandleType, selectedElements: readonly NonDeletedExcalidrawElement[], elementsMap: SceneElementsMap, 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: import("../../math").LocalPoint[];
-} | {
-    points?: undefined;
-};
-export declare const measureFontSizeFromWidth: (element: NonDeleted<ExcalidrawTextElement>, elementsMap: ElementsMap, nextWidth: number) => {
-    size: number;
-} | null;
-export declare const resizeSingleElement: (originalElements: PointerDownState["originalElements"], shouldMaintainAspectRatio: boolean, element: NonDeletedExcalidrawElement, elementsMap: SceneElementsMap, transformHandleDirection: TransformHandleDirection, shouldResizeFromCenter: boolean, pointerX: number, pointerY: number) => void;
-export declare const resizeMultipleElements: (originalElements: PointerDownState["originalElements"], selectedElements: readonly NonDeletedExcalidrawElement[], elementsMap: NonDeletedSceneElementsMap | SceneElementsMap, transformHandleType: TransformHandleDirection, shouldResizeFromCenter: boolean, shouldMaintainAspectRatio: boolean, pointerX: number, pointerY: number) => 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";

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

@@ -1,15 +0,0 @@
-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,12 +0,0 @@
-import { type LocalPoint, type Vector } from "../../math";
-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;
-}) => void;
-export declare const updateElbowArrow: (arrow: ExcalidrawElbowArrowElement, elementsMap: NonDeletedSceneElementsMap | SceneElementsMap, nextPoints: readonly LocalPoint[], offset?: Vector, options?: {
-    isDragging?: boolean;
-    disableBinding?: boolean;
-    informMutation?: boolean;
-}) => ElementUpdate<ExcalidrawElbowArrowElement> | null;

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

@@ -1,3 +0,0 @@
-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 +0,0 @@
-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 +0,0 @@
-import type { ExcalidrawElement } from "./types";
-export declare const normalizeElementOrder: (elements: readonly ExcalidrawElement[]) => readonly ExcalidrawElement[];

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

@@ -1,73 +0,0 @@
-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 containsCJK: (text: string) => boolean;
-export declare const containsEmoji: (text: string) => boolean;
-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;
-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 parseTokens: (line: string) => string[];
-export declare const wrapText: (text: string, font: FontString, maxWidth: number) => string;
-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/textWysiwyg.d.ts

@@ -1,22 +0,0 @@
-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 +0,0 @@
-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) => 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;

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

@@ -1,39 +0,0 @@
-import type { ElementOrToolType } from "../types";
-import type { MarkNonNullable } from "../utility-types";
-import type { Bounds } from "./bounds";
-import type { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawEmbeddableElement, ExcalidrawLinearElement, ExcalidrawBindableElement, ExcalidrawFreeDrawElement, InitializedExcalidrawImageElement, ExcalidrawImageElement, ExcalidrawTextElementWithContainer, ExcalidrawTextContainer, ExcalidrawFrameElement, RoundnessType, ExcalidrawFrameLikeElement, ExcalidrawElementType, ExcalidrawIframeElement, ExcalidrawIframeLikeElement, ExcalidrawMagicFrameElement, ExcalidrawArrowElement, ExcalidrawElbowArrowElement, PointBinding, FixedPointBinding, ExcalidrawFlowchartNodeElement } from "./types";
-export declare const isInitializedImageElement: (element: ExcalidrawElement | null) => element is InitializedExcalidrawImageElement;
-export declare const isImageElement: (element: ExcalidrawElement | null) => element is ExcalidrawImageElement;
-export declare const isEmbeddableElement: (element: ExcalidrawElement | null | undefined) => element is ExcalidrawEmbeddableElement;
-export declare const isIframeElement: (element: ExcalidrawElement | null) => element is ExcalidrawIframeElement;
-export declare const isIframeLikeElement: (element: ExcalidrawElement | null) => element is ExcalidrawIframeLikeElement;
-export declare const isTextElement: (element: ExcalidrawElement | null) => element is ExcalidrawTextElement;
-export declare const isFrameElement: (element: ExcalidrawElement | null) => element is ExcalidrawFrameElement;
-export declare const isMagicFrameElement: (element: ExcalidrawElement | null) => element is ExcalidrawMagicFrameElement;
-export declare const isFrameLikeElement: (element: ExcalidrawElement | null) => element is ExcalidrawFrameLikeElement;
-export declare const isFreeDrawElement: (element?: ExcalidrawElement | null) => element is ExcalidrawFreeDrawElement;
-export declare const isFreeDrawElementType: (elementType: ExcalidrawElementType) => boolean;
-export declare const isLinearElement: (element?: ExcalidrawElement | null) => element is ExcalidrawLinearElement;
-export declare const isArrowElement: (element?: ExcalidrawElement | null) => element is ExcalidrawArrowElement;
-export declare const isElbowArrow: (element?: ExcalidrawElement) => element is ExcalidrawElbowArrowElement;
-export declare const isLinearElementType: (elementType: ElementOrToolType) => boolean;
-export declare const isBindingElement: (element?: ExcalidrawElement | null, includeLocked?: boolean) => element is ExcalidrawLinearElement;
-export declare const isBindingElementType: (elementType: ElementOrToolType) => boolean;
-export declare const isBindableElement: (element: ExcalidrawElement | null | undefined, includeLocked?: boolean) => element is ExcalidrawBindableElement;
-export declare const isRectanguloidElement: (element?: ExcalidrawElement | null) => element is ExcalidrawBindableElement;
-export declare const isRectangularElement: (element?: ExcalidrawElement | null) => element is ExcalidrawBindableElement;
-export declare const isTextBindableContainer: (element: ExcalidrawElement | null, includeLocked?: boolean) => element is ExcalidrawTextContainer;
-export declare const isExcalidrawElement: (element: any) => element is ExcalidrawElement;
-export declare const isFlowchartNodeElement: (element: ExcalidrawElement) => element is ExcalidrawFlowchartNodeElement;
-export declare const hasBoundTextElement: (element: ExcalidrawElement | null) => element is MarkNonNullable<ExcalidrawBindableElement, "boundElements">;
-export declare const isBoundToContainer: (element: ExcalidrawElement | null) => element is ExcalidrawTextElementWithContainer;
-export declare const isUsingAdaptiveRadius: (type: string) => boolean;
-export declare const isUsingProportionalRadius: (type: string) => boolean;
-export declare const canApplyRoundnessTypeToElement: (roundnessType: RoundnessType, element: ExcalidrawElement) => boolean;
-export declare const getDefaultRoundnessTypeForElement: (element: ExcalidrawElement) => {
-    type: 2;
-} | {
-    type: 3;
-} | null;
-export declare const isFixedPointBinding: (binding: PointBinding | FixedPointBinding) => binding is FixedPointBinding;
-export declare const isBounds: (box: unknown) => box is Bounds;