@prosekit/web 0.3.11 → 0.3.13

package/dist/_tsup-dts-rollup.d.ts

@@ -7,14 +7,18 @@ import { defaultPopoverRootProps } from '@aria-ui/popover';
 import { defaultPopoverTriggerProps } from '@aria-ui/popover';
 import { defaultTooltipRootProps } from '@aria-ui/tooltip';
 import { defaultTooltipTriggerProps } from '@aria-ui/tooltip';
+import type { defineTableCommands } from '@prosekit/extensions/table';
 import { Editor } from '@prosekit/core';
 import type { EditorView } from '@prosekit/pm/view';
 import type { EmptyObject } from '@aria-ui/core';
 import { Extension } from '@prosekit/core';
 import { ExtensionTyping } from '@prosekit/core';
 import { FocusChangeHandler } from '@prosekit/core';
+import { ItemFilter } from '@aria-ui/collection';
 import { Keymap } from '@prosekit/core';
 import { ListboxProps } from '@aria-ui/listbox';
+import { MenuContentProps } from '@aria-ui/menu';
+import { MenuItemProps } from '@aria-ui/menu';
 import { Options } from 'tsup';
 import { OverlayPositionerProps } from '@aria-ui/overlay';
 import type { Placement } from '@floating-ui/dom';
@@ -376,6 +380,117 @@ declare const defaultResizableRootProps: {
 export { defaultResizableRootProps }
 export { defaultResizableRootProps as defaultResizableRootProps_alias_1 }
 
+declare const defaultTableHandleColumnRootProps: Readonly<{
+    editor: null;
+    placement: "top";
+    strategy: "absolute";
+    autoUpdate: true;
+    hoist: false;
+    transform: false;
+    offset: null;
+    flip: false;
+    shift: false;
+    overlap: false;
+    fitViewport: false;
+    sameWidth: false;
+    sameHeight: false;
+    inline: false;
+    hide: false;
+    boundary: "clippingAncestors";
+    rootBoundary: "viewport";
+    overflowPadding: 0;
+    elementContext: "floating";
+    altBoundary: true;
+}>;
+export { defaultTableHandleColumnRootProps }
+export { defaultTableHandleColumnRootProps as defaultTableHandleColumnRootProps_alias_1 }
+
+declare const defaultTableHandleColumnTriggerProps: Readonly<{
+    editor: null;
+}>;
+export { defaultTableHandleColumnTriggerProps }
+export { defaultTableHandleColumnTriggerProps as defaultTableHandleColumnTriggerProps_alias_1 }
+
+declare const defaultTableHandlePopoverContentProps: Readonly<{
+    placement: "right-start";
+    offset: {
+        mainAxis: number;
+        crossAxis: number;
+    };
+    editor: null;
+    onKeydownHandlerAdd: null;
+    hoist: true;
+    flip: true;
+    shift: true;
+    overflowPadding: 4;
+    onEscapeKeyDown: null;
+    onPointerDownOutside: null;
+    onFocusOutside: null;
+    onInteractOutside: null;
+    strategy: "absolute";
+    autoUpdate: true;
+    transform: false;
+    overlap: false;
+    fitViewport: false;
+    sameWidth: false;
+    sameHeight: false;
+    inline: false;
+    hide: false;
+    boundary: "clippingAncestors";
+    rootBoundary: "viewport";
+    elementContext: "floating";
+    altBoundary: true;
+}>;
+export { defaultTableHandlePopoverContentProps }
+export { defaultTableHandlePopoverContentProps as defaultTableHandlePopoverContentProps_alias_1 }
+
+declare const defaultTableHandlePopoverItemProps: Readonly<{
+    disabled: false;
+    value: "";
+    query: "";
+    filter: ItemFilter;
+    onSelect: null;
+}>;
+export { defaultTableHandlePopoverItemProps }
+export { defaultTableHandlePopoverItemProps as defaultTableHandlePopoverItemProps_alias_1 }
+
+declare const defaultTableHandleRootProps: Readonly<{
+    editor: null;
+}>;
+export { defaultTableHandleRootProps }
+export { defaultTableHandleRootProps as defaultTableHandleRootProps_alias_1 }
+
+declare const defaultTableHandleRowRootProps: Readonly<{
+    editor: null;
+    placement: "left";
+    strategy: "absolute";
+    autoUpdate: true;
+    hoist: false;
+    transform: false;
+    offset: null;
+    flip: false;
+    shift: false;
+    overlap: false;
+    fitViewport: false;
+    sameWidth: false;
+    sameHeight: false;
+    inline: false;
+    hide: false;
+    boundary: "clippingAncestors";
+    rootBoundary: "viewport";
+    overflowPadding: 0;
+    elementContext: "floating";
+    altBoundary: true;
+}>;
+export { defaultTableHandleRowRootProps }
+export { defaultTableHandleRowRootProps as defaultTableHandleRowRootProps_alias_1 }
+
+declare const defaultTableHandleRowTriggerProps: Readonly<{
+    editor: null;
+}>;
+export { defaultTableHandleRowTriggerProps }
+export { defaultTableHandleRowTriggerProps as defaultTableHandleRowTriggerProps_alias_1 }
+
 declare const defaultTooltipContentProps: {
     shift: true;
     flip: true;
@@ -406,14 +521,26 @@ export { defaultTooltipRootProps as defaultTooltipRootProps_alias_1 }
 export { defaultTooltipTriggerProps }
 export { defaultTooltipTriggerProps as defaultTooltipTriggerProps_alias_1 }
 
+export declare function defineCellHoverHandler(handler: (hoveringCell: HoveringCellInfo | null) => void): Extension<ExtensionTyping<any, any, any>>;
+
 export declare function defineCustomElement(name: string, constructor: CustomElementConstructor, options?: ElementDefinitionOptions): void;
 
 export declare function defineElementHoverHandler(handler: ElementHoverHandler): Union<readonly [Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>]>;
 
 export declare type ElementHoverHandler = (reference: VirtualElement | null, element: HTMLElement | null, node: ProseMirrorNode | null, pos: number | null) => void;
 
+export declare function getHoveringCell(view: EditorView, event: MouseEvent): HoveringCellInfo | undefined;
+
 export declare function getVirtualSelectionElement(view: EditorView): ReferenceElement | undefined;
 
+export declare interface HoveringCellInfo {
+    rowIndex: number;
+    colIndex: number;
+    cellPos: number;
+    rowFirstCellPos: number;
+    colFirstCellPos: number;
+}
+
 declare class InlinePopoverElement extends InlinePopoverElement_base {
 }
 export { InlinePopoverElement }
@@ -501,6 +628,8 @@ export { InlinePopoverProps as InlinePopoverProps_alias_1 }
 
 export declare function isFinitePositiveNumber(value: unknown): value is number;
 
+export declare function isHoveringCellInfoEqual(a?: HoveringCellInfo | null, b?: HoveringCellInfo | null): boolean;
+
 /**
  * @internal
  */
@@ -627,6 +756,167 @@ declare interface ResizableRootProps {
 export { ResizableRootProps }
 export { ResizableRootProps as ResizableRootProps_alias_1 }
 
+declare type TableCommandsExtension = ReturnType<typeof defineTableCommands>;
+
+declare type TableCommandsExtension_2 = ReturnType<typeof defineTableCommands>;
+
+declare class TableHandleColumnRootElement extends TableHandleColumnRootElement_base {
+}
+export { TableHandleColumnRootElement }
+export { TableHandleColumnRootElement as TableHandleColumnRootElement_alias_1 }
+
+declare const TableHandleColumnRootElement_base: {
+    new (): BaseElement & TableHandleColumnRootProps;
+    prototype: HTMLElement;
+};
+
+declare interface TableHandleColumnRootProps extends Omit<OverlayPositionerProps, 'placement'> {
+    /**
+     * The ProseKit editor instance.
+     *
+     * @default null
+     */
+    editor: Editor | null;
+    /**
+     * The placement of the popover, relative to the hovered table cell.
+     *
+     * @default "top"
+     */
+    placement: Placement;
+}
+export { TableHandleColumnRootProps }
+export { TableHandleColumnRootProps as TableHandleColumnRootProps_alias_1 }
+
+declare class TableHandleColumnTriggerElement extends TableHandleColumnTriggerElement_base {
+}
+export { TableHandleColumnTriggerElement }
+export { TableHandleColumnTriggerElement as TableHandleColumnTriggerElement_alias_1 }
+
+declare const TableHandleColumnTriggerElement_base: {
+    new (): BaseElement & TableHandleColumnTriggerProps;
+    prototype: HTMLElement;
+};
+
+declare interface TableHandleColumnTriggerProps {
+    editor: Editor<TableCommandsExtension> | null;
+}
+export { TableHandleColumnTriggerProps }
+export { TableHandleColumnTriggerProps as TableHandleColumnTriggerProps_alias_1 }
+
+declare class TableHandlePopoverContentElement extends TableHandlePopoverContentElement_base {
+}
+export { TableHandlePopoverContentElement }
+export { TableHandlePopoverContentElement as TableHandlePopoverContentElement_alias_1 }
+
+declare const TableHandlePopoverContentElement_base: {
+    new (): BaseElement & TableHandlePopoverContentProps;
+    prototype: HTMLElement;
+};
+
+declare interface TableHandlePopoverContentProps extends Omit<MenuContentProps, 'placement' | 'offset'> {
+    /**
+     * @default 'bottom-start'
+     */
+    placement: MenuContentProps['placement'];
+    /**
+     * @default {mainAxis: -4, crossAxis: 4}
+     */
+    offset: MenuContentProps['offset'];
+    editor: Editor | null;
+}
+export { TableHandlePopoverContentProps }
+export { TableHandlePopoverContentProps as TableHandlePopoverContentProps_alias_1 }
+
+declare class TableHandlePopoverItemElement extends TableHandlePopoverItemElement_base {
+}
+export { TableHandlePopoverItemElement }
+export { TableHandlePopoverItemElement as TableHandlePopoverItemElement_alias_1 }
+
+declare const TableHandlePopoverItemElement_base: {
+    new (): BaseElement & TableHandlePopoverItemProps;
+    prototype: HTMLElement;
+};
+
+declare interface TableHandlePopoverItemProps extends MenuItemProps {
+    disabled?: boolean;
+}
+export { TableHandlePopoverItemProps }
+export { TableHandlePopoverItemProps as TableHandlePopoverItemProps_alias_1 }
+
+/**
+ * @internal
+ */
+export declare type TableHandleRootContext = HoveringCellInfo | null;
+
+/**
+ * @internal
+ */
+export declare const tableHandleRootContext: Context<TableHandleRootContext>;
+
+declare class TableHandleRootElement extends TableHandleRootElement_base {
+}
+export { TableHandleRootElement }
+export { TableHandleRootElement as TableHandleRootElement_alias_1 }
+
+declare const TableHandleRootElement_base: {
+    new (): BaseElement & TableHandleRootProps;
+    prototype: HTMLElement;
+};
+
+declare interface TableHandleRootProps {
+    /**
+     * The ProseKit editor instance.
+     *
+     * @default null
+     */
+    editor: Editor | null;
+}
+export { TableHandleRootProps }
+export { TableHandleRootProps as TableHandleRootProps_alias_1 }
+
+declare class TableHandleRowRootElement extends TableHandleRowRootElement_base {
+}
+export { TableHandleRowRootElement }
+export { TableHandleRowRootElement as TableHandleRowRootElement_alias_1 }
+
+declare const TableHandleRowRootElement_base: {
+    new (): BaseElement & TableHandleRowRootProps;
+    prototype: HTMLElement;
+};
+
+declare interface TableHandleRowRootProps extends Omit<OverlayPositionerProps, 'placement'> {
+    /**
+     * The ProseKit editor instance.
+     *
+     * @default null
+     */
+    editor: Editor | null;
+    /**
+     * The placement of the popover, relative to the hovered table cell.
+     *
+     * @default "left"
+     */
+    placement: Placement;
+}
+export { TableHandleRowRootProps }
+export { TableHandleRowRootProps as TableHandleRowRootProps_alias_1 }
+
+declare class TableHandleRowTriggerElement extends TableHandleRowTriggerElement_base {
+}
+export { TableHandleRowTriggerElement }
+export { TableHandleRowTriggerElement as TableHandleRowTriggerElement_alias_1 }
+
+declare const TableHandleRowTriggerElement_base: {
+    new (): BaseElement & TableHandleRowTriggerProps;
+    prototype: HTMLElement;
+};
+
+declare interface TableHandleRowTriggerProps {
+    editor: Editor<TableCommandsExtension_2> | null;
+}
+export { TableHandleRowTriggerProps }
+export { TableHandleRowTriggerProps as TableHandleRowTriggerProps_alias_1 }
+
 /**
  * @internal
  */
@@ -690,6 +980,8 @@ export declare function useEditorExtension(host: ConnectableElement, editor: Rea
  */
 export declare function useEditorFocusChangeEvent(host: ConnectableElement, editor: ReadonlySignal<Editor | null>, handler: FocusChangeHandler): void;
 
+export declare function useEditorTyping(host: ConnectableElement, editor: ReadonlySignal<Editor | null>): ReadonlySignal<boolean>;
+
 /**
  * @internal
  */
@@ -711,6 +1003,20 @@ export declare function useResizableHandle(host: ConnectableElement, state: Sign
 
 export declare function useResizableRoot(host: ConnectableElement, state: SignalState<ResizableRootProps>): void;
 
+export declare function useTableHandleColumnRoot(host: ConnectableElement, state: SignalState<TableHandleColumnRootProps>): void;
+
+export declare function useTableHandleColumnTrigger(host: ConnectableElement, state: SignalState<TableHandleColumnTriggerProps>): void;
+
+export declare function useTableHandlePopoverContent(host: ConnectableElement, state: SignalState<TableHandlePopoverContentProps>): void;
+
+export declare function useTableHandlePopoverItem(element: ConnectableElement, state: SignalState<TableHandlePopoverItemProps>): void;
+
+export declare function useTableHandleRoot(host: ConnectableElement, state: SignalState<TableHandleRootProps>): void;
+
+export declare function useTableHandleRowRoot(host: ConnectableElement, state: SignalState<TableHandleRowRootProps>): void;
+
+export declare function useTableHandleRowTrigger(host: ConnectableElement, state: SignalState<TableHandleRowTriggerProps>): void;
+
 export { useTooltipContent }
 
 export { useTooltipRoot }

package/dist/prosekit-web-table-handle.d.ts

@@ -0,0 +1,21 @@
+export { TableHandleColumnRootElement } from './_tsup-dts-rollup';
+export { defaultTableHandleColumnRootProps } from './_tsup-dts-rollup';
+export { TableHandleColumnRootProps } from './_tsup-dts-rollup';
+export { TableHandleColumnTriggerElement } from './_tsup-dts-rollup';
+export { defaultTableHandleColumnTriggerProps } from './_tsup-dts-rollup';
+export { TableHandleColumnTriggerProps } from './_tsup-dts-rollup';
+export { TableHandlePopoverContentElement } from './_tsup-dts-rollup';
+export { defaultTableHandlePopoverContentProps } from './_tsup-dts-rollup';
+export { TableHandlePopoverContentProps } from './_tsup-dts-rollup';
+export { TableHandlePopoverItemElement } from './_tsup-dts-rollup';
+export { defaultTableHandlePopoverItemProps } from './_tsup-dts-rollup';
+export { TableHandlePopoverItemProps } from './_tsup-dts-rollup';
+export { TableHandleRootElement } from './_tsup-dts-rollup';
+export { defaultTableHandleRootProps } from './_tsup-dts-rollup';
+export { TableHandleRootProps } from './_tsup-dts-rollup';
+export { TableHandleRowRootElement } from './_tsup-dts-rollup';
+export { defaultTableHandleRowRootProps } from './_tsup-dts-rollup';
+export { TableHandleRowRootProps } from './_tsup-dts-rollup';
+export { TableHandleRowTriggerElement } from './_tsup-dts-rollup';
+export { defaultTableHandleRowTriggerProps } from './_tsup-dts-rollup';
+export { TableHandleRowTriggerProps } from './_tsup-dts-rollup';

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

@@ -0,0 +1,440 @@
+import {
+  useEditorExtension
+} from "./chunk-MZSYOTZT.js";
+import {
+  defineCustomElement
+} from "./chunk-LCDA7GFP.js";
+
+// src/components/table-handle/table-handle-column-root/element.gen.ts
+import { ElementBuilder } from "@aria-ui/core";
+
+// src/components/table-handle/table-handle-column-root/props.ts
+import {
+  defaultOverlayPositionerProps
+} from "@aria-ui/overlay";
+var defaultTableHandleColumnRootProps = Object.freeze({
+  ...defaultOverlayPositionerProps,
+  editor: null,
+  placement: "top"
+});
+
+// src/components/table-handle/table-handle-column-root/state.ts
+import {
+  createComputed,
+  createSignal,
+  mapSignals,
+  useAttribute,
+  useEffect
+} from "@aria-ui/core";
+import { defaultMenuRootProps, useMenuRoot } from "@aria-ui/menu";
+import { useOverlayPositionerState } from "@aria-ui/overlay";
+import { usePresence } from "@aria-ui/presence";
+
+// src/components/table-handle/context.ts
+import { createContext } from "@aria-ui/core";
+var tableHandleRootContext = createContext(
+  "prosekit-table-handle-root-context",
+  null
+);
+
+// src/components/table-handle/table-handle-column-root/state.ts
+function useTableHandleColumnRoot(host, state) {
+  const { editor, ...overlayState } = state;
+  const rootContext = tableHandleRootContext.consume(host);
+  const colFirstCellPos = createComputed(() => {
+    var _a;
+    return (_a = rootContext.get()) == null ? void 0 : _a.colFirstCellPos;
+  });
+  const referenceCell = createComputed(() => {
+    var _a;
+    const pos = colFirstCellPos.get();
+    const view = (_a = editor.get()) == null ? void 0 : _a.view;
+    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, {
+    ...mapSignals(defaultMenuRootProps),
+    open: contentOpen
+  });
+}
+
+// src/components/table-handle/table-handle-column-root/element.gen.ts
+var TableHandleColumnRootElement = class extends ElementBuilder(useTableHandleColumnRoot, defaultTableHandleColumnRootProps) {
+};
+defineCustomElement("prosekit-table-handle-column-root", TableHandleColumnRootElement);
+
+// src/components/table-handle/table-handle-column-trigger/element.gen.ts
+import { ElementBuilder as ElementBuilder2 } from "@aria-ui/core";
+
+// src/components/table-handle/table-handle-column-trigger/props.ts
+var defaultTableHandleColumnTriggerProps = Object.freeze({
+  editor: null
+});
+
+// src/components/table-handle/table-handle-column-trigger/state.ts
+import {
+  useEventListener
+} from "@aria-ui/core";
+import { useMenuTrigger } from "@aria-ui/menu";
+import { selectTableColumn } from "@prosekit/extensions/table";
+function useTableHandleColumnTrigger(host, state) {
+  useMenuTrigger(host);
+  const context = tableHandleRootContext.consume(host);
+  useEventListener(host, "pointerdown", () => {
+    var _a;
+    const editor = state.editor.peek();
+    const cellPos = (_a = context.peek()) == null ? void 0 : _a.cellPos;
+    if (!editor || !cellPos) return;
+    editor.exec(selectTableColumn({ head: cellPos }));
+  });
+}
+
+// src/components/table-handle/table-handle-column-trigger/element.gen.ts
+var TableHandleColumnTriggerElement = class extends ElementBuilder2(useTableHandleColumnTrigger, defaultTableHandleColumnTriggerProps) {
+};
+defineCustomElement("prosekit-table-handle-column-trigger", TableHandleColumnTriggerElement);
+
+// src/components/table-handle/table-handle-popover-content/element.gen.ts
+import { ElementBuilder as ElementBuilder3 } from "@aria-ui/core";
+
+// src/components/table-handle/table-handle-popover-content/props.ts
+import { defaultMenuContentProps } from "@aria-ui/menu";
+var defaultTableHandlePopoverContentProps = Object.freeze({
+  ...defaultMenuContentProps,
+  placement: "right-start",
+  offset: { mainAxis: -4, crossAxis: 4 },
+  editor: null
+});
+
+// src/components/table-handle/table-handle-popover-content/state.ts
+import {
+  createComputed as createComputed2,
+  createSignal as createSignal2,
+  mapSignals as mapSignals2,
+  useEffect as useEffect2
+} from "@aria-ui/core";
+import {
+  defaultMenuContentProps as defaultMenuContentProps2,
+  useMenuContent
+} from "@aria-ui/menu";
+function useTableHandlePopoverContent(host, state) {
+  const rootContext = tableHandleRootContext.consume(host);
+  const open = createComputed2(() => !!rootContext.get());
+  const onKeydownHandlerAdd = useKeyboardHandler(host, open);
+  const menuContentProps = {
+    ...mapSignals2({
+      ...defaultMenuContentProps2,
+      onKeydownHandlerAdd
+    }),
+    placement: state.placement,
+    offset: state.offset
+  };
+  useMenuContent(host, menuContentProps);
+}
+function useKeyboardHandler(element, open) {
+  const keydownHandler = createSignal2(
+    null
+  );
+  let disposeKeydownHandler;
+  useEffect2(element, () => {
+    const keydownHandlerValue = keydownHandler.get();
+    if (!keydownHandlerValue) {
+      return;
+    }
+    const handleKeydown = (event) => {
+      if (event.isComposing || event.defaultPrevented || !open.get()) {
+        return false;
+      }
+      keydownHandlerValue(event);
+    };
+    document.addEventListener("keydown", handleKeydown);
+    disposeKeydownHandler = () => {
+      document.removeEventListener("keydown", handleKeydown);
+    };
+  });
+  return (keydownHandlerValue) => {
+    keydownHandler.set(keydownHandlerValue);
+    return () => {
+      disposeKeydownHandler == null ? void 0 : disposeKeydownHandler();
+      disposeKeydownHandler = void 0;
+    };
+  };
+}
+
+// src/components/table-handle/table-handle-popover-content/element.gen.ts
+var TableHandlePopoverContentElement = class extends ElementBuilder3(useTableHandlePopoverContent, defaultTableHandlePopoverContentProps) {
+};
+defineCustomElement("prosekit-table-handle-popover-content", TableHandlePopoverContentElement);
+
+// src/components/table-handle/table-handle-popover-item/element.gen.ts
+import { ElementBuilder as ElementBuilder4 } from "@aria-ui/core";
+
+// src/components/table-handle/table-handle-popover-item/props.ts
+import { defaultMenuItemProps } from "@aria-ui/menu";
+var defaultTableHandlePopoverItemProps = Object.freeze({
+  ...defaultMenuItemProps,
+  disabled: false
+});
+
+// src/components/table-handle/table-handle-popover-item/state.ts
+import {
+  useAttribute as useAttribute2
+} from "@aria-ui/core";
+import { useMenuItem } from "@aria-ui/menu";
+function useTableHandlePopoverItem(element, state) {
+  useAttribute2(
+    element,
+    "data-disabled",
+    () => {
+      var _a;
+      return ((_a = state.disabled) == null ? void 0 : _a.get()) ? "true" : "false";
+    }
+  );
+  useMenuItem(element, state);
+}
+
+// src/components/table-handle/table-handle-popover-item/element.gen.ts
+var TableHandlePopoverItemElement = class extends ElementBuilder4(useTableHandlePopoverItem, defaultTableHandlePopoverItemProps) {
+};
+defineCustomElement("prosekit-table-handle-popover-item", TableHandlePopoverItemElement);
+
+// src/components/table-handle/table-handle-root/element.gen.ts
+import { ElementBuilder as ElementBuilder5 } from "@aria-ui/core";
+
+// src/components/table-handle/table-handle-root/props.ts
+var defaultTableHandleRootProps = Object.freeze({
+  editor: null
+});
+
+// src/components/table-handle/table-handle-root/state.ts
+import {
+  createSignal as createSignal4,
+  useEffect as useEffect3
+} from "@aria-ui/core";
+import { defineDOMEventHandler as defineDOMEventHandler2 } from "@prosekit/core";
+
+// src/hooks/use-editor-typing.ts
+import {
+  createSignal as createSignal3
+} from "@aria-ui/core";
+import { defineDOMEventHandler, union } from "@prosekit/core";
+function useEditorTyping(host, editor) {
+  const typing = createSignal3(false);
+  const handleKeypress = () => {
+    typing.set(true);
+  };
+  const handlePointerMove = () => {
+    typing.set(false);
+  };
+  const extension = union(
+    defineDOMEventHandler("keypress", handleKeypress),
+    defineDOMEventHandler("pointermove", handlePointerMove)
+  );
+  useEditorExtension(host, editor, extension);
+  return typing;
+}
+
+// src/components/table-handle/utils.ts
+import { cellAround, TableMap } from "prosemirror-tables";
+function isHoveringCellInfoEqual(a, b) {
+  if (!a && !b) return true;
+  if (!a || !b) return false;
+  return a.rowIndex === b.rowIndex && a.colIndex === b.colIndex && a.cellPos === b.cellPos && a.rowFirstCellPos === b.rowFirstCellPos && a.colFirstCellPos === b.colFirstCellPos;
+}
+function domCellAround(target) {
+  var _a;
+  while (target && target.nodeName != "TD" && target.nodeName != "TH") {
+    target = ((_a = target.classList) == null ? void 0 : _a.contains("ProseMirror")) ? null : target.parentNode;
+  }
+  return target;
+}
+function getHoveringCell(view, event) {
+  const domCell = domCellAround(event.target);
+  if (!domCell) return;
+  const { left, top, width, height } = domCell.getBoundingClientRect();
+  const eventPos = view.posAtCoords({
+    // Use the center coordinates of the cell to ensure we're within the
+    // selected cell. This prevents potential issues when the mouse is on the
+    // border of two cells.
+    left: left + width / 2,
+    top: top + height / 2
+  });
+  if (!eventPos) return;
+  const $cellPos = cellAround(view.state.doc.resolve(eventPos.pos));
+  if (!$cellPos) return;
+  const map = TableMap.get($cellPos.node(-1));
+  const tableStart = $cellPos.start(-1);
+  const cellRect = map.findCell($cellPos.pos - tableStart);
+  const rowIndex = cellRect.top;
+  const colIndex = cellRect.left;
+  return {
+    rowIndex,
+    colIndex,
+    cellPos: $cellPos.pos,
+    rowFirstCellPos: getCellPos(map, tableStart, rowIndex, 0),
+    colFirstCellPos: getCellPos(map, tableStart, 0, colIndex)
+  };
+}
+function getCellPos(map, tableStart, rowIndex, colIndex) {
+  const cellIndex = getCellIndex(map, rowIndex, colIndex);
+  const posInTable = map.map[cellIndex];
+  return tableStart + posInTable;
+}
+function getCellIndex(map, rowIndex, colIndex) {
+  return map.width * rowIndex + colIndex;
+}
+
+// src/components/table-handle/table-handle-root/state.ts
+function useTableHandleRoot(host, state) {
+  const { editor } = state;
+  const context = createSignal4(null);
+  const hoveringCell = useHoveringCell(host, editor);
+  const typing = useEditorTyping(host, editor);
+  useEffect3(host, () => {
+    const typingValue = typing.get();
+    const hoveringCellValue = hoveringCell.get();
+    context.set(typingValue ? null : hoveringCellValue);
+  });
+  tableHandleRootContext.provide(host, context);
+}
+function useHoveringCell(host, editor) {
+  const hoveringCell = createSignal4(null);
+  const extension = defineCellHoverHandler((curr) => {
+    const prev = hoveringCell.peek();
+    if (!isHoveringCellInfoEqual(prev, curr)) {
+      hoveringCell.set(curr);
+    }
+  });
+  useEditorExtension(host, editor, extension);
+  return hoveringCell;
+}
+function defineCellHoverHandler(handler) {
+  const pointerHandler = (view, event) => {
+    const hoveringCell = getHoveringCell(view, event);
+    return handler(hoveringCell != null ? hoveringCell : null);
+  };
+  return defineDOMEventHandler2("pointerover", pointerHandler);
+}
+
+// src/components/table-handle/table-handle-root/element.gen.ts
+var TableHandleRootElement = class extends ElementBuilder5(useTableHandleRoot, defaultTableHandleRootProps) {
+};
+defineCustomElement("prosekit-table-handle-root", TableHandleRootElement);
+
+// src/components/table-handle/table-handle-row-root/element.gen.ts
+import { ElementBuilder as ElementBuilder6 } from "@aria-ui/core";
+
+// src/components/table-handle/table-handle-row-root/props.ts
+import {
+  defaultOverlayPositionerProps as defaultOverlayPositionerProps2
+} from "@aria-ui/overlay";
+var defaultTableHandleRowRootProps = Object.freeze({
+  ...defaultOverlayPositionerProps2,
+  editor: null,
+  placement: "left"
+});
+
+// src/components/table-handle/table-handle-row-root/state.ts
+import {
+  createComputed as createComputed3,
+  createSignal as createSignal5,
+  mapSignals as mapSignals3,
+  useAttribute as useAttribute3,
+  useEffect as useEffect4
+} from "@aria-ui/core";
+import { defaultMenuRootProps as defaultMenuRootProps2, useMenuRoot as useMenuRoot2 } from "@aria-ui/menu";
+import { useOverlayPositionerState as useOverlayPositionerState2 } from "@aria-ui/overlay";
+import { usePresence as usePresence2 } from "@aria-ui/presence";
+function useTableHandleRowRoot(host, state) {
+  const { editor, ...overlayState } = state;
+  const rootContext = tableHandleRootContext.consume(host);
+  const rowFirstCellPos = createComputed3(() => {
+    var _a;
+    return (_a = rootContext.get()) == null ? void 0 : _a.rowFirstCellPos;
+  });
+  const referenceCell = createComputed3(() => {
+    var _a;
+    const pos = rowFirstCellPos.get();
+    const view = (_a = editor.get()) == null ? void 0 : _a.view;
+    if (!pos || !view) return null;
+    return view.nodeDOM(pos);
+  });
+  const contentOpen = createSignal5(false);
+  useEffect4(host, () => {
+    rowFirstCellPos.get();
+    contentOpen.set(false);
+  });
+  useOverlayPositionerState2(host, overlayState, {
+    reference: referenceCell
+  });
+  const presence = createComputed3(() => !!referenceCell.get());
+  useAttribute3(host, "data-state", () => presence.get() ? "open" : "closed");
+  usePresence2(host, presence);
+  useMenuRoot2(host, {
+    ...mapSignals3(defaultMenuRootProps2),
+    open: contentOpen
+  });
+}
+
+// src/components/table-handle/table-handle-row-root/element.gen.ts
+var TableHandleRowRootElement = class extends ElementBuilder6(useTableHandleRowRoot, defaultTableHandleRowRootProps) {
+};
+defineCustomElement("prosekit-table-handle-row-root", TableHandleRowRootElement);
+
+// src/components/table-handle/table-handle-row-trigger/element.gen.ts
+import { ElementBuilder as ElementBuilder7 } from "@aria-ui/core";
+
+// src/components/table-handle/table-handle-row-trigger/props.ts
+var defaultTableHandleRowTriggerProps = Object.freeze({
+  editor: null
+});
+
+// src/components/table-handle/table-handle-row-trigger/state.ts
+import {
+  useEventListener as useEventListener2
+} from "@aria-ui/core";
+import { useMenuTrigger as useMenuTrigger2 } from "@aria-ui/menu";
+import { selectTableRow } from "@prosekit/extensions/table";
+function useTableHandleRowTrigger(host, state) {
+  useMenuTrigger2(host);
+  const context = tableHandleRootContext.consume(host);
+  useEventListener2(host, "pointerdown", () => {
+    var _a;
+    const editor = state.editor.peek();
+    const cellPos = (_a = context.peek()) == null ? void 0 : _a.cellPos;
+    if (!editor || !cellPos) return;
+    editor.exec(selectTableRow({ head: cellPos }));
+  });
+}
+
+// src/components/table-handle/table-handle-row-trigger/element.gen.ts
+var TableHandleRowTriggerElement = class extends ElementBuilder7(useTableHandleRowTrigger, defaultTableHandleRowTriggerProps) {
+};
+defineCustomElement("prosekit-table-handle-row-trigger", TableHandleRowTriggerElement);
+export {
+  TableHandleColumnRootElement,
+  TableHandleColumnTriggerElement,
+  TableHandlePopoverContentElement,
+  TableHandlePopoverItemElement,
+  TableHandleRootElement,
+  TableHandleRowRootElement,
+  TableHandleRowTriggerElement,
+  defaultTableHandleColumnRootProps,
+  defaultTableHandleColumnTriggerProps,
+  defaultTableHandlePopoverContentProps,
+  defaultTableHandlePopoverItemProps,
+  defaultTableHandleRootProps,
+  defaultTableHandleRowRootProps,
+  defaultTableHandleRowTriggerProps
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/web",
   "type": "module",
-  "version": "0.3.11",
+  "version": "0.3.13",
   "private": false,
   "author": {
     "name": "ocavue",
@@ -55,6 +55,11 @@
       "import": "./dist/prosekit-web-resizable.js",
       "default": "./dist/prosekit-web-resizable.js"
     },
+    "./table-handle": {
+      "types": "./dist/prosekit-web-table-handle.d.ts",
+      "import": "./dist/prosekit-web-table-handle.js",
+      "default": "./dist/prosekit-web-table-handle.js"
+    },
     "./tooltip": {
       "types": "./dist/prosekit-web-tooltip.d.ts",
       "import": "./dist/prosekit-web-tooltip.js",
@@ -68,15 +73,17 @@
     "@aria-ui/collection": "^0.0.3",
     "@aria-ui/core": "^0.0.18",
     "@aria-ui/listbox": "^0.0.18",
+    "@aria-ui/menu": "^0.0.12",
     "@aria-ui/overlay": "^0.0.19",
     "@aria-ui/popover": "^0.0.20",
     "@aria-ui/presence": "^0.0.14",
     "@aria-ui/tooltip": "^0.0.22",
     "@floating-ui/dom": "^1.6.10",
-    "@zag-js/dom-query": "^0.65.0",
+    "@zag-js/dom-query": "^0.65.1",
     "just-omit": "^2.2.0",
+    "prosemirror-tables": "^1.5.0",
     "@prosekit/core": "^0.7.9",
-    "@prosekit/extensions": "^0.7.11",
+    "@prosekit/extensions": "^0.7.13",
     "@prosekit/pm": "^0.1.8"
   },
   "devDependencies": {
@@ -110,6 +117,9 @@
       "resizable": [
         "./dist/prosekit-web-resizable.d.ts"
       ],
+      "table-handle": [
+        "./dist/prosekit-web-table-handle.d.ts"
+      ],
       "tooltip": [
         "./dist/prosekit-web-tooltip.d.ts"
       ]