@zsviczian/excalidraw 0.17.6-1 → 0.17.6-11

package/types/excalidraw/groups.d.ts

@@ -1,33 +1,33 @@
-import type { GroupId, ExcalidrawElement, NonDeleted, NonDeletedExcalidrawElement, ElementsMapOrArray, ElementsMap } from "./element/types";
-import type { AppClassProperties, AppState, InteractiveCanvasAppState } from "./types";
-import type { Mutable } from "./utility-types";
-export declare const selectGroup: (groupId: GroupId, appState: InteractiveCanvasAppState, elements: readonly NonDeleted<ExcalidrawElement>[]) => Pick<InteractiveCanvasAppState, "selectedGroupIds" | "selectedElementIds" | "editingGroupId">;
-export declare const selectGroupsForSelectedElements: {
-    (appState: Pick<AppState, "selectedElementIds" | "editingGroupId">, elements: readonly NonDeletedExcalidrawElement[], prevAppState: InteractiveCanvasAppState, app: AppClassProperties | null): Mutable<Pick<InteractiveCanvasAppState, "selectedGroupIds" | "editingGroupId" | "selectedElementIds">>;
-    clearCache(): void;
-};
-/**
- * If the element's group is selected, don't render an individual
- * selection border around it.
- */
-export declare const isSelectedViaGroup: (appState: InteractiveCanvasAppState, element: ExcalidrawElement) => boolean;
-export declare const getSelectedGroupForElement: (appState: InteractiveCanvasAppState, element: ExcalidrawElement) => string | undefined;
-export declare const getSelectedGroupIds: (appState: InteractiveCanvasAppState) => GroupId[];
-export declare const selectGroupsFromGivenElements: (elements: readonly NonDeleted<ExcalidrawElement>[], appState: InteractiveCanvasAppState) => {
-    [groupId: string]: boolean;
-};
-export declare const editGroupForSelectedElement: (appState: AppState, element: NonDeleted<ExcalidrawElement>) => AppState;
-export declare const isElementInGroup: (element: ExcalidrawElement, groupId: string) => boolean;
-export declare const getElementsInGroup: (elements: ElementsMapOrArray, groupId: string) => ExcalidrawElement[];
-export declare const getSelectedGroupIdForElement: (element: ExcalidrawElement, selectedGroupIds: {
-    [groupId: string]: boolean;
-}) => string | undefined;
-export declare const getNewGroupIdsForDuplication: (groupIds: ExcalidrawElement["groupIds"], editingGroupId: AppState["editingGroupId"], mapper: (groupId: GroupId) => GroupId) => string[];
-export declare const addToGroup: (prevGroupIds: ExcalidrawElement["groupIds"], newGroupId: GroupId, editingGroupId: AppState["editingGroupId"]) => string[];
-export declare const removeFromSelectedGroups: (groupIds: ExcalidrawElement["groupIds"], selectedGroupIds: {
-    [groupId: string]: boolean;
-}) => string[];
-export declare const getMaximumGroups: (elements: ExcalidrawElement[], elementsMap: ElementsMap) => ExcalidrawElement[][];
-export declare const getNonDeletedGroupIds: (elements: ElementsMap) => Set<string>;
-export declare const elementsAreInSameGroup: (elements: readonly ExcalidrawElement[]) => boolean;
-export declare const isInGroup: (element: NonDeletedExcalidrawElement) => boolean;
+import type { GroupId, ExcalidrawElement, NonDeleted, NonDeletedExcalidrawElement, ElementsMapOrArray, ElementsMap } from "./element/types";
+import type { AppClassProperties, AppState, InteractiveCanvasAppState } from "./types";
+import type { Mutable } from "./utility-types";
+export declare const selectGroup: (groupId: GroupId, appState: InteractiveCanvasAppState, elements: readonly NonDeleted<ExcalidrawElement>[]) => Pick<InteractiveCanvasAppState, "selectedGroupIds" | "selectedElementIds" | "editingGroupId">;
+export declare const selectGroupsForSelectedElements: {
+    (appState: Pick<AppState, "selectedElementIds" | "editingGroupId">, elements: readonly NonDeletedExcalidrawElement[], prevAppState: InteractiveCanvasAppState, app: AppClassProperties | null): Mutable<Pick<InteractiveCanvasAppState, "selectedGroupIds" | "editingGroupId" | "selectedElementIds">>;
+    clearCache(): void;
+};
+/**
+ * If the element's group is selected, don't render an individual
+ * selection border around it.
+ */
+export declare const isSelectedViaGroup: (appState: InteractiveCanvasAppState, element: ExcalidrawElement) => boolean;
+export declare const getSelectedGroupForElement: (appState: InteractiveCanvasAppState, element: ExcalidrawElement) => string | undefined;
+export declare const getSelectedGroupIds: (appState: InteractiveCanvasAppState) => GroupId[];
+export declare const selectGroupsFromGivenElements: (elements: readonly NonDeleted<ExcalidrawElement>[], appState: InteractiveCanvasAppState) => {
+    [groupId: string]: boolean;
+};
+export declare const editGroupForSelectedElement: (appState: AppState, element: NonDeleted<ExcalidrawElement>) => AppState;
+export declare const isElementInGroup: (element: ExcalidrawElement, groupId: string) => boolean;
+export declare const getElementsInGroup: (elements: ElementsMapOrArray, groupId: string) => ExcalidrawElement[];
+export declare const getSelectedGroupIdForElement: (element: ExcalidrawElement, selectedGroupIds: {
+    [groupId: string]: boolean;
+}) => string | undefined;
+export declare const getNewGroupIdsForDuplication: (groupIds: ExcalidrawElement["groupIds"], editingGroupId: AppState["editingGroupId"], mapper: (groupId: GroupId) => GroupId) => string[];
+export declare const addToGroup: (prevGroupIds: ExcalidrawElement["groupIds"], newGroupId: GroupId, editingGroupId: AppState["editingGroupId"]) => string[];
+export declare const removeFromSelectedGroups: (groupIds: ExcalidrawElement["groupIds"], selectedGroupIds: {
+    [groupId: string]: boolean;
+}) => string[];
+export declare const getMaximumGroups: (elements: ExcalidrawElement[], elementsMap: ElementsMap) => ExcalidrawElement[][];
+export declare const getNonDeletedGroupIds: (elements: ElementsMap) => Set<string>;
+export declare const elementsAreInSameGroup: (elements: readonly ExcalidrawElement[]) => boolean;
+export declare const isInGroup: (element: NonDeletedExcalidrawElement) => boolean;

