@excalidraw/element 0.18.0-91c7748 → 0.18.0-a52cd20

package/dist/types/excalidraw/scene/types.d.ts

@@ -1,7 +1,7 @@
-import type { UserIdleState } from "@excalidraw/common";
+import type { UserIdleState, EditorInterface } from "@excalidraw/common";
 import type { ExcalidrawElement, NonDeletedElementsMap, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap } from "@excalidraw/element/types";
 import type { MakeBrand } from "@excalidraw/common/utility-types";
-import type { AppClassProperties, AppState, EmbedsValidationStatus, ElementsPendingErasure, InteractiveCanvasAppState, StaticCanvasAppState, SocketId, Device, PendingExcalidrawElements } from "../types";
+import type { AppClassProperties, AppState, EmbedsValidationStatus, ElementRenderOverrides, ElementsPendingErasure, InteractiveCanvasAppState, StaticCanvasAppState, SocketId, PendingExcalidrawElements } from "../types";
 import type { RoughCanvas } from "roughjs/bin/canvas";
 import type { Drawable } from "roughjs/bin/core";
 export type RenderableElementsMap = NonDeletedElementsMap & MakeBrand<"RenderableElementsMap">;
@@ -9,12 +9,17 @@ export type StaticCanvasRenderConfig = {
     canvasBackgroundColor: AppState["viewBackgroundColor"];
     imageCache: AppClassProperties["imageCache"];
     renderGrid: boolean;
+    /** whether to render link icons on elements with links (never rendered
+     when exporting). @default true */
+    renderLinks?: boolean;
     /** when exporting the behavior is slightly different (e.g. we can't use
      CSS filters), and we disable render optimizations for best output */
     isExporting: boolean;
     embedsValidationStatus: EmbedsValidationStatus;
     elementsPendingErasure: ElementsPendingErasure;
     pendingFlowchartNodes: PendingExcalidrawElements | null;
+    theme: AppState["theme"];
+    elementRenderOverrides?: ElementRenderOverrides;
 };
 export type SVGRenderConfig = {
     offsetX: number;
@@ -32,6 +37,7 @@ export type SVGRenderConfig = {
      * @default true
      */
     reuseImages: boolean;
+    theme: AppState["theme"];
 };
 export type InteractiveCanvasRenderConfig = {
     remoteSelectedElementIds: Map<ExcalidrawElement["id"], SocketId[]>;
@@ -43,11 +49,13 @@ export type InteractiveCanvasRenderConfig = {
     remotePointerUsernames: Map<SocketId, string>;
     remotePointerButton: Map<SocketId, string | undefined>;
     selectionColor: string;
+    lastViewportPosition: {
+        x: number;
+        y: number;
+    };
     renderScrollbars?: boolean;
 };
 export type RenderInteractiveSceneCallback = {
-    atLeastOneVisibleElement: boolean;
-    elementsMap: RenderableElementsMap;
     scrollBars?: ScrollBars;
 };
 export type StaticSceneRenderConfig = {
@@ -60,7 +68,13 @@ export type StaticSceneRenderConfig = {
     appState: StaticCanvasAppState;
     renderConfig: StaticCanvasRenderConfig;
 };
+export type InteractiveSceneRenderAnimationState = {
+    bindingHighlight: {
+        runtime: number;
+    } | undefined;
+};
 export type InteractiveSceneRenderConfig = {
+    app: AppClassProperties;
     canvas: HTMLCanvasElement | null;
     elementsMap: RenderableElementsMap;
     visibleElements: readonly NonDeletedExcalidrawElement[];
@@ -69,13 +83,15 @@ export type InteractiveSceneRenderConfig = {
     scale: number;
     appState: InteractiveCanvasAppState;
     renderConfig: InteractiveCanvasRenderConfig;
-    device: Device;
+    editorInterface: EditorInterface;
     callback: (data: RenderInteractiveSceneCallback) => void;
+    animationState?: InteractiveSceneRenderAnimationState;
+    deltaTime: number;
 };
 export type NewElementSceneRenderConfig = {
     canvas: HTMLCanvasElement | null;
     rc: RoughCanvas;
-    newElement: ExcalidrawElement | null;
+    newElement: NonDeletedExcalidrawElement | null;
     elementsMap: RenderableElementsMap;
     allElementsMap: NonDeletedSceneElementsMap;
     scale: number;
@@ -103,17 +119,21 @@ export type ScrollBars = {
         deltaMultiplier: number;
     } | null;
 };
-export type ElementShape = Drawable | Drawable[] | null;
+export type SVGPathString = string & {
+    __brand: "SVGPathString";
+};
+export type ElementShape = Drawable | Drawable[] | Path2D | (Drawable | SVGPathString)[] | null;
 export type ElementShapes = {
     rectangle: Drawable;
     ellipse: Drawable;
     diamond: Drawable;
     iframe: Drawable;
     embeddable: Drawable;
-    freedraw: Drawable | null;
+    freedraw: (Drawable | SVGPathString)[];
     arrow: Drawable[];
     line: Drawable[];
     text: null;
+    stickynote: null;
     image: null;
     frame: null;
     magicframe: null;

package/dist/types/excalidraw/shortcut.d.ts

@@ -0,0 +1 @@
+export declare const getShortcutKey: (shortcut: string) => string;

package/dist/types/excalidraw/snapping.d.ts

@@ -1,6 +1,6 @@
 import { type GlobalPoint } from "@excalidraw/math";
 import type { InclusiveRange } from "@excalidraw/math";
-import type { Bounds } from "@excalidraw/element";
+import type { Bounds } from "@excalidraw/common";
 import type { MaybeTransformHandleType } from "@excalidraw/element";
 import type { ElementsMap, ExcalidrawElement, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
 import type { AppClassProperties, AppState, KeyboardModifiersObject } from "./types";
@@ -66,19 +66,19 @@ export declare const isGridModeEnabled: (app: AppClassProperties) => boolean;
 export declare const isSnappingEnabled: ({ event, app, selectedElements, }: {
     app: AppClassProperties;
     event: KeyboardModifiersObject;
-    selectedElements: NonDeletedExcalidrawElement[];
+    selectedElements: readonly NonDeletedExcalidrawElement[];
 }) => boolean;
 export declare const areRoughlyEqual: (a: number, b: number, precision?: number) => boolean;
-export declare const getElementsCorners: (elements: ExcalidrawElement[], elementsMap: ElementsMap, { omitCenter, boundingBoxCorners, dragOffset, }?: {
-    omitCenter?: boolean | undefined;
-    boundingBoxCorners?: boolean | undefined;
-    dragOffset?: Vector2D | undefined;
+export declare const getElementsCorners: (elements: readonly NonDeletedExcalidrawElement[], elementsMap: ElementsMap, { omitCenter, boundingBoxCorners, dragOffset, }?: {
+    omitCenter?: boolean;
+    boundingBoxCorners?: boolean;
+    dragOffset?: Vector2D;
 }) => GlobalPoint[];
-export declare const getVisibleGaps: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: ExcalidrawElement[], appState: AppState, elementsMap: ElementsMap) => {
+export declare const getVisibleGaps: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: readonly NonDeletedExcalidrawElement[], appState: AppState, elementsMap: ElementsMap) => {
     horizontalGaps: Gap[];
     verticalGaps: Gap[];
 };
-export declare const getReferenceSnapPoints: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: ExcalidrawElement[], appState: AppState, elementsMap: ElementsMap) => GlobalPoint[];
+export declare const getReferenceSnapPoints: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: readonly NonDeletedExcalidrawElement[], appState: AppState, elementsMap: ElementsMap) => GlobalPoint[];
 export declare const snapDraggedElements: (elements: ExcalidrawElement[], dragOffset: Vector2D, app: AppClassProperties, event: KeyboardModifiersObject, elementsMap: ElementsMap) => {
     snapOffset: {
         x: number;
@@ -86,26 +86,26 @@ export declare const snapDraggedElements: (elements: ExcalidrawElement[], dragOf
     };
     snapLines: (PointSnapLine | GapSnapLine)[];
 };
-export declare const snapResizingElements: (selectedElements: ExcalidrawElement[], selectedOriginalElements: ExcalidrawElement[], app: AppClassProperties, event: KeyboardModifiersObject, dragOffset: Vector2D, transformHandle: MaybeTransformHandleType) => {
+export declare const snapResizingElements: (selectedElements: readonly NonDeletedExcalidrawElement[], selectedOriginalElements: readonly NonDeletedExcalidrawElement[], app: AppClassProperties, event: KeyboardModifiersObject, dragOffset: Vector2D, transformHandle: MaybeTransformHandleType) => {
     snapOffset: {
         x: number;
         y: number;
     };
     snapLines: PointSnapLine[];
 };
-export declare const snapNewElement: (newElement: ExcalidrawElement, app: AppClassProperties, event: KeyboardModifiersObject, origin: Vector2D, dragOffset: Vector2D, elementsMap: ElementsMap) => {
+export declare const snapNewElement: (newElement: NonDeletedExcalidrawElement, app: AppClassProperties, event: KeyboardModifiersObject, origin: Vector2D, dragOffset: Vector2D, elementsMap: ElementsMap) => {
     snapOffset: {
         x: number;
         y: number;
     };
     snapLines: PointSnapLine[];
 };
-export declare const getSnapLinesAtPointer: (elements: readonly ExcalidrawElement[], app: AppClassProperties, pointer: Vector2D, event: KeyboardModifiersObject, elementsMap: ElementsMap) => {
+export declare const getSnapLinesAtPointer: (elements: readonly NonDeletedExcalidrawElement[], app: AppClassProperties, pointer: Vector2D, event: KeyboardModifiersObject, elementsMap: ElementsMap) => {
     originOffset: {
         x: number;
         y: number;
     };
     snapLines: PointerSnapLine[];
 };
-export declare const isActiveToolNonLinearSnappable: (activeToolType: AppState["activeTool"]["type"]) => boolean;
+export declare const isActiveToolNonLinearSnappable: (activeToolType: AppState["activeTool"]["type"]) => activeToolType is "text" | "rectangle" | "diamond" | "ellipse" | "image" | "frame" | "magicframe";
 export {};

package/dist/types/excalidraw/subset/harfbuzz/harfbuzz-bindings.d.ts

@@ -38,7 +38,7 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-declare function subset(hbSubsetWasm: any, heapu8: Uint8Array, font: ArrayBuffer, codePoints: ReadonlySet<number>): Uint8Array;
+declare function subset(hbSubsetWasm: any, heapu8: Uint8Array, font: ArrayBuffer, codePoints: ReadonlySet<number>): Uint8Array<ArrayBuffer>;
 declare const _default: {
     subset: typeof subset;
 };

package/dist/types/excalidraw/subset/harfbuzz/harfbuzz-loader.d.ts

@@ -7,7 +7,7 @@
  * In the future consider separating common utils into a separate shared chunk.
  */
 declare const load: () => Promise<{
-    subset: (fontBuffer: ArrayBuffer, codePoints: ReadonlySet<number>) => Uint8Array;
+    subset: (fontBuffer: ArrayBuffer, codePoints: ReadonlySet<number>) => Uint8Array<ArrayBuffer>;
 }>;
 declare const _default: () => ReturnType<typeof load>;
 export default _default;

package/dist/types/excalidraw/subset/harfbuzz/harfbuzz-wasm.d.ts

@@ -1,2 +1,2 @@
-declare const _default: Uint8Array;
+declare const _default: Uint8Array<ArrayBuffer>;
 export default _default;

package/dist/types/excalidraw/subset/woff2/woff2-loader.d.ts

@@ -7,8 +7,8 @@
  * In the future consider separating common utils into a separate shared chunk.
  */
 declare const load: () => Promise<{
-    compress: (buffer: ArrayBuffer) => Uint8Array;
-    decompress: (buffer: ArrayBuffer) => Uint8Array;
+    compress: (buffer: ArrayBuffer) => Uint8Array<ArrayBuffer>;
+    decompress: (buffer: ArrayBuffer) => Uint8Array<ArrayBuffer>;
 }>;
 declare const _default: () => ReturnType<typeof load>;
 export default _default;

package/dist/types/excalidraw/subset/woff2/woff2-wasm.d.ts

@@ -1,2 +1,2 @@
-declare const _default: Uint8Array;
+declare const _default: Uint8Array<ArrayBuffer>;
 export default _default;

package/dist/types/excalidraw/textAutoResizeHandle.d.ts

@@ -0,0 +1,15 @@
+import { type GlobalPoint } from "@excalidraw/math";
+import type { EditorInterface } from "@excalidraw/common";
+import type { ExcalidrawTextElement } from "@excalidraw/element/types";
+export declare const getTextBoxPadding: (zoomValue: number) => number;
+export declare const getTextAutoResizeHandle: (textElement: ExcalidrawTextElement, zoomValue: number, formFactor: EditorInterface["formFactor"]) => {
+    center: GlobalPoint | import("@excalidraw/math").LocalPoint;
+    start: GlobalPoint;
+    end: GlobalPoint;
+    hitboxWidth: number;
+    hitboxHeight: number;
+} | null;
+export declare const isPointHittingTextAutoResizeHandle: (point: Readonly<{
+    x: number;
+    y: number;
+}>, textElement: ExcalidrawTextElement, zoomValue: number, formFactor: EditorInterface["formFactor"]) => boolean;