@zsviczian/excalidraw 0.17.6-30 → 0.17.6-31

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

@@ -0,0 +1,488 @@
+import type { NonDeletedExcalidrawElement } from "../element/types";
+import type { ElementOrToolType } from "../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 getElementAtPosition: (elements: readonly NonDeletedExcalidrawElement[], isAtPositionFn: (element: NonDeletedExcalidrawElement) => boolean) => (Readonly<{
+    id: string;
+    x: number;
+    y: number;
+    strokeColor: string;
+    backgroundColor: string;
+    fillStyle: import("../element/types").FillStyle;
+    strokeWidth: number;
+    strokeStyle: import("../element/types").StrokeStyle;
+    roundness: {
+        type: import("../element/types").RoundnessType;
+        value?: number | undefined;
+    } | null;
+    roughness: number;
+    opacity: number;
+    width: number;
+    height: number;
+    angle: import("../../math").Radians;
+    seed: number;
+    version: number;
+    versionNonce: number;
+    index: import("../element/types").FractionalIndex | null;
+    isDeleted: boolean;
+    groupIds: readonly string[];
+    frameId: string | null;
+    boundElements: readonly Readonly<{
+        id: string;
+        type: "text" | "arrow";
+    }>[] | null;
+    updated: number;
+    link: string | null;
+    locked: boolean;
+    customData?: Record<string, any> | undefined;
+}> & {
+    type: "rectangle";
+} & {
+    isDeleted: boolean;
+}) | (Readonly<{
+    id: string;
+    x: number;
+    y: number;
+    strokeColor: string;
+    backgroundColor: string;
+    fillStyle: import("../element/types").FillStyle;
+    strokeWidth: number;
+    strokeStyle: import("../element/types").StrokeStyle;
+    roundness: {
+        type: import("../element/types").RoundnessType;
+        value?: number | undefined;
+    } | null;
+    roughness: number;
+    opacity: number;
+    width: number;
+    height: number;
+    angle: import("../../math").Radians;
+    seed: number;
+    version: number;
+    versionNonce: number;
+    index: import("../element/types").FractionalIndex | null;
+    isDeleted: boolean;
+    groupIds: readonly string[];
+    frameId: string | null;
+    boundElements: readonly Readonly<{
+        id: string;
+        type: "text" | "arrow";
+    }>[] | null;
+    updated: number;
+    link: string | null;
+    locked: boolean;
+    customData?: Record<string, any> | undefined;
+}> & {
+    type: "diamond";
+} & {
+    isDeleted: boolean;
+}) | (Readonly<{
+    id: string;
+    x: number;
+    y: number;
+    strokeColor: string;
+    backgroundColor: string;
+    fillStyle: import("../element/types").FillStyle;
+    strokeWidth: number;
+    strokeStyle: import("../element/types").StrokeStyle;
+    roundness: {
+        type: import("../element/types").RoundnessType;
+        value?: number | undefined;
+    } | null;
+    roughness: number;
+    opacity: number;
+    width: number;
+    height: number;
+    angle: import("../../math").Radians;
+    seed: number;
+    version: number;
+    versionNonce: number;
+    index: import("../element/types").FractionalIndex | null;
+    isDeleted: boolean;
+    groupIds: readonly string[];
+    frameId: string | null;
+    boundElements: readonly Readonly<{
+        id: string;
+        type: "text" | "arrow";
+    }>[] | null;
+    updated: number;
+    link: string | null;
+    locked: boolean;
+    customData?: Record<string, any> | undefined;
+}> & {
+    type: "ellipse";
+} & {
+    isDeleted: boolean;
+}) | (Readonly<{
+    id: string;
+    x: number;
+    y: number;
+    strokeColor: string;
+    backgroundColor: string;
+    fillStyle: import("../element/types").FillStyle;
+    strokeWidth: number;
+    strokeStyle: import("../element/types").StrokeStyle;
+    roundness: {
+        type: import("../element/types").RoundnessType;
+        value?: number | undefined;
+    } | null;
+    roughness: number;
+    opacity: number;
+    width: number;
+    height: number;
+    angle: import("../../math").Radians;
+    seed: number;
+    version: number;
+    versionNonce: number;
+    index: import("../element/types").FractionalIndex | null;
+    isDeleted: boolean;
+    groupIds: readonly string[];
+    frameId: string | null;
+    boundElements: readonly Readonly<{
+        id: string;
+        type: "text" | "arrow";
+    }>[] | null;
+    updated: number;
+    link: string | null;
+    locked: boolean;
+    customData?: Record<string, any> | undefined;
+}> & Readonly<{
+    type: "text";
+    fontSize: number;
+    fontFamily: number;
+    text: string;
+    rawText: string;
+    textAlign: string;
+    verticalAlign: string;
+    containerId: string | null;
+    originalText: string;
+    autoResize: boolean;
+    lineHeight: number & {
+        _brand: "unitlessLineHeight";
+    };
+}> & {
+    isDeleted: boolean;
+}) | (Readonly<{
+    id: string;
+    x: number;
+    y: number;
+    strokeColor: string;
+    backgroundColor: string;
+    fillStyle: import("../element/types").FillStyle;
+    strokeWidth: number;
+    strokeStyle: import("../element/types").StrokeStyle;
+    roundness: {
+        type: import("../element/types").RoundnessType;
+        value?: number | undefined;
+    } | null;
+    roughness: number;
+    opacity: number;
+    width: number;
+    height: number;
+    angle: import("../../math").Radians;
+    seed: number;
+    version: number;
+    versionNonce: number;
+    index: import("../element/types").FractionalIndex | null;
+    isDeleted: boolean;
+    groupIds: readonly string[];
+    frameId: string | null;
+    boundElements: readonly Readonly<{
+        id: string;
+        type: "text" | "arrow";
+    }>[] | null;
+    updated: number;
+    link: string | null;
+    locked: boolean;
+    customData?: Record<string, any> | undefined;
+}> & Readonly<{
+    type: "line" | "arrow";
+    points: readonly import("../../math").LocalPoint[];
+    lastCommittedPoint: import("../../math").LocalPoint | null;
+    startBinding: import("../element/types").PointBinding | null;
+    endBinding: import("../element/types").PointBinding | null;
+    startArrowhead: import("../element/types").Arrowhead | null;
+    endArrowhead: import("../element/types").Arrowhead | null;
+}> & {
+    isDeleted: boolean;
+}) | (Readonly<{
+    id: string;
+    x: number;
+    y: number;
+    strokeColor: string;
+    backgroundColor: string;
+    fillStyle: import("../element/types").FillStyle;
+    strokeWidth: number;
+    strokeStyle: import("../element/types").StrokeStyle;
+    roundness: {
+        type: import("../element/types").RoundnessType;
+        value?: number | undefined;
+    } | null;
+    roughness: number;
+    opacity: number;
+    width: number;
+    height: number;
+    angle: import("../../math").Radians;
+    seed: number;
+    version: number;
+    versionNonce: number;
+    index: import("../element/types").FractionalIndex | null;
+    isDeleted: boolean;
+    groupIds: readonly string[];
+    frameId: string | null;
+    boundElements: readonly Readonly<{
+        id: string;
+        type: "text" | "arrow";
+    }>[] | null;
+    updated: number;
+    link: string | null;
+    locked: boolean;
+    customData?: Record<string, any> | undefined;
+}> & Readonly<{
+    type: "freedraw";
+    points: readonly import("../../math").LocalPoint[];
+    pressures: readonly number[];
+    simulatePressure: boolean;
+    lastCommittedPoint: import("../../math").LocalPoint | null;
+}> & {
+    isDeleted: boolean;
+}) | (Readonly<{
+    id: string;
+    x: number;
+    y: number;
+    strokeColor: string;
+    backgroundColor: string;
+    fillStyle: import("../element/types").FillStyle;
+    strokeWidth: number;
+    strokeStyle: import("../element/types").StrokeStyle;
+    roundness: {
+        type: import("../element/types").RoundnessType;
+        value?: number | undefined;
+    } | null;
+    roughness: number;
+    opacity: number;
+    width: number;
+    height: number;
+    angle: import("../../math").Radians;
+    seed: number;
+    version: number;
+    versionNonce: number;
+    index: import("../element/types").FractionalIndex | null;
+    isDeleted: boolean;
+    groupIds: readonly string[];
+    frameId: string | null;
+    boundElements: readonly Readonly<{
+        id: string;
+        type: "text" | "arrow";
+    }>[] | null;
+    updated: number;
+    link: string | null;
+    locked: boolean;
+    customData?: Record<string, any> | undefined;
+}> & Readonly<{
+    type: "image";
+    fileId: import("../element/types").FileId | null;
+    status: "pending" | "saved" | "error";
+    scale: [number, number];
+    crop: import("../element/types").ImageCrop | null;
+}> & {
+    isDeleted: boolean;
+}) | (Readonly<{
+    id: string;
+    x: number;
+    y: number;
+    strokeColor: string;
+    backgroundColor: string;
+    fillStyle: import("../element/types").FillStyle;
+    strokeWidth: number;
+    strokeStyle: import("../element/types").StrokeStyle;
+    roundness: {
+        type: import("../element/types").RoundnessType;
+        value?: number | undefined;
+    } | null;
+    roughness: number;
+    opacity: number;
+    width: number;
+    height: number;
+    angle: import("../../math").Radians;
+    seed: number;
+    version: number;
+    versionNonce: number;
+    index: import("../element/types").FractionalIndex | null;
+    isDeleted: boolean;
+    groupIds: readonly string[];
+    frameId: string | null;
+    boundElements: readonly Readonly<{
+        id: string;
+        type: "text" | "arrow";
+    }>[] | null;
+    updated: number;
+    link: string | null;
+    locked: boolean;
+    customData?: Record<string, any> | undefined;
+}> & {
+    type: "frame";
+    name: string | null;
+} & {
+    isDeleted: boolean;
+}) | (Readonly<{
+    id: string;
+    x: number;
+    y: number;
+    strokeColor: string;
+    backgroundColor: string;
+    fillStyle: import("../element/types").FillStyle;
+    strokeWidth: number;
+    strokeStyle: import("../element/types").StrokeStyle;
+    roundness: {
+        type: import("../element/types").RoundnessType;
+        value?: number | undefined;
+    } | null;
+    roughness: number;
+    opacity: number;
+    width: number;
+    height: number;
+    angle: import("../../math").Radians;
+    seed: number;
+    version: number;
+    versionNonce: number;
+    index: import("../element/types").FractionalIndex | null;
+    isDeleted: boolean;
+    groupIds: readonly string[];
+    frameId: string | null;
+    boundElements: readonly Readonly<{
+        id: string;
+        type: "text" | "arrow";
+    }>[] | null;
+    updated: number;
+    link: string | null;
+    locked: boolean;
+    customData?: Record<string, any> | undefined;
+}> & {
+    type: "magicframe";
+    name: string | null;
+} & {
+    isDeleted: boolean;
+}) | (Readonly<{
+    id: string;
+    x: number;
+    y: number;
+    strokeColor: string;
+    backgroundColor: string;
+    fillStyle: import("../element/types").FillStyle;
+    strokeWidth: number;
+    strokeStyle: import("../element/types").StrokeStyle;
+    roundness: {
+        type: import("../element/types").RoundnessType;
+        value?: number | undefined;
+    } | null;
+    roughness: number;
+    opacity: number;
+    width: number;
+    height: number;
+    angle: import("../../math").Radians;
+    seed: number;
+    version: number;
+    versionNonce: number;
+    index: import("../element/types").FractionalIndex | null;
+    isDeleted: boolean;
+    groupIds: readonly string[];
+    frameId: string | null;
+    boundElements: readonly Readonly<{
+        id: string;
+        type: "text" | "arrow";
+    }>[] | null;
+    updated: number;
+    link: string | null;
+    locked: boolean;
+    customData?: Record<string, any> | undefined;
+}> & Readonly<{
+    type: "iframe";
+    customData?: {
+        generationData?: import("../element/types").MagicGenerationData | undefined;
+    } | undefined;
+    scale: [number, number];
+}> & {
+    isDeleted: boolean;
+}) | (Readonly<{
+    id: string;
+    x: number;
+    y: number;
+    strokeColor: string;
+    backgroundColor: string;
+    fillStyle: import("../element/types").FillStyle;
+    strokeWidth: number;
+    strokeStyle: import("../element/types").StrokeStyle;
+    roundness: {
+        type: import("../element/types").RoundnessType;
+        value?: number | undefined;
+    } | null;
+    roughness: number;
+    opacity: number;
+    width: number;
+    height: number;
+    angle: import("../../math").Radians;
+    seed: number;
+    version: number;
+    versionNonce: number;
+    index: import("../element/types").FractionalIndex | null;
+    isDeleted: boolean;
+    groupIds: readonly string[];
+    frameId: string | null;
+    boundElements: readonly Readonly<{
+        id: string;
+        type: "text" | "arrow";
+    }>[] | null;
+    updated: number;
+    link: string | null;
+    locked: boolean;
+    customData?: Record<string, any> | undefined;
+}> & Readonly<{
+    type: "embeddable";
+    scale: [number, number];
+}> & {
+    isDeleted: boolean;
+}) | (Readonly<{
+    id: string;
+    x: number;
+    y: number;
+    strokeColor: string;
+    backgroundColor: string;
+    fillStyle: import("../element/types").FillStyle;
+    strokeWidth: number;
+    strokeStyle: import("../element/types").StrokeStyle;
+    roundness: {
+        type: import("../element/types").RoundnessType;
+        value?: number | undefined;
+    } | null;
+    roughness: number;
+    opacity: number;
+    width: number;
+    height: number;
+    angle: import("../../math").Radians;
+    seed: number;
+    version: number;
+    versionNonce: number;
+    index: import("../element/types").FractionalIndex | null;
+    isDeleted: boolean;
+    groupIds: readonly string[];
+    frameId: string | null;
+    boundElements: readonly Readonly<{
+        id: string;
+        type: "text" | "arrow";
+    }>[] | null;
+    updated: number;
+    link: string | null;
+    locked: boolean;
+    customData?: Record<string, any> | undefined;
+}> & {
+    type: "selection";
+} & {
+    isDeleted: boolean;
+}) | null;
+export declare const getElementsAtPosition: (elements: readonly NonDeletedExcalidrawElement[], isAtPositionFn: (element: NonDeletedExcalidrawElement) => boolean) => NonDeletedExcalidrawElement[];

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