package/types/excalidraw/history.d.ts

@@ -1,40 +1,40 @@
-import type { AppStateChange, ElementsChange } from "./change";
-import type { SceneElementsMap } from "./element/types";
-import { Emitter } from "./emitter";
-import type { Snapshot } from "./store";
-import type { AppState } from "./types";
-export declare class HistoryChangedEvent {
-    readonly isUndoStackEmpty: boolean;
-    readonly isRedoStackEmpty: boolean;
-    constructor(isUndoStackEmpty?: boolean, isRedoStackEmpty?: boolean);
-}
-export declare class History {
-    readonly onHistoryChangedEmitter: Emitter<[HistoryChangedEvent]>;
-    private readonly undoStack;
-    private readonly redoStack;
-    get isUndoStackEmpty(): boolean;
-    get isRedoStackEmpty(): boolean;
-    clear(): void;
-    /**
-     * Record a local change which will go into the history
-     */
-    record(elementsChange: ElementsChange, appStateChange: AppStateChange): void;
-    undo(elements: SceneElementsMap, appState: AppState, snapshot: Readonly<Snapshot>): void | [SceneElementsMap, AppState];
-    redo(elements: SceneElementsMap, appState: AppState, snapshot: Readonly<Snapshot>): void | [SceneElementsMap, AppState];
-    private perform;
-    private static pop;
-    private static push;
-}
-export declare class HistoryEntry {
-    readonly appStateChange: AppStateChange;
-    readonly elementsChange: ElementsChange;
-    private constructor();
-    static create(appStateChange: AppStateChange, elementsChange: ElementsChange): HistoryEntry;
-    inverse(): HistoryEntry;
-    applyTo(elements: SceneElementsMap, appState: AppState, snapshot: Readonly<Snapshot>): [SceneElementsMap, AppState, boolean];
-    /**
-     * Apply latest (remote) changes to the history entry, creates new instance of `HistoryEntry`.
-     */
-    applyLatestChanges(elements: SceneElementsMap): HistoryEntry;
-    isEmpty(): boolean;
-}
+import type { AppStateChange, ElementsChange } from "./change";
+import type { SceneElementsMap } from "./element/types";
+import { Emitter } from "./emitter";
+import type { Snapshot } from "./store";
+import type { AppState } from "./types";
+export declare class HistoryChangedEvent {
+    readonly isUndoStackEmpty: boolean;
+    readonly isRedoStackEmpty: boolean;
+    constructor(isUndoStackEmpty?: boolean, isRedoStackEmpty?: boolean);
+}
+export declare class History {
+    readonly onHistoryChangedEmitter: Emitter<[HistoryChangedEvent]>;
+    private readonly undoStack;
+    private readonly redoStack;
+    get isUndoStackEmpty(): boolean;
+    get isRedoStackEmpty(): boolean;
+    clear(): void;
+    /**
+     * Record a local change which will go into the history
+     */
+    record(elementsChange: ElementsChange, appStateChange: AppStateChange): void;
+    undo(elements: SceneElementsMap, appState: AppState, snapshot: Readonly<Snapshot>): void | [SceneElementsMap, AppState];
+    redo(elements: SceneElementsMap, appState: AppState, snapshot: Readonly<Snapshot>): void | [SceneElementsMap, AppState];
+    private perform;
+    private static pop;
+    private static push;
+}
+export declare class HistoryEntry {
+    readonly appStateChange: AppStateChange;
+    readonly elementsChange: ElementsChange;
+    private constructor();
+    static create(appStateChange: AppStateChange, elementsChange: ElementsChange): HistoryEntry;
+    inverse(): HistoryEntry;
+    applyTo(elements: SceneElementsMap, appState: AppState, snapshot: Readonly<Snapshot>): [SceneElementsMap, AppState, boolean];
+    /**
+     * Apply latest (remote) changes to the history entry, creates new instance of `HistoryEntry`.
+     */
+    applyLatestChanges(elements: SceneElementsMap): HistoryEntry;
+    isEmpty(): boolean;
+}

