@prosekit/web 0.3.12 → 0.3.14

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';
@@ -175,6 +179,9 @@ declare const BlockDragHandleElement_base: {
     prototype: HTMLElement;
 };
 
+/**
+ * @deprecated Use `BlockHandleDraggableProps` instead.
+ */
 declare interface BlockDragHandleProps {
     /**
      * The ProseKit editor instance.
@@ -186,14 +193,67 @@ declare interface BlockDragHandleProps {
 export { BlockDragHandleProps }
 export { BlockDragHandleProps as BlockDragHandleProps_alias_1 }
 
+declare class BlockHandleAddElement extends BlockHandleAddElement_base {
+}
+export { BlockHandleAddElement }
+export { BlockHandleAddElement as BlockHandleAddElement_alias_1 }
+
+declare const BlockHandleAddElement_base: {
+    new (): BaseElement & BlockHandleAddProps;
+    prototype: HTMLElement;
+};
+
+declare interface BlockHandleAddProps {
+    /**
+     * The ProseKit editor instance.
+     *
+     * @default null
+     */
+    editor: Editor | null;
+}
+export { BlockHandleAddProps }
+export { BlockHandleAddProps as BlockHandleAddProps_alias_1 }
+
+declare class BlockHandleDraggableElement extends BlockHandleDraggableElement_base {
+}
+export { BlockHandleDraggableElement }
+export { BlockHandleDraggableElement as BlockHandleDraggableElement_alias_1 }
+
+declare const BlockHandleDraggableElement_base: {
+    new (): BaseElement & BlockHandleDraggableProps;
+    prototype: HTMLElement;
+};
+
+declare interface BlockHandleDraggableProps {
+    /**
+     * The ProseKit editor instance.
+     *
+     * @default null
+     */
+    editor: Editor | null;
+}
+export { BlockHandleDraggableProps }
+export { BlockHandleDraggableProps as BlockHandleDraggableProps_alias_1 }
+
+declare class BlockHandlePopoverElement extends BlockHandlePopoverElement_base {
+}
+export { BlockHandlePopoverElement }
+export { BlockHandlePopoverElement as BlockHandlePopoverElement_alias_1 }
+
+declare const BlockHandlePopoverElement_base: {
+    new (): BaseElement & BlockHandlePopoverProps;
+    prototype: HTMLElement;
+};
+
+declare interface BlockHandlePopoverProps extends BlockPopoverProps {
+}
+export { BlockHandlePopoverProps }
+export { BlockHandlePopoverProps as BlockHandlePopoverProps_alias_1 }
+
 /**
  * @internal
  */
-export declare interface BlockPopoverContext {
-    pos: number | null;
-    node: ProseMirrorNode | null;
-    element: HTMLElement | null;
-}
+export declare type BlockPopoverContext = HoverState | null;
 
 /**
  * @internal
@@ -294,6 +354,43 @@ declare const defaultBlockDragHandleProps: Readonly<{
 export { defaultBlockDragHandleProps }
 export { defaultBlockDragHandleProps as defaultBlockDragHandleProps_alias_1 }
 
+declare const defaultBlockHandleAddProps: Readonly<{
+    editor: null;
+}>;
+export { defaultBlockHandleAddProps }
+export { defaultBlockHandleAddProps as defaultBlockHandleAddProps_alias_1 }
+
+declare const defaultBlockHandleDraggableProps: Readonly<{
+    editor: null;
+}>;
+export { defaultBlockHandleDraggableProps }
+export { defaultBlockHandleDraggableProps as defaultBlockHandleDraggableProps_alias_1 }
+
+declare const defaultBlockHandlePopoverProps: Readonly<{
+    editor: null;
+    placement: "left-start";
+    offset: 4;
+    strategy: "absolute";
+    autoUpdate: true;
+    hoist: false;
+    transform: false;
+    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 { defaultBlockHandlePopoverProps }
+export { defaultBlockHandlePopoverProps as defaultBlockHandlePopoverProps_alias_1 }
+
 declare const defaultBlockPopoverProps: Readonly<{
     editor: null;
     placement: "left-start";
@@ -376,6 +473,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 +614,35 @@ 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 type ElementHoverHandler = (reference: VirtualElement | null, hoverState: HoverState | 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;
+}
+
+/**
+ * @internal
+ */
+export declare interface HoverState {
+    element: HTMLElement;
+    node: ProseMirrorNode;
+    pos: number;
+}
+
 declare class InlinePopoverElement extends InlinePopoverElement_base {
 }
 export { InlinePopoverElement }
@@ -501,6 +730,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 +858,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
  */
