@zsviczian/excalidraw 0.17.1-obsidian-17 → 0.17.1-obsidian-19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zsviczian/excalidraw",
-  "version": "0.17.1-obsidian-17",
+  "version": "0.17.1-obsidian-19",
   "main": "main.js",
   "types": "types/excalidraw/index.d.ts",
   "files": [

package/types/excalidraw/components/Toast.d.ts

@@ -1,7 +1,9 @@
+import { CSSProperties } from "react";
 import "./Toast.scss";
-export declare const Toast: ({ message, onClose, closable, duration, }: {
+export declare const Toast: ({ message, onClose, closable, duration, style, }: {
     message: string;
     onClose: () => void;
     closable?: boolean | undefined;
     duration?: number | undefined;
+    style?: CSSProperties | undefined;
 }) => import("react/jsx-runtime").JSX.Element;

package/types/excalidraw/components/icons.d.ts

@@ -60,6 +60,7 @@ export declare const UndoIcon: import("react/jsx-runtime").JSX.Element;
 export declare const RedoIcon: import("react/jsx-runtime").JSX.Element;
 export declare const questionCircle: import("react/jsx-runtime").JSX.Element;
 export declare const share: import("react/jsx-runtime").JSX.Element;
+export declare const warning: import("react/jsx-runtime").JSX.Element;
 export declare const shareIOS: import("react/jsx-runtime").JSX.Element;
 export declare const shareWindows: import("react/jsx-runtime").JSX.Element;
 export declare const resetZoom: import("react/jsx-runtime").JSX.Element;

package/types/excalidraw/data/library.d.ts

@@ -1,13 +1,53 @@
-import { LibraryItems, ExcalidrawImperativeAPI, LibraryItemsSource } from "../types";
+import { LibraryItems, ExcalidrawImperativeAPI, LibraryItemsSource, LibraryItems_anyVersion } from "../types";
 import type App from "../components/App";
 import { ExcalidrawElement } from "../element/types";
+import { MaybePromise } from "../utility-types";
+export type LibraryPersistedData = {
+    libraryItems: LibraryItems;
+};
+export type LibraryAdatapterSource = "load" | "save";
+export interface LibraryPersistenceAdapter {
+    /**
+     * Should load data that were previously saved into the database using the
+     * `save` method. Should throw if saving fails.
+     *
+     * Will be used internally in multiple places, such as during save to
+     * in order to reconcile changes with latest store data.
+     */
+    load(metadata: {
+        /**
+         * Indicates whether we're loading data for save purposes, or reading
+         * purposes, in which case host app can implement more aggressive caching.
+         */
+        source: LibraryAdatapterSource;
+    }): MaybePromise<{
+        libraryItems: LibraryItems_anyVersion;
+    } | null>;
+    /** Should persist to the database as is (do no change the data structure). */
+    save(libraryData: LibraryPersistedData): MaybePromise<void>;
+}
+export interface LibraryMigrationAdapter {
+    /**
+     * loads data from legacy data source. Returns `null` if no data is
+     * to be migrated.
+     */
+    load(): MaybePromise<{
+        libraryItems: LibraryItems_anyVersion;
+    } | null>;
+    /** clears entire storage afterwards */
+    clear(): MaybePromise<void>;
+}
 export declare const libraryItemsAtom: import("jotai").PrimitiveAtom<{
     status: "loading" | "loaded";
+    /** indicates whether library is initialized with library items (has gone
+     * through at least one update). Used in UI. Specific to this atom only. */
     isInitialized: boolean;
     libraryItems: LibraryItems;
 }> & {
     init: {
         status: "loading" | "loaded";
+        /** indicates whether library is initialized with library items (has gone
+         * through at least one update). Used in UI. Specific to this atom only. */
         isInitialized: boolean;
         libraryItems: LibraryItems;
     };
@@ -17,10 +57,9 @@ export declare const libraryItemsAtom: import("jotai").PrimitiveAtom<{
 export declare const mergeLibraryItems: (localItems: LibraryItems, otherItems: LibraryItems) => LibraryItems;
 declare class Library {
     /** latest libraryItems */
-    private lastLibraryItems;
-    /** indicates whether library is initialized with library items (has gone
-     * though at least one update) */
-    private isInitialized;
+    private currLibraryItems;
+    /** snapshot of library items since last onLibraryChange call */
+    private prevLibraryItems;
     private app;
     constructor(app: App);
     private updateQueue;
@@ -48,7 +87,20 @@ export declare const parseLibraryTokensFromUrl: () => {
     libraryUrl: string;
     idToken: string | null;
 } | null;
-export declare const useHandleLibrary: ({ excalidrawAPI, getInitialLibraryItems, }: {
+export declare const getLibraryItemsHash: (items: LibraryItems) => number;
+export declare const useHandleLibrary: (opts: {
     excalidrawAPI: ExcalidrawImperativeAPI | null;
-    getInitialLibraryItems?: (() => LibraryItemsSource) | undefined;
-}) => void;
+} & ({
+    /** @deprecated we recommend using `opts.adapter` instead */
+    getInitialLibraryItems?: () => MaybePromise<LibraryItemsSource>;
+} | {
+    adapter: LibraryPersistenceAdapter;
+    /**
+     * Adapter that takes care of loading data from legacy data store.
+     * Supply this if you want to migrate data on initial load from legacy
+     * data store.
+     *
+     * Can be a different LibraryPersistenceAdapter.
+     */
+    migrationAdapter?: LibraryMigrationAdapter;
+})) => void;

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

@@ -10,7 +10,15 @@ export { isTextElement, isExcalidrawElement } from "./typeChecks";
 export { redrawTextBoundingBox } from "./textElement";
 export { getPerfectElementSize, getLockedLinearCursorAlignSize, isInvisiblySmallElement, resizePerfectLineForNWHandler, getNormalizedDimensions, } from "./sizeHelpers";
 export { showSelectedShapeActions } from "./showSelectedShapeActions";
+/**
+ * @deprecated unsafe, use hashElementsVersion instead
+ */
 export declare const getSceneVersion: (elements: readonly ExcalidrawElement[]) => number;
+/**
+ * Hashes elements' versionNonce (using djb2 algo). Order of elements matters.
+ */
+export declare const hashElementsVersion: (elements: readonly ExcalidrawElement[]) => number;
+export declare const hashString: (s: string) => number;
 export declare const getVisibleElements: (elements: readonly ExcalidrawElement[]) => readonly NonDeletedExcalidrawElement[];
 export declare const getNonDeletedElements: <T extends ExcalidrawElement>(elements: readonly T[]) => readonly NonDeleted<T>[];
 export declare const isNonDeletedElement: <T extends ExcalidrawElement>(element: T) => element is NonDeleted<T>;

package/types/excalidraw/element/linearElementEditor.d.ts

@@ -232,7 +232,7 @@ export declare class LinearElementEditor {
             offsetLeft: number;
             fileHandle: import("browser-fs-access").FileSystemHandle | null;
             collaborators: Map<import("../types").SocketId, Readonly<{
-                pointer?: import("../types").CollaboratorPointer | undefined; /** indices */
+                pointer?: import("../types").CollaboratorPointer | undefined;
                 button?: "up" | "down" | undefined;
                 selectedElementIds?: Readonly<{
                     [id: string]: true;

package/types/excalidraw/element/newElement.d.ts

@@ -33,7 +33,6 @@ export declare const refreshTextDimensions: (textElement: ExcalidrawTextElement,
     y: number;
     width: number;
     height: number;
-    baseline: number;
     text: string;
 } | undefined;
 export declare const updateTextElement: (textElement: ExcalidrawTextElement, container: ExcalidrawTextContainer | null, elementsMap: ElementsMap, { text, isDeleted, originalText, rawText, link, }: {

package/types/excalidraw/element/textElement.d.ts

@@ -1,7 +1,7 @@
 import { ElementsMap, ExcalidrawElement, ExcalidrawElementType, ExcalidrawTextContainer, ExcalidrawTextElement, ExcalidrawTextElementWithContainer, FontFamilyValues, FontString, NonDeletedExcalidrawElement } from "./types";
 import { MaybeTransformHandleType } from "./transformHandles";
 import { AppState } from "../types";
-import { ExtractSetType } from "../utility-types";
+import { ExtractSetType, MakeBrand } from "../utility-types";
 export declare const normalizeText: (text: string) => string;
 export declare const redrawTextBoundingBox: (textElement: ExcalidrawTextElement, container: ExcalidrawElement | null, elementsMap: ElementsMap) => void;
 export declare const bindTextToShapeAfterDuplication: (newElements: ExcalidrawElement[], oldElements: ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
@@ -14,8 +14,11 @@ export declare const measureText: (text: string, font: FontString, lineHeight: E
     baseline: number;
     height: number;
     width: number;
+} | {
+    width: number;
+    height: number;
+    baseline?: undefined;
 };
-export declare const measureBaseline: (text: string, font: FontString, lineHeight: ExcalidrawTextElement["lineHeight"], wrapInContainer?: boolean) => number;
 /**
  * To get unitless line-height (if unknown) we can calculate it by dividing
  * height-per-line by fontSize.
@@ -28,6 +31,10 @@ export declare const detectLineHeight: (textElement: ExcalidrawTextElement) => n
  * aligning with the W3C spec.
  */
 export declare const getLineHeightInPx: (fontSize: ExcalidrawTextElement["fontSize"], lineHeight: ExcalidrawTextElement["lineHeight"]) => number;
+/**
+ * Calculates vertical offset for a text with alphabetic baseline.
+ */
+export declare const getVerticalOffset: (fontFamily: ExcalidrawTextElement["fontFamily"], fontSize: ExcalidrawTextElement["fontSize"], lineHeightPx: number) => number;
 export declare const getApproxMinLineHeight: (fontSize: ExcalidrawTextElement["fontSize"], lineHeight: ExcalidrawTextElement["lineHeight"]) => number;
 export declare const getTextWidth: (text: string, font: FontString) => number;
 export declare const getTextHeight: (text: string, fontSize: number, lineHeight: ExcalidrawTextElement["lineHeight"]) => number;
@@ -68,6 +75,21 @@ export declare const computeContainerDimensionForBoundText: (dimension: number,
 export declare const getBoundTextMaxWidth: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElement | null) => number;
 export declare const getBoundTextMaxHeight: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElementWithContainer) => number;
 export declare const isMeasureTextSupported: () => boolean;
+/** OS/2 sTypoAscender, https://learn.microsoft.com/en-us/typography/opentype/spec/os2#stypoascender */
+type sTypoAscender = number & MakeBrand<"sTypoAscender">;
+/** OS/2 sTypoDescender, https://learn.microsoft.com/en-us/typography/opentype/spec/os2#stypodescender */
+type sTypoDescender = number & MakeBrand<"sTypoDescender">;
+/**
+ * Hardcoded metrics for default fonts, read by https://opentype.js.org/font-inspector.html.
+ * For custom fonts, read these metrics from OS/2 table and extend this object.
+ *
+ * WARN: opentype does NOT open WOFF2 correctly, make sure to convert WOFF2 to TTF first.
+ */
+export declare const FONT_METRICS: Record<number, {
+    unitsPerEm: number;
+    ascender: sTypoAscender;
+    descender: sTypoDescender;
+}>;
 export declare const getDefaultLineHeight: (fontFamily: FontFamilyValues) => number & {
     _brand: "unitlessLineHeight";
 };

package/types/excalidraw/element/types.d.ts

@@ -137,7 +137,6 @@ export type ExcalidrawTextElement = _ExcalidrawElementBase & Readonly<{
     fontFamily: FontFamilyValues;
     text: string;
     rawText: string;
-    baseline: number;
     textAlign: TextAlign;
     verticalAlign: VerticalAlign;
     containerId: ExcalidrawGenericElement["id"] | null;

package/types/excalidraw/index.d.ts

@@ -8,10 +8,10 @@ import MainMenu from "./components/main-menu/MainMenu";
 import WelcomeScreen from "./components/welcome-screen/WelcomeScreen";
 import LiveCollaborationTrigger from "./components/live-collaboration/LiveCollaborationTrigger";
 export declare const Excalidraw: React.MemoExoticComponent<(props: ExcalidrawProps) => import("react/jsx-runtime").JSX.Element>;
-export { getSceneVersion, isInvisiblySmallElement, getNonDeletedElements, } from "./element";
+export { getSceneVersion, hashElementsVersion, hashString, isInvisiblySmallElement, getNonDeletedElements, } from "./element";
 export { defaultLang, useI18n, languages } from "./i18n";
 export { restore, restoreAppState, restoreElements, restoreLibraryItems, } from "./data/restore";
-export { exportToCanvas, exportToBlob, exportToSvg, serializeAsJSON, serializeLibraryAsJSON, loadLibraryFromBlob, loadFromBlob, loadSceneOrLibraryFromBlob, getFreeDrawSvgPath, getCommonBoundingBox, //zsviczian
+export { exportToCanvas, exportToBlob, exportToSvg, exportToClipboard, getCommonBoundingBox, //zsviczian
 getMaximumGroups, //zsviczian
 intersectElementWithLine, //zsviczian
 determineFocusDistance, //zsviczian
@@ -20,7 +20,11 @@ getDefaultLineHeight, //zsviczian
 wrapText, //zsviczian
 getFontString, //zsviczian
 getBoundTextMaxWidth, //zsviczian
-exportToClipboard, mergeLibraryItems, mermaidToExcalidraw, } from "../utils/export";
+mermaidToExcalidraw, } from "../utils/export";
+export { serializeAsJSON, serializeLibraryAsJSON } from "./data/json";
+export { loadFromBlob, loadSceneOrLibraryFromBlob, loadLibraryFromBlob, } from "./data/blob";
+export { getFreeDrawSvgPath } from "./renderer/renderElement";
+export { mergeLibraryItems, getLibraryItemsHash } from "./data/library";
 export { isLinearElement } from "./element/typeChecks";
 export { FONT_FAMILY, THEME, MIME_TYPES, ROUNDNESS } from "./constants";
 export { mutateElement, newElementWith, bumpVersion, } from "./element/mutateElement";
@@ -41,4 +45,4 @@ export { normalizeLink } from "./data/url";
 export { zoomToFitBounds } from "./actions/actionCanvas";
 export { convertToExcalidrawElements } from "./data/transform";
 export { getCommonBounds, getVisibleSceneBounds } from "./element/bounds";
-export { elementsOverlappingBBox, isElementInsideBBox, elementPartiallyOverlapsWithOrContainsBBox, } from "../utils/export";
+export { elementsOverlappingBBox, isElementInsideBBox, elementPartiallyOverlapsWithOrContainsBBox, } from "../utils/withinBounds";

package/types/excalidraw/obsidianUtils.d.ts

@@ -2,3 +2,4 @@ export declare const getAreaLimit: () => any;
 export declare const getWidthHeightLimit: () => any;
 export declare const isExcaliBrainView: () => any;
 export declare const getExcalidrawContentEl: () => HTMLElement;
+export declare const hideFreedrawPenmodeCursor: () => boolean;

package/types/excalidraw/queue.d.ts

@@ -0,0 +1,9 @@
+import { MaybePromise } from "./utility-types";
+type Job<T, TArgs extends unknown[]> = (...args: TArgs) => MaybePromise<T>;
+export declare class Queue {
+    private jobs;
+    private running;
+    private tick;
+    push<TValue, TArgs extends unknown[]>(jobFactory: Job<TValue, TArgs>, ...args: TArgs): Promise<TValue>;
+}
+export {};

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

@@ -0,0 +1,13 @@
+import { StaticCanvasAppState, AppState } from "../types";
+import { StaticCanvasRenderConfig } from "../scene/types";
+export declare const fillCircle: (context: CanvasRenderingContext2D, cx: number, cy: number, radius: number, stroke?: boolean) => void;
+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("../element/types").Theme | undefined;
+    isExporting?: boolean | undefined;
+    viewBackgroundColor?: string | null | undefined;
+}) => CanvasRenderingContext2D;

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

@@ -0,0 +1,20 @@
+import { InteractiveSceneRenderConfig, RenderableElementsMap } from "../scene/types";
+/** throttled to animation framerate */
+export declare const renderInteractiveSceneThrottled: {
+    (config: InteractiveSceneRenderConfig): void;
+    flush(): void;
+    cancel(): void;
+};
+/**
+ * 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, scale, appState, renderConfig, }: 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>;

package/types/excalidraw/renderer/renderElement.d.ts

@@ -1,8 +1,8 @@
 import { ExcalidrawElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, ExcalidrawFreeDrawElement, ExcalidrawFrameLikeElement, NonDeletedSceneElementsMap } from "../element/types";
 import type { RoughCanvas } from "roughjs/bin/canvas";
-import type { RoughSVG } from "roughjs/bin/svg";
-import { SVGRenderConfig, StaticCanvasRenderConfig, RenderableElementsMap } from "../scene/types";
-import { AppState, StaticCanvasAppState, BinaryFiles, InteractiveCanvasAppState, ElementsPendingErasure } from "../types";
+import { StaticCanvasRenderConfig, RenderableElementsMap } from "../scene/types";
+import { AppState, StaticCanvasAppState, InteractiveCanvasAppState, ElementsPendingErasure } from "../types";
+export declare const IMAGE_INVERT_FILTER = "invert(100%) hue-rotate(180deg) saturate(1.25)";
 export declare const getRenderOpacity: (element: ExcalidrawElement, containingFrame: ExcalidrawFrameLikeElement | null, elementsPendingErasure: ElementsPendingErasure) => number;
 export interface ExcalidrawElementWithCanvas {
     element: ExcalidrawElement | ExcalidrawTextElement;
@@ -19,7 +19,6 @@ export declare const DEFAULT_LINK_SIZE = 14;
 export declare const elementWithCanvasCache: WeakMap<ExcalidrawElement, ExcalidrawElementWithCanvas>;
 export declare const renderSelectionElement: (element: NonDeletedExcalidrawElement, context: CanvasRenderingContext2D, appState: InteractiveCanvasAppState) => void;
 export declare const renderElement: (element: NonDeletedExcalidrawElement, elementsMap: RenderableElementsMap, allElementsMap: NonDeletedSceneElementsMap, rc: RoughCanvas, context: CanvasRenderingContext2D, renderConfig: StaticCanvasRenderConfig, appState: StaticCanvasAppState) => void;
-export declare const renderElementToSvg: (element: NonDeletedExcalidrawElement, elementsMap: RenderableElementsMap, rsvg: RoughSVG, svgRoot: SVGElement, files: BinaryFiles, offsetX: number, offsetY: number, renderConfig: SVGRenderConfig) => void;
 export declare const pathsCache: WeakMap<ExcalidrawFreeDrawElement, Path2D>;
 export declare function generateFreeDrawShape(element: ExcalidrawFreeDrawElement): Path2D;
 export declare function getFreeDrawPath2D(element: ExcalidrawFreeDrawElement): Path2D | undefined;

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

@@ -0,0 +1,11 @@
+import { StaticSceneRenderConfig } from "../scene/types";
+/** throttled to animation framerate */
+export declare const renderStaticSceneThrottled: {
+    (config: StaticSceneRenderConfig): void;
+    flush(): void;
+    cancel(): void;
+};
+/**
+ * Static scene is the non-ui canvas where we render elements.
+ */
+export declare const renderStaticScene: (renderConfig: StaticSceneRenderConfig, throttle?: boolean) => void;

package/types/excalidraw/renderer/staticSvgScene.d.ts

@@ -0,0 +1,5 @@
+import { RoughSVG } from "roughjs/bin/svg";
+import { NonDeletedExcalidrawElement } from "../element/types";
+import { RenderableElementsMap, SVGRenderConfig } from "../scene/types";
+import { BinaryFiles } from "../types";
+export declare const renderSceneToSvg: (elements: readonly NonDeletedExcalidrawElement[], elementsMap: RenderableElementsMap, rsvg: RoughSVG, svgRoot: SVGElement, files: BinaryFiles, renderConfig: SVGRenderConfig) => void;

package/types/excalidraw/types.d.ts

@@ -17,7 +17,7 @@ import type { FileSystemHandle } from "./data/filesystem";
 import type { IMAGE_MIME_TYPES, MIME_TYPES } from "./constants";
 import { ContextMenuItems } from "./components/ContextMenu";
 import { SnapLine } from "./snapping";
-import { Merge, ValueOf } from "./utility-types";
+import { Merge, MaybePromise, ValueOf } from "./utility-types";
 import { ColorPaletteCustom } from "./colors";
 export type Point = Readonly<RoughPoint>;
 export type SocketId = string & {
@@ -341,9 +341,9 @@ export type LibraryItem = {
 };
 export type LibraryItems = readonly LibraryItem[];
 export type LibraryItems_anyVersion = LibraryItems | LibraryItems_v1;
-export type LibraryItemsSource = ((currentLibraryItems: LibraryItems) => Blob | LibraryItems_anyVersion | Promise<LibraryItems_anyVersion | Blob>) | Blob | LibraryItems_anyVersion | Promise<LibraryItems_anyVersion | Blob>;
+export type LibraryItemsSource = ((currentLibraryItems: LibraryItems) => MaybePromise<LibraryItems_anyVersion | Blob>) | MaybePromise<LibraryItems_anyVersion | Blob>;
 export type ExcalidrawInitialDataState = Merge<ImportedDataState, {
-    libraryItems?: Required<ImportedDataState>["libraryItems"] | Promise<Required<ImportedDataState>["libraryItems"]>;
+    libraryItems?: MaybePromise<Required<ImportedDataState>["libraryItems"]>;
 }>;
 export type OnUserFollowedPayload = {
     userToFollow: UserToFollow;
@@ -351,7 +351,7 @@ export type OnUserFollowedPayload = {
 };
 export interface ExcalidrawProps {
     onChange?: (elements: readonly ExcalidrawElement[], appState: AppState, files: BinaryFiles) => void;
-    initialData?: ExcalidrawInitialDataState | null | Promise<ExcalidrawInitialDataState | null>;
+    initialData?: MaybePromise<ExcalidrawInitialDataState | null>;
     excalidrawAPI?: (api: ExcalidrawImperativeAPI) => void;
     isCollaborating?: boolean;
     onPointerUpdate?: (payload: {
@@ -536,7 +536,7 @@ export type PointerDownState = Readonly<{
     };
 }>;
 export type UnsubscribeCallback = () => void;
-export type ExcalidrawImperativeAPI = {
+export interface ExcalidrawImperativeAPI {
     updateScene: InstanceType<typeof App>["updateScene"];
     updateLibrary: InstanceType<typeof Library>["updateLibrary"];
     resetScene: InstanceType<typeof App>["resetScene"];
@@ -580,7 +580,7 @@ export type ExcalidrawImperativeAPI = {
     onPointerUp: (callback: (activeTool: AppState["activeTool"], pointerDownState: PointerDownState, event: PointerEvent) => void) => UnsubscribeCallback;
     onScrollChange: (callback: (scrollX: number, scrollY: number, zoom: Zoom) => void) => UnsubscribeCallback;
     onUserFollow: (callback: (payload: OnUserFollowedPayload) => void) => UnsubscribeCallback;
-};
+}
 export type Device = Readonly<{
     viewport: {
         isMobile: boolean;

package/types/excalidraw/utility-types.d.ts

@@ -27,3 +27,5 @@ export type ReadonlySetLike<T> = ReadonlySet<T> | readonly T[];
 export type MakeBrand<T extends string> = {
     [K in `~brand~${T}`]: T;
 };
+/** Maybe just promise or already fulfilled one! */
+export type MaybePromise<T> = T | Promise<T>;

package/types/excalidraw/utils.d.ts

@@ -1,6 +1,7 @@
 import { EVENT } from "./constants";
 import { FontFamilyValues, FontString } from "./element/types";
 import { ActiveTool, AppState, ToolType, UnsubscribeCallback, Zoom } from "./types";
+import { MaybePromise } from "./utility-types";
 export declare const setDateTimeForTests: (dateTime: string) => void;
 export declare const getDateTime: () => string;
 export declare const capitalizeString: (str: string) => string;
@@ -137,7 +138,7 @@ export declare const findIndex: <T>(array: readonly T[], cb: (element: T, index:
 export declare const findLastIndex: <T>(array: readonly T[], cb: (element: T, index: number, array: readonly T[]) => boolean, fromIndex?: number) => number;
 export declare const isTransparent: (color: string) => boolean;
 export type ResolvablePromise<T> = Promise<T> & {
-    resolve: [T] extends [undefined] ? (value?: T) => void : (value: T) => void;
+    resolve: [T] extends [undefined] ? (value?: MaybePromise<Awaited<T>>) => void : (value: MaybePromise<Awaited<T>>) => void;
     reject: (error: Error) => void;
 };
 export declare const resolvablePromise: <T>() => ResolvablePromise<T>;
@@ -219,4 +220,5 @@ type Unbrand<T> = T extends Map<infer E, infer F> ? Map<E, F> : T extends Set<in
  * compose branded types which are not composite themselves.)
  */
 export declare const toBrandedType: <BrandedType, CurrentType = BrandedType>(value: Unbrand<BrandedType>) => CurrentType & BrandedType;
+export declare const promiseTry: <TValue, TArgs extends unknown[]>(fn: (...args: TArgs) => TValue | PromiseLike<TValue>, ...args: TArgs) => Promise<TValue>;
 export {};

package/types/utils/export.d.ts

@@ -31,11 +31,6 @@ export declare const exportToClipboard: (opts: ExportOpts & {
     quality?: number;
     type: "png" | "svg" | "json";
 }) => Promise<void>;
-export * from "./bbox";
-export { elementsOverlappingBBox, isElementInsideBBox, elementPartiallyOverlapsWithOrContainsBBox, } from "./withinBounds";
-export { serializeAsJSON, serializeLibraryAsJSON, } from "../excalidraw/data/json";
-export { loadFromBlob, loadSceneOrLibraryFromBlob, loadLibraryFromBlob, } from "../excalidraw/data/blob";
-export { getFreeDrawSvgPath } from "../excalidraw/renderer/renderElement";
 export { getCommonBoundingBox } from "../excalidraw/element/bounds";
 export { getMaximumGroups } from "../excalidraw/groups";
 export { intersectElementWithLine } from "../excalidraw/element/collision";
@@ -43,5 +38,4 @@ export { determineFocusDistance } from "../excalidraw/element/collision";
 export { measureText, wrapText, getDefaultLineHeight, } from "../excalidraw/element/textElement";
 export { getFontString } from "../excalidraw/utils";
 export { getBoundTextMaxWidth } from "../excalidraw/element/textElement";
-export { mergeLibraryItems } from "../excalidraw/data/library";
 export { mermaidToExcalidraw } from "../excalidraw/components/TTDDialog/MermaidToExcalidraw";

package/types/utils/index.d.ts

@@ -1 +1,3 @@
 export * from "./export";
+export * from "./withinBounds";
+export * from "./bbox";

package/types/excalidraw/components/LaserTool/LaserPathManager.d.ts

@@ -1,28 +0,0 @@
-import { LaserPointer } from "@excalidraw/laser-pointer";
-import App from "../App";
-declare global {
-    interface Window {
-        LPM: LaserPathManager;
-    }
-}
-export declare class LaserPathManager {
-    private app;
-    private ownState;
-    private collaboratorsState;
-    private rafId;
-    private isDrawing;
-    private container;
-    constructor(app: App);
-    destroy(): void;
-    startPath(x: number, y: number): void;
-    addPointToPath(x: number, y: number): void;
-    endPath(): void;
-    private updatePath;
-    private isRunning;
-    start(svg?: SVGSVGElement): void;
-    stop(): void;
-    loop(): void;
-    draw(path: LaserPointer): string;
-    updateCollabolatorsState(): void;
-    update(): void;
-}

package/types/excalidraw/components/LaserTool/LaserPointerButton.d.ts

@@ -1,10 +0,0 @@
-import "../ToolIcon.scss";
-type LaserPointerIconProps = {
-    title?: string;
-    name?: string;
-    checked: boolean;
-    onChange?(): void;
-    isMobile?: boolean;
-};
-export declare const LaserPointerButton: (props: LaserPointerIconProps) => import("react/jsx-runtime").JSX.Element;
-export {};

package/types/excalidraw/components/LaserTool/LaserTool.d.ts

@@ -1,7 +0,0 @@
-import { LaserPathManager } from "./LaserPathManager";
-import "./LaserToolOverlay.scss";
-type LaserToolOverlayProps = {
-    manager: LaserPathManager;
-};
-export declare const LaserToolOverlay: ({ manager }: LaserToolOverlayProps) => import("react/jsx-runtime").JSX.Element;
-export {};