package/types/excalidraw/hooks/useCallbackRefState.d.ts

@@ -1 +1 @@
-export declare const useCallbackRefState: <T>() => readonly [T | null, (value: T | null) => void];
+export declare const useCallbackRefState: <T>() => readonly [T | null, (value: T | null) => void];

package/types/excalidraw/hooks/useCopiedIndicator.d.ts

@@ -1,5 +1,5 @@
-export declare const useCopyStatus: () => {
-    copyStatus: "success" | null;
-    resetCopyStatus: () => void;
-    onCopy: () => void;
-};
+export declare const useCopyStatus: () => {
+    copyStatus: "success" | null;
+    resetCopyStatus: () => void;
+    onCopy: () => void;
+};

package/types/excalidraw/hooks/useCreatePortalContainer.d.ts

@@ -1,7 +1,7 @@
-export declare const useCreatePortalContainer: (opts?: {
-    className?: string | undefined;
-    parentSelector?: string | undefined;
-    style?: {
-        [x: string]: string;
-    } | undefined;
-} | undefined) => HTMLDivElement | null;
+export declare const useCreatePortalContainer: (opts?: {
+    className?: string | undefined;
+    parentSelector?: string | undefined;
+    style?: {
+        [x: string]: string;
+    } | undefined;
+} | undefined) => HTMLDivElement | null;

