@dxos/plugin-thread 0.8.4-main.ae835ea → 0.8.4-main.bc2380dfbc

package/dist/lib/neutral/containers/index.mjs

@@ -0,0 +1,15 @@
+import "../chunk-J5LGTIGS.mjs";
+
+// src/containers/index.ts
+import { lazy } from "react";
+var ChannelChat = lazy(() => import("../ChannelChat-6YTD5HWL.mjs"));
+var ChannelArticle = lazy(() => import("../ChannelArticle-ACZD7YFT.mjs"));
+var ThreadContainer = lazy(() => import("../ThreadContainer-XYEPEOSD.mjs"));
+var ThreadCompanion = lazy(() => import("../ThreadCompanion-NQWPS2H6.mjs"));
+export {
+  ChannelArticle,
+  ChannelChat,
+  ThreadCompanion,
+  ThreadContainer
+};
+//# sourceMappingURL=index.mjs.map

package/dist/lib/neutral/containers/index.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/containers/index.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { type ComponentType, lazy } from 'react';\n\nexport const ChannelChat: ComponentType<any> = lazy(() => import('./ChannelChat'));\nexport const ChannelArticle: ComponentType<any> = lazy(() => import('./ChannelArticle'));\nexport const ThreadContainer: ComponentType<any> = lazy(() => import('./ThreadContainer'));\nexport const ThreadCompanion: ComponentType<any> = lazy(() => import('./ThreadCompanion'));\n"],
+  "mappings": ";;;AAIA,SAA6BA,YAAY;AAElC,IAAMC,cAAkCD,KAAK,MAAM,OAAO,6BAAA,CAAA;AAC1D,IAAME,iBAAqCF,KAAK,MAAM,OAAO,gCAAA,CAAA;AAC7D,IAAMG,kBAAsCH,KAAK,MAAM,OAAO,iCAAA,CAAA;AAC9D,IAAMI,kBAAsCJ,KAAK,MAAM,OAAO,iCAAA,CAAA;",
+  "names": ["lazy", "ChannelChat", "ChannelArticle", "ThreadContainer", "ThreadCompanion"]
+}

package/dist/lib/neutral/create-OAQJ6LXN.mjs

@@ -0,0 +1,52 @@
+import {
+  ThreadCapabilities_exports,
+  ThreadOperation_exports
+} from "./chunk-PE7IH7EL.mjs";
+import "./chunk-J5LGTIGS.mjs";
+
+// src/operations/create.ts
+import * as Effect from "effect/Effect";
+import { Capabilities, Capability } from "@dxos/app-framework";
+import { LayoutOperation } from "@dxos/app-toolkit";
+import { Operation } from "@dxos/compute";
+import { Obj, Relation } from "@dxos/echo";
+import { linkedSegment } from "@dxos/react-ui-attention";
+import { AnchoredTo, Thread } from "@dxos/types";
+var handler = ThreadOperation_exports.Create.pipe(Operation.withHandler(Effect.fnUntraced(function* ({ name, anchor: _anchor, subject }) {
+  const registry = yield* Capability.get(Capabilities.AtomRegistry);
+  const stateAtom = yield* Capability.get(ThreadCapabilities_exports.State);
+  const subjectId = Obj.getDXN(subject).toString();
+  const thread = Thread.make({
+    name
+  });
+  const anchor = Relation.make(AnchoredTo.AnchoredTo, {
+    [Relation.Source]: thread,
+    [Relation.Target]: subject,
+    anchor: _anchor
+  });
+  const state = registry.get(stateAtom);
+  const existingDrafts = state.drafts[subjectId];
+  registry.set(stateAtom, {
+    ...state,
+    drafts: {
+      ...state.drafts,
+      [subjectId]: existingDrafts ? [
+        ...existingDrafts,
+        anchor
+      ] : [
+        anchor
+      ]
+    }
+  });
+  yield* Operation.invoke(ThreadOperation_exports.Select, {
+    current: Obj.getDXN(thread).toString()
+  });
+  yield* Operation.invoke(LayoutOperation.UpdateCompanion, {
+    subject: linkedSegment("comments")
+  });
+})));
+var create_default = handler;
+export {
+  create_default as default
+};
+//# sourceMappingURL=create-OAQJ6LXN.mjs.map

