@ecsplico/editor 3.1.0 → 3.2.0

package/dist/features/transfer/components/TransferMenu.js

@@ -0,0 +1,93 @@
+import { useUiKit } from "../../../vue/kit/use-ui-kit.js";
+import { useEditorI18n } from "../../../vue/use-editor-i18n.js";
+import { useStoreRef } from "../../../vue/store-ref.js";
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, defineComponent, normalizeStyle, onBeforeUnmount, openBlock, ref, renderList, toDisplayString, unref, watch } from "vue";
+//#region src/features/transfer/components/TransferMenu.vue
+const _hoisted_1 = ["aria-label"];
+const _hoisted_2 = { class: "px-2 py-1 text-xs text-[var(--sk-muted)]" };
+/**
+* The transform menu of a Shift-drop (mounted by the transfer feature): opens at the drop point while a drop waits in
+* `editor.storage.blockDropTarget.pending`, lists the transforms available for it and runs the one picked. Escape or a
+* click elsewhere cancels the drop.
+*/
+const ITEM_HEIGHT = 32;
+const MENU_WIDTH = 240;
+const EDGE = 8;
+const _sfc_main = /*@__PURE__*/ defineComponent({
+	__name: "TransferMenu",
+	props: { editor: {} },
+	setup(__props) {
+		const props = __props;
+		const { Button: UButton } = useUiKit();
+		const { t } = useEditorI18n();
+		const storage = props.editor.storage.blockDropTarget;
+		const pending = useStoreRef(storage.pending);
+		const transforms = computed(() => pending.value ? storage.available(pending.value) : []);
+		const label = (transform) => transform.labelKey ? t(transform.labelKey) : transform.label;
+		/** The menu's top-left corner: at the drop point, kept inside the viewport. */
+		const style = computed(() => {
+			const drop = pending.value;
+			if (!drop) return {};
+			const height = transforms.value.length * ITEM_HEIGHT + ITEM_HEIGHT + 16;
+			const left = Math.max(EDGE, Math.min(drop.x, window.innerWidth - MENU_WIDTH - EDGE));
+			const top = Math.max(EDGE, Math.min(drop.y, window.innerHeight - height - EDGE));
+			return {
+				left: `${left}px`,
+				top: `${top}px`,
+				width: `${MENU_WIDTH}px`
+			};
+		});
+		const root = ref(null);
+		const cancel = () => props.editor.commands.cancelTransfer();
+		const onKey = (event) => {
+			if (event.key !== "Escape") return;
+			event.preventDefault();
+			cancel();
+		};
+		const onPointerDown = (event) => {
+			if (!root.value?.contains(event.target)) cancel();
+		};
+		const listen = (on) => {
+			if (on) {
+				document.addEventListener("keydown", onKey, true);
+				document.addEventListener("pointerdown", onPointerDown, true);
+			} else {
+				document.removeEventListener("keydown", onKey, true);
+				document.removeEventListener("pointerdown", onPointerDown, true);
+			}
+		};
+		watch(() => pending.value !== null, listen, { immediate: true });
+		onBeforeUnmount(() => listen(false));
+		return (_ctx, _cache) => {
+			return unref(pending) ? (openBlock(), createElementBlock("div", {
+				key: 0,
+				ref_key: "root",
+				ref: root,
+				class: "fixed z-50 rounded-lg border border-[var(--sk-border)] bg-[var(--sk-bg)] p-1 shadow-lg",
+				style: normalizeStyle(style.value),
+				role: "menu",
+				"aria-label": unref(t)("transfer.menu.title")
+			}, [createElementVNode("p", _hoisted_2, toDisplayString(unref(t)("transfer.menu.title")), 1), (openBlock(true), createElementBlock(Fragment, null, renderList(transforms.value, (transform) => {
+				return openBlock(), createBlock(unref(UButton), {
+					key: transform.id,
+					class: "w-full justify-start",
+					size: "sm",
+					color: "neutral",
+					variant: "ghost",
+					role: "menuitem",
+					icon: transform.icon,
+					label: label(transform),
+					onClick: ($event) => unref(storage).run(transform.id, unref(pending))
+				}, null, 8, [
+					"icon",
+					"label",
+					"onClick"
+				]);
+			}), 128))], 12, _hoisted_1)) : createCommentVNode("v-if", true);
+		};
+	}
+});
+//#endregion
+export { _sfc_main as default };
+
+//# sourceMappingURL=TransferMenu.js.map