package/types/excalidraw/hooks/useEmitter.d.ts

@@ -1,2 +1,2 @@
-import type { Emitter } from "../emitter";
-export declare const useEmitter: <TEvent extends unknown>(emitter: Emitter<[TEvent]>, initialState: TEvent) => TEvent;
+import type { Emitter } from "../emitter";
+export declare const useEmitter: <TEvent extends unknown>(emitter: Emitter<[TEvent]>, initialState: TEvent) => TEvent;

package/types/excalidraw/hooks/useLibraryItemSvg.d.ts

@@ -1,11 +1,11 @@
-import type { LibraryItem } from "../types";
-export type SvgCache = Map<LibraryItem["id"], SVGSVGElement>;
-export declare const libraryItemSvgsCache: import("jotai").PrimitiveAtom<SvgCache> & {
-    init: SvgCache;
-};
-export declare const useLibraryItemSvg: (id: LibraryItem["id"] | null, elements: LibraryItem["elements"] | undefined, svgCache: SvgCache) => SVGSVGElement | undefined;
-export declare const useLibraryCache: () => {
-    clearLibraryCache: () => void;
-    deleteItemsFromLibraryCache: (items: LibraryItem["id"][]) => void;
-    svgCache: SvgCache;
-};
+import type { LibraryItem } from "../types";
+export type SvgCache = Map<LibraryItem["id"], SVGSVGElement>;
+export declare const libraryItemSvgsCache: import("jotai").PrimitiveAtom<SvgCache> & {
+    init: SvgCache;
+};
+export declare const useLibraryItemSvg: (id: LibraryItem["id"] | null, elements: LibraryItem["elements"] | undefined, svgCache: SvgCache) => SVGSVGElement | undefined;
+export declare const useLibraryCache: () => {
+    clearLibraryCache: () => void;
+    deleteItemsFromLibraryCache: (items: LibraryItem["id"][]) => void;
+    svgCache: SvgCache;
+};

package/types/excalidraw/hooks/useOutsideClick.d.ts

@@ -1,19 +1,19 @@
-export declare function useOutsideClick<T extends HTMLElement>(ref: React.RefObject<T>, 
-/** if performance is of concern, memoize the callback */
-callback: (event: Event) => void, 
-/**
- * Optional callback which is called on every click.
- *
- * Should return `true` if click should be considered as inside the container,
- * and `false` if it falls outside and should call the `callback`.
- *
- * Returning `true` overrides the default behavior and `callback` won't be
- * called.
- *
- * Returning `undefined` will fallback to the default behavior.
- */
-isInside?: (event: Event & {
-    target: HTMLElement;
-}, 
-/** the element of the passed ref */
-container: T) => boolean | undefined): void;
+export declare function useOutsideClick<T extends HTMLElement>(ref: React.RefObject<T>, 
+/** if performance is of concern, memoize the callback */
+callback: (event: Event) => void, 
+/**
+ * Optional callback which is called on every click.
+ *
+ * Should return `true` if click should be considered as inside the container,
+ * and `false` if it falls outside and should call the `callback`.
+ *
+ * Returning `true` overrides the default behavior and `callback` won't be
+ * called.
+ *
+ * Returning `undefined` will fallback to the default behavior.
+ */
+isInside?: (event: Event & {
+    target: HTMLElement;
+}, 
+/** the element of the passed ref */
+container: T) => boolean | undefined): void;

package/types/excalidraw/hooks/useScrollPosition.d.ts

@@ -1 +1 @@
-export declare const useScrollPosition: <T extends HTMLElement>(elementRef: import("react").RefObject<T>) => number;
+export declare const useScrollPosition: <T extends HTMLElement>(elementRef: import("react").RefObject<T>) => number;

