@excalidraw/element 0.18.0-4e471c107 → 0.18.0-4f68076

package/dist/types/excalidraw/{laser-trails.d.ts → laserTrails.d.ts}

@@ -1,20 +1,18 @@
-import { AnimatedTrail } from "./animated-trail";
-import type { Trail } from "./animated-trail";
-import type { AnimationFrameHandler } from "./animation-frame-handler";
+import { AnimatedTrail } from "./animatedTrail";
+import type { Trail } from "./animatedTrail";
 import type App from "./components/App";
 export declare class LaserTrails implements Trail {
-    private animationFrameHandler;
     private app;
     localTrail: AnimatedTrail;
     private collabTrails;
     private container?;
-    constructor(animationFrameHandler: AnimationFrameHandler, app: App);
+    constructor(app: App);
     private getTrailOptions;
     startPath(x: number, y: number): void;
     addPointToPath(x: number, y: number): void;
     endPath(): void;
     start(container: SVGSVGElement): void;
     stop(): void;
-    onFrame(): void;
-    private updateCollabTrails;
+    private stopCollabTrails;
+    updateCollabTrails(collaborators: App["state"]["collaborators"]): void;
 }

package/dist/types/excalidraw/lasso/index.d.ts

@@ -1,5 +1,4 @@
-import { type AnimationFrameHandler } from "../animation-frame-handler";
-import { AnimatedTrail } from "../animated-trail";
+import { AnimatedTrail } from "../animatedTrail";
 import type App from "../components/App";
 export declare class LassoTrail extends AnimatedTrail {
     private intersectedElements;
@@ -7,7 +6,7 @@ export declare class LassoTrail extends AnimatedTrail {
     private elementsSegments;
     private canvasTranslate;
     private keepPreviousSelection;
-    constructor(animationFrameHandler: AnimationFrameHandler, app: App);
+    constructor(app: App);
     startPath(x: number, y: number, keepPreviousSelection?: boolean): void;
     selectElementsFromIds: (ids: string[]) => void;
     addPointToPath: (x: number, y: number, keepPreviousSelection?: boolean) => void;

package/dist/types/excalidraw/lasso/utils.d.ts

@@ -1,5 +1,6 @@
 import type { ElementsSegmentsMap, GlobalPoint } from "@excalidraw/math/types";
 import type { ElementsMap, ExcalidrawElement } from "@excalidraw/element/types";
+import type { BoxSelectionMode } from "../types";
 export declare const getLassoSelectedElementIds: (input: {
     lassoPath: GlobalPoint[];
     elements: readonly ExcalidrawElement[];
@@ -8,6 +9,7 @@ export declare const getLassoSelectedElementIds: (input: {
     intersectedElements: Set<ExcalidrawElement["id"]>;
     enclosedElements: Set<ExcalidrawElement["id"]>;
     simplifyDistance?: number;
+    mode?: BoxSelectionMode;
 }) => {
     selectedElementIds: string[];
 };

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

@@ -0,0 +1,9 @@
+import type { ElementRenderOffsets, ElementRenderOverrides } from "./types";
+/** Validate and copy before publishing, so a rejected snapshot changes nothing. */
+export declare const copyElementRenderOverrides: (overrides: ElementRenderOverrides | null) => ElementRenderOverrides;
+/**
+ * Extracts the offsets of a snapshot, returning `previous` when they are the
+ * same. Visibility is memoized on this map's identity, so a snapshot that only
+ * changes opacities (a fade) never re-runs viewport geometry.
+ */
+export declare const getElementRenderOffsets: (overrides: ElementRenderOverrides, previous: ElementRenderOffsets) => ElementRenderOffsets;

package/dist/types/excalidraw/renderer/animation.d.ts

@@ -0,0 +1,16 @@
+export type Animation<R extends object> = (params: {
+    deltaTime: number;
+    state?: R;
+}) => R | null | undefined;
+export declare class AnimationController {
+    private static scheduledFrame;
+    private static animations;
+    static start<R extends object>(key: string, animation: Animation<R>): void;
+    private static scheduleNextFrame;
+    private static cancelScheduledFrame;
+    private static cancelScheduledFrameIfIdle;
+    private static tick;
+    static running(key: string): boolean;
+    static cancel(key: string): void;
+    static reset(): void;
+}

package/dist/types/excalidraw/renderer/helpers.d.ts

@@ -1,18 +1,41 @@
-import type { ElementsMap, ExcalidrawDiamondElement, ExcalidrawRectanguloidElement } from "@excalidraw/element/types";
 import type { StaticCanvasRenderConfig } from "../scene/types";
 import type { AppState, StaticCanvasAppState } from "../types";
+export declare const DEFAULT_SELECTION_COLOR = "#6965db";
+/**
+ * Returns the theme's selection color (`--color-selection`), read from the
+ * computed style of any element inside the editor container so that host
+ * overrides are respected. Falls back to the default when unavailable.
+ */
+export declare const getSelectionColor: (element: Element | null | undefined) => string;
 export declare const fillCircle: (context: CanvasRenderingContext2D, cx: number, cy: number, radius: number, stroke: boolean, fill?: boolean) => void;
+/**
+ * The scroll the renderers draw at: the real one, rounded to whole device
+ * pixels. Panning writes a fractional scroll (pointer delta ÷ zoom), and an
+ * element's cached bitmap blitted at a fractional device offset gets
+ * resampled — so as the fraction drifts under a pan, every element pulses
+ * between crisp and soft. A whole-pixel scroll moves the scene the way a
+ * browser scrolls a page: each element keeps its own, constant sub-pixel
+ * phase and a pan never changes how anything is filtered. The difference
+ * stays under half a device pixel, so hit-testing and DOM overlays keep
+ * using the real scroll. Identity when nothing needs to change.
+ */
+export declare const snapScrollToDevicePixels: <T extends {
+    scrollX: number;
+    scrollY: number;
+    zoom: {
+        value: number;
+    };
+}>(appState: T, scale: number) => T;
 export declare const getNormalizedCanvasDimensions: (canvas: HTMLCanvasElement, scale: number) => [number, number];
 export declare const bootstrapCanvas: ({ canvas, scale, normalizedWidth, normalizedHeight, theme, isExporting, viewBackgroundColor, }: {
     canvas: HTMLCanvasElement;
     scale: number;
     normalizedWidth: number;
     normalizedHeight: number;
-    theme?: import("@excalidraw/element/types").Theme | undefined;
-    isExporting?: boolean | undefined;
-    viewBackgroundColor?: string | null | undefined;
+    theme?: AppState["theme"];
+    isExporting?: StaticCanvasRenderConfig["isExporting"];
+    viewBackgroundColor?: StaticCanvasAppState["viewBackgroundColor"];
 }) => CanvasRenderingContext2D;
-export declare const drawHighlightForRectWithRotation: (context: CanvasRenderingContext2D, element: ExcalidrawRectanguloidElement, elementsMap: ElementsMap, padding: number) => void;
-export declare const strokeEllipseWithRotation: (context: CanvasRenderingContext2D, width: number, height: number, cx: number, cy: number, angle: number) => void;
-export declare const strokeRectWithRotation: (context: CanvasRenderingContext2D, x: number, y: number, width: number, height: number, cx: number, cy: number, angle: number, fill?: boolean, radius?: number) => void;
-export declare const drawHighlightForDiamondWithRotation: (context: CanvasRenderingContext2D, padding: number, element: ExcalidrawDiamondElement, elementsMap: ElementsMap) => void;
+export declare const strokeRectWithRotation_simple: (context: CanvasRenderingContext2D, x: number, y: number, width: number, height: number, cx: number, cy: number, angle: number, fill?: boolean, 
+/** should account for zoom */
+radius?: number) => void;

package/dist/types/excalidraw/renderer/interactiveScene.d.ts

@@ -1,20 +1,12 @@
-import type { InteractiveSceneRenderConfig, RenderableElementsMap } from "../scene/types";
-/** throttled to animation framerate */
-export declare const renderInteractiveSceneThrottled: {
-    (config: InteractiveSceneRenderConfig): void;
-    flush(): void;
-    cancel(): void;
+import { getScrollBars } from "../scene/scrollbars";
+import type { InteractiveSceneRenderConfig } from "../scene/types";
+declare const _renderInteractiveScene: ({ app, canvas, elementsMap, visibleElements, selectedElements, allElementsMap, scale, appState: unsnappedAppState, renderConfig, editorInterface, animationState, deltaTime, }: InteractiveSceneRenderConfig) => {
+    scrollBars?: ReturnType<typeof getScrollBars>;
+    animationState?: typeof animationState;
 };
 /**
  * Interactive scene is the ui-canvas where we render bounding boxes, selections
  * and other ui stuff.
  */
-export declare const renderInteractiveScene: <U extends ({ canvas, elementsMap, visibleElements, selectedElements, allElementsMap, scale, appState, renderConfig, device, }: InteractiveSceneRenderConfig) => {
-    atLeastOneVisibleElement: boolean;
-    elementsMap: RenderableElementsMap;
-    scrollBars?: undefined;
-} | {
-    scrollBars: import("../scene/types").ScrollBars | undefined;
-    atLeastOneVisibleElement: boolean;
-    elementsMap: RenderableElementsMap;
-}, T extends boolean = false>(renderConfig: InteractiveSceneRenderConfig, throttle?: T | undefined) => T extends true ? void : ReturnType<U>;
+export declare const renderInteractiveScene: <U extends typeof _renderInteractiveScene>(renderConfig: InteractiveSceneRenderConfig) => ReturnType<U>;
+export {};

package/dist/types/excalidraw/renderer/staticScene.d.ts

@@ -1,4 +1,7 @@
-import type { StaticSceneRenderConfig } from "../scene/types";
+import type { ExcalidrawFrameLikeElement } from "@excalidraw/element/types";
+import type { StaticCanvasRenderConfig, StaticSceneRenderConfig } from "../scene/types";
+import type { StaticCanvasAppState } from "../types";
+export declare const frameClip: (frame: ExcalidrawFrameLikeElement, context: CanvasRenderingContext2D, renderConfig: StaticCanvasRenderConfig, appState: StaticCanvasAppState) => void;
 /** throttled to animation framerate */
 export declare const renderStaticSceneThrottled: {
     (config: StaticSceneRenderConfig): void;