package/dist/lib/neutral/create-OAQJ6LXN.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/operations/create.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { Capabilities, Capability } from '@dxos/app-framework';\nimport { LayoutOperation } from '@dxos/app-toolkit';\nimport { Operation } from '@dxos/compute';\nimport { Obj, Relation } from '@dxos/echo';\nimport { linkedSegment } from '@dxos/react-ui-attention';\nimport { AnchoredTo, Thread } from '@dxos/types';\n\nimport { ThreadCapabilities } from '../types';\nimport { ThreadOperation } from '../types';\n\nconst handler: Operation.WithHandler<typeof ThreadOperation.Create> = ThreadOperation.Create.pipe(\n  Operation.withHandler(\n    Effect.fnUntraced(function* ({ name, anchor: _anchor, subject }) {\n      const registry = yield* Capability.get(Capabilities.AtomRegistry);\n      const stateAtom = yield* Capability.get(ThreadCapabilities.State);\n      const subjectId = Obj.getDXN(subject).toString();\n      const thread = Thread.make({ name });\n      const anchor = Relation.make(AnchoredTo.AnchoredTo, {\n        [Relation.Source]: thread,\n        [Relation.Target]: subject,\n        anchor: _anchor,\n      });\n\n      const state = registry.get(stateAtom);\n      const existingDrafts = state.drafts[subjectId];\n      registry.set(stateAtom, {\n        ...state,\n        drafts: {\n          ...state.drafts,\n          [subjectId]: existingDrafts ? [...existingDrafts, anchor] : [anchor],\n        },\n      });\n\n      yield* Operation.invoke(ThreadOperation.Select, { current: Obj.getDXN(thread).toString() });\n      yield* Operation.invoke(LayoutOperation.UpdateCompanion, {\n        subject: linkedSegment('comments'),\n      });\n    }),\n  ),\n);\n\nexport default handler;\n"],
+  "mappings": ";;;;;;;AAIA,YAAYA,YAAY;AAExB,SAASC,cAAcC,kBAAkB;AACzC,SAASC,uBAAuB;AAChC,SAASC,iBAAiB;AAC1B,SAASC,KAAKC,gBAAgB;AAC9B,SAASC,qBAAqB;AAC9B,SAASC,YAAYC,cAAc;AAKnC,IAAMC,UAAgEC,wBAAgBC,OAAOC,KAC3FC,UAAUC,YACDC,kBAAW,WAAW,EAAEC,MAAMC,QAAQC,SAASC,QAAO,GAAE;AAC7D,QAAMC,WAAW,OAAOC,WAAWC,IAAIC,aAAaC,YAAY;AAChE,QAAMC,YAAY,OAAOJ,WAAWC,IAAII,2BAAmBC,KAAK;AAChE,QAAMC,YAAYC,IAAIC,OAAOX,OAAAA,EAASY,SAAQ;AAC9C,QAAMC,SAASC,OAAOC,KAAK;IAAElB;EAAK,CAAA;AAClC,QAAMC,SAASkB,SAASD,KAAKE,WAAWA,YAAY;IAClD,CAACD,SAASE,MAAM,GAAGL;IACnB,CAACG,SAASG,MAAM,GAAGnB;IACnBF,QAAQC;EACV,CAAA;AAEA,QAAMqB,QAAQnB,SAASE,IAAIG,SAAAA;AAC3B,QAAMe,iBAAiBD,MAAME,OAAOb,SAAAA;AACpCR,WAASsB,IAAIjB,WAAW;IACtB,GAAGc;IACHE,QAAQ;MACN,GAAGF,MAAME;MACT,CAACb,SAAAA,GAAYY,iBAAiB;WAAIA;QAAgBvB;UAAU;QAACA;;IAC/D;EACF,CAAA;AAEA,SAAOJ,UAAU8B,OAAOjC,wBAAgBkC,QAAQ;IAAEC,SAAShB,IAAIC,OAAOE,MAAAA,EAAQD,SAAQ;EAAG,CAAA;AACzF,SAAOlB,UAAU8B,OAAOG,gBAAgBC,iBAAiB;IACvD5B,SAAS6B,cAAc,UAAA;EACzB,CAAA;AACF,CAAA,CAAA,CAAA;AAIJ,IAAA,iBAAevC;",
+  "names": ["Effect", "Capabilities", "Capability", "LayoutOperation", "Operation", "Obj", "Relation", "linkedSegment", "AnchoredTo", "Thread", "handler", "ThreadOperation", "Create", "pipe", "Operation", "withHandler", "fnUntraced", "name", "anchor", "_anchor", "subject", "registry", "Capability", "get", "Capabilities", "AtomRegistry", "stateAtom", "ThreadCapabilities", "State", "subjectId", "Obj", "getDXN", "toString", "thread", "Thread", "make", "Relation", "AnchoredTo", "Source", "Target", "state", "existingDrafts", "drafts", "set", "invoke", "Select", "current", "LayoutOperation", "UpdateCompanion", "linkedSegment"]
+}

package/dist/lib/neutral/create-channel-3E4FJ662.mjs

@@ -0,0 +1,19 @@
+import {
+  ThreadOperation_exports
+} from "./chunk-PE7IH7EL.mjs";
+import "./chunk-J5LGTIGS.mjs";
+
+// src/operations/create-channel.ts
+import * as Effect from "effect/Effect";
+import { Operation } from "@dxos/compute";
+import { Channel } from "@dxos/types";
+var handler = ThreadOperation_exports.CreateChannel.pipe(Operation.withHandler((input) => Effect.sync(() => ({
+  object: Channel.make({
+    name: input.name
+  })
+}))));
+var create_channel_default = handler;
+export {
+  create_channel_default as default
+};
+//# sourceMappingURL=create-channel-3E4FJ662.mjs.map

package/dist/lib/neutral/create-channel-3E4FJ662.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/operations/create-channel.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { Operation } from '@dxos/compute';\nimport { Channel } from '@dxos/types';\n\nimport { ThreadOperation } from '../types';\n\nconst handler: Operation.WithHandler<typeof ThreadOperation.CreateChannel> = ThreadOperation.CreateChannel.pipe(\n  Operation.withHandler((input) =>\n    Effect.sync(() => ({\n      object: Channel.make({ name: input.name }),\n    })),\n  ),\n);\n\nexport default handler;\n"],
+  "mappings": ";;;;;;AAIA,YAAYA,YAAY;AAExB,SAASC,iBAAiB;AAC1B,SAASC,eAAe;AAIxB,IAAMC,UAAuEC,wBAAgBC,cAAcC,KACzGC,UAAUC,YAAY,CAACC,UACdC,YAAK,OAAO;EACjBC,QAAQC,QAAQC,KAAK;IAAEC,MAAML,MAAMK;EAAK,CAAA;AAC1C,EAAA,CAAA,CAAA;AAIJ,IAAA,yBAAeX;",
+  "names": ["Effect", "Operation", "Channel", "handler", "ThreadOperation", "CreateChannel", "pipe", "Operation", "withHandler", "input", "sync", "object", "Channel", "make", "name"]
+}

package/dist/lib/neutral/create-object-HIEWSBZB.mjs

@@ -0,0 +1,27 @@
+import "./chunk-J5LGTIGS.mjs";
+
+// src/capabilities/create-object.ts
+import * as Effect from "effect/Effect";
+import { Capability } from "@dxos/app-framework";
+import { Operation } from "@dxos/compute";
+import { SpaceOperation } from "@dxos/plugin-space";
+import { SpaceCapabilities } from "@dxos/plugin-space";
+import { Channel } from "@dxos/types";
+var create_object_default = Capability.makeModule(Effect.fnUntraced(function* () {
+  return Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+    id: Channel.Channel.typename,
+    createObject: (props, options) => Effect.gen(function* () {
+      const object = Channel.make(props);
+      return yield* Operation.invoke(SpaceOperation.AddObject, {
+        object,
+        target: options.target,
+        hidden: true,
+        targetNodeId: options.targetNodeId
+      });
+    })
+  });
+}));
+export {
+  create_object_default as default
+};
+//# sourceMappingURL=create-object-HIEWSBZB.mjs.map