package/types/excalidraw/hooks/useStable.d.ts

@@ -1 +1 @@
-export declare const useStable: <T extends Record<string, any>>(value: T) => T;
+export declare const useStable: <T extends Record<string, any>>(value: T) => T;

package/types/excalidraw/hooks/useStableCallback.d.ts

@@ -1,4 +1,4 @@
-/**
- * Returns a stable function of the same type.
- */
-export declare const useStableCallback: <T extends (...args: any[]) => any>(userFn: T) => T;
+/**
+ * Returns a stable function of the same type.
+ */
+export declare const useStableCallback: <T extends (...args: any[]) => any>(userFn: T) => T;

package/types/excalidraw/hooks/useTransition.d.ts

@@ -1,2 +1,2 @@
-import React from "react";
-export declare const useTransition: typeof React.useTransition;
+import React from "react";
+export declare const useTransition: typeof React.useTransition;

package/types/excalidraw/i18n.d.ts

@@ -1,24 +1,24 @@
-import fallbackLangData from "./locales/en.json";
-import type { NestedKeyOf } from "./utility-types";
-export interface Language {
-    code: string;
-    label: string;
-    rtl?: boolean;
-}
-export type TranslationKeys = NestedKeyOf<typeof fallbackLangData>;
-export declare const defaultLang: {
-    code: string;
-    label: string;
-};
-export declare const languages: Language[];
-export declare const setLanguage: (lang: Language) => Promise<void>;
-export declare const getLanguage: () => Language;
-export declare const t: (path: NestedKeyOf<typeof fallbackLangData>, replacement?: {
-    [key: string]: string | number;
-} | null | undefined, fallback?: string) => string;
-export declare const useI18n: () => {
-    t: (path: NestedKeyOf<typeof fallbackLangData>, replacement?: {
-        [key: string]: string | number;
-    } | null | undefined, fallback?: string) => string;
-    langCode: string;
-};
+import fallbackLangData from "./locales/en.json";
+import type { NestedKeyOf } from "./utility-types";
+export interface Language {
+    code: string;
+    label: string;
+    rtl?: boolean;
+}
+export type TranslationKeys = NestedKeyOf<typeof fallbackLangData>;
+export declare const defaultLang: {
+    code: string;
+    label: string;
+};
+export declare const languages: Language[];
+export declare const setLanguage: (lang: Language) => Promise<void>;
+export declare const getLanguage: () => Language;
+export declare const t: (path: NestedKeyOf<typeof fallbackLangData>, replacement?: {
+    [key: string]: string | number;
+} | null | undefined, fallback?: string) => string;
+export declare const useI18n: () => {
+    t: (path: NestedKeyOf<typeof fallbackLangData>, replacement?: {
+        [key: string]: string | number;
+    } | null | undefined, fallback?: string) => string;
+    langCode: string;
+};

package/types/excalidraw/index-node.d.ts

@@ -1 +1 @@
-export {};
+export {};

package/types/excalidraw/index.d.ts