@@ -0,0 +1,37 @@
+import type { ExcalidrawFrameLikeElement, NonDeletedExcalidrawElement } from "../element/types";
+import type { AppState, BinaryFiles } from "../types";
+export declare const exportToCanvas: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState, files: BinaryFiles, { exportBackground, exportPadding, viewBackgroundColor, exportingFrame, }: {
+    exportBackground: boolean;
+    exportPadding?: number | undefined;
+    viewBackgroundColor: string;
+    exportingFrame?: ExcalidrawFrameLikeElement | null | undefined;
+}, createCanvas?: (width: number, height: number) => {
+    canvas: HTMLCanvasElement;
+    scale: number;
+}, loadFonts?: () => Promise<void>) => Promise<HTMLCanvasElement>;
+export declare const exportToSvg: (elements: readonly NonDeletedExcalidrawElement[], appState: {
+    exportBackground: boolean;
+    exportPadding?: number;
+    exportScale?: number;
+    viewBackgroundColor: string;
+    exportWithDarkMode?: boolean;
+    exportEmbedScene?: boolean;
+    frameRendering?: AppState["frameRendering"];
+    frameColor?: AppState["frameColor"];
+}, files: BinaryFiles | null, opts?: {
+    /**
+     * if true, all embeddables passed in will be rendered when possible.
+     */
+    renderEmbeddables?: boolean;
+    exportingFrame?: ExcalidrawFrameLikeElement | null;
+    skipInliningFonts?: true;
+    reuseImages?: boolean;
+}) => Promise<SVGSVGElement>;
+export declare const encodeSvgBase64Payload: ({ payload, metadataElement, }: {
+    payload: string;
+    metadataElement: SVGMetadataElement;
+}) => void;
+export declare const decodeSvgBase64Payload: ({ svg }: {
+    svg: string;
+}) => string;
+export declare const getExportSize: (elements: readonly NonDeletedExcalidrawElement[], exportPadding: number, scale: number) => [number, number];

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