package/dist/lib/neutral/create-object-HIEWSBZB.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/capabilities/create-object.ts"],
+  "sourcesContent": ["//\n// Copyright 2023 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { Capability } from '@dxos/app-framework';\nimport { Operation } from '@dxos/compute';\nimport { SpaceOperation } from '@dxos/plugin-space';\nimport { SpaceCapabilities } from '@dxos/plugin-space';\nimport { Channel } from '@dxos/types';\n\nexport default Capability.makeModule(\n  Effect.fnUntraced(function* () {\n    return Capability.contributes(SpaceCapabilities.CreateObjectEntry, {\n      id: Channel.Channel.typename,\n      createObject: (props, options) =>\n        Effect.gen(function* () {\n          const object = Channel.make(props);\n          return yield* Operation.invoke(SpaceOperation.AddObject, {\n            object,\n            target: options.target,\n            hidden: true,\n            targetNodeId: options.targetNodeId,\n          });\n        }),\n    });\n  }),\n);\n"],
+  "mappings": ";;;AAIA,YAAYA,YAAY;AAExB,SAASC,kBAAkB;AAC3B,SAASC,iBAAiB;AAC1B,SAASC,sBAAsB;AAC/B,SAASC,yBAAyB;AAClC,SAASC,eAAe;AAExB,IAAA,wBAAeJ,WAAWK,WACjBC,kBAAW,aAAA;AAChB,SAAON,WAAWO,YAAYJ,kBAAkBK,mBAAmB;IACjEC,IAAIL,QAAQA,QAAQM;IACpBC,cAAc,CAACC,OAAOC,YACbC,WAAI,aAAA;AACT,YAAMC,SAASX,QAAQY,KAAKJ,KAAAA;AAC5B,aAAO,OAAOX,UAAUgB,OAAOf,eAAegB,WAAW;QACvDH;QACAI,QAAQN,QAAQM;QAChBC,QAAQ;QACRC,cAAcR,QAAQQ;MACxB,CAAA;IACF,CAAA;EACJ,CAAA;AACF,CAAA,CAAA;",
+  "names": ["Effect", "Capability", "Operation", "SpaceOperation", "SpaceCapabilities", "Channel", "makeModule", "fnUntraced", "contributes", "CreateObjectEntry", "id", "typename", "createObject", "props", "options", "gen", "object", "make", "invoke", "AddObject", "target", "hidden", "targetNodeId"]
+}

package/dist/lib/neutral/create-proposals-GRYZXRMV.mjs

@@ -0,0 +1,56 @@
+import {
+  ThreadOperation_exports
+} from "./chunk-PE7IH7EL.mjs";
+import "./chunk-J5LGTIGS.mjs";
+
+// src/operations/create-proposals.ts
+import * as Array from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import { computeDiffsWithCursors } from "@dxos/assistant";
+import { Operation } from "@dxos/compute";
+import { Database, Obj, Ref, Relation } from "@dxos/echo";
+import { createDocAccessor } from "@dxos/echo-db";
+import { AnchoredTo, Message, Thread } from "@dxos/types";
+var handler = ThreadOperation_exports.CreateProposals.pipe(Operation.withHandler(Effect.fn(function* ({ doc, diffs }) {
+  const object = yield* Database.load(doc);
+  const content = yield* Effect.promise(() => object.content.load());
+  const accessor = createDocAccessor(content, [
+    "content"
+  ]);
+  yield* Function.pipe(computeDiffsWithCursors(accessor, diffs), Array.map(Effect.fnUntraced(function* ({ cursor, text }) {
+    const proposal = Obj.make(Message.Message, {
+      created: (/* @__PURE__ */ new Date()).toISOString(),
+      sender: {
+        role: "assistant"
+      },
+      blocks: [
+        {
+          _tag: "proposal",
+          text
+        }
+      ]
+    });
+    const thread = Thread.make({
+      name: "Proposal",
+      messages: [
+        Ref.make(proposal)
+      ],
+      status: "active"
+    });
+    const relation = Relation.make(AnchoredTo.AnchoredTo, {
+      [Relation.Source]: thread,
+      [Relation.Target]: object,
+      anchor: cursor
+    });
+    yield* Database.add(thread);
+    yield* Database.add(relation);
+  })), Effect.allWith({
+    concurrency: "unbounded"
+  }));
+})));
+var create_proposals_default = handler;
+export {
+  create_proposals_default as default
+};
+//# sourceMappingURL=create-proposals-GRYZXRMV.mjs.map

