@dxos/plugin-thread 0.6.13 → 0.6.14-main.69511f5

package/dist/lib/node-esm/index.mjs

@@ -0,0 +1,1151 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  ThreadAction
+} from "./chunk-KWNXG6FG.mjs";
+import {
+  ChatContainer,
+  ChatHeading,
+  MessageContainer,
+  command,
+  getMessageMetadata,
+  useAnalyticsCallback,
+  useOnEditAnalytics,
+  useStatus
+} from "./chunk-SXXOBRAX.mjs";
+import {
+  THREAD_ITEM,
+  THREAD_PLUGIN,
+  meta_default
+} from "./chunk-DC5ZA6H5.mjs";
+
+// packages/plugins/plugin-thread/src/ThreadPlugin.tsx
+import React5 from "react";
+import { NavigationAction, isLayoutParts, parseIntentPlugin, parseNavigationPlugin, parseMetadataResolverPlugin, resolvePlugin, LayoutAction as LayoutAction2 } from "@dxos/app-framework";
+import { LocalStorageStore } from "@dxos/local-storage";
+import { log } from "@dxos/log";
+import { parseClientPlugin } from "@dxos/plugin-client";
+import { createExtension, isActionGroup, toSignal } from "@dxos/plugin-graph";
+import { ObservabilityAction } from "@dxos/plugin-observability/meta";
+import { SpaceAction } from "@dxos/plugin-space";
+import { ThreadType as ThreadType2, MessageType as MessageType2, ChannelType } from "@dxos/plugin-space/types";
+import { create as create2, getTypename } from "@dxos/react-client/echo";
+import { getSpace as getSpace3, fullyQualifiedId as fullyQualifiedId5, loadObjectReferences, parseId } from "@dxos/react-client/echo";
+import { translations as threadTranslations } from "@dxos/react-ui-thread";
+
+// packages/plugins/plugin-thread/src/components/index.ts
+import { lazy } from "react";
+
+// packages/plugins/plugin-thread/src/components/CommentContainer.tsx
+import { CheckCircle, X } from "@phosphor-icons/react";
+import React, { useCallback, useMemo, useRef, useState } from "react";
+import { create } from "@dxos/echo-schema";
+import { MessageType } from "@dxos/plugin-space/types";
+import { fullyQualifiedId, getSpace, useMembers } from "@dxos/react-client/echo";
+import { useIdentity } from "@dxos/react-client/halo";
+import { Button, Tag, Tooltip, useThemeContext, useTranslation } from "@dxos/react-ui";
+import { createBasicExtensions, createThemeExtensions, listener } from "@dxos/react-ui-editor";
+import { getSize, hoverableControlItem, hoverableControls, hoverableFocusedWithinControls, mx } from "@dxos/react-ui-theme";
+import { MessageTextbox, Thread, ThreadFooter, ThreadHeading } from "@dxos/react-ui-thread";
+import { nonNullable } from "@dxos/util";
+var sizeClass = getSize(4);
+var ToggleResolvedButton = ({ isResolved, onResolve }) => {
+  const { t } = useTranslation(THREAD_PLUGIN);
+  const label = t(isResolved ? "mark as unresolved label" : "mark as resolved label");
+  return /* @__PURE__ */ React.createElement(Tooltip.Root, null, /* @__PURE__ */ React.createElement(Tooltip.Trigger, {
+    asChild: true
+  }, /* @__PURE__ */ React.createElement(Button, {
+    variant: "ghost",
+    "data-testid": "thread.toggle-resolved",
+    onClick: onResolve,
+    classNames: [
+      "min-bs-0 p-1",
+      !isResolved && hoverableControlItem
+    ]
+  }, /* @__PURE__ */ React.createElement("span", {
+    className: "sr-only"
+  }, label), isResolved ? /* @__PURE__ */ React.createElement(CheckCircle, {
+    className: sizeClass,
+    weight: "fill"
+  }) : /* @__PURE__ */ React.createElement(CheckCircle, {
+    className: sizeClass
+  }))), /* @__PURE__ */ React.createElement(Tooltip.Portal, null, /* @__PURE__ */ React.createElement(Tooltip.Content, {
+    classNames: "z-[21]"
+  }, label, /* @__PURE__ */ React.createElement(Tooltip.Arrow, null))));
+};
+var DeleteThreadButton = ({ onDelete }) => {
+  const { t } = useTranslation(THREAD_PLUGIN);
+  const label = t("delete thread label");
+  return /* @__PURE__ */ React.createElement(Tooltip.Root, null, /* @__PURE__ */ React.createElement(Tooltip.Trigger, {
+    asChild: true
+  }, /* @__PURE__ */ React.createElement(Button, {
+    variant: "ghost",
+    "data-testid": "thread.delete",
+    onClick: onDelete,
+    classNames: [
+      "min-bs-0 p-1",
+      hoverableControlItem
+    ]
+  }, /* @__PURE__ */ React.createElement("span", {
+    className: "sr-only"
+  }, label), /* @__PURE__ */ React.createElement(X, {
+    className: sizeClass
+  }))), /* @__PURE__ */ React.createElement(Tooltip.Portal, null, /* @__PURE__ */ React.createElement(Tooltip.Content, {
+    classNames: "z-[21]"
+  }, label, /* @__PURE__ */ React.createElement(Tooltip.Arrow, null))));
+};
+var CommentContainer = ({ thread, detached, context, current, onAttend, onThreadDelete, onMessageDelete, onResolve, onComment }) => {
+  const identity = useIdentity();
+  const space = getSpace(thread);
+  const members = useMembers(space?.key);
+  const activity = useStatus(space, fullyQualifiedId(thread));
+  const { t } = useTranslation(THREAD_PLUGIN);
+  const threadScrollRef = useRef(null);
+  const { themeMode } = useThemeContext();
+  const textboxMetadata = getMessageMetadata(fullyQualifiedId(thread), identity);
+  const [_count, _setCount] = useState(0);
+  const rerenderEditor = () => _setCount((count) => count + 1);
+  const messageRef = useRef("");
+  const extensions = useMemo(() => [
+    createBasicExtensions({
+      placeholder: t("message placeholder")
+    }),
+    createThemeExtensions({
+      themeMode
+    }),
+    listener({
+      onChange: (text) => messageRef.current = text
+    }),
+    command
+  ], [
+    _count
+  ]);
+  const scrollToEnd = (behavior) => setTimeout(() => threadScrollRef.current?.scrollIntoView({
+    behavior,
+    block: "end"
+  }), 10);
+  const handleCreate = useCallback(() => {
+    if (!messageRef.current) {
+      return false;
+    }
+    thread.messages.push(create(MessageType, {
+      sender: {
+        identityKey: identity.identityKey.toHex()
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      text: messageRef.current,
+      context
+    }));
+    onComment?.(thread);
+    messageRef.current = "";
+    scrollToEnd("instant");
+    rerenderEditor();
+    return true;
+  }, [
+    thread,
+    identity
+  ]);
+  return /* @__PURE__ */ React.createElement(Thread, {
+    onClickCapture: onAttend,
+    onFocusCapture: onAttend,
+    current,
+    id: fullyQualifiedId(thread)
+  }, /* @__PURE__ */ React.createElement("div", {
+    role: "none",
+    className: mx("col-span-2 grid grid-cols-[var(--rail-size)_1fr_min-content]", hoverableControls, hoverableFocusedWithinControls)
+  }, detached ? /* @__PURE__ */ React.createElement(Tooltip.Root, null, /* @__PURE__ */ React.createElement(Tooltip.Trigger, {
+    asChild: true
+  }, /* @__PURE__ */ React.createElement(ThreadHeading, {
+    detached: true
+  }, thread.name ?? t("thread title placeholder"))), /* @__PURE__ */ React.createElement(Tooltip.Portal, null, /* @__PURE__ */ React.createElement(Tooltip.Content, {
+    classNames: "z-[21]",
+    side: "top"
+  }, t("detached thread label"), /* @__PURE__ */ React.createElement(Tooltip.Arrow, null)))) : /* @__PURE__ */ React.createElement(ThreadHeading, null, thread.name ?? t("thread title placeholder")), /* @__PURE__ */ React.createElement("div", {
+    className: "flex flex-row items-center pli-1"
+  }, thread.status === "staged" && /* @__PURE__ */ React.createElement(Tag, {
+    palette: "neutral"
+  }, t("draft button")), onResolve && !(thread?.status === "staged") && /* @__PURE__ */ React.createElement(ToggleResolvedButton, {
+    isResolved: thread?.status === "resolved",
+    onResolve
+  }), onThreadDelete && /* @__PURE__ */ React.createElement(DeleteThreadButton, {
+    onDelete: onThreadDelete
+  }))), thread.messages.filter(nonNullable).map((message) => /* @__PURE__ */ React.createElement(MessageContainer, {
+    key: message.id,
+    message,
+    members,
+    onDelete: (id) => onMessageDelete?.(id)
+  })), /* @__PURE__ */ React.createElement(MessageTextbox, {
+    extensions,
+    onSend: handleCreate,
+    ...textboxMetadata
+  }), /* @__PURE__ */ React.createElement(ThreadFooter, {
+    activity
+  }, t("activity message")), /* @__PURE__ */ React.createElement("div", {
+    role: "none",
+    className: "bs-px -mbs-px",
+    ref: threadScrollRef
+  }));
+};
+
+// packages/plugins/plugin-thread/src/components/CommentsContainer.tsx
+import { ChatText } from "@phosphor-icons/react";
+import React2, { useEffect } from "react";
+import { fullyQualifiedId as fullyQualifiedId2 } from "@dxos/react-client/echo";
+import { useTranslation as useTranslation2, Trans } from "@dxos/react-ui";
+import { descriptionText, mx as mx2 } from "@dxos/react-ui-theme";
+var CommentsContainer = ({ threads: threads2, detached = [], currentId, showResolvedThreads, onThreadAttend, onThreadDelete, onMessageDelete, onThreadToggleResolved, ...props }) => {
+  const { t } = useTranslation2(THREAD_PLUGIN);
+  const filteredThreads = showResolvedThreads ? threads2 : threads2.filter((thread) => !(thread?.status === "resolved"));
+  useEffect(() => {
+    if (currentId) {
+      document.getElementById(currentId)?.scrollIntoView({
+        behavior: "smooth",
+        block: "end"
+      });
+    }
+  }, [
+    currentId
+  ]);
+  return /* @__PURE__ */ React2.createElement(React2.Fragment, null, filteredThreads.length > 0 ? filteredThreads.map((thread) => {
+    const threadId = fullyQualifiedId2(thread);
+    return /* @__PURE__ */ React2.createElement(CommentContainer, {
+      key: threadId,
+      thread,
+      current: currentId === threadId,
+      detached: detached.includes(threadId),
+      ...onThreadAttend && {
+        onAttend: () => onThreadAttend(thread)
+      },
+      ...onThreadDelete && {
+        onThreadDelete: () => onThreadDelete(thread)
+      },
+      ...onMessageDelete && {
+        onMessageDelete: (messageId) => onMessageDelete(thread, messageId)
+      },
+      ...onThreadToggleResolved && {
+        onResolve: () => onThreadToggleResolved(thread)
+      },
+      ...props
+    });
+  }) : /* @__PURE__ */ React2.createElement("div", {
+    role: "alert",
+    className: mx2(descriptionText, "place-self-center border border-dashed border-neutral-400/50 rounded-lg text-center p-4 m-4")
+  }, /* @__PURE__ */ React2.createElement("h2", {
+    className: "mbe-2 font-medium text-baseText"
+  }, t("no comments title")), /* @__PURE__ */ React2.createElement("p", null, /* @__PURE__ */ React2.createElement(Trans, {
+    t,
+    i18nKey: "no comments message",
+    components: {
+      commentIcon: /* @__PURE__ */ React2.createElement(ChatText, {
+        className: "inline-block"
+      })
+    }
+  }))));
+};
+
+// packages/plugins/plugin-thread/src/components/ThreadComplementary.tsx
+import React3, { useEffect as useEffect2, useMemo as useMemo2 } from "react";
+import { LayoutAction, useIntentDispatcher, useResolvePlugins } from "@dxos/app-framework";
+import { fullyQualifiedId as fullyQualifiedId3 } from "@dxos/react-client/echo";
+import { ScrollArea } from "@dxos/react-ui";
+import { useAttended } from "@dxos/react-ui-attention";
+import { nonNullable as nonNullable2 } from "@dxos/util";
+var providesThreadsConfig = (plugin) => "thread" in plugin.provides ? plugin : void 0;
+var ThreadComplementary = ({ role, subject, drafts, current, showResolvedThreads }) => {
+  const dispatch = useIntentDispatcher();
+  const threadsIntegrators = useResolvePlugins(providesThreadsConfig);
+  const threadProvides = useMemo2(() => threadsIntegrators.map((p) => p.provides.thread), [
+    threadsIntegrators
+  ]);
+  const createSort = useMemo2(() => threadProvides.find((p) => p.predicate(subject))?.createSort, [
+    threadProvides,
+    subject
+  ]);
+  const sort = useMemo2(() => createSort?.(subject), [
+    createSort,
+    subject
+  ]);
+  const threads2 = useMemo2(() => {
+    return subject.threads.concat(drafts ?? []).filter(nonNullable2);
+  }, [
+    JSON.stringify(subject.threads),
+    JSON.stringify(drafts)
+  ]);
+  const detachedIds = useMemo2(() => {
+    return threads2.filter(({ anchor }) => !anchor).map((thread) => fullyQualifiedId3(thread));
+  }, [
+    threads2
+  ]);
+  useEffect2(() => {
+    if (!sort) {
+      return;
+    }
+    threads2.sort((a, b) => sort(a?.anchor, b?.anchor));
+  }, [
+    sort,
+    threads2
+  ]);
+  const attended = useAttended();
+  const qualifiedSubjectId = fullyQualifiedId3(subject);
+  return /* @__PURE__ */ React3.createElement("div", {
+    role: "none",
+    className: "contents"
+  }, /* @__PURE__ */ React3.createElement(ScrollArea.Root, {
+    classNames: "row-span-2"
+  }, /* @__PURE__ */ React3.createElement(ScrollArea.Viewport, null, /* @__PURE__ */ React3.createElement(CommentsContainer, {
+    threads: threads2,
+    detached: detachedIds,
+    currentId: attended.includes(qualifiedSubjectId) ? current : void 0,
+    showResolvedThreads,
+    onThreadAttend: (thread) => {
+      const threadId = fullyQualifiedId3(thread);
+      if (current !== threadId) {
+        current = threadId;
+        void dispatch?.([
+          {
+            action: LayoutAction.SCROLL_INTO_VIEW,
+            data: {
+              id: fullyQualifiedId3(subject),
+              thread: threadId,
+              cursor: thread.anchor
+            }
+          }
+        ]);
+      }
+    },
+    onThreadDelete: (thread) => {
+      return dispatch({
+        plugin: THREAD_PLUGIN,
+        action: ThreadAction.DELETE,
+        data: {
+          subject,
+          thread
+        }
+      });
+    },
+    onMessageDelete: (thread, messageId) => dispatch({
+      plugin: THREAD_PLUGIN,
+      action: ThreadAction.DELETE_MESSAGE,
+      data: {
+        subject,
+        thread,
+        messageId
+      }
+    }),
+    onThreadToggleResolved: (thread) => dispatch({
+      plugin: THREAD_PLUGIN,
+      action: ThreadAction.TOGGLE_RESOLVED,
+      data: {
+        thread
+      }
+    }),
+    onComment: (thread) => {
+      void dispatch({
+        action: ThreadAction.ON_MESSAGE_ADD,
+        data: {
+          thread,
+          subject
+        }
+      });
+    }
+  }), /* @__PURE__ */ React3.createElement("div", {
+    role: "none",
+    className: "bs-10"
+  }), /* @__PURE__ */ React3.createElement(ScrollArea.Scrollbar, null, /* @__PURE__ */ React3.createElement(ScrollArea.Thumb, null)))));
+};
+
+// packages/plugins/plugin-thread/src/components/ThreadSettings.tsx
+import React4 from "react";
+import { Input, useTranslation as useTranslation3 } from "@dxos/react-ui";
+import { FormInput } from "@dxos/react-ui-data";
+var ThreadSettings = ({ settings }) => {
+  const { t } = useTranslation3(THREAD_PLUGIN);
+  return /* @__PURE__ */ React4.createElement(React4.Fragment, null, /* @__PURE__ */ React4.createElement(FormInput, {
+    label: t("settings standalone label")
+  }, /* @__PURE__ */ React4.createElement(Input.Switch, {
+    checked: settings.standalone,
+    onCheckedChange: (checked) => settings.standalone = !!checked
+  })));
+};
+
+// packages/plugins/plugin-thread/src/components/index.ts
+var ThreadMain = lazy(() => import("./ThreadMain-U7R24CN3.mjs"));
+var ThreadArticle = lazy(() => import("./ThreadArticle-PXO4ZJFU.mjs"));
+
+// packages/plugins/plugin-thread/src/extensions/threads.ts
+import { EditorView } from "@codemirror/view";
+import { computed, effect } from "@preact/signals-core";
+import { ThreadType } from "@dxos/plugin-space/types";
+import { getSpace as getSpace2, getTextInRange, createDocAccessor, fullyQualifiedId as fullyQualifiedId4 } from "@dxos/react-client/echo";
+import { comments, createExternalCommentSync } from "@dxos/react-ui-editor";
+import { nonNullable as nonNullable3 } from "@dxos/util";
+var getName = (doc, anchor) => {
+  if (doc.content) {
+    const [start, end] = anchor.split(":");
+    return getTextInRange(createDocAccessor(doc.content, [
+      "content"
+    ]), start, end);
+  }
+};
+var threads = (state, doc, dispatch) => {
+  const space = doc && getSpace2(doc);
+  if (!doc || !space || !dispatch) {
+    return [
+      comments()
+    ];
+  }
+  const threads2 = computed(() => [
+    ...doc.threads.filter(nonNullable3),
+    ...state.drafts[fullyQualifiedId4(doc)] ?? []
+  ].filter((thread) => !(thread?.status === "resolved")));
+  return [
+    EditorView.updateListener.of((update) => {
+      if (update.docChanged) {
+        doc.threads.forEach((thread) => {
+          if (thread?.anchor) {
+            const name = getName(doc, thread.anchor);
+            if (name && name !== thread.name) {
+              thread.name = name;
+            }
+          }
+        });
+      }
+    }),
+    createExternalCommentSync(fullyQualifiedId4(doc), (sink) => effect(() => sink()), () => threads2.value.filter((thread) => thread?.anchor).map((thread) => ({
+      id: fullyQualifiedId4(thread),
+      cursor: thread.anchor
+    }))),
+    comments({
+      id: fullyQualifiedId4(doc),
+      onCreate: ({ cursor }) => {
+        const name = getName(doc, cursor);
+        void dispatch({
+          action: ThreadAction.CREATE,
+          data: {
+            cursor,
+            name,
+            subject: doc
+          }
+        });
+      },
+      onDelete: ({ id }) => {
+        const draft = state.drafts[fullyQualifiedId4(doc)];
+        if (draft) {
+          const index = draft.findIndex((thread2) => fullyQualifiedId4(thread2) === id);
+          if (index !== -1) {
+            draft.splice(index, 1);
+          }
+        }
+        const thread = doc.threads.find((thread2) => thread2?.id === id);
+        if (thread) {
+          thread.anchor = void 0;
+        }
+      },
+      onUpdate: ({ id, cursor }) => {
+        const thread = state.drafts[fullyQualifiedId4(doc)]?.find((thread2) => fullyQualifiedId4(thread2) === id) ?? doc.threads.find((thread2) => thread2?.id === id);
+        if (thread instanceof ThreadType && thread.anchor) {
+          thread.name = getName(doc, thread.anchor);
+          thread.anchor = cursor;
+        }
+      },
+      onSelect: ({ selection: { current, closest } }) => {
+        void dispatch({
+          action: ThreadAction.SELECT,
+          data: {
+            current: current ?? closest,
+            skipOpen: true
+          }
+        });
+      }
+    })
+  ];
+};
+
+// packages/plugins/plugin-thread/src/translations.ts
+var translations_default = [
+  {
+    "en-US": {
+      [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"
+      }
+    }
+  }
+];
+
+// packages/plugins/plugin-thread/src/ThreadPlugin.tsx
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/plugins/plugin-thread/src/ThreadPlugin.tsx";
+var initialViewState = {
+  showResolvedThreads: false
+};
+var ThreadPlugin = () => {
+  const settings = new LocalStorageStore(THREAD_PLUGIN);
+  const state = create2({
+    drafts: {}
+  });
+  const viewStore = create2({});
+  const getViewState = (subjectId) => {
+    if (!viewStore[subjectId]) {
+      viewStore[subjectId] = {
+        ...initialViewState
+      };
+    }
+    return viewStore[subjectId];
+  };
+  let navigationPlugin;
+  let intentPlugin;
+  const unsubscribeCallbacks = [];
+  return {
+    meta: meta_default,
+    ready: async (plugins) => {
+      settings.prop({
+        key: "standalone",
+        type: LocalStorageStore.bool({
+          allowUndefined: true
+        })
+      });
+      navigationPlugin = resolvePlugin(plugins, parseNavigationPlugin);
+      intentPlugin = resolvePlugin(plugins, parseIntentPlugin);
+    },
+    unload: async () => {
+      unsubscribeCallbacks.forEach((unsubscribe) => unsubscribe());
+    },
+    provides: {
+      settings: settings.values,
+      metadata: {
+        records: {
+          [ChannelType.typename]: {
+            placeholder: [
+              "channel title placeholder",
+              {
+                ns: THREAD_PLUGIN
+              }
+            ],
+            icon: "ph--chat--regular",
+            // TODO(wittjosiah): Move out of metadata.
+            loadReferences: (channel) => loadObjectReferences(channel, (channel2) => channel2.threads)
+          },
+          [ThreadType2.typename]: {
+            // TODO(wittjosiah): Move out of metadata.
+            loadReferences: (thread) => loadObjectReferences(thread, (thread2) => thread2.messages)
+          },
+          [MessageType2.typename]: {
+            // TODO(wittjosiah): Move out of metadata.
+            loadReferences: (message) => []
+          },
+          [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,
+        ...threadTranslations
+      ],
+      echo: {
+        schema: [
+          ChannelType,
+          ThreadType2,
+          MessageType2
+        ]
+      },
+      graph: {
+        builder: (plugins) => {
+          const client = resolvePlugin(plugins, parseClientPlugin)?.provides.client;
+          const dispatch = resolvePlugin(plugins, parseIntentPlugin)?.provides.intent.dispatch;
+          const metadataResolver = resolvePlugin(plugins, parseMetadataResolverPlugin)?.provides.metadata.resolver;
+          if (!client || !dispatch || !metadataResolver) {
+            return [];
+          }
+          const type = "orphan-comments-for-subject";
+          const icon = "ph--chat-text--regular";
+          return [
+            createExtension({
+              id: `${THREAD_PLUGIN}/comments-for-subject`,
+              resolver: ({ id }) => {
+                if (!id.endsWith("~comments")) {
+                  return;
+                }
+                const [subjectId] = id.split("~");
+                const { spaceId, objectId } = parseId(subjectId);
+                const space = client.spaces.get().find((space2) => space2.id === spaceId);
+                if (!objectId) {
+                  return {
+                    id,
+                    type,
+                    data: null,
+                    properties: {
+                      icon,
+                      label: [
+                        "unnamed object threads label",
+                        {
+                          ns: THREAD_PLUGIN
+                        }
+                      ],
+                      showResolvedThreads: false,
+                      object: null,
+                      space
+                    }
+                  };
+                }
+                const object = toSignal((onChange) => {
+                  const timeout = setTimeout(async () => {
+                    await space?.db.loadObjectById(objectId);
+                    onChange();
+                  });
+                  return () => clearTimeout(timeout);
+                }, () => space?.db.getObjectById(objectId), subjectId);
+                if (!object || !subjectId) {
+                  return;
+                }
+                const meta = metadataResolver(getTypename(object) ?? "");
+                const label = meta.label?.(object) || object.name || meta.placeholder || [
+                  "unnamed object threads label",
+                  {
+                    ns: THREAD_PLUGIN
+                  }
+                ];
+                const viewState = getViewState(subjectId);
+                return {
+                  id,
+                  type,
+                  data: null,
+                  properties: {
+                    icon,
+                    label,
+                    showResolvedThreads: viewState.showResolvedThreads,
+                    object
+                  }
+                };
+              },
+              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 dispatch({
+                    action: ObservabilityAction.SEND_EVENT,
+                    data: {
+                      name: "threads.toggle-show-resolved",
+                      properties: {
+                        spaceId,
+                        threadId: objectId,
+                        showResolved: newToggleState
+                      }
+                    }
+                  });
+                };
+                return [
+                  {
+                    id: `${THREAD_PLUGIN}/toggle-show-resolved/${node.id}`,
+                    data: toggle,
+                    properties: {
+                      label: [
+                        "toggle show resolved",
+                        {
+                          ns: THREAD_PLUGIN
+                        }
+                      ],
+                      menuItemType: "toggle",
+                      isChecked: viewState.showResolvedThreads,
+                      testId: "threadPlugin.toggleShowResolved",
+                      icon: viewState.showResolvedThreads ? "ph--eye-slash--regular" : "ph--eye--regular"
+                    }
+                  }
+                ];
+              }
+            }),
+            createExtension({
+              id: ThreadAction.CREATE,
+              filter: (node) => !!settings.values.standalone && isActionGroup(node) && node.id.startsWith(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: `${THREAD_PLUGIN}/create/${node.id}`,
+                    data: async () => {
+                      await dispatch([
+                        {
+                          plugin: THREAD_PLUGIN,
+                          action: ThreadAction.CREATE
+                        },
+                        {
+                          action: SpaceAction.ADD_OBJECT,
+                          data: {
+                            target
+                          }
+                        },
+                        {
+                          action: NavigationAction.OPEN
+                        }
+                      ]);
+                    },
+                    properties: {
+                      label: [
+                        "create channel label",
+                        {
+                          ns: THREAD_PLUGIN
+                        }
+                      ],
+                      icon: "ph--chat--regular",
+                      testId: "threadPlugin.createObject"
+                    }
+                  }
+                ];
+              }
+            })
+          ];
+        }
+      },
+      surface: {
+        component: ({ data, role }) => {
+          switch (role) {
+            case "main": {
+              return data.active instanceof ChannelType && data.active.threads[0] ? /* @__PURE__ */ React5.createElement(ThreadMain, {
+                thread: data.active.threads[0]
+              }) : null;
+            }
+            case "settings": {
+              return data.plugin === meta_default.id ? /* @__PURE__ */ React5.createElement(ThreadSettings, {
+                settings: settings.values
+              }) : null;
+            }
+            case "article": {
+              const location = navigationPlugin?.provides.location;
+              if (data.object instanceof ChannelType && data.object.threads[0]) {
+                const channel = data.object;
+                if (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 = getSpace3(data.object)?.db.getObjectById(objectToTheLeft.id);
+                    return /* @__PURE__ */ React5.createElement(ThreadArticle, {
+                      thread: data.object.threads[0],
+                      context
+                    });
+                  }
+                }
+                return /* @__PURE__ */ React5.createElement(ThreadArticle, {
+                  thread: data.object.threads[0]
+                });
+              }
+              if (data.subject instanceof ThreadType2) {
+                return /* @__PURE__ */ React5.createElement(React5.Fragment, null, /* @__PURE__ */ React5.createElement(ChatHeading, {
+                  attendableId: data.subject.id
+                }), /* @__PURE__ */ React5.createElement(ChatContainer, {
+                  thread: data.subject
+                }));
+              }
+              break;
+            }
+            case "complementary--comments": {
+              if (data.subject && typeof data.subject === "object" && "threads" in data.subject && Array.isArray(data.subject.threads)) {
+                const { showResolvedThreads } = getViewState(fullyQualifiedId5(data.subject));
+                return /* @__PURE__ */ React5.createElement(ThreadComplementary, {
+                  role,
+                  subject: data.subject,
+                  drafts: state.drafts[fullyQualifiedId5(data.subject)],
+                  current: state.current,
+                  showResolvedThreads
+                });
+              }
+              break;
+            }
+          }
+          return null;
+        }
+      },
+      intent: {
+        resolver: async (intent) => {
+          switch (intent.action) {
+            case ThreadAction.CREATE: {
+              if (intent.data && intent.data.cursor !== void 0) {
+                const { cursor, name, subject } = intent.data;
+                if (subject?.threads === void 0) {
+                  try {
+                    subject.threads = [];
+                  } catch (err) {
+                    log.error("Subject does not support threads array", subject?.typename, {
+                      F: __dxlog_file,
+                      L: 347,
+                      S: void 0,
+                      C: (f, a) => f(...a)
+                    });
+                    return;
+                  }
+                }
+                const subjectId = fullyQualifiedId5(subject);
+                const thread = create2(ThreadType2, {
+                  name,
+                  anchor: cursor,
+                  messages: [],
+                  status: "staged"
+                });
+                const draft = state.drafts[subjectId];
+                if (draft) {
+                  draft.push(thread);
+                } else {
+                  state.drafts[subjectId] = [
+                    thread
+                  ];
+                }
+                return {
+                  data: thread,
+                  intents: [
+                    [
+                      {
+                        action: ThreadAction.SELECT,
+                        data: {
+                          current: fullyQualifiedId5(thread)
+                        }
+                      }
+                    ],
+                    [
+                      {
+                        action: NavigationAction.OPEN,
+                        data: {
+                          activeParts: {
+                            complementary: "comments"
+                          }
+                        }
+                      }
+                    ],
+                    [
+                      {
+                        action: LayoutAction2.SET_LAYOUT,
+                        data: {
+                          element: "complementary",
+                          state: true
+                        }
+                      }
+                    ]
+                  ]
+                };
+              } else {
+                return {
+                  data: create2(ChannelType, {
+                    threads: [
+                      create2(ThreadType2, {
+                        messages: []
+                      })
+                    ]
+                  })
+                };
+              }
+            }
+            case ThreadAction.SELECT: {
+              state.current = intent.data?.current;
+              return {
+                data: true,
+                intents: !intent.data?.skipOpen ? [
+                  [
+                    {
+                      action: NavigationAction.OPEN,
+                      data: {
+                        activeParts: {
+                          complementary: "comments"
+                        }
+                      }
+                    }
+                  ]
+                ] : []
+              };
+            }
+            case ThreadAction.TOGGLE_RESOLVED: {
+              const { thread } = intent.data ?? {};
+              if (!(thread instanceof ThreadType2)) {
+                return;
+              }
+              if (thread.status === "active" || thread.status === void 0) {
+                thread.status = "resolved";
+              } else if (thread.status === "resolved") {
+                thread.status = "active";
+              }
+              const space = getSpace3(thread);
+              const spaceId = space?.id;
+              return {
+                data: true,
+                intents: [
+                  [
+                    {
+                      action: ObservabilityAction.SEND_EVENT,
+                      data: {
+                        name: "threads.toggle-resolved",
+                        properties: {
+                          threadId: thread.id,
+                          spaceId
+                        }
+                      }
+                    }
+                  ]
+                ]
+              };
+            }
+            case ThreadAction.DELETE: {
+              const { subject, thread } = intent.data ?? {};
+              if (!(thread instanceof ThreadType2) || !(subject && typeof subject === "object" && "threads" in subject)) {
+                return;
+              }
+              const subjectId = fullyQualifiedId5(subject);
+              const draft = state.drafts[subjectId];
+              if (draft) {
+                const index = draft.findIndex((t) => t.id === thread.id);
+                if (index !== -1) {
+                  draft.splice(index, 1);
+                  return {
+                    data: true
+                  };
+                }
+              }
+              const space = getSpace3(thread);
+              if (!space || !subject.threads) {
+                return;
+              }
+              if (!intent.undo) {
+                const index = subject.threads.findIndex((t) => t?.id === thread.id);
+                const cursor = subject.threads[index]?.anchor;
+                if (index !== -1) {
+                  subject.threads?.splice(index, 1);
+                }
+                space.db.remove(thread);
+                return {
+                  undoable: {
+                    message: translations_default[0]["en-US"][THREAD_PLUGIN]["thread deleted label"],
+                    data: {
+                      cursor
+                    }
+                  },
+                  intents: [
+                    [
+                      {
+                        action: ObservabilityAction.SEND_EVENT,
+                        data: {
+                          name: "threads.delete",
+                          properties: {
+                            threadId: thread.id,
+                            spaceId: space.id
+                          }
+                        }
+                      }
+                    ]
+                  ]
+                };
+              } else if (intent.undo) {
+                const savedThread = space.db.add(thread);
+                subject.threads.push(savedThread);
+                return {
+                  data: true,
+                  intents: [
+                    [
+                      {
+                        action: ObservabilityAction.SEND_EVENT,
+                        data: {
+                          name: "threads.undo-delete",
+                          properties: {
+                            threadId: thread.id,
+                            spaceId: space.id
+                          }
+                        }
+                      }
+                    ]
+                  ]
+                };
+              }
+              break;
+            }
+            case ThreadAction.ON_MESSAGE_ADD: {
+              const { thread, subject } = intent.data ?? {};
+              if (!(thread instanceof ThreadType2) || !(subject && typeof subject === "object" && "threads" in subject && Array.isArray(subject.threads))) {
+                return;
+              }
+              const subjectId = fullyQualifiedId5(subject);
+              const space = getSpace3(subject);
+              const intents = [];
+              const analyticsProperties = {
+                threadId: thread.id,
+                spaceId: space?.id
+              };
+              if (state.drafts[subjectId]?.find((t) => t === thread)) {
+                thread.status = "active";
+                subject.threads ? subject.threads.push(thread) : subject.threads = [
+                  thread
+                ];
+                state.drafts[subjectId] = state.drafts[subjectId]?.filter(({ id }) => id !== thread.id);
+                intents.push({
+                  action: ObservabilityAction.SEND_EVENT,
+                  data: {
+                    name: "threads.thread-created",
+                    properties: analyticsProperties
+                  }
+                });
+              }
+              intents.push({
+                action: ObservabilityAction.SEND_EVENT,
+                data: {
+                  name: "threads.message-added",
+                  properties: {
+                    ...analyticsProperties,
+                    threadLength: thread.messages.length
+                  }
+                }
+              });
+              return {
+                data: thread,
+                intents: [
+                  intents
+                ]
+              };
+            }
+            case ThreadAction.DELETE_MESSAGE: {
+              const { subject, thread, messageId } = intent.data ?? {};
+              const space = getSpace3(subject);
+              if (!(thread instanceof ThreadType2) || !(subject && typeof subject === "object" && "threads" in subject)) {
+                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: ThreadAction.DELETE,
+                          data: {
+                            subject,
+                            thread
+                          }
+                        }
+                      ]
+                    ]
+                  };
+                } else {
+                  thread.messages.splice(messageIndex, 1);
+                }
+                return {
+                  undoable: {
+                    message: translations_default[0]["en-US"][THREAD_PLUGIN]["message deleted label"],
+                    data: {
+                      message,
+                      messageIndex
+                    }
+                  },
+                  intents: [
+                    [
+                      {
+                        action: 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 MessageType2) || !(typeof messageIndex === "number")) {
+                  return;
+                }
+                thread.messages.splice(messageIndex, 0, message);
+                return {
+                  data: true,
+                  intents: [
+                    [
+                      {
+                        action: ObservabilityAction.SEND_EVENT,
+                        data: {
+                          name: "threads.message.undo-delete",
+                          properties: {
+                            threadId: thread.id,
+                            spaceId: space?.id
+                          }
+                        }
+                      }
+                    ]
+                  ]
+                };
+              }
+            }
+          }
+        }
+      },
+      markdown: {
+        extensions: ({ document: doc }) => {
+          return threads(state, doc, intentPlugin?.provides.intent.dispatch);
+        }
+      }
+    }
+  };
+};
+
+// packages/plugins/plugin-thread/src/index.ts
+var src_default = ThreadPlugin;
+export {
+  ThreadAction,
+  ThreadPlugin,
+  src_default as default,
+  useAnalyticsCallback,
+  useOnEditAnalytics,
+  useStatus
+};
+//# sourceMappingURL=index.mjs.map