@dxos/plugin-thread 0.6.12-main.f9d0246 → 0.6.12-staging.0b4bb48

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

@@ -1,1133 +0,0 @@
-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-import {
-  ThreadAction
-} from "./chunk-YO46JGAE.mjs";
-import {
-  ChatContainer,
-  ChatHeading,
-  MessageContainer,
-  command,
-  getMessageMetadata,
-  useAnalyticsCallback,
-  useOnEditAnalytics,
-  useStatus
-} from "./chunk-A44C4MTQ.mjs";
-import {
-  THREAD_ITEM,
-  THREAD_PLUGIN,
-  meta_default
-} from "./chunk-Y475KZTX.mjs";
-
-// packages/plugins/plugin-thread/src/ThreadPlugin.tsx
-import { computed, effect } from "@preact/signals-core";
-import React6 from "react";
-import { LayoutAction as LayoutAction2, NavigationAction, parseIntentPlugin, parseNavigationPlugin, resolvePlugin, isLayoutParts, parseMetadataResolverPlugin } from "@dxos/app-framework";
-import { getTypename } from "@dxos/echo-schema";
-import { create as create2 } from "@dxos/echo-schema";
-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, MessageType as MessageType2, ChannelType } from "@dxos/plugin-space/types";
-import { getSpace as getSpace2, getTextInRange, createDocAccessor, fullyQualifiedId as fullyQualifiedId4, loadObjectReferences } from "@dxos/react-client/echo";
-import { comments, createExternalCommentSync, listener as listener2 } from "@dxos/react-ui-editor";
-import { translations as threadTranslations } from "@dxos/react-ui-thread";
-import { nonNullable as nonNullable3 } from "@dxos/util";
-
-// packages/plugins/plugin-thread/src/components/index.ts
-import React4 from "react";
-
-// packages/plugins/plugin-thread/src/components/ThreadSettings.tsx
-import React from "react";
-import { SettingsValue } from "@dxos/plugin-settings";
-import { Input, useTranslation } from "@dxos/react-ui";
-var ThreadSettings = ({ settings }) => {
-  const { t } = useTranslation(THREAD_PLUGIN);
-  return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(SettingsValue, {
-    label: t("settings standalone label")
-  }, /* @__PURE__ */ React.createElement(Input.Switch, {
-    checked: settings.standalone,
-    onCheckedChange: (checked) => settings.standalone = !!checked
-  })));
-};
-
-// packages/plugins/plugin-thread/src/components/CommentContainer.tsx
-import { CheckCircle, X } from "@phosphor-icons/react";
-import React2, { useCallback, useEffect, 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 as useTranslation2 } 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 } = useTranslation2(THREAD_PLUGIN);
-  const label = t(isResolved ? "mark as unresolved label" : "mark as resolved label");
-  return /* @__PURE__ */ React2.createElement(Tooltip.Root, null, /* @__PURE__ */ React2.createElement(Tooltip.Trigger, {
-    asChild: true
-  }, /* @__PURE__ */ React2.createElement(Button, {
-    variant: "ghost",
-    "data-testid": "thread.toggle-resolved",
-    onClick: onResolve,
-    classNames: [
-      "min-bs-0 p-1",
-      !isResolved && hoverableControlItem
-    ]
-  }, /* @__PURE__ */ React2.createElement("span", {
-    className: "sr-only"
-  }, label), isResolved ? /* @__PURE__ */ React2.createElement(CheckCircle, {
-    className: sizeClass,
-    weight: "fill"
-  }) : /* @__PURE__ */ React2.createElement(CheckCircle, {
-    className: sizeClass
-  }))), /* @__PURE__ */ React2.createElement(Tooltip.Portal, null, /* @__PURE__ */ React2.createElement(Tooltip.Content, {
-    classNames: "z-[21]"
-  }, label, /* @__PURE__ */ React2.createElement(Tooltip.Arrow, null))));
-};
-var DeleteThreadButton = ({ onDelete }) => {
-  const { t } = useTranslation2(THREAD_PLUGIN);
-  const label = t("delete thread label");
-  return /* @__PURE__ */ React2.createElement(Tooltip.Root, null, /* @__PURE__ */ React2.createElement(Tooltip.Trigger, {
-    asChild: true
-  }, /* @__PURE__ */ React2.createElement(Button, {
-    variant: "ghost",
-    "data-testid": "thread.delete",
-    onClick: onDelete,
-    classNames: [
-      "min-bs-0 p-1",
-      hoverableControlItem
-    ]
-  }, /* @__PURE__ */ React2.createElement("span", {
-    className: "sr-only"
-  }, label), /* @__PURE__ */ React2.createElement(X, {
-    className: sizeClass
-  }))), /* @__PURE__ */ React2.createElement(Tooltip.Portal, null, /* @__PURE__ */ React2.createElement(Tooltip.Content, {
-    classNames: "z-[21]"
-  }, label, /* @__PURE__ */ React2.createElement(Tooltip.Arrow, null))));
-};
-var CommentContainer = ({ thread, detached, context, current, autoFocusTextbox, 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 } = useTranslation2(THREAD_PLUGIN);
-  const threadScrollRef = useRef(null);
-  const [autoFocus, setAutoFocus] = useState(!!autoFocusTextbox);
-  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
-  ]);
-  useEffect(() => {
-    setAutoFocus(!!autoFocusTextbox);
-  }, [
-    autoFocusTextbox
-  ]);
-  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 = "";
-    setAutoFocus(true);
-    scrollToEnd("instant");
-    rerenderEditor();
-    return true;
-  }, [
-    thread,
-    identity
-  ]);
-  return /* @__PURE__ */ React2.createElement(Thread, {
-    onClickCapture: onAttend,
-    onFocusCapture: onAttend,
-    current,
-    id: fullyQualifiedId(thread)
-  }, /* @__PURE__ */ React2.createElement("div", {
-    role: "none",
-    className: mx("col-span-2 grid grid-cols-[var(--rail-size)_1fr_min-content]", hoverableControls, hoverableFocusedWithinControls)
-  }, detached ? /* @__PURE__ */ React2.createElement(Tooltip.Root, null, /* @__PURE__ */ React2.createElement(Tooltip.Trigger, {
-    asChild: true
-  }, /* @__PURE__ */ React2.createElement(ThreadHeading, {
-    detached: true
-  }, thread.name ?? t("thread title placeholder"))), /* @__PURE__ */ React2.createElement(Tooltip.Portal, null, /* @__PURE__ */ React2.createElement(Tooltip.Content, {
-    classNames: "z-[21]",
-    side: "top"
-  }, t("detached thread label"), /* @__PURE__ */ React2.createElement(Tooltip.Arrow, null)))) : /* @__PURE__ */ React2.createElement(ThreadHeading, null, thread.name ?? t("thread title placeholder")), /* @__PURE__ */ React2.createElement("div", {
-    className: "flex flex-row items-center pli-1"
-  }, thread.status === "staged" && /* @__PURE__ */ React2.createElement(Tag, {
-    palette: "neutral"
-  }, t("draft button")), onResolve && !(thread?.status === "staged") && /* @__PURE__ */ React2.createElement(ToggleResolvedButton, {
-    isResolved: thread?.status === "resolved",
-    onResolve
-  }), onThreadDelete && /* @__PURE__ */ React2.createElement(DeleteThreadButton, {
-    onDelete: onThreadDelete
-  }))), thread.messages.filter(nonNullable).map((message) => /* @__PURE__ */ React2.createElement(MessageContainer, {
-    key: message.id,
-    message,
-    members,
-    onDelete: (id) => onMessageDelete?.(id)
-  })), /* @__PURE__ */ React2.createElement(MessageTextbox, {
-    extensions,
-    autoFocus,
-    onSend: handleCreate,
-    ...textboxMetadata
-  }), /* @__PURE__ */ React2.createElement(ThreadFooter, {
-    activity
-  }, t("activity message")), /* @__PURE__ */ React2.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 React3, { useEffect as useEffect2 } from "react";
-import { fullyQualifiedId as fullyQualifiedId2 } from "@dxos/react-client/echo";
-import { useTranslation as useTranslation3, Icon, Trans } from "@dxos/react-ui";
-import { PlankHeading } from "@dxos/react-ui-deck";
-import { descriptionText, mx as mx2 } from "@dxos/react-ui-theme";
-var CommentsHeading = ({ attendableId }) => {
-  const { t } = useTranslation3(THREAD_PLUGIN);
-  return /* @__PURE__ */ React3.createElement("div", {
-    role: "none",
-    className: "flex items-center"
-  }, /* @__PURE__ */ React3.createElement(PlankHeading.Button, {
-    attendableId
-  }, /* @__PURE__ */ React3.createElement(Icon, {
-    icon: "ph--quotes--regular",
-    size: 5
-  })), /* @__PURE__ */ React3.createElement(PlankHeading.Label, {
-    attendableId
-  }, t("comments heading")));
-};
-var CommentsContainer = ({ threads, detached = [], currentId, autoFocusCurrentTextbox, showResolvedThreads, onThreadAttend, onThreadDelete, onMessageDelete, onThreadToggleResolved, ...props }) => {
-  const { t } = useTranslation3(THREAD_PLUGIN);
-  const filteredThreads = showResolvedThreads ? threads : threads.filter((thread) => !(thread?.status === "resolved"));
-  useEffect2(() => {
-    if (currentId) {
-      document.getElementById(currentId)?.scrollIntoView({
-        behavior: "smooth",
-        block: "end"
-      });
-    }
-  }, [
-    currentId
-  ]);
-  return /* @__PURE__ */ React3.createElement(React3.Fragment, null, filteredThreads.length > 0 ? filteredThreads.map((thread) => {
-    const threadId = fullyQualifiedId2(thread);
-    return /* @__PURE__ */ React3.createElement(CommentContainer, {
-      key: threadId,
-      thread,
-      current: currentId === threadId,
-      detached: detached.includes(threadId),
-      autoFocusTextbox: autoFocusCurrentTextbox && currentId === threadId,
-      ...onThreadAttend && {
-        onAttend: () => onThreadAttend(thread)
-      },
-      ...onThreadDelete && {
-        onThreadDelete: () => onThreadDelete(thread)
-      },
-      ...onMessageDelete && {
-        onMessageDelete: (messageId) => onMessageDelete(thread, messageId)
-      },
-      ...onThreadToggleResolved && {
-        onResolve: () => onThreadToggleResolved(thread)
-      },
-      ...props
-    });
-  }) : /* @__PURE__ */ React3.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__ */ React3.createElement("h2", {
-    className: "mbe-2 font-medium text-baseText"
-  }, t("no comments title")), /* @__PURE__ */ React3.createElement("p", null, /* @__PURE__ */ React3.createElement(Trans, {
-    t,
-    i18nKey: "no comments message",
-    components: {
-      commentIcon: /* @__PURE__ */ React3.createElement(ChatText, {
-        className: "inline-block"
-      })
-    }
-  }))));
-};
-
-// packages/plugins/plugin-thread/src/components/index.ts
-var ThreadMain = React4.lazy(() => import("./ThreadMain-2A3VQLCW.mjs"));
-var ThreadArticle = React4.lazy(() => import("./ThreadArticle-NKI5F4W5.mjs"));
-
-// packages/plugins/plugin-thread/src/components/ThreadComplementary.tsx
-import React5, { useEffect as useEffect3, 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 { createAttendableAttributes, useAttentionContext } 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, stagedThreads, current, focus, 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 threads = useMemo2(() => {
-    return subject.threads.concat(stagedThreads ?? []).filter(nonNullable2);
-  }, [
-    JSON.stringify(subject.threads),
-    JSON.stringify(stagedThreads)
-  ]);
-  const detachedIds = useMemo2(() => {
-    return threads.filter(({ anchor }) => !anchor).map((thread) => fullyQualifiedId3(thread));
-  }, [
-    threads
-  ]);
-  useEffect3(() => {
-    if (!sort) {
-      return;
-    }
-    threads.sort((a, b) => sort(a?.anchor, b?.anchor));
-  }, [
-    sort,
-    threads
-  ]);
-  const { attended } = useAttentionContext("Thread Complementary");
-  const qualifiedSubjectId = fullyQualifiedId3(subject);
-  const attendableAttrs = createAttendableAttributes(qualifiedSubjectId);
-  return /* @__PURE__ */ React5.createElement("div", {
-    role: "none",
-    className: "contents group/attention",
-    ...attendableAttrs
-  }, role === "complementary" && /* @__PURE__ */ React5.createElement(CommentsHeading, {
-    attendableId: qualifiedSubjectId
-  }), /* @__PURE__ */ React5.createElement(ScrollArea.Root, {
-    classNames: "row-span-2"
-  }, /* @__PURE__ */ React5.createElement(ScrollArea.Viewport, null, /* @__PURE__ */ React5.createElement(CommentsContainer, {
-    threads,
-    detached: detachedIds,
-    currentId: attended.has(qualifiedSubjectId) ? current : void 0,
-    autoFocusCurrentTextbox: focus,
-    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__ */ React5.createElement("div", {
-    role: "none",
-    className: "bs-10"
-  }), /* @__PURE__ */ React5.createElement(ScrollArea.Scrollbar, null, /* @__PURE__ */ React5.createElement(ScrollArea.Thumb, null)))));
-};
-
-// 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({
-    staging: {}
-  });
-  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)
-          },
-          [ThreadType.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,
-          ThreadType,
-          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 [];
-          }
-          return [
-            createExtension({
-              id: `${THREAD_PLUGIN}/comments-for-subject`,
-              resolver: ({ id }) => {
-                if (!id.endsWith("~comments")) {
-                  return;
-                }
-                const subjectId = id.split("~").at(0);
-                const [spaceId, objectId] = subjectId?.split(":") ?? [];
-                const space = client.spaces.get().find((space2) => space2.id === spaceId);
-                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: "orphan-comments-for-subject",
-                  data: object,
-                  properties: {
-                    icon: meta.icon,
-                    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 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__ */ React6.createElement(ThreadMain, {
-                thread: data.active.threads[0]
-              }) : null;
-            }
-            case "settings": {
-              return data.plugin === meta_default.id ? /* @__PURE__ */ React6.createElement(ThreadSettings, {
-                settings: settings.values
-              }) : null;
-            }
-            case "article":
-            case "complementary": {
-              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 = getSpace2(data.object)?.db.getObjectById(objectToTheLeft.id);
-                    return /* @__PURE__ */ React6.createElement(ThreadArticle, {
-                      thread: data.object.threads[0],
-                      context
-                    });
-                  }
-                }
-                return /* @__PURE__ */ React6.createElement(ThreadArticle, {
-                  thread: data.object.threads[0]
-                });
-              }
-              if (data.subject instanceof ThreadType) {
-                return /* @__PURE__ */ React6.createElement(React6.Fragment, null, /* @__PURE__ */ React6.createElement(ChatHeading, {
-                  attendableId: data.subject.id
-                }), /* @__PURE__ */ React6.createElement(ChatContainer, {
-                  thread: data.subject
-                }));
-              }
-              if (data.subject && typeof data.subject === "object" && "threads" in data.subject && Array.isArray(data.subject.threads)) {
-                const { showResolvedThreads } = getViewState(fullyQualifiedId4(data.subject));
-                return /* @__PURE__ */ React6.createElement(ThreadComplementary, {
-                  role,
-                  subject: data.subject,
-                  stagedThreads: state.staging[fullyQualifiedId4(data.subject)],
-                  current: state.current,
-                  focus: true,
-                  showResolvedThreads
-                });
-              }
-            }
-          }
-          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 (e) {
-                    log.error("Subject does not support threads array", subject?.typename, {
-                      F: __dxlog_file,
-                      L: 332,
-                      S: void 0,
-                      C: (f, a) => f(...a)
-                    });
-                    return;
-                  }
-                }
-                const subjectId = fullyQualifiedId4(subject);
-                const thread = create2(ThreadType, {
-                  name,
-                  anchor: cursor,
-                  messages: [],
-                  status: "staged"
-                });
-                const stagingArea = state.staging[subjectId];
-                if (stagingArea) {
-                  stagingArea.push(thread);
-                } else {
-                  state.staging[subjectId] = [
-                    thread
-                  ];
-                }
-                return {
-                  data: thread,
-                  intents: [
-                    [
-                      {
-                        action: ThreadAction.SELECT,
-                        data: {
-                          current: fullyQualifiedId4(thread),
-                          focus: true
-                        }
-                      },
-                      {
-                        action: LayoutAction2.SET_LAYOUT,
-                        data: {
-                          element: "complementary",
-                          subject: subjectId,
-                          state: true
-                        }
-                      }
-                    ]
-                  ]
-                };
-              } else {
-                return {
-                  data: create2(ChannelType, {
-                    threads: [
-                      create2(ThreadType, {
-                        messages: []
-                      })
-                    ]
-                  })
-                };
-              }
-            }
-            case ThreadAction.SELECT: {
-              state.focus = intent.data?.current === state.current ? state.focus : intent.data?.focus;
-              state.current = intent.data?.current;
-              return {
-                data: true
-              };
-            }
-            case ThreadAction.TOGGLE_RESOLVED: {
-              const { thread } = intent.data ?? {};
-              if (!(thread instanceof ThreadType)) {
-                return;
-              }
-              if (thread.status === "active" || thread.status === void 0) {
-                thread.status = "resolved";
-              } else if (thread.status === "resolved") {
-                thread.status = "active";
-              }
-              const space = getSpace2(thread);
-              const spaceId = space?.id;
-              return {
-                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 ThreadType) || !(subject && typeof subject === "object" && "threads" in subject)) {
-                return;
-              }
-              const subjectId = fullyQualifiedId4(subject);
-              const stagingArea = state.staging[subjectId];
-              if (stagingArea) {
-                const index = stagingArea.findIndex((t) => t.id === thread.id);
-                if (index !== -1) {
-                  stagingArea.splice(index, 1);
-                  return {
-                    data: true
-                  };
-                }
-              }
-              const space = getSpace2(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 ThreadType) || !(subject && typeof subject === "object" && "threads" in subject && Array.isArray(subject.threads))) {
-                return;
-              }
-              const subjectId = fullyQualifiedId4(subject);
-              const space = getSpace2(subject);
-              const intents = [];
-              const analyticsProperties = {
-                threadId: thread.id,
-                spaceId: space?.id
-              };
-              if (state.staging[subjectId]?.find((t) => t === thread)) {
-                thread.status = "active";
-                subject.threads ? subject.threads.push(thread) : subject.threads = [
-                  thread
-                ];
-                state.staging[subjectId] = state.staging[subjectId]?.filter((t) => t.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 = getSpace2(subject);
-              if (!(thread instanceof ThreadType) || !(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: {
-        // TODO(burdon): Factor out extension factory into separate file (for simplicity).
-        extensions: ({ document: doc }) => {
-          const space = doc && getSpace2(doc);
-          if (!doc || !space) {
-            return [
-              comments()
-            ];
-          }
-          const threads = computed(() => [
-            ...doc.threads.filter(nonNullable3),
-            ...state.staging[fullyQualifiedId4(doc)] ?? []
-          ].filter((thread) => !(thread?.status === "resolved")));
-          return [
-            listener2({
-              onChange: () => {
-                doc.threads.forEach((thread) => {
-                  if (thread?.anchor) {
-                    const [start, end] = thread.anchor.split(":");
-                    const name = doc.content && getTextInRange(createDocAccessor(doc.content, [
-                      "content"
-                    ]), start, end);
-                    if (name && name !== thread.name) {
-                      thread.name = name;
-                    }
-                  }
-                });
-              }
-            }),
-            createExternalCommentSync(doc.id, (sink) => effect(() => sink()), () => threads.value.filter((thread) => thread?.anchor).map((thread) => ({
-              id: fullyQualifiedId4(thread),
-              cursor: thread.anchor
-            }))),
-            comments({
-              id: doc.id,
-              onCreate: ({ cursor }) => {
-                const [start, end] = cursor.split(":");
-                const name = doc.content && getTextInRange(createDocAccessor(doc.content, [
-                  "content"
-                ]), start, end);
-                void intentPlugin?.provides.intent.dispatch({
-                  action: ThreadAction.CREATE,
-                  data: {
-                    cursor,
-                    name,
-                    subject: doc
-                  }
-                });
-              },
-              onDelete: ({ id }) => {
-                const stagingArea = state.staging[fullyQualifiedId4(doc)];
-                if (stagingArea) {
-                  const index = stagingArea.findIndex((thread2) => fullyQualifiedId4(thread2) === 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[fullyQualifiedId4(doc)]?.find((thread2) => fullyQualifiedId4(thread2) === id) ?? doc.threads.find((thread2) => thread2?.id === id);
-                if (thread instanceof ThreadType && thread.anchor) {
-                  const [start, end] = thread.anchor.split(":");
-                  thread.name = doc.content && getTextInRange(createDocAccessor(doc.content, [
-                    "content"
-                  ]), start, end);
-                  thread.anchor = cursor;
-                }
-              },
-              onSelect: ({ selection: { current, closest } }) => {
-                const dispatch = intentPlugin?.provides.intent.dispatch;
-                if (dispatch) {
-                  void dispatch([
-                    {
-                      action: ThreadAction.SELECT,
-                      data: {
-                        current: current ?? closest
-                      }
-                    }
-                  ]);
-                }
-              }
-            })
-          ];
-        }
-      }
-    }
-  };
-};
-
-// 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