@dxos/plugin-markdown 0.8.2-main.f11618f → 0.8.2-staging.42af850

package/dist/lib/node/{state-PC7IVXFP.cjs → state-KKDRAG7X.cjs}

@@ -16,12 +16,12 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var state_PC7IVXFP_exports = {};
-__export(state_PC7IVXFP_exports, {
+var state_KKDRAG7X_exports = {};
+__export(state_KKDRAG7X_exports, {
   default: () => state_default
 });
-module.exports = __toCommonJS(state_PC7IVXFP_exports);
-var import_chunk_DZXTXSXX = require("./chunk-DZXTXSXX.cjs");
+module.exports = __toCommonJS(state_KKDRAG7X_exports);
+var import_chunk_IFYSBQE5 = require("./chunk-IFYSBQE5.cjs");
 var import_chunk_ZU5OIHCY = require("./chunk-ZU5OIHCY.cjs");
 var import_app_framework = require("@dxos/app-framework");
 var import_local_storage = require("@dxos/local-storage");
@@ -37,15 +37,15 @@ var state_default = (context) => {
   });
   const editorState = (0, import_react_ui_editor.createEditorStateStore)(`${import_chunk_ZU5OIHCY.MARKDOWN_PLUGIN}/editor`);
   const getViewMode = (id) => {
-    const defaultViewMode = context.requestCapability(import_app_framework.Capabilities.SettingsStore).getStore(import_chunk_ZU5OIHCY.MARKDOWN_PLUGIN).value.defaultViewMode;
+    const defaultViewMode = context.getCapability(import_app_framework.Capabilities.SettingsStore).getStore(import_chunk_ZU5OIHCY.MARKDOWN_PLUGIN).value.defaultViewMode;
     return id && state.values.viewMode[id] || defaultViewMode;
   };
   const setViewMode = (id, viewMode) => state.values.viewMode[id] = viewMode;
-  return (0, import_app_framework.contributes)(import_chunk_DZXTXSXX.MarkdownCapabilities.State, {
+  return (0, import_app_framework.contributes)(import_chunk_IFYSBQE5.MarkdownCapabilities.State, {
     state: state.values,
     editorState,
     getViewMode,
     setViewMode
   });
 };
-//# sourceMappingURL=state-PC7IVXFP.cjs.map
+//# sourceMappingURL=state-KKDRAG7X.cjs.map

package/dist/lib/node/state-KKDRAG7X.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/capabilities/state.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { Capabilities, contributes, type PluginContext } from '@dxos/app-framework';\nimport { LocalStorageStore } from '@dxos/local-storage';\nimport { type EditorViewMode, createEditorStateStore } from '@dxos/react-ui-editor';\n\nimport { MarkdownCapabilities } from './capabilities';\nimport { MARKDOWN_PLUGIN } from '../meta';\nimport { type MarkdownPluginState, type MarkdownSettingsProps } from '../types';\n\nexport default (context: PluginContext) => {\n  const state = new LocalStorageStore<MarkdownPluginState>(MARKDOWN_PLUGIN, { extensionProviders: [], viewMode: {} });\n  state.prop({ key: 'viewMode', type: LocalStorageStore.json<{ [key: string]: EditorViewMode }>() });\n\n  // TODO(wittjosiah): Fold into state.\n  const editorState = createEditorStateStore(`${MARKDOWN_PLUGIN}/editor`);\n\n  const getViewMode = (id: string) => {\n    const defaultViewMode = context\n      .getCapability(Capabilities.SettingsStore)\n      .getStore<MarkdownSettingsProps>(MARKDOWN_PLUGIN)!.value.defaultViewMode;\n    return (id && state.values.viewMode[id]) || defaultViewMode;\n  };\n\n  const setViewMode = (id: string, viewMode: EditorViewMode) => (state.values.viewMode[id] = viewMode);\n\n  // Return object with methods.\n  return contributes(MarkdownCapabilities.State, { state: state.values, editorState, getViewMode, setViewMode });\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAIA,2BAA8D;AAC9D,2BAAkC;AAClC,6BAA4D;AAM5D,IAAA,gBAAe,CAACA,YAAAA;AACd,QAAMC,QAAQ,IAAIC,uCAAuCC,uCAAiB;IAAEC,oBAAoB,CAAA;IAAIC,UAAU,CAAC;EAAE,CAAA;AACjHJ,QAAMK,KAAK;IAAEC,KAAK;IAAYC,MAAMN,uCAAkBO,KAAI;EAAsC,CAAA;AAGhG,QAAMC,kBAAcC,+CAAuB,GAAGR,qCAAAA,SAAwB;AAEtE,QAAMS,cAAc,CAACC,OAAAA;AACnB,UAAMC,kBAAkBd,QACrBe,cAAcC,kCAAaC,aAAa,EACxCC,SAAgCf,qCAAAA,EAAkBgB,MAAML;AAC3D,WAAQD,MAAMZ,MAAMmB,OAAOf,SAASQ,EAAAA,KAAQC;EAC9C;AAEA,QAAMO,cAAc,CAACR,IAAYR,aAA8BJ,MAAMmB,OAAOf,SAASQ,EAAAA,IAAMR;AAG3F,aAAOiB,kCAAYC,2CAAqBC,OAAO;IAAEvB,OAAOA,MAAMmB;IAAQV;IAAaE;IAAaS;EAAY,CAAA;AAC9G;",
+  "names": ["context", "state", "LocalStorageStore", "MARKDOWN_PLUGIN", "extensionProviders", "viewMode", "prop", "key", "type", "json", "editorState", "createEditorStateStore", "getViewMode", "id", "defaultViewMode", "getCapability", "Capabilities", "SettingsStore", "getStore", "value", "values", "setViewMode", "contributes", "MarkdownCapabilities", "State"]
+}

package/dist/lib/node/types/index.cjs

@@ -18,15 +18,15 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var types_exports = {};
 __export(types_exports, {
-  DocumentSchema: () => import_chunk_YHL4JSA6.DocumentSchema,
-  DocumentType: () => import_chunk_YHL4JSA6.DocumentType,
-  MarkdownAction: () => import_chunk_YHL4JSA6.MarkdownAction,
-  MarkdownSettingsSchema: () => import_chunk_YHL4JSA6.MarkdownSettingsSchema,
-  createDocument: () => import_chunk_YHL4JSA6.createDocument,
-  isEditorModel: () => import_chunk_YHL4JSA6.isEditorModel
+  DocumentSchema: () => import_chunk_RQS4KBMG.DocumentSchema,
+  DocumentType: () => import_chunk_RQS4KBMG.DocumentType,
+  MarkdownAction: () => import_chunk_RQS4KBMG.MarkdownAction,
+  MarkdownSettingsSchema: () => import_chunk_RQS4KBMG.MarkdownSettingsSchema,
+  createDocument: () => import_chunk_RQS4KBMG.createDocument,
+  isEditorModel: () => import_chunk_RQS4KBMG.isEditorModel
 });
 module.exports = __toCommonJS(types_exports);
-var import_chunk_YHL4JSA6 = require("../chunk-YHL4JSA6.cjs");
+var import_chunk_RQS4KBMG = require("../chunk-RQS4KBMG.cjs");
 var import_chunk_ZU5OIHCY = require("../chunk-ZU5OIHCY.cjs");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/lib/node/types/index.cjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["index.cjs"],
-  "sourcesContent": ["import {\n  DocumentSchema,\n  DocumentType,\n  MarkdownAction,\n  MarkdownSettingsSchema,\n  createDocument,\n  isEditorModel\n} from \"../chunk-YHL4JSA6.cjs\";\nimport \"../chunk-ZU5OIHCY.cjs\";\nexport {\n  DocumentSchema,\n  DocumentType,\n  MarkdownAction,\n  MarkdownSettingsSchema,\n  createDocument,\n  isEditorModel\n};\n//# sourceMappingURL=index.cjs.map\n"],
+  "sourcesContent": ["import {\n  DocumentSchema,\n  DocumentType,\n  MarkdownAction,\n  MarkdownSettingsSchema,\n  createDocument,\n  isEditorModel\n} from \"../chunk-RQS4KBMG.cjs\";\nimport \"../chunk-ZU5OIHCY.cjs\";\nexport {\n  DocumentSchema,\n  DocumentType,\n  MarkdownAction,\n  MarkdownSettingsSchema,\n  createDocument,\n  isEditorModel\n};\n//# sourceMappingURL=index.cjs.map\n"],
   "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,4BAOO;AACP,4BAAO;",
   "names": []
 }

package/dist/lib/node-esm/MarkdownContainer-UZSLXMWO.mjs

@@ -0,0 +1,589 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import "./chunk-EIUTPXGL.mjs";
+import {
+  MarkdownCapabilities
+} from "./chunk-JXXDCSMW.mjs";
+import {
+  getFallbackName,
+  setFallbackName
+} from "./chunk-6RPARLIK.mjs";
+import {
+  DocumentType
+} from "./chunk-NCMPVEXO.mjs";
+import {
+  MARKDOWN_PLUGIN
+} from "./chunk-RX63ZNML.mjs";
+
+// packages/plugins/plugin-markdown/src/components/MarkdownContainer.tsx
+import { useSignals as _useSignals2 } from "@preact-signals/safe-react/tracking";
+import { Rx } from "@effect-rx/rx-react";
+import React3, { useEffect as useEffect2, useMemo as useMemo4 } from "react";
+import { Capabilities, useAppGraph, useCapabilities as useCapabilities2 } from "@dxos/app-framework";
+import { isInstanceOf } from "@dxos/echo-schema";
+import { fullyQualifiedId as fullyQualifiedId2, getSpace as getSpace2 } from "@dxos/react-client/echo";
+import { DataType } from "@dxos/schema";
+
+// packages/plugins/plugin-markdown/src/components/MarkdownEditor/MarkdownEditor.tsx
+import { useSignals as _useSignals } from "@preact-signals/safe-react/tracking";
+import React, { useMemo as useMemo2, useEffect, useCallback } from "react";
+import { useDropzone } from "react-dropzone";
+import { invariant as invariant2 } from "@dxos/invariant";
+import { useThemeContext, useTranslation } from "@dxos/react-ui";
+import { EditorToolbar, createBasicExtensions, createMarkdownExtensions, createThemeExtensions, dropFile, editorSlots, editorGutter, processEditorPayload, stackItemContentEditorClassNames, useFormattingState, useTextEditor, useEditorToolbarState, addLink } from "@dxos/react-ui-editor";
+import { StackItem } from "@dxos/react-ui-stack";
+import { isNotFalsy, isNonNullable } from "@dxos/util";
+
+// packages/plugins/plugin-markdown/src/hooks/useSelectCurrentThread.tsx
+import { EditorView } from "@codemirror/view";
+import { Schema } from "effect";
+import { useMemo } from "react";
+import { createResolver, LayoutAction, useIntentResolver } from "@dxos/app-framework";
+import { invariant } from "@dxos/invariant";
+import { Cursor, setSelection } from "@dxos/react-ui-editor";
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/plugins/plugin-markdown/src/hooks/useSelectCurrentThread.tsx";
+var useSelectCurrentThread = (editorView, documentId2) => {
+  const scrollIntoViewResolver = useMemo(() => createResolver({
+    intent: LayoutAction.UpdateLayout,
+    position: "hoist",
+    filter: (data) => {
+      if (!Schema.is(LayoutAction.ScrollIntoView.fields.input)(data)) {
+        return false;
+      }
+      return !!editorView && data.subject === documentId2 && !!data.options?.cursor;
+    },
+    resolve: ({ options: { cursor } }) => {
+      invariant(editorView, "Editor view is not defined.", {
+        F: __dxlog_file,
+        L: 32,
+        S: void 0,
+        A: [
+          "editorView",
+          "'Editor view is not defined.'"
+        ]
+      });
+      const range = Cursor.getRangeFromCursor(editorView.state, cursor);
+      if (range) {
+        const selection = editorView.state.selection.main.from !== range.from ? {
+          anchor: range.from
+        } : void 0;
+        const effects = [
+          // NOTE: This does not use the DOM scrollIntoView function.
+          EditorView.scrollIntoView(range.from, {
+            y: "start",
+            yMargin: 96
+          })
+        ];
+        if (selection) {
+          effects.push(setSelection.of({
+            current: documentId2
+          }));
+        }
+        editorView.dispatch({
+          effects,
+          selection: selection ? {
+            anchor: range.from
+          } : void 0
+        });
+      }
+    }
+  }), [
+    documentId2,
+    editorView
+  ]);
+  useIntentResolver(MARKDOWN_PLUGIN, scrollIntoViewResolver);
+};
+
+// packages/plugins/plugin-markdown/src/components/MarkdownEditor/MarkdownEditor.tsx
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/plugins/plugin-markdown/src/components/MarkdownEditor/MarkdownEditor.tsx";
+var MarkdownEditor = ({ id, role = "article", initialValue, extensions, extensionProviders, scrollPastEnd, toolbar, customActions, viewMode, editorStateStore, onFileUpload, onViewModeChange }) => {
+  var _effect = _useSignals();
+  try {
+    const { t } = useTranslation(MARKDOWN_PLUGIN);
+    const { themeMode } = useThemeContext();
+    const toolbarState = useEditorToolbarState({
+      viewMode
+    });
+    const formattingObserver = useFormattingState(toolbarState);
+    const { scrollTo, selection } = useMemo2(() => editorStateStore?.getState(id) ?? {}, [
+      id
+    ]);
+    const providerExtensions = useMemo2(() => extensionProviders?.flatMap((provider) => provider({})).filter(isNonNullable), [
+      extensionProviders
+    ]);
+    const handleDrop = async (view, { files }) => {
+      const file = files[0];
+      const info = file && onFileUpload ? await onFileUpload(file) : void 0;
+      if (info) {
+        processEditorPayload(view, {
+          type: "image",
+          data: info.url
+        });
+      }
+    };
+    const { parentRef, view: editorView, focusAttributes } = useTextEditor(() => ({
+      initialValue,
+      extensions: [
+        formattingObserver,
+        createBasicExtensions({
+          readOnly: viewMode === "readonly",
+          placeholder: t("editor placeholder"),
+          scrollPastEnd: role === "section" ? false : scrollPastEnd
+        }),
+        createMarkdownExtensions({
+          themeMode
+        }),
+        createThemeExtensions({
+          themeMode,
+          syntaxHighlighting: true,
+          slots: editorSlots
+        }),
+        editorGutter,
+        role !== "section" && onFileUpload && dropFile({
+          onDrop: handleDrop
+        }),
+        providerExtensions,
+        extensions
+      ].filter(isNotFalsy),
+      ...role !== "section" && {
+        id,
+        scrollTo,
+        selection,
+        // TODO(wittjosiah): Autofocus based on layout is racy.
+        // autoFocus: layoutPlugin?.provides.layout ? layoutPlugin?.provides.layout.scrollIntoView === id : true,
+        moveToEndOfLine: true
+      }
+    }), [
+      id,
+      formattingObserver,
+      viewMode,
+      themeMode,
+      extensions,
+      providerExtensions
+    ]);
+    useTest(editorView);
+    useSelectCurrentThread(editorView, id);
+    const { acceptedFiles, getInputProps, open } = useDropzone({
+      multiple: false,
+      noDrag: true,
+      accept: {
+        "image/*": [
+          ".jpg",
+          ".jpeg",
+          ".png",
+          ".gif"
+        ]
+      }
+    });
+    useEffect(() => {
+      if (editorView && onFileUpload && acceptedFiles.length) {
+        requestAnimationFrame(async () => {
+          const f = acceptedFiles[0];
+          const file = new File([
+            f
+          ], f.name, {
+            type: f.type,
+            lastModified: f.lastModified
+          });
+          const info = await onFileUpload(file);
+          if (info) {
+            addLink({
+              url: info.url,
+              image: true
+            })(editorView);
+          }
+        });
+      }
+    }, [
+      acceptedFiles,
+      editorView,
+      onFileUpload
+    ]);
+    const getView = useCallback(() => {
+      invariant2(editorView, void 0, {
+        F: __dxlog_file2,
+        L: 165,
+        S: void 0,
+        A: [
+          "editorView",
+          ""
+        ]
+      });
+      return editorView;
+    }, [
+      editorView
+    ]);
+    const handleViewModeChange = useCallback((mode) => onViewModeChange?.(id, mode), [
+      id,
+      onViewModeChange
+    ]);
+    const handleImageUpload = useCallback(() => {
+      if (onFileUpload) {
+        open();
+      }
+    }, [
+      onFileUpload
+    ]);
+    return /* @__PURE__ */ React.createElement(StackItem.Content, {
+      toolbar: !!toolbar
+    }, toolbar && /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(EditorToolbar, {
+      attendableId: id,
+      role,
+      state: toolbarState,
+      customActions,
+      getView,
+      image: handleImageUpload,
+      viewMode: handleViewModeChange
+    }), /* @__PURE__ */ React.createElement("input", getInputProps())), /* @__PURE__ */ React.createElement("div", {
+      role: "none",
+      ref: parentRef,
+      "data-testid": "composer.markdownRoot",
+      "data-toolbar": toolbar ? "enabled" : "disabled",
+      className: stackItemContentEditorClassNames(role),
+      "data-popover-collision-boundary": true,
+      ...focusAttributes
+    }));
+  } finally {
+    _effect.f();
+  }
+};
+var useTest = (view) => {
+  useEffect(() => {
+    const composer = window.composer;
+    if (composer) {
+      composer.editorView = view;
+    }
+  }, [
+    view
+  ]);
+};
+
+// packages/plugins/plugin-markdown/src/extensions.tsx
+import React2, { useMemo as useMemo3 } from "react";
+import { createRoot } from "react-dom/client";
+import { createIntent, LayoutAction as LayoutAction2, useCapabilities, useIntentDispatcher } from "@dxos/app-framework";
+import { invariant as invariant3 } from "@dxos/invariant";
+import { createDocAccessor, fullyQualifiedId, getSpace } from "@dxos/react-client/echo";
+import { useIdentity } from "@dxos/react-client/halo";
+import { Icon, ThemeProvider } from "@dxos/react-ui";
+import { InputModeExtensions, createDataExtensions, autocomplete, decorateMarkdown, folding, formattingKeymap, linkTooltip, listener, preview, selectionState, typewriter, EditorView as EditorView2, documentId, Cursor as Cursor2 } from "@dxos/react-ui-editor";
+import { defaultTx } from "@dxos/react-ui-theme";
+import { isNotFalsy as isNotFalsy2 } from "@dxos/util";
+var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/plugins/plugin-markdown/src/extensions.tsx";
+var useExtensions = ({ document, id, text, settings, selectionManager, viewMode, editorStateStore }) => {
+  const { dispatchPromise: dispatch } = useIntentDispatcher();
+  const identity = useIdentity();
+  const space = getSpace(document) ?? getSpace(text);
+  const baseExtensions = useMemo3(() => createBaseExtensions({
+    document,
+    id,
+    text,
+    settings,
+    selectionManager,
+    viewMode,
+    dispatch
+  }), [
+    document,
+    id,
+    text,
+    viewMode,
+    dispatch,
+    settings,
+    settings.editorInputMode,
+    settings.folding,
+    settings.numberedHeadings,
+    settings.debug,
+    settings.typewriter,
+    selectionManager
+  ]);
+  const extensionProviders = useCapabilities(MarkdownCapabilities.Extensions);
+  const pluginExtensions = useMemo3(() => {
+    if (!document) {
+      return [];
+    }
+    return extensionProviders.flat().reduce((acc, provider) => {
+      const extension = typeof provider === "function" ? provider({
+        document
+      }) : provider;
+      if (extension) {
+        acc.push(extension);
+      }
+      return acc;
+    }, []);
+  }, [
+    extensionProviders,
+    document
+  ]);
+  return useMemo3(() => [
+    // NOTE: Data extensions must be first so that automerge is updated before other extensions compute their state.
+    document && createDataExtensions({
+      id: document.id,
+      text: document.content.target && createDocAccessor(document.content.target, [
+        "content"
+      ]),
+      space,
+      identity
+    }),
+    text && id && createDataExtensions({
+      id,
+      text: createDocAccessor(text, [
+        "content"
+      ]),
+      space,
+      identity
+    }),
+    selectionState(editorStateStore),
+    document && listener({
+      onChange: (text2) => setFallbackName(document, text2)
+    }),
+    baseExtensions,
+    pluginExtensions
+  ].filter(isNotFalsy2), [
+    baseExtensions,
+    pluginExtensions,
+    document,
+    document?.content?.target,
+    text,
+    id,
+    space,
+    identity
+  ]);
+};
+var createBaseExtensions = ({ document, id, dispatch, settings, selectionManager, query, viewMode }) => {
+  const extensions = [
+    selectionManager && selectionChange(selectionManager),
+    settings.editorInputMode && InputModeExtensions[settings.editorInputMode],
+    settings.folding && folding()
+  ].filter(isNotFalsy2);
+  if (viewMode !== "source") {
+    extensions.push(...[
+      formattingKeymap(),
+      decorateMarkdown({
+        selectionChangeDelay: 100,
+        numberedHeadings: settings.numberedHeadings ? {
+          from: 2
+        } : void 0,
+        // TODO(wittjosiah): For internal links, consider ignoring the link text and rendering the label of the object being linked to.
+        renderLinkButton: dispatch && (document || id) ? createLinkRenderer((id2) => {
+          void dispatch(createIntent(LayoutAction2.Open, {
+            part: "main",
+            subject: [
+              id2
+            ],
+            options: {
+              pivotId: document ? fullyQualifiedId(document) : id2
+            }
+          }));
+        }) : void 0
+      }),
+      linkTooltip(renderLinkTooltip),
+      preview()
+    ]);
+  }
+  if (query) {
+    extensions.push(autocomplete({
+      onSearch: (text) => {
+        return query.objects.map((object) => object.name?.length && object.id !== document?.id ? {
+          label: object.name,
+          // TODO(burdon): Factor out URL builder.
+          apply: `[${object.name}](/${fullyQualifiedId(object)})`
+        } : void 0).filter(isNotFalsy2);
+      }
+    }));
+  }
+  if (settings.debug) {
+    const items = settings.typewriter?.split(/[,\n]/) ?? "";
+    if (items) {
+      extensions.push(typewriter({
+        items
+      }));
+    }
+  }
+  return extensions;
+};
+var selectionChange = (selectionManager) => {
+  return EditorView2.updateListener.of((update) => {
+    if (update.selectionSet) {
+      const id = update.state.facet(documentId);
+      const cursorConverter = update.state.facet(Cursor2.converter);
+      const selection = update.state.selection;
+      const ranges = selection.ranges.map((range) => ({
+        from: cursorConverter.toCursor(range.from),
+        to: cursorConverter.toCursor(range.to)
+      })).filter(({ from, to }) => to > from);
+      selectionManager.updateMultiRange(id, ranges);
+    }
+  });
+};
+var style = {
+  hover: "rounded-sm text-primary-500 hover:text-primary-600 dark:text-primary-500 hover:dark:text-primary-400",
+  icon: "inline-block leading-none mis-1 cursor-pointer"
+};
+var createLinkRenderer = (onSelectObject) => (el, { url }) => {
+  const isInternal = url.startsWith("/") || // TODO(wittjosiah): This should probably be parsed out on paste?
+  url.startsWith(window.location.origin);
+  const options = isInternal ? {
+    onClick: () => {
+      const qualifiedId = url.split("/").at(-1);
+      invariant3(qualifiedId, "Invalid link format.", {
+        F: __dxlog_file3,
+        L: 281,
+        S: void 0,
+        A: [
+          "qualifiedId",
+          "'Invalid link format.'"
+        ]
+      });
+      onSelectObject(qualifiedId);
+    }
+  } : {
+    href: url,
+    rel: "noreferrer",
+    target: "_blank"
+  };
+  renderRoot(el, /* @__PURE__ */ React2.createElement("a", {
+    ...options,
+    className: style.hover
+  }, /* @__PURE__ */ React2.createElement(Icon, {
+    icon: isInternal ? "ph--arrow-square-down--bold" : "ph--arrow-square-out--bold",
+    size: 4,
+    classNames: style.icon
+  })));
+};
+var renderLinkTooltip = (el, { url }) => {
+  const web = new URL(url);
+  renderRoot(el, /* @__PURE__ */ React2.createElement("a", {
+    href: url,
+    rel: "noreferrer",
+    target: "_blank",
+    className: style.hover
+  }, web.origin, /* @__PURE__ */ React2.createElement(Icon, {
+    icon: "ph--arrow-square-out--bold",
+    size: 4,
+    classNames: style.icon
+  })));
+};
+var renderRoot = (root, node) => {
+  createRoot(root).render(/* @__PURE__ */ React2.createElement(ThemeProvider, {
+    tx: defaultTx
+  }, node));
+  return root;
+};
+
+// packages/plugins/plugin-markdown/src/components/MarkdownContainer.tsx
+var MarkdownContainer = ({ id, role, object, settings, selectionManager, viewMode, editorStateStore, onViewModeChange }) => {
+  var _effect = _useSignals2();
+  try {
+    const scrollPastEnd = role === "article";
+    const doc = isInstanceOf(DocumentType, object) ? object : void 0;
+    const text = isInstanceOf(DataType.Text, object) ? object : void 0;
+    const extensions = useExtensions({
+      document: doc,
+      text,
+      id,
+      settings,
+      selectionManager,
+      viewMode,
+      editorStateStore
+    });
+    if (doc) {
+      return /* @__PURE__ */ React3.createElement(DocumentEditor, {
+        id: fullyQualifiedId2(object),
+        role,
+        document: doc,
+        extensions,
+        viewMode,
+        settings,
+        scrollPastEnd,
+        onViewModeChange
+      });
+    } else if (text) {
+      return /* @__PURE__ */ React3.createElement(MarkdownEditor, {
+        id,
+        role,
+        initialValue: text.content,
+        extensions,
+        viewMode,
+        toolbar: settings.toolbar,
+        inputMode: settings.editorInputMode,
+        scrollPastEnd,
+        onViewModeChange
+      });
+    } else {
+      return /* @__PURE__ */ React3.createElement(MarkdownEditor, {
+        id,
+        role,
+        initialValue: object.text,
+        extensions,
+        viewMode,
+        toolbar: settings.toolbar,
+        inputMode: settings.editorInputMode,
+        scrollPastEnd,
+        onViewModeChange
+      });
+    }
+  } finally {
+    _effect.f();
+  }
+};
+var DocumentEditor = ({ id, document: doc, settings, viewMode, ...props }) => {
+  var _effect = _useSignals2();
+  try {
+    const space = getSpace2(doc);
+    useEffect2(() => {
+      if (typeof doc.fallbackName === "string") {
+        return;
+      }
+      const fallbackName = doc.content?.target?.content ? getFallbackName(doc.content.target.content) : void 0;
+      if (fallbackName) {
+        doc.fallbackName = fallbackName;
+      }
+    }, [
+      doc,
+      doc.content
+    ]);
+    const [upload] = useCapabilities2(Capabilities.FileUploader);
+    const handleFileUpload = useMemo4(() => {
+      if (space === void 0 || upload === void 0) {
+        return void 0;
+      }
+      return async (file) => upload(file, space);
+    }, [
+      space,
+      upload
+    ]);
+    const { graph } = useAppGraph();
+    const customActions = useMemo4(() => {
+      return Rx.make((get) => {
+        const actions = get(graph.actions(id));
+        const nodes = actions.filter((action) => action.properties.disposition === "toolbar");
+        return {
+          nodes,
+          edges: nodes.map((node) => ({
+            source: "root",
+            target: node.id
+          }))
+        };
+      });
+    }, [
+      graph
+    ]);
+    return /* @__PURE__ */ React3.createElement(MarkdownEditor, {
+      id,
+      initialValue: doc.content?.target?.content,
+      viewMode,
+      toolbar: settings.toolbar,
+      customActions,
+      inputMode: settings.editorInputMode,
+      onFileUpload: handleFileUpload,
+      ...props
+    });
+  } finally {
+    _effect.f();
+  }
+};
+var MarkdownContainer_default = MarkdownContainer;
+export {
+  DocumentEditor,
+  MarkdownContainer_default as default
+};
+//# sourceMappingURL=MarkdownContainer-UZSLXMWO.mjs.map