package/dist/lib/neutral/create-proposals-GRYZXRMV.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/operations/create-proposals.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Array from 'effect/Array';\nimport * as Effect from 'effect/Effect';\nimport * as Function from 'effect/Function';\n\nimport { computeDiffsWithCursors } from '@dxos/assistant';\nimport { Operation } from '@dxos/compute';\nimport { Database, Obj, Ref, Relation } from '@dxos/echo';\nimport { createDocAccessor } from '@dxos/echo-db';\nimport { AnchoredTo, Message, Thread } from '@dxos/types';\n\nimport { ThreadOperation } from '../types';\n\nconst handler: Operation.WithHandler<typeof ThreadOperation.CreateProposals> = ThreadOperation.CreateProposals.pipe(\n  Operation.withHandler(\n    Effect.fn(function* ({ doc, diffs }) {\n      const object = yield* Database.load(doc);\n      const content = yield* Effect.promise(() => object.content.load());\n      const accessor = createDocAccessor(content, ['content']);\n\n      yield* Function.pipe(\n        computeDiffsWithCursors(accessor, diffs),\n        Array.map(\n          Effect.fnUntraced(function* ({ cursor, text }) {\n            const proposal = Obj.make(Message.Message, {\n              created: new Date().toISOString(),\n              sender: { role: 'assistant' },\n              blocks: [{ _tag: 'proposal', text }],\n            });\n            const thread = Thread.make({ name: 'Proposal', messages: [Ref.make(proposal)], status: 'active' });\n            const relation = Relation.make(AnchoredTo.AnchoredTo, {\n              [Relation.Source]: thread,\n              [Relation.Target]: object,\n              anchor: cursor,\n            });\n            yield* Database.add(thread);\n            yield* Database.add(relation);\n          }),\n        ),\n        Effect.allWith({ concurrency: 'unbounded' }),\n      );\n    }),\n  ),\n);\n\nexport default handler;\n"],
+  "mappings": ";;;;;;AAIA,YAAYA,WAAW;AACvB,YAAYC,YAAY;AACxB,YAAYC,cAAc;AAE1B,SAASC,+BAA+B;AACxC,SAASC,iBAAiB;AAC1B,SAASC,UAAUC,KAAKC,KAAKC,gBAAgB;AAC7C,SAASC,yBAAyB;AAClC,SAASC,YAAYC,SAASC,cAAc;AAI5C,IAAMC,UAAyEC,wBAAgBC,gBAAgBC,KAC7GC,UAAUC,YACDC,UAAG,WAAW,EAAEC,KAAKC,MAAK,GAAE;AACjC,QAAMC,SAAS,OAAOC,SAASC,KAAKJ,GAAAA;AACpC,QAAMK,UAAU,OAAcC,eAAQ,MAAMJ,OAAOG,QAAQD,KAAI,CAAA;AAC/D,QAAMG,WAAWC,kBAAkBH,SAAS;IAAC;GAAU;AAEvD,SAAgBT,cACda,wBAAwBF,UAAUN,KAAAA,GAC5BS,UACGC,kBAAW,WAAW,EAAEC,QAAQC,KAAI,GAAE;AAC3C,UAAMC,WAAWC,IAAIC,KAAKC,QAAQA,SAAS;MACzCC,UAAS,oBAAIC,KAAAA,GAAOC,YAAW;MAC/BC,QAAQ;QAAEC,MAAM;MAAY;MAC5BC,QAAQ;QAAC;UAAEC,MAAM;UAAYX;QAAK;;IACpC,CAAA;AACA,UAAMY,SAASC,OAAOV,KAAK;MAAEW,MAAM;MAAYC,UAAU;QAACC,IAAIb,KAAKF,QAAAA;;MAAYgB,QAAQ;IAAS,CAAA;AAChG,UAAMC,WAAWC,SAAShB,KAAKiB,WAAWA,YAAY;MACpD,CAACD,SAASE,MAAM,GAAGT;MACnB,CAACO,SAASG,MAAM,GAAGjC;MACnBkC,QAAQxB;IACV,CAAA;AACA,WAAOT,SAASkC,IAAIZ,MAAAA;AACpB,WAAOtB,SAASkC,IAAIN,QAAAA;EACtB,CAAA,CAAA,GAEKO,eAAQ;IAAEC,aAAa;EAAY,CAAA,CAAA;AAE9C,CAAA,CAAA,CAAA;AAIJ,IAAA,2BAAe9C;",
+  "names": ["Array", "Effect", "Function", "computeDiffsWithCursors", "Operation", "Database", "Obj", "Ref", "Relation", "createDocAccessor", "AnchoredTo", "Message", "Thread", "handler", "ThreadOperation", "CreateProposals", "pipe", "Operation", "withHandler", "fn", "doc", "diffs", "object", "Database", "load", "content", "promise", "accessor", "createDocAccessor", "computeDiffsWithCursors", "map", "fnUntraced", "cursor", "text", "proposal", "Obj", "make", "Message", "created", "Date", "toISOString", "sender", "role", "blocks", "_tag", "thread", "Thread", "name", "messages", "Ref", "status", "relation", "Relation", "AnchoredTo", "Source", "Target", "anchor", "add", "allWith", "concurrency"]
+}

package/dist/lib/neutral/delete-HCCG5RVR.mjs

@@ -0,0 +1,57 @@
+import {
+  ThreadCapabilities_exports,
+  ThreadOperation_exports
+} from "./chunk-PE7IH7EL.mjs";
+import "./chunk-J5LGTIGS.mjs";
+
+// src/operations/delete.ts
+import * as Effect from "effect/Effect";
+import { Capabilities, Capability } from "@dxos/app-framework";
+import { sleep } from "@dxos/async";
+import { Operation } from "@dxos/compute";
+import { Obj, Relation } from "@dxos/echo";
+import { ObservabilityOperation } from "@dxos/plugin-observability";
+var handler = ThreadOperation_exports.Delete.pipe(Operation.withHandler(Effect.fnUntraced(function* ({ subject, anchor, thread: _thread }) {
+  const registry = yield* Capability.get(Capabilities.AtomRegistry);
+  const stateAtom = yield* Capability.get(ThreadCapabilities_exports.State);
+  const thread = _thread ?? Relation.getSource(anchor);
+  const subjectId = Obj.getDXN(subject).toString();
+  const state = registry.get(stateAtom);
+  const draft = state.drafts[subjectId];
+  if (draft) {
+    const index = draft.findIndex((a) => a.id === anchor.id);
+    if (index !== -1) {
+      registry.set(stateAtom, {
+        ...state,
+        drafts: {
+          ...state.drafts,
+          [subjectId]: state.drafts[subjectId]?.filter((_, i) => i !== index)
+        }
+      });
+      return {};
+    }
+  }
+  const db = Obj.getDatabase(thread);
+  if (!db) {
+    return {};
+  }
+  db.remove(anchor);
+  yield* Effect.promise(() => sleep(100));
+  db.remove(thread);
+  yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+    name: "threads.delete",
+    properties: {
+      spaceId: db.spaceId,
+      threadId: thread.id
+    }
+  });
+  return {
+    thread,
+    anchor
+  };
+})));
+var delete_default = handler;
+export {
+  delete_default as default
+};
+//# sourceMappingURL=delete-HCCG5RVR.mjs.map

