@haklex/rich-ext-excalidraw 0.0.51

package/LICENSE

@@ -0,0 +1,28 @@
+MIT License
+
+Copyright (c) 2024 Innei
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+Additional Terms and Conditions
+
+----------------
+
+Use of this software is governed by the terms of MIT and, in addition, by the terms and conditions described in the additional file (ADDITIONAL_TERMS.md). By using this software, you agree to abide by these additional terms and conditions.

package/dist/ExcalidrawConfigContext.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+export interface ExcalidrawConfig {
+    apiUrl?: string;
+    saveSnapshot?: (snapshot: object) => Promise<string>;
+}
+export declare function ExcalidrawConfigProvider({ apiUrl, saveSnapshot, children, }: ExcalidrawConfig & {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useExcalidrawConfig(): ExcalidrawConfig;
+//# sourceMappingURL=ExcalidrawConfigContext.d.ts.map

package/dist/ExcalidrawConfigContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExcalidrawConfigContext.d.ts","sourceRoot":"","sources":["../src/ExcalidrawConfigContext.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAGtC,MAAM,WAAW,gBAAgB;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,YAAY,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;CACrD;AAID,wBAAgB,wBAAwB,CAAC,EACvC,MAAM,EACN,YAAY,EACZ,QAAQ,GACT,EAAE,gBAAgB,GAAG;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,2CAU5C;AAED,wBAAgB,mBAAmB,IAAI,gBAAgB,CAEtD"}

package/dist/ExcalidrawDisplayRenderer.d.ts

@@ -0,0 +1,6 @@
+import { FC } from 'react';
+export interface ExcalidrawStaticRendererProps {
+    snapshot: string;
+}
+export declare const ExcalidrawDisplayRenderer: FC<ExcalidrawStaticRendererProps>;
+//# sourceMappingURL=ExcalidrawDisplayRenderer.d.ts.map

package/dist/ExcalidrawDisplayRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExcalidrawDisplayRenderer.d.ts","sourceRoot":"","sources":["../src/ExcalidrawDisplayRenderer.tsx"],"names":[],"mappings":"AAQA,OAAO,EAAiC,KAAK,EAAE,EAAkB,MAAM,OAAO,CAAA;AAO9E,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,eAAO,MAAM,yBAAyB,EAAE,EAAE,CAAC,6BAA6B,CAsCvE,CAAA"}

package/dist/ExcalidrawEditNode.d.ts

@@ -0,0 +1,14 @@
+import { SlashMenuItemConfig } from '@haklex/rich-editor';
+import { EditorConfig, LexicalEditor, LexicalNode, NodeKey } from 'lexical';
+import { ReactElement } from 'react';
+import { ExcalidrawNode, SerializedExcalidrawNode } from './ExcalidrawNode';
+export declare class ExcalidrawEditNode extends ExcalidrawNode {
+    static slashMenuItems: SlashMenuItemConfig[];
+    static clone(node: ExcalidrawEditNode): ExcalidrawEditNode;
+    constructor(snapshot: string, key?: NodeKey);
+    static importJSON(serializedNode: SerializedExcalidrawNode): ExcalidrawEditNode;
+    decorate(editor: LexicalEditor, _config: EditorConfig): ReactElement;
+}
+export declare function $createExcalidrawEditNode(snapshot: string): ExcalidrawEditNode;
+export declare function $isExcalidrawEditNode(node: LexicalNode | null | undefined): node is ExcalidrawEditNode;
+//# sourceMappingURL=ExcalidrawEditNode.d.ts.map

package/dist/ExcalidrawEditNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExcalidrawEditNode.d.ts","sourceRoot":"","sources":["../src/ExcalidrawEditNode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AAGhF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,OAAO,CAAA;AAGzC,OAAO,EAAE,cAAc,EAAC,KAAK,wBAAwB,EAAE,MAAM,kBAAkB,CAAA;AAe/E,qBAAa,kBAAmB,SAAQ,cAAc;IACpD,MAAM,CAAC,cAAc,EAAE,mBAAmB,EAAE,CAa3C;IAED,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,kBAAkB,GAAG,kBAAkB;gBAI9C,QAAQ,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO;IAI3C,MAAM,CAAC,UAAU,CACf,cAAc,EAAE,wBAAwB,GACvC,kBAAkB;IAIrB,QAAQ,CAAC,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,YAAY,GAAG,YAAY;CAsCrE;AAED,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,MAAM,GACf,kBAAkB,CAEpB;AAED,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GACnC,IAAI,IAAI,kBAAkB,CAE5B"}

package/dist/ExcalidrawEditRenderer.d.ts

@@ -0,0 +1,8 @@
+import { FC } from 'react';
+import { ExcalidrawSnapshot } from './types';
+export interface ExcalidrawEditRendererProps {
+    snapshot: ExcalidrawSnapshot | null;
+    onSnapshotChange: (snapshot: ExcalidrawSnapshot) => void;
+}
+export declare const ExcalidrawEditRenderer: FC<ExcalidrawEditRendererProps>;
+//# sourceMappingURL=ExcalidrawEditRenderer.d.ts.map

package/dist/ExcalidrawEditRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExcalidrawEditRenderer.d.ts","sourceRoot":"","sources":["../src/ExcalidrawEditRenderer.tsx"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAiB,EAAE,EAAE,MAAM,OAAO,CAAA;AAM9C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAGjD,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,EAAE,kBAAkB,GAAG,IAAI,CAAA;IACnC,gBAAgB,EAAE,CAAC,QAAQ,EAAE,kBAAkB,KAAK,IAAI,CAAA;CACzD;AAsYD,eAAO,MAAM,sBAAsB,EAAE,EAAE,CAAC,2BAA2B,CAiIlE,CAAA"}

package/dist/ExcalidrawNode-Biawr0pH.js

@@ -0,0 +1,537 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+import { useColorScheme } from "@haklex/rich-editor";
+import { presentDialog } from "@haklex/rich-editor-ui";
+import { usePortalTheme } from "@haklex/rich-style-token";
+import { ZoomIn, ZoomOut, ScanSearch, Maximize2, X } from "lucide-react";
+import { createContext, use, useMemo, useState, useEffect, useRef, useCallback, Component, lazy, Suspense, createElement } from "react";
+import { DecoratorNode } from "lexical";
+const ExcalidrawConfigContext = createContext({});
+function ExcalidrawConfigProvider({
+  apiUrl,
+  saveSnapshot,
+  children
+}) {
+  const value = useMemo(
+    () => ({ apiUrl, saveSnapshot }),
+    [apiUrl, saveSnapshot]
+  );
+  return /* @__PURE__ */ jsx(ExcalidrawConfigContext.Provider, { value, children });
+}
+function useExcalidrawConfig() {
+  return use(ExcalidrawConfigContext);
+}
+const readonlyUIOptions = {
+  canvasActions: {
+    toggleTheme: false,
+    export: false,
+    saveAsImage: false,
+    loadScene: false,
+    changeViewBackgroundColor: false
+  }
+};
+var excalidrawStaticContainer = "_1c3wdzl0";
+var excalidrawEditorContainer = "_1c3wdzl1";
+var excalidrawLoading = "_1c3wdzl2";
+var excalidrawError = "_1c3wdzl4";
+var excalidrawActionGroup = "_1c3wdzl5";
+var excalidrawActionButton = "_1c3wdzl6";
+var excalidrawFullscreenPopup = "_1c3wdzl7";
+var excalidrawDialogHeader = "_1c3wdzl8";
+var excalidrawDialogHeaderTitle = "_1c3wdzl9";
+var excalidrawStatusDot = "_1c3wdzla";
+var excalidrawDialogTitle = "_1c3wdzlb";
+var excalidrawDialogMeta = "_1c3wdzlc";
+var excalidrawHeaderActions = "_1c3wdzld";
+var excalidrawHeaderClose = "_1c3wdzle";
+var excalidrawActionBarBtn = "_1c3wdzlf";
+var excalidrawActionBarSep = "_1c3wdzlg";
+var excalidrawActionBarUrl = "_1c3wdzlh";
+var excalidrawDialogCanvas = "_1c3wdzli";
+var excalidrawConfirmActions = "_1c3wdzlj";
+var excalidrawConfirmBtn = "_1c3wdzlk";
+var excalidrawConfirmBtnPrimary = "_1c3wdzll";
+var excalidrawConfirmBtnDanger = "_1c3wdzlm";
+var excalidrawEditOverlay = "_1c3wdzln";
+var excalidrawEditLabel = "_1c3wdzlo";
+function parseSnapshot(raw) {
+  if (!raw || !raw.trim()) return null;
+  try {
+    const json = JSON.parse(raw);
+    if (json && typeof json === "object") return { type: "inline", data: json };
+  } catch {
+  }
+  const lines = raw.split("\n");
+  const firstLine = lines[0].trim();
+  if (!firstLine.startsWith("http") && !firstLine.startsWith("blob:") && !firstLine.startsWith("ref:"))
+    return null;
+  const remaining = lines.slice(1).join("\n").trim();
+  if (remaining) {
+    try {
+      const delta = JSON.parse(remaining);
+      if (delta && typeof delta === "object")
+        return { type: "delta", baseUrl: firstLine, delta };
+    } catch {
+    }
+  }
+  return { type: "remote", url: firstLine };
+}
+function serializeSnapshot(snapshot) {
+  switch (snapshot.type) {
+    case "inline":
+      return JSON.stringify(snapshot.data);
+    case "remote":
+      return snapshot.url;
+    case "delta":
+      return [snapshot.baseUrl, JSON.stringify(snapshot.delta)].join("\n");
+  }
+}
+function resolveUrl(url, apiUrl) {
+  const refLine = url;
+  if (url.startsWith("http") || url.startsWith("blob:")) {
+    return { fetchUrl: url, refLine };
+  }
+  if (url.startsWith("ref:") && apiUrl) {
+    return { fetchUrl: `${apiUrl}/objects/${url.slice(4)}`, refLine };
+  }
+  return {
+    error: url.startsWith("ref:") ? "Missing apiUrl for ref resolution" : "Unrecognized snapshot format"
+  };
+}
+function typedToParsed(typed, apiUrl) {
+  switch (typed.type) {
+    case "inline":
+      return { type: "inline", snapshot: typed.data };
+    case "remote": {
+      const result = resolveUrl(typed.url, apiUrl);
+      if ("error" in result) return { type: "error", error: result.error };
+      return {
+        type: "remote",
+        fetchUrl: result.fetchUrl,
+        refLine: result.refLine
+      };
+    }
+    case "delta": {
+      const result = resolveUrl(typed.baseUrl, apiUrl);
+      if ("error" in result) return { type: "error", error: result.error };
+      return {
+        type: "incremental",
+        fetchUrl: result.fetchUrl,
+        refLine: result.refLine,
+        delta: typed.delta
+      };
+    }
+  }
+}
+function stringToParsed(data, apiUrl) {
+  const typed = parseSnapshot(data);
+  if (!typed) return { type: "empty" };
+  return typedToParsed(typed, apiUrl);
+}
+function useExcalidrawData(data) {
+  const { apiUrl } = useExcalidrawConfig();
+  const parsed = useMemo(() => {
+    if (data === null || data === void 0) return { type: "empty" };
+    if (typeof data === "string") return stringToParsed(data, apiUrl);
+    return typedToParsed(data, apiUrl);
+  }, [data, apiUrl]);
+  const [remoteSnapshot, setRemoteSnapshot] = useState();
+  const [baseData, setBaseData] = useState();
+  const [loading, setLoading] = useState(
+    parsed.type === "remote" || parsed.type === "incremental"
+  );
+  const [error, setError] = useState("");
+  useEffect(() => {
+    if (parsed.type !== "remote" && parsed.type !== "incremental") return;
+    const { fetchUrl } = parsed;
+    const delta = parsed.type === "incremental" ? parsed.delta : void 0;
+    let cancelled = false;
+    setLoading(true);
+    setError("");
+    fetch(fetchUrl).then((res) => {
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      return res.json();
+    }).then(async (json) => {
+      if (cancelled) return;
+      setBaseData(json);
+      const deltaKeys = delta ? Object.keys(delta) : [];
+      if (deltaKeys.length > 0) {
+        const { patch } = await import("jsondiffpatch");
+        if (cancelled) return;
+        const patched = patch(structuredClone(json), delta);
+        setRemoteSnapshot(patched);
+      } else {
+        setRemoteSnapshot(json);
+      }
+      setLoading(false);
+    }).catch((err) => {
+      if (!cancelled) {
+        setError(err instanceof Error ? err.message : "Failed to load");
+        setLoading(false);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [parsed]);
+  if (parsed.type === "inline") {
+    return { snapshot: parsed.snapshot, loading: false, error: "" };
+  }
+  if (parsed.type === "remote" || parsed.type === "incremental") {
+    return {
+      snapshot: remoteSnapshot,
+      loading,
+      error,
+      baseRef: parsed.refLine,
+      baseData
+    };
+  }
+  if (parsed.type === "error") {
+    return { snapshot: void 0, loading: false, error: parsed.error };
+  }
+  return { snapshot: void 0, loading: false, error: "" };
+}
+const ExcalidrawDisplayRenderer = ({
+  snapshot
+}) => {
+  const theme = useColorScheme();
+  const containerRef = useRef(null);
+  const [hasEnteredView, setHasEnteredView] = useState(false);
+  useEffect(() => {
+    if (hasEnteredView) return;
+    const target = containerRef.current;
+    if (!target) return;
+    const observer = new IntersectionObserver(
+      (entries) => {
+        if (entries.some((e) => e.isIntersecting)) {
+          setHasEnteredView(true);
+          observer.disconnect();
+        }
+      },
+      { rootMargin: "200px 0px", threshold: 0.1 }
+    );
+    observer.observe(target);
+    return () => observer.disconnect();
+  }, [hasEnteredView]);
+  if (!hasEnteredView) {
+    return /* @__PURE__ */ jsx("div", { ref: containerRef, className: excalidrawStaticContainer, children: /* @__PURE__ */ jsx("div", { className: excalidrawLoading, children: "Loading excalidraw..." }) });
+  }
+  return /* @__PURE__ */ jsx("div", { ref: containerRef, children: /* @__PURE__ */ jsx(ExcalidrawStaticCanvas, { snapshot, theme }) });
+};
+const ExcalidrawExpandContent = ({ dismiss, ExcalidrawComponent, data, theme }) => {
+  const apiRef = useRef(null);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsxs("div", { className: excalidrawDialogHeader, children: [
+      /* @__PURE__ */ jsxs("div", { className: excalidrawDialogHeaderTitle, children: [
+        /* @__PURE__ */ jsx("span", { className: excalidrawDialogTitle, children: "Whiteboard" }),
+        /* @__PURE__ */ jsx("span", { className: excalidrawDialogMeta, children: "excalidraw" })
+      ] }),
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          className: excalidrawHeaderClose,
+          onClick: dismiss,
+          children: /* @__PURE__ */ jsx(X, { size: 18 })
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: excalidrawDialogCanvas, children: /* @__PURE__ */ jsx(
+      ExcalidrawComponent,
+      {
+        initialData: data,
+        viewModeEnabled: true,
+        zenModeEnabled: true,
+        theme,
+        UIOptions: readonlyUIOptions,
+        excalidrawAPI: (api) => {
+          apiRef.current = api;
+          setTimeout(() => api.scrollToContent(), 100);
+        }
+      }
+    ) })
+  ] });
+};
+const ExcalidrawStaticCanvas = ({ snapshot, theme }) => {
+  const {
+    snapshot: data,
+    loading: dataLoading,
+    error: dataError
+  } = useExcalidrawData(snapshot);
+  const [ExcalidrawComponent, setExcalidrawComponent] = useState(null);
+  const [libLoading, setLibLoading] = useState(true);
+  const apiRef = useRef(null);
+  const { className: portalClassName } = usePortalTheme();
+  useEffect(() => {
+    import("@excalidraw/excalidraw").then((mod) => {
+      const Comp = mod.Excalidraw;
+      if (Comp)
+        setExcalidrawComponent(() => Comp);
+      setLibLoading(false);
+    }).catch((error) => {
+      console.error("Error loading excalidraw", error);
+      setLibLoading(false);
+    });
+  }, []);
+  const handleExpand = useCallback(() => {
+    if (!ExcalidrawComponent || !data) return;
+    presentDialog({
+      content: ({ dismiss }) => /* @__PURE__ */ jsx(
+        ExcalidrawExpandContent,
+        {
+          dismiss,
+          ExcalidrawComponent,
+          data,
+          theme
+        }
+      ),
+      className: excalidrawFullscreenPopup,
+      portalClassName,
+      theme,
+      showCloseButton: false,
+      clickOutsideToDismiss: true
+    });
+  }, [ExcalidrawComponent, data, theme, portalClassName]);
+  const loading = dataLoading || libLoading;
+  if (loading) {
+    return /* @__PURE__ */ jsx("div", { className: excalidrawStaticContainer, children: /* @__PURE__ */ jsx("div", { className: excalidrawLoading, children: "Loading excalidraw..." }) });
+  }
+  if (dataError || !data) {
+    return /* @__PURE__ */ jsx("div", { className: excalidrawStaticContainer, children: /* @__PURE__ */ jsx("div", { className: excalidrawError, children: dataError || "No data" }) });
+  }
+  if (!ExcalidrawComponent) {
+    return /* @__PURE__ */ jsx("div", { className: excalidrawStaticContainer, children: /* @__PURE__ */ jsx("div", { className: excalidrawError, children: "Failed to load excalidraw" }) });
+  }
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: excalidrawStaticContainer,
+      "data-theme": theme,
+      "data-color-scheme": theme,
+      suppressHydrationWarning: true,
+      children: [
+        /* @__PURE__ */ jsx(
+          ExcalidrawErrorBoundary,
+          {
+            fallback: /* @__PURE__ */ jsx("div", { className: excalidrawError, children: "Failed to render excalidraw" }),
+            children: /* @__PURE__ */ jsx(
+              ExcalidrawComponent,
+              {
+                initialData: data,
+                viewModeEnabled: true,
+                zenModeEnabled: true,
+                theme,
+                UIOptions: readonlyUIOptions,
+                excalidrawAPI: (api) => {
+                  apiRef.current = api;
+                  setTimeout(() => api.scrollToContent(), 100);
+                }
+              }
+            )
+          }
+        ),
+        /* @__PURE__ */ jsxs("div", { className: excalidrawActionGroup, children: [
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              className: excalidrawActionButton,
+              title: "Zoom In",
+              onClick: () => {
+                const api = apiRef.current;
+                if (!api) return;
+                const zoom = api.getAppState().zoom.value;
+                api.updateScene({ appState: { zoom: { value: zoom * 1.25 } } });
+              },
+              children: /* @__PURE__ */ jsx(ZoomIn, { size: 20 })
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              className: excalidrawActionButton,
+              title: "Zoom Out",
+              onClick: () => {
+                const api = apiRef.current;
+                if (!api) return;
+                const zoom = api.getAppState().zoom.value;
+                api.updateScene({ appState: { zoom: { value: zoom / 1.25 } } });
+              },
+              children: /* @__PURE__ */ jsx(ZoomOut, { size: 20 })
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              className: excalidrawActionButton,
+              title: "Fit to Content",
+              onClick: () => apiRef.current?.scrollToContent(),
+              children: /* @__PURE__ */ jsx(ScanSearch, { size: 20 })
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              className: excalidrawActionButton,
+              title: "Expand",
+              onClick: handleExpand,
+              children: /* @__PURE__ */ jsx(Maximize2, { size: 20 })
+            }
+          )
+        ] })
+      ]
+    }
+  );
+};
+class ExcalidrawErrorBoundary extends Component {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "state", { hasError: false });
+  }
+  static getDerivedStateFromError() {
+    return { hasError: true };
+  }
+  render() {
+    return this.state.hasError ? this.props.fallback : this.props.children;
+  }
+}
+const ExcalidrawDisplayRenderer$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ExcalidrawDisplayRenderer
+}, Symbol.toStringTag, { value: "Module" }));
+const LazyDisplayRenderer = lazy(
+  () => Promise.resolve().then(() => ExcalidrawDisplayRenderer$1).then((m) => ({
+    default: m.ExcalidrawDisplayRenderer
+  }))
+);
+const ExcalidrawPlaceholder = ({ snapshot }) => {
+  let label = "Excalidraw Whiteboard";
+  try {
+    const data = JSON.parse(snapshot);
+    if (data && typeof data === "object") {
+      const elementCount = Array.isArray(data.elements) ? data.elements.length : 0;
+      if (elementCount > 0) {
+        label = `Excalidraw Whiteboard (${elementCount} elements)`;
+      }
+    }
+  } catch {
+  }
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: "rich-excalidraw-ssr-placeholder",
+      style: {
+        position: "relative",
+        width: "100%",
+        aspectRatio: "16 / 10",
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        backgroundColor: "var(--rich-excalidraw-bg, #f5f5f5)",
+        borderRadius: "8px",
+        border: "1px solid var(--rich-excalidraw-border, #e5e5e5)",
+        color: "var(--rich-excalidraw-fg, #737373)",
+        fontSize: "14px"
+      },
+      "aria-label": label,
+      children: /* @__PURE__ */ jsx("span", { children: label })
+    }
+  );
+};
+const ExcalidrawSSRRenderer = ({
+  snapshot
+}) => {
+  return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(ExcalidrawPlaceholder, { snapshot }), children: /* @__PURE__ */ jsx(LazyDisplayRenderer, { snapshot }) });
+};
+class ExcalidrawNode extends DecoratorNode {
+  constructor(snapshot, key) {
+    super(key);
+    __publicField(this, "__snapshot");
+    this.__snapshot = snapshot;
+  }
+  static getType() {
+    return "excalidraw";
+  }
+  static clone(node) {
+    return new ExcalidrawNode(node.__snapshot, node.__key);
+  }
+  createDOM(_config) {
+    const div = document.createElement("div");
+    div.className = "rich-excalidraw-wrapper";
+    return div;
+  }
+  updateDOM() {
+    return false;
+  }
+  isInline() {
+    return false;
+  }
+  static importJSON(serializedNode) {
+    return $createExcalidrawNode(serializedNode.snapshot);
+  }
+  exportJSON() {
+    return {
+      ...super.exportJSON(),
+      type: "excalidraw",
+      snapshot: this.__snapshot,
+      version: 1
+    };
+  }
+  getSnapshot() {
+    return this.__snapshot;
+  }
+  setSnapshot(snapshot) {
+    const writable = this.getWritable();
+    writable.__snapshot = snapshot;
+  }
+  decorate(_editor, _config) {
+    return createElement(ExcalidrawSSRRenderer, {
+      snapshot: this.__snapshot
+    });
+  }
+}
+function $createExcalidrawNode(snapshot) {
+  return new ExcalidrawNode(snapshot);
+}
+function $isExcalidrawNode(node) {
+  return node instanceof ExcalidrawNode;
+}
+export {
+  $createExcalidrawNode as $,
+  excalidrawActionBarUrl as A,
+  excalidrawHeaderClose as B,
+  excalidrawDialogCanvas as C,
+  ExcalidrawDisplayRenderer$1 as D,
+  ExcalidrawConfigProvider as E,
+  $isExcalidrawNode as a,
+  ExcalidrawDisplayRenderer as b,
+  ExcalidrawNode as c,
+  ExcalidrawSSRRenderer as d,
+  useExcalidrawData as e,
+  excalidrawFullscreenPopup as f,
+  excalidrawEditorContainer as g,
+  excalidrawLoading as h,
+  excalidrawError as i,
+  excalidrawEditOverlay as j,
+  excalidrawEditLabel as k,
+  excalidrawConfirmActions as l,
+  excalidrawConfirmBtn as m,
+  excalidrawConfirmBtnDanger as n,
+  excalidrawConfirmBtnPrimary as o,
+  parseSnapshot as p,
+  excalidrawDialogHeader as q,
+  readonlyUIOptions as r,
+  serializeSnapshot as s,
+  excalidrawStatusDot as t,
+  useExcalidrawConfig as u,
+  excalidrawDialogTitle as v,
+  excalidrawDialogMeta as w,
+  excalidrawHeaderActions as x,
+  excalidrawActionBarSep as y,
+  excalidrawActionBarBtn as z
+};

package/dist/ExcalidrawNode.d.ts

@@ -0,0 +1,22 @@
+import { EditorConfig, LexicalEditor, LexicalNode, NodeKey, SerializedLexicalNode, Spread, DecoratorNode } from 'lexical';
+import { ReactElement } from 'react';
+export type SerializedExcalidrawNode = Spread<{
+    snapshot: string;
+}, SerializedLexicalNode>;
+export declare class ExcalidrawNode extends DecoratorNode<ReactElement> {
+    __snapshot: string;
+    static getType(): string;
+    static clone(node: ExcalidrawNode): ExcalidrawNode;
+    constructor(snapshot: string, key?: NodeKey);
+    createDOM(_config: EditorConfig): HTMLElement;
+    updateDOM(): boolean;
+    isInline(): boolean;
+    static importJSON(serializedNode: SerializedExcalidrawNode): ExcalidrawNode;
+    exportJSON(): SerializedExcalidrawNode;
+    getSnapshot(): string;
+    setSnapshot(snapshot: string): void;
+    decorate(_editor: LexicalEditor, _config: EditorConfig): ReactElement;
+}
+export declare function $createExcalidrawNode(snapshot: string): ExcalidrawNode;
+export declare function $isExcalidrawNode(node: LexicalNode | null | undefined): node is ExcalidrawNode;
+//# sourceMappingURL=ExcalidrawNode.d.ts.map

package/dist/ExcalidrawNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExcalidrawNode.d.ts","sourceRoot":"","sources":["../src/ExcalidrawNode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EACb,WAAW,EACX,OAAO,EACP,qBAAqB,EACrB,MAAM,EACP,MAAM,SAAS,CAAA;AAChB,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AACvC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,OAAO,CAAA;AAKzC,MAAM,MAAM,wBAAwB,GAAG,MAAM,CAC3C;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,EACpB,qBAAqB,CACtB,CAAA;AAED,qBAAa,cAAe,SAAQ,aAAa,CAAC,YAAY,CAAC;IAC7D,UAAU,EAAE,MAAM,CAAA;IAElB,MAAM,CAAC,OAAO,IAAI,MAAM;IAIxB,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,cAAc,GAAG,cAAc;gBAItC,QAAQ,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO;IAK3C,SAAS,CAAC,OAAO,EAAE,YAAY,GAAG,WAAW;IAM7C,SAAS,IAAI,OAAO;IAIpB,QAAQ,IAAI,OAAO;IAInB,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,wBAAwB,GAAG,cAAc;IAI3E,UAAU,IAAI,wBAAwB;IAStC,WAAW,IAAI,MAAM;IAIrB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAKnC,QAAQ,CAAC,OAAO,EAAE,aAAa,EAAE,OAAO,EAAE,YAAY,GAAG,YAAY;CAKtE;AAED,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc,CAEtE;AAED,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GACnC,IAAI,IAAI,cAAc,CAExB"}

package/dist/ExcalidrawPlugin.d.ts

@@ -0,0 +1,3 @@
+export declare const INSERT_EXCALIDRAW_COMMAND: import('lexical').LexicalCommand<string>;
+export declare function ExcalidrawPlugin(): null;
+//# sourceMappingURL=ExcalidrawPlugin.d.ts.map

package/dist/ExcalidrawPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExcalidrawPlugin.d.ts","sourceRoot":"","sources":["../src/ExcalidrawPlugin.tsx"],"names":[],"mappings":"AAMA,eAAO,MAAM,yBAAyB,0CACM,CAAA;AAE5C,wBAAgB,gBAAgB,SAgB/B"}

package/dist/ExcalidrawRenderer.d.ts

@@ -0,0 +1,3 @@
+export type { ExcalidrawStaticRendererProps as ExcalidrawRendererProps } from './ExcalidrawDisplayRenderer';
+export { ExcalidrawDisplayRenderer as ExcalidrawRenderer } from './ExcalidrawDisplayRenderer';
+//# sourceMappingURL=ExcalidrawRenderer.d.ts.map

package/dist/ExcalidrawRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExcalidrawRenderer.d.ts","sourceRoot":"","sources":["../src/ExcalidrawRenderer.tsx"],"names":[],"mappings":"AAAA,YAAY,EAAE,6BAA6B,IAAI,uBAAuB,EAAE,MAAM,6BAA6B,CAAA;AAC3G,OAAO,EAAE,yBAAyB,IAAI,kBAAkB,EAAE,MAAM,6BAA6B,CAAA"}

package/dist/ExcalidrawSSRRenderer.d.ts

@@ -0,0 +1,6 @@
+import { FC } from 'react';
+export interface ExcalidrawSSRRendererProps {
+    snapshot: string;
+}
+export declare const ExcalidrawSSRRenderer: FC<ExcalidrawSSRRendererProps>;
+//# sourceMappingURL=ExcalidrawSSRRenderer.d.ts.map

package/dist/ExcalidrawSSRRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExcalidrawSSRRenderer.d.ts","sourceRoot":"","sources":["../src/ExcalidrawSSRRenderer.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,OAAO,CAAA;AAG/B,MAAM,WAAW,0BAA0B;IACzC,QAAQ,EAAE,MAAM,CAAA;CACjB;AA+CD,eAAO,MAAM,qBAAqB,EAAE,EAAE,CAAC,0BAA0B,CAQhE,CAAA"}