@@ -0,0 +1,4 @@
+export { isSomeElementSelected, getElementsWithinSelection, getCommonAttributeOfSelectedElements, getSelectedElements, getTargetElements, } from "./selection";
+export { calculateScrollCenter } from "./scroll";
+export { hasBackground, hasStrokeWidth, hasStrokeStyle, canHaveArrowheads, canChangeRoundness, getElementAtPosition, getElementsAtPosition, } from "./comparisons";
+export { getNormalizedZoom, getNormalizedGridSize, getNormalizedGridStep, } from "./normalize";

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

@@ -0,0 +1,4 @@
+import type { NormalizedZoomValue } from "../types";
+export declare const getNormalizedZoom: (zoom: number) => NormalizedZoomValue;
+export declare const getNormalizedGridSize: (gridStep: number) => number;
+export declare const getNormalizedGridStep: (gridStep: number) => number;

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

@@ -0,0 +1,23 @@
+import type { AppState, Offsets, PointerCoords, Zoom } from "../types";
+import type { ExcalidrawElement } from "../element/types";
+export declare const centerScrollOn: ({ scenePoint, viewportDimensions, zoom, offsets, }: {
+    scenePoint: PointerCoords;
+    viewportDimensions: {
+        height: number;
+        width: number;
+    };
+    zoom: Zoom;
+    offsets?: Partial<{
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    }> | undefined;
+}) => {
+    scrollX: number;
+    scrollY: number;
+};
+export declare const calculateScrollCenter: (elements: readonly ExcalidrawElement[], appState: AppState) => {
+    scrollX: number;
+    scrollY: number;
+};

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