package/dist/features/transfer/components/TransferMenu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransferMenu.js","names":["_unref","_openBlock","_createElementBlock","_normalizeStyle","_createElementVNode","_toDisplayString","_Fragment","_renderList","_createBlock","_createCommentVNode"],"sources":["../../../../src/features/transfer/components/TransferMenu.vue"],"sourcesContent":["<script setup lang=\"ts\">\nimport type { Editor } from '@tiptap/vue-3'\nimport { computed, onBeforeUnmount, ref, watch } from 'vue'\nimport { useStoreRef } from '../../../vue/store-ref'\nimport { useUiKit } from '../../../vue/kit/use-ui-kit'\nimport { useEditorI18n } from '../../../vue/use-editor-i18n'\nimport type { BlockTransform } from '../transforms'\n\n/**\n * The transform menu of a Shift-drop (mounted by the transfer feature): opens at the drop point while a drop waits in\n * `editor.storage.blockDropTarget.pending`, lists the transforms available for it and runs the one picked. Escape or a\n * click elsewhere cancels the drop.\n */\nconst props = defineProps<{ editor: Editor }>()\n\nconst { Button: UButton } = useUiKit()\nconst { t } = useEditorI18n()\n\nconst storage = props.editor.storage.blockDropTarget!\nconst pending = useStoreRef(storage.pending)\n\nconst ITEM_HEIGHT = 32\nconst MENU_WIDTH = 240\nconst EDGE = 8\n\nconst transforms = computed<BlockTransform[]>(() => (pending.value ? storage.available(pending.value) : []))\nconst label = (transform: BlockTransform) => (transform.labelKey ? t(transform.labelKey) : transform.label)\n\n/** The menu's top-left corner: at the drop point, kept inside the viewport. */\nconst style = computed(() => {\n  const drop = pending.value\n  if (!drop) return {}\n  const height = transforms.value.length * ITEM_HEIGHT + ITEM_HEIGHT + 2 * EDGE\n  const left = Math.max(EDGE, Math.min(drop.x, window.innerWidth - MENU_WIDTH - EDGE))\n  const top = Math.max(EDGE, Math.min(drop.y, window.innerHeight - height - EDGE))\n  return { left: `${left}px`, top: `${top}px`, width: `${MENU_WIDTH}px` }\n})\n\nconst root = ref<HTMLElement | null>(null)\nconst cancel = () => props.editor.commands.cancelTransfer()\nconst onKey = (event: KeyboardEvent) => {\n  if (event.key !== 'Escape') return\n  event.preventDefault()\n  cancel()\n}\nconst onPointerDown = (event: PointerEvent) => {\n  if (!root.value?.contains(event.target as Node)) cancel()\n}\nconst listen = (on: boolean) => {\n  if (on) {\n    document.addEventListener('keydown', onKey, true)\n    document.addEventListener('pointerdown', onPointerDown, true)\n  }\n  else {\n    document.removeEventListener('keydown', onKey, true)\n    document.removeEventListener('pointerdown', onPointerDown, true)\n  }\n}\nwatch(() => pending.value !== null, listen, { immediate: true })\nonBeforeUnmount(() => listen(false))\n</script>\n\n<template>\n  <div\n    v-if=\"pending\"\n    ref=\"root\"\n    class=\"fixed z-50 rounded-lg border border-[var(--sk-border)] bg-[var(--sk-bg)] p-1 shadow-lg\"\n    :style=\"style\"\n    role=\"menu\"\n    :aria-label=\"t('transfer.menu.title')\"\n  >\n    <p class=\"px-2 py-1 text-xs text-[var(--sk-muted)]\">{{ t('transfer.menu.title') }}</p>\n    <UButton\n      v-for=\"transform in transforms\"\n      :key=\"transform.id\"\n      class=\"w-full justify-start\"\n      size=\"sm\"\n      color=\"neutral\"\n      variant=\"ghost\"\n      role=\"menuitem\"\n      :icon=\"transform.icon\"\n      :label=\"label(transform)\"\n      @click=\"storage.run(transform.id, pending)\"\n    />\n  </div>\n</template>\n"],"mappings":";;;;;;;;;;;;AAqBA,MAAM,cAAc;AACpB,MAAM,aAAa;AACnB,MAAM,OAAO;;;;;EAVb,MAAM,QAAQ;EAEd,MAAM,EAAE,QAAQ,YAAY,SAAS;EACrC,MAAM,EAAE,MAAM,cAAc;EAE5B,MAAM,UAAU,MAAM,OAAO,QAAQ;EACrC,MAAM,UAAU,YAAY,QAAQ,OAAO;EAM3C,MAAM,aAAa,eAAkC,QAAQ,QAAQ,QAAQ,UAAU,QAAQ,KAAK,IAAI,CAAC,CAAE;EAC3G,MAAM,SAAS,cAA+B,UAAU,WAAW,EAAE,UAAU,QAAQ,IAAI,UAAU;;EAGrG,MAAM,QAAQ,eAAe;GAC3B,MAAM,OAAO,QAAQ;GACrB,IAAI,CAAC,MAAM,OAAO,CAAC;GACnB,MAAM,SAAS,WAAW,MAAM,SAAS,cAAc,cAAc;GACrE,MAAM,OAAO,KAAK,IAAI,MAAM,KAAK,IAAI,KAAK,GAAG,OAAO,aAAa,aAAa,IAAI,CAAC;GACnF,MAAM,MAAM,KAAK,IAAI,MAAM,KAAK,IAAI,KAAK,GAAG,OAAO,cAAc,SAAS,IAAI,CAAC;GAC/E,OAAO;IAAE,MAAM,GAAG,KAAK;IAAK,KAAK,GAAG,IAAI;IAAK,OAAO,GAAG,WAAW;GAAI;EACxE,CAAC;EAED,MAAM,OAAO,IAAwB,IAAI;EACzC,MAAM,eAAe,MAAM,OAAO,SAAS,eAAe;EAC1D,MAAM,SAAS,UAAyB;GACtC,IAAI,MAAM,QAAQ,UAAU;GAC5B,MAAM,eAAe;GACrB,OAAO;EACT;EACA,MAAM,iBAAiB,UAAwB;GAC7C,IAAI,CAAC,KAAK,OAAO,SAAS,MAAM,MAAc,GAAG,OAAO;EAC1D;EACA,MAAM,UAAU,OAAgB;GAC9B,IAAI,IAAI;IACN,SAAS,iBAAiB,WAAW,OAAO,IAAI;IAChD,SAAS,iBAAiB,eAAe,eAAe,IAAI;GAC9D,OACK;IACH,SAAS,oBAAoB,WAAW,OAAO,IAAI;IACnD,SAAS,oBAAoB,eAAe,eAAe,IAAI;GACjE;EACF;EACA,YAAY,QAAQ,UAAU,MAAM,QAAQ,EAAE,WAAW,KAAK,CAAC;EAC/D,sBAAsB,OAAO,KAAK,CAAC;;GAKzB,OAAAA,MAAA,OAAA,KADRC,UAAA,GAAAC,mBAqBM,OAAA;;IAnBA,SAAA;IAAJ,KAAI;IACJ,OAAM;IACL,OAAKC,eAAE,MAAA,KAAK;IACb,MAAK;IACJ,cAAYH,MAAA,CAAA,CAAC,CAAA,qBAAA;GAEd,GAAA,CAAAI,mBAAsF,KAAtF,YAAsFC,gBAA/BL,MAAA,CAAA,CAAC,CAAA,qBAAA,CAAA,GAAA,CAAA,IACxDC,UAAA,IAAA,GAAAC,mBAWEI,UAAA,MAAAC,WAVoB,WAAA,QAAb,cAAS;IADlB,OAAAN,UAAA,GAAAO,YAWER,MAAA,OAAA,GAAA;KATC,KAAK,UAAU;KAChB,OAAM;KACN,MAAK;KACL,OAAM;KACN,SAAQ;KACR,MAAK;KACJ,MAAM,UAAU;KAChB,OAAO,MAAM,SAAS;KACtB,UAAK,WAAEA,MAAA,OAAA,CAAO,CAAC,IAAI,UAAU,IAAIA,MAAA,OAAA,CAAO"}

package/dist/features/transfer/components/TransferMenu.vue.d.ts

@@ -0,0 +1,15 @@
+import { Editor } from "@tiptap/vue-3";
+//#region src/features/transfer/components/TransferMenu.vue.d.ts
+/**
+ * The transform menu of a Shift-drop (mounted by the transfer feature): opens at the drop point while a drop waits in
+ * `editor.storage.blockDropTarget.pending`, lists the transforms available for it and runs the one picked. Escape or a
+ * click elsewhere cancels the drop.
+ */
+type __VLS_Props = {
+  editor: Editor;
+};
+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=TransferMenu.vue.d.ts.map

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

