@zsviczian/excalidraw 0.14.2-obsidian-5 → 0.15.2-obsidian-2

package/types/components/Sidebar/Sidebar.d.ts

@@ -1,11 +1,14 @@
-/// <reference types="react" />
+import React from "react";
 import "./Sidebar.scss";
-/** using a counter instead of boolean to handle race conditions where
- * the host app may render (mount/unmount) multiple different sidebar */
-export declare const hostSidebarCountersAtom: import("jotai").Atom<{
-    rendered: number;
-    docked: number;
-}> & {
+/**
+ * Flags whether the currently rendered Sidebar is docked or not, for use
+ * in upstream components that need to act on this (e.g. LayerUI to shift the
+ * UI). We use an atom because of potential host app sidebars (for the default
+ * sidebar we could just read from appState.defaultSidebarDockedPreference).
+ *
+ * Since we can only render one Sidebar at a time, we can use a simple flag.
+ */
+export declare const isSidebarDockedAtom: import("jotai").Atom<boolean> & {
     write: (get: {
         <Value>(atom: import("jotai").Atom<Value | Promise<Value>>): Value;
         <Value_1>(atom: import("jotai").Atom<Promise<Value_1>>): Value_1;
@@ -23,51 +26,71 @@ export declare const hostSidebarCountersAtom: import("jotai").Atom<{
     }, set: {
         <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: {
-        rendered: number;
-        docked: number;
-    } | ((prev: {
-        rendered: number;
-        docked: number;
-    }) => {
-        rendered: number;
-        docked: number;
-    })) => void;
-    onMount?: (<S extends (update: {
-        rendered: number;
-        docked: number;
-    } | ((prev: {
-        rendered: number;
-        docked: number;
-    }) => {
-        rendered: number;
-        docked: number;
-    })) => void>(setAtom: S) => void | (() => void)) | undefined;
+    }, update: boolean | ((prev: boolean) => boolean)) => void;
+    onMount?: (<S extends (update: boolean | ((prev: boolean) => boolean)) => void>(setAtom: S) => void | (() => void)) | undefined;
 } & {
-    init: {
-        rendered: number;
-        docked: number;
-    };
+    init: boolean;
 };
-export declare const Sidebar: import("react").ForwardRefExoticComponent<{
-    children: import("react").ReactNode;
-    onClose?: (() => boolean | void) | undefined;
+export declare const SidebarInner: React.ForwardRefExoticComponent<Pick<{
+    name: string;
+    children: React.ReactNode;
+    onStateChange?: ((state: {
+        name: string;
+        tab?: string | undefined;
+    } | null) => void) | undefined;
     onDock?: ((docked: boolean) => void) | undefined;
     docked?: boolean | undefined;
-    initialDockedState?: boolean | undefined;
-    dockable?: boolean | undefined;
     className?: string | undefined;
-} & {
-    /** @private internal */
-    __isInternal?: boolean | undefined;
-} & import("react").RefAttributes<HTMLDivElement>> & {
+    __fallback?: boolean | undefined;
+} & Omit<React.RefAttributes<HTMLDivElement>, "onSelect">, "className" | "name" | "children" | "key" | "onDock" | "docked" | "onStateChange" | "__fallback"> & React.RefAttributes<HTMLDivElement>>;
+export declare const Sidebar: React.ForwardRefExoticComponent<{
+    name: string;
+    children: React.ReactNode;
+    onStateChange?: ((state: {
+        name: string;
+        tab?: string | undefined;
+    } | null) => void) | undefined;
+    onDock?: ((docked: boolean) => void) | undefined;
+    docked?: boolean | undefined;
+    className?: string | undefined;
+    __fallback?: boolean | undefined;
+} & React.RefAttributes<HTMLDivElement>> & {
     Header: {
-        (props: {
-            children?: import("react").ReactNode;
+        ({ children, className, }: {
+            children?: React.ReactNode;
             className?: string | undefined;
-        } & {
-            __isFallback?: boolean | undefined;
-        }): JSX.Element | null;
+        }): JSX.Element;
+        displayName: string;
+    };
+    TabTriggers: {
+        ({ children, ...rest }: {
+            children: React.ReactNode;
+        } & Omit<React.RefAttributes<HTMLDivElement>, "onSelect">): JSX.Element;
+        displayName: string;
+    };
+    TabTrigger: {
+        ({ children, tab, onSelect, ...rest }: {
+            children: React.ReactNode;
+            tab: string;
+            onSelect?: React.ReactEventHandler<HTMLButtonElement> | undefined;
+        } & Omit<React.HTMLAttributes<HTMLButtonElement>, "onSelect">): JSX.Element;
+        displayName: string;
+    };
+    Tabs: {
+        ({ children, ...rest }: {
+            children: React.ReactNode;
+        } & Omit<React.RefAttributes<HTMLDivElement>, "onSelect">): JSX.Element | null;
+        displayName: string;
+    };
+    Tab: {
+        ({ tab, children, ...rest }: {
+            tab: string;
+            children: React.ReactNode;
+        } & React.HTMLAttributes<HTMLDivElement>): JSX.Element;
+        displayName: string;
+    };
+    Trigger: {
+        ({ name, tab, icon, title, children, onToggle, className, style, }: import("./common").SidebarTriggerProps): JSX.Element;
         displayName: string;
     };
 };

package/types/components/Sidebar/SidebarHeader.d.ts

@@ -1,20 +1,7 @@
-/// <reference types="react" />
-export declare const SidebarDockButton: (props: {
-    checked: boolean;
-    onChange?(): void;
-}) => JSX.Element;
-/** @private */
-export declare const SidebarHeaderComponents: {
-    Context: import("react").FC<{
-        children: import("react").ReactNode;
-    }>;
-    Component: {
-        (props: {
-            children?: React.ReactNode;
-            className?: string | undefined;
-        } & {
-            __isFallback?: boolean | undefined;
-        }): JSX.Element | null;
-        displayName: string;
-    };
+export declare const SidebarHeader: {
+    ({ children, className, }: {
+        children?: React.ReactNode;
+        className?: string | undefined;
+    }): JSX.Element;
+    displayName: string;
 };

package/types/components/Sidebar/SidebarTab.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { SidebarTabName } from "../../types";
+export declare const SidebarTab: {
+    ({ tab, children, ...rest }: {
+        tab: SidebarTabName;
+        children: React.ReactNode;
+    } & import("react").HTMLAttributes<HTMLDivElement>): JSX.Element;
+    displayName: string;
+};

package/types/components/Sidebar/SidebarTabTrigger.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { SidebarTabName } from "../../types";
+export declare const SidebarTabTrigger: {
+    ({ children, tab, onSelect, ...rest }: {
+        children: React.ReactNode;
+        tab: SidebarTabName;
+        onSelect?: React.ReactEventHandler<HTMLButtonElement> | undefined;
+    } & Omit<import("react").HTMLAttributes<HTMLButtonElement>, "onSelect">): JSX.Element;
+    displayName: string;
+};

package/types/components/Sidebar/SidebarTabTriggers.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+export declare const SidebarTabTriggers: {
+    ({ children, ...rest }: {
+        children: React.ReactNode;
+    } & Omit<import("react").RefAttributes<HTMLDivElement>, "onSelect">): JSX.Element;
+    displayName: string;
+};

package/types/components/Sidebar/SidebarTabs.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+export declare const SidebarTabs: {
+    ({ children, ...rest }: {
+        children: React.ReactNode;
+    } & Omit<import("react").RefAttributes<HTMLDivElement>, "onSelect">): JSX.Element | null;
+    displayName: string;
+};

package/types/components/Sidebar/SidebarTrigger.d.ts

@@ -0,0 +1,6 @@
+import { SidebarTriggerProps } from "./common";
+import "./SidebarTrigger.scss";
+export declare const SidebarTrigger: {
+    ({ name, tab, icon, title, children, onToggle, className, style, }: SidebarTriggerProps): JSX.Element;
+    displayName: string;
+};

package/types/components/Sidebar/common.d.ts

@@ -1,16 +1,33 @@
 import React from "react";
+import { AppState, SidebarName, SidebarTabName } from "../../types";
+export declare type SidebarTriggerProps = {
+    name: SidebarName;
+    tab?: SidebarTabName;
+    icon?: JSX.Element;
+    children?: React.ReactNode;
+    title?: string;
+    className?: string;
+    onToggle?: (open: boolean) => void;
+    style?: React.CSSProperties;
+};
 export declare type SidebarProps<P = {}> = {
+    name: SidebarName;
     children: React.ReactNode;
     /**
-     * Called on sidebar close (either by user action or by the editor).
+     * Called on sidebar open/close or tab change.
+     */
+    onStateChange?: (state: AppState["openSidebar"]) => void;
+    /**
+     * supply alongside `docked` prop in order to make the Sidebar user-dockable
      */
-    onClose?: () => void | boolean;
-    /** if not supplied, sidebar won't be dockable */
     onDock?: (docked: boolean) => void;
     docked?: boolean;
-    initialDockedState?: boolean;
-    dockable?: boolean;
     className?: string;
+    /** @private internal */
+    __fallback?: boolean;
 } & P;
-export declare type SidebarPropsContextValue = Pick<SidebarProps, "onClose" | "onDock" | "docked" | "dockable">;
+export declare type SidebarPropsContextValue = Pick<SidebarProps, "onDock" | "docked"> & {
+    onCloseRequest: () => void;
+    shouldRenderDockButton: boolean;
+};
 export declare const SidebarPropsContext: React.Context<SidebarPropsContextValue>;

package/types/components/Stats.d.ts

@@ -1,10 +1,10 @@
 import React from "react";
 import { NonDeletedExcalidrawElement } from "../element/types";
-import { AppState, ExcalidrawProps } from "../types";
+import { ExcalidrawProps, UIAppState } from "../types";
 import "./Stats.scss";
 export declare const Stats: (props: {
-    appState: AppState;
-    setAppState: React.Component<any, AppState>["setState"];
+    appState: UIAppState;
+    setAppState: React.Component<any, UIAppState>["setState"];
     elements: readonly NonDeletedExcalidrawElement[];
     onClose: () => void;
     renderCustomStats: ExcalidrawProps["renderCustomStats"];

package/types/components/Trans.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+declare const Trans: ({ i18nKey, children, ...props }: {
+    [key: string]: React.ReactNode | ((el: React.ReactNode) => React.ReactNode);
+    i18nKey: string;
+}) => React.FunctionComponentElement<{
+    children?: React.ReactNode;
+}>;
+export default Trans;

package/types/components/footer/Footer.d.ts

@@ -1,8 +1,8 @@
 import { ActionManager } from "../../actions/manager";
-import { AppState } from "../../types";
+import { UIAppState } from "../../types";
 declare const Footer: {
     ({ appState, actionManager, showExitZenModeBtn, renderWelcomeScreen, }: {
-        appState: AppState;
+        appState: UIAppState;
         actionManager: ActionManager;
         showExitZenModeBtn: boolean;
         renderWelcomeScreen: boolean;

package/types/constants.d.ts

@@ -1,5 +1,5 @@
 import { AppProps } from "./types";
-import { FontFamilyValues } from "./element/types";
+import { ExcalidrawElement, FontFamilyValues } from "./element/types";
 export declare const isDarwin: boolean;
 export declare const isWindows: boolean;
 export declare const isAndroid: boolean;
@@ -85,19 +85,32 @@ export declare const DEFAULT_VERTICAL_ALIGN = "top";
 export declare const DEFAULT_VERSION = "{version}";
 export declare const CANVAS_ONLY_ACTIONS: string[];
 export declare const GRID_SIZE = 20;
+export declare const IMAGE_MIME_TYPES: {
+    readonly svg: "image/svg+xml";
+    readonly png: "image/png";
+    readonly jpg: "image/jpeg";
+    readonly gif: "image/gif";
+    readonly webp: "image/webp";
+    readonly bmp: "image/bmp";
+    readonly ico: "image/x-icon";
+    readonly avif: "image/avif";
+    readonly jfif: "image/jfif";
+};
 export declare const MIME_TYPES: {
-    readonly excalidraw: "application/vnd.excalidraw+json";
-    readonly excalidrawlib: "application/vnd.excalidrawlib+json";
-    readonly json: "application/json";
     readonly svg: "image/svg+xml";
-    readonly "excalidraw.svg": "image/svg+xml";
     readonly png: "image/png";
-    readonly "excalidraw.png": "image/png";
     readonly jpg: "image/jpeg";
     readonly gif: "image/gif";
     readonly webp: "image/webp";
     readonly bmp: "image/bmp";
     readonly ico: "image/x-icon";
+    readonly avif: "image/avif";
+    readonly jfif: "image/jfif";
+    readonly json: "application/json";
+    readonly excalidraw: "application/vnd.excalidraw+json";
+    readonly excalidrawlib: "application/vnd.excalidrawlib+json";
+    readonly "excalidraw.svg": "image/svg+xml";
+    readonly "excalidraw.png": "image/png";
     readonly binary: "application/octet-stream";
 };
 export declare const EXPORT_DATA_TYPES: {
@@ -135,7 +148,6 @@ export declare const MAX_DECIMALS_FOR_SVG_EXPORT = 2;
 export declare const EXPORT_SCALES: number[];
 export declare const DEFAULT_EXPORT_PADDING = 10;
 export declare const DEFAULT_MAX_IMAGE_WIDTH_OR_HEIGHT = 1440;
-export declare const ALLOWED_IMAGE_MIME_TYPES: readonly ["image/png", "image/jpeg", "image/svg+xml", "image/gif", "image/webp", "image/bmp", "image/x-icon"];
 export declare const MAX_ALLOWED_FILE_BYTES: number;
 export declare const SVG_NS = "http://www.w3.org/2000/svg";
 export declare const ENCRYPTION_KEY_BITS = 128;
@@ -168,3 +180,18 @@ export declare const PRECEDING_ELEMENT_KEY = "__precedingElement__";
 export declare const COLOR_NAMES: {
     [key: string]: string;
 };
+export declare const DEFAULT_ELEMENT_PROPS: {
+    strokeColor: ExcalidrawElement["strokeColor"];
+    backgroundColor: ExcalidrawElement["backgroundColor"];
+    fillStyle: ExcalidrawElement["fillStyle"];
+    strokeWidth: ExcalidrawElement["strokeWidth"];
+    strokeStyle: ExcalidrawElement["strokeStyle"];
+    roughness: ExcalidrawElement["roughness"];
+    opacity: ExcalidrawElement["opacity"];
+    locked: ExcalidrawElement["locked"];
+};
+export declare const LIBRARY_SIDEBAR_TAB = "library";
+export declare const DEFAULT_SIDEBAR: {
+    readonly name: "default";
+    readonly defaultTab: "library";
+};

package/types/context/tunnels.d.ts

@@ -0,0 +1,18 @@
+import React from "react";
+import tunnel from "tunnel-rat";
+export declare type Tunnel = ReturnType<typeof tunnel>;
+declare type TunnelsContextValue = {
+    MainMenuTunnel: Tunnel;
+    WelcomeScreenMenuHintTunnel: Tunnel;
+    WelcomeScreenToolbarHintTunnel: Tunnel;
+    WelcomeScreenHelpHintTunnel: Tunnel;
+    WelcomeScreenCenterTunnel: Tunnel;
+    FooterCenterTunnel: Tunnel;
+    DefaultSidebarTriggerTunnel: Tunnel;
+    DefaultSidebarTabTriggersTunnel: Tunnel;
+    jotaiScope: symbol;
+};
+export declare const TunnelsContext: React.Context<TunnelsContextValue>;
+export declare const useTunnels: () => TunnelsContextValue;
+export declare const useInitializeTunnels: () => TunnelsContextValue;
+export {};

package/types/context/ui-appState.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import { UIAppState } from "../types";
+export declare const UIAppStateContext: React.Context<UIAppState>;
+export declare const useUIAppState: () => UIAppState;

package/types/data/blob.d.ts

@@ -1,4 +1,4 @@
-import { ALLOWED_IMAGE_MIME_TYPES, MIME_TYPES } from "../constants";
+import { IMAGE_MIME_TYPES, MIME_TYPES } from "../constants";
 import { ExcalidrawElement, FileId } from "../element/types";
 import { AppState, DataURL, LibraryItem } from "../types";
 import { ValueOf } from "../utility-types";
@@ -9,7 +9,7 @@ export declare const getFileHandleType: (handle: FileSystemHandle | null) => str
 export declare const isImageFileHandleType: (type: string | null) => type is "svg" | "png";
 export declare const isImageFileHandle: (handle: FileSystemHandle | null) => boolean;
 export declare const isSupportedImageFile: (blob: Blob | null | undefined) => blob is Blob & {
-    type: (typeof ALLOWED_IMAGE_MIME_TYPES)[number];
+    type: ValueOf<typeof IMAGE_MIME_TYPES>;
 };
 export declare const loadSceneOrLibraryFromBlob: (blob: Blob | File, localAppState: AppState | null, localElements: readonly ExcalidrawElement[] | null, fileHandle?: FileSystemHandle | null) => Promise<{
     type: "application/vnd.excalidraw+json";

package/types/data/filesystem.d.ts

@@ -1,5 +1,6 @@
 import { FileSystemHandle, supported as nativeFileSystemSupported } from "browser-fs-access";
-declare type FILE_EXTENSION = "gif" | "jpg" | "png" | "excalidraw.png" | "svg" | "excalidraw.svg" | "json" | "excalidraw" | "excalidrawlib";
+import { MIME_TYPES } from "../constants";
+declare type FILE_EXTENSION = Exclude<keyof typeof MIME_TYPES, "binary">;
 export declare const fileOpen: <M extends boolean | undefined = false>(opts: {
     extensions?: FILE_EXTENSION[] | undefined;
     description: string;

package/types/data/types.d.ts

@@ -18,10 +18,8 @@ export interface ExportedDataState {
  * Don't consume on its own.
  */
 export declare type LegacyAppState = {
-    /** @deprecated #5663 TODO remove 22-12-15 */
-    isLibraryOpen: [boolean, "openSidebar"];
-    /** @deprecated #5663 TODO remove 22-12-15 */
-    isLibraryMenuDocked: [boolean, "isSidebarDocked"];
+    /** @deprecated #6213 TODO remove 23-06-01 */
+    isSidebarDocked: [boolean, "defaultSidebarDockedPreference"];
 };
 export interface ImportedDataState {
     type?: string;

package/types/element/Hyperlink.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="react" />
-import { AppState, ExcalidrawProps } from "../types";
+import { AppState, ExcalidrawProps, UIAppState } from "../types";
 import { NonDeletedExcalidrawElement } from "./types";
 import { Bounds } from "./bounds";
 import "./Hyperlink.scss";
@@ -76,9 +76,12 @@ export declare const actionLink: {
                 value: import("../types").NormalizedZoomValue;
             }>;
             openPopup: "canvasColorPicker" | "backgroundColorPicker" | "strokeColorPicker" | null;
-            openSidebar: "library" | "customSidebar" | null;
+            openSidebar: {
+                name: string;
+                tab?: string | undefined;
+            } | null;
             openDialog: "imageExport" | "help" | "jsonExport" | null;
-            isSidebarDocked: boolean;
+            defaultSidebarDockedPreference: boolean;
             lastPointerDownWith: import("./types").PointerType;
             selectedElementIds: {
                 [id: string]: boolean;
@@ -132,6 +135,7 @@ export declare const actionLink: {
             resetCustomPen?: any;
             gridColor: string;
             dynamicStyle: string;
+            invertBindingBehaviour: boolean;
             selectedLinearElement: import("./linearElementEditor").LinearElementEditor | null;
         };
         commitToHistory: true;
@@ -148,7 +152,7 @@ export declare const actionLink: {
     keyTest?: ((event: KeyboardEvent | import("react").KeyboardEvent<Element>) => boolean) | undefined;
 };
 export declare const getContextMenuLabel: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState) => "labels.link.edit" | "labels.link.create";
-export declare const getLinkHandleFromCoords: ([x1, y1, x2, y2]: Bounds, angle: number, appState: AppState) => [x: number, y: number, width: number, height: number];
+export declare const getLinkHandleFromCoords: ([x1, y1, x2, y2]: Bounds, angle: number, appState: UIAppState) => [x: number, y: number, width: number, height: number];
 export declare const isPointHittingLinkIcon: (element: NonDeletedExcalidrawElement, appState: AppState, [x, y]: readonly [number, number], isMobile: boolean) => boolean;
 export declare const showHyperlinkTooltip: (element: NonDeletedExcalidrawElement, appState: AppState) => void;
 export declare const hideHyperlinkToolip: () => void;

package/types/element/image.d.ts

@@ -10,7 +10,17 @@ export declare const updateImageCache: ({ fileIds, files, imageCache, }: {
 }) => Promise<{
     imageCache: Map<FileId, {
         image: HTMLImageElement | Promise<HTMLImageElement>;
-        mimeType: "image/svg+xml" | "image/png" | "image/jpeg" | "image/gif" | "image/webp" | "image/bmp" | "image/x-icon";
+        mimeType: import("../utility-types").ValueOf<{
+            readonly svg: "image/svg+xml";
+            readonly png: "image/png";
+            readonly jpg: "image/jpeg";
+            readonly gif: "image/gif";
+            readonly webp: "image/webp";
+            readonly bmp: "image/bmp";
+            readonly ico: "image/x-icon";
+            readonly avif: "image/avif";
+            readonly jfif: "image/jfif";
+        }>;
     }>;
     /** includes errored files because they cache was updated nonetheless */
     updatedFiles: Map<FileId, true>;

package/types/element/linearElementEditor.d.ts

@@ -138,10 +138,7 @@ export declare class LinearElementEditor {
             isBindingEnabled: boolean;
             startBoundElement: NonDeleted<ExcalidrawBindableElement> | null;
             suggestedBindings: import("./binding").SuggestedBinding[];
-            editingElement: import("./types").NonDeletedExcalidrawElement | null; /**
-             * @param id the `elementId` from the instance of this class (so that we can
-             *  statically guarantee this method returns an ExcalidrawLinearElement)
-             */
+            editingElement: import("./types").NonDeletedExcalidrawElement | null;
             activeTool: {
                 lastActiveTool: import("../types").LastActiveTool;
                 locked: boolean;
@@ -184,9 +181,12 @@ export declare class LinearElementEditor {
             }>;
             openMenu: "canvas" | "shape" | null;
             openPopup: "canvasColorPicker" | "backgroundColorPicker" | "strokeColorPicker" | null;
-            openSidebar: "library" | "customSidebar" | null;
+            openSidebar: {
+                name: string;
+                tab?: string | undefined;
+            } | null;
             openDialog: "imageExport" | "help" | "jsonExport" | null;
-            isSidebarDocked: boolean;
+            defaultSidebarDockedPreference: boolean;
             lastPointerDownWith: import("./types").PointerType;
             selectedElementIds: {
                 [id: string]: boolean;
@@ -241,6 +241,7 @@ export declare class LinearElementEditor {
             resetCustomPen?: any;
             gridColor: string;
             dynamicStyle: string;
+            invertBindingBehaviour: boolean;
             selectedLinearElement: LinearElementEditor | null;
         };
     };

package/types/element/newElement.d.ts

@@ -1,19 +1,20 @@
 import { ExcalidrawElement, ExcalidrawImageElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawGenericElement, NonDeleted, TextAlign, GroupId, VerticalAlign, Arrowhead, ExcalidrawFreeDrawElement, FontFamilyValues, ExcalidrawTextContainer } from "../element/types";
 import { AppState } from "../types";
 import { MarkOptional, Mutable } from "../utility-types";
-declare type ElementConstructorOpts = MarkOptional<Omit<ExcalidrawGenericElement, "id" | "type" | "isDeleted" | "updated">, "width" | "height" | "angle" | "groupIds" | "boundElements" | "seed" | "version" | "versionNonce" | "link">;
+declare type ElementConstructorOpts = MarkOptional<Omit<ExcalidrawGenericElement, "id" | "type" | "isDeleted" | "updated">, "width" | "height" | "angle" | "groupIds" | "boundElements" | "seed" | "version" | "versionNonce" | "link" | "strokeStyle" | "fillStyle" | "strokeColor" | "backgroundColor" | "roughness" | "strokeWidth" | "roundness" | "locked" | "opacity">;
 export declare const newElement: (opts: {
     type: ExcalidrawGenericElement["type"];
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawGenericElement>;
 export declare const newTextElement: (opts: {
     text: string;
     rawText: string;
-    fontSize: number;
-    fontFamily: FontFamilyValues;
-    textAlign: TextAlign;
-    verticalAlign: VerticalAlign;
+    fontSize?: number;
+    fontFamily?: FontFamilyValues;
+    textAlign?: TextAlign;
+    verticalAlign?: VerticalAlign;
     containerId?: ExcalidrawTextContainer["id"];
     lineHeight?: ExcalidrawTextElement["lineHeight"];
+    strokeWidth?: ExcalidrawTextElement["strokeWidth"];
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawTextElement>;
 export declare const refreshTextDimensions: (textElement: ExcalidrawTextElement, text?: string) => {
     x: number;
@@ -47,7 +48,16 @@ export declare const newImageElement: (opts: {
     fileId?: ExcalidrawImageElement["fileId"];
     scale?: ExcalidrawImageElement["scale"];
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawImageElement>;
-export declare const deepCopyElement: (val: any, depth?: number) => any;
+/**
+ * Clones ExcalidrawElement data structure. Does not regenerate id, nonce, or
+ * any value. The purpose is to to break object references for immutability
+ * reasons, whenever we want to keep the original element, but ensure it's not
+ * mutated.
+ *
+ * Only clones plain objects and arrays. Doesn't clone Date, RegExp, Map, Set,
+ * Typed arrays and other non-null objects.
+ */
+export declare const deepCopyElement: <T extends ExcalidrawElement>(val: T) => Mutable<T>;
 /**
  * Duplicate an element, often used in the alt-drag operation.
  * Note that this method has gotten a bit complicated since the
@@ -62,5 +72,19 @@ export declare const deepCopyElement: (val: any, depth?: number) => any;
  * @param element Element to duplicate
  * @param overrides Any element properties to override
  */
-export declare const duplicateElement: <TElement extends Mutable<ExcalidrawElement>>(editingGroupId: AppState["editingGroupId"], groupIdMapForOperation: Map<GroupId, GroupId>, element: TElement, overrides?: Partial<TElement> | undefined) => TElement;
+export declare const duplicateElement: <TElement extends ExcalidrawElement>(editingGroupId: AppState["editingGroupId"], groupIdMapForOperation: Map<GroupId, GroupId>, element: TElement, overrides?: Partial<TElement> | undefined) => Readonly<TElement>;
+/**
+ * Clones elements, regenerating their ids (including bindings) and group ids.
+ *
+ * If bindings don't exist in the elements array, they are removed. Therefore,
+ * it's advised to supply the whole elements array, or sets of elements that
+ * are encapsulated (such as library items), if the purpose is to retain
+ * bindings to the cloned elements intact.
+ *
+ * NOTE by default does not randomize or regenerate anything except the id.
+ */
+export declare const duplicateElements: (elements: readonly ExcalidrawElement[], opts?: {
+    /** NOTE also updates version flags and `updated` */
+    randomizeSeed: boolean;
+}) => ExcalidrawElement[];
 export {};

package/types/element/showSelectedShapeActions.d.ts

@@ -1,3 +1,3 @@
-import { AppState } from "../types";
 import { NonDeletedExcalidrawElement } from "./types";
-export declare const showSelectedShapeActions: (appState: AppState, elements: readonly NonDeletedExcalidrawElement[]) => boolean;
+import { UIAppState } from "../types";
+export declare const showSelectedShapeActions: (appState: UIAppState, elements: readonly NonDeletedExcalidrawElement[]) => boolean;

package/types/element/textElement.d.ts

@@ -32,6 +32,7 @@ export declare const getLineHeightInPx: (fontSize: ExcalidrawTextElement["fontSi
 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;
+export declare const parseTokens: (text: string) => string[];
 export declare const wrapText: (text: string, font: FontString, maxWidth: number) => string;
 export declare const charWidth: {
     calculate: (char: string, font: FontString) => number;
@@ -70,8 +71,8 @@ export declare const getTextBindableContainerAtPosition: (elements: readonly Exc
 declare const VALID_CONTAINER_TYPES: Set<string>;
 export declare const isValidTextContainer: (element: ExcalidrawElement) => boolean;
 export declare const computeContainerDimensionForBoundText: (dimension: number, containerType: ExtractSetType<typeof VALID_CONTAINER_TYPES>, legacy?: boolean) => number;
-export declare const getMaxContainerWidth: (container: ExcalidrawElement) => number;
-export declare const getMaxContainerHeight: (container: ExcalidrawElement) => number;
+export declare const getBoundTextMaxWidth: (container: ExcalidrawElement) => number;
+export declare const getBoundTextMaxHeight: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElementWithContainer) => number;
 export declare const isMeasureTextSupported: () => boolean;
 export declare const getDefaultLineHeight: (fontFamily: FontFamilyValues) => number & {
     _brand: "unitlessLineHeight";

package/types/hooks/useOutsideClick.d.ts

@@ -1,2 +1,2 @@
 /// <reference types="react" />
-export declare const useOutsideClickHook: (handler: (event: Event) => void) => import("react").MutableRefObject<null>;
+export declare const useOutsideClick: (handler: (event: Event) => void) => import("react").MutableRefObject<null>;

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

@@ -19,7 +19,7 @@ measureText, //zsviczian
 getDefaultLineHeight, //zsviczian
 wrapText, //zsviczian
 getFontString, //zsviczian
-getMaxContainerWidth, //zsviczian
+getBoundTextMaxWidth, //zsviczian
 exportToClipboard, mergeLibraryItems, } from "../../packages/utils";
 export { isLinearElement } from "../../element/typeChecks";
 export { FONT_FAMILY, THEME, MIME_TYPES } from "../../constants";
@@ -33,3 +33,4 @@ export { MainMenu };
 export { useDevice } from "../../components/App";
 export { WelcomeScreen };
 export { LiveCollaborationTrigger };
+export { DefaultSidebar } from "../../components/DefaultSidebar";

package/types/packages/utils.d.ts

@@ -38,5 +38,5 @@ export { intersectElementWithLine } from "../element/collision";
 export { determineFocusDistance } from "../element/collision";
 export { measureText, wrapText, getDefaultLineHeight } from "../element/textElement";
 export { getFontString } from "../utils";
-export { getMaxContainerWidth } from "../element/textElement";
+export { getBoundTextMaxWidth } from "../element/textElement";
 export { mergeLibraryItems } from "../data/library";