package/dist/lib/neutral/delete-HCCG5RVR.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/operations/delete.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { Capabilities, Capability } from '@dxos/app-framework';\nimport { sleep } from '@dxos/async';\nimport { Operation } from '@dxos/compute';\nimport { Obj, Relation } from '@dxos/echo';\nimport { ObservabilityOperation } from '@dxos/plugin-observability';\nimport { Thread } from '@dxos/types';\n\nimport { ThreadCapabilities } from '../types';\nimport { ThreadOperation } from '../types';\n\nconst handler: Operation.WithHandler<typeof ThreadOperation.Delete> = ThreadOperation.Delete.pipe(\n  Operation.withHandler(\n    Effect.fnUntraced(function* ({ subject, anchor, thread: _thread }) {\n      const registry = yield* Capability.get(Capabilities.AtomRegistry);\n      const stateAtom = yield* Capability.get(ThreadCapabilities.State);\n      const thread = _thread ?? (Relation.getSource(anchor) as Thread.Thread);\n      const subjectId = Obj.getDXN(subject).toString();\n      const state = registry.get(stateAtom);\n      const draft = state.drafts[subjectId];\n      if (draft) {\n        const index = draft.findIndex((a: { id: string }) => a.id === anchor.id);\n        if (index !== -1) {\n          registry.set(stateAtom, {\n            ...state,\n            drafts: {\n              ...state.drafts,\n              [subjectId]: state.drafts[subjectId]?.filter((_, i) => i !== index),\n            },\n          });\n          return {};\n        }\n      }\n\n      const db = Obj.getDatabase(thread);\n      if (!db) {\n        return {};\n      }\n\n      // TODO(wittjosiah): Without sleep, rendering crashes at `Relation.setSource(anchor)`.\n      db.remove(anchor);\n      yield* Effect.promise(() => sleep(100));\n      db.remove(thread);\n\n      yield* Operation.schedule(ObservabilityOperation.SendEvent, {\n        name: 'threads.delete',\n        properties: {\n          spaceId: db.spaceId,\n          threadId: thread.id,\n        },\n      });\n\n      return { thread, anchor };\n    }),\n  ),\n);\n\nexport default handler;\n"],
+  "mappings": ";;;;;;;AAIA,YAAYA,YAAY;AAExB,SAASC,cAAcC,kBAAkB;AACzC,SAASC,aAAa;AACtB,SAASC,iBAAiB;AAC1B,SAASC,KAAKC,gBAAgB;AAC9B,SAASC,8BAA8B;AAMvC,IAAMC,UAAgEC,wBAAgBC,OAAOC,KAC3FC,UAAUC,YACDC,kBAAW,WAAW,EAAEC,SAASC,QAAQC,QAAQC,QAAO,GAAE;AAC/D,QAAMC,WAAW,OAAOC,WAAWC,IAAIC,aAAaC,YAAY;AAChE,QAAMC,YAAY,OAAOJ,WAAWC,IAAII,2BAAmBC,KAAK;AAChE,QAAMT,SAASC,WAAYS,SAASC,UAAUZ,MAAAA;AAC9C,QAAMa,YAAYC,IAAIC,OAAOhB,OAAAA,EAASiB,SAAQ;AAC9C,QAAMC,QAAQd,SAASE,IAAIG,SAAAA;AAC3B,QAAMU,QAAQD,MAAME,OAAON,SAAAA;AAC3B,MAAIK,OAAO;AACT,UAAME,QAAQF,MAAMG,UAAU,CAACC,MAAsBA,EAAEC,OAAOvB,OAAOuB,EAAE;AACvE,QAAIH,UAAU,IAAI;AAChBjB,eAASqB,IAAIhB,WAAW;QACtB,GAAGS;QACHE,QAAQ;UACN,GAAGF,MAAME;UACT,CAACN,SAAAA,GAAYI,MAAME,OAAON,SAAAA,GAAYY,OAAO,CAACC,GAAGC,MAAMA,MAAMP,KAAAA;QAC/D;MACF,CAAA;AACA,aAAO,CAAC;IACV;EACF;AAEA,QAAMQ,KAAKd,IAAIe,YAAY5B,MAAAA;AAC3B,MAAI,CAAC2B,IAAI;AACP,WAAO,CAAC;EACV;AAGAA,KAAGE,OAAO9B,MAAAA;AACV,SAAc+B,eAAQ,MAAMC,MAAM,GAAA,CAAA;AAClCJ,KAAGE,OAAO7B,MAAAA;AAEV,SAAOL,UAAUqC,SAASC,uBAAuBC,WAAW;IAC1DC,MAAM;IACNC,YAAY;MACVC,SAASV,GAAGU;MACZC,UAAUtC,OAAOsB;IACnB;EACF,CAAA;AAEA,SAAO;IAAEtB;IAAQD;EAAO;AAC1B,CAAA,CAAA,CAAA;AAIJ,IAAA,iBAAeR;",
+  "names": ["Effect", "Capabilities", "Capability", "sleep", "Operation", "Obj", "Relation", "ObservabilityOperation", "handler", "ThreadOperation", "Delete", "pipe", "Operation", "withHandler", "fnUntraced", "subject", "anchor", "thread", "_thread", "registry", "Capability", "get", "Capabilities", "AtomRegistry", "stateAtom", "ThreadCapabilities", "State", "Relation", "getSource", "subjectId", "Obj", "getDXN", "toString", "state", "draft", "drafts", "index", "findIndex", "a", "id", "set", "filter", "_", "i", "db", "getDatabase", "remove", "promise", "sleep", "schedule", "ObservabilityOperation", "SendEvent", "name", "properties", "spaceId", "threadId"]
+}

package/dist/lib/neutral/delete-message-DHFRACB4.mjs

@@ -0,0 +1,54 @@
+import {
+  ThreadOperation_exports
+} from "./chunk-PE7IH7EL.mjs";
+import "./chunk-J5LGTIGS.mjs";
+
+// src/operations/delete-message.ts
+import * as Effect from "effect/Effect";
+import { Operation } from "@dxos/compute";
+import { Obj, Relation } from "@dxos/echo";
+import { invariant } from "@dxos/invariant";
+import { ObservabilityOperation } from "@dxos/plugin-observability";
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-thread/src/operations/delete-message.ts";
+var handler = ThreadOperation_exports.DeleteMessage.pipe(Operation.withHandler(Effect.fnUntraced(function* ({ subject, anchor, messageId }) {
+  const thread = Relation.getSource(anchor);
+  const db = Obj.getDatabase(subject);
+  invariant(db, "Database not found", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 13, S: this, A: ["db", "'Database not found'"] });
+  const msgIndex = thread.messages.findIndex((ref) => ref.target?.id === messageId);
+  const msg = thread.messages[msgIndex]?.target;
+  if (!msg) {
+    return {
+      messageIndex: -1
+    };
+  }
+  if (msgIndex === 0 && thread.messages.length === 1) {
+    yield* Operation.invoke(ThreadOperation_exports.Delete, {
+      subject,
+      anchor
+    });
+    return {
+      messageIndex: -1
+    };
+  }
+  Obj.update(thread, (thread2) => {
+    thread2.messages.splice(msgIndex, 1);
+  });
+  yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+    name: "threads.message.delete",
+    properties: {
+      spaceId: db.spaceId,
+      threadId: thread.id,
+      threadLength: thread.messages.length,
+      messageId
+    }
+  });
+  return {
+    message: msg,
+    messageIndex: msgIndex
+  };
+})));
+var delete_message_default = handler;
+export {
+  delete_message_default as default
+};
+//# sourceMappingURL=delete-message-DHFRACB4.mjs.map

