@zsviczian/excalidraw 0.17.1-obsidian-14 → 0.17.1-obsidian-16

package/types/excalidraw/example/initialData.d.ts

@@ -0,0 +1,290 @@
+import type { ExcalidrawElementSkeleton } from "../data/transform";
+declare const _default: {
+    elements: ExcalidrawElementSkeleton[];
+    appState: {
+        viewBackgroundColor: string;
+        currentItemFontFamily: number;
+    };
+    scrollToContent: boolean;
+    libraryItems: ({
+        type: string;
+        x: number;
+        y: number;
+        strokeColor: string;
+        backgroundColor: string;
+        width: number;
+        height: number;
+        strokeSharpness: string;
+        points: number[][];
+    }[] | ({
+        type: string;
+        fillStyle: string;
+        strokeWidth: number;
+        strokeStyle: string;
+        x: number;
+        y: number;
+        strokeColor: string;
+        backgroundColor: string;
+        width: number;
+        height: number;
+        groupIds: string[];
+        points: number[][];
+        roughness?: undefined;
+        opacity?: undefined;
+        angle?: undefined;
+        seed?: undefined;
+        strokeSharpness?: undefined;
+        boundElementIds?: undefined;
+    } | {
+        type: string;
+        fillStyle: string;
+        strokeWidth: number;
+        strokeStyle: string;
+        roughness: number;
+        opacity: number;
+        angle: number;
+        x: number;
+        y: number;
+        strokeColor: string;
+        backgroundColor: string;
+        width: number;
+        height: number;
+        seed: number;
+        groupIds: string[];
+        strokeSharpness: string;
+        points: number[][];
+        boundElementIds?: undefined;
+    } | {
+        type: string;
+        fillStyle: string;
+        strokeWidth: number;
+        strokeStyle: string;
+        roughness: number;
+        opacity: number;
+        angle: number;
+        x: number;
+        y: number;
+        strokeColor: string;
+        backgroundColor: string;
+        width: number;
+        height: number;
+        seed: number;
+        groupIds: string[];
+        strokeSharpness: string;
+        boundElementIds: string[];
+        points?: undefined;
+    } | {
+        type: string;
+        fillStyle: string;
+        strokeWidth: number;
+        strokeStyle: string;
+        roughness: number;
+        opacity: number;
+        angle: number;
+        x: number;
+        y: number;
+        strokeColor: string;
+        backgroundColor: string;
+        width: number;
+        height: number;
+        seed: number;
+        groupIds: string[];
+        strokeSharpness: string;
+        points?: undefined;
+        boundElementIds?: undefined;
+    })[] | ({
+        type: string;
+        fillStyle: string;
+        strokeWidth: number;
+        strokeStyle: string;
+        roughness: number;
+        opacity: number;
+        angle: number;
+        x: number;
+        y: number;
+        strokeColor: string;
+        backgroundColor: string;
+        width: number;
+        height: number;
+        seed: number;
+        groupIds: string[];
+        strokeSharpness: string;
+        points: number[][];
+        version?: undefined;
+        versionNonce?: undefined;
+        isDeleted?: undefined;
+        id?: undefined;
+        boundElementIds?: undefined;
+    } | {
+        type: string;
+        version: number;
+        versionNonce: number;
+        isDeleted: boolean;
+        id: string;
+        fillStyle: string;
+        strokeWidth: number;
+        strokeStyle: string;
+        roughness: number;
+        opacity: number;
+        angle: number;
+        x: number;
+        y: number;
+        strokeColor: string;
+        backgroundColor: string;
+        width: number;
+        height: number;
+        seed: number;
+        groupIds: string[];
+        strokeSharpness: string;
+        points: number[][];
+        boundElementIds?: undefined;
+    } | {
+        type: string;
+        fillStyle: string;
+        strokeWidth: number;
+        strokeStyle: string;
+        roughness: number;
+        opacity: number;
+        angle: number;
+        x: number;
+        y: number;
+        strokeColor: string;
+        backgroundColor: string;
+        width: number;
+        height: number;
+        seed: number;
+        groupIds: string[];
+        strokeSharpness: string;
+        boundElementIds: string[];
+        points?: undefined;
+        version?: undefined;
+        versionNonce?: undefined;
+        isDeleted?: undefined;
+        id?: undefined;
+    })[] | ({
+        type: string;
+        fillStyle: string;
+        strokeWidth: number;
+        strokeStyle: string;
+        roughness: number;
+        opacity: number;
+        angle: number;
+        x: number;
+        y: number;
+        strokeColor: string;
+        backgroundColor: string;
+        width: number;
+        height: number;
+        seed: number;
+        groupIds: string[];
+        strokeSharpness: string;
+        points?: undefined;
+    } | {
+        type: string;
+        fillStyle: string;
+        strokeWidth: number;
+        strokeStyle: string;
+        roughness: number;
+        opacity: number;
+        angle: number;
+        x: number;
+        y: number;
+        strokeColor: string;
+        backgroundColor: string;
+        width: number;
+        height: number;
+        seed: number;
+        groupIds: string[];
+        strokeSharpness: string;
+        points: number[][];
+    } | {
+        type: string;
+        fillStyle: string;
+        strokeWidth: number;
+        strokeStyle: string;
+        x: number;
+        y: number;
+        strokeColor: string;
+        backgroundColor: string;
+        width: number;
+        height: number;
+        groupIds: string[];
+        strokeSharpness: string;
+        points: number[][];
+        roughness?: undefined;
+        opacity?: undefined;
+        angle?: undefined;
+        seed?: undefined;
+    } | {
+        type: string;
+        fillStyle: string;
+        strokeWidth: number;
+        strokeStyle: string;
+        roughness: number;
+        opacity: number;
+        angle: number;
+        x: number;
+        y: number;
+        strokeColor: string;
+        backgroundColor: string;
+        width: number;
+        height: number;
+        groupIds: string[];
+        strokeSharpness: string;
+        points: number[][];
+        seed?: undefined;
+    } | {
+        type: string;
+        fillStyle: string;
+        strokeWidth: number;
+        strokeStyle: string;
+        opacity: number;
+        x: number;
+        y: number;
+        strokeColor: string;
+        backgroundColor: string;
+        width: number;
+        height: number;
+        seed: number;
+        groupIds: string[];
+        strokeSharpness: string;
+        points: number[][];
+        roughness?: undefined;
+        angle?: undefined;
+    })[] | ({
+        type: string;
+        fillStyle: string;
+        strokeWidth: number;
+        strokeStyle: string;
+        roughness: number;
+        opacity: number;
+        angle: number;
+        x: number;
+        y: number;
+        strokeColor: string;
+        backgroundColor: string;
+        width: number;
+        height: number;
+        seed: number;
+        groupIds: string[];
+        strokeSharpness: string;
+    } | {
+        type: string;
+        fillStyle: string;
+        strokeWidth: number;
+        strokeStyle: string;
+        x: number;
+        y: number;
+        strokeColor: string;
+        backgroundColor: string;
+        width: number;
+        height: number;
+        seed: number;
+        groupIds: string[];
+        strokeSharpness: string;
+        roughness?: undefined;
+        opacity?: undefined;
+        angle?: undefined;
+    })[])[];
+};
+export default _default;