@@ -0,0 +1,76 @@
+import { Store } from "../../core/store.js";
+import { EditorFeature } from "../../core/feature.js";
+import { BlockTransfer } from "../../core/block-transfer.js";
+import "../../core/index.js";
+import { BlockTransform } from "./transforms.js";
+import { Node } from "@tiptap/pm/model";
+//#region src/features/transfer/feature.d.ts
+/** One drop of a block: the dragged block, where it lands (document position), whether the transform menu opens first and where it opens (viewport pixels). */
+export interface TransferDrop {
+  payload: BlockTransfer;
+  pos: number;
+  /** `true`: the menu opens at (`x`, `y`) and the user picks the transform; `false`: the default transform runs. */
+  menu: boolean;
+  x: number;
+  y: number;
+}
+/** A drop waiting for the user to pick a transform from the menu (`TransferDrop` with `menu` on). */
+export type PendingDrop = TransferDrop;
+export interface BlockDropTargetStorage {
+  /** The drop the transform menu is open for; `null` while no menu is open. */
+  pending: Store<PendingDrop | null>;
+  /** The transforms the menu offers for `drop` (those whose `available` says yes). */
+  available: (drop: PendingDrop) => BlockTransform[];
+  /** Closes the menu and runs the transform `id` for `drop` (a refused insert shows its notice). */
+  run: (id: string, drop: PendingDrop) => Promise<void>;
+}
+declare module '@tiptap/core' {
+  interface Storage {
+    /** Absent in an editor without the transfer feature. */
+    blockDropTarget?: BlockDropTargetStorage;
+  }
+  interface Commands<ReturnType> {
+    blockTransfer: {
+      /**
+       * Puts the block of `payload` into the document at `pos` (a position where a block may be inserted): with `menu`
+       * the transform menu opens at (`x`, `y`) and the transform the user picks runs, else the default transform runs.
+       * Refuses a drop of a block onto its own position in the same document (notice). Used by the document tree's drop executor.
+       */
+      transferBlock: (options: {
+        payload: BlockTransfer;
+        pos: number;
+        menu: boolean;
+        x?: number;
+        y?: number;
+      }) => ReturnType;
+      /** Closes the transform menu without inserting anything. */
+      cancelTransfer: () => ReturnType;
+    };
+  }
+}
+/**
+ * Whether dropping `payload` at `pos` of `doc` lands inside the very block it was dragged from: the payload names a
+ * block of this document (same `documentId`, a block with that id exists) and `pos` is strictly inside it.
+ */
+export declare function isSelfDrop(doc: Node, documentId: string | null | undefined, payload: BlockTransfer, pos: number): boolean;
+/** Options of `transferFeature`. */
+export interface TransferFeatureOptions {
+  /** The transforms the menu offers and a drop can run; default `[copyTransform]` (`composeEditor` adds the AI transforms of `@ecsplico/editor/integrations/composite-ai` when `ai` is on). A host list replaces the default (add built-ins explicitly). */
+  transforms?: readonly BlockTransform[];
+  /** Id of the transform a plain drop (no Shift) runs; default `copy`. */
+  defaultTransform?: string;
+}
+/** What a framework binding supplies to `transferFeatureCore`. */
+export interface TransferUi<C> {
+  /** The transform menu (receives `{ editor }`), mounted as an overlay. */
+  menu: C;
+}
+/**
+ * Block transfer between editor surfaces and document trees (the framework-free part of `transferFeature`): a block
+ * dragged out of another surface lands as a copy with fresh ids and a `meta.derivation` pointing at its source, or,
+ * with Shift held at the drop, as the result of a transform picked from a menu (the copy, and the AI transforms a host or `composeEditor` adds).
+ * Insert guards apply; the commands `transferBlock` and `cancelTransfer` serve the document tree's drops.
+ */
+export declare function transferFeatureCore<C>(ui: TransferUi<C>, options?: TransferFeatureOptions): EditorFeature<C>;
+//#endregion
+//# sourceMappingURL=feature.d.ts.map

package/dist/features/transfer/feature.js

