@prosekit/web 0.8.0-beta.0 → 0.8.0-beta.1

package/dist/prosekit-web-table-handle.js

@@ -1,96 +1,204 @@
-import { t as getStateWithDefaults } from "./get-default-state.js";
 import { t as useEditorExtension } from "./use-editor-extension.js";
 import { t as getSafeEditorView } from "./get-safe-editor-view.js";
 import { n as assignStyles, t as useScrolling } from "./use-scrolling.js";
-import { createComputed, createContext, createSignal, defineCustomElement, defineEmit, registerCustomElement, useAttribute, useEffect, useEventListener } from "@aria-ui/core";
+import { computed, createContext, createSignal, defineCustomElement, defineProps, onMount, registerCustomElement, useEffect, useEventListener } from "@aria-ui/core";
+import { OverlayPositionerPropsDeclaration, createOverlayStore, setupOverlayPopup, setupOverlayPositioner } from "@aria-ui/elements/overlay";
 import { defineDOMEventHandler, union } from "@prosekit/core";
-import { useOverlayPositionerState } from "@aria-ui/overlay/elements";
-import { usePresence } from "@aria-ui/presence";
 import { getDocument, getId, isHTMLElement, once } from "@ocavue/utils";
-import { overlayPositionerEvents as overlayPositionerEvents$1, overlayPositionerProps as overlayPositionerProps$1 } from "@aria-ui/overlay";
-import { menuContentEvents, menuContentProps, menuRootEvents, menuRootProps, useMenuContent, useMenuItem, useMenuRoot, useMenuTrigger } from "@aria-ui/menu/elements";
+import { MenuRootPropsDeclaration, setupMenuRoot, setupMenuTrigger } from "@aria-ui/elements/menu";
 import { moveTableColumn, moveTableRow, selectTableColumn, selectTableRow } from "@prosekit/extensions/table";
 import { computePosition, offset } from "@floating-ui/dom";
-import { menuItemEvents, menuItemProps } from "@aria-ui/menu";
 import { TableMap, cellAround } from "prosemirror-tables";
-//#region src/components/table-handle/context.ts
-/**
-* @internal
-*/
-const tableHandleRootContext = createContext("prosekit-table-handle-root-context", null);
+//#region src/components/table-handle/store.ts
+function noop() {}
+function returnTrue() {
+	return true;
+}
+function returnFalse() {
+	return false;
+}
+var DndStore = class {
+	constructor() {
+		this.dragging = createSignal(false);
+		this.direction = createSignal("row");
+		this.draggingIndex = createSignal(-1);
+		this.droppingIndex = createSignal(-1);
+		this.x = createSignal(-1);
+		this.y = createSignal(-1);
+		this.startX = createSignal(-1);
+		this.startY = createSignal(-1);
+	}
+};
 /**
 * @internal
 */
-const defaultTableHandleDndContext = {
-	dragging: false,
-	direction: "row",
-	draggingIndex: -1,
-	droppingIndex: -1,
-	x: -1,
-	y: -1,
-	startX: -1,
-	startY: -1
-};
+function createTableHandleStore(getHoveringCellInfo, getCanShow) {
+	const isColumnMenuOpen = createSignal(false);
+	const isRowMenuOpen = createSignal(false);
+	const getHasMenuOpen = () => {
+		return isColumnMenuOpen.get() || isRowMenuOpen.get();
+	};
+	const setIsRowMenuOpen = (open) => {
+		isRowMenuOpen.set(open);
+	};
+	const setIsColumnMenuOpen = (open) => {
+		isColumnMenuOpen.set(open);
+	};
+	const referenceCellInfo = createSignal(void 0);
+	let prevHoveringCellInfo = void 0;
+	const getReferenceCell = computed(() => {
+		if (!getCanShow()) {
+			referenceCellInfo.set(void 0);
+			return;
+		}
+		if (getHasMenuOpen()) return prevHoveringCellInfo;
+		prevHoveringCellInfo = getHoveringCellInfo();
+		return prevHoveringCellInfo;
+	});
+	const getOpen = computed(() => {
+		return !!getReferenceCell();
+	});
+	const handleOpenChange = (event) => {
+		if (getHasMenuOpen()) event.preventDefault();
+	};
+	const columnOverlayStore = createOverlayStore(getOpen, noop, returnTrue, returnFalse, handleOpenChange);
+	const rowOverlayStore = createOverlayStore(getOpen, noop, returnTrue, returnFalse, handleOpenChange);
+	return {
+		dndStore: new DndStore(),
+		setIsRowMenuOpen,
+		setIsColumnMenuOpen,
+		columnOverlayStore,
+		rowOverlayStore,
+		getReferenceCell
+	};
+}
 /**
 * @internal
 */
-const tableHandleDndContext = createContext("prosekit-table-handle-dnd-context", defaultTableHandleDndContext);
+const tableHandleStoreContext = createContext("prosekit-table-handle-store");
 //#endregion
-//#region src/components/table-handle/table-handle-column-root/setup.ts
+//#region src/components/table-handle/table-handle-column-popup.ts
+/** @internal */
+const TableHandleColumnPopupPropsDeclaration = defineProps({});
+/** @internal */
+function setupTableHandleColumnPopup(host, _props) {
+	const getStore = tableHandleStoreContext.consume(host);
+	const getOverlayStore = () => getStore()?.columnOverlayStore;
+	setupOverlayPopup(host, getOverlayStore);
+}
+const TableHandleColumnPopupElementBase = defineCustomElement(setupTableHandleColumnPopup, TableHandleColumnPopupPropsDeclaration);
 /**
-* @internal
+* @public
 */