package/dist/lib/neutral/delete-message-DHFRACB4.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/operations/delete-message.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { Operation } from '@dxos/compute';\nimport { Obj, Relation } from '@dxos/echo';\nimport { invariant } from '@dxos/invariant';\nimport { ObservabilityOperation } from '@dxos/plugin-observability';\nimport { Thread } from '@dxos/types';\n\nimport { ThreadOperation } from '../types';\n\nconst handler: Operation.WithHandler<typeof ThreadOperation.DeleteMessage> = ThreadOperation.DeleteMessage.pipe(\n  Operation.withHandler(\n    Effect.fnUntraced(function* ({ subject, anchor, messageId }) {\n      const thread = Relation.getSource(anchor) as Thread.Thread;\n      const db = Obj.getDatabase(subject);\n      invariant(db, 'Database not found');\n\n      const msgIndex = thread.messages.findIndex((ref) => ref.target?.id === messageId);\n      const msg = thread.messages[msgIndex]?.target;\n      if (!msg) {\n        return { messageIndex: -1 };\n      }\n\n      if (msgIndex === 0 && thread.messages.length === 1) {\n        // TODO(wittjosiah): This doesn't support restoring the thread.\n        yield* Operation.invoke(ThreadOperation.Delete, { subject, anchor });\n        return { messageIndex: -1 };\n      }\n\n      Obj.update(thread, (thread) => {\n        thread.messages.splice(msgIndex, 1);\n      });\n\n      yield* Operation.schedule(ObservabilityOperation.SendEvent, {\n        name: 'threads.message.delete',\n        properties: {\n          spaceId: db.spaceId,\n          threadId: thread.id,\n          threadLength: thread.messages.length,\n          messageId,\n        },\n      });\n\n      return { message: msg, messageIndex: msgIndex };\n    }),\n  ),\n);\n\nexport default handler;\n"],
+  "mappings": ";;;;;;AAIA,YAAYA,YAAY;AAExB,SAASC,iBAAiB;AAC1B,SAASC,KAAKC,gBAAgB;AAC9B,SAASC,iBAAiB;AAC1B,SAASC,8BAA8B;AAKvC,IAAA,eAA6EC;IAIvE,UAAWC,wBAAgBC,cAAAA,KAAAA,UAAAA,YAAAA,kBAAAA,WAAAA,EAAAA,SAAAA,QAAAA,UAAAA,GAAAA;AAC3BC,QAAAA,SAAc,SAAA,UAAA,MAAA;AAEd,QAAMC,KAAAA,IAAAA,YAAkBC,OAASC;AACjC,YAAMC,IAAMC,sBAAgBJ,EAAAA,YAAWK,YAAAA,GAAAA,cAAAA,GAAAA,IAAAA,GAAAA,MAAAA,GAAAA,CAAAA,MAAAA,sBAAAA,EAAAA,CAAAA;AACvC,QAAKF,WAAK,OAAA,SAAA,UAAA,CAAA,QAAA,IAAA,QAAA,OAAA,SAAA;QACR,MAAO,OAAA,SAAA,QAAA,GAAA;YAAEG;AAAiB,WAAA;MAC5B,cAAA;IAEIN;;MAEF,aAAOO,KAAUC,OAAOZ,SAAAA,WAAgBa,GAAQ;WAAWC,UAAAA,OAAAA,wBAAAA,QAAAA;MAAO;MAClE;;AAA0B,WAAA;MAC5B,cAAA;IAEIC;;AAEJ,MAAA,OAAA,QAAA,CAAAP,YAAA;AAEA,IAAAA,QAAOG,SAAUK,OAASC,UAAAA,CAAAA;;SAExBC,UAAY,SAAA,uBAAA,WAAA;UACVC;gBACAC;MACAC,SAAAA,GAAAA;MACAC,UAAAA,OAAAA;MACF,cAAA,OAAA,SAAA;MACF;IAEA;;SAAuBZ;IAAuB,SAAA;IAChD,cAAA;EAIJ;;;",
+  "names": ["Effect", "Operation", "Obj", "Relation", "invariant", "ObservabilityOperation", "ThreadOperation", "Obj", "subject", "invariant", "msgIndex", "messages", "findIndex", "msg", "thread", "target", "messageIndex", "Operation", "invoke", "Delete", "anchor", "update", "schedule", "ObservabilityOperation", "properties", "spaceId", "threadId", "threadLength", "messageId"]
+}

package/dist/lib/neutral/hooks/index.mjs

@@ -0,0 +1,10 @@
+import {
+  useOnEditAnalytics,
+  useStatus
+} from "../chunk-QFDT33VT.mjs";
+import "../chunk-J5LGTIGS.mjs";
+export {
+  useOnEditAnalytics,
+  useStatus
+};
+//# sourceMappingURL=index.mjs.map

package/dist/lib/neutral/index.mjs

@@ -0,0 +1,28 @@
+import {
+  useOnEditAnalytics,
+  useStatus
+} from "./chunk-QFDT33VT.mjs";
+import {
+  THREAD_ITEM,
+  meta
+} from "./chunk-7GHUS3IX.mjs";
+import {
+  Settings_exports,
+  ThreadCapabilities_exports,
+  ThreadOperation_exports
+} from "./chunk-PE7IH7EL.mjs";
+import {
+  thread_blueprint_default
+} from "./chunk-5T5LPLBN.mjs";
+import "./chunk-J5LGTIGS.mjs";
+export {
+  Settings_exports as Settings,
+  THREAD_ITEM,
+  thread_blueprint_default as ThreadBlueprint,
+  ThreadCapabilities_exports as ThreadCapabilities,
+  ThreadOperation_exports as ThreadOperation,
+  meta,
+  useOnEditAnalytics,
+  useStatus
+};
+//# sourceMappingURL=index.mjs.map

package/dist/lib/neutral/markdown-BUORNCPG.mjs

@@ -0,0 +1,83 @@
+import {
+  threads
+} from "./chunk-KRXHIW4P.mjs";
+import "./chunk-J5LGTIGS.mjs";
+
+// src/capabilities/markdown.ts
+import { EditorView } from "@codemirror/view";
+import * as Effect from "effect/Effect";
+import { Capabilities, Capability } from "@dxos/app-framework";
+import { LayoutOperation } from "@dxos/app-toolkit";
+import { MarkdownCapabilities } from "@dxos/plugin-markdown";
+import { linkedSegment } from "@dxos/react-ui-attention";
+import { commentClickedEffect, commentsState, documentId, overlap } from "@dxos/ui-editor";
+import { ThreadCapabilities } from "#types";
+var markdown_default = Capability.makeModule(Effect.fnUntraced(function* () {
+  const capabilities = yield* Capability.Service;
+  return Capability.contributes(MarkdownCapabilities.Extensions, [
+    ({ document: doc }) => {
+      const { invokePromise } = capabilities.get(Capabilities.OperationInvoker);
+      const registry = capabilities.get(Capabilities.AtomRegistry);
+      const stateAtom = capabilities.get(ThreadCapabilities.State);
+      return threads({
+        registry,
+        stateAtom
+      }, doc, invokePromise);
+    },
+    ({ document: doc }) => {
+      if (!doc) {
+        return [];
+      }
+      const registry = capabilities.get(Capabilities.AtomRegistry);
+      const stateAtom = capabilities.get(ThreadCapabilities.State);
+      return EditorView.updateListener.of((update) => {
+        if (update.docChanged || update.selectionSet) {
+          const id = update.state.facet(documentId);
+          const overlaps = selectionOverlapsComment(update.state);
+          const current = registry.get(stateAtom);
+          registry.set(stateAtom, {
+            ...current,
+            toolbar: {
+              ...current.toolbar,
+              [id]: overlaps
+            }
+          });
+        }
+      });
+    },
+    ({ document: doc }) => {
+      if (!doc) {
+        return [];
+      }
+      const { invokePromise } = capabilities.get(Capabilities.OperationInvoker);
+      return EditorView.updateListener.of((update) => {
+        update.transactions.forEach((transaction) => {
+          transaction.effects.forEach(async (effect) => {
+            if (effect.is(commentClickedEffect)) {
+              void invokePromise(LayoutOperation.UpdateCompanion, {
+                subject: linkedSegment("comments")
+              });
+            }
+          });
+        });
+      });
+    }
+  ]);
+}));
+var selectionOverlapsComment = (state) => {
+  const commentState = state.field(commentsState, false);
+  if (commentState === void 0) {
+    return false;
+  }
+  const { selection } = state;
+  for (const range of selection.ranges) {
+    if (commentState.comments.some(({ range: commentRange }) => overlap(commentRange, range))) {
+      return true;
+    }
+  }
+  return false;
+};
+export {
+  markdown_default as default
+};
+//# sourceMappingURL=markdown-BUORNCPG.mjs.map

package/dist/lib/neutral/markdown-BUORNCPG.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/capabilities/markdown.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { EditorView } from '@codemirror/view';\nimport * as Effect from 'effect/Effect';\n\nimport { Capabilities, Capability } from '@dxos/app-framework';\nimport { LayoutOperation } from '@dxos/app-toolkit';\nimport { MarkdownCapabilities } from '@dxos/plugin-markdown';\nimport { linkedSegment } from '@dxos/react-ui-attention';\nimport { type EditorState, commentClickedEffect, commentsState, documentId, overlap } from '@dxos/ui-editor';\n\nimport { ThreadCapabilities } from '#types';\n\nimport { threads } from '../extensions';\n\nexport default Capability.makeModule(\n  Effect.fnUntraced(function* () {\n    // Get context for lazy capability access in callbacks.\n    const capabilities = yield* Capability.Service;\n\n    return Capability.contributes(MarkdownCapabilities.Extensions, [\n      ({ document: doc }) => {\n        const { invokePromise } = capabilities.get(Capabilities.OperationInvoker);\n        const registry = capabilities.get(Capabilities.AtomRegistry);\n        const stateAtom = capabilities.get(ThreadCapabilities.State);\n        return threads({ registry, stateAtom }, doc, invokePromise);\n      },\n      ({ document: doc }) => {\n        if (!doc) {\n          return [];\n        }\n        const registry = capabilities.get(Capabilities.AtomRegistry);\n        const stateAtom = capabilities.get(ThreadCapabilities.State);\n\n        return EditorView.updateListener.of((update) => {\n          if (update.docChanged || update.selectionSet) {\n            const id = update.state.facet(documentId);\n            const overlaps = selectionOverlapsComment(update.state);\n            const current = registry.get(stateAtom);\n            registry.set(stateAtom, {\n              ...current,\n              toolbar: { ...current.toolbar, [id]: overlaps },\n            });\n          }\n        });\n      },\n      ({ document: doc }) => {\n        if (!doc) {\n          return [];\n        }\n        const { invokePromise } = capabilities.get(Capabilities.OperationInvoker);\n\n        return EditorView.updateListener.of((update) => {\n          update.transactions.forEach((transaction) => {\n            transaction.effects.forEach(async (effect) => {\n              if (effect.is(commentClickedEffect)) {\n                void invokePromise(LayoutOperation.UpdateCompanion, {\n                  subject: linkedSegment('comments'),\n                });\n              }\n            });\n          });\n        });\n      },\n    ]);\n  }),\n);\n\nconst selectionOverlapsComment = (state: EditorState): boolean => {\n  // May not be defined if thread plugin not installed.\n  const commentState = state.field(commentsState, false);\n  if (commentState === undefined) {\n    return false;\n  }\n\n  const { selection } = state;\n  for (const range of selection.ranges) {\n    if (commentState.comments.some(({ range: commentRange }) => overlap(commentRange, range))) {\n      return true;\n    }\n  }\n\n  return false;\n};\n"],
+  "mappings": ";;;;;;AAIA,SAASA,kBAAkB;AAC3B,YAAYC,YAAY;AAExB,SAASC,cAAcC,kBAAkB;AACzC,SAASC,uBAAuB;AAChC,SAASC,4BAA4B;AACrC,SAASC,qBAAqB;AAC9B,SAA2BC,sBAAsBC,eAAeC,YAAYC,eAAe;AAE3F,SAASC,0BAA0B;AAInC,IAAA,mBAAeC,WAAWC,WACjBC,kBAAW,aAAA;AAEhB,QAAMC,eAAe,OAAOH,WAAWI;AAEvC,SAAOJ,WAAWK,YAAYC,qBAAqBC,YAAY;IAC7D,CAAC,EAAEC,UAAUC,IAAG,MAAE;AAChB,YAAM,EAAEC,cAAa,IAAKP,aAAaQ,IAAIC,aAAaC,gBAAgB;AACxE,YAAMC,WAAWX,aAAaQ,IAAIC,aAAaG,YAAY;AAC3D,YAAMC,YAAYb,aAAaQ,IAAIM,mBAAmBC,KAAK;AAC3D,aAAOC,QAAQ;QAAEL;QAAUE;MAAU,GAAGP,KAAKC,aAAAA;IAC/C;IACA,CAAC,EAAEF,UAAUC,IAAG,MAAE;AAChB,UAAI,CAACA,KAAK;AACR,eAAO,CAAA;MACT;AACA,YAAMK,WAAWX,aAAaQ,IAAIC,aAAaG,YAAY;AAC3D,YAAMC,YAAYb,aAAaQ,IAAIM,mBAAmBC,KAAK;AAE3D,aAAOE,WAAWC,eAAeC,GAAG,CAACC,WAAAA;AACnC,YAAIA,OAAOC,cAAcD,OAAOE,cAAc;AAC5C,gBAAMC,KAAKH,OAAOI,MAAMC,MAAMC,UAAAA;AAC9B,gBAAMC,WAAWC,yBAAyBR,OAAOI,KAAK;AACtD,gBAAMK,UAAUlB,SAASH,IAAIK,SAAAA;AAC7BF,mBAASmB,IAAIjB,WAAW;YACtB,GAAGgB;YACHE,SAAS;cAAE,GAAGF,QAAQE;cAAS,CAACR,EAAAA,GAAKI;YAAS;UAChD,CAAA;QACF;MACF,CAAA;IACF;IACA,CAAC,EAAEtB,UAAUC,IAAG,MAAE;AAChB,UAAI,CAACA,KAAK;AACR,eAAO,CAAA;MACT;AACA,YAAM,EAAEC,cAAa,IAAKP,aAAaQ,IAAIC,aAAaC,gBAAgB;AAExE,aAAOO,WAAWC,eAAeC,GAAG,CAACC,WAAAA;AACnCA,eAAOY,aAAaC,QAAQ,CAACC,gBAAAA;AAC3BA,sBAAYC,QAAQF,QAAQ,OAAOG,WAAAA;AACjC,gBAAIA,OAAOC,GAAGC,oBAAAA,GAAuB;AACnC,mBAAK/B,cAAcgC,gBAAgBC,iBAAiB;gBAClDC,SAASC,cAAc,UAAA;cACzB,CAAA;YACF;UACF,CAAA;QACF,CAAA;MACF,CAAA;IACF;GACD;AACH,CAAA,CAAA;AAGF,IAAMd,2BAA2B,CAACJ,UAAAA;AAEhC,QAAMmB,eAAenB,MAAMoB,MAAMC,eAAe,KAAA;AAChD,MAAIF,iBAAiBG,QAAW;AAC9B,WAAO;EACT;AAEA,QAAM,EAAEC,UAAS,IAAKvB;AACtB,aAAWwB,SAASD,UAAUE,QAAQ;AACpC,QAAIN,aAAaO,SAASC,KAAK,CAAC,EAAEH,OAAOI,aAAY,MAAOC,QAAQD,cAAcJ,KAAAA,CAAAA,GAAS;AACzF,aAAO;IACT;EACF;AAEA,SAAO;AACT;",
+  "names": ["EditorView", "Effect", "Capabilities", "Capability", "LayoutOperation", "MarkdownCapabilities", "linkedSegment", "commentClickedEffect", "commentsState", "documentId", "overlap", "ThreadCapabilities", "Capability", "makeModule", "fnUntraced", "capabilities", "Service", "contributes", "MarkdownCapabilities", "Extensions", "document", "doc", "invokePromise", "get", "Capabilities", "OperationInvoker", "registry", "AtomRegistry", "stateAtom", "ThreadCapabilities", "State", "threads", "EditorView", "updateListener", "of", "update", "docChanged", "selectionSet", "id", "state", "facet", "documentId", "overlaps", "selectionOverlapsComment", "current", "set", "toolbar", "transactions", "forEach", "transaction", "effects", "effect", "is", "commentClickedEffect", "LayoutOperation", "UpdateCompanion", "subject", "linkedSegment", "commentState", "field", "commentsState", "undefined", "selection", "range", "ranges", "comments", "some", "commentRange", "overlap"]
+}