package/types/excalidraw/example/sidebar/ExampleSidebar.d.ts

@@ -0,0 +1,4 @@
+import "./ExampleSidebar.scss";
+export default function Sidebar({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/types/excalidraw/frame.d.ts

@@ -1,18 +1,18 @@
 import { ElementsMap, ElementsMapOrArray, ExcalidrawElement, ExcalidrawFrameLikeElement, NonDeleted, NonDeletedExcalidrawElement } from "./element/types";
 import { AppClassProperties, AppState, StaticCanvasAppState } from "./types";
-import { ExcalidrawElementsIncludingDeleted } from "./scene/Scene";
+import type { ExcalidrawElementsIncludingDeleted } from "./scene/Scene";
 import { ReadonlySetLike } from "./utility-types";
 export declare const bindElementsToFramesAfterDuplication: (nextElements: ExcalidrawElement[], oldElements: readonly ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
-export declare function isElementIntersectingFrame(element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement): boolean;
-export declare const getElementsCompletelyInFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement) => ExcalidrawElement[];
-export declare const isElementContainingFrame: (elements: readonly ExcalidrawElement[], element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement) => boolean;
+export declare function isElementIntersectingFrame(element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap): boolean;
+export declare const getElementsCompletelyInFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => ExcalidrawElement[];
+export declare const isElementContainingFrame: (elements: readonly ExcalidrawElement[], element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => boolean;
 export declare const getElementsIntersectingFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement) => ExcalidrawElement[];
-export declare const elementsAreInFrameBounds: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement) => boolean;
-export declare const elementOverlapsWithFrame: (element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement) => boolean;
+export declare const elementsAreInFrameBounds: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => boolean;
+export declare const elementOverlapsWithFrame: (element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => boolean;
 export declare const isCursorInFrame: (cursorCoords: {
     x: number;
     y: number;
-}, frame: NonDeleted<ExcalidrawFrameLikeElement>) => boolean;
+}, frame: NonDeleted<ExcalidrawFrameLikeElement>, elementsMap: ElementsMap) => boolean;
 export declare const groupsAreAtLeastIntersectingTheFrame: (elements: readonly NonDeletedExcalidrawElement[], groupIds: readonly string[], frame: ExcalidrawFrameLikeElement) => boolean;
 export declare const groupsAreCompletelyOutOfFrame: (elements: readonly NonDeletedExcalidrawElement[], groupIds: readonly string[], frame: ExcalidrawFrameLikeElement) => boolean;
 /**
@@ -30,9 +30,9 @@ export declare const getFrameLikeElements: (allElements: ExcalidrawElementsInclu
  * Considers non-frame bound elements (container or arrow labels) as root.
  */
 export declare const getRootElements: (allElements: ExcalidrawElementsIncludingDeleted) => ExcalidrawElement[];