@@ -679,8 +1071,20 @@ export declare function useAutocompleteList(element: ConnectableElement, state:
 
 export declare function useAutocompletePopover(host: ConnectableElement, state: SignalState<AutocompletePopoverProps>): void;
 
+/**
+ * @deprecated Use `useBlockHandleDraggable` instead.
+ */
 export declare function useBlockDragHandle(host: ConnectableElement, state: SignalState<BlockDragHandleProps>): void;
 
+export declare function useBlockHandleAdd(host: ConnectableElement, state: SignalState<BlockHandleAddProps>): void;
+
+export declare function useBlockHandleDraggable(host: ConnectableElement, state: SignalState<BlockHandleDraggableProps>): void;
+
+export declare function useBlockHandlePopover(host: ConnectableElement, state: SignalState<BlockHandlePopoverProps>): void;
+
+/**
+ * @deprecated Use `useBlockHandlePopover` instead.
+ */
 export declare function useBlockPopover(host: ConnectableElement, state: SignalState<BlockPopoverProps>): void;
 
 export declare function useEditorExtension(host: ConnectableElement, editor: ReadonlySignal<Editor | null>, extension: Extension): void;
@@ -690,6 +1094,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 +1117,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-autocomplete.js

@@ -82,7 +82,6 @@ var defaultAutocompleteListProps = {
 
 // src/components/autocomplete/autocomplete-list/state.ts
 import {
-  createSignal,
   mapSignals,
   useEffect as useEffect2
 } from "@aria-ui/core";
@@ -144,14 +143,11 @@ function useAutocompleteList(element, state) {
   });
 }
 function useKeyboardHandler(element, open, editor) {
-  const keydownHandler = createSignal(
-    null
-  );
+  let keydownHandler = null;
   let disposeKeydownHandler;
   useEffect2(element, () => {
     const editorValue = editor.get();
-    const keydownHandlerValue = keydownHandler.get();
-    if (!editorValue || !keydownHandlerValue) {
+    if (!editorValue) {
       return;
     }
     const extension = defineDOMEventHandler(
@@ -160,7 +156,7 @@ function useKeyboardHandler(element, open, editor) {
         if (view.composing || event.defaultPrevented || !open.get()) {
           return false;
         }
-        keydownHandlerValue(event);
+        keydownHandler == null ? void 0 : keydownHandler(event);
         return event.defaultPrevented;
       }
     );
@@ -170,7 +166,7 @@ function useKeyboardHandler(element, open, editor) {
     );
   });
   return (keydownHandlerValue) => {
-    keydownHandler.set(keydownHandlerValue);
+    keydownHandler = keydownHandlerValue;
     return () => {
       disposeKeydownHandler == null ? void 0 : disposeKeydownHandler();
       disposeKeydownHandler = void 0;
@@ -210,7 +206,7 @@ var defaultAutocompletePopoverProps = Object.freeze({
 // src/components/autocomplete/autocomplete-popover/state.ts
 import {
   createComputed,
-  createSignal as createSignal3,
+  createSignal as createSignal2,
   useAnimationFrame,
   useAttribute,
   useEffect as useEffect4
@@ -229,11 +225,11 @@ import {
 
 // src/hooks/use-first-rendering.ts
 import {
-  createSignal as createSignal2,
+  createSignal,
   useEffect as useEffect3
 } from "@aria-ui/core";
 function useFirstRendering(host) {
-  const firstRendering = createSignal2(true);
+  const firstRendering = createSignal(true);
   useEffect3(host, () => {
     requestAnimationFrame(() => {
       firstRendering.set(false);
@@ -250,10 +246,10 @@ function defaultQueryBuilder(match) {
 // src/components/autocomplete/autocomplete-popover/state.ts
 function useAutocompletePopover(host, state) {
   const { editor, regex, ...overlayState } = state;
-  const reference = createSignal3(null);
-  const query = createSignal3("");
-  const onDismiss = createSignal3(null);
-  const onSubmit = createSignal3(null);
+  const reference = createSignal2(null);
+  const query = createSignal2("");
+  const onDismiss = createSignal2(null);
+  const onSubmit = createSignal2(null);
   const presence = createComputed(() => !!reference.get());
   queryContext.provide(host, query);
   onSubmitContext.provide(host, onSubmit);
@@ -297,7 +293,7 @@ function useAutocompleteExtension(host, editor, regex, reference, query, onDismi
     if (!editorValue || !regexValue) {
       return;
     }
-    return addAutocompleteExtension(
+    const rule = createAutocompleteRule(
       editorValue,
       regexValue,
       reference,
@@ -305,9 +301,11 @@ function useAutocompleteExtension(host, editor, regex, reference, query, onDismi
       onDismiss,
       onSubmit
     );
+    const extension = defineAutocomplete(rule);
+    return editorValue.use(extension);
   });
 }
-function addAutocompleteExtension(editor, regex, reference, query, onDismiss, onSubmit) {
+function createAutocompleteRule(editor, regex, reference, query, onDismiss, onSubmit) {
   const handleEnter = (options) => {
     const span = editor.view.dom.querySelector(".prosemirror-prediction-match");
     if (span) {
@@ -323,13 +321,11 @@ function addAutocompleteExtension(editor, regex, reference, query, onDismiss, on
     onDismiss.set(null);
     onSubmit.set(null);
   };
-  const rule = new AutocompleteRule({
+  return new AutocompleteRule({
     regex,
     onEnter: handleEnter,
     onLeave: handleLeave
   });
-  const extension = defineAutocomplete(rule);
-  return editor.use(extension);
 }
 function createKeymapHandler(handler, enabled) {
   return () => {

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

@@ -1,6 +1,15 @@
 export { BlockDragHandleElement } from './_tsup-dts-rollup';
 export { defaultBlockDragHandleProps } from './_tsup-dts-rollup';
 export { BlockDragHandleProps } from './_tsup-dts-rollup';
+export { BlockHandleAddElement } from './_tsup-dts-rollup';
+export { defaultBlockHandleAddProps } from './_tsup-dts-rollup';
+export { BlockHandleAddProps } from './_tsup-dts-rollup';
+export { BlockHandleDraggableElement } from './_tsup-dts-rollup';
+export { defaultBlockHandleDraggableProps } from './_tsup-dts-rollup';
+export { BlockHandleDraggableProps } from './_tsup-dts-rollup';
+export { BlockHandlePopoverElement } from './_tsup-dts-rollup';
+export { defaultBlockHandlePopoverProps } from './_tsup-dts-rollup';
+export { BlockHandlePopoverProps } from './_tsup-dts-rollup';
 export { BlockPopoverElement } from './_tsup-dts-rollup';
 export { defaultBlockPopoverProps } from './_tsup-dts-rollup';
 export { BlockPopoverProps } from './_tsup-dts-rollup';