@@ -0,0 +1,12 @@
+import type { InteractiveCanvasAppState } from "../types";
+import type { ScrollBars } from "./types";
+import type { ExcalidrawElement } from "../element/types";
+export declare const SCROLLBAR_MARGIN = 4;
+export declare const SCROLLBAR_WIDTH = 6;
+export declare const SCROLLBAR_COLOR = "rgba(128,128,128,0.3)";
+export declare const getScrollBars: (elements: readonly ExcalidrawElement[], viewportWidth: number, viewportHeight: number, appState: InteractiveCanvasAppState) => ScrollBars;
+export declare const isOverScrollBars: (scrollBars: ScrollBars, x: number, y: number) => {
+    isOverEither: boolean;
+    isOverHorizontal: boolean;
+    isOverVertical: boolean;
+};

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

@@ -0,0 +1,32 @@
+import type { ElementsMap, ElementsMapOrArray, ExcalidrawElement, NonDeletedExcalidrawElement } from "../element/types";
+import type { AppState, InteractiveCanvasAppState } from "../types";
+/**
+ * Frames and their containing elements are not to be selected at the same time.
+ * Given an array of selected elements, if there are frames and their containing elements
+ * we only keep the frames.
+ * @param selectedElements
+ */
+export declare const excludeElementsInFramesFromSelection: <T extends ExcalidrawElement>(selectedElements: readonly T[]) => T[];
+export declare const getElementsWithinSelection: (elements: readonly NonDeletedExcalidrawElement[], selection: NonDeletedExcalidrawElement, elementsMap: ElementsMap, excludeElementsInFrames?: boolean) => NonDeletedExcalidrawElement[];
+export declare const getVisibleAndNonSelectedElements: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: readonly NonDeletedExcalidrawElement[], appState: AppState, elementsMap: ElementsMap) => NonDeletedExcalidrawElement[];
+export declare const isSomeElementSelected: {
+    (elements: readonly NonDeletedExcalidrawElement[], appState: Pick<AppState, "selectedElementIds">): boolean;
+    clearCache(): void;
+};
+/**
+ * Returns common attribute (picked by `getAttribute` callback) of selected
+ *  elements. If elements don't share the same value, returns `null`.
+ */
+export declare const getCommonAttributeOfSelectedElements: <T>(elements: readonly NonDeletedExcalidrawElement[], appState: Pick<AppState, "selectedElementIds">, getAttribute: (element: ExcalidrawElement) => T) => T | null;
+export declare const getSelectedElements: (elements: ElementsMapOrArray, appState: Pick<InteractiveCanvasAppState, "selectedElementIds">, opts?: {
+    includeBoundTextElement?: boolean;
+    includeElementsInFrames?: boolean;
+}) => ExcalidrawElement[];
+export declare const getTargetElements: (elements: ElementsMapOrArray, appState: Pick<AppState, "selectedElementIds" | "editingTextElement" | "newElement">) => ExcalidrawElement[];
+/**
+ * returns prevState's selectedElementids if no change from previous, so as to
+ * retain reference identity for memoization
+ */
+export declare const makeNextSelectedElementIds: (nextSelectedElementIds: AppState["selectedElementIds"], prevState: Pick<AppState, "selectedElementIds">) => Readonly<{
+    [id: string]: true;
+}>;