-function useTableHandleColumnRoot(host, { state }) {
-	const { editor, ...overlayState } = state;
-	const rootContext = tableHandleRootContext.consume(host);
-	const colFirstCellPos = createComputed(() => {
-		return rootContext.get()?.colFirstCellPos;
-	});
-	const referenceCell = createComputed(() => {
-		const pos = colFirstCellPos.get();
-		const view = getSafeEditorView(editor.get());
-		if (!pos || !view) return null;
-		return view.nodeDOM(pos);
-	});
-	const contentOpen = createSignal(false);
-	useEffect(host, () => {
-		colFirstCellPos.get();
-		contentOpen.set(false);
-	});
-	useOverlayPositionerState(host, overlayState, { reference: referenceCell });
-	const presence = createComputed(() => !!referenceCell.get());
-	useAttribute(host, "data-state", () => presence.get() ? "open" : "closed");
-	usePresence(host, presence);
-	useMenuRoot(host, {
-		state: getStateWithDefaults({ open: contentOpen }, menuRootProps),
-		emit: () => void 0
+var TableHandleColumnPopupElement = class extends TableHandleColumnPopupElementBase {};
+/** @internal */
+function registerTableHandleColumnPopupElement() {
+	registerCustomElement("prosekit-table-handle-column-popup", TableHandleColumnPopupElement);
+}
+//#endregion
+//#region src/utils/use-html-element-at.ts
+function useHTMLElementAt(getEditor, getPos) {
+	return computed(() => {
+		const editor = getEditor();
+		const pos = getPos();
+		if (!editor || !pos) return;
+		const element = editor.view.nodeDOM(pos);
+		if (element && isHTMLElement(element)) return element;
 	});
 }
 //#endregion
-//#region src/components/table-handle/table-handle-column-root/types.ts
+//#region src/components/table-handle/shared.ts
 /** @internal */
-const tableHandleColumnRootProps = Object.freeze({
-	...overlayPositionerProps$1,
-	editor: { default: null },
-	placement: { default: "top" },
-	hoist: { default: false },
-	flip: { default: false },
-	shift: { default: false },
-	hide: { default: true }
+const SharedTableHandlePositionerPropsDeclaration = defineProps({
+	...OverlayPositionerPropsDeclaration,
+	editor: {
+		default: null,
+		attribute: false,
+		type: "json"
+	},
+	hoist: {
+		default: false,
+		attribute: false,
+		type: "boolean"
+	},
+	flip: {
+		default: false,
+		attribute: false,
+		type: "json"
+	},
+	shift: {
+		default: false,
+		attribute: false,
+		type: "boolean"
+	},
+	hide: {
+		default: true,
+		attribute: false,
+		type: "boolean"
+	},
+	offset: {
+		default: 0,
+		attribute: false,
+		type: "json"
+	}
 });
-/** @internal */
-const tableHandleColumnRootEvents = overlayPositionerEvents$1;
 //#endregion
-//#region src/components/table-handle/table-handle-column-root/element.gen.ts
-const TableHandleColumnRootElementBase = defineCustomElement({
-	props: tableHandleColumnRootProps,
-	events: tableHandleColumnRootEvents,
-	setup: useTableHandleColumnRoot
+//#region src/components/table-handle/table-handle-column-positioner.ts
+/** @internal */
+const TableHandleColumnPositionerPropsDeclaration = defineProps({
+	...SharedTableHandlePositionerPropsDeclaration,
+	placement: {
+		default: "top",
+		attribute: "placement",
+		type: "string"
+	}
 });
-var TableHandleColumnRootElement = class extends TableHandleColumnRootElementBase {};
-registerCustomElement("prosekit-table-handle-column-root", TableHandleColumnRootElement);
+/** @internal */
+function setupTableHandleColumnPositioner(host, props) {
+	const getStore = tableHandleStoreContext.consume(host);
+	const getOverlayStore = () => getStore()?.columnOverlayStore;
+	setupOverlayPositioner(host, props, getOverlayStore);
+	const getEditor = props.editor.get;
+	const getReferenceCell = useHTMLElementAt(getEditor, computed(() => getStore()?.getReferenceCell()?.colFirstCellPos));
+	useEffect(host, () => {
+		getOverlayStore()?.setAnchorElement(getReferenceCell());
+	});
+}
+const TableHandleColumnPositionerElementBase = defineCustomElement(setupTableHandleColumnPositioner, TableHandleColumnPositionerPropsDeclaration);
+/**
+* @public
+*/
+var TableHandleColumnPositionerElement = class extends TableHandleColumnPositionerElementBase {};
+/** @internal */
+function registerTableHandleColumnPositionerElement() {
+	registerCustomElement("prosekit-table-handle-column-positioner", TableHandleColumnPositionerElement);
+}
+//#endregion
+//#region src/components/table-handle/table-handle-column-menu-root.ts
+/** @internal */
+const TableHandleColumnMenuRootPropsDeclaration = defineProps(MenuRootPropsDeclaration);
+/** @internal */
+function setupTableHandleColumnMenuRoot(host, props) {
+	setupMenuRoot(host, props);
+	const getStore = tableHandleStoreContext.consume(host);
+	useEffect(host, () => {
+		const open = props.open.get() || false;
+		const store = getStore?.();
+		if (!store) return;
+		store.setIsColumnMenuOpen(open);
+	});
+}
+const TableHandleColumnMenuRootElementBase = defineCustomElement(setupTableHandleColumnMenuRoot, TableHandleColumnMenuRootPropsDeclaration);
+/**
+* @public
+*/
+var TableHandleColumnMenuRootElement = class extends TableHandleColumnMenuRootElementBase {};
+/** @internal */
+function registerTableHandleColumnMenuRootElement() {
+	registerCustomElement("prosekit-table-handle-column-menu-root", TableHandleColumnMenuRootElement);
+}
 //#endregion
-//#region src/components/table-handle/hooks/use-empty-image.ts
+//#region src/components/table-handle/use-empty-image.ts
 /**
 * Returns a function that returns a 1x1 transparent image. This is used to
 * prevent the browser from showing the default drag image. An earth icon in
@@ -114,21 +222,25 @@ function useEmptyImage(host) {
 	return () => image;
 }
 //#endregion
-//#region src/components/table-handle/table-handle-column-trigger/setup.ts
-/**
-* @internal
-*/
-function useTableHandleColumnTrigger(host, { state }) {
-	useMenuTrigger(host);
-	const context = tableHandleRootContext.consume(host);
-	const dndContext = tableHandleDndContext.consume(host);
+//#region src/components/table-handle/table-handle-column-menu-trigger.ts
+/** @internal */
+const TableHandleColumnMenuTriggerPropsDeclaration = defineProps({ editor: {
+	default: null,
+	attribute: false,
+	type: "json"
+} });
+/** @internal */
+function setupTableHandleColumnMenuTrigger(host, props) {
+	const getEditor = props.editor.get;
+	const getStore = tableHandleStoreContext.consume(host);
+	setupMenuTrigger(host, { disabled: createSignal(false) });
 	useEventListener(host, "pointerdown", () => {
-		const editor = state.editor.peek();
-		const cellPos = context.peek()?.cellPos;
+		const editor = getEditor();
+		const cellPos = getStore()?.getReferenceCell()?.cellPos;
 		if (!editor || !cellPos) return;
 		editor.exec(selectTableColumn({ head: cellPos }));
 	});
-	useEffect(host, () => {
+	onMount(host, () => {
 		host.draggable = true;
 	});
 	const getEmptyImage = useEmptyImage(host);
@@ -140,61 +252,49 @@ function useTableHandleColumnTrigger(host, { state }) {
 			if (emptyImage) dataTransfer.setDragImage(emptyImage, 0, 0);
 			dataTransfer.setData("application/x-prosekit-table-handle-drag", "");
 		}
-		const prev = dndContext.peek();
-		const index = context.peek()?.colIndex;
+		const store = getStore();
+		if (!store) return;
+		const index = store.getReferenceCell()?.colIndex;
 		if (index == null || index < 0) {
 			console.warn("[prosekit] Invalid column index for drag operation:", index);
 			event.preventDefault();
 			return;
 		}
-		dndContext.set({
-			...prev,
-			direction: "col",
-			dragging: true,
-			draggingIndex: index,
-			startX: event.clientX,
-			startY: event.clientY
-		});
+		const dndStore = store.dndStore;
+		dndStore.direction.set("col");
+		dndStore.dragging.set(true);
+		dndStore.draggingIndex.set(index);
+		dndStore.startX.set(event.clientX);
+		dndStore.startY.set(event.clientY);
 	});
 }
-//#endregion
-//#region src/components/table-handle/table-handle-column-trigger/types.ts
-/** @internal */
-const tableHandleColumnTriggerProps = { editor: { default: null } };
-/** @internal */
-const tableHandleColumnTriggerEvents = {};
-//#endregion
-//#region src/components/table-handle/table-handle-column-trigger/element.gen.ts
-const TableHandleColumnTriggerElementBase = defineCustomElement({
-	props: tableHandleColumnTriggerProps,
-	events: tableHandleColumnTriggerEvents,
-	setup: useTableHandleColumnTrigger
-});
-var TableHandleColumnTriggerElement = class extends TableHandleColumnTriggerElementBase {};
-registerCustomElement("prosekit-table-handle-column-trigger", TableHandleColumnTriggerElement);
+const TableHandleColumnMenuTriggerElementBase = defineCustomElement(setupTableHandleColumnMenuTrigger, TableHandleColumnMenuTriggerPropsDeclaration);
+/**
+* @public
+*/
+var TableHandleColumnMenuTriggerElement = class extends TableHandleColumnMenuTriggerElementBase {};
+/**
+* @internal
+*/
+function registerTableHandleColumnMenuTriggerElement() {
+	registerCustomElement("prosekit-table-handle-column-menu-trigger", TableHandleColumnMenuTriggerElement);
+}
 //#endregion
 //#region src/components/table-handle/dnd.ts
-function useInitDndPosition(host, editor, onInit) {
-	const dndContext = tableHandleDndContext.consume(host);
-	const rootContext = tableHandleRootContext.consume(host);
-	const draggingSignal = createComputed(() => {
-		return dndContext.get().dragging;
-	});
-	const directionSignal = createComputed(() => {
-		return dndContext.get().direction;
-	});
-	const draggingIndexSignal = createComputed(() => {
-		return dndContext.get().draggingIndex;
-	});
+function useInitDndPosition(host, getEditor, onInit) {
+	const getStore = tableHandleStoreContext.consume(host);
 	useEffect(host, () => {
-		const view = getSafeEditorView(editor.get());
+		const view = getSafeEditorView(getEditor());
 		if (!view) return;
-		const dragging = draggingSignal.get();
-		const direction = directionSignal.get();
+		const store = getStore();
+		if (!store) return;
+		const dndStore = store.dndStore;
+		const dragging = dndStore.dragging.get();
+		const direction = dndStore.direction.get();
 		host.dataset.direction = direction;
 		host.dataset.dragging = dragging.toString();
-		const draggingIndex = draggingIndexSignal.get();
-		const relatedDOMs = getDndRelatedDOMs(view, rootContext.peek()?.cellPos, draggingIndex, direction);
+		const draggingIndex = dndStore.draggingIndex.get();
+		const relatedDOMs = getDndRelatedDOMs(view, store.getReferenceCell()?.cellPos, draggingIndex, direction);
 		if (!relatedDOMs) return;
 		const { table, cell } = relatedDOMs;
 		onInit({
@@ -349,7 +449,7 @@ function injectStyle(container, styleText) {
 	container.appendChild(style);
 }
 //#endregion
-//#region src/components/table-handle/table-handle-drag-preview/render-preview.ts
+//#region src/components/table-handle/render-preview.ts
 function clearPreviewDOM(previewRoot) {
 	while (previewRoot.firstChild) previewRoot.removeChild(previewRoot.firstChild);
 }
@@ -399,27 +499,59 @@ function unsetSize(element) {
 	});
 }
 //#endregion
-//#region src/components/table-handle/table-handle-drag-preview/updater.ts
-function useUpdatePreviewPosition(host, editor) {
-	const dndContext = tableHandleDndContext.consume(host);
-	const rootContext = tableHandleRootContext.consume(host);
-	const draggingSignal = createComputed(() => {
-		return dndContext.get().dragging;
+//#region src/components/table-handle/table-handle-drag-preview.ts
+/** @internal */
+const TableHandleDragPreviewPropsDeclaration = defineProps({ editor: {
+	default: null,
+	attribute: false,
+	type: "json"
+} });
+/**
+* @internal
+*/
+function setupTableHandleDragPreview(host, props) {
+	const getEditor = props.editor.get;
+	useEffect(host, () => {
+		assignStyles(host, {
+			position: "absolute",
+			pointerEvents: "none"
+		});
 	});
-	const clientXSignal = createComputed(() => {
-		return dndContext.get().x;
+	useInitDndPosition(host, getEditor, onInitPreviewPosition);
+	useUpdatePreviewPosition(host, getEditor);
+}
+function onInitPreviewPosition({ host, direction, dragging, table, cell, draggingIndex }) {
+	assignStyles(host, { display: dragging ? "block" : "none" });
+	if (!dragging) {
+		clearPreviewDOM(host);
+		return;
+	}
+	createPreviewDOM(table, host, draggingIndex, direction);
+	const tableRect = table.getBoundingClientRect();
+	const cellRect = cell.getBoundingClientRect();
+	if (direction === "col") assignStyles(host, {
+		width: `${cellRect.width}px`,
+		height: `${tableRect.height}px`
 	});
-	const clientYSignal = createComputed(() => {
-		return dndContext.get().y;
+	if (direction === "row") assignStyles(host, {
+		width: `${tableRect.width}px`,
+		height: `${cellRect.height}px`
 	});
+}
+function useUpdatePreviewPosition(host, getEditor) {
+	const getStore = tableHandleStoreContext.consume(host);
 	useEffect(host, () => {
-		const view = getSafeEditorView(editor.get());
+		const view = getSafeEditorView(getEditor());
 		if (!view) return;
-		if (!draggingSignal.get()) return;
-		const { draggingIndex, direction } = dndContext.peek();
-		const x = clientXSignal.get();
-		const y = clientYSignal.get();
-		const relatedDOMs = getDndRelatedDOMs(view, rootContext.peek()?.cellPos, draggingIndex, direction);
+		const store = getStore();
+		if (!store) return;
+		const dndStore = store.dndStore;
+		if (!dndStore.dragging.get()) return;
+		const draggingIndex = dndStore.draggingIndex.get();
+		const direction = dndStore.direction.get();
+		const x = dndStore.x.get();
+		const y = dndStore.y.get();
+		const relatedDOMs = getDndRelatedDOMs(view, store.getReferenceCell()?.cellPos, draggingIndex, direction);
 		if (!relatedDOMs) return;
 		const { cell } = relatedDOMs;
 		let cancelled = false;
@@ -457,55 +589,19 @@ function getVirtualElement(cell, x, y) {
 		}
 	};
 }
-//#endregion
-//#region src/components/table-handle/table-handle-drag-preview/setup.ts
+const TableHandleDragPreviewElementBase = defineCustomElement(setupTableHandleDragPreview, TableHandleDragPreviewPropsDeclaration);
+/**
+* @public
+*/
+var TableHandleDragPreviewElement = class extends TableHandleDragPreviewElementBase {};
 /**
 * @internal
 */
-function useTableHandleDragPreview(host, { state }) {
-	const { editor } = state;
-	useEffect(host, () => {
-		assignStyles(host, {
-			position: "absolute",
-			pointerEvents: "none"
-		});
-	});
-	useInitDndPosition(host, editor, onInitPreviewPosition);
-	useUpdatePreviewPosition(host, editor);
-}
-function onInitPreviewPosition({ host, direction, dragging, table, cell, draggingIndex }) {
-	assignStyles(host, { display: dragging ? "block" : "none" });
-	if (!dragging) {
-		clearPreviewDOM(host);
-		return;
-	}
-	createPreviewDOM(table, host, draggingIndex, direction);
-	const tableRect = table.getBoundingClientRect();
-	const cellRect = cell.getBoundingClientRect();
-	if (direction === "col") assignStyles(host, {
-		width: `${cellRect.width}px`,
-		height: `${tableRect.height}px`
-	});
-	if (direction === "row") assignStyles(host, {
-		width: `${tableRect.width}px`,
-		height: `${cellRect.height}px`
-	});
+function registerTableHandleDragPreviewElement() {
+	registerCustomElement("prosekit-table-handle-drag-preview", TableHandleDragPreviewElement);
 }
 //#endregion
-//#region src/components/table-handle/table-handle-drag-preview/types.ts
-const tableHandleDragPreviewProps = { editor: { default: null } };
-const tableHandleDragPreviewEvents = {};
-//#endregion
-//#region src/components/table-handle/table-handle-drag-preview/element.gen.ts
-const TableHandleDragPreviewElementBase = defineCustomElement({
-	props: tableHandleDragPreviewProps,
-	events: tableHandleDragPreviewEvents,
-	setup: useTableHandleDragPreview
-});
-var TableHandleDragPreviewElement = class extends TableHandleDragPreviewElementBase {};
-registerCustomElement("prosekit-table-handle-drag-preview", TableHandleDragPreviewElement);
-//#endregion
-//#region src/components/table-handle/table-handle-drop-indicator/calc-drag-over.ts
+//#region src/components/table-handle/calc-drag-over.ts
 function findDragOverElement(elements, pointer, axis) {
 	const startProp = axis === "x" ? "left" : "top";
 	const endProp = axis === "x" ? "right" : "bottom";
@@ -530,33 +626,54 @@ function getDragOverRow(table, pointerY) {
 	return findDragOverElement(Array.from(table.querySelectorAll("tr")), pointerY, "y");
 }
 //#endregion
-//#region src/components/table-handle/table-handle-drop-indicator/updater.ts
-function useUpdateIndicatorPosition(host, editor, handleWidth) {
-	const dndContext = tableHandleDndContext.consume(host);
-	const rootContext = tableHandleRootContext.consume(host);
-	const draggingSignal = createComputed(() => {
-		return dndContext.get().dragging;
-	});
-	const clientXSignal = createComputed(() => {
-		return dndContext.get().x;
-	});
-	const clientYSignal = createComputed(() => {
-		return dndContext.get().y;
+//#region src/components/table-handle/table-handle-drop-indicator.ts
+const HANDLE_WIDTH = 2;
+/** @internal */
+const TableHandleDropIndicatorPropsDeclaration = defineProps({ editor: {
+	default: null,
+	attribute: false,
+	type: "json"
+} });
+/**
+* @internal
+*/
+function setupTableHandleDropIndicator(host, props) {
+	const getEditor = props.editor.get;
+	useEffect(host, () => {
+		assignStyles(host, {
+			pointerEvents: "none",
+			position: "absolute"
+		});
 	});
-	const startXSignal = createComputed(() => {
-		return dndContext.get().startX;
+	useInitDndPosition(host, getEditor, onInitIndicatorPosition);
+	useUpdateIndicatorPosition(host, getEditor, HANDLE_WIDTH);
+}
+function onInitIndicatorPosition({ host, direction, dragging, table }) {
+	assignStyles(host, { display: dragging ? "block" : "none" });
+	const tableRect = table.getBoundingClientRect();
+	if (direction === "col") assignStyles(host, {
+		width: `${HANDLE_WIDTH}px`,
+		height: `${tableRect.height}px`
 	});
-	const startYSignal = createComputed(() => {
-		return dndContext.get().startY;
+	if (direction === "row") assignStyles(host, {
+		width: `${tableRect.width}px`,
+		height: `${HANDLE_WIDTH}px`
 	});
+}
+function useUpdateIndicatorPosition(host, getEditor, handleWidth) {
+	const getStore = tableHandleStoreContext.consume(host);
 	useEffect(host, () => {
-		const view = getSafeEditorView(editor.get());
+		const view = getSafeEditorView(getEditor());
 		if (!view) return;
-		if (!draggingSignal.get()) return;
-		const { draggingIndex, direction } = dndContext.peek();
-		const x = clientXSignal.get();
-		const y = clientYSignal.get();
-		const relatedDOMs = getDndRelatedDOMs(view, rootContext.peek()?.cellPos, draggingIndex, direction);
+		const store = getStore();
+		if (!store) return;
+		const dndStore = store.dndStore;
+		if (!dndStore.dragging.get()) return;
+		const draggingIndex = dndStore.draggingIndex.get();
+		const direction = dndStore.direction.get();
+		const x = dndStore.x.get();
+		const y = dndStore.y.get();
+		const relatedDOMs = getDndRelatedDOMs(view, store.getReferenceCell()?.cellPos, draggingIndex, direction);
 		if (!relatedDOMs) return;
 		const { table } = relatedDOMs;
 		let cancelled = false;
@@ -564,17 +681,14 @@ function useUpdateIndicatorPosition(host, editor, handleWidth) {
 			cancelled = true;
 		};
 		if (direction === "col") {
-			const direction = startXSignal.get() > x ? "left" : "right";
+			const dir = dndStore.startX.get() > x ? "left" : "right";
 			const dragOverColumn = getDragOverColumn(table, x);
 			if (dragOverColumn) {
 				const [col, index] = dragOverColumn;
-				dndContext.set({
-					...dndContext.peek(),
-					droppingIndex: index
-				});
+				dndStore.droppingIndex.set(index);
 				computePosition(col, host, {
-					placement: direction === "left" ? "left" : "right",
-					middleware: [offset(direction === "left" ? -1 * handleWidth : 0)]
+					placement: dir === "left" ? "left" : "right",
+					middleware: [offset(dir === "left" ? -1 * handleWidth : 0)]
 				}).then(({ x }) => {
 					if (cancelled) return;
 					assignStyles(host, { left: `${x}px` });
@@ -583,17 +697,14 @@ function useUpdateIndicatorPosition(host, editor, handleWidth) {
 			return cleanup;
 		}
 		if (direction === "row") {
-			const direction = startYSignal.get() > y ? "up" : "down";
+			const dir = dndStore.startY.get() > y ? "up" : "down";
 			const dragOverRow = getDragOverRow(table, y);
 			if (dragOverRow) {
 				const [row, index] = dragOverRow;
-				dndContext.set({
-					...dndContext.peek(),
-					droppingIndex: index
-				});
+				dndStore.droppingIndex.set(index);
 				computePosition(row, host, {
-					placement: direction === "up" ? "top" : "bottom",
-					middleware: [offset(direction === "up" ? -1 * handleWidth : 0)]
+					placement: dir === "up" ? "top" : "bottom",
+					middleware: [offset(dir === "up" ? -1 * handleWidth : 0)]
 				}).then(({ y }) => {
 					if (cancelled) return;
 					assignStyles(host, { top: `${y}px` });
@@ -603,150 +714,27 @@ function useUpdateIndicatorPosition(host, editor, handleWidth) {
 		}
 	});
 }
-//#endregion
-//#region src/components/table-handle/table-handle-drop-indicator/setup.ts
-const HANDLE_WIDTH = 2;
+const TableHandleDropIndicatorElementBase = defineCustomElement(setupTableHandleDropIndicator, TableHandleDropIndicatorPropsDeclaration);
 /**
-* @internal
+* @public
 */
-function useTableHandleDropIndicator(host, { state }) {
-	const { editor } = state;
-	useEffect(host, () => {
-		assignStyles(host, {
-			pointerEvents: "none",
-			position: "absolute"
-		});
-	});
-	useInitDndPosition(host, editor, onInitIndicatorPosition);
-	useUpdateIndicatorPosition(host, editor, HANDLE_WIDTH);
-}
-function onInitIndicatorPosition({ host, direction, dragging, table }) {
-	assignStyles(host, { display: dragging ? "block" : "none" });
-	const tableRect = table.getBoundingClientRect();
-	if (direction === "col") assignStyles(host, {
-		width: `${HANDLE_WIDTH}px`,
-		height: `${tableRect.height}px`
-	});
-	if (direction === "row") assignStyles(host, {
-		width: `${tableRect.width}px`,
-		height: `${HANDLE_WIDTH}px`
-	});
-}
-//#endregion
-//#region src/components/table-handle/table-handle-drop-indicator/types.ts
-const tableHandleDropIndicatorProps = { editor: { default: null } };
-const tableHandleDropIndicatorEvents = {};
-//#endregion
-//#region src/components/table-handle/table-handle-drop-indicator/element.gen.ts
-const TableHandleDropIndicatorElementBase = defineCustomElement({
-	props: tableHandleDropIndicatorProps,
-	events: tableHandleDropIndicatorEvents,
-	setup: useTableHandleDropIndicator
-});
 var TableHandleDropIndicatorElement = class extends TableHandleDropIndicatorElementBase {};
-registerCustomElement("prosekit-table-handle-drop-indicator", TableHandleDropIndicatorElement);
-//#endregion
-//#region src/components/table-handle/table-handle-popover-content/setup.ts
 /**
 * @internal
 */
-function useTableHandlePopoverContent(host, { state, emit }) {
-	const rootContext = tableHandleRootContext.consume(host);
-	const keyDownTarget = useKeyDownTarget(host, createComputed(() => !!rootContext.get()));
-	useMenuContent(host, {
-		state: getStateWithDefaults({
-			placement: state.placement,
-			offset: state.offset,
-			eventTarget: createSignal(keyDownTarget)
-		}, menuContentProps),
-		emit
-	});
-}
-function useKeyDownTarget(element, open) {
-	const keydownHandlers = [];
-	useEffect(element, () => {
-		const handleKeydown = (event) => {
-			if (event.isComposing || event.defaultPrevented || !open.get()) return false;
-			keydownHandlers.forEach((handler) => handler(event));
-		};
-		document.addEventListener("keydown", handleKeydown);
-		return () => {
-			document.removeEventListener("keydown", handleKeydown);
-		};
-	});
-	return {
-		addEventListener: (type, listener) => {
-			if (type === "keydown") keydownHandlers.push(listener);
-		},
-		removeEventListener: (type, listener) => {
-			if (type === "keydown") {
-				const index = keydownHandlers.indexOf(listener);
-				if (index !== -1) keydownHandlers.splice(index, 1);
-			}
-		}
-	};
+function registerTableHandleDropIndicatorElement() {
+	registerCustomElement("prosekit-table-handle-drop-indicator", TableHandleDropIndicatorElement);
 }
 //#endregion
-//#region src/components/table-handle/table-handle-popover-content/types.ts
-/** @internal */
-const tableHandlePopoverContentProps = Object.freeze({
-	...menuContentProps,
-	placement: { default: "right-start" },
-	offset: { default: {
-		mainAxis: -4,
-		crossAxis: 4
-	} },
-	editor: { default: null }
-});
-/** @internal */
-const tableHandlePopoverContentEvents = Object.freeze({ ...menuContentEvents });
-//#endregion
-//#region src/components/table-handle/table-handle-popover-content/element.gen.ts
-const TableHandlePopoverContentElementBase = defineCustomElement({
-	props: tableHandlePopoverContentProps,
-	events: tableHandlePopoverContentEvents,
-	setup: useTableHandlePopoverContent
-});
-var TableHandlePopoverContentElement = class extends TableHandlePopoverContentElementBase {};
-registerCustomElement("prosekit-table-handle-popover-content", TableHandlePopoverContentElement);
-//#endregion
-//#region src/components/table-handle/table-handle-popover-item/setup.ts
-/**
-* @internal
-*/
-function useTableHandlePopoverItem(element, { state, emit }) {
-	useMenuItem(element, {
-		state,
-		emit
-	});
-}
-//#endregion
-//#region src/components/table-handle/table-handle-popover-item/types.ts
-/** @internal */
-const tableHandlePopoverItemProps = { ...menuItemProps };
-/** @internal */
-const tableHandlePopoverItemEvents = { ...menuItemEvents };
-//#endregion
-//#region src/components/table-handle/table-handle-popover-item/element.gen.ts
-const TableHandlePopoverItemElementBase = defineCustomElement({
-	props: tableHandlePopoverItemProps,
-	events: tableHandlePopoverItemEvents,
-	setup: useTableHandlePopoverItem
-});
-var TableHandlePopoverItemElement = class extends TableHandlePopoverItemElementBase {};
-registerCustomElement("prosekit-table-handle-popover-item", TableHandlePopoverItemElement);
-//#endregion
 //#region src/hooks/use-editor-typing.ts
-function useEditorTyping(host, editor) {
+function useEditorTyping(host, getEditor) {
 	const typing = createSignal(false);
-	const handleKeypress = () => {
+	useEditorExtension(host, getEditor, union(defineDOMEventHandler("keypress", () => {
 		typing.set(true);
-	};
-	const handlePointerMove = () => {
+	}), defineDOMEventHandler("pointermove", () => {
 		typing.set(false);
-	};
-	useEditorExtension(host, editor, union(defineDOMEventHandler("keypress", handleKeypress), defineDOMEventHandler("pointermove", handlePointerMove)));
-	return typing;
+	})));
+	return typing.get;
 }
 //#endregion
 //#region src/hooks/use-selecting.ts
@@ -754,12 +742,12 @@ function useEditorTyping(host, editor) {
 * Detect if the user is selecting text inside the editor, in which case some
 * components should be disabled or hidden.
 */
-function useSelecting(host, editor, enabled) {
+function useSelecting(host, getEditor, getEnabled) {
 	const selecting = createSignal(false);
 	const isPointerDown = createSignal(false);
 	useEffect(host, () => {
-		if (!enabled.get()) return;
-		const view = getSafeEditorView(editor.peek());
+		if (!getEnabled()) return;
+		const view = getSafeEditorView(getEditor());
 		if (!view) return;
 		const { dom, root } = view;
 		if (!root) return;
@@ -782,22 +770,26 @@ function useSelecting(host, editor, enabled) {
 			root.removeEventListener("pointermove", handleMouseMove);
 		};
 	});
-	return selecting;
+	return selecting.get;
 }
 //#endregion
-//#region src/components/table-handle/hooks/use-drop.ts
-function useDrop(host, editor, dndContext) {
-	const dragging = createComputed(() => dndContext.get().dragging);
+//#region src/components/table-handle/use-drop.ts
+function useDrop(host, getEditor, store) {
+	const getDndStore = () => store.dndStore;
+	const getDragging = computed(() => getDndStore().dragging.get());
 	useEffect(host, () => {
-		const view = getSafeEditorView(editor.get());
+		const view = getSafeEditorView(getEditor());
 		if (!view || !view.editable) return;
 		const ownerDocument = view.dom?.ownerDocument;
 		if (!ownerDocument) return;
 		const handleDrop = () => {
-			if (!dragging.peek()) return;
-			const editorValue = editor.peek();
-			if (!editorValue) return;
-			const { droppingIndex, draggingIndex, direction } = dndContext.peek();
+			if (!getDragging()) return;
+			const editor = getEditor();
+			if (!editor) return;
+			const dndStore = getDndStore();
+			const droppingIndex = dndStore.droppingIndex.get();
+			const draggingIndex = dndStore.draggingIndex.get();
+			const direction = dndStore.direction.get();
 			if (draggingIndex < 0 || droppingIndex < 0) {
 				console.warn("[prosekit] Invalid drag indices:", {
 					draggingIndex,
@@ -806,14 +798,14 @@ function useDrop(host, editor, dndContext) {
 				return;
 			}
 			if (direction === "row") {
-				editorValue.exec(moveTableRow({
+				editor.exec(moveTableRow({
 					from: draggingIndex,
 					to: droppingIndex
 				}));
 				return;
 			}
 			if (direction === "col") {
-				editorValue.exec(moveTableColumn({
+				editor.exec(moveTableColumn({
 					from: draggingIndex,
 					to: droppingIndex
 				}));
@@ -821,23 +813,16 @@ function useDrop(host, editor, dndContext) {
 			}
 		};
 		const handleDragOver = (event) => {
-			if (!dragging.peek()) return;
+			if (!getDragging()) return;
 			event.preventDefault();
-			const prev = dndContext.peek();
-			dndContext.set({
-				...prev,
-				dragging: true,
-				x: event.clientX,
-				y: event.clientY
-			});
+			const dndStore = getDndStore();
+			dndStore.dragging.set(true);
+			dndStore.x.set(event.clientX);
+			dndStore.y.set(event.clientY);
 		};
 		const handleDragEnd = () => {
-			if (!dragging.peek()) return;
-			const prev = dndContext.peek();
-			dndContext.set({
-				...prev,
-				dragging: false
-			});
+			if (!getDragging()) return;
+			getDndStore().dragging.set(false);
 		};
 		ownerDocument.addEventListener("dragover", handleDragOver);
 		ownerDocument.addEventListener("drop", handleDrop);
@@ -897,126 +882,145 @@ function getCellIndex(map, rowIndex, colIndex) {
 	return map.width * rowIndex + colIndex;
 }
 //#endregion
-//#region src/components/table-handle/table-handle-root/setup.ts
+//#region src/components/table-handle/table-handle-root.ts
+/** @internal */
+const TableHandleRootPropsDeclaration = defineProps({ editor: {
+	default: null,
+	attribute: false,
+	type: "json"
+} });
 /**
 * @internal
 */
-function useTableHandleRoot(host, { state }) {
-	const { editor } = state;
-	const context = createSignal(null);
-	const dndContext = createSignal(defaultTableHandleDndContext);
-	const hoveringCell = useHoveringCell(host, editor);
-	const typing = useEditorTyping(host, editor);
-	const selecting = useSelecting(host, editor, createComputed(() => !!hoveringCell.get()));
-	const scrolling = useScrolling(host);
-	const canShow = createComputed(() => {
-		return !typing.get() && !selecting.get() && !scrolling.get();
-	});
-	useEffect(host, () => {
-		context.set(canShow.get() ? hoveringCell.get() : null);
-	});
-	tableHandleRootContext.provide(host, context);
-	tableHandleDndContext.provide(host, dndContext);
-	useDrop(host, editor, dndContext);
+function setupTableHandleRoot(host, props) {
+	const getEditor = props.editor.get;
+	const getHoveringCellInfo = useHoveringCell(host, getEditor);
+	const getTyping = useEditorTyping(host, getEditor);
+	const getSelecting = useSelecting(host, getEditor, computed(() => !!getHoveringCellInfo()));
+	const getScrolling = useScrolling(host);
+	const store = createTableHandleStore(getHoveringCellInfo, computed(() => !getTyping() && !getSelecting() && !getScrolling()));
+	tableHandleStoreContext.provide(host, store);
+	useDrop(host, getEditor, store);
 }
-function useHoveringCell(host, editor) {
-	const hoveringCell = createSignal(null);
-	useEditorExtension(host, editor, defineCellHoverHandler((curr) => {
-		if (!isHoveringCellInfoEqual(hoveringCell.peek(), curr)) hoveringCell.set(curr);
+function useHoveringCell(host, getEditor) {
+	const hoveringCell = createSignal(void 0);
+	useEditorExtension(host, getEditor, defineCellHoverHandler((curr) => {
+		if (isHoveringCellInfoEqual(hoveringCell.get(), curr)) return;
+		hoveringCell.set(curr);
 	}));
-	return hoveringCell;
+	return hoveringCell.get;
 }
 function defineCellHoverHandler(handler) {
 	const pointerHandler = (view, event) => {
-		return handler(getHoveringCell(view, event) ?? null);
+		return handler(getHoveringCell(view, event));
 	};
 	return defineDOMEventHandler("pointerover", pointerHandler);
 }
-//#endregion
-//#region src/components/table-handle/table-handle-root/types.ts
-/** @internal */
-const tableHandleRootProps = { editor: { default: null } };
-/** @internal */
-const tableHandleRootEvents = {};
-//#endregion
-//#region src/components/table-handle/table-handle-root/element.gen.ts
-const TableHandleRootElementBase = defineCustomElement({
-	props: tableHandleRootProps,
-	events: tableHandleRootEvents,
-	setup: useTableHandleRoot
-});
+const TableHandleRootElementBase = defineCustomElement(setupTableHandleRoot, TableHandleRootPropsDeclaration);
+/**
+* @public
+*/
 var TableHandleRootElement = class extends TableHandleRootElementBase {};
-registerCustomElement("prosekit-table-handle-root", TableHandleRootElement);
-//#endregion
-//#region src/components/table-handle/table-handle-row-root/setup.ts
 /**
 * @internal
 */
-function useTableHandleRowRoot(host, { state }) {
-	const { editor, ...overlayState } = state;
-	const rootContext = tableHandleRootContext.consume(host);
-	const rowFirstCellPos = createComputed(() => {
-		return rootContext.get()?.rowFirstCellPos;
-	});
-	const referenceCell = createComputed(() => {
-		const pos = rowFirstCellPos.get();
-		const view = getSafeEditorView(editor.get());
-		if (!pos || !view) return null;
-		return view.nodeDOM(pos);
-	});
-	const contentOpen = createSignal(false);
-	useEffect(host, () => {
-		rowFirstCellPos.get();
-		contentOpen.set(false);
-	});
-	useOverlayPositionerState(host, overlayState, { reference: referenceCell });
-	const presence = createComputed(() => !!referenceCell.get());
-	useAttribute(host, "data-state", () => presence.get() ? "open" : "closed");
-	usePresence(host, presence);
-	useMenuRoot(host, {
-		state: getStateWithDefaults({ open: contentOpen }, menuRootProps),
-		emit: defineEmit(host, menuRootEvents)
-	});
+function registerTableHandleRootElement() {
+	registerCustomElement("prosekit-table-handle-root", TableHandleRootElement);
 }
 //#endregion
-//#region src/components/table-handle/table-handle-row-root/types.ts
+//#region src/components/table-handle/table-handle-row-popup.ts
 /** @internal */
-const tableHandleRowRootProps = {
-	...overlayPositionerProps$1,
-	editor: { default: null },
-	placement: { default: "left" },
-	hoist: { default: false },
-	flip: { default: false },
-	shift: { default: false },
-	hide: { default: true }
-};
+const TableHandleRowPopupPropsDeclaration = defineProps({});
+/** @internal */
+function setupTableHandleRowPopup(host, _props) {
+	const getStore = tableHandleStoreContext.consume(host);
+	const getOverlayStore = () => getStore()?.rowOverlayStore;
+	setupOverlayPopup(host, getOverlayStore);
+}
+const TableHandleRowPopupElementBase = defineCustomElement(setupTableHandleRowPopup, TableHandleRowPopupPropsDeclaration);
+/**
+* @public
+*/
+var TableHandleRowPopupElement = class extends TableHandleRowPopupElementBase {};
 /** @internal */
-const tableHandleRowRootEvents = {};
+function registerTableHandleRowPopupElement() {
+	registerCustomElement("prosekit-table-handle-row-popup", TableHandleRowPopupElement);
+}
 //#endregion
-//#region src/components/table-handle/table-handle-row-root/element.gen.ts
-const TableHandleRowRootElementBase = defineCustomElement({
-	props: tableHandleRowRootProps,
-	events: tableHandleRowRootEvents,
-	setup: useTableHandleRowRoot
+//#region src/components/table-handle/table-handle-row-positioner.ts
+/** @internal */
+const TableHandleRowPositionerPropsDeclaration = defineProps({
+	...SharedTableHandlePositionerPropsDeclaration,
+	placement: {
+		default: "left",
+		attribute: "placement",
+		type: "string"
+	}
 });
-var TableHandleRowRootElement = class extends TableHandleRowRootElementBase {};
-registerCustomElement("prosekit-table-handle-row-root", TableHandleRowRootElement);
+/** @internal */
+function setupTableHandleRowPositioner(host, props) {
+	const getStore = tableHandleStoreContext.consume(host);
+	const getOverlayStore = () => getStore()?.rowOverlayStore;
+	setupOverlayPositioner(host, props, getOverlayStore);
+	const getEditor = props.editor.get;
+	const getReferenceCell = useHTMLElementAt(getEditor, computed(() => getStore()?.getReferenceCell()?.rowFirstCellPos));
+	useEffect(host, () => {
+		getOverlayStore()?.setAnchorElement(getReferenceCell());
+	});
+}
+const TableHandleRowPositionerElementBase = defineCustomElement(setupTableHandleRowPositioner, TableHandleRowPositionerPropsDeclaration);
+/**
+* @public
+*/
+var TableHandleRowPositionerElement = class extends TableHandleRowPositionerElementBase {};
+/** @internal */
+function registerTableHandleRowPositionerElement() {
+	registerCustomElement("prosekit-table-handle-row-positioner", TableHandleRowPositionerElement);
+}
 //#endregion
-//#region src/components/table-handle/table-handle-row-trigger/setup.ts
+//#region src/components/table-handle/table-handle-row-menu-root.ts
+/** @internal */
+const TableHandleRowMenuRootPropsDeclaration = defineProps(MenuRootPropsDeclaration);
+/** @internal */
+function setupTableHandleRowMenuRoot(host, props) {
+	setupMenuRoot(host, props);
+	const getStore = tableHandleStoreContext.consume(host);
+	useEffect(host, () => {
+		const open = props.open.get() || false;
+		const store = getStore?.();
+		if (!store) return;
+		store.setIsRowMenuOpen(open);
+	});
+}
+const TableHandleRowMenuRootElementBase = defineCustomElement(setupTableHandleRowMenuRoot, TableHandleRowMenuRootPropsDeclaration);
 /**
-* @internal
+* @public
 */
-function useTableHandleRowTrigger(host, { state }) {
-	useMenuTrigger(host);
-	const context = tableHandleRootContext.consume(host);
-	const dndContext = tableHandleDndContext.consume(host);
+var TableHandleRowMenuRootElement = class extends TableHandleRowMenuRootElementBase {};
+/** @internal */
+function registerTableHandleRowMenuRootElement() {
+	registerCustomElement("prosekit-table-handle-row-menu-root", TableHandleRowMenuRootElement);
+}
+//#endregion
+//#region src/components/table-handle/table-handle-row-menu-trigger.ts
+/** @internal */
+const TableHandleRowMenuTriggerPropsDeclaration = defineProps({ editor: {
+	default: null,
+	attribute: false,
+	type: "json"
+} });
+/** @internal */
+function setupTableHandleRowMenuTrigger(host, props) {
+	const getEditor = props.editor.get;
+	const getStore = tableHandleStoreContext.consume(host);
+	setupMenuTrigger(host, { disabled: createSignal(false) });
 	useEventListener(host, "pointerdown", () => {
-		const editor = state.editor.peek();
-		const cellPos = context.peek()?.cellPos;
+		const editor = getEditor();
+		const cellPos = getStore()?.getReferenceCell()?.cellPos;
 		if (!editor || !cellPos) return;
 		editor.exec(selectTableRow({ head: cellPos }));
 	});
-	useEffect(host, () => {
+	onMount(host, () => {
 		host.draggable = true;
 	});
 	const getEmptyImage = useEmptyImage(host);
@@ -1027,39 +1031,34 @@ function useTableHandleRowTrigger(host, { state }) {
 			const emptyImage = getEmptyImage();
 			if (emptyImage) dataTransfer.setDragImage(emptyImage, 0, 0);
 		}
-		const prev = dndContext.peek();
-		const index = context.peek()?.rowIndex;
+		const store = getStore();
+		if (!store) return;
+		const index = store.getReferenceCell()?.rowIndex;
 		if (index == null || index < 0) {
 			console.warn("[prosekit] Invalid row index for drag operation:", index);
 			event.preventDefault();
 			return;
 		}
-		dndContext.set({
-			...prev,
-			direction: "row",
-			dragging: true,
-			draggingIndex: index,
-			startX: event.clientX,
-			startY: event.clientY
-		});
+		const dndStore = store.dndStore;
+		dndStore.direction.set("row");
+		dndStore.dragging.set(true);
+		dndStore.draggingIndex.set(index);
+		dndStore.startX.set(event.clientX);
+		dndStore.startY.set(event.clientY);
 	});
 }
+const TableHandleRowMenuTriggerElementBase = defineCustomElement(setupTableHandleRowMenuTrigger, TableHandleRowMenuTriggerPropsDeclaration);
+/**
+* @public
+*/
+var TableHandleRowMenuTriggerElement = class extends TableHandleRowMenuTriggerElementBase {};
+/**
+* @internal
+*/
+function registerTableHandleRowMenuTriggerElement() {
+	registerCustomElement("prosekit-table-handle-row-menu-trigger", TableHandleRowMenuTriggerElement);
+}
 //#endregion
-//#region src/components/table-handle/table-handle-row-trigger/types.ts
-/** @internal */
-const tableHandleRowTriggerProps = { editor: { default: null } };
-/** @internal */
-const tableHandleRowTriggerEvents = { select: {} };
-//#endregion
-//#region src/components/table-handle/table-handle-row-trigger/element.gen.ts
-const TableHandleRowTriggerElementBase = defineCustomElement({
-	props: tableHandleRowTriggerProps,
-	events: tableHandleRowTriggerEvents,
-	setup: useTableHandleRowTrigger
-});
-var TableHandleRowTriggerElement = class extends TableHandleRowTriggerElementBase {};
-registerCustomElement("prosekit-table-handle-row-trigger", TableHandleRowTriggerElement);
-//#endregion
-export { TableHandleColumnRootElement, TableHandleColumnTriggerElement, TableHandleDragPreviewElement, TableHandleDropIndicatorElement, TableHandlePopoverContentElement, TableHandlePopoverItemElement, TableHandleRootElement, TableHandleRowRootElement, TableHandleRowTriggerElement, tableHandleColumnRootEvents, tableHandleColumnRootProps, tableHandleColumnTriggerEvents, tableHandleColumnTriggerProps, tableHandleDragPreviewEvents, tableHandleDragPreviewProps, tableHandleDropIndicatorEvents, tableHandleDropIndicatorProps, tableHandlePopoverContentEvents, tableHandlePopoverContentProps, tableHandlePopoverItemEvents, tableHandlePopoverItemProps, tableHandleRootEvents, tableHandleRootProps, tableHandleRowRootEvents, tableHandleRowRootProps, tableHandleRowTriggerEvents, tableHandleRowTriggerProps, useTableHandleColumnRoot, useTableHandleColumnTrigger, useTableHandleDragPreview, useTableHandleDropIndicator, useTableHandlePopoverContent, useTableHandlePopoverItem, useTableHandleRoot, useTableHandleRowRoot, useTableHandleRowTrigger };
+export { TableHandleColumnMenuRootElement, TableHandleColumnMenuRootPropsDeclaration, TableHandleColumnMenuTriggerElement, TableHandleColumnMenuTriggerPropsDeclaration, TableHandleColumnPopupElement, TableHandleColumnPopupPropsDeclaration, TableHandleColumnPositionerElement, TableHandleColumnPositionerPropsDeclaration, TableHandleDragPreviewElement, TableHandleDragPreviewPropsDeclaration, TableHandleDropIndicatorElement, TableHandleDropIndicatorPropsDeclaration, TableHandleRootElement, TableHandleRootPropsDeclaration, TableHandleRowMenuRootElement, TableHandleRowMenuRootPropsDeclaration, TableHandleRowMenuTriggerElement, TableHandleRowMenuTriggerPropsDeclaration, TableHandleRowPopupElement, TableHandleRowPopupPropsDeclaration, TableHandleRowPositionerElement, TableHandleRowPositionerPropsDeclaration, registerTableHandleColumnMenuRootElement, registerTableHandleColumnMenuTriggerElement, registerTableHandleColumnPopupElement, registerTableHandleColumnPositionerElement, registerTableHandleDragPreviewElement, registerTableHandleDropIndicatorElement, registerTableHandleRootElement, registerTableHandleRowMenuRootElement, registerTableHandleRowMenuTriggerElement, registerTableHandleRowPopupElement, registerTableHandleRowPositionerElement, setupTableHandleColumnMenuRoot, setupTableHandleColumnMenuTrigger, setupTableHandleColumnPopup, setupTableHandleColumnPositioner, setupTableHandleDragPreview, setupTableHandleDropIndicator, setupTableHandleRoot, setupTableHandleRowMenuRoot, setupTableHandleRowMenuTrigger, setupTableHandleRowPopup, setupTableHandleRowPositioner };
 
 //# sourceMappingURL=prosekit-web-table-handle.js.map