-export declare const getElementsInResizingFrame: (allElements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameLikeElement, appState: AppState) => ExcalidrawElement[];
-export declare const getElementsInNewFrame: (allElements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameLikeElement) => ExcalidrawElement[];
-export declare const getContainingFrame: (element: ExcalidrawElement, elementsMap?: Map<string, ExcalidrawElement>) => ExcalidrawFrameLikeElement | null;
+export declare const getElementsInResizingFrame: (allElements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameLikeElement, appState: AppState, elementsMap: ElementsMap) => ExcalidrawElement[];
+export declare const getElementsInNewFrame: (elements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => ExcalidrawElement[];
+export declare const getContainingFrame: (element: ExcalidrawElement, elementsMap: ElementsMap) => ExcalidrawFrameLikeElement | null;
 /** */
 export declare const filterElementsEligibleAsFrameChildren: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement) => ExcalidrawElement[];
 /**
@@ -58,6 +58,6 @@ export declare const omitGroupsContainingFrameLikes: (allElements: ElementsMapOr
  * is going to be added to or remove from
  */
 export declare const getTargetFrame: (element: ExcalidrawElement, elementsMap: ElementsMap, appState: StaticCanvasAppState) => import("./element/types").ExcalidrawFrameElement | import("./element/types").ExcalidrawMagicFrameElement | null;
-export declare const isElementInFrame: (element: ExcalidrawElement, allElements: ElementsMap, appState: StaticCanvasAppState) => boolean;
+export declare const isElementInFrame: (element: ExcalidrawElement, allElementsMap: ElementsMap, appState: StaticCanvasAppState) => boolean;
 export declare const getFrameLikeTitle: (element: ExcalidrawFrameLikeElement, frameIdx: number) => string;
 export declare const getElementsOverlappingFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement) => NonDeletedExcalidrawElement[];

package/types/excalidraw/history.d.ts

@@ -14,7 +14,7 @@ declare const clearAppStatePropertiesForHistory: (appState: AppState) => {
     viewBackgroundColor: string;
     editingLinearElement: import("./element/linearElementEditor").LinearElementEditor | null;
     editingGroupId: string | null;
-    name: string;
+    name: string | null;
 };
 declare class History {
     private elementCache;

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

@@ -9,12 +9,7 @@ export type ExcalidrawElementsIncludingDeleted = readonly ExcalidrawElement[];
 declare class Scene {
     private static sceneMapByElement;
     private static sceneMapById;
-    static mapElementToScene(elementKey: ElementKey, scene: Scene, 
-    /**
-     * needed because of frame exporting hack.
-     * elementId:Scene mapping will be removed completely, soon.
-     */
-    mapElementIds?: boolean): void;
+    static mapElementToScene(elementKey: ElementKey, scene: Scene): void;
     static getScene(elementKey: ElementKey): Scene | null;
     private callbacks;
     private nonDeletedElements;
@@ -58,7 +53,7 @@ declare class Scene {
      * @returns whether a change was made
      */
     mapElements(iteratee: (element: ExcalidrawElement) => ExcalidrawElement): boolean;
-    replaceAllElements(nextElements: ElementsMapOrArray, mapElementIds?: boolean): void;
+    replaceAllElements(nextElements: ElementsMapOrArray): void;
     informMutation(): void;
     addCallback(cb: SceneStateCallback): SceneStateCallbackRemover;
     destroy(): void;

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

@@ -1,9 +1,10 @@
 import { InteractiveCanvasAppState } from "../types";
-import { RenderableElementsMap, ScrollBars } from "./types";
+import { ScrollBars } from "./types";
+import { 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: RenderableElementsMap, viewportWidth: number, viewportHeight: number, appState: InteractiveCanvasAppState) => ScrollBars;
+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;

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

@@ -1,4 +1,4 @@
-import { ElementsMapOrArray, ExcalidrawElement, NonDeletedExcalidrawElement } from "../element/types";
+import { ElementsMap, ElementsMapOrArray, ExcalidrawElement, NonDeletedExcalidrawElement } from "../element/types";
 import { AppState, InteractiveCanvasAppState } from "../types";
 /**
  * Frames and their containing elements are not to be selected at the same time.
@@ -7,8 +7,8 @@ import { AppState, InteractiveCanvasAppState } from "../types";
  * @param selectedElements
  */
 export declare const excludeElementsInFramesFromSelection: <T extends ExcalidrawElement>(selectedElements: readonly T[]) => T[];
-export declare const getElementsWithinSelection: (elements: readonly NonDeletedExcalidrawElement[], selection: NonDeletedExcalidrawElement, excludeElementsInFrames?: boolean) => NonDeletedExcalidrawElement[];
-export declare const getVisibleAndNonSelectedElements: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: readonly NonDeletedExcalidrawElement[], appState: AppState) => NonDeletedExcalidrawElement[];
+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;

package/types/excalidraw/snapping.d.ts

@@ -1,6 +1,6 @@
 import { Bounds } from "./element/bounds";
 import { MaybeTransformHandleType } from "./element/transformHandles";
-import { ExcalidrawElement, NonDeletedExcalidrawElement } from "./element/types";
+import { ElementsMap, ExcalidrawElement, NonDeletedExcalidrawElement } from "./element/types";
 import { AppState, KeyboardModifiersObject, Point } from "./types";
 export declare const getSnapDistance: (zoomValue: number) => number;
 type Vector2D = {
@@ -66,17 +66,17 @@ export declare const isSnappingEnabled: ({ event, appState, selectedElements, }:
     selectedElements: NonDeletedExcalidrawElement[];
 }) => boolean;
 export declare const areRoughlyEqual: (a: number, b: number, precision?: number) => boolean;
-export declare const getElementsCorners: (elements: ExcalidrawElement[], { omitCenter, boundingBoxCorners, dragOffset, }?: {
+export declare const getElementsCorners: (elements: ExcalidrawElement[], elementsMap: ElementsMap, { omitCenter, boundingBoxCorners, dragOffset, }?: {
     omitCenter?: boolean | undefined;
     boundingBoxCorners?: boolean | undefined;
     dragOffset?: Vector2D | undefined;
 }) => Point[];
-export declare const getVisibleGaps: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: ExcalidrawElement[], appState: AppState) => {
+export declare const getVisibleGaps: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: ExcalidrawElement[], appState: AppState, elementsMap: ElementsMap) => {
     horizontalGaps: Gap[];
     verticalGaps: Gap[];
 };
-export declare const getReferenceSnapPoints: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: ExcalidrawElement[], appState: AppState) => (readonly [number, number])[];
-export declare const snapDraggedElements: (selectedElements: ExcalidrawElement[], dragOffset: Vector2D, appState: AppState, event: KeyboardModifiersObject) => {
+export declare const getReferenceSnapPoints: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: ExcalidrawElement[], appState: AppState, elementsMap: ElementsMap) => (readonly [number, number])[];
+export declare const snapDraggedElements: (elements: ExcalidrawElement[], dragOffset: Vector2D, appState: AppState, event: KeyboardModifiersObject, elementsMap: ElementsMap) => {
     snapOffset: {
         x: number;
         y: number;
@@ -90,14 +90,14 @@ export declare const snapResizingElements: (selectedElements: ExcalidrawElement[
     };
     snapLines: PointSnapLine[];
 };
-export declare const snapNewElement: (draggingElement: ExcalidrawElement, appState: AppState, event: KeyboardModifiersObject, origin: Vector2D, dragOffset: Vector2D) => {
+export declare const snapNewElement: (draggingElement: ExcalidrawElement, appState: AppState, event: KeyboardModifiersObject, origin: Vector2D, dragOffset: Vector2D, elementsMap: ElementsMap) => {
     snapOffset: {
         x: number;
         y: number;
     };
     snapLines: PointSnapLine[];
 };
-export declare const getSnapLinesAtPointer: (elements: readonly ExcalidrawElement[], appState: AppState, pointer: Vector2D, event: KeyboardModifiersObject) => {
+export declare const getSnapLinesAtPointer: (elements: readonly ExcalidrawElement[], appState: AppState, pointer: Vector2D, event: KeyboardModifiersObject, elementsMap: ElementsMap) => {
     originOffset: {
         x: number;
         y: number;

package/types/excalidraw/types.d.ts

@@ -185,7 +185,7 @@ export interface AppState {
     scrollY: number;
     cursorButton: "up" | "down";
     scrolledOutside: boolean;
-    name: string;
+    name: string | null;
     isResizing: boolean;
     isRotating: boolean;
     zoom: Zoom;
@@ -417,7 +417,7 @@ export declare enum UserIdleState {
 }
 export type ExportOpts = {
     saveFileToDisk?: boolean;
-    onExportToBackend?: (exportedElements: readonly NonDeletedExcalidrawElement[], appState: UIAppState, files: BinaryFiles, canvas: HTMLCanvasElement) => void;
+    onExportToBackend?: (exportedElements: readonly NonDeletedExcalidrawElement[], appState: UIAppState, files: BinaryFiles) => void;
     renderCustomUI?: (exportedElements: readonly NonDeletedExcalidrawElement[], appState: UIAppState, files: BinaryFiles, canvas: HTMLCanvasElement) => JSX.Element;
 };
 export type CanvasActions = Partial<{
@@ -480,6 +480,7 @@ export type AppClassProperties = {
     setOpenDialog: App["setOpenDialog"];
     insertEmbeddableElement: App["insertEmbeddableElement"];
     onMagicframeToolSelect: App["onMagicframeToolSelect"];
+    getName: App["getName"];
 };
 export type PointerDownState = Readonly<{
     origin: Readonly<{
@@ -543,12 +544,13 @@ export type ExcalidrawImperativeAPI = {
     history: {
         clear: InstanceType<typeof App>["resetHistory"];
     };
-    scrollToContent: InstanceType<typeof App>["scrollToContent"];
     zoomToFit: InstanceType<typeof App>["zoomToFit"];
     startLineEditor: InstanceType<typeof App>["startLineEditor"];
     getSceneElements: InstanceType<typeof App>["getSceneElements"];
     getAppState: () => InstanceType<typeof App>["state"];
     getFiles: () => InstanceType<typeof App>["files"];
+    getName: InstanceType<typeof App>["getName"];
+    scrollToContent: InstanceType<typeof App>["scrollToContent"];
     registerAction: (action: Action) => void;
     refresh: InstanceType<typeof App>["refresh"];
     setToast: InstanceType<typeof App>["setToast"];

package/types/excalidraw/vite.config.d.mts

@@ -0,0 +1,2 @@
+declare const _default: import("vite").UserConfig;
+export default _default;

package/types/utils/index.d.ts

@@ -0,0 +1 @@
+export * from "./export";