@@ -1,62 +1,62 @@
-import React from "react";
-import "./css/app.scss";
-import "./css/styles.scss";
-import "./fonts/css/fonts.css";
-import type { ExcalidrawProps } from "./types";
-import Footer from "./components/footer/FooterCenter";
-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) => JSX.Element>;
-export { getSceneVersion, hashElementsVersion, hashString, isInvisiblySmallElement, getNonDeletedElements, getTextFromElements, } from "./element";
-export { defaultLang, useI18n, languages } from "./i18n";
-export { restore, restoreAppState, restoreElements, restoreLibraryItems, } from "./data/restore";
-export { reconcileElements } from "./data/reconcile";
-export { exportToCanvas, exportToBlob, exportToSvg, exportToClipboard, getCommonBoundingBox, //zsviczian
-getMaximumGroups, //zsviczian
-intersectElementWithLine, //zsviczian
-determineFocusDistance, //zsviczian
-measureText, //zsviczian
-getLineHeight, //zsviczian
-wrapText, //zsviczian
-getFontString, //zsviczian
-getBoundTextMaxWidth, //zsviczian
-mermaidToExcalidraw, //zsviczian
-destroyObsidianUtils, //zsviczian
-registerLocalFont, //zsviczian
-getFontFamilies, //zsviczian
-getFontFamilyString, //zsviczian
-registerFontsInCSS, //zsviczian
-getCSSFontDefinition, //zsviczian
-loadSceneFonts, } from "../utils/export";
-export { refreshTextDimensions } from "./element/newElement";
-export { getContainerElement } from "./element/textElement";
-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, DEFAULT_LASER_COLOR, } from "./constants";
-export { mutateElement, newElementWith, bumpVersion, } from "./element/mutateElement";
-export { StoreAction } from "./store";
-export { parseLibraryTokensFromUrl, useHandleLibrary } from "./data/library";
-export { sceneCoordsToViewportCoords, viewportCoordsToSceneCoords, safelyParseJSON, } from "./utils";
-export { getEmbedLink } from "./element/embeddable";
-export { Sidebar } from "./components/Sidebar/Sidebar";
-export { Button } from "./components/Button";
-export { Footer };
-export { MainMenu };
-export { useDevice } from "./components/App";
-export { WelcomeScreen };
-export { LiveCollaborationTrigger };
-export { Stats } from "./components/Stats";
-export { DefaultSidebar } from "./components/DefaultSidebar";
-export { TTDDialog } from "./components/TTDDialog/TTDDialog";
-export { TTDDialogTrigger } from "./components/TTDDialog/TTDDialogTrigger";
-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/withinBounds";
-export { DiagramToCodePlugin } from "./components/DiagramToCodePlugin/DiagramToCodePlugin";
-export { getDataURL } from "./data/blob";
+import React from "react";
+import "./css/app.scss";
+import "./css/styles.scss";
+import "./fonts/fonts.css";
+import type { ExcalidrawProps } from "./types";
+import Footer from "./components/footer/FooterCenter";
+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) => JSX.Element>;
+export { getSceneVersion, hashElementsVersion, hashString, isInvisiblySmallElement, getNonDeletedElements, getTextFromElements, } from "./element";
+export { defaultLang, useI18n, languages } from "./i18n";
+export { restore, restoreAppState, restoreElements, restoreLibraryItems, } from "./data/restore";
+export { reconcileElements } from "./data/reconcile";
+export { exportToCanvas, exportToBlob, exportToSvg, exportToClipboard, getCommonBoundingBox, //zsviczian
+getMaximumGroups, //zsviczian
+intersectElementWithLine, //zsviczian
+determineFocusDistance, //zsviczian
+measureText, //zsviczian
+getLineHeight, //zsviczian
+wrapText, //zsviczian
+getFontString, //zsviczian
+getBoundTextMaxWidth, //zsviczian
+mermaidToExcalidraw, //zsviczian
+destroyObsidianUtils, //zsviczian
+registerLocalFont, //zsviczian
+getFontFamilies, //zsviczian
+getFontFamilyString, //zsviczian
+registerFontsInCSS, //zsviczian
+getCSSFontDefinition, //zsviczian
+loadSceneFonts, } from "../utils/export";
+export { refreshTextDimensions } from "./element/newElement";
+export { getContainerElement } from "./element/textElement";
+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, DEFAULT_LASER_COLOR, } from "./constants";
+export { mutateElement, newElementWith, bumpVersion, } from "./element/mutateElement";
+export { StoreAction } from "./store";
+export { parseLibraryTokensFromUrl, useHandleLibrary } from "./data/library";
+export { sceneCoordsToViewportCoords, viewportCoordsToSceneCoords, safelyParseJSON, } from "./utils";
+export { getEmbedLink } from "./element/embeddable";
+export { Sidebar } from "./components/Sidebar/Sidebar";
+export { Button } from "./components/Button";
+export { Footer };
+export { MainMenu };
+export { useDevice } from "./components/App";
+export { WelcomeScreen };
+export { LiveCollaborationTrigger };
+export { Stats } from "./components/Stats";
+export { DefaultSidebar } from "./components/DefaultSidebar";
+export { TTDDialog } from "./components/TTDDialog/TTDDialog";
+export { TTDDialogTrigger } from "./components/TTDDialog/TTDDialogTrigger";
+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/withinBounds";
+export { DiagramToCodePlugin } from "./components/DiagramToCodePlugin/DiagramToCodePlugin";
+export { getDataURL } from "./data/blob";

