@excalidraw/excalidraw 0.18.0-c141960 → 0.18.0-c158187

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

@@ -86,6 +86,12 @@ export declare const CLASSES: {
     SHAPE_ACTIONS_THEME_SCOPE: string;
     FRAME_NAME: string;
 };
+export declare const FONT_SIZES: {
+    readonly sm: 16;
+    readonly md: 20;
+    readonly lg: 28;
+    readonly xl: 36;
+};
 export declare const CJK_HAND_DRAWN_FALLBACK_FONT = "Xiaolai";
 export declare const WINDOWS_EMOJI_FALLBACK_FONT = "Segoe UI Emoji";
 /**
@@ -126,16 +132,13 @@ export declare const THEME: {
     readonly DARK: "dark";
 };
 export declare const FRAME_STYLE: {
-    strokeColor: string;
-    strokeWidth: number;
-    strokeStyle: import("@excalidraw/element/types").StrokeStyle;
-    fillStyle: import("@excalidraw/element/types").FillStyle;
-    roughness: number;
-    roundness: {
-        type: import("@excalidraw/element/types").RoundnessType;
-        value?: number | undefined;
-    } | null;
-    backgroundColor: string;
+    strokeColor: ExcalidrawElement["strokeColor"];
+    strokeWidth: ExcalidrawElement["strokeWidth"];
+    strokeStyle: ExcalidrawElement["strokeStyle"];
+    fillStyle: ExcalidrawElement["fillStyle"];
+    roughness: ExcalidrawElement["roughness"];
+    roundness: ExcalidrawElement["roundness"];
+    backgroundColor: ExcalidrawElement["backgroundColor"];
     radius: number;
     nameOffsetY: number;
     nameColorLightTheme: string;
@@ -223,7 +226,6 @@ export declare const MAX_ZOOM = 30;
 export declare const HYPERLINK_TOOLTIP_DELAY = 300;
 export declare const IDLE_THRESHOLD = 60000;
 export declare const ACTIVE_THRESHOLD = 3000;
-export declare const THEME_FILTER = "invert(93%) hue-rotate(180deg)";
 export declare const URL_QUERY_KEYS: {
     readonly addLibrary: "addLibrary";
 };

package/dist/types/common/src/font-metadata.d.ts

@@ -43,6 +43,4 @@ export declare const getVerticalOffset: (fontFamily: ExcalidrawTextElement["font
 /**
  * Gets line height for a selected family.
  */
-export declare const getLineHeight: (fontFamily: FontFamilyValues) => number & {
-    _brand: "unitlessLineHeight";
-};
+export declare const getLineHeight: (fontFamily: FontFamilyValues) => ExcalidrawTextElement["lineHeight"];

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

@@ -1,4 +1,5 @@
 export * from "./binary-heap";
+export * from "./bounds";
 export * from "./colors";
 export * from "./constants";
 export * from "./font-metadata";

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

@@ -183,7 +183,7 @@ export declare const isLatinChar: (key: string) => boolean;
  * More details in https://github.com/excalidraw/excalidraw/pull/5944
  */
 export declare const matchKey: (event: KeyboardEvent | React.KeyboardEvent<Element>, key: ValueOf<typeof KEYS>) => boolean;
-export declare const isArrowKey: (key: string) => boolean;
+export declare const isArrowKey: (key: string) => key is "ArrowDown" | "ArrowLeft" | "ArrowRight" | "ArrowUp";
 export declare const shouldResizeFromCenter: (event: MouseEvent | KeyboardEvent) => boolean;
 export declare const shouldMaintainAspectRatio: (event: MouseEvent | KeyboardEvent) => boolean;
 export declare const shouldRotateWithDiscreteAngle: (event: MouseEvent | KeyboardEvent | React.PointerEvent<HTMLCanvasElement>) => boolean;

package/dist/types/common/src/utility-types.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 export type Mutable<T> = {
     -readonly [P in keyof T]: T[P];
 };

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

@@ -1,14 +1,14 @@
 import type { FontFamilyValues, FontString } from "@excalidraw/element/types";
 import type { ActiveTool, AppState, ToolType, UnsubscribeCallback, Zoom } from "@excalidraw/excalidraw/types";
-import type { MaybePromise } from "./utility-types";
+import type { MaybePromise, ResolutionType } from "./utility-types";
 import type { EVENT } from "./constants";
 export declare const setDateTimeForTests: (dateTime: string) => void;
 export declare const getDateTime: () => string;
 export declare const capitalizeString: (str: string) => string;
 export declare const isToolIcon: (target: Element | EventTarget | null) => target is HTMLElement;
-export declare const isInputLike: (target: Element | EventTarget | null) => target is HTMLBRElement | HTMLDivElement | HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement;
+export declare const isInputLike: (target: Element | EventTarget | null) => target is HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | HTMLBRElement | HTMLDivElement;
 export declare const isInteractive: (target: Element | EventTarget | null) => boolean;
-export declare const isWritableElement: (target: Element | EventTarget | null) => target is HTMLBRElement | HTMLDivElement | HTMLInputElement | HTMLTextAreaElement;
+export declare const isWritableElement: (target: Element | EventTarget | null) => target is HTMLInputElement | HTMLTextAreaElement | HTMLBRElement | HTMLDivElement;
 export declare const getFontFamilyString: ({ fontFamily, }: {
     fontFamily: FontFamilyValues;
 }) => string;