@@ -0,0 +1,169 @@
+import { findBlockById } from "../../core/schema/block-ids.js";
+import { readBlockTransfer } from "../../core/block-transfer.js";
+import { createStore } from "../../core/store.js";
+import { DEFAULT_TRANSFORMS, availableTransforms, runTransform } from "./transforms.js";
+import { Extension } from "@tiptap/core";
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+import { Fragment, Slice } from "@tiptap/pm/model";
+import { dropPoint } from "@tiptap/pm/transform";
+//#region src/features/transfer/feature.ts
+/**
+* Whether dropping `payload` at `pos` of `doc` lands inside the very block it was dragged from: the payload names a
+* block of this document (same `documentId`, a block with that id exists) and `pos` is strictly inside it.
+*/
+function isSelfDrop(doc, documentId, payload, pos) {
+	if (!payload.blockId || (payload.documentId ?? null) !== (documentId ?? null)) return false;
+	const found = findBlockById(doc, payload.blockId);
+	return !!found && pos > found.pos && pos < found.pos + found.node.nodeSize;
+}
+/**
+* The shared tail of a drop (DOM drop and `transferBlock`): refuses a self-drop, else opens the menu (`menu`) or runs
+* the default transform.
+*/
+function dropBlock(env, documentId, defaultId, pending, drop) {
+	const { payload, pos } = drop;
+	pending.set(null);
+	if (isSelfDrop(env.editor.state.doc, documentId, payload, pos)) {
+		env.notify({
+			kind: "warning",
+			title: env.t("transfer.selfDrop")
+		});
+		return;
+	}
+	if (drop.menu) pending.set(drop);
+	else queueMicrotask(() => {
+		runTransform(env, defaultId, payload, pos);
+	});
+}
+const blockDropTargetKey = new PluginKey("blockDropTarget");
+/**
+* The slice dropping `payload` would insert, for `dropPoint`; `null` when this schema cannot hold the block. It is closed
+* (`openStart` and `openEnd` 0): an open slice would let `dropPoint` return a position inside a paragraph, where the
+* Baustein cannot be inserted.
+*/
+function sliceOf(editor, payload) {
+	try {
+		return new Slice(Fragment.from(editor.schema.nodeFromJSON(payload.json)), 0, 0);
+	} catch {
+		return null;
+	}
+}
+/**
+* Takes blocks dragged out of another editor surface or document tree (`BLOCK_MIME`): a plain drop runs the default
+* transform, Shift opens the transform menu at the drop point. A drag that started in this editor stays ProseMirror's
+* native move. Also the commands `transferBlock` and `cancelTransfer`.
+*/
+function blockDropTarget(ctx, transforms, defaultId) {
+	const envOf = (editor) => ({
+		editor,
+		transforms,
+		ai: ctx.backend.ai,
+		app: ctx.app,
+		notify: ctx.notify,
+		t: ctx.t
+	});
+	let created;
+	const editorOf = () => {
+		if (!created) throw new Error("blockDropTarget: the editor is not created yet");
+		return created;
+	};
+	return Extension.create({
+		name: "blockDropTarget",
+		onBeforeCreate() {
+			created = this.editor;
+		},
+		addStorage() {
+			const pending = createStore(null);
+			return {
+				pending,
+				available: ({ payload, pos }) => availableTransforms(envOf(editorOf()), payload, pos),
+				run: async (id, { payload, pos }) => {
+					pending.set(null);
+					await runTransform(envOf(editorOf()), id, payload, pos);
+				}
+			};
+		},
+		addCommands() {
+			return {
+				transferBlock: ({ payload, pos, menu, x = 0, y = 0 }) => ({ editor, dispatch }) => {
+					if (!dispatch) return true;
+					dropBlock(envOf(editor), ctx.documentId ?? null, defaultId, this.storage.pending, {
+						payload,
+						pos: Math.min(Math.max(pos, 0), editor.state.doc.content.size),
+						menu,
+						x,
+						y
+					});
+					return true;
+				},
+				cancelTransfer: () => () => {
+					this.storage.pending.set(null);
+					return true;
+				}
+			};
+		},
+		addProseMirrorPlugins() {
+			const editor = this.editor;
+			return [new Plugin({
+				key: blockDropTargetKey,
+				props: {
+					handleDOMEvents: { dragover: (view, event) => {
+						if (view.dragging || !view.editable || !event.dataTransfer?.types.includes("application/x-tip-block")) return false;
+						event.preventDefault();
+						event.dataTransfer.dropEffect = "copy";
+						return false;
+					} },
+					handleDrop: (view, event) => {
+						if (view.dragging || !view.editable || !event.dataTransfer) return false;
+						const payload = readBlockTransfer(event.dataTransfer);
+						if (!payload) return false;
+						event.preventDefault();
+						const env = envOf(editor);
+						const slice = sliceOf(editor, payload);
+						if (!slice) {
+							env.notify({
+								kind: "warning",
+								title: env.t("transfer.refused")
+							});
+							return true;
+						}
+						const at = view.posAtCoords({
+							left: event.clientX,
+							top: event.clientY
+						})?.pos ?? view.state.doc.content.size;
+						const pos = dropPoint(view.state.doc, at, slice) ?? view.state.doc.content.size;
+						dropBlock(env, ctx.documentId ?? null, defaultId, this.storage.pending, {
+							payload,
+							pos,
+							menu: event.shiftKey,
+							x: event.clientX,
+							y: event.clientY
+						});
+						return true;
+					}
+				}
+			})];
+		}
+	});
+}
+/**
+* Block transfer between editor surfaces and document trees (the framework-free part of `transferFeature`): a block
+* dragged out of another surface lands as a copy with fresh ids and a `meta.derivation` pointing at its source, or,
+* with Shift held at the drop, as the result of a transform picked from a menu (the copy, and the AI transforms a host or `composeEditor` adds).
+* Insert guards apply; the commands `transferBlock` and `cancelTransfer` serve the document tree's drops.
+*/
+function transferFeatureCore(ui, options = {}) {
+	const transforms = options.transforms ?? DEFAULT_TRANSFORMS;
+	const defaultId = options.defaultTransform ?? "copy";
+	return {
+		id: "transfer",
+		dimension: "interaction",
+		requires: ["composites"],
+		extensions: (ctx) => [blockDropTarget(ctx, transforms, defaultId)],
+		overlays: [ui.menu]
+	};
+}
+//#endregion
+export { isSelfDrop, transferFeatureCore };
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"feature.js","names":[],"sources":["../../../src/features/transfer/feature.ts"],"sourcesContent":["import { type AnyExtension, type Editor, Extension } from '@tiptap/core'\nimport { Fragment, type Node as PMNode, Slice } from '@tiptap/pm/model'\nimport { Plugin, PluginKey } from '@tiptap/pm/state'\nimport { dropPoint } from '@tiptap/pm/transform'\nimport { BLOCK_MIME, type BlockTransfer, readBlockTransfer } from '../../core'\nimport type { EditorFeature, FeatureContext } from '../../core/feature'\nimport { findBlockById } from '../../core/schema'\nimport { createStore, type Store } from '../../core/store'\nimport { availableTransforms, type BlockTransform, DEFAULT_TRANSFORMS, runTransform, type TransferEnv } from './transforms'\n\n/** One drop of a block: the dragged block, where it lands (document position), whether the transform menu opens first and where it opens (viewport pixels). */\nexport interface TransferDrop {\n  payload: BlockTransfer\n  pos: number\n  /** `true`: the menu opens at (`x`, `y`) and the user picks the transform; `false`: the default transform runs. */\n  menu: boolean\n  x: number\n  y: number\n}\n\n/** A drop waiting for the user to pick a transform from the menu (`TransferDrop` with `menu` on). */\nexport type PendingDrop = TransferDrop\n\nexport interface BlockDropTargetStorage {\n  /** The drop the transform menu is open for; `null` while no menu is open. */\n  pending: Store<PendingDrop | null>\n  /** The transforms the menu offers for `drop` (those whose `available` says yes). */\n  available: (drop: PendingDrop) => BlockTransform[]\n  /** Closes the menu and runs the transform `id` for `drop` (a refused insert shows its notice). */\n  run: (id: string, drop: PendingDrop) => Promise<void>\n}\n\ndeclare module '@tiptap/core' {\n  interface Storage {\n    /** Absent in an editor without the transfer feature. */\n    blockDropTarget?: BlockDropTargetStorage\n  }\n  interface Commands<ReturnType> {\n    blockTransfer: {\n      /**\n       * Puts the block of `payload` into the document at `pos` (a position where a block may be inserted): with `menu`\n       * the transform menu opens at (`x`, `y`) and the transform the user picks runs, else the default transform runs.\n       * Refuses a drop of a block onto its own position in the same document (notice). Used by the document tree's drop executor.\n       */\n      transferBlock: (options: { payload: BlockTransfer, pos: number, menu: boolean, x?: number, y?: number }) => ReturnType\n      /** Closes the transform menu without inserting anything. */\n      cancelTransfer: () => ReturnType\n    }\n  }\n}\n\n/**\n * Whether dropping `payload` at `pos` of `doc` lands inside the very block it was dragged from: the payload names a\n * block of this document (same `documentId`, a block with that id exists) and `pos` is strictly inside it.\n */\nexport function isSelfDrop(doc: PMNode, documentId: string | null | undefined, payload: BlockTransfer, pos: number): boolean {\n  if (!payload.blockId || (payload.documentId ?? null) !== (documentId ?? null)) return false\n  const found = findBlockById(doc, payload.blockId)\n  return !!found && pos > found.pos && pos < found.pos + found.node.nodeSize\n}\n\n/**\n * The shared tail of a drop (DOM drop and `transferBlock`): refuses a self-drop, else opens the menu (`menu`) or runs\n * the default transform.\n */\nfunction dropBlock(env: TransferEnv, documentId: string | null, defaultId: string, pending: Store<PendingDrop | null>, drop: TransferDrop): void {\n  const { payload, pos } = drop\n  pending.set(null)\n  if (isSelfDrop(env.editor.state.doc, documentId, payload, pos)) {\n    env.notify({ kind: 'warning', title: env.t('transfer.selfDrop') })\n    return\n  }\n  if (drop.menu) pending.set(drop)\n  // The transform dispatches its own transaction, which must not collide with the one a tiptap command still holds (the command's transaction is dispatched after it returns).\n  else queueMicrotask(() => { void runTransform(env, defaultId, payload, pos) })\n}\n\nconst blockDropTargetKey = new PluginKey('blockDropTarget')\n\n/**\n * The slice dropping `payload` would insert, for `dropPoint`; `null` when this schema cannot hold the block. It is closed\n * (`openStart` and `openEnd` 0): an open slice would let `dropPoint` return a position inside a paragraph, where the\n * Baustein cannot be inserted.\n */\nfunction sliceOf(editor: Editor, payload: BlockTransfer): Slice | null {\n  try {\n    return new Slice(Fragment.from(editor.schema.nodeFromJSON(payload.json)), 0, 0)\n  }\n  catch {\n    return null\n  }\n}\n\n/**\n * Takes blocks dragged out of another editor surface or document tree (`BLOCK_MIME`): a plain drop runs the default\n * transform, Shift opens the transform menu at the drop point. A drag that started in this editor stays ProseMirror's\n * native move. Also the commands `transferBlock` and `cancelTransfer`.\n */\nfunction blockDropTarget(ctx: FeatureContext, transforms: readonly BlockTransform[], defaultId: string): AnyExtension {\n  const envOf = (editor: Editor): TransferEnv => ({ editor, transforms, ai: ctx.backend.ai, app: ctx.app, notify: ctx.notify, t: ctx.t })\n  // The storage is built before the editor exists (`addStorage` has no `this.editor`); `onBeforeCreate` hands it over.\n  let created: Editor | undefined\n  const editorOf = (): Editor => {\n    if (!created) throw new Error('blockDropTarget: the editor is not created yet')\n    return created\n  }\n  return Extension.create<unknown, BlockDropTargetStorage>({\n    name: 'blockDropTarget',\n    onBeforeCreate() {\n      created = this.editor\n    },\n    addStorage() {\n      const pending = createStore<PendingDrop | null>(null)\n      return {\n        pending,\n        available: ({ payload, pos }) => availableTransforms(envOf(editorOf()), payload, pos),\n        run: async (id, { payload, pos }) => {\n          pending.set(null)\n          await runTransform(envOf(editorOf()), id, payload, pos)\n        },\n      }\n    },\n    addCommands() {\n      return {\n        transferBlock: ({ payload, pos, menu, x = 0, y = 0 }) => ({ editor, dispatch }) => {\n          if (!dispatch) return true\n          dropBlock(envOf(editor), ctx.documentId ?? null, defaultId, this.storage.pending, { payload, pos: Math.min(Math.max(pos, 0), editor.state.doc.content.size), menu, x, y })\n          return true\n        },\n        cancelTransfer: () => () => {\n          this.storage.pending.set(null)\n          return true\n        },\n      }\n    },\n    addProseMirrorPlugins() {\n      const editor = this.editor\n      return [new Plugin({\n        key: blockDropTargetKey,\n        props: {\n          handleDOMEvents: {\n            dragover: (view, event) => {\n              if (view.dragging || !view.editable || !event.dataTransfer?.types.includes(BLOCK_MIME)) return false\n              event.preventDefault()\n              event.dataTransfer.dropEffect = 'copy'\n              return false\n            },\n          },\n          handleDrop: (view, event) => {\n            if (view.dragging || !view.editable || !event.dataTransfer) return false\n            const payload = readBlockTransfer(event.dataTransfer)\n            if (!payload) return false\n            event.preventDefault()\n            const env = envOf(editor)\n            const slice = sliceOf(editor, payload)\n            if (!slice) {\n              env.notify({ kind: 'warning', title: env.t('transfer.refused') })\n              return true\n            }\n            const at = view.posAtCoords({ left: event.clientX, top: event.clientY })?.pos ?? view.state.doc.content.size\n            const pos = dropPoint(view.state.doc, at, slice) ?? view.state.doc.content.size\n            dropBlock(env, ctx.documentId ?? null, defaultId, this.storage.pending, { payload, pos, menu: event.shiftKey, x: event.clientX, y: event.clientY })\n            return true\n          },\n        },\n      })]\n    },\n  })\n}\n\n/** Options of `transferFeature`. */\nexport interface TransferFeatureOptions {\n  /** The transforms the menu offers and a drop can run; default `[copyTransform]` (`composeEditor` adds the AI transforms of `@ecsplico/editor/integrations/composite-ai` when `ai` is on). A host list replaces the default (add built-ins explicitly). */\n  transforms?: readonly BlockTransform[]\n  /** Id of the transform a plain drop (no Shift) runs; default `copy`. */\n  defaultTransform?: string\n}\n\n/** What a framework binding supplies to `transferFeatureCore`. */\nexport interface TransferUi<C> {\n  /** The transform menu (receives `{ editor }`), mounted as an overlay. */\n  menu: C\n}\n\n/**\n * Block transfer between editor surfaces and document trees (the framework-free part of `transferFeature`): a block\n * dragged out of another surface lands as a copy with fresh ids and a `meta.derivation` pointing at its source, or,\n * with Shift held at the drop, as the result of a transform picked from a menu (the copy, and the AI transforms a host or `composeEditor` adds).\n * Insert guards apply; the commands `transferBlock` and `cancelTransfer` serve the document tree's drops.\n */\nexport function transferFeatureCore<C>(ui: TransferUi<C>, options: TransferFeatureOptions = {}): EditorFeature<C> {\n  const transforms = options.transforms ?? DEFAULT_TRANSFORMS\n  const defaultId = options.defaultTransform ?? 'copy'\n  return {\n    id: 'transfer',\n    dimension: 'interaction',\n    requires: ['composites'],\n    extensions: ctx => [blockDropTarget(ctx, transforms, defaultId)],\n    overlays: [ui.menu],\n  }\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,3 @@
+import { BlockTransform, DEFAULT_TRANSFORMS, TransferEnv, TransformContext, availableTransforms, copyTransform, createsOf, runTransform, transferKindOf, transferSourceHash, transformContextOf, withFreshBlockIds } from "./transforms.js";
+import { BlockDropTargetStorage, PendingDrop, TransferDrop, TransferFeatureOptions, TransferUi, isSelfDrop, transferFeatureCore } from "./feature.js";
+export { type BlockDropTargetStorage, type BlockTransform, DEFAULT_TRANSFORMS, type PendingDrop, type TransferDrop, type TransferEnv, type TransferFeatureOptions, type TransferUi, type TransformContext, availableTransforms, copyTransform, createsOf, isSelfDrop, runTransform, transferFeatureCore, transferKindOf, transferSourceHash, transformContextOf, withFreshBlockIds };

package/dist/features/transfer/index.js

@@ -0,0 +1,3 @@
+import { DEFAULT_TRANSFORMS, availableTransforms, copyTransform, createsOf, runTransform, transferKindOf, transferSourceHash, transformContextOf, withFreshBlockIds } from "./transforms.js";
+import { isSelfDrop, transferFeatureCore } from "./feature.js";
+export { DEFAULT_TRANSFORMS, availableTransforms, copyTransform, createsOf, isSelfDrop, runTransform, transferFeatureCore, transferKindOf, transferSourceHash, transformContextOf, withFreshBlockIds };

package/dist/features/transfer/react/TransferMenu.d.ts

@@ -0,0 +1,12 @@
+import { Editor } from "@tiptap/core";
+//#region src/features/transfer/react/TransferMenu.d.ts
+/**
+ * The transform menu of a Shift-drop (mounted by the transfer feature): opens at the drop point while a drop waits in
+ * `editor.storage.blockDropTarget.pending`, lists the transforms available for it and runs the one picked. Escape or a
+ * click elsewhere cancels the drop.
+ */
+export declare function TransferMenu({ editor }: {
+  editor: Editor;
+}): import("react").JSX.Element | null;
+//#endregion
+//# sourceMappingURL=TransferMenu.d.ts.map

package/dist/features/transfer/react/TransferMenu.js

@@ -0,0 +1,71 @@
+import { useEditorI18n } from "../../../react/use-editor-i18n.js";
+import { Icon } from "../../../react/Icon.js";
+import { useStore } from "../../../react/use-store.js";
+import { Button } from "../../../react/ui/button.js";
+import { useEffect, useRef } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/features/transfer/react/TransferMenu.tsx
+const ITEM_HEIGHT = 32;
+const MENU_WIDTH = 240;
+const EDGE = 8;
+/**
+* The transform menu of a Shift-drop (mounted by the transfer feature): opens at the drop point while a drop waits in
+* `editor.storage.blockDropTarget.pending`, lists the transforms available for it and runs the one picked. Escape or a
+* click elsewhere cancels the drop.
+*/
+function TransferMenu({ editor }) {
+	const { t } = useEditorI18n();
+	const storage = editor.storage.blockDropTarget;
+	const pending = useStore(storage.pending);
+	const root = useRef(null);
+	const open = pending !== null;
+	useEffect(() => {
+		if (!open) return;
+		const cancel = () => editor.commands.cancelTransfer();
+		const onKey = (event) => {
+			if (event.key !== "Escape") return;
+			event.preventDefault();
+			cancel();
+		};
+		const onPointerDown = (event) => {
+			if (!root.current?.contains(event.target)) cancel();
+		};
+		document.addEventListener("keydown", onKey, true);
+		document.addEventListener("pointerdown", onPointerDown, true);
+		return () => {
+			document.removeEventListener("keydown", onKey, true);
+			document.removeEventListener("pointerdown", onPointerDown, true);
+		};
+	}, [open, editor]);
+	if (!pending) return null;
+	const transforms = storage.available(pending);
+	const height = transforms.length * ITEM_HEIGHT + ITEM_HEIGHT + 16;
+	const left = Math.max(EDGE, Math.min(pending.x, window.innerWidth - MENU_WIDTH - EDGE));
+	const top = Math.max(EDGE, Math.min(pending.y, window.innerHeight - height - EDGE));
+	return /* @__PURE__ */ jsxs("div", {
+		ref: root,
+		className: "fixed z-50 rounded-lg border border-border bg-popover p-1 text-popover-foreground shadow-lg",
+		style: {
+			left,
+			top,
+			width: MENU_WIDTH
+		},
+		role: "menu",
+		"aria-label": t("transfer.menu.title"),
+		children: [/* @__PURE__ */ jsx("p", {
+			className: "px-2 py-1 text-xs text-muted-foreground",
+			children: t("transfer.menu.title")
+		}), transforms.map((transform) => /* @__PURE__ */ jsxs(Button, {
+			variant: "ghost",
+			size: "sm",
+			className: "w-full justify-start",
+			role: "menuitem",
+			onClick: () => void storage.run(transform.id, pending),
+			children: [/* @__PURE__ */ jsx(Icon, { name: transform.icon }), transform.labelKey ? t(transform.labelKey) : transform.label]
+		}, transform.id))]
+	});
+}
+//#endregion
+export { TransferMenu };
+
+//# sourceMappingURL=TransferMenu.js.map

package/dist/features/transfer/react/TransferMenu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransferMenu.js","names":[],"sources":["../../../../src/features/transfer/react/TransferMenu.tsx"],"sourcesContent":["import type { Editor } from '@tiptap/core'\nimport { useEffect, useRef } from 'react'\nimport { Icon } from '../../../react/Icon'\nimport { Button } from '../../../react/ui/button'\nimport { useStore } from '../../../react/use-store'\nimport { useEditorI18n } from '../../../react/use-editor-i18n'\nimport type { BlockTransform } from '../transforms'\n\nconst ITEM_HEIGHT = 32\nconst MENU_WIDTH = 240\nconst EDGE = 8\n\n/**\n * The transform menu of a Shift-drop (mounted by the transfer feature): opens at the drop point while a drop waits in\n * `editor.storage.blockDropTarget.pending`, lists the transforms available for it and runs the one picked. Escape or a\n * click elsewhere cancels the drop.\n */\nexport function TransferMenu({ editor }: { editor: Editor }) {\n  const { t } = useEditorI18n()\n  const storage = editor.storage.blockDropTarget!\n  const pending = useStore(storage.pending)\n  const root = useRef<HTMLDivElement>(null)\n  const open = pending !== null\n\n  useEffect(() => {\n    if (!open) return\n    const cancel = () => editor.commands.cancelTransfer()\n    const onKey = (event: KeyboardEvent) => {\n      if (event.key !== 'Escape') return\n      event.preventDefault()\n      cancel()\n    }\n    const onPointerDown = (event: PointerEvent) => {\n      if (!root.current?.contains(event.target as Node)) cancel()\n    }\n    document.addEventListener('keydown', onKey, true)\n    document.addEventListener('pointerdown', onPointerDown, true)\n    return () => {\n      document.removeEventListener('keydown', onKey, true)\n      document.removeEventListener('pointerdown', onPointerDown, true)\n    }\n  }, [open, editor])\n\n  if (!pending) return null\n  const transforms: BlockTransform[] = storage.available(pending)\n  const height = transforms.length * ITEM_HEIGHT + ITEM_HEIGHT + 2 * EDGE\n  const left = Math.max(EDGE, Math.min(pending.x, window.innerWidth - MENU_WIDTH - EDGE))\n  const top = Math.max(EDGE, Math.min(pending.y, window.innerHeight - height - EDGE))\n  return (\n    <div\n      ref={root}\n      className=\"fixed z-50 rounded-lg border border-border bg-popover p-1 text-popover-foreground shadow-lg\"\n      style={{ left, top, width: MENU_WIDTH }}\n      role=\"menu\"\n      aria-label={t('transfer.menu.title')}\n    >\n      <p className=\"px-2 py-1 text-xs text-muted-foreground\">{t('transfer.menu.title')}</p>\n      {transforms.map(transform => (\n        <Button key={transform.id} variant=\"ghost\" size=\"sm\" className=\"w-full justify-start\" role=\"menuitem\" onClick={() => void storage.run(transform.id, pending)}>\n          <Icon name={transform.icon} />\n          {transform.labelKey ? t(transform.labelKey) : transform.label}\n        </Button>\n      ))}\n    </div>\n  )\n}\n"],"mappings":";;;;;;;AAQA,MAAM,cAAc;AACpB,MAAM,aAAa;AACnB,MAAM,OAAO;;;;;;AAOb,SAAgB,aAAa,EAAE,UAA8B;CAC3D,MAAM,EAAE,MAAM,cAAc;CAC5B,MAAM,UAAU,OAAO,QAAQ;CAC/B,MAAM,UAAU,SAAS,QAAQ,OAAO;CACxC,MAAM,OAAO,OAAuB,IAAI;CACxC,MAAM,OAAO,YAAY;CAEzB,gBAAgB;EACd,IAAI,CAAC,MAAM;EACX,MAAM,eAAe,OAAO,SAAS,eAAe;EACpD,MAAM,SAAS,UAAyB;GACtC,IAAI,MAAM,QAAQ,UAAU;GAC5B,MAAM,eAAe;GACrB,OAAO;EACT;EACA,MAAM,iBAAiB,UAAwB;GAC7C,IAAI,CAAC,KAAK,SAAS,SAAS,MAAM,MAAc,GAAG,OAAO;EAC5D;EACA,SAAS,iBAAiB,WAAW,OAAO,IAAI;EAChD,SAAS,iBAAiB,eAAe,eAAe,IAAI;EAC5D,aAAa;GACX,SAAS,oBAAoB,WAAW,OAAO,IAAI;GACnD,SAAS,oBAAoB,eAAe,eAAe,IAAI;EACjE;CACF,GAAG,CAAC,MAAM,MAAM,CAAC;CAEjB,IAAI,CAAC,SAAS,OAAO;CACrB,MAAM,aAA+B,QAAQ,UAAU,OAAO;CAC9D,MAAM,SAAS,WAAW,SAAS,cAAc,cAAc;CAC/D,MAAM,OAAO,KAAK,IAAI,MAAM,KAAK,IAAI,QAAQ,GAAG,OAAO,aAAa,aAAa,IAAI,CAAC;CACtF,MAAM,MAAM,KAAK,IAAI,MAAM,KAAK,IAAI,QAAQ,GAAG,OAAO,cAAc,SAAS,IAAI,CAAC;CAClF,OACE,qBAAC,OAAD;EACE,KAAK;EACL,WAAU;EACV,OAAO;GAAE;GAAM;GAAK,OAAO;EAAW;EACtC,MAAK;EACL,cAAY,EAAE,qBAAqB;EALrC,UAAA,CAOE,oBAAC,KAAD;GAAG,WAAU;GAA2C,UAAA,EAAE,qBAAqB;EAAK,CAAA,GACnF,WAAW,KAAI,cACd,qBAAC,QAAD;GAA2B,SAAQ;GAAQ,MAAK;GAAK,WAAU;GAAuB,MAAK;GAAW,eAAe,KAAK,QAAQ,IAAI,UAAU,IAAI,OAAO;GAA3J,UAAA,CACE,oBAAC,MAAD,EAAM,MAAM,UAAU,KAAO,CAAA,GAC5B,UAAU,WAAW,EAAE,UAAU,QAAQ,IAAI,UAAU,KAClD;EAHK,GAAA,UAAU,EAGf,CACT,CACE;;AAET"}

package/dist/features/transfer/react.d.ts

@@ -0,0 +1,10 @@
+import { ReactFeature } from "../../react/EditorSurface.js";
+import "../../react/index.js";
+import { TransferFeatureOptions } from "./feature.js";
+import { TransferMenu } from "./react/TransferMenu.js";
+//#region src/features/transfer/react.d.ts
+/** The React transfer feature (shadcn): see `transferFeatureCore`. */
+export declare function transferFeature(options?: TransferFeatureOptions): ReactFeature;
+//#endregion
+export { TransferMenu };
+//# sourceMappingURL=react.d.ts.map

package/dist/features/transfer/react.js

@@ -0,0 +1,11 @@
+import { transferFeatureCore } from "./feature.js";
+import { TransferMenu } from "./react/TransferMenu.js";
+//#region src/features/transfer/react.ts
+/** The React transfer feature (shadcn): see `transferFeatureCore`. */
+function transferFeature(options = {}) {
+	return transferFeatureCore({ menu: TransferMenu }, options);
+}
+//#endregion
+export { TransferMenu, transferFeature };
+
+//# sourceMappingURL=react.js.map

package/dist/features/transfer/react.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.js","names":[],"sources":["../../../src/features/transfer/react.ts"],"sourcesContent":["import type { Editor } from '@tiptap/core'\nimport type { ComponentType } from 'react'\nimport type { ReactFeature } from '../../react'\nimport { type TransferFeatureOptions, transferFeatureCore } from './feature'\nimport { TransferMenu } from './react/TransferMenu'\n\nexport { TransferMenu } from './react/TransferMenu'\n\n/** The React transfer feature (shadcn): see `transferFeatureCore`. */\nexport function transferFeature(options: TransferFeatureOptions = {}): ReactFeature {\n  return transferFeatureCore<ComponentType<{ editor: Editor }>>({ menu: TransferMenu }, options)\n}\n"],"mappings":";;;;AASA,SAAgB,gBAAgB,UAAkC,CAAC,GAAiB;CAClF,OAAO,oBAAuD,EAAE,MAAM,aAAa,GAAG,OAAO;AAC/F"}

package/dist/features/transfer/transforms.d.ts

@@ -0,0 +1,83 @@
+import { MessageKey, Translate } from "../../i18n/index.js";
+import { EditorBackend } from "../../core/backend.js";
+import { Notifier } from "../../core/notify.js";
+import { EditorContext } from "../../core/context.js";
+import { Creates } from "../../core/command-types.js";
+import { BlockTransfer } from "../../core/block-transfer.js";
+import "../../core/index.js";
+import { Editor, JSONContent } from "@tiptap/core";
+//#region src/features/transfer/transforms.d.ts
+/** What a transform works with: the target editor, the dragged block, where it lands and the app services. */
+export interface TransformContext {
+  editor: Editor;
+  payload: BlockTransfer;
+  /** Document position the result is inserted at (a valid drop point of `editor.state.doc`). */
+  pos: number;
+  /** The app's AI backend; absent when the app has none. */
+  ai: EditorBackend['ai'] | undefined;
+  /** The app context the editor belongs to; transforms that need app services (the AI model profiles) read them from it. */
+  app: EditorContext;
+  notify: Notifier;
+  t: Translate;
+}
+/** One way to put a dragged block into a surface: offered by the transform menu and run by a plain drop (the default transform). */
+export interface BlockTransform {
+  id: string;
+  /** Menu text; shown as is unless `labelKey` is set. */
+  label: string;
+  /** Message key of the label: the menu renders it in the editor's language instead of `label`. */
+  labelKey?: MessageKey;
+  /** Iconify name (`i-lucide-…`). */
+  icon: string;
+  /** Absent = always available. */
+  available?: (ctx: TransformContext) => boolean;
+  /**
+   * What `run` inserts at `ctx.pos`, so the insert guards and the target's content rules are checked before `run`; a
+   * refused insert shows the warning „lässt sich nicht einfügen“ and runs nothing. Absent: the transform `copy` is
+   * checked as inserting the dragged block itself, every other transform checks itself.
+   */
+  creates?: (ctx: TransformContext) => Creates | null;
+  run: (ctx: TransformContext) => Promise<void>;
+}
+/** `json` with a fresh block id on every block that carries one (recursively); other nodes and attributes stay. */
+export declare function withFreshBlockIds(editor: Editor, json: JSONContent): JSONContent;
+/** The `Creates` a node of `json` stands for in the insert guards. */
+export declare const createsOf: (json: JSONContent) => Creates;
+/**
+ * The hash a derivation of the dragged block records as `inputHash`: the Markdown of a Baustein's body (the same text
+ * `derivationState` hashes for a source in the open document), else of the whole block. Without a Markdown serializer the
+ * hash of the payload's Markdown.
+ */
+export declare function transferSourceHash(editor: Editor, payload: BlockTransfer): string;
+/** The kind of Baustein the AI transforms insert: the setting `blocks.defaultKind` when the editor offers it, else its first kind. */
+export declare function transferKindOf(editor: Editor): string;
+/**
+ * „Kopie einfügen“: inserts the dragged block with fresh block ids (the block and every block inside it). A Baustein
+ * that has a block id records its source in `meta.derivation` (`from: { block, document }`, method `copy`, the source
+ * Markdown as `inputHash`, the hash of the copy's body as `outputHash`, so the badge shows „bearbeitet“ once the copy is edited).
+ */
+export declare const copyTransform: BlockTransform;
+/** The transforms `transferFeature` offers unless the host passes its own list: the copy. The AI transforms (`summaryTransform`, `bulletsTransform`) live in `@ecsplico/editor/integrations/composite-ai`; `composeEditor` adds them when `ai` is on. */
+export declare const DEFAULT_TRANSFORMS: readonly BlockTransform[];
+/** What `runTransform` needs: the editor, the transform list and the app services. */
+export interface TransferEnv {
+  editor: Editor;
+  transforms: readonly BlockTransform[];
+  ai: EditorBackend['ai'] | undefined;
+  app: EditorContext;
+  notify: Notifier;
+  t: Translate;
+}
+/** The context a transform of `env` gets for dropping `payload` at `pos` (clamped into the document). */
+export declare function transformContextOf(env: TransferEnv, payload: BlockTransfer, pos: number): TransformContext;
+/** The transforms of `env` available for dropping `payload` at `pos`, in list order. */
+export declare function availableTransforms(env: TransferEnv, payload: BlockTransfer, pos: number): BlockTransform[];
+/**
+ * Runs the transform `id` of `env` for dropping `payload` at `pos`. Nothing runs for an unknown or unavailable
+ * transform. What the transform inserts (`BlockTransform.creates`) must pass the insert guards below `pos`'s parent and
+ * the parent's content rules, else the warning „Hier lässt sich der Baustein nicht einfügen“ is shown and the document stays
+ * unchanged. The transform's own failure is its own to report; this never throws for a refusal.
+ */
+export declare function runTransform(env: TransferEnv, id: string, payload: BlockTransfer, pos: number): Promise<void>;
+//#endregion
+//# sourceMappingURL=transforms.d.ts.map