package/types/excalidraw/jotai.d.ts

@@ -1,34 +1,34 @@
-import type { PrimitiveAtom } from "jotai";
-export declare const jotaiScope: unique symbol;
-export declare const jotaiStore: {
-    get: <Value>(atom: import("jotai").Atom<Value>) => Awaited<Value> | undefined;
-    asyncGet: <Value_1>(atom: import("jotai").Atom<Value_1>) => Promise<Awaited<Value_1>>;
-    set: <Value_2, Update, Result extends void | Promise<void>>(atom: import("jotai").WritableAtom<Value_2, Update, Result>, update: Update) => Result;
-    sub: (atom: import("jotai").Atom<unknown>, callback: () => void) => () => void;
-    SECRET_INTERNAL_store: {
-        r: <Value_3>(readingAtom: import("jotai").Atom<Value_3>, version?: import("jotai/core/store").VersionObject | undefined) => import("jotai/core/store").AtomState<Value_3>;
-        w: <Value_1_1, Update_1, Result_1 extends void | Promise<void>>(writingAtom: import("jotai").WritableAtom<Value_1_1, Update_1, Result_1>, update: Update_1, version?: import("jotai/core/store").VersionObject | undefined) => Result_1;
-        c: (_atom: import("jotai").Atom<unknown> | null, version?: import("jotai/core/store").VersionObject | undefined) => void;
-        s: (atom: import("jotai").Atom<unknown>, callback: (version?: import("jotai/core/store").VersionObject | undefined) => void, version?: import("jotai/core/store").VersionObject | undefined) => () => void;
-        h: (values: Iterable<readonly [import("jotai").Atom<unknown>, unknown]>, version?: import("jotai/core/store").VersionObject | undefined) => void;
-        n: (l: () => void) => () => void;
-        l: () => IterableIterator<import("jotai").Atom<unknown>>;
-        a: (a: import("jotai").Atom<unknown>) => import("jotai/core/store").AtomState<unknown> | undefined;
-        m: (a: import("jotai").Atom<unknown>) => {
-            l: Set<(version?: import("jotai/core/store").VersionObject | undefined) => void>;
-            t: Set<import("jotai").Atom<unknown>>;
-            u?: (() => void) | undefined;
-        } | undefined;
-    } | {
-        r: <Value_4>(readingAtom: import("jotai").Atom<Value_4>, version?: import("jotai/core/store").VersionObject | undefined) => import("jotai/core/store").AtomState<Value_4>;
-        w: <Value_1_2, Update_2, Result_2 extends void | Promise<void>>(writingAtom: import("jotai").WritableAtom<Value_1_2, Update_2, Result_2>, update: Update_2, version?: import("jotai/core/store").VersionObject | undefined) => Result_2;
-        c: (_atom: import("jotai").Atom<unknown> | null, version?: import("jotai/core/store").VersionObject | undefined) => void;
-        s: (atom: import("jotai").Atom<unknown>, callback: (version?: import("jotai/core/store").VersionObject | undefined) => void, version?: import("jotai/core/store").VersionObject | undefined) => () => void;
-        h: (values: Iterable<readonly [import("jotai").Atom<unknown>, unknown]>, version?: import("jotai/core/store").VersionObject | undefined) => void;
-        n?: undefined;
-        l?: undefined;
-        a?: undefined;
-        m?: undefined;
-    };
-};
-export declare const useAtomWithInitialValue: <T extends unknown, A extends PrimitiveAtom<T>>(atom: A, initialValue: T | (() => T)) => readonly [Awaited<T>, import("jotai/core/atom").SetAtom<T | ((prev: T) => T), void>];
+import type { PrimitiveAtom } from "jotai";
+export declare const jotaiScope: unique symbol;
+export declare const jotaiStore: {
+    get: <Value>(atom: import("jotai").Atom<Value>) => Awaited<Value> | undefined;
+    asyncGet: <Value_1>(atom: import("jotai").Atom<Value_1>) => Promise<Awaited<Value_1>>;
+    set: <Value_2, Update, Result extends void | Promise<void>>(atom: import("jotai").WritableAtom<Value_2, Update, Result>, update: Update) => Result;
+    sub: (atom: import("jotai").Atom<unknown>, callback: () => void) => () => void;
+    SECRET_INTERNAL_store: {
+        r: <Value_3>(readingAtom: import("jotai").Atom<Value_3>, version?: import("jotai/core/store").VersionObject | undefined) => import("jotai/core/store").AtomState<Value_3>;
+        w: <Value_1_1, Update_1, Result_1 extends void | Promise<void>>(writingAtom: import("jotai").WritableAtom<Value_1_1, Update_1, Result_1>, update: Update_1, version?: import("jotai/core/store").VersionObject | undefined) => Result_1;
+        c: (_atom: import("jotai").Atom<unknown> | null, version?: import("jotai/core/store").VersionObject | undefined) => void;
+        s: (atom: import("jotai").Atom<unknown>, callback: (version?: import("jotai/core/store").VersionObject | undefined) => void, version?: import("jotai/core/store").VersionObject | undefined) => () => void;
+        h: (values: Iterable<readonly [import("jotai").Atom<unknown>, unknown]>, version?: import("jotai/core/store").VersionObject | undefined) => void;
+        n: (l: () => void) => () => void;
+        l: () => IterableIterator<import("jotai").Atom<unknown>>;
+        a: (a: import("jotai").Atom<unknown>) => import("jotai/core/store").AtomState<unknown> | undefined;
+        m: (a: import("jotai").Atom<unknown>) => {
+            l: Set<(version?: import("jotai/core/store").VersionObject | undefined) => void>;
+            t: Set<import("jotai").Atom<unknown>>;
+            u?: (() => void) | undefined;
+        } | undefined;
+    } | {
+        r: <Value_4>(readingAtom: import("jotai").Atom<Value_4>, version?: import("jotai/core/store").VersionObject | undefined) => import("jotai/core/store").AtomState<Value_4>;
+        w: <Value_1_2, Update_2, Result_2 extends void | Promise<void>>(writingAtom: import("jotai").WritableAtom<Value_1_2, Update_2, Result_2>, update: Update_2, version?: import("jotai/core/store").VersionObject | undefined) => Result_2;
+        c: (_atom: import("jotai").Atom<unknown> | null, version?: import("jotai/core/store").VersionObject | undefined) => void;
+        s: (atom: import("jotai").Atom<unknown>, callback: (version?: import("jotai/core/store").VersionObject | undefined) => void, version?: import("jotai/core/store").VersionObject | undefined) => () => void;
+        h: (values: Iterable<readonly [import("jotai").Atom<unknown>, unknown]>, version?: import("jotai/core/store").VersionObject | undefined) => void;
+        n?: undefined;
+        l?: undefined;
+        a?: undefined;
+        m?: undefined;
+    };
+};
+export declare const useAtomWithInitialValue: <T extends unknown, A extends PrimitiveAtom<T>>(atom: A, initialValue: T | (() => T)) => readonly [Awaited<T>, import("jotai/core/atom").SetAtom<T | ((prev: T) => T), void>];