@@ -71,18 +71,20 @@ export declare const easeToValuesRAF: <T extends Record<keyof T, number>, K exte
      * Interpolate a single value.
      * Return undefined to be handled by the default interpolator.
      */
-    interpolateValue?: ((fromValue: number, toValue: number, progress: number, key: K) => number | undefined) | undefined;
+    interpolateValue?: (fromValue: number, toValue: number, 
+    /** no easing applied  */
+    progress: number, key: K) => number | undefined;
     onStep: (values: T) => void;
-    duration?: number | undefined;
-    onStart?: (() => void) | undefined;
-    onEnd?: (() => void) | undefined;
-    onCancel?: (() => void) | undefined;
+    duration?: number;
+    onStart?: () => void;
+    onEnd?: () => void;
+    onCancel?: () => void;
 }) => () => void;
-export declare const chunk: <T extends unknown>(array: readonly T[], size: number) => T[][];
+export declare const chunk: <T extends any>(array: readonly T[], size: number) => T[][];
 export declare const selectNode: (node: Element) => void;
 export declare const removeSelection: () => void;
 export declare const distance: (x: number, y: number) => number;
-export declare const isSelectionLikeTool: (type: ToolType | "custom") => boolean;
+export declare const isSelectionLikeTool: (type: ToolType | "custom") => type is "selection" | "lasso";
 export declare const updateActiveTool: (appState: Pick<AppState, "activeTool">, data: (({
     type: ToolType;
 } | {
@@ -140,7 +142,7 @@ export declare const muteFSAbortError: (error?: Error) => void;
 export declare const findIndex: <T>(array: readonly T[], cb: (element: T, index: number, array: readonly T[]) => boolean, fromIndex?: number) => number;
 export declare const findLastIndex: <T>(array: readonly T[], cb: (element: T, index: number, array: readonly T[]) => boolean, fromIndex?: number) => number;
 /** returns the first non-null mapped value */
-export declare const mapFind: <T, K>(collection: readonly T[], iteratee: (value: T, index: number) => K | null | undefined) => K | undefined;
+export declare const mapFind: <T, K>(collection: readonly T[], iteratee: (value: T, index: number) => K | undefined | null) => K | undefined;
 export declare const isTransparent: (color: string) => boolean;
 export type ResolvablePromise<T> = Promise<T> & {
     resolve: [T] extends [undefined] ? (value?: MaybePromise<Awaited<T>>) => void : (value: MaybePromise<Awaited<T>>) => void;
@@ -159,16 +161,16 @@ export declare const getUpdatedTimestamp: () => number;
  * Transforms array of objects containing `id` attribute,
  * or array of ids (strings), into a Map, keyd by `id`.
  */
-export declare const arrayToMap: <T extends string | {
+export declare const arrayToMap: <T extends {
     id: string;
-}>(items: Map<string, T> | readonly T[]) => Map<string, T>;
+} | string>(items: readonly T[] | Map<string, T>) => Map<string, T>;
 export declare const arrayToMapWithIndex: <T extends {
     id: string;
 }>(elements: readonly T[]) => Map<string, [element: T, index: number]>;
 /**
  * Transform array into an object, use only when array order is irrelevant.
  */
-export declare const arrayToObject: <T>(array: readonly T[], groupBy?: ((value: T) => string | number) | undefined) => {
+export declare const arrayToObject: <T>(array: readonly T[], groupBy?: (value: T) => string | number) => {
     [key: string]: T;
 };
 /** Doubly linked node */
@@ -184,11 +186,11 @@ export declare const arrayToList: <T>(array: readonly T[]) => Node<T>[];
  * Converts a readonly array or map into an iterable.
  * Useful for avoiding entry allocations when iterating object / map on each iteration.
  */
-export declare const toIterable: <T>(values: ReadonlyMap<string, T> | readonly T[]) => Iterable<T>;
+export declare const toIterable: <T>(values: readonly T[] | ReadonlyMap<string, T>) => Iterable<T>;
 /**
  * Converts a readonly array or map into an array.
  */
-export declare const toArray: <T>(values: ReadonlyMap<string, T> | readonly T[]) => T[];
+export declare const toArray: <T>(values: readonly T[] | ReadonlyMap<string, T>) => T[];
 export declare const isTestEnv: () => boolean;
 export declare const isDevEnv: () => boolean;
 export declare const isProdEnv: () => boolean;
@@ -200,18 +202,18 @@ export declare const updateObject: <T extends Record<string, any>>(obj: T, updat
 export declare const isPrimitive: (val: any) => boolean;
 export declare const getFrame: () => "top" | "iframe";
 export declare const isRunningInIframe: () => boolean;
-export declare const isPromiseLike: (value: any) => value is Promise<any>;
+export declare const isPromiseLike: (value: any) => value is Promise<ResolutionType<typeof value>>;
 export declare const queryFocusableElements: (container: HTMLElement | null) => HTMLElement[];
 /**
  * Returns whether object/array is shallow equal.
  * Considers empty object/arrays as equal (whether top-level or second-level).
  */
-export declare const isShallowEqual: <T extends Record<string, any>, K extends readonly unknown[]>(objA: T, objB: T, comparators?: { [key in keyof T]?: ((a: T[key], b: T[key]) => boolean) | undefined; } | (keyof T extends K[number] ? K extends readonly (keyof T)[] ? K : {
+export declare const isShallowEqual: <T extends Record<string, any>, K extends readonly unknown[]>(objA: T, objB: T, comparators?: { [key in keyof T]?: (a: T[key], b: T[key]) => boolean; } | (keyof T extends K[number] ? K extends readonly (keyof T)[] ? K : {
     _error: "keys are either missing or include keys not in compared obj";
 } : {
     _error: "keys are either missing or include keys not in compared obj";
-}) | undefined, debug?: boolean) => boolean;
-export declare const composeEventHandlers: <E>(originalEventHandler?: ((event: E) => void) | undefined, ourEventHandler?: ((event: E) => void) | undefined, { checkForDefaultPrevented }?: {
+}), debug?: boolean) => boolean;
+export declare const composeEventHandlers: <E>(originalEventHandler?: (event: E) => void, ourEventHandler?: (event: E) => void, { checkForDefaultPrevented }?: {
     checkForDefaultPrevented?: boolean | undefined;
 }) => (event: E) => void;
 /**
@@ -223,11 +225,15 @@ export declare function invariant(condition: any, message: string): asserts cond
 /**
  * Memoizes on values of `opts` object (strict equality).
  */
-export declare const memoize: <T extends Record<string, any>, R extends unknown>(func: (opts: T) => R) => ((opts: T) => R) & {
+export declare const memoize: <T extends Record<string, any>, R extends any>(func: (opts: T) => R) => typeof func & {
     clear: () => void;
 };
 /** Checks if value is inside given collection. Useful for type-safety. */
-export declare const isMemberOf: <T extends string>(collection: Set<T> | Record<T, any> | Map<T, any> | readonly T[], value: string) => value is T;
+export declare const isMemberOf: <T extends string>(
+/** Set/Map/Array/Object */
+collection: Set<T> | readonly T[] | Record<T, any> | Map<T, any>, 
+/** value to look for */
+value: string) => value is T;
 export declare const cloneJSON: <T>(obj: T) => T;
 export declare const updateStable: <T extends any[] | Record<string, any>>(prevValue: T, nextValue: T) => T;
 export declare function addEventListener<K extends keyof WindowEventMap>(target: Window & typeof globalThis, type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | AddEventListenerOptions): UnsubscribeCallback;
@@ -238,21 +244,25 @@ export declare function addEventListener<K extends keyof FontFaceSetEventMap>(ta
 export declare function addEventListener<K extends keyof HTMLElementEventMap>(target: Document | (Window & typeof globalThis) | HTMLElement | undefined | null | false, type: K, listener: (this: HTMLDivElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): UnsubscribeCallback;
 export declare function getSvgPathFromStroke(points: number[][], closed?: boolean): string;
 export declare const normalizeEOL: (str: string) => string;
-type HasBrand<T> = {
-    [K in keyof T]: K extends `~brand${infer _}` ? true : never;
+export type HasBrand<T> = {
+    [K in keyof T]: K extends `~brand${infer _}` | "_brand" ? true : never;
 }[keyof T];
 type RemoveAllBrands<T> = HasBrand<T> extends true ? {
-    [K in keyof T as K extends `~brand~${infer _}` ? never : K]: T[K];
-} : never;
-type Unbrand<T> = T extends Map<infer E, infer F> ? Map<E, F> : T extends Set<infer E> ? Set<E> : T extends Array<infer E> ? Array<E> : RemoveAllBrands<T>;
+    [K in keyof T as K extends `~brand~${infer _}` | "_brand" ? never : K]: T[K];
+} : T;
+type UnbrandForValue<T> = T extends Map<infer E, infer F> ? Map<UnbrandForValue<E>, UnbrandForValue<F>> : T extends Set<infer E> ? Set<UnbrandForValue<E>> : T extends readonly any[] ? T extends any[] ? unknown[] : readonly unknown[] : RemoveAllBrands<T>;
+export type Unbrand<T> = T extends Map<infer E, infer F> ? Map<Unbrand<E>, Unbrand<F>> : T extends Set<infer E> ? Set<Unbrand<E>> : T extends readonly (infer E)[] ? Array<Unbrand<E>> : RemoveAllBrands<T>;
+export type CombineBrands<BrandedType, CurrentType> = BrandedType extends readonly (infer BE)[] ? CurrentType extends readonly (infer CE)[] ? Array<CE & BE> : CurrentType & BrandedType : CurrentType & BrandedType;
+export type CombineBrandsIfNeeded<T, Required> = [T] extends [Required] ? T[] : HasBrand<T> extends true ? CombineBrands<T, Required>[] : Required[];
 /**
  * Makes type into a branded type, ensuring that value is assignable to
- * the base ubranded type. Optionally you can explicitly supply current value
+ * the base unbranded type. Optionally you can explicitly supply current value
  * type to combine both (useful for composite branded types. Make sure you
  * compose branded types which are not composite themselves.)
  */
-export declare const toBrandedType: <BrandedType, CurrentType = BrandedType>(value: Unbrand<BrandedType>) => CurrentType & BrandedType;
-export declare const promiseTry: <TValue, TArgs extends unknown[]>(fn: (...args: TArgs) => TValue | PromiseLike<TValue>, ...args: TArgs) => Promise<TValue>;
+export declare function toBrandedType<BrandedType>(value: UnbrandForValue<BrandedType>): BrandedType;
+export declare function toBrandedType<BrandedType, CurrentType>(value: CurrentType): CombineBrands<BrandedType, CurrentType>;
+export declare const promiseTry: <TValue, TArgs extends unknown[]>(fn: (...args: TArgs) => PromiseLike<TValue> | TValue, ...args: TArgs) => Promise<TValue>;
 export declare const isAnyTrue: (...args: boolean[]) => boolean;
 export declare const safelyParseJSON: (json: string) => Record<string, any> | null;
 /**
@@ -264,10 +274,10 @@ export declare const castArray: <T>(value: T | T[]) => T[];
 /** hack for Array.isArray type guard not working with readonly value[] */
 export declare const isReadonlyArray: (value?: any) => value is readonly any[];
 export declare const sizeOf: (value: readonly unknown[] | Readonly<Map<string, unknown>> | Readonly<Record<string, unknown>> | ReadonlySet<unknown>) => number;
-export declare const reduceToCommonValue: <T, R = T>(collection: ReadonlySet<T> | readonly T[], getValue?: ((item: T) => R) | undefined) => R | null;
+export declare const reduceToCommonValue: <T, R = T>(collection: readonly T[] | ReadonlySet<T>, getValue?: (item: T) => R) => R | null;
 type FEATURE_FLAGS = {
     COMPLEX_BINDINGS: boolean;
 };
-export declare const getFeatureFlag: <F extends "COMPLEX_BINDINGS">(flag: F) => FEATURE_FLAGS[F];
-export declare const setFeatureFlag: <F extends "COMPLEX_BINDINGS">(flag: F, value: FEATURE_FLAGS[F]) => void;
+export declare const getFeatureFlag: <F extends keyof FEATURE_FLAGS>(flag: F) => FEATURE_FLAGS[F];
+export declare const setFeatureFlag: <F extends keyof FEATURE_FLAGS>(flag: F, value: FEATURE_FLAGS[F]) => void;
 export {};

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

@@ -1,7 +1,7 @@
 import { type GlobalPoint, type LocalPoint } from "@excalidraw/math";
 import type { Curve } from "@excalidraw/math";
 import type { LineSegment } from "@excalidraw/utils";
-import type { Bounds } from "@excalidraw/element";
+import { type Bounds } from "./bounds";
 declare global {
     interface Window {
         visualDebug?: {

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

@@ -1,5 +1,5 @@
 import { type ElementUpdate } from "@excalidraw/element";
-import type { ExcalidrawElement, NonDeletedExcalidrawElement, NonDeleted, ExcalidrawFrameLikeElement, ElementsMapOrArray, OrderedExcalidrawElement, Ordered } from "@excalidraw/element/types";
+import type { ExcalidrawElement, NonDeletedExcalidrawElement, NonDeleted, ExcalidrawFrameLikeElement, ElementsMapOrArray, SceneElementsMap, NonDeletedSceneElementsMap, OrderedExcalidrawElement, Ordered } from "@excalidraw/element/types";
 import type { Mutable } from "@excalidraw/common/utility-types";
 import type { AppState } from "../../excalidraw/types";
 type SceneStateCallback = () => void;
@@ -22,9 +22,9 @@ export declare class Scene {
      */
     private sceneNonce;
     getSceneNonce(): number | undefined;
-    getNonDeletedElementsMap(): Map<string, Ordered<NonDeletedExcalidrawElement>> & import("@excalidraw/common/utility-types").MakeBrand<"NonDeletedSceneElementsMap">;
+    getNonDeletedElementsMap(): NonDeletedSceneElementsMap;
     getElementsIncludingDeleted(): readonly OrderedExcalidrawElement[];
-    getElementsMapIncludingDeleted(): Map<string, Ordered<ExcalidrawElement>> & import("@excalidraw/common/utility-types").MakeBrand<"SceneElementsMap">;
+    getElementsMapIncludingDeleted(): SceneElementsMap;
     getNonDeletedElements(): readonly Ordered<NonDeletedExcalidrawElement>[];
     getFramesIncludingDeleted(): readonly ExcalidrawFrameLikeElement[];
     constructor(elements?: ElementsMapOrArray | null, options?: {

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

@@ -1,9 +1,9 @@
 import { type GlobalPoint } from "@excalidraw/math";
 import type { LineSegment, LocalPoint } from "@excalidraw/math";
 import type { AppState } from "@excalidraw/excalidraw/types";
+import type { Bounds } from "@excalidraw/common";
 import { type Heading } from "./heading";
 import type { Scene } from "./Scene";
-import type { Bounds } from "./bounds";
 import type { ElementUpdate } from "./mutateElement";
 import type { BindMode, ElementsMap, ExcalidrawArrowElement, ExcalidrawBindableElement, ExcalidrawElbowArrowElement, ExcalidrawElement, FixedPoint, FixedPointBinding, NonDeleted, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap, Ordered, PointsPositionUpdates } from "./types";
 export type BindingStrategy = {
@@ -30,17 +30,18 @@ export declare const getBindingGap: (bindTarget: ExcalidrawBindableElement, opts
 export declare const maxBindingDistance_simple: (zoom?: AppState["zoom"]) => number;
 export declare const shouldEnableBindingForPointerEvent: (event: React.PointerEvent<HTMLElement>) => boolean;
 export declare const isBindingEnabled: (appState: AppState) => boolean;
-export declare const bindOrUnbindBindingElement: (arrow: NonDeleted<ExcalidrawArrowElement>, draggingPoints: PointsPositionUpdates, scene: Scene, appState: AppState, opts?: {
+export declare const bindOrUnbindBindingElement: (arrow: NonDeleted<ExcalidrawArrowElement>, draggingPoints: PointsPositionUpdates, scenePointerX: number, scenePointerY: number, scene: Scene, appState: AppState, opts?: {
     newArrow?: boolean;
     altKey?: boolean;
+    angleLocked?: boolean;
     initialBinding?: boolean;
 }) => {
     start: BindingStrategy;
     end: BindingStrategy;
 };
-export declare const getBindingStrategyForDraggingBindingElementEndpoints: (arrow: NonDeleted<ExcalidrawArrowElement>, draggingPoints: PointsPositionUpdates, elementsMap: NonDeletedSceneElementsMap, elements: readonly Ordered<NonDeletedExcalidrawElement>[], appState: AppState, opts?: {
+export declare const getBindingStrategyForDraggingBindingElementEndpoints: (arrow: NonDeleted<ExcalidrawArrowElement>, draggingPoints: PointsPositionUpdates, screenPointerX: number, screenPointerY: number, elementsMap: NonDeletedSceneElementsMap, elements: readonly Ordered<NonDeletedExcalidrawElement>[], appState: AppState, opts?: {
     newArrow?: boolean;
-    shiftKey?: boolean;
+    angleLocked?: boolean;
     altKey?: boolean;
     finalize?: boolean;
     initialBinding?: boolean;
@@ -120,3 +121,4 @@ export declare const getGlobalFixedPointForBindableElement: (fixedPointRatio: Fi
 export declare const getGlobalFixedPoints: (arrow: ExcalidrawArrowElement, elementsMap: ElementsMap) => [GlobalPoint, GlobalPoint];
 export declare const getArrowLocalFixedPoints: (arrow: ExcalidrawElbowArrowElement, elementsMap: ElementsMap) => LocalPoint[];
 export declare const normalizeFixedPoint: <T extends FixedPoint | null>(fixedPoint: T) => T extends null ? null : FixedPoint;
+export declare const getBindingSideMidPoint: (binding: FixedPointBinding, elementsMap: ElementsMap) => GlobalPoint | LocalPoint | null;

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

@@ -1,3 +1,4 @@
+import { type Bounds } from "@excalidraw/common";
 import type { Degrees, GlobalPoint, LineSegment, LocalPoint } from "@excalidraw/math";
 import type { AppState } from "@excalidraw/excalidraw/types";
 import type { Drawable, Op } from "roughjs/bin/core";
@@ -9,15 +10,6 @@ export type RectangleBox = {
     height: number;
     angle: number;
 };
-/**
- * x and y position of top left corner, x and y position of bottom right corner
- */
-export type Bounds = readonly [
-    minX: number,
-    minY: number,
-    maxX: number,
-    maxY: number
-];
 export type SceneBounds = readonly [
     sceneX: number,
     sceneY: number,
@@ -45,7 +37,7 @@ export declare const getElementLineSegments: (element: ExcalidrawElement, elemen
 export declare const getRectangleBoxAbsoluteCoords: (boxSceneCoords: RectangleBox) => number[];
 export declare const getDiamondPoints: (element: ExcalidrawElement) => number[];
 export declare const getCubicBezierCurveBound: (p0: GlobalPoint, p1: GlobalPoint, p2: GlobalPoint, p3: GlobalPoint) => Bounds;
-export declare const getMinMaxXYFromCurvePathOps: (ops: Op[], transformXY?: ((p: GlobalPoint) => GlobalPoint) | undefined) => Bounds;
+export declare const getMinMaxXYFromCurvePathOps: (ops: Op[], transformXY?: (p: GlobalPoint) => GlobalPoint) => Bounds;
 export declare const getBoundsFromPoints: (points: ExcalidrawFreeDrawElement["points"]) => Bounds;
 /** @returns number in pixels */
 export declare const getArrowheadSize: (arrowhead: Arrowhead) => number;

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

@@ -14,8 +14,8 @@ export declare const hitElementItself: ({ point, element, threshold, elementsMap
 export declare const hitElementBoundingBox: (point: GlobalPoint, element: ExcalidrawElement, elementsMap: ElementsMap, tolerance?: number) => boolean;
 export declare const hitElementBoundingBoxOnly: (hitArgs: HitTestArgs, elementsMap: ElementsMap) => boolean;
 export declare const hitElementBoundText: (point: GlobalPoint, element: ExcalidrawElement, elementsMap: ElementsMap) => boolean;
-export declare const getAllHoveredElementAtPoint: (point: Readonly<GlobalPoint>, elements: readonly Ordered<NonDeletedExcalidrawElement>[], elementsMap: NonDeletedSceneElementsMap, toleranceFn?: ((element: ExcalidrawBindableElement) => number) | undefined) => NonDeleted<ExcalidrawBindableElement>[];
-export declare const getHoveredElementForBinding: (point: Readonly<GlobalPoint>, elements: readonly Ordered<NonDeletedExcalidrawElement>[], elementsMap: NonDeletedSceneElementsMap, toleranceFn?: ((element: ExcalidrawBindableElement) => number) | undefined) => NonDeleted<ExcalidrawBindableElement> | null;
+export declare const getAllHoveredElementAtPoint: (point: Readonly<GlobalPoint>, elements: readonly Ordered<NonDeletedExcalidrawElement>[], elementsMap: NonDeletedSceneElementsMap, toleranceFn?: (element: ExcalidrawBindableElement) => number) => NonDeleted<ExcalidrawBindableElement>[];
+export declare const getHoveredElementForBinding: (point: Readonly<GlobalPoint>, elements: readonly Ordered<NonDeletedExcalidrawElement>[], elementsMap: NonDeletedSceneElementsMap, toleranceFn?: (element: ExcalidrawBindableElement) => number) => NonDeleted<ExcalidrawBindableElement> | null;
 /**
  * Intersect a line with an element for binding test
  *

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

@@ -1,8 +1,8 @@
 import type { ElementOrToolType } from "@excalidraw/excalidraw/types";
-export declare const hasBackground: (type: ElementOrToolType) => boolean;
-export declare const hasStrokeColor: (type: ElementOrToolType) => boolean;
-export declare const hasStrokeWidth: (type: ElementOrToolType) => boolean;
-export declare const hasStrokeStyle: (type: ElementOrToolType) => boolean;
-export declare const canChangeRoundness: (type: ElementOrToolType) => boolean;
-export declare const toolIsArrow: (type: ElementOrToolType) => boolean;
-export declare const canHaveArrowheads: (type: ElementOrToolType) => boolean;
+export declare const hasBackground: (type: ElementOrToolType) => type is "line" | "rectangle" | "diamond" | "ellipse" | "embeddable" | "iframe" | "freedraw";
+export declare const hasStrokeColor: (type: ElementOrToolType) => type is "line" | "arrow" | "text" | "rectangle" | "diamond" | "ellipse" | "embeddable" | "freedraw";
+export declare const hasStrokeWidth: (type: ElementOrToolType) => type is "line" | "arrow" | "rectangle" | "diamond" | "ellipse" | "embeddable" | "iframe" | "freedraw";
+export declare const hasStrokeStyle: (type: ElementOrToolType) => type is "line" | "arrow" | "rectangle" | "diamond" | "ellipse" | "embeddable" | "iframe";
+export declare const canChangeRoundness: (type: ElementOrToolType) => type is "line" | "rectangle" | "diamond" | "embeddable" | "iframe" | "image";
+export declare const toolIsArrow: (type: ElementOrToolType) => type is "arrow";
+export declare const canHaveArrowheads: (type: ElementOrToolType) => type is "arrow";

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

@@ -24,10 +24,10 @@ export declare const dragNewElement: ({ newElement, elementType, originX, origin
     scene: Scene;
     /** whether to keep given aspect ratio when `isResizeWithSidesSameLength` is
         true */
-    widthAspectRatio?: number | null | undefined;
+    widthAspectRatio?: number | null;
     originOffset?: {
         x: number;
         y: number;
-    } | null | undefined;
-    informMutation?: boolean | undefined;
+    } | null;
+    informMutation?: boolean;
 }) => void;

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

@@ -17,12 +17,12 @@ import type { ExcalidrawElement, GroupId } from "./types";
 export declare const duplicateElement: <TElement extends ExcalidrawElement>(editingGroupId: AppState["editingGroupId"], groupIdMapForOperation: Map<GroupId, GroupId>, element: TElement, randomizeSeed?: boolean) => Readonly<TElement>;
 export declare const duplicateElements: (opts: {
     elements: readonly ExcalidrawElement[];
-    randomizeSeed?: boolean | undefined;
-    overrides?: ((data: {
+    randomizeSeed?: boolean;
+    overrides?: (data: {
         duplicateElement: ExcalidrawElement;
         origElement: ExcalidrawElement;
         origIdToDuplicateId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>;
-    }) => Partial<ExcalidrawElement>) | undefined;
+    }) => Partial<ExcalidrawElement>;
 } & ({
     /**
      * Duplicates all elements in array.

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

@@ -26,11 +26,11 @@ export declare class InvalidFractionalIndexError extends Error {
 export declare const validateFractionalIndices: (elements: readonly ExcalidrawElement[], { shouldThrow, includeBoundTextValidation, ignoreLogs, reconciliationContext, }: {
     shouldThrow: boolean;
     includeBoundTextValidation: boolean;
-    ignoreLogs?: true | undefined;
+    ignoreLogs?: true;
     reconciliationContext?: {
         localElements: ReadonlyArray<ExcalidrawElement>;
         remoteElements: ReadonlyArray<ExcalidrawElement>;
-    } | undefined;
+    };
 }) => void;
 /**
  * Order the elements based on the fractional indices.

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

@@ -53,7 +53,11 @@ export declare const updateFrameMembershipOfSelectedElements: <T extends Element
  * filters out elements that are inside groups that contain a frame element
  * anywhere in the group tree
  */
-export declare const omitGroupsContainingFrameLikes: (allElements: ElementsMapOrArray, selectedElements?: readonly ExcalidrawElement[]) => ExcalidrawElement[];
+export declare const omitGroupsContainingFrameLikes: (allElements: ElementsMapOrArray, 
+/** subset of elements you want to filter. Optional perf optimization so we
+ * don't have to filter all elements unnecessarily
+ */
+selectedElements?: readonly ExcalidrawElement[]) => ExcalidrawElement[];
 /**
  * depending on the appState, return target frame, which is the frame the given element
  * is going to be added to or remove from

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

@@ -1,3 +1,4 @@
+import { type Bounds } from "@excalidraw/common";
 import type { LocalPoint, GlobalPoint, Vector } from "@excalidraw/math";
 import type { ExcalidrawBindableElement } from "./types";
 export declare const HEADING_RIGHT: Heading;
@@ -11,5 +12,5 @@ export declare const headingForPointIsHorizontal: <P extends GlobalPoint | Local
 export declare const compareHeading: (a: Heading, b: Heading) => boolean;
 export declare const headingIsHorizontal: (a: Heading) => boolean;
 export declare const headingIsVertical: (a: Heading) => boolean;
-export declare const headingForPointFromElement: <Point extends GlobalPoint>(element: Readonly<ExcalidrawBindableElement>, aabb: readonly [minX: number, minY: number, maxX: number, maxY: number], p: Readonly<Point>) => Heading;
+export declare const headingForPointFromElement: <Point extends GlobalPoint>(element: Readonly<ExcalidrawBindableElement>, aabb: Readonly<Bounds>, p: Readonly<Point>) => Heading;
 export declare const flipHeading: (h: Heading) => Heading;

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

@@ -10,17 +10,7 @@ export declare const updateImageCache: ({ fileIds, files, imageCache, }: {
 }) => Promise<{
     imageCache: Map<FileId, {
         image: HTMLImageElement | Promise<HTMLImageElement>;
-        mimeType: import("../../common/src/utility-types").ValueOf<{
-            readonly svg: "image/svg+xml";
-            readonly png: "image/png";
-            readonly jpg: "image/jpeg";
-            readonly gif: "image/gif";
-            readonly webp: "image/webp";
-            readonly bmp: "image/bmp";
-            readonly ico: "image/x-icon";
-            readonly avif: "image/avif";
-            readonly jfif: "image/jfif";
-        }>;
+        mimeType: import("@excalidraw/common/utility-types").ValueOf<typeof import("@excalidraw/common").IMAGE_MIME_TYPES>;
     }>;
     /** includes errored files because they cache was updated nonetheless */
     updatedFiles: Map<FileId, true>;

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

@@ -49,6 +49,7 @@ export * from "./store";
 export * from "./textElement";
 export * from "./textMeasurements";
 export * from "./textWrapping";
+export * from "./transform";
 export * from "./transformHandles";
 export * from "./typeChecks";
 export * from "./utils";

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

@@ -1,9 +1,8 @@
-/// <reference types="react" />
 import { type GlobalPoint, type LocalPoint } from "@excalidraw/math";
 import { type Store } from "@excalidraw/element";
 import type { AppState, PointerCoords, InteractiveCanvasAppState, AppClassProperties, NullableGridSize, Zoom } from "@excalidraw/excalidraw/types";
+import type { Bounds } from "@excalidraw/common";
 import type { Scene } from "./Scene";
-import type { Bounds } from "./bounds";
 import type { NonDeleted, ExcalidrawLinearElement, ExcalidrawElement, ExcalidrawTextElementWithContainer, ElementsMap, NonDeletedSceneElementsMap, FixedPointBinding, ExcalidrawElbowArrowElement, PointsPositionUpdates } from "./types";
 export declare class LinearElementEditor {
     readonly elementId: ExcalidrawElement["id"] & {

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

@@ -12,7 +12,9 @@ export type ElementUpdate<TElement extends ExcalidrawElement> = Omit<Partial<TEl
 export declare const mutateElement: <TElement extends Mutable<ExcalidrawElement>>(element: TElement, elementsMap: ElementsMap, updates: ElementUpdate<TElement>, options?: {
     isDragging?: boolean;
 }) => TElement;
-export declare const newElementWith: <TElement extends ExcalidrawElement>(element: TElement, updates: ElementUpdate<TElement>, force?: boolean) => TElement;
+export declare const newElementWith: <TElement extends ExcalidrawElement>(element: TElement, updates: ElementUpdate<TElement>, 
+/** pass `true` to always regenerate */
+force?: boolean) => TElement;
 /**
  * Mutates element, bumping `version`, `versionNonce`, and `updated`.
  *

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

@@ -47,12 +47,12 @@ export declare const newLinearElement: (opts: {
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawLinearElement>;
 export declare const newArrowElement: <T extends boolean>(opts: {
     type: ExcalidrawArrowElement["type"];
-    startArrowhead?: Arrowhead | null | undefined;
-    endArrowhead?: Arrowhead | null | undefined;
-    points?: readonly import("@excalidraw/math").LocalPoint[] | undefined;
-    elbowed?: T | undefined;
-    fixedSegments?: readonly import("./types").FixedSegment[] | null | undefined;
-} & Omit<Omit<ExcalidrawGenericElement, "id" | "isDeleted" | "updated" | "type">, "link" | "strokeColor" | "backgroundColor" | "fillStyle" | "strokeWidth" | "strokeStyle" | "roundness" | "roughness" | "opacity" | "width" | "height" | "angle" | "seed" | "version" | "versionNonce" | "index" | "groupIds" | "frameId" | "boundElements" | "locked" | "customData"> & Partial<Pick<Omit<ExcalidrawGenericElement, "id" | "isDeleted" | "updated" | "type">, "link" | "strokeColor" | "backgroundColor" | "fillStyle" | "strokeWidth" | "strokeStyle" | "roundness" | "roughness" | "opacity" | "width" | "height" | "angle" | "seed" | "version" | "versionNonce" | "index" | "groupIds" | "frameId" | "boundElements" | "locked" | "customData">>) => T extends true ? NonDeleted<ExcalidrawElbowArrowElement> : NonDeleted<ExcalidrawArrowElement>;
+    startArrowhead?: Arrowhead | null;
+    endArrowhead?: Arrowhead | null;
+    points?: ExcalidrawArrowElement["points"];
+    elbowed?: T;
+    fixedSegments?: ExcalidrawElbowArrowElement["fixedSegments"] | null;
+} & ElementConstructorOpts) => T extends true ? NonDeleted<ExcalidrawElbowArrowElement> : NonDeleted<ExcalidrawArrowElement>;
 export declare const newImageElement: (opts: {
     type: ExcalidrawImageElement["type"];
     status?: ExcalidrawImageElement["status"];

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

@@ -3,7 +3,6 @@ import type { AppState, StaticCanvasAppState, InteractiveCanvasAppState, Element
 import type { StaticCanvasRenderConfig, RenderableElementsMap, InteractiveCanvasRenderConfig } from "@excalidraw/excalidraw/scene/types";
 import type { ExcalidrawElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, ExcalidrawFreeDrawElement, ExcalidrawImageElement, ExcalidrawFrameLikeElement, NonDeletedSceneElementsMap, ElementsMap } from "./types";
 import type { RoughCanvas } from "roughjs/bin/canvas";
-export declare const IMAGE_INVERT_FILTER = "invert(100%) hue-rotate(180deg) saturate(1.25)";
 export declare const getRenderOpacity: (element: ExcalidrawElement, containingFrame: ExcalidrawFrameLikeElement | null, elementsPendingErasure: ElementsPendingErasure, pendingNodes: Readonly<PendingExcalidrawElements> | null, globalAlpha?: number) => number;
 export interface ExcalidrawElementWithCanvas {
     element: ExcalidrawElement | ExcalidrawTextElement;
@@ -23,9 +22,4 @@ export declare const DEFAULT_LINK_SIZE = 14;
 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) => void;
-export declare const pathsCache: WeakMap<ExcalidrawFreeDrawElement, Path2D>;
-export declare function generateFreeDrawShape(element: ExcalidrawFreeDrawElement): Path2D;
-export declare function getFreeDrawPath2D(element: ExcalidrawFreeDrawElement): Path2D | undefined;
-export declare function getFreeDrawSvgPath(element: ExcalidrawFreeDrawElement): string;
 export declare function getFreedrawOutlineAsSegments(element: ExcalidrawFreeDrawElement, points: [number, number][], elementsMap: ElementsMap): import("@excalidraw/math").LineSegment<GlobalPoint>[];
-export declare function getFreedrawOutlinePoints(element: ExcalidrawFreeDrawElement): [number, number][];

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

@@ -17,16 +17,16 @@ export declare const resizeSingleTextElement: (origElement: NonDeleted<Excalidra
 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, originalElementsMap: ElementsMap, scene: Scene, handleDirection: TransformHandleDirection, { shouldInformMutation, shouldMaintainAspectRatio, shouldResizeFromCenter, }?: {
-    shouldMaintainAspectRatio?: boolean | undefined;
-    shouldResizeFromCenter?: boolean | undefined;
-    shouldInformMutation?: boolean | undefined;
+    shouldMaintainAspectRatio?: boolean;
+    shouldResizeFromCenter?: boolean;
+    shouldInformMutation?: boolean;
 }) => void;
 export declare const resizeMultipleElements: (selectedElements: readonly NonDeletedExcalidrawElement[], elementsMap: ElementsMap, handleDirection: TransformHandleDirection, scene: Scene, originalElementsMap: ElementsMap, { shouldMaintainAspectRatio, shouldResizeFromCenter, flipByX, flipByY, nextHeight, nextWidth, originalBoundingBox, }?: {
-    nextWidth?: number | undefined;
-    nextHeight?: number | undefined;
-    shouldMaintainAspectRatio?: boolean | undefined;
-    shouldResizeFromCenter?: boolean | undefined;
-    flipByX?: boolean | undefined;
-    flipByY?: boolean | undefined;
-    originalBoundingBox?: BoundingBox | undefined;
+    nextWidth?: number;
+    nextHeight?: number;
+    shouldMaintainAspectRatio?: boolean;
+    shouldResizeFromCenter?: boolean;
+    flipByX?: boolean;
+    flipByY?: boolean;
+    originalBoundingBox?: BoundingBox;
 }) => void;

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

@@ -1,7 +1,7 @@
 import { type EditorInterface } from "@excalidraw/common";
 import type { GlobalPoint, LocalPoint } from "@excalidraw/math";
 import type { AppState, Zoom } from "@excalidraw/excalidraw/types";
-import type { Bounds } from "./bounds";
+import type { Bounds } from "@excalidraw/common";
 import type { MaybeTransformHandleType } from "./transformHandles";
 import type { ExcalidrawElement, PointerType, NonDeletedExcalidrawElement, ElementsMap } from "./types";
 export declare const resizeTest: <Point extends GlobalPoint | LocalPoint>(element: NonDeletedExcalidrawElement, elementsMap: ElementsMap, appState: AppState, x: number, y: number, zoom: Zoom, pointerType: PointerType, editorInterface: EditorInterface) => MaybeTransformHandleType;