@ecsplico/editor 0.0.0-stage → 2.0.0

package/dist/features/comments/components/CommentsPopover.js

@@ -0,0 +1,124 @@
+import { useUiKit } from "../../../vue/kit/use-ui-kit.js";
+import { useEditorSettings } from "../../../vue/settings.js";
+import { useComments } from "../use-comments.js";
+import _sfc_main$1 from "./CommentComposer.js";
+import _sfc_main$2 from "./CommentThreadView.js";
+import { computed, createBlock, createCommentVNode, defineComponent, openBlock, unref, withCtx } from "vue";
+//#region src/features/comments/components/CommentsPopover.vue
+const _sfc_main = /*@__PURE__*/ defineComponent({
+	__name: "CommentsPopover",
+	props: { editor: {} },
+	setup(__props) {
+		/**
+		* Inline comments („Inline“ layout): the draft composer or the active thread in a compact popover at its text.
+		* Opens when a comment is started or highlighted text is clicked (another highlight switches the thread); a click
+		* outside or Esc in the popover closes it (cancels the draft / deactivates the thread). Esc in the editor is a binding
+		* of `DocumentEditor` (ProseMirror marks every Esc in the editor as handled). Orphaned
+		* threads (opened from the toolbar's `CommentsListMenu`) anchor at the top of the editor. Renders only when the
+		* user's comments layout is `inline`.
+		*/
+		const props = __props;
+		const { Popover: UPopover } = useUiKit();
+		const { settings } = useEditorSettings();
+		const enabled = computed(() => settings.value.editing.commentsLayout === "inline");
+		const comments = useComments(() => enabled.value ? props.editor : void 0);
+		const activeThread = computed(() => {
+			const id = comments.active.value;
+			return id ? comments.threads.value.find((t) => t.id === id) ?? null : null;
+		});
+		const drafting = computed(() => !!comments.draft.value);
+		const open = computed(() => enabled.value && comments.available.value && (drafting.value || !!activeThread.value));
+		/** The draft range, else the active thread's range; null for an orphan. */
+		function anchorRange() {
+			const draft = comments.draft.value;
+			if (draft) return draft;
+			const id = comments.active.value;
+			return id ? comments.ranges.value.get(id) ?? null : null;
+		}
+		let anchorRect = new DOMRect();
+		/** Virtual reference: the anchor text (its first line's extent, or the editor's width when it spans lines). */
+		const reference = {
+			getBoundingClientRect() {
+				const editor = props.editor;
+				if (!editor || editor.isDestroyed) return anchorRect;
+				const { view } = editor;
+				const bounds = view.dom.getBoundingClientRect();
+				const range = anchorRange();
+				if (!range || range.from >= range.to || range.to > editor.state.doc.content.size) {
+					anchorRect = new DOMRect(bounds.left, bounds.top, Math.max(bounds.width, 1), 1);
+					return anchorRect;
+				}
+				const start = view.coordsAtPos(range.from, 1);
+				const end = view.coordsAtPos(range.to, -1);
+				const oneLine = end.top < start.bottom;
+				const left = oneLine ? start.left : bounds.left;
+				const right = oneLine ? end.right : bounds.right;
+				anchorRect = new DOMRect(left, start.top, Math.max(right - left, 1), end.bottom - start.top);
+				return anchorRect;
+			},
+			get contextElement() {
+				const editor = props.editor;
+				return editor && !editor.isDestroyed ? editor.view.dom : void 0;
+			}
+		};
+		function close() {
+			if (drafting.value) comments.cancelDraft();
+			else comments.activate(null);
+		}
+		/** Menus of the thread (dropdowns, portalled) count as inside, so choosing an action does not close the popover. */
+		function onInteractOutside(event) {
+			const target = event.detail?.originalEvent?.target ?? event.target;
+			if (target instanceof Element && target.closest("[role=\"menu\"], [data-reka-popper-content-wrapper]")) event.preventDefault();
+		}
+		/** The active thread keeps the editor focused (clicks in the text activate it); the composer focuses itself. */
+		function onOpenAutoFocus(event) {
+			if (!drafting.value) event.preventDefault();
+		}
+		return (_ctx, _cache) => {
+			return enabled.value ? (openBlock(), createBlock(unref(UPopover), {
+				key: 0,
+				open: open.value,
+				reference,
+				content: {
+					side: "bottom",
+					align: "start",
+					sideOffset: 4,
+					updatePositionStrategy: "always",
+					onInteractOutside,
+					onOpenAutoFocus,
+					onCloseAutoFocus: (e) => e.preventDefault()
+				},
+				ui: { content: "w-72 max-w-[calc(100vw-2rem)] max-h-[60vh] overflow-auto p-2" },
+				"onUpdate:open": _cache[2] || (_cache[2] = (value) => {
+					if (!value) close();
+				})
+			}, {
+				content: withCtx(() => [drafting.value ? (openBlock(), createBlock(_sfc_main$1, {
+					key: 0,
+					dense: "",
+					quote: unref(comments).draftQuote.value,
+					onSubmit: _cache[0] || (_cache[0] = (text) => unref(comments).add(text)),
+					onCancel: _cache[1] || (_cache[1] = ($event) => unref(comments).cancelDraft())
+				}, null, 8, ["quote"])) : activeThread.value ? (openBlock(), createBlock(_sfc_main$2, {
+					key: 1,
+					dense: "",
+					thread: activeThread.value,
+					user: unref(comments).user.value,
+					active: true,
+					orphan: unref(comments).isOrphan(activeThread.value.id),
+					comments: unref(comments)
+				}, null, 8, [
+					"thread",
+					"user",
+					"orphan",
+					"comments"
+				])) : createCommentVNode("v-if", true)]),
+				_: 1
+			}, 8, ["open", "content"])) : createCommentVNode("v-if", true);
+		};
+	}
+});
+//#endregion
+export { _sfc_main as default };
+
+//# sourceMappingURL=CommentsPopover.js.map

package/dist/features/comments/components/CommentsPopover.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CommentsPopover.js","names":["_openBlock","_createBlock","_unref","_withCtx","CommentComposer","CommentThreadView","_createCommentVNode"],"sources":["../../../../src/features/comments/components/CommentsPopover.vue"],"sourcesContent":["<script setup lang=\"ts\">\n/**\n * Inline comments („Inline“ layout): the draft composer or the active thread in a compact popover at its text.\n * Opens when a comment is started or highlighted text is clicked (another highlight switches the thread); a click\n * outside or Esc in the popover closes it (cancels the draft / deactivates the thread). Esc in the editor is a binding\n * of `DocumentEditor` (ProseMirror marks every Esc in the editor as handled). Orphaned\n * threads (opened from the toolbar's `CommentsListMenu`) anchor at the top of the editor. Renders only when the\n * user's comments layout is `inline`.\n */\nimport { useUiKit } from '../../../vue/kit/use-ui-kit'\nimport type { Editor } from '@tiptap/vue-3'\nimport { computed } from 'vue'\nimport { useComments } from '../use-comments'\nimport { useEditorSettings } from '../../../vue/settings'\nimport CommentComposer from './CommentComposer.vue'\nimport CommentThreadView from './CommentThreadView.vue'\n\nconst props = defineProps<{ editor: Editor | undefined }>()\nconst { Popover: UPopover } = useUiKit()\n\nconst { settings } = useEditorSettings()\nconst enabled = computed(() => settings.value.editing.commentsLayout === 'inline')\n// Idle (no Y.Doc observer) while another layout shows the comments.\nconst comments = useComments(() => enabled.value ? props.editor : undefined)\n\nconst activeThread = computed(() => {\n  const id = comments.active.value\n  return id ? comments.threads.value.find(t => t.id === id) ?? null : null\n})\nconst drafting = computed(() => !!comments.draft.value)\nconst open = computed(() => enabled.value && comments.available.value && (drafting.value || !!activeThread.value))\n\n/** The draft range, else the active thread's range; null for an orphan. */\nfunction anchorRange() {\n  const draft = comments.draft.value\n  if (draft) return draft\n  const id = comments.active.value\n  return id ? comments.ranges.value.get(id) ?? null : null\n}\n\nlet anchorRect = new DOMRect()\n/** Virtual reference: the anchor text (its first line's extent, or the editor's width when it spans lines). */\nconst reference = {\n  getBoundingClientRect(): DOMRect {\n    const editor = props.editor\n    if (!editor || editor.isDestroyed) return anchorRect\n    const { view } = editor\n    const bounds = view.dom.getBoundingClientRect()\n    const range = anchorRange()\n    if (!range || range.from >= range.to || range.to > editor.state.doc.content.size) {\n      anchorRect = new DOMRect(bounds.left, bounds.top, Math.max(bounds.width, 1), 1)\n      return anchorRect\n    }\n    const start = view.coordsAtPos(range.from, 1)\n    const end = view.coordsAtPos(range.to, -1)\n    const oneLine = end.top < start.bottom\n    const left = oneLine ? start.left : bounds.left\n    const right = oneLine ? end.right : bounds.right\n    anchorRect = new DOMRect(left, start.top, Math.max(right - left, 1), end.bottom - start.top)\n    return anchorRect\n  },\n  get contextElement() {\n    const editor = props.editor\n    return editor && !editor.isDestroyed ? editor.view.dom : undefined\n  },\n}\n\nfunction close() {\n  if (drafting.value) comments.cancelDraft()\n  else comments.activate(null)\n}\n\n/** Menus of the thread (dropdowns, portalled) count as inside, so choosing an action does not close the popover. */\nfunction onInteractOutside(event: Event) {\n  const target = (event as CustomEvent<{ originalEvent: Event }>).detail?.originalEvent?.target ?? event.target\n  if (target instanceof Element && target.closest('[role=\"menu\"], [data-reka-popper-content-wrapper]')) event.preventDefault()\n}\n\n/** The active thread keeps the editor focused (clicks in the text activate it); the composer focuses itself. */\nfunction onOpenAutoFocus(event: Event) {\n  if (!drafting.value) event.preventDefault()\n}\n</script>\n\n<template>\n  <UPopover\n    v-if=\"enabled\"\n    :open=\"open\"\n    :reference=\"reference\"\n    :content=\"{ side: 'bottom', align: 'start', sideOffset: 4, updatePositionStrategy: 'always', onInteractOutside, onOpenAutoFocus, onCloseAutoFocus: (e: Event) => e.preventDefault() }\"\n    :ui=\"{ content: 'w-72 max-w-[calc(100vw-2rem)] max-h-[60vh] overflow-auto p-2' }\"\n    @update:open=\"(value: boolean) => { if (!value) close() }\"\n  >\n    <template #content>\n      <CommentComposer\n        v-if=\"drafting\"\n        dense\n        :quote=\"comments.draftQuote.value\"\n        @submit=\"(text: string) => comments.add(text)\"\n        @cancel=\"comments.cancelDraft()\"\n      />\n      <CommentThreadView\n        v-else-if=\"activeThread\"\n        dense\n        :thread=\"activeThread\"\n        :user=\"comments.user.value\"\n        :active=\"true\"\n        :orphan=\"comments.isOrphan(activeThread.id)\"\n        :comments=\"comments\"\n      />\n    </template>\n  </UPopover>\n</template>\n"],"mappings":"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"}

package/dist/features/comments/components/CommentsPopover.vue.d.ts

@@ -0,0 +1,10 @@
+import { Editor } from "@tiptap/vue-3";
+//#region src/features/comments/components/CommentsPopover.vue.d.ts
+type __VLS_Props = {
+  editor: Editor | undefined;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+//#endregion
+export { _default as default };
+//# sourceMappingURL=CommentsPopover.vue.d.ts.map

package/dist/features/comments/components/CommentsToolbarButton.js

@@ -0,0 +1,61 @@
+import { useUiKit } from "../../../vue/kit/use-ui-kit.js";
+import { useEditorSettings } from "../../../vue/settings.js";
+import { useEditorI18n } from "../../../vue/use-editor-i18n.js";
+import { useEditorUi } from "../../../vue/use-editor-ui.js";
+import { useComments } from "../use-comments.js";
+import _sfc_main$1 from "./CommentsListMenu.js";
+import { createBlock, createVNode, defineComponent, openBlock, unref, withCtx, withModifiers } from "vue";
+//#region src/features/comments/components/CommentsToolbarButton.vue
+/**
+* Toolbar entry of the comments feature, by the user's layout: in `margin` the „Kommentare“ toggle of the margin
+* column (Mod-Shift-m; disabled with an explanation without a collaborative document), in `inline` the
+* `CommentsListMenu` with the number of open threads.
+*/
+const _sfc_main = /*@__PURE__*/ defineComponent({
+	__name: "CommentsToolbarButton",
+	props: { editor: {} },
+	setup(__props) {
+		const props = __props;
+		const { Button: UButton, Tooltip: UTooltip } = useUiKit();
+		const { settings } = useEditorSettings();
+		const { t } = useEditorI18n();
+		const editorUi = useEditorUi(() => props.editor);
+		const available = useComments(() => props.editor).available;
+		return (_ctx, _cache) => {
+			return unref(settings).editing.commentsLayout === "margin" ? (openBlock(), createBlock(unref(UTooltip), {
+				key: 0,
+				text: unref(available) ? unref(t)("comments.title") : unref(t)("comments.unavailable"),
+				kbds: unref(available) ? [
+					"meta",
+					"shift",
+					"m"
+				] : void 0
+			}, {
+				default: withCtx(() => [createVNode(unref(UButton), {
+					color: "neutral",
+					variant: "ghost",
+					"active-color": "primary",
+					"active-variant": "soft",
+					icon: "i-lucide-message-square-text",
+					"aria-label": unref(t)("comments.title"),
+					active: !!unref(editorUi)?.commentsOpen,
+					disabled: !unref(editorUi) || !unref(available),
+					onMousedown: _cache[0] || (_cache[0] = withModifiers(() => {}, ["prevent"])),
+					onClick: _cache[1] || (_cache[1] = ($event) => unref(editorUi)?.toggleComments())
+				}, null, 8, [
+					"aria-label",
+					"active",
+					"disabled"
+				])]),
+				_: 1
+			}, 8, ["text", "kbds"])) : (openBlock(), createBlock(_sfc_main$1, {
+				key: 1,
+				editor: props.editor
+			}, null, 8, ["editor"]));
+		};
+	}
+});
+//#endregion
+export { _sfc_main as default };
+
+//# sourceMappingURL=CommentsToolbarButton.js.map

package/dist/features/comments/components/CommentsToolbarButton.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CommentsToolbarButton.js","names":["_unref","_openBlock","_createBlock","_withCtx","_createVNode","_withModifiers","CommentsListMenu"],"sources":["../../../../src/features/comments/components/CommentsToolbarButton.vue"],"sourcesContent":["<script setup lang=\"ts\">\nimport { useUiKit } from '../../../vue/kit/use-ui-kit'\nimport type { Editor } from '@tiptap/vue-3'\nimport { useEditorSettings } from '../../../vue/settings'\nimport { useEditorI18n } from '../../../vue/use-editor-i18n'\nimport { useEditorUi } from '../../../vue/use-editor-ui'\nimport { useComments } from '../use-comments'\nimport CommentsListMenu from './CommentsListMenu.vue'\n\n/**\n * Toolbar entry of the comments feature, by the user's layout: in `margin` the „Kommentare“ toggle of the margin\n * column (Mod-Shift-m; disabled with an explanation without a collaborative document), in `inline` the\n * `CommentsListMenu` with the number of open threads.\n */\nconst props = defineProps<{ editor: Editor | undefined }>()\nconst { Button: UButton, Tooltip: UTooltip } = useUiKit()\n\nconst { settings } = useEditorSettings()\nconst { t } = useEditorI18n()\n// The toolbar sits beside the surface (outside its provide): the chrome registered for `props.editor`.\nconst editorUi = useEditorUi(() => props.editor)\n// Without comments (the default model needs collaboration) the button is disabled and its tooltip says why.\nconst comments = useComments(() => props.editor)\nconst available = comments.available\n</script>\n\n<template>\n  <UTooltip\n    v-if=\"settings.editing.commentsLayout === 'margin'\"\n    :text=\"available ? t('comments.title') : t('comments.unavailable')\"\n    :kbds=\"available ? ['meta', 'shift', 'm'] : undefined\"\n  >\n    <UButton\n      color=\"neutral\"\n      variant=\"ghost\"\n      active-color=\"primary\"\n      active-variant=\"soft\"\n      icon=\"i-lucide-message-square-text\"\n      :aria-label=\"t('comments.title')\"\n      :active=\"!!editorUi?.commentsOpen\"\n      :disabled=\"!editorUi || !available\"\n      @mousedown.prevent\n      @click=\"editorUi?.toggleComments()\"\n    />\n  </UTooltip>\n  <CommentsListMenu v-else :editor=\"props.editor\" />\n</template>\n"],"mappings":";;;;;;;;;;;;;;;;;EAcA,MAAM,QAAQ;EACd,MAAM,EAAE,QAAQ,SAAS,SAAS,aAAa,SAAS;EAExD,MAAM,EAAE,aAAa,kBAAkB;EACvC,MAAM,EAAE,MAAM,cAAc;EAE5B,MAAM,WAAW,kBAAkB,MAAM,MAAM;EAG/C,MAAM,YADW,kBAAkB,MAAM,MACvB,CAAA,CAAS;;GAKjB,OAAAA,MAAA,QAAA,CAAQ,CAAC,QAAQ,mBAAc,YADvCC,UAAA,GAAAC,YAiBWF,MAAA,QAAA,GAAA;;IAfR,MAAMA,MAAA,SAAA,IAAYA,MAAA,CAAA,CAAC,CAAA,gBAAA,IAAqBA,MAAA,CAAA,CAAC,CAAA,sBAAA;IACzC,MAAMA,MAAA,SAAA,IAAS;KAAA;KAAA;KAAA;IAAA,IAA4B,KAAA;;IAE5C,SAAAG,cAWE,CAXFC,YAWEJ,MAAA,OAAA,GAAA;KAVA,OAAM;KACN,SAAQ;KACR,gBAAa;KACb,kBAAe;KACf,MAAK;KACJ,cAAYA,MAAA,CAAA,CAAC,CAAA,gBAAA;KACb,QAAM,CAAA,CAAIA,MAAA,QAAA,CAAQ,EAAE;KACpB,UAAQ,CAAGA,MAAA,QAAA,KAAQ,CAAKA,MAAA,SAAA;KACxB,aAAS,OAAA,OAAA,OAAA,KAAAK,oBAAV,CAAA,GAAkB,CAAA,SAAA,CAAA;KACjB,SAAK,OAAA,OAAA,OAAA,MAAA,WAAEL,MAAA,QAAA,CAAQ,EAAE,eAAc;;;;;;;GAGpC,GAAA,GAAA,CAAA,QAAA,MAAA,CAAA,MAAAC,UAAA,GAAAC,YAAkDI,aAAA;;IAAxB,QAAQ,MAAM"}

package/dist/features/comments/components/SettingsCommentsTab.js

@@ -0,0 +1,46 @@
+import { useUiKit } from "../../../vue/kit/use-ui-kit.js";
+import { useEditorSettings } from "../../../vue/settings.js";
+import { useEditorI18n } from "../../../vue/use-editor-i18n.js";
+import _sfc_main$1 from "../../../vue/components/SettingsSection.js";
+import { computed, createElementBlock, createElementVNode, createVNode, defineComponent, openBlock, unref, withCtx } from "vue";
+//#region src/features/comments/components/SettingsCommentsTab.vue
+const _hoisted_1 = { class: "flex flex-col gap-8" };
+const _hoisted_2 = { class: "py-3" };
+/** „Kommentare“: where the comments of a shared document are shown. */
+const _sfc_main = /*@__PURE__*/ defineComponent({
+	__name: "SettingsCommentsTab",
+	setup(__props) {
+		const { settings } = useEditorSettings();
+		const { RadioGroup: URadioGroup } = useUiKit();
+		const { t } = useEditorI18n();
+		const layoutItems = computed(() => [{
+			label: t("comments.layout.margin.label"),
+			description: t("comments.layout.margin.description"),
+			value: "margin"
+		}, {
+			label: t("comments.layout.inline.label"),
+			description: t("comments.layout.inline.description"),
+			value: "inline"
+		}]);
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", _hoisted_1, [createVNode(_sfc_main$1, { title: unref(t)("comments.tab") }, {
+				default: withCtx(() => [createElementVNode("div", _hoisted_2, [createVNode(unref(URadioGroup), {
+					modelValue: unref(settings).editing.commentsLayout,
+					"onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => unref(settings).editing.commentsLayout = $event),
+					legend: unref(t)("comments.layout.legend"),
+					orientation: "horizontal",
+					items: layoutItems.value
+				}, null, 8, [
+					"modelValue",
+					"legend",
+					"items"
+				])])]),
+				_: 1
+			}, 8, ["title"])]);
+		};
+	}
+});
+//#endregion
+export { _sfc_main as default };
+
+//# sourceMappingURL=SettingsCommentsTab.js.map

package/dist/features/comments/components/SettingsCommentsTab.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SettingsCommentsTab.js","names":["_openBlock","_createElementBlock","_createVNode","SettingsSection","_unref","_withCtx","_createElementVNode"],"sources":["../../../../src/features/comments/components/SettingsCommentsTab.vue"],"sourcesContent":["<script setup lang=\"ts\">\nimport { computed } from 'vue'\nimport { useUiKit } from '../../../vue/kit/use-ui-kit'\nimport SettingsSection from '../../../vue/components/SettingsSection.vue'\nimport { useEditorSettings } from '../../../vue/settings'\nimport { useEditorI18n } from '../../../vue/use-editor-i18n'\nimport type { CommentsLayout } from '../../../settings'\n\n/** „Kommentare“: where the comments of a shared document are shown. */\nconst { settings } = useEditorSettings()\nconst { RadioGroup: URadioGroup } = useUiKit()\nconst { t } = useEditorI18n()\n\nconst layoutItems = computed<{ label: string, description: string, value: CommentsLayout }[]>(() => [\n  { label: t('comments.layout.margin.label'), description: t('comments.layout.margin.description'), value: 'margin' },\n  { label: t('comments.layout.inline.label'), description: t('comments.layout.inline.description'), value: 'inline' },\n])\n</script>\n\n<template>\n  <div class=\"flex flex-col gap-8\">\n    <SettingsSection :title=\"t('comments.tab')\">\n      <div class=\"py-3\">\n        <URadioGroup v-model=\"settings.editing.commentsLayout\" :legend=\"t('comments.layout.legend')\" orientation=\"horizontal\" :items=\"layoutItems\" />\n      </div>\n    </SettingsSection>\n  </div>\n</template>\n"],"mappings":";;;;;;;;;;;;EASA,MAAM,EAAE,aAAa,kBAAkB;EACvC,MAAM,EAAE,YAAY,gBAAgB,SAAS;EAC7C,MAAM,EAAE,MAAM,cAAc;EAE5B,MAAM,cAAc,eAAgF,CAClG;GAAE,OAAO,EAAE,8BAA8B;GAAG,aAAa,EAAE,oCAAoC;GAAG,OAAO;EAAS,GAClH;GAAE,OAAO,EAAE,8BAA8B;GAAG,aAAa,EAAE,oCAAoC;GAAG,OAAO;EAAS,CACpH,CAAC;;GAIC,OAAAA,UAAA,GAAAC,mBAMM,OANN,YAMM,CALJC,YAIkBC,aAAA,EAJA,OAAOC,MAAA,CAAA,CAAC,CAAA,cAAA,EAAA,GAAA;IACxB,SAAAC,cAEM,CAFNC,mBAEM,OAFN,YAEM,CADJJ,YAA6IE,MAAA,WAAA,GAAA;KAAvH,YAAAA,MAAA,QAAA,CAAQ,CAAC,QAAQ;KAAjB,uBAAA,OAAA,OAAA,OAAA,MAAA,WAAA,MAAA,QAAA,CAAQ,CAAC,QAAQ,iBAAc;KAAG,QAAQA,MAAA,CAAA,CAAC,CAAA,wBAAA;KAA4B,aAAY;KAAc,OAAO,YAAA"}

package/dist/features/comments/components/SettingsCommentsTab.vue.d.ts

@@ -0,0 +1,6 @@
+//#region src/features/comments/components/SettingsCommentsTab.vue.d.ts
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+//#endregion
+export { _default as default };
+//# sourceMappingURL=SettingsCommentsTab.vue.d.ts.map

package/dist/features/comments/feature.d.ts

@@ -0,0 +1,39 @@
+import { EditorFeature } from "../../core/feature.js";
+import "../../core/index.js";
+import { CommentsModelFactory } from "./model.js";
+//#region src/features/comments/feature.d.ts
+/** What a framework binding supplies to the comments feature. */
+export interface CommentsUi<C> {
+  /** The toolbar entry: the margin toggle or the list menu, by the user's comments layout. */
+  toolbarButton: C;
+  /** Mounted beside the editor content: the selection bubble, the inline popover and the layout glue. */
+  overlay: C;
+  /** The „Kommentare“ settings tab component of the framework. */
+  settingsTab: C;
+}
+/** Options of `commentsFeatureCore`. */
+export interface CommentsFeatureOptions {
+  /**
+   * Backs the comments with the host's own model (REST threads, a database) instead of the document's Y.Doc: the feature
+   * then requires no `collab` feature, the `Comments` plugin reads the user from the model, gets the thread ids
+   * (`known`/`hidden`) and the text ranges from its snapshot, and the framework `useComments` hooks use the model of
+   * the surface (`commentsModelOf(ctx)`) instead of `createCommentsModel`. The factory runs once for the plugin and once
+   * per `useComments` consumer, so a model that shares state between them keeps it outside the factory. The model
+   * itself drives the active thread and the draft through the `comments-plugin` helpers.
+   */
+  model?: CommentsModelFactory;
+}
+/**
+ * Google-Docs-style comments on a collaborative document: select text, „Kommentar“ in the selection bubble, others
+ * reply, anyone resolves or reopens a thread. Threads live in the Y.Doc (a `Y.Map` named `comments`, `createCommentsModel`), so
+ * they sync live and persist with the document; the text range is the `comment` mark, highlighted by the `Comments`
+ * plugin from the thread state. The user chooses per setting (`editing.commentsLayout`) between the margin column
+ * (`CommentsMargin`, which the host places in the editor's scroll container and shows while the surface's
+ * `commentsOpen` model is true; Mod-Shift-m or the toolbar button toggle it, and it excludes the AI sidebar) and the
+ * inline popover plus the toolbar's list. Needs a collaborative surface with a `collaboration.user`: without one the
+ * UI says so and nothing can be written (the schema mark stays registered, so stored comment marks round-trip). With
+ * `options.model` the threads live wherever the host's model keeps them and no collaboration is needed.
+ */
+export declare function commentsFeatureCore<C>(ui: CommentsUi<C>, options?: CommentsFeatureOptions): EditorFeature<C>;
+//#endregion
+//# sourceMappingURL=feature.d.ts.map

package/dist/features/comments/feature.js

@@ -0,0 +1,128 @@
+import { Comments, commentsKey } from "./comments-plugin.js";
+import { CommentMark } from "./schema.js";
+import { provideCommentsModel } from "./model.js";
+import { commentsShortcuts } from "./shortcuts.js";
+import { Extension } from "@tiptap/core";
+//#region src/features/comments/feature.ts
+/**
+* Google-Docs-style comments on a collaborative document: select text, „Kommentar“ in the selection bubble, others
+* reply, anyone resolves or reopens a thread. Threads live in the Y.Doc (a `Y.Map` named `comments`, `createCommentsModel`), so
+* they sync live and persist with the document; the text range is the `comment` mark, highlighted by the `Comments`
+* plugin from the thread state. The user chooses per setting (`editing.commentsLayout`) between the margin column
+* (`CommentsMargin`, which the host places in the editor's scroll container and shows while the surface's
+* `commentsOpen` model is true; Mod-Shift-m or the toolbar button toggle it, and it excludes the AI sidebar) and the
+* inline popover plus the toolbar's list. Needs a collaborative surface with a `collaboration.user`: without one the
+* UI says so and nothing can be written (the schema mark stays registered, so stored comment marks round-trip). With
+* `options.model` the threads live wherever the host's model keeps them and no collaboration is needed.
+*/
+function commentsFeatureCore(ui, options = {}) {
+	const { model: factory } = options;
+	return {
+		id: "comments",
+		requires: factory ? [] : ["collab"],
+		extensions: (ctx) => {
+			if (!factory) return [
+				CommentMark,
+				Comments.configure({
+					user: () => ctx.collaboration?.user ?? null,
+					doc: () => ctx.collaboration?.ydoc ?? null
+				}),
+				commentsShortcuts(ctx)
+			];
+			provideCommentsModel(ctx, factory);
+			const { configured, bridge } = modelExtensions(factory, ctx.getEditor);
+			return [
+				CommentMark,
+				configured,
+				bridge,
+				commentsShortcuts(ctx)
+			];
+		},
+		toolbar: (ctx) => [{
+			id: "collaboration",
+			order: 1010,
+			items: [{
+				id: "comments",
+				order: 10,
+				icon: "i-lucide-message-square-text",
+				label: ctx.t("comments.title"),
+				component: ui.toolbarButton
+			}]
+		}],
+		overlays: [ui.overlay],
+		settingsTabs: (ctx) => [{
+			id: "comments",
+			label: ctx.t("comments.tab"),
+			icon: "i-lucide-message-square-text",
+			component: ui.settingsTab
+		}]
+	};
+}
+/**
+* The `Comments` plugin and its feed for a host model: the plugin reads user, availability and `canComment` from the
+* model's snapshot; the bridge extension refreshes the model once the editor exists, mirrors the snapshot's thread ids
+* and ranges into the plugin state (queued, never from inside a transaction) and disposes the model with the editor.
+*/
+function modelExtensions(factory, getEditor) {
+	let created;
+	const model = factory(() => created ?? getEditor());
+	const snapshot = () => model.state.get();
+	let stop;
+	let queued = false;
+	let told;
+	let toldRanges;
+	function push() {
+		queued = false;
+		const editor = created;
+		const value = editor && !editor.isDestroyed ? commentsKey.getState(editor.state) : void 0;
+		if (!editor || !value) return;
+		const { threads, ranges } = snapshot();
+		if (threads === told && ranges === toldRanges) return;
+		const known = new Set(threads.map((t) => t.id));
+		const hidden = new Set(threads.filter((t) => t.resolved).map((t) => t.id));
+		const meta = {
+			known,
+			hidden,
+			modelRanges: ranges
+		};
+		const before = value.active ? told?.find((t) => t.id === value.active) : void 0;
+		if (value.active && before && !before.resolved && (!known.has(value.active) || hidden.has(value.active))) meta.active = null;
+		told = threads;
+		toldRanges = ranges;
+		editor.view.dispatch(editor.state.tr.setMeta(commentsKey, meta).setMeta("addToHistory", false));
+	}
+	function queue() {
+		if (queued) return;
+		queued = true;
+		queueMicrotask(push);
+	}
+	return {
+		configured: Comments.configure({
+			user: () => snapshot().user,
+			doc: () => null,
+			available: () => snapshot().available,
+			canComment: () => snapshot().canComment
+		}),
+		bridge: Extension.create({
+			name: "commentsModelBridge",
+			onCreate() {
+				created = this.editor;
+				model.refresh();
+				stop = model.state.subscribe(queue);
+				queue();
+			},
+			onDestroy() {
+				stop?.();
+				stop = void 0;
+				model.dispose();
+				created = void 0;
+				told = void 0;
+				toldRanges = void 0;
+			}
+		})
+	};
+}
+//#endregion
+export { commentsFeatureCore };
+
+//# sourceMappingURL=feature.js.map

package/dist/features/comments/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.js","names":[],"sources":["../../../src/features/comments/feature.ts"],"sourcesContent":["import { type AnyExtension, type Editor, Extension } from '@tiptap/core'\nimport type { EditorFeature } from '../../core'\nimport { Comments, type CommentsMeta, commentsKey } from './comments-plugin'\nimport { type CommentsModelFactory, type CommentsSnapshot, provideCommentsModel } from './model'\nimport { CommentMark } from './schema'\nimport { commentsShortcuts } from './shortcuts'\n\n/** What a framework binding supplies to the comments feature. */\nexport interface CommentsUi<C> {\n  /** The toolbar entry: the margin toggle or the list menu, by the user's comments layout. */\n  toolbarButton: C\n  /** Mounted beside the editor content: the selection bubble, the inline popover and the layout glue. */\n  overlay: C\n  /** The „Kommentare“ settings tab component of the framework. */\n  settingsTab: C\n}\n\n/** Options of `commentsFeatureCore`. */\nexport interface CommentsFeatureOptions {\n  /**\n   * Backs the comments with the host's own model (REST threads, a database) instead of the document's Y.Doc: the feature\n   * then requires no `collab` feature, the `Comments` plugin reads the user from the model, gets the thread ids\n   * (`known`/`hidden`) and the text ranges from its snapshot, and the framework `useComments` hooks use the model of\n   * the surface (`commentsModelOf(ctx)`) instead of `createCommentsModel`. The factory runs once for the plugin and once\n   * per `useComments` consumer, so a model that shares state between them keeps it outside the factory. The model\n   * itself drives the active thread and the draft through the `comments-plugin` helpers.\n   */\n  model?: CommentsModelFactory\n}\n\n/**\n * Google-Docs-style comments on a collaborative document: select text, „Kommentar“ in the selection bubble, others\n * reply, anyone resolves or reopens a thread. Threads live in the Y.Doc (a `Y.Map` named `comments`, `createCommentsModel`), so\n * they sync live and persist with the document; the text range is the `comment` mark, highlighted by the `Comments`\n * plugin from the thread state. The user chooses per setting (`editing.commentsLayout`) between the margin column\n * (`CommentsMargin`, which the host places in the editor's scroll container and shows while the surface's\n * `commentsOpen` model is true; Mod-Shift-m or the toolbar button toggle it, and it excludes the AI sidebar) and the\n * inline popover plus the toolbar's list. Needs a collaborative surface with a `collaboration.user`: without one the\n * UI says so and nothing can be written (the schema mark stays registered, so stored comment marks round-trip). With\n * `options.model` the threads live wherever the host's model keeps them and no collaboration is needed.\n */\nexport function commentsFeatureCore<C>(ui: CommentsUi<C>, options: CommentsFeatureOptions = {}): EditorFeature<C> {\n  const { model: factory } = options\n  return {\n    id: 'comments',\n    requires: factory ? [] : ['collab'],\n    extensions: (ctx) => {\n      if (!factory) {\n        return [\n          CommentMark,\n          Comments.configure({\n            user: () => ctx.collaboration?.user ?? null,\n            doc: () => ctx.collaboration?.ydoc ?? null,\n          }),\n          commentsShortcuts(ctx),\n        ]\n      }\n      provideCommentsModel(ctx, factory)\n      const { configured, bridge } = modelExtensions(factory, ctx.getEditor)\n      return [CommentMark, configured, bridge, commentsShortcuts(ctx)]\n    },\n    toolbar: ctx => [{\n      id: 'collaboration',\n      order: 1010,\n      items: [{ id: 'comments', order: 10, icon: 'i-lucide-message-square-text', label: ctx.t('comments.title'), component: ui.toolbarButton }],\n    }],\n    overlays: [ui.overlay],\n    settingsTabs: ctx => [{ id: 'comments', label: ctx.t('comments.tab'), icon: 'i-lucide-message-square-text', component: ui.settingsTab }],\n  }\n}\n\n/**\n * The `Comments` plugin and its feed for a host model: the plugin reads user, availability and `canComment` from the\n * model's snapshot; the bridge extension refreshes the model once the editor exists, mirrors the snapshot's thread ids\n * and ranges into the plugin state (queued, never from inside a transaction) and disposes the model with the editor.\n */\nfunction modelExtensions(factory: CommentsModelFactory, getEditor: Parameters<CommentsModelFactory>[0]): { configured: AnyExtension, bridge: AnyExtension } {\n  let created: Editor | undefined\n  const model = factory(() => created ?? getEditor())\n  const snapshot = () => model.state.get()\n\n  let stop: (() => void) | undefined\n  let queued = false\n  // What the plugin was last told, to skip no-op dispatches and to apply the deactivation rule.\n  let told: CommentsSnapshot['threads'] | undefined\n  let toldRanges: CommentsSnapshot['ranges'] | undefined\n\n  function push() {\n    queued = false\n    const editor = created\n    const value = editor && !editor.isDestroyed ? commentsKey.getState(editor.state) : undefined\n    if (!editor || !value) return\n    const { threads, ranges } = snapshot()\n    if (threads === told && ranges === toldRanges) return\n    const known = new Set(threads.map(t => t.id))\n    const hidden = new Set(threads.filter(t => t.resolved).map(t => t.id))\n    const meta: CommentsMeta = { known, hidden, modelRanges: ranges }\n    const before = value.active ? told?.find(t => t.id === value.active) : undefined\n    if (value.active && before && !before.resolved && (!known.has(value.active) || hidden.has(value.active))) meta.active = null\n    told = threads\n    toldRanges = ranges\n    editor.view.dispatch(editor.state.tr.setMeta(commentsKey, meta).setMeta('addToHistory', false))\n  }\n\n  function queue() {\n    if (queued) return\n    queued = true\n    queueMicrotask(push)\n  }\n\n  return {\n    configured: Comments.configure({\n      user: () => snapshot().user,\n      doc: () => null,\n      available: () => snapshot().available,\n      canComment: () => snapshot().canComment,\n    }),\n    bridge: Extension.create({\n      name: 'commentsModelBridge',\n      onCreate() {\n        created = this.editor\n        model.refresh()\n        stop = model.state.subscribe(queue)\n        queue()\n      },\n      onDestroy() {\n        stop?.()\n        stop = undefined\n        model.dispose()\n        created = undefined\n        told = undefined\n        toldRanges = undefined\n      },\n    }),\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAyCA,SAAgB,oBAAuB,IAAmB,UAAkC,CAAC,GAAqB;CAChH,MAAM,EAAE,OAAO,YAAY;CAC3B,OAAO;EACL,IAAI;EACJ,UAAU,UAAU,CAAC,IAAI,CAAC,QAAQ;EAClC,aAAa,QAAQ;GACnB,IAAI,CAAC,SACH,OAAO;IACL;IACA,SAAS,UAAU;KACjB,YAAY,IAAI,eAAe,QAAQ;KACvC,WAAW,IAAI,eAAe,QAAQ;IACxC,CAAC;IACD,kBAAkB,GAAG;GACvB;GAEF,qBAAqB,KAAK,OAAO;GACjC,MAAM,EAAE,YAAY,WAAW,gBAAgB,SAAS,IAAI,SAAS;GACrE,OAAO;IAAC;IAAa;IAAY;IAAQ,kBAAkB,GAAG;GAAC;EACjE;EACA,UAAS,QAAO,CAAC;GACf,IAAI;GACJ,OAAO;GACP,OAAO,CAAC;IAAE,IAAI;IAAY,OAAO;IAAI,MAAM;IAAgC,OAAO,IAAI,EAAE,gBAAgB;IAAG,WAAW,GAAG;GAAc,CAAC;EAC1I,CAAC;EACD,UAAU,CAAC,GAAG,OAAO;EACrB,eAAc,QAAO,CAAC;GAAE,IAAI;GAAY,OAAO,IAAI,EAAE,cAAc;GAAG,MAAM;GAAgC,WAAW,GAAG;EAAY,CAAC;CACzI;AACF;;;;;;AAOA,SAAS,gBAAgB,SAA+B,WAAoG;CAC1J,IAAI;CACJ,MAAM,QAAQ,cAAc,WAAW,UAAU,CAAC;CAClD,MAAM,iBAAiB,MAAM,MAAM,IAAI;CAEvC,IAAI;CACJ,IAAI,SAAS;CAEb,IAAI;CACJ,IAAI;CAEJ,SAAS,OAAO;EACd,SAAS;EACT,MAAM,SAAS;EACf,MAAM,QAAQ,UAAU,CAAC,OAAO,cAAc,YAAY,SAAS,OAAO,KAAK,IAAI,KAAA;EACnF,IAAI,CAAC,UAAU,CAAC,OAAO;EACvB,MAAM,EAAE,SAAS,WAAW,SAAS;EACrC,IAAI,YAAY,QAAQ,WAAW,YAAY;EAC/C,MAAM,QAAQ,IAAI,IAAI,QAAQ,KAAI,MAAK,EAAE,EAAE,CAAC;EAC5C,MAAM,SAAS,IAAI,IAAI,QAAQ,QAAO,MAAK,EAAE,QAAQ,CAAC,CAAC,KAAI,MAAK,EAAE,EAAE,CAAC;EACrE,MAAM,OAAqB;GAAE;GAAO;GAAQ,aAAa;EAAO;EAChE,MAAM,SAAS,MAAM,SAAS,MAAM,MAAK,MAAK,EAAE,OAAO,MAAM,MAAM,IAAI,KAAA;EACvE,IAAI,MAAM,UAAU,UAAU,CAAC,OAAO,aAAa,CAAC,MAAM,IAAI,MAAM,MAAM,KAAK,OAAO,IAAI,MAAM,MAAM,IAAI,KAAK,SAAS;EACxH,OAAO;EACP,aAAa;EACb,OAAO,KAAK,SAAS,OAAO,MAAM,GAAG,QAAQ,aAAa,IAAI,CAAC,CAAC,QAAQ,gBAAgB,KAAK,CAAC;CAChG;CAEA,SAAS,QAAQ;EACf,IAAI,QAAQ;EACZ,SAAS;EACT,eAAe,IAAI;CACrB;CAEA,OAAO;EACL,YAAY,SAAS,UAAU;GAC7B,YAAY,SAAS,CAAC,CAAC;GACvB,WAAW;GACX,iBAAiB,SAAS,CAAC,CAAC;GAC5B,kBAAkB,SAAS,CAAC,CAAC;EAC/B,CAAC;EACD,QAAQ,UAAU,OAAO;GACvB,MAAM;GACN,WAAW;IACT,UAAU,KAAK;IACf,MAAM,QAAQ;IACd,OAAO,MAAM,MAAM,UAAU,KAAK;IAClC,MAAM;GACR;GACA,YAAY;IACV,OAAO;IACP,OAAO,KAAA;IACP,MAAM,QAAQ;IACd,UAAU,KAAA;IACV,OAAO,KAAA;IACP,aAAa,KAAA;GACf;EACF,CAAC;CACH;AACF"}

package/dist/features/comments/index.d.ts

@@ -0,0 +1,6 @@
+import { COMMENTS_LAYOUTS, CommentsLayout } from "../../settings/values.js";
+import { COMMENTS_FIELD, COMMENT_LIMITS, CommentAuthor, CommentMark, CommentReply, CommentThread, commentsSchemaExtensions } from "./schema.js";
+import { CommentsActions, CommentsModel, CommentsModelFactory, CommentsSnapshot, DocRange, commentsModelOf, createCommentsModel, createEditorCommentsModel } from "./model.js";
+import { CommentsFeatureOptions, CommentsUi, commentsFeatureCore } from "./feature.js";
+import { Comments, CommentsMeta, CommentsOptions, CommentsState, cancelCommentDraft, commentsAvailable, commentsCanComment, commentsDoc, commentsKey, commentsState, commentsUser, setActiveComment, startCommentDraft } from "./comments-plugin.js";
+export { COMMENTS_FIELD, COMMENTS_LAYOUTS, COMMENT_LIMITS, type CommentAuthor, CommentMark, type CommentReply, type CommentThread, Comments, type CommentsActions, type CommentsFeatureOptions, type CommentsLayout, type CommentsMeta, type CommentsModel, type CommentsModelFactory, type CommentsOptions, type CommentsSnapshot, type CommentsState, type CommentsUi, type DocRange, cancelCommentDraft, commentsAvailable, commentsCanComment, commentsDoc, commentsFeatureCore, commentsKey, commentsModelOf, commentsSchemaExtensions, commentsState, commentsUser, createCommentsModel, createEditorCommentsModel, setActiveComment, startCommentDraft };

package/dist/features/comments/index.js

@@ -0,0 +1,6 @@
+import { COMMENTS_LAYOUTS } from "../../settings/values.js";
+import { Comments, cancelCommentDraft, commentsAvailable, commentsCanComment, commentsDoc, commentsKey, commentsState, commentsUser, setActiveComment, startCommentDraft } from "./comments-plugin.js";
+import { COMMENTS_FIELD, COMMENT_LIMITS, CommentMark, commentsSchemaExtensions } from "./schema.js";
+import { commentsModelOf, createCommentsModel, createEditorCommentsModel } from "./model.js";
+import { commentsFeatureCore } from "./feature.js";
+export { COMMENTS_FIELD, COMMENTS_LAYOUTS, COMMENT_LIMITS, CommentMark, Comments, cancelCommentDraft, commentsAvailable, commentsCanComment, commentsDoc, commentsFeatureCore, commentsKey, commentsModelOf, commentsSchemaExtensions, commentsState, commentsUser, createCommentsModel, createEditorCommentsModel, setActiveComment, startCommentDraft };

package/dist/features/comments/model.d.ts

@@ -0,0 +1,87 @@
+import { ReadonlyStore } from "../../core/store.js";
+import { AuthorIdentity, FeatureContext } from "../../core/feature.js";
+import "../../core/index.js";
+import { CommentThread } from "./schema.js";
+import { Editor } from "@tiptap/core";
+//#region src/features/comments/model.d.ts
+export type DocRange = {
+  from: number;
+  to: number;
+};
+/** What a comments UI renders: replaced (a new object) whenever any part of it changes, so a store subscriber re-renders only then. */
+export interface CommentsSnapshot {
+  /** Comments need a collaborative editor whose `Comments` extension has a user (a host model decides for itself). */
+  available: boolean;
+  /**
+   * Whether the user may compose a comment now: the default model says `available` and the editor is editable, a host
+   * model may allow readers of a read-only document to comment.
+   */
+  canComment: boolean;
+  user: AuthorIdentity | null;
+  /** Plain snapshots of all threads in the Y.Doc, replaced on every change. */
+  threads: readonly CommentThread[];
+  /** Current text range per thread id (threads without one are orphans). */
+  ranges: ReadonlyMap<string, DocRange>;
+  active: string | null;
+  /** Current range of the draft a new comment is being written for. */
+  draft: DocRange | null;
+  /** The draft's text as the new thread will keep it (`quote`). */
+  draftQuote: string;
+  /** Unresolved threads in document order, orphans last; resolved ones newest first. */
+  open: readonly CommentThread[];
+  resolved: readonly CommentThread[];
+}
+/** The mutations of the comments of one editor; no-ops without collaboration or a user. */
+export interface CommentsActions {
+  /** Creates a thread on the draft range; its id, or null without a (non-empty) draft or text. */
+  add: (text: string) => string | null;
+  reply: (threadId: string, text: string) => void;
+  /** Changes the text of the user's own thread (`replyId` null) or reply. */
+  edit: (threadId: string, replyId: string | null, text: string) => void;
+  /** Resolves or reopens a thread (anyone may). */
+  setResolved: (threadId: string, resolved: boolean) => void;
+  /** Deletes the user's own thread with its marks / the user's own reply. */
+  remove: (threadId: string) => void;
+  removeReply: (threadId: string, replyId: string) => void;
+  /** Activates a thread (`null`: none); `reveal` selects and scrolls to its text. */
+  activate: (id: string | null, options?: {
+    reveal?: boolean;
+  }) => void;
+  /** Starts a comment on the current selection (the layout shows the composer while `draft` is set). */
+  startDraft: () => void;
+  cancelDraft: () => void;
+}
+/**
+ * The comments of one editor, framework-free: `state` is the observable snapshot, `refresh()` brings it up to date
+ * (the framework hook calls it when the editor it watches changes; the model itself listens to that editor's
+ * transactions from then on), `dispose()` detaches the editor and Y.Doc listeners and may be followed by `refresh()` again
+ * (StrictMode mounts twice).
+ */
+export interface CommentsModel extends CommentsActions {
+  readonly state: ReadonlyStore<CommentsSnapshot>;
+  refresh: () => void;
+  dispose: () => void;
+}
+/**
+ * The comment threads of a collaborative editor, stored in its Y.Doc (`COMMENTS_FIELD`, one nested `Y.Map` per thread,
+ * replies in a nested `Y.Array`), so they sync live with the document and persist with its Yjs state. Keeps the
+ * `Comments` plugin's `known`/`hidden` thread ids in step with the store (highlights), exposes the plugin's ranges,
+ * active thread and draft, and the mutations. Mutations are no-ops without collaboration or user; editing and
+ * deleting are limited to the user's own comments and replies (a client-side rule: the Y.Doc itself has no ACL).
+ * `getEditor` names the editor to work on (it may change over time and may return a destroyed or no editor).
+ */
+export declare function createCommentsModel(getEditor: () => Editor | undefined): CommentsModel;
+/** Creates the comments model of one editor, as a host supplies it to `commentsFeatureCore`. */
+export type CommentsModelFactory = (getEditor: () => Editor | undefined) => CommentsModel;
+/** The host model factory the comments feature of `ctx` was configured with; undefined for the default Y.Doc model. */
+export declare function commentsModelOf(ctx: FeatureContext): CommentsModelFactory | undefined;
+/**
+ * The comments model the framework hooks (`useComments`) use: the model of the surface `getEditor` belongs to
+ * (`commentsModelOf` of its feature context: the host's `model` factory) and `createCommentsModel` for every other
+ * editor. It follows the editor over time: when the editor changes to one of a surface with another model, the inner
+ * model is replaced (disposed, created, refreshed) and `state` carries on with the new one. The factory runs once per
+ * consumer of this function, so a host model that must share state across them keeps it outside the factory.
+ */
+export declare function createEditorCommentsModel(getEditor: () => Editor | undefined): CommentsModel;
+//#endregion
+//# sourceMappingURL=model.d.ts.map