@dwelle/excalidraw 0.3.63 → 0.3.66

package/types/data/library.d.ts

@@ -1,12 +1,9 @@
-import { LibraryItems, LibraryItem } from "../types";
+import { LibraryItems, ExcalidrawImperativeAPI, LibraryItemsSource } from "../types";
 import type App from "../components/App";
-import { ImportedDataState } from "./types";
+import { ExcalidrawElement } from "../element/types";
 export declare const libraryItemsAtom: import("jotai").Atom<{
-    status: "loading";
-    libraryItems: null;
-    promise: Promise<LibraryItems>;
-} | {
-    status: "loaded";
+    status: "loading" | "loaded";
+    isInitialized: boolean;
     libraryItems: LibraryItems;
 }> & {
     write: (get: {
@@ -27,71 +24,73 @@ export declare const libraryItemsAtom: import("jotai").Atom<{
         <Value_6, Result extends void | Promise<void>>(atom: import("jotai").WritableAtom<Value_6, undefined, Result>): Result;
         <Value_7, Update, Result_1 extends void | Promise<void>>(atom: import("jotai").WritableAtom<Value_7, Update, Result_1>, update: Update): Result_1;
     }, update: {
-        status: "loading";
-        libraryItems: null;
-        promise: Promise<LibraryItems>;
-    } | {
-        status: "loaded";
+        status: "loading" | "loaded";
+        isInitialized: boolean;
         libraryItems: LibraryItems;
     } | ((prev: {
-        status: "loading";
-        libraryItems: null;
-        promise: Promise<LibraryItems>;
-    } | {
-        status: "loaded";
+        status: "loading" | "loaded";
+        isInitialized: boolean;
         libraryItems: LibraryItems;
     }) => {
-        status: "loading";
-        libraryItems: null;
-        promise: Promise<LibraryItems>;
-    } | {
-        status: "loaded";
+        status: "loading" | "loaded";
+        isInitialized: boolean;
         libraryItems: LibraryItems;
     })) => void;
     onMount?: (<S extends (update: {
-        status: "loading";
-        libraryItems: null;
-        promise: Promise<LibraryItems>;
-    } | {
-        status: "loaded";
+        status: "loading" | "loaded";
+        isInitialized: boolean;
         libraryItems: LibraryItems;
     } | ((prev: {
-        status: "loading";
-        libraryItems: null;
-        promise: Promise<LibraryItems>;
-    } | {
-        status: "loaded";
+        status: "loading" | "loaded";
+        isInitialized: boolean;
         libraryItems: LibraryItems;
     }) => {
-        status: "loading";
-        libraryItems: null;
-        promise: Promise<LibraryItems>;
-    } | {
-        status: "loaded";
+        status: "loading" | "loaded";
+        isInitialized: boolean;
         libraryItems: LibraryItems;
     })) => void>(setAtom: S) => void | (() => void)) | undefined;
 } & {
     init: {
-        status: "loading";
-        libraryItems: null;
-        promise: Promise<LibraryItems>;
-    } | {
-        status: "loaded";
+        status: "loading" | "loaded";
+        isInitialized: boolean;
         libraryItems: LibraryItems;
     };
 };
+/** Merges otherItems into localItems. Unique items in otherItems array are
+    sorted first. */
+export declare const mergeLibraryItems: (localItems: LibraryItems, otherItems: LibraryItems) => LibraryItems;
 declare class Library {
-    /** cache for currently active promise when initializing/updating libaries
-     asynchronously */
-    private libraryItemsPromise;
-    /** last resolved libraryItems */
+    /** latest libraryItems */
     private lastLibraryItems;
+    /** indicates whether library is initialized with library items (has gone
+     * though at least one update) */
+    private isInitialized;
     private app;
     constructor(app: App);
-    resetLibrary: () => Promise<void>;
-    /** imports library (currently merges, removing duplicates) */
-    importLibrary(library: Blob | Required<ImportedDataState>["libraryItems"] | Promise<Required<ImportedDataState>["libraryItems"]>, defaultStatus?: LibraryItem["status"]): Promise<void>;
-    loadLibrary: () => Promise<LibraryItems>;
-    saveLibrary: (items: LibraryItems | Promise<LibraryItems>) => Promise<void>;
+    private updateQueue;
+    private getLastUpdateTask;
+    private notifyListeners;
+    resetLibrary: () => Promise<LibraryItems>;
+    /**
+     * @returns latest cloned libraryItems. Awaits all in-progress updates first.
+     */
+    getLatestLibrary: () => Promise<LibraryItems>;
+    updateLibrary: ({ libraryItems, prompt, merge, openLibraryMenu, defaultStatus, }: {
+        libraryItems: LibraryItemsSource;
+        merge?: boolean | undefined;
+        prompt?: boolean | undefined;
+        openLibraryMenu?: boolean | undefined;
+        defaultStatus?: "published" | "unpublished" | undefined;
+    }) => Promise<LibraryItems>;
+    setLibrary: (libraryItems: LibraryItems | Promise<LibraryItems> | ((latestLibraryItems: LibraryItems) => LibraryItems | Promise<LibraryItems>)) => Promise<LibraryItems>;
 }
 export default Library;
+export declare const distributeLibraryItemsOnSquareGrid: (libraryItems: LibraryItems) => ExcalidrawElement[];
+export declare const parseLibraryTokensFromUrl: () => {
+    libraryUrl: string;
+    idToken: string | null;
+} | null;
+export declare const useHandleLibrary: ({ excalidrawAPI, getInitialLibraryItems, }: {
+    excalidrawAPI: ExcalidrawImperativeAPI | null;
+    getInitialLibraryItems?: (() => LibraryItemsSource) | undefined;
+}) => void;

package/types/data/types.d.ts

@@ -1,5 +1,5 @@
 import { ExcalidrawElement } from "../element/types";
-import { AppState, BinaryFiles, LibraryItems, LibraryItems_v1 } from "../types";
+import { AppState, BinaryFiles, LibraryItems, LibraryItems_anyVersion } from "../types";
 import type { cleanAppStateForExport } from "../appState";
 import { VERSIONS } from "../constants";
 export interface ExportedDataState {
@@ -17,7 +17,7 @@ export interface ImportedDataState {
     elements?: readonly ExcalidrawElement[] | null;
     appState?: Readonly<Partial<AppState>> | null;
     scrollToContent?: boolean;
-    libraryItems?: LibraryItems | LibraryItems_v1;
+    libraryItems?: LibraryItems_anyVersion;
     files?: BinaryFiles;
 }
 export interface ExportedLibraryData {

package/types/distribute.d.ts

@@ -0,0 +1,6 @@
+import { ExcalidrawElement } from "./element/types";
+export interface Distribution {
+    space: "between";
+    axis: "x" | "y";
+}
+export declare const distributeElements: (selectedElements: ExcalidrawElement[], distribution: Distribution) => ExcalidrawElement[];

package/types/element/Hyperlink.d.ts

@@ -32,7 +32,13 @@ export declare const actionLink: {
             editingLinearElement: import("./linearElementEditor").LinearElementEditor | null;
             activeTool: {
                 type: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "freedraw" | "eraser";
-                lastActiveToolBeforeEraser: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "freedraw" | null;
+                lastActiveToolBeforeEraser: import("../types").LastActiveToolBeforeEraser;
+                locked: boolean;
+                customType: null;
+            } | {
+                type: "custom";
+                customType: string;
+                lastActiveToolBeforeEraser: import("../types").LastActiveToolBeforeEraser;
                 locked: boolean;
             };
             penMode: boolean;

package/types/element/linearElementEditor.d.ts

@@ -86,7 +86,10 @@ export declare class LinearElementEditor {
                 startBindingElement: ExcalidrawBindableElement | "keep" | null;
                 endBindingElement: ExcalidrawBindableElement | "keep" | null;
             };
-            isLoading: boolean;
+            isLoading: boolean; /**
+             * @param id the `elementId` from the instance of this class (so that we can
+             *  statically guarantee this method returns an ExcalidrawLinearElement)
+             */
             errorMessage: string | null;
             draggingElement: import("./types").NonDeletedExcalidrawElement | null;
             resizingElement: import("./types").NonDeletedExcalidrawElement | null;
@@ -98,7 +101,13 @@ export declare class LinearElementEditor {
             editingElement: import("./types").NonDeletedExcalidrawElement | null;
             activeTool: {
                 type: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "freedraw" | "eraser";
-                lastActiveToolBeforeEraser: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "freedraw" | null;
+                lastActiveToolBeforeEraser: import("../types").LastActiveToolBeforeEraser;
+                locked: boolean;
+                customType: null;
+            } | {
+                type: "custom";
+                customType: string;
+                lastActiveToolBeforeEraser: import("../types").LastActiveToolBeforeEraser;
                 locked: boolean;
             };
             penMode: boolean;

package/types/packages/excalidraw/dist/excalidraw.production.min.d.ts

@@ -1,3 +1 @@
-declare const _exports: any;
-export = _exports;
-export var ExcalidrawLib: any;
+export const ExcalidrawLib: {};

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

@@ -7,12 +7,12 @@ export declare const Excalidraw: React.MemoExoticComponent<React.ForwardRefExoti
 export { getSceneVersion, isInvisiblySmallElement, getNonDeletedElements, } from "../../element";
 export { defaultLang, languages } from "../../i18n";
 export { restore, restoreAppState, restoreElements, restoreLibraryItems, } from "../../data/restore";
-export { exportToBlob, exportToCanvas, exportToSvg, serializeAsJSON, serializeLibraryAsJSON, loadLibraryFromBlob, loadFromBlob, getFreeDrawSvgPath, } from "../../packages/utils";
+export { exportToBlob, exportToCanvas, exportToSvg, serializeAsJSON, serializeLibraryAsJSON, loadLibraryFromBlob, loadFromBlob, loadSceneOrLibraryFromBlob, getFreeDrawSvgPath, exportToClipboard, mergeLibraryItems, } from "../../packages/utils";
 export { isLinearElement } from "../../element/typeChecks";
+export { FONT_FAMILY, THEME, MIME_TYPES } from "../../constants";
 export { mutateElement, newElementWith, bumpVersion, } from "../../element/mutateElement";
-export { FONT_FAMILY, THEME } from "../../constants";
-export { exportToClipboard } from "../utils";
-export { getDefaultAppState } from "../../appState";
-export { cleanAppStateForExport, clearAppStateForLocalStorage, } from "../../appState";
+export { parseLibraryTokensFromUrl, useHandleLibrary, } from "../../data/library";
+export { sceneCoordsToViewportCoords, viewportCoordsToSceneCoords, } from "../../utils";
+export { getDefaultAppState, cleanAppStateForExport, clearAppStateForLocalStorage, } from "../../appState";
 export { jotaiScope, jotaiStore } from "../../jotai";
 export { libraryItemsAtom } from "../../data/library";

package/types/packages/utils.d.ts

@@ -1,5 +1,7 @@
 import { AppState, BinaryFiles } from "../types";
 import { ExcalidrawElement, NonDeleted } from "../element/types";
+import { MIME_TYPES } from "../constants";
+export { MIME_TYPES };
 declare type ExportOpts = {
     elements: readonly NonDeleted<ExcalidrawElement>[];
     appState?: Partial<Omit<AppState, "offsetTop" | "offsetLeft">>;
@@ -15,14 +17,16 @@ export declare const exportToCanvas: ({ elements, appState, files, maxWidthOrHei
 export declare const exportToBlob: (opts: ExportOpts & {
     mimeType?: string;
     quality?: number;
-}) => Promise<Blob | null>;
+}) => Promise<Blob>;
 export declare const exportToSvg: ({ elements, appState, files, exportPadding, }: Omit<ExportOpts, "getDimensions"> & {
     exportPadding?: number | undefined;
 }) => Promise<SVGSVGElement>;
-export { serializeAsJSON, serializeLibraryAsJSON } from "../data/json";
 export declare const exportToClipboard: (opts: ExportOpts & {
     mimeType?: string;
     quality?: number;
+    type: "png" | "svg" | "json";
 }) => Promise<void>;
-export { loadFromBlob, loadLibraryFromBlob } from "../data/blob";
+export { serializeAsJSON, serializeLibraryAsJSON } from "../data/json";
+export { loadFromBlob, loadSceneOrLibraryFromBlob, loadLibraryFromBlob, } from "../data/blob";
 export { getFreeDrawSvgPath } from "../renderer/renderElement";
+export { mergeLibraryItems } from "../data/library";

package/types/scene/Scene.d.ts

@@ -14,10 +14,9 @@ declare class Scene {
     private elements;
     private elementsMap;
     getElementsIncludingDeleted(): readonly ExcalidrawElement[];
-    getElements(): readonly NonDeletedExcalidrawElement[];
+    getNonDeletedElements(): readonly NonDeletedExcalidrawElement[];
     getElement<T extends ExcalidrawElement>(id: T["id"]): T | null;
     getNonDeletedElement(id: ExcalidrawElement["id"]): NonDeleted<ExcalidrawElement> | null;
-    getNonDeletedElements(ids: readonly ExcalidrawElement["id"][]): NonDeleted<ExcalidrawElement>[];
     replaceAllElements(nextElements: readonly ExcalidrawElement[]): void;
     informMutation(): void;
     addCallback(cb: SceneStateCallback): SceneStateCallbackRemover;

package/types/types.d.ts

@@ -29,7 +29,7 @@ export declare type Collaborator = {
         background: string;
         stroke: string;
     };
-    picture?: string;
+    avatarUrl?: string;
 };
 export declare type DataURL = string & {
     _brand: "DataURL";
@@ -42,6 +42,13 @@ export declare type BinaryFileData = {
 };
 export declare type BinaryFileMetadata = Omit<BinaryFileData, "dataURL">;
 export declare type BinaryFiles = Record<ExcalidrawElement["id"], BinaryFileData>;
+export declare type LastActiveToolBeforeEraser = {
+    type: typeof SHAPES[number]["value"] | "eraser";
+    customType: null;
+} | {
+    type: "custom";
+    customType: string;
+} | null;
 export declare type AppState = {
     isLoading: boolean;
     errorMessage: string | null;
@@ -56,7 +63,13 @@ export declare type AppState = {
     editingLinearElement: LinearElementEditor | null;
     activeTool: {
         type: typeof SHAPES[number]["value"] | "eraser";
-        lastActiveToolBeforeEraser: typeof SHAPES[number]["value"] | null;
+        lastActiveToolBeforeEraser: LastActiveToolBeforeEraser;
+        locked: boolean;
+        customType: null;
+    } | {
+        type: "custom";
+        customType: string;
+        lastActiveToolBeforeEraser: LastActiveToolBeforeEraser;
         locked: boolean;
     };
     penMode: boolean;
@@ -157,7 +170,7 @@ export declare class GestureEvent extends UIEvent {
 /** @deprecated legacy: do not use outside of migration paths */
 export declare type LibraryItem_v1 = readonly NonDeleted<ExcalidrawElement>[];
 /** @deprecated legacy: do not use outside of migration paths */
-export declare type LibraryItems_v1 = readonly LibraryItem_v1[];
+declare type LibraryItems_v1 = readonly LibraryItem_v1[];
 /** v2 library item */
 export declare type LibraryItem = {
     id: string;
@@ -169,6 +182,8 @@ export declare type LibraryItem = {
     error?: string;
 };
 export declare type LibraryItems = readonly LibraryItem[];
+export declare type LibraryItems_anyVersion = LibraryItems | LibraryItems_v1;
+export declare type LibraryItemsSource = ((currentLibraryItems: LibraryItems) => Blob | LibraryItems_anyVersion | Promise<LibraryItems_anyVersion | Blob>) | Blob | LibraryItems_anyVersion | Promise<LibraryItems_anyVersion | Blob>;
 export declare type ExcalidrawAPIRefValue = ExcalidrawImperativeAPI | {
     readyPromise?: ResolvablePromise<ExcalidrawImperativeAPI>;
     ready?: false;
@@ -217,13 +232,14 @@ export interface ExcalidrawProps {
     onLinkOpen?: (element: NonDeletedExcalidrawElement, event: CustomEvent<{
         nativeEvent: MouseEvent | React.PointerEvent<HTMLCanvasElement>;
     }>) => void;
+    onPointerDown?: (activeTool: AppState["activeTool"], pointerDownState: PointerDownState) => void;
+    onScrollChange?: (scrollX: number, scrollY: number) => void;
 }
 export declare type SceneData = {
     elements?: ImportedDataState["elements"];
     appState?: ImportedDataState["appState"];
     collaborators?: Map<string, Collaborator>;
     commitToHistory?: boolean;
-    libraryItems?: LibraryItems | LibraryItems_v1;
 };
 export declare enum UserIdleState {
     ACTIVE = "active",
@@ -331,6 +347,7 @@ export declare type PointerDownState = Readonly<{
 }>;
 export declare type ExcalidrawImperativeAPI = {
     updateScene: InstanceType<typeof App>["updateScene"];
+    updateLibrary: InstanceType<typeof Library>["updateLibrary"];
     resetScene: InstanceType<typeof App>["resetScene"];
     getSceneElementsIncludingDeleted: InstanceType<typeof App>["getSceneElementsIncludingDeleted"];
     history: {
@@ -341,15 +358,16 @@ export declare type ExcalidrawImperativeAPI = {
     getAppState: () => InstanceType<typeof App>["state"];
     getFiles: () => InstanceType<typeof App>["files"];
     refresh: InstanceType<typeof App>["refresh"];
-    importLibrary: InstanceType<typeof App>["importLibraryFromUrl"];
     setToastMessage: InstanceType<typeof App>["setToastMessage"];
     addFiles: (data: BinaryFileData[]) => void;
     readyPromise: ResolvablePromise<ExcalidrawImperativeAPI>;
     ready: true;
     id: string;
+    setActiveTool: InstanceType<typeof App>["setActiveTool"];
     app: InstanceType<typeof App>;
 };
 export declare type DeviceType = {
     isMobile: boolean;
     isTouchScreen: boolean;
 };
+export {};

package/types/utils.d.ts

@@ -1,6 +1,7 @@
 import { EVENT } from "./constants";
 import { FontFamilyValues, FontString } from "./element/types";
-import { AppState, Zoom } from "./types";
+import { AppState, LastActiveToolBeforeEraser, Zoom } from "./types";
+import { SHAPES } from "./shapes";
 export declare const setDateTimeForTests: (dateTime: string) => void;
 export declare const getDateTime: () => string;
 export declare const capitalizeString: (str: string) => string;
@@ -29,6 +30,14 @@ export declare const chunk: <T extends unknown>(array: readonly T[], size: numbe
 export declare const selectNode: (node: Element) => void;
 export declare const removeSelection: () => void;
 export declare const distance: (x: number, y: number) => number;
+export declare const updateActiveTool: (appState: Pick<AppState, "activeTool">, data: ({
+    type: typeof SHAPES[number]["value"] | "eraser";
+} | {
+    type: "custom";
+    customType: string;
+}) & {
+    lastActiveToolBeforeEraser?: LastActiveToolBeforeEraser;
+}) => AppState["activeTool"];
 export declare const resetCursor: (canvas: HTMLCanvasElement | null) => void;
 export declare const setCursor: (canvas: HTMLCanvasElement | null, cursor: string) => void;
 export declare const setEraserCursor: (canvas: HTMLCanvasElement | null, theme: AppState["theme"]) => void;