@dxos/plugin-thread 0.6.8-main.046e6cf

package/dist/lib/node/index.cjs

@@ -0,0 +1,1067 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var node_exports = {};
+__export(node_exports, {
+  ThreadAction: () => import_chunk_WPPLQNMJ.ThreadAction,
+  ThreadPlugin: () => ThreadPlugin,
+  default: () => src_default,
+  useAnalyticsCallback: () => import_chunk_3VAAUEU5.useAnalyticsCallback,
+  useOnEditAnalytics: () => import_chunk_3VAAUEU5.useOnEditAnalytics,
+  useStatus: () => import_chunk_3VAAUEU5.useStatus
+});
+module.exports = __toCommonJS(node_exports);
+var import_chunk_WPPLQNMJ = require("./chunk-WPPLQNMJ.cjs");
+var import_chunk_3VAAUEU5 = require("./chunk-3VAAUEU5.cjs");
+var import_chunk_BWBONZGU = require("./chunk-BWBONZGU.cjs");
+var import_react = require("@phosphor-icons/react");
+var import_signals_core = require("@preact/signals-core");
+var import_react2 = __toESM(require("react"));
+var import_app_framework = require("@dxos/app-framework");
+var import_echo_schema = require("@dxos/echo-schema");
+var import_echo_schema2 = require("@dxos/echo-schema");
+var import_local_storage = require("@dxos/local-storage");
+var import_plugin_attention = require("@dxos/plugin-attention");
+var import_plugin_client = require("@dxos/plugin-client");
+var import_plugin_graph = require("@dxos/plugin-graph");
+var import_types = require("@dxos/plugin-markdown/types");
+var import_meta = require("@dxos/plugin-observability/meta");
+var import_plugin_space = require("@dxos/plugin-space");
+var import_types2 = require("@dxos/plugin-space/types");
+var import_echo = require("@dxos/react-client/echo");
+var import_react_ui = require("@dxos/react-ui");
+var import_react_ui_attention = require("@dxos/react-ui-attention");
+var import_react_ui_editor = require("@dxos/react-ui-editor");
+var import_react_ui_thread = require("@dxos/react-ui-thread");
+var import_util = require("@dxos/util");
+var import_react3 = __toESM(require("react"));
+var import_react4 = __toESM(require("react"));
+var import_plugin_settings = require("@dxos/plugin-settings");
+var import_react_ui2 = require("@dxos/react-ui");
+var import_react5 = require("@phosphor-icons/react");
+var import_react6 = __toESM(require("react"));
+var import_echo_schema3 = require("@dxos/echo-schema");
+var import_types3 = require("@dxos/plugin-space/types");
+var import_echo2 = require("@dxos/react-client/echo");
+var import_halo = require("@dxos/react-client/halo");
+var import_react_ui3 = require("@dxos/react-ui");
+var import_react_ui_editor2 = require("@dxos/react-ui-editor");
+var import_react_ui_theme = require("@dxos/react-ui-theme");
+var import_react_ui_thread2 = require("@dxos/react-ui-thread");
+var import_util2 = require("@dxos/util");
+var import_react7 = require("@phosphor-icons/react");
+var import_react8 = __toESM(require("react"));
+var import_react_ui4 = require("@dxos/react-ui");
+var import_react_ui_deck = require("@dxos/react-ui-deck");
+var import_react_ui_theme2 = require("@dxos/react-ui-theme");
+var ThreadSettings = ({ settings }) => {
+  const { t } = (0, import_react_ui2.useTranslation)(import_chunk_BWBONZGU.THREAD_PLUGIN);
+  return /* @__PURE__ */ import_react4.default.createElement(import_react4.default.Fragment, null, /* @__PURE__ */ import_react4.default.createElement(import_plugin_settings.SettingsValue, {
+    label: t("settings standalone label")
+  }, /* @__PURE__ */ import_react4.default.createElement(import_react_ui2.Input.Switch, {
+    checked: settings.standalone,
+    onCheckedChange: (checked) => settings.standalone = !!checked
+  })));
+};
+var sizeClass = (0, import_react_ui_theme.getSize)(4);
+var ToggleResolvedButton = ({ isResolved, onResolve }) => {
+  const { t } = (0, import_react_ui3.useTranslation)(import_chunk_BWBONZGU.THREAD_PLUGIN);
+  const label = t(isResolved ? "mark as unresolved label" : "mark as resolved label");
+  return /* @__PURE__ */ import_react6.default.createElement(import_react_ui3.Tooltip.Root, null, /* @__PURE__ */ import_react6.default.createElement(import_react_ui3.Tooltip.Trigger, {
+    asChild: true
+  }, /* @__PURE__ */ import_react6.default.createElement(import_react_ui3.Button, {
+    variant: "ghost",
+    "data-testid": "thread.toggle-resolved",
+    onClick: onResolve,
+    classNames: [
+      "min-bs-0 p-1",
+      !isResolved && import_react_ui_theme.hoverableControlItem
+    ]
+  }, /* @__PURE__ */ import_react6.default.createElement("span", {
+    className: "sr-only"
+  }, label), isResolved ? /* @__PURE__ */ import_react6.default.createElement(import_react5.CheckCircle, {
+    className: sizeClass,
+    weight: "fill"
+  }) : /* @__PURE__ */ import_react6.default.createElement(import_react5.CheckCircle, {
+    className: sizeClass
+  }))), /* @__PURE__ */ import_react6.default.createElement(import_react_ui3.Tooltip.Portal, null, /* @__PURE__ */ import_react6.default.createElement(import_react_ui3.Tooltip.Content, {
+    classNames: "z-[21]"
+  }, label, /* @__PURE__ */ import_react6.default.createElement(import_react_ui3.Tooltip.Arrow, null))));
+};
+var DeleteThreadButton = ({ onDelete }) => {
+  const { t } = (0, import_react_ui3.useTranslation)(import_chunk_BWBONZGU.THREAD_PLUGIN);
+  const label = t("delete thread label");
+  return /* @__PURE__ */ import_react6.default.createElement(import_react_ui3.Tooltip.Root, null, /* @__PURE__ */ import_react6.default.createElement(import_react_ui3.Tooltip.Trigger, {
+    asChild: true
+  }, /* @__PURE__ */ import_react6.default.createElement(import_react_ui3.Button, {
+    variant: "ghost",
+    "data-testid": "thread.delete",
+    onClick: onDelete,
+    classNames: [
+      "min-bs-0 p-1",
+      import_react_ui_theme.hoverableControlItem
+    ]
+  }, /* @__PURE__ */ import_react6.default.createElement("span", {
+    className: "sr-only"
+  }, label), /* @__PURE__ */ import_react6.default.createElement(import_react5.X, {
+    className: sizeClass
+  }))), /* @__PURE__ */ import_react6.default.createElement(import_react_ui3.Tooltip.Portal, null, /* @__PURE__ */ import_react6.default.createElement(import_react_ui3.Tooltip.Content, {
+    classNames: "z-[21]"
+  }, label, /* @__PURE__ */ import_react6.default.createElement(import_react_ui3.Tooltip.Arrow, null))));
+};
+var CommentContainer = ({ thread, detached, context, current, autoFocusTextbox, onAttend, onThreadDelete, onMessageDelete, onResolve, onComment }) => {
+  const identity = (0, import_halo.useIdentity)();
+  const space = (0, import_echo2.getSpace)(thread);
+  const members = (0, import_echo2.useMembers)(space?.key);
+  const activity = (0, import_chunk_3VAAUEU5.useStatus)(space, thread.id);
+  const { t } = (0, import_react_ui3.useTranslation)(import_chunk_BWBONZGU.THREAD_PLUGIN);
+  const threadScrollRef = (0, import_react6.useRef)(null);
+  const [autoFocus, setAutoFocus] = (0, import_react6.useState)(!!autoFocusTextbox);
+  const { themeMode } = (0, import_react_ui3.useThemeContext)();
+  const textboxMetadata = (0, import_chunk_3VAAUEU5.getMessageMetadata)(thread.id, identity);
+  const [_count, _setCount] = (0, import_react6.useState)(0);
+  const rerenderEditor = () => _setCount((count) => count + 1);
+  const messageRef = (0, import_react6.useRef)("");
+  const extensions = (0, import_react6.useMemo)(() => [
+    (0, import_react_ui_editor2.createBasicExtensions)({
+      placeholder: t("message placeholder")
+    }),
+    (0, import_react_ui_editor2.createThemeExtensions)({
+      themeMode
+    }),
+    (0, import_react_ui_editor2.listener)({
+      onChange: (text) => messageRef.current = text
+    }),
+    import_chunk_3VAAUEU5.command
+  ], [
+    _count
+  ]);
+  (0, import_react6.useEffect)(() => {
+    setAutoFocus(!!autoFocusTextbox);
+  }, [
+    autoFocusTextbox
+  ]);
+  const scrollToEnd = (behavior) => setTimeout(() => threadScrollRef.current?.scrollIntoView({
+    behavior,
+    block: "end"
+  }), 10);
+  const handleCreate = (0, import_react6.useCallback)(() => {
+    if (!messageRef.current) {
+      return false;
+    }
+    thread.messages.push((0, import_echo_schema3.create)(import_types3.MessageType, {
+      sender: {
+        identityKey: identity.identityKey.toHex()
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      text: messageRef.current,
+      context
+    }));
+    onComment?.(thread);
+    messageRef.current = "";
+    setAutoFocus(true);
+    scrollToEnd("instant");
+    rerenderEditor();
+    return true;
+  }, [
+    thread,
+    identity
+  ]);
+  const handleDeleteMessage = (id) => onMessageDelete?.(id);
+  return /* @__PURE__ */ import_react6.default.createElement(import_react_ui_thread2.Thread, {
+    onClickCapture: onAttend,
+    onFocusCapture: onAttend,
+    current,
+    id: thread.id
+  }, /* @__PURE__ */ import_react6.default.createElement("div", {
+    role: "none",
+    className: (0, import_react_ui_theme.mx)("col-span-2 grid grid-cols-[var(--rail-size)_1fr_min-content]", import_react_ui_theme.hoverableControls, import_react_ui_theme.hoverableFocusedWithinControls)
+  }, detached ? /* @__PURE__ */ import_react6.default.createElement(import_react_ui3.Tooltip.Root, null, /* @__PURE__ */ import_react6.default.createElement(import_react_ui3.Tooltip.Trigger, {
+    asChild: true
+  }, /* @__PURE__ */ import_react6.default.createElement(import_react_ui_thread2.ThreadHeading, {
+    detached: true
+  }, thread.name ?? t("thread title placeholder"))), /* @__PURE__ */ import_react6.default.createElement(import_react_ui3.Tooltip.Portal, null, /* @__PURE__ */ import_react6.default.createElement(import_react_ui3.Tooltip.Content, {
+    classNames: "z-[21]",
+    side: "top"
+  }, t("detached thread label"), /* @__PURE__ */ import_react6.default.createElement(import_react_ui3.Tooltip.Arrow, null)))) : /* @__PURE__ */ import_react6.default.createElement(import_react_ui_thread2.ThreadHeading, null, thread.name ?? t("thread title placeholder")), /* @__PURE__ */ import_react6.default.createElement("div", {
+    className: "flex flex-row items-center pli-1"
+  }, thread.status === "staged" && /* @__PURE__ */ import_react6.default.createElement(import_react_ui3.Tag, {
+    palette: "neutral"
+  }, t("draft button")), onResolve && !(thread?.status === "staged") && /* @__PURE__ */ import_react6.default.createElement(ToggleResolvedButton, {
+    isResolved: thread?.status === "resolved",
+    onResolve
+  }), onThreadDelete && /* @__PURE__ */ import_react6.default.createElement(DeleteThreadButton, {
+    onDelete: onThreadDelete
+  }))), thread.messages.filter(import_util2.nonNullable).map((message) => /* @__PURE__ */ import_react6.default.createElement(import_chunk_3VAAUEU5.MessageContainer, {
+    key: message.id,
+    message,
+    members,
+    onDelete: handleDeleteMessage
+  })), /* @__PURE__ */ import_react6.default.createElement(import_react_ui_thread2.MessageTextbox, {
+    extensions,
+    autoFocus,
+    onSend: handleCreate,
+    ...textboxMetadata
+  }), /* @__PURE__ */ import_react6.default.createElement(import_react_ui_thread2.ThreadFooter, {
+    activity
+  }, t("activity message")), /* @__PURE__ */ import_react6.default.createElement("div", {
+    role: "none",
+    className: "bs-px -mbs-px",
+    ref: threadScrollRef
+  }));
+};
+var CommentsHeading = ({ attendableId }) => {
+  const { t } = (0, import_react_ui4.useTranslation)(import_chunk_BWBONZGU.THREAD_PLUGIN);
+  return /* @__PURE__ */ import_react8.default.createElement("div", {
+    role: "none",
+    className: "flex items-center"
+  }, /* @__PURE__ */ import_react8.default.createElement(import_react_ui_deck.PlankHeading.Button, {
+    attendableId
+  }, /* @__PURE__ */ import_react8.default.createElement(import_react7.Quotes, import_react_ui_deck.plankHeadingIconProps)), /* @__PURE__ */ import_react8.default.createElement(import_react_ui_deck.PlankHeading.Label, {
+    attendableId
+  }, t("comments heading")));
+};
+var CommentsContainer = ({ threads, detached = [], currentId, autoFocusCurrentTextbox, showResolvedThreads, onThreadAttend, onThreadDelete, onMessageDelete, onThreadToggleResolved, ...props }) => {
+  const { t } = (0, import_react_ui4.useTranslation)(import_chunk_BWBONZGU.THREAD_PLUGIN);
+  const filteredThreads = showResolvedThreads ? threads : threads.filter((thread) => !(thread?.status === "resolved"));
+  (0, import_react8.useEffect)(() => {
+    if (currentId) {
+      document.getElementById(currentId)?.scrollIntoView({
+        behavior: "smooth",
+        block: "end"
+      });
+    }
+  }, [
+    currentId
+  ]);
+  return /* @__PURE__ */ import_react8.default.createElement(import_react8.default.Fragment, null, filteredThreads.length > 0 ? filteredThreads.map((thread) => /* @__PURE__ */ import_react8.default.createElement(CommentContainer, {
+    key: thread.id,
+    thread,
+    current: currentId === thread.id,
+    detached: detached.includes(thread.id),
+    autoFocusTextbox: autoFocusCurrentTextbox && currentId === thread.id,
+    ...onThreadAttend && {
+      onAttend: () => onThreadAttend(thread)
+    },
+    ...onThreadDelete && {
+      onThreadDelete: () => onThreadDelete(thread)
+    },
+    ...onMessageDelete && {
+      onMessageDelete: (messageId) => onMessageDelete(thread, messageId)
+    },
+    ...onThreadToggleResolved && {
+      onResolve: () => onThreadToggleResolved(thread)
+    },
+    ...props
+  })) : /* @__PURE__ */ import_react8.default.createElement("div", {
+    role: "alert",
+    className: (0, import_react_ui_theme2.mx)(import_react_ui_theme2.descriptionText, "place-self-center border border-dashed border-neutral-400/50 rounded-lg text-center p-4 m-4")
+  }, /* @__PURE__ */ import_react8.default.createElement("h2", {
+    className: "mbe-2 font-medium text-base"
+  }, t("no comments title")), /* @__PURE__ */ import_react8.default.createElement("p", null, /* @__PURE__ */ import_react8.default.createElement(import_react_ui4.Trans, {
+    t,
+    i18nKey: "no comments message",
+    components: {
+      commentIcon: /* @__PURE__ */ import_react8.default.createElement(import_react7.ChatText, {
+        className: "inline-block"
+      })
+    }
+  }))));
+};
+var ThreadMain = import_react3.default.lazy(() => import("./ThreadMain-XP4YSF7U.cjs"));
+var ThreadArticle = import_react3.default.lazy(() => import("./ThreadArticle-CSENFNNT.cjs"));
+var translations_default = [
+  {
+    "en-US": {
+      [import_chunk_BWBONZGU.THREAD_PLUGIN]: {
+        "plugin name": "Threads",
+        "channel name placeholder": "New channel",
+        "channel title label": "Title",
+        "delete channel label": "Delete channel",
+        "create channel label": "Create channel",
+        "message placeholder": "Reply\u2026",
+        "settings standalone label": "Enable channel creation (experimental)",
+        "activity message": "Processing\u2026",
+        "anonymous label": "Anonymous",
+        "delete message block label": "Delete message block",
+        "detached thread label": "Referenced content was removed",
+        "delete thread label": "Delete thread",
+        "thread deleted label": "You deleted a thread.",
+        "message deleted label": "You deleted a message.",
+        "comments heading": "Comments",
+        "chat heading": "Chat",
+        "draft button": "DRAFT",
+        "no comments title": "No comments (yet)",
+        "no comments message": "To start a comment thread, select a range of text in a document and click the <commentIcon></commentIcon> Create comment button in the toolbar.",
+        "toggle show resolved": "Show resolved",
+        "unnamed object threads label": "Threads",
+        "mark as resolved label": "Mark as resolved",
+        "mark as unresolved label": "Mark as unresolved",
+        "save message label": "Save",
+        "edit message label": "Edit",
+        "delete message label": "Delete message"
+      }
+    }
+  }
+];
+var initialViewState = {
+  showResolvedThreads: false
+};
+var ThreadPlugin = () => {
+  const settings = new import_local_storage.LocalStorageStore(import_chunk_BWBONZGU.THREAD_PLUGIN);
+  const state = (0, import_echo_schema2.create)({
+    staging: {}
+  });
+  const viewStore = (0, import_echo_schema2.create)({});
+  const getViewState = (subjectId) => {
+    if (!viewStore[subjectId]) {
+      viewStore[subjectId] = {
+        ...initialViewState
+      };
+    }
+    return viewStore[subjectId];
+  };
+  let attentionPlugin;
+  let navigationPlugin;
+  let intentPlugin;
+  let dispatch;
+  const unsubscribeCallbacks = [];
+  return {
+    meta: import_chunk_BWBONZGU.meta_default,
+    ready: async (plugins) => {
+      settings.prop({
+        key: "standalone",
+        type: import_local_storage.LocalStorageStore.bool({
+          allowUndefined: true
+        })
+      });
+      attentionPlugin = (0, import_app_framework.resolvePlugin)(plugins, import_plugin_attention.parseAttentionPlugin);
+      navigationPlugin = (0, import_app_framework.resolvePlugin)(plugins, import_app_framework.parseNavigationPlugin);
+      intentPlugin = (0, import_app_framework.resolvePlugin)(plugins, import_app_framework.parseIntentPlugin);
+      dispatch = intentPlugin?.provides.intent.dispatch;
+      const graphPlugin = (0, import_app_framework.resolvePlugin)(plugins, import_app_framework.parseGraphPlugin);
+      const client = (0, import_app_framework.resolvePlugin)(plugins, import_plugin_client.parseClientPlugin)?.provides.client;
+      if (!client) {
+        return;
+      }
+      const channelsQuery = client.spaces.query(import_echo.Filter.schema(import_types2.ChannelType));
+      const queryUnsubscribe = channelsQuery.subscribe();
+      const unsubscribe = (0, import_signals_core.effect)(() => {
+        const attention = attentionPlugin?.provides.attention;
+        if (!attention?.attended) {
+          return;
+        }
+        const firstAttendedNodeWithComments = Array.from(attention.attended).map((id) => graphPlugin?.provides.graph.findNode(id)).find((node) => node?.data instanceof import_types.DocumentType && (node.data.threads?.length ?? 0) > 0);
+        if (firstAttendedNodeWithComments) {
+          void intentPlugin?.provides.intent.dispatch({
+            action: import_app_framework.NavigationAction.OPEN,
+            data: {
+              activeParts: {
+                complementary: `${firstAttendedNodeWithComments.id}${import_app_framework.SLUG_PATH_SEPARATOR}comments`
+              }
+            }
+          });
+        }
+      });
+      unsubscribeCallbacks.push(queryUnsubscribe);
+      unsubscribeCallbacks.push(unsubscribe);
+    },
+    unload: async () => {
+      unsubscribeCallbacks.forEach((unsubscribe) => unsubscribe());
+    },
+    provides: {
+      settings: settings.values,
+      metadata: {
+        records: {
+          [import_types2.ChannelType.typename]: {
+            placeholder: [
+              "channel title placeholder",
+              {
+                ns: import_chunk_BWBONZGU.THREAD_PLUGIN
+              }
+            ],
+            icon: (props) => /* @__PURE__ */ import_react2.default.createElement(import_react.Chat, props),
+            iconSymbol: "ph--chat--regular",
+            // TODO(wittjosiah): Move out of metadata.
+            loadReferences: (channel) => (0, import_echo.loadObjectReferences)(channel, (channel2) => channel2.threads)
+          },
+          [import_types2.ThreadType.typename]: {
+            // TODO(wittjosiah): Move out of metadata.
+            loadReferences: (thread) => (0, import_echo.loadObjectReferences)(thread, (thread2) => thread2.messages)
+          },
+          [import_types2.MessageType.typename]: {
+            // TODO(wittjosiah): Move out of metadata.
+            loadReferences: (message) => []
+          },
+          [import_chunk_BWBONZGU.THREAD_ITEM]: {
+            parse: (item, type) => {
+              switch (type) {
+                case "node":
+                  return {
+                    id: item.id,
+                    label: item.title,
+                    data: item
+                  };
+                case "object":
+                  return item;
+                case "view-object":
+                  return {
+                    id: `${item.id}-view`,
+                    object: item
+                  };
+              }
+            }
+          }
+        }
+      },
+      translations: [
+        ...translations_default,
+        ...import_react_ui_thread.translations
+      ],
+      echo: {
+        schema: [
+          import_types2.ChannelType,
+          import_types2.ThreadType,
+          import_types2.MessageType
+        ]
+      },
+      graph: {
+        builder: (plugins) => {
+          const client = (0, import_app_framework.resolvePlugin)(plugins, import_plugin_client.parseClientPlugin)?.provides.client;
+          const dispatch2 = (0, import_app_framework.resolvePlugin)(plugins, import_app_framework.parseIntentPlugin)?.provides.intent.dispatch;
+          const metadataResolver = (0, import_app_framework.resolvePlugin)(plugins, import_app_framework.parseMetadataResolverPlugin)?.provides.metadata.resolver;
+          if (!client || !dispatch2 || !metadataResolver) {
+            return [];
+          }
+          return [
+            (0, import_plugin_graph.createExtension)({
+              id: `${import_chunk_BWBONZGU.THREAD_PLUGIN}/comments-for-subject`,
+              resolver: ({ id }) => {
+                if (!id.endsWith("~comments")) {
+                  return;
+                }
+                const docId = id.split("~").at(0);
+                const [spaceId, objectId] = docId?.split(":") ?? [];
+                const space = client.spaces.get().find((space2) => space2.id === spaceId);
+                const doc = space?.db.getObjectById(objectId);
+                if (!doc || !docId) {
+                  return;
+                }
+                const docMeta = metadataResolver((0, import_echo_schema.getTypename)(doc) ?? "");
+                const label = docMeta.label?.(doc) || doc.name || docMeta.placeholder || [
+                  "unnamed object threads label",
+                  {
+                    ns: import_chunk_BWBONZGU.THREAD_PLUGIN
+                  }
+                ];
+                const viewState = getViewState(docId);
+                return {
+                  id,
+                  type: "orphan-comments-for-subject",
+                  data: doc,
+                  properties: {
+                    icon: import_chunk_BWBONZGU.meta_default.iconComponent,
+                    label,
+                    showResolvedThreads: viewState.showResolvedThreads
+                  }
+                };
+              },
+              actions: ({ node }) => {
+                const dataId = node.id.split("~").at(0);
+                if (!node.id.endsWith("~comments") || !dataId) {
+                  return;
+                }
+                const [spaceId, objectId] = dataId.split(":");
+                const viewState = getViewState(dataId);
+                const toggle = () => {
+                  const newToggleState = !viewState.showResolvedThreads;
+                  viewState.showResolvedThreads = newToggleState;
+                  void dispatch2({
+                    action: import_meta.ObservabilityAction.SEND_EVENT,
+                    data: {
+                      name: "threads.toggle-show-resolved",
+                      properties: {
+                        spaceId,
+                        threadId: objectId,
+                        showResolved: newToggleState
+                      }
+                    }
+                  });
+                };
+                return [
+                  {
+                    id: `${import_chunk_BWBONZGU.THREAD_PLUGIN}/toggle-show-resolved/${node.id}`,
+                    data: toggle,
+                    properties: {
+                      label: [
+                        "toggle show resolved",
+                        {
+                          ns: import_chunk_BWBONZGU.THREAD_PLUGIN
+                        }
+                      ],
+                      menuItemType: "toggle",
+                      isChecked: viewState.showResolvedThreads,
+                      testId: "threadPlugin.toggleShowResolved"
+                    }
+                  }
+                ];
+              }
+            }),
+            (0, import_plugin_graph.createExtension)({
+              id: import_chunk_WPPLQNMJ.ThreadAction.CREATE,
+              filter: (node) => !!settings.values.standalone && (0, import_plugin_graph.isActionGroup)(node) && node.id.startsWith(import_plugin_space.SpaceAction.ADD_OBJECT),
+              actions: ({ node }) => {
+                const id = node.id.split("/").at(-1);
+                const [spaceId, objectId] = id?.split(":") ?? [];
+                const space = client.spaces.get().find((space2) => space2.id === spaceId);
+                const object = objectId && space?.db.getObjectById(objectId);
+                const target = objectId ? object : space;
+                if (!target) {
+                  return;
+                }
+                return [
+                  {
+                    id: `${import_chunk_BWBONZGU.THREAD_PLUGIN}/create/${node.id}`,
+                    data: async () => {
+                      await dispatch2([
+                        {
+                          plugin: import_chunk_BWBONZGU.THREAD_PLUGIN,
+                          action: import_chunk_WPPLQNMJ.ThreadAction.CREATE
+                        },
+                        {
+                          action: import_plugin_space.SpaceAction.ADD_OBJECT,
+                          data: {
+                            target
+                          }
+                        },
+                        {
+                          action: import_app_framework.NavigationAction.OPEN
+                        }
+                      ]);
+                    },
+                    properties: {
+                      label: [
+                        "create channel label",
+                        {
+                          ns: import_chunk_BWBONZGU.THREAD_PLUGIN
+                        }
+                      ],
+                      icon: (props) => /* @__PURE__ */ import_react2.default.createElement(import_react.Chat, props),
+                      iconSymbol: "ph--chat--regular",
+                      testId: "threadPlugin.createObject"
+                    }
+                  }
+                ];
+              }
+            })
+          ];
+        }
+      },
+      surface: {
+        component: ({ data, role }) => {
+          switch (role) {
+            case "main": {
+              return data.active instanceof import_types2.ChannelType && data.active.threads[0] ? /* @__PURE__ */ import_react2.default.createElement(ThreadMain, {
+                thread: data.active.threads[0]
+              }) : null;
+            }
+            case "settings": {
+              return data.plugin === import_chunk_BWBONZGU.meta_default.id ? /* @__PURE__ */ import_react2.default.createElement(ThreadSettings, {
+                settings: settings.values
+              }) : null;
+            }
+            case "article":
+            case "complementary": {
+              const location = navigationPlugin?.provides.location;
+              if (data.object instanceof import_types2.ChannelType && data.object.threads[0]) {
+                const channel = data.object;
+                if ((0, import_app_framework.isLayoutParts)(location?.active) && location.active.main) {
+                  const layoutEntries = location.active.main;
+                  const currentPosition = layoutEntries.findIndex((entry) => channel.id === entry.id);
+                  if (currentPosition > 0) {
+                    const objectToTheLeft = layoutEntries[currentPosition - 1];
+                    const context = (0, import_echo.getSpace)(data.object)?.db.getObjectById(objectToTheLeft.id);
+                    return /* @__PURE__ */ import_react2.default.createElement(ThreadArticle, {
+                      thread: data.object.threads[0],
+                      context
+                    });
+                  }
+                }
+                return /* @__PURE__ */ import_react2.default.createElement(ThreadArticle, {
+                  thread: data.object.threads[0]
+                });
+              }
+              if (data.subject instanceof import_types.DocumentType) {
+                const doc = data.subject;
+                const accessor = doc.content ? (0, import_echo.createDocAccessor)(doc.content, [
+                  "content"
+                ]) : void 0;
+                if (!accessor) {
+                  return null;
+                }
+                const getStartPosition = (cursor) => {
+                  const range = cursor ? (0, import_echo.getRangeFromCursor)(accessor, cursor) : void 0;
+                  return range?.start ?? Number.MAX_SAFE_INTEGER;
+                };
+                const threads = doc.threads.concat(state.staging[data.subject.id]).filter(import_util.nonNullable).sort((a, b) => getStartPosition(a.anchor) - getStartPosition(b.anchor));
+                const detached = data.subject.threads.filter(import_util.nonNullable).filter(({ anchor }) => !anchor).map((thread) => thread.id);
+                const qualifiedSubjectId = (0, import_echo.fullyQualifiedId)(doc);
+                const attention = attentionPlugin?.provides.attention?.attended ?? /* @__PURE__ */ new Set([
+                  qualifiedSubjectId
+                ]);
+                const attendableAttrs = (0, import_react_ui_attention.createAttendableAttributes)(qualifiedSubjectId);
+                const space = (0, import_echo.getSpace)(doc);
+                const { showResolvedThreads } = getViewState(qualifiedSubjectId);
+                const dispatchAnalytic = (name, meta) => {
+                  void dispatch?.({
+                    action: import_meta.ObservabilityAction.SEND_EVENT,
+                    data: {
+                      name,
+                      properties: {
+                        ...meta,
+                        space: space?.id
+                      }
+                    }
+                  });
+                };
+                return /* @__PURE__ */ import_react2.default.createElement("div", {
+                  role: "none",
+                  className: "contents group/attention",
+                  ...attendableAttrs
+                }, role === "complementary" && /* @__PURE__ */ import_react2.default.createElement(CommentsHeading, {
+                  attendableId: qualifiedSubjectId
+                }), /* @__PURE__ */ import_react2.default.createElement(import_react_ui.ScrollArea.Root, {
+                  classNames: "row-span-2"
+                }, /* @__PURE__ */ import_react2.default.createElement(import_react_ui.ScrollArea.Viewport, null, /* @__PURE__ */ import_react2.default.createElement(CommentsContainer, {
+                  threads,
+                  detached,
+                  currentId: attention.has(qualifiedSubjectId) ? state.current : void 0,
+                  autoFocusCurrentTextbox: state.focus,
+                  showResolvedThreads,
+                  onThreadAttend: (thread) => {
+                    if (state.current !== thread.id) {
+                      state.current = thread.id;
+                      void dispatch?.({
+                        action: import_app_framework.LayoutAction.SCROLL_INTO_VIEW,
+                        data: {
+                          id: thread.id
+                        }
+                      });
+                    }
+                  },
+                  onThreadDelete: (thread) => dispatch?.({
+                    plugin: import_chunk_BWBONZGU.THREAD_PLUGIN,
+                    action: import_chunk_WPPLQNMJ.ThreadAction.DELETE,
+                    data: {
+                      document: data.subject,
+                      thread
+                    }
+                  }),
+                  onMessageDelete: (thread, messageId) => dispatch?.({
+                    plugin: import_chunk_BWBONZGU.THREAD_PLUGIN,
+                    action: import_chunk_WPPLQNMJ.ThreadAction.DELETE_MESSAGE,
+                    data: {
+                      document: data.subject,
+                      thread,
+                      messageId
+                    }
+                  }),
+                  onThreadToggleResolved: (thread) => dispatch?.({
+                    plugin: import_chunk_BWBONZGU.THREAD_PLUGIN,
+                    action: import_chunk_WPPLQNMJ.ThreadAction.TOGGLE_RESOLVED,
+                    data: {
+                      thread
+                    }
+                  }),
+                  onComment: (thread) => {
+                    const doc2 = data.subject;
+                    if (state.staging[doc2.id]?.find((t) => t === thread)) {
+                      thread.status = "active";
+                      doc2.threads ? doc2.threads.push(thread) : doc2.threads = [
+                        thread
+                      ];
+                      state.staging[doc2.id] = state.staging[doc2.id]?.filter((t) => t.id !== thread.id);
+                      dispatchAnalytic("threads.thread-created", {
+                        threadId: thread.id
+                      });
+                    }
+                    dispatchAnalytic("threads.message-added", {
+                      threadId: thread.id,
+                      threadLength: thread.messages.length
+                    });
+                  }
+                }), /* @__PURE__ */ import_react2.default.createElement("div", {
+                  role: "none",
+                  className: "bs-10"
+                }), /* @__PURE__ */ import_react2.default.createElement(import_react_ui.ScrollArea.Scrollbar, null, /* @__PURE__ */ import_react2.default.createElement(import_react_ui.ScrollArea.Thumb, null)))));
+              } else if (data.subject instanceof import_types2.ThreadType) {
+                return /* @__PURE__ */ import_react2.default.createElement(import_react2.default.Fragment, null, /* @__PURE__ */ import_react2.default.createElement(import_chunk_3VAAUEU5.ChatHeading, {
+                  attendableId: data.subject.id
+                }), /* @__PURE__ */ import_react2.default.createElement(import_chunk_3VAAUEU5.ChatContainer, {
+                  thread: data.subject
+                }));
+              }
+            }
+          }
+          return null;
+        }
+      },
+      intent: {
+        resolver: async (intent) => {
+          switch (intent.action) {
+            case import_chunk_WPPLQNMJ.ThreadAction.CREATE: {
+              return {
+                data: (0, import_echo_schema2.create)(import_types2.ChannelType, {
+                  threads: [
+                    (0, import_echo_schema2.create)(import_types2.ThreadType, {
+                      messages: []
+                    })
+                  ]
+                })
+              };
+            }
+            case import_chunk_WPPLQNMJ.ThreadAction.SELECT: {
+              state.focus = intent.data?.current === state.current ? state.focus : intent.data?.focus;
+              state.current = intent.data?.current;
+              return {
+                data: true
+              };
+            }
+            case import_chunk_WPPLQNMJ.ThreadAction.TOGGLE_RESOLVED: {
+              const { thread } = intent.data ?? {};
+              if (!(thread instanceof import_types2.ThreadType)) {
+                return;
+              }
+              if (thread.status === "active" || thread.status === void 0) {
+                thread.status = "resolved";
+              } else if (thread.status === "resolved") {
+                thread.status = "active";
+              }
+              const space = (0, import_echo.getSpace)(thread);
+              const spaceId = space?.id;
+              return {
+                intents: [
+                  [
+                    {
+                      action: import_meta.ObservabilityAction.SEND_EVENT,
+                      data: {
+                        name: "threads.toggle-resolved",
+                        properties: {
+                          threadId: thread.id,
+                          spaceId
+                        }
+                      }
+                    }
+                  ]
+                ]
+              };
+            }
+            case import_chunk_WPPLQNMJ.ThreadAction.DELETE: {
+              const { document: doc, thread } = intent.data ?? {};
+              if (!(doc instanceof import_types.DocumentType) || !(thread instanceof import_types2.ThreadType)) {
+                return;
+              }
+              const stagingArea = state.staging[doc.id];
+              if (stagingArea) {
+                const index = state.staging[doc.id]?.findIndex((t) => t.id === thread.id);
+                if (index !== -1) {
+                  state.staging[doc.id]?.splice(index, 1);
+                  return;
+                }
+              }
+              const space = (0, import_echo.getSpace)(thread);
+              if (!space || !doc.threads) {
+                return;
+              }
+              if (!intent.undo) {
+                const index = doc.threads.findIndex((t) => t?.id === thread.id);
+                const cursor = doc.threads[index]?.anchor;
+                if (index !== -1) {
+                  doc.threads?.splice(index, 1);
+                }
+                space.db.remove(thread);
+                return {
+                  undoable: {
+                    message: translations_default[0]["en-US"][import_chunk_BWBONZGU.THREAD_PLUGIN]["thread deleted label"],
+                    data: {
+                      cursor
+                    }
+                  },
+                  intents: [
+                    [
+                      {
+                        action: import_meta.ObservabilityAction.SEND_EVENT,
+                        data: {
+                          name: "threads.delete",
+                          properties: {
+                            threadId: thread.id,
+                            spaceId: space.id
+                          }
+                        }
+                      }
+                    ]
+                  ]
+                };
+              } else if (intent.undo) {
+                const savedThread = space.db.add(thread);
+                doc.threads.push(savedThread);
+                return {
+                  data: true,
+                  intents: [
+                    [
+                      {
+                        action: import_meta.ObservabilityAction.SEND_EVENT,
+                        data: {
+                          name: "threads.undo-delete",
+                          properties: {
+                            threadId: thread.id,
+                            spaceId: space.id
+                          }
+                        }
+                      }
+                    ]
+                  ]
+                };
+              }
+              break;
+            }
+            case import_chunk_WPPLQNMJ.ThreadAction.DELETE_MESSAGE: {
+              const { document: doc, thread, messageId } = intent.data ?? {};
+              const space = (0, import_echo.getSpace)(doc);
+              if (!(doc instanceof import_types.DocumentType) || !(thread instanceof import_types2.ThreadType) || !space) {
+                return;
+              }
+              if (!intent.undo) {
+                const message = thread.messages.find((m) => m?.id === messageId);
+                const messageIndex = thread.messages.findIndex((m) => m?.id === messageId);
+                if (messageIndex === -1 || !message) {
+                  return void 0;
+                }
+                if (messageIndex === 0 && thread.messages.length === 1) {
+                  return {
+                    intents: [
+                      [
+                        {
+                          action: import_chunk_WPPLQNMJ.ThreadAction.DELETE,
+                          data: {
+                            document: doc,
+                            thread
+                          }
+                        }
+                      ]
+                    ]
+                  };
+                } else {
+                  thread.messages.splice(messageIndex, 1);
+                }
+                return {
+                  undoable: {
+                    message: translations_default[0]["en-US"][import_chunk_BWBONZGU.THREAD_PLUGIN]["message deleted label"],
+                    data: {
+                      message,
+                      messageIndex
+                    }
+                  },
+                  intents: [
+                    [
+                      {
+                        action: import_meta.ObservabilityAction.SEND_EVENT,
+                        data: {
+                          name: "threads.message.delete",
+                          properties: {
+                            threadId: thread.id,
+                            spaceId: space.id
+                          }
+                        }
+                      }
+                    ]
+                  ]
+                };
+              } else if (intent.undo) {
+                const message = intent.data?.message;
+                const messageIndex = intent.data?.messageIndex;
+                if (!(message instanceof import_types2.MessageType) || !(typeof messageIndex === "number")) {
+                  return;
+                }
+                thread.messages.splice(messageIndex, 0, message);
+                return {
+                  data: true,
+                  intents: [
+                    [
+                      {
+                        action: import_meta.ObservabilityAction.SEND_EVENT,
+                        data: {
+                          name: "threads.message.undo-delete",
+                          properties: {
+                            threadId: thread.id,
+                            spaceId: space.id
+                          }
+                        }
+                      }
+                    ]
+                  ]
+                };
+              }
+            }
+          }
+        }
+      },
+      markdown: {
+        // TODO(burdon): Factor out extension factory into separate file (for simplicity).
+        extensions: ({ document: doc }) => {
+          const space = doc && (0, import_echo.getSpace)(doc);
+          if (!doc || !space) {
+            return [
+              (0, import_react_ui_editor.comments)()
+            ];
+          }
+          const threads = (0, import_signals_core.computed)(() => [
+            ...doc.threads.filter(import_util.nonNullable),
+            ...state.staging[doc.id] ?? []
+          ].filter((thread) => !(thread?.status === "resolved")));
+          return [
+            (0, import_react_ui_editor.listener)({
+              onChange: () => {
+                doc.threads.forEach((thread) => {
+                  if (thread?.anchor) {
+                    const [start, end] = thread.anchor.split(":");
+                    const name = doc.content && (0, import_echo.getTextInRange)((0, import_echo.createDocAccessor)(doc.content, [
+                      "content"
+                    ]), start, end);
+                    if (name && name !== thread.name) {
+                      thread.name = name;
+                    }
+                  }
+                });
+              }
+            }),
+            (0, import_react_ui_editor.createExternalCommentSync)(doc.id, (sink) => (0, import_signals_core.effect)(() => sink()), () => threads.value.filter((thread) => thread?.anchor).map((thread) => ({
+              id: thread.id,
+              cursor: thread.anchor
+            }))),
+            (0, import_react_ui_editor.comments)({
+              id: doc.id,
+              onCreate: ({ cursor }) => {
+                const [start, end] = cursor.split(":");
+                const name = doc.content && (0, import_echo.getTextInRange)((0, import_echo.createDocAccessor)(doc.content, [
+                  "content"
+                ]), start, end);
+                const thread = (0, import_echo_schema2.create)(import_types2.ThreadType, {
+                  name,
+                  anchor: cursor,
+                  messages: [],
+                  status: "staged"
+                });
+                const stagingArea = state.staging[doc.id];
+                if (stagingArea) {
+                  stagingArea.push(thread);
+                } else {
+                  state.staging[doc.id] = [
+                    thread
+                  ];
+                }
+                void intentPlugin?.provides.intent.dispatch([
+                  {
+                    action: import_app_framework.NavigationAction.OPEN,
+                    data: {
+                      activeParts: {
+                        complementary: `${(0, import_echo.fullyQualifiedId)(doc)}${import_app_framework.SLUG_PATH_SEPARATOR}comments${import_app_framework.SLUG_COLLECTION_INDICATOR}`
+                      }
+                    }
+                  },
+                  {
+                    action: import_chunk_WPPLQNMJ.ThreadAction.SELECT,
+                    data: {
+                      current: thread.id,
+                      focus: true
+                    }
+                  },
+                  {
+                    action: import_app_framework.LayoutAction.SET_LAYOUT,
+                    data: {
+                      element: "complementary",
+                      subject: doc,
+                      state: true
+                    }
+                  }
+                ]);
+                return thread.id;
+              },
+              onDelete: ({ id }) => {
+                const stagingArea = state.staging[doc.id];
+                if (stagingArea) {
+                  const index = stagingArea.findIndex((thread2) => thread2.id === id);
+                  if (index !== -1) {
+                    stagingArea.splice(index, 1);
+                  }
+                }
+                const thread = doc.threads.find((thread2) => thread2?.id === id);
+                if (thread) {
+                  thread.anchor = void 0;
+                }
+              },
+              onUpdate: ({ id, cursor }) => {
+                const thread = state.staging[doc.id]?.find((thread2) => thread2.id === id) ?? doc.threads.find((thread2) => thread2?.id === id);
+                if (thread instanceof import_types2.ThreadType && thread.anchor) {
+                  const [start, end] = thread.anchor.split(":");
+                  thread.name = doc.content && (0, import_echo.getTextInRange)((0, import_echo.createDocAccessor)(doc.content, [
+                    "content"
+                  ]), start, end);
+                  thread.anchor = cursor;
+                }
+              },
+              onSelect: ({ selection: { current, closest } }) => {
+                const dispatch2 = intentPlugin?.provides.intent.dispatch;
+                if (dispatch2) {
+                  void dispatch2([
+                    {
+                      action: import_chunk_WPPLQNMJ.ThreadAction.SELECT,
+                      data: {
+                        current: current ?? closest
+                      }
+                    }
+                  ]);
+                }
+              }
+            })
+          ];
+        }
+      }
+    }
+  };
+};
+var src_default = ThreadPlugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ThreadAction,
+  ThreadPlugin,
+  useAnalyticsCallback,
+  useOnEditAnalytics,
+  useStatus
+});
+//# sourceMappingURL=index.cjs.map