@prosekit/web 0.3.12 → 0.3.14

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

@@ -15,6 +15,8 @@ var defaultBlockDragHandleProps = Object.freeze({
 
 // src/components/block-handle/block-drag-handle/state.ts
 import {
+  createSignal,
+  useAttribute,
   useEffect,
   useEventListener
 } from "@aria-ui/core";
@@ -25,11 +27,7 @@ import { NodeSelection } from "@prosekit/pm/state";
 import { createContext } from "@aria-ui/core";
 var blockPopoverContext = createContext(
   "prosekit-block-popover-context",
-  {
-    pos: null,
-    node: null,
-    element: null
-  }
+  null
 );
 
 // src/components/block-handle/block-drag-handle/state.ts
@@ -38,10 +36,15 @@ function useBlockDragHandle(host, state) {
   useEffect(host, () => {
     host.draggable = true;
   });
+  usePointerDownHandler(host, context, state.editor);
+  useDraggingPreview(host, context, state.editor);
+  useDataDraggingAttribute(host);
+}
+function usePointerDownHandler(host, context, editor) {
   useEventListener(host, "pointerdown", () => {
     var _a, _b;
     const { pos } = (_a = context.get()) != null ? _a : {};
-    const { view } = (_b = state.editor.get()) != null ? _b : {};
+    const { view } = (_b = editor.get()) != null ? _b : {};
     if (pos == null || view == null) {
       return;
     }
@@ -52,13 +55,16 @@ function useBlockDragHandle(host, state) {
       view.focus();
     });
   });
+}
+function useDraggingPreview(host, context, editor) {
   useEventListener(host, "dragstart", (event) => {
-    var _a, _b;
-    const { pos, element, node } = (_a = context.get()) != null ? _a : {};
-    const { view } = (_b = state.editor.get()) != null ? _b : {};
-    if (pos == null || !element || !node || !view || !event.dataTransfer) {
+    var _a;
+    const hoverState = context.get();
+    const { view } = (_a = editor.get()) != null ? _a : {};
+    if (!hoverState || !view || !event.dataTransfer) {
       return;
     }
+    const { element, node } = hoverState;
     event.dataTransfer.clearData();
     event.dataTransfer.setData("text/html", element.outerHTML);
     event.dataTransfer.effectAllowed = "copyMove";
@@ -69,15 +75,82 @@ function useBlockDragHandle(host, state) {
     };
   });
 }
+function useDataDraggingAttribute(host) {
+  const dragging = useDragging(host);
+  useAttribute(host, "data-dragging", () => dragging.get() ? "" : void 0);
+}
+function useDragging(host) {
+  const dragging = createSignal(false);
+  useEventListener(host, "dragstart", () => {
+    dragging.set(true);
+  });
+  useEventListener(host, "dragend", () => {
+    dragging.set(false);
+  });
+  return dragging;
+}
 
 // src/components/block-handle/block-drag-handle/element.gen.ts
 var BlockDragHandleElement = class extends ElementBuilder(useBlockDragHandle, defaultBlockDragHandleProps) {
 };
 defineCustomElement("prosekit-block-drag-handle", BlockDragHandleElement);
 
-// src/components/block-handle/block-popover/element.gen.ts
+// src/components/block-handle/block-handle-add/element.gen.ts
 import { ElementBuilder as ElementBuilder2 } from "@aria-ui/core";
 
+// src/components/block-handle/block-handle-add/props.ts
+var defaultBlockHandleAddProps = Object.freeze({
+  editor: null
+});
+
+// src/components/block-handle/block-handle-add/state.ts
+import {
+  useEventListener as useEventListener2
+} from "@aria-ui/core";
+import { insertDefaultBlock } from "@prosekit/core";
+function useBlockHandleAdd(host, state) {
+  const context = blockPopoverContext.consume(host);
+  useEventListener2(host, "pointerdown", (event) => {
+    event.preventDefault();
+    const editor = state.editor.get();
+    const hoverState = context.get();
+    if (!editor || !hoverState) {
+      return;
+    }
+    const { node, pos } = hoverState;
+    editor.exec(insertDefaultBlock({ pos: pos + node.nodeSize }));
+    editor.focus();
+    context.set(null);
+  });
+}
+
+// src/components/block-handle/block-handle-add/element.gen.ts
+var BlockHandleAddElement = class extends ElementBuilder2(useBlockHandleAdd, defaultBlockHandleAddProps) {
+};
+defineCustomElement("prosekit-block-handle-add", BlockHandleAddElement);
+
+// src/components/block-handle/block-handle-draggable/element.gen.ts
+import { ElementBuilder as ElementBuilder3 } from "@aria-ui/core";
+
+// src/components/block-handle/block-handle-draggable/props.ts
+var defaultBlockHandleDraggableProps = Object.freeze({
+  editor: null
+});
+
+// src/components/block-handle/block-handle-draggable/state.ts
+import "@aria-ui/core";
+function useBlockHandleDraggable(host, state) {
+  useBlockDragHandle(host, state);
+}
+
+// src/components/block-handle/block-handle-draggable/element.gen.ts
+var BlockHandleDraggableElement = class extends ElementBuilder3(useBlockHandleDraggable, defaultBlockHandleDraggableProps) {
+};
+defineCustomElement("prosekit-block-handle-draggable", BlockHandleDraggableElement);
+
+// src/components/block-handle/block-handle-popover/element.gen.ts
+import { ElementBuilder as ElementBuilder4 } from "@aria-ui/core";
+
 // src/components/block-handle/block-popover/props.ts
 import {
   defaultOverlayPositionerProps
@@ -89,11 +162,18 @@ var defaultBlockPopoverProps = Object.freeze({
   offset: 4
 });
 
+// src/components/block-handle/block-handle-popover/props.ts
+var defaultBlockHandlePopoverProps = Object.freeze({
+  ...defaultBlockPopoverProps
+});
+
+// src/components/block-handle/block-handle-popover/state.ts
+import "@aria-ui/core";
+
 // src/components/block-handle/block-popover/state.ts
 import {
-  createComputed,
-  createSignal,
-  useAttribute,
+  createSignal as createSignal2,
+  useAttribute as useAttribute2,
   useEffect as useEffect2
 } from "@aria-ui/core";
 import { useOverlayPositionerState } from "@aria-ui/overlay";
@@ -125,7 +205,7 @@ function defineElementHoverHandler(handler) {
       left: rect.left + rect.width / 2
     })) == null ? void 0 : _a.inside;
     if (pos == null || pos < 0) {
-      handler(null, null, null, null);
+      handler(null, null);
       return;
     }
     const $pos = view.state.doc.resolve(pos);
@@ -135,8 +215,8 @@ function defineElementHoverHandler(handler) {
       const ancestorPos = $pos.before($pos.depth);
       const node2 = view.state.doc.nodeAt(ancestorPos);
       const element2 = view.nodeDOM(ancestorPos);
-      if (!element2) {
-        handler(null, null, null, null);
+      if (!element2 || !node2) {
+        handler(null, null);
         return;
       }
       const reference = {
@@ -162,64 +242,78 @@ function defineElementHoverHandler(handler) {
           };
         }
       };
-      handler(reference, element2, node2, ancestorPos);
+      handler(reference, { element: element2, node: node2, pos: ancestorPos });
       return;
     }
-    handler(element, element, node, pos);
+    handler(element, element && node && { element, node, pos });
   };
   return union(
     defineDOMEventHandler("pointermove", throttle(handlePointerEvent, 200)),
     defineDOMEventHandler("pointerout", handlePointerEvent),
-    defineDOMEventHandler("keypress", () => handler(null, null, null, null))
+    defineDOMEventHandler("keypress", () => handler(null, null))
   );
 }
 
 // src/components/block-handle/block-popover/state.ts
 function useBlockPopover(host, state) {
   const { editor, ...overlayState } = state;
-  const reference = createSignal(null);
+  const reference = createSignal2(null);
   useOverlayPositionerState(host, overlayState, { reference });
-  const context = createSignal({
-    pos: null,
-    node: null,
-    element: null
-  });
+  const context = createSignal2(null);
   blockPopoverContext.provide(host, context);
-  const open = createSignal(false);
+  const open = createSignal2(false);
   useEffect2(host, () => {
-    open.set(!!context.get().element);
+    var _a;
+    open.set(!!((_a = context.get()) == null ? void 0 : _a.element));
   });
-  useHoverExtension(host, editor, (referenceValue, element, node, pos) => {
+  useHoverExtension(host, editor, (referenceValue, hoverState) => {
     reference.set(referenceValue);
-    context.set({ element, node, pos });
+    context.set(hoverState);
   });
-  const presence = createComputed(() => !!reference.get());
-  useAttribute(host, "data-state", () => presence.get() ? "open" : "closed");
-  usePresence(host, presence);
+  useAttribute2(host, "data-state", () => open.get() ? "open" : "closed");
+  usePresence(host, open);
 }
 function useHoverExtension(host, editor, handler) {
-  let prevElement = null;
-  let prevPos = null;
-  const extension = defineElementHoverHandler(
-    (reference, element, node, pos) => {
-      if (prevElement === element && prevPos === pos) {
-        return;
-      }
-      prevElement = element;
-      prevPos = pos;
-      handler(reference, element, node, pos);
+  let prevHoverState = null;
+  const extension = defineElementHoverHandler((reference, hoverState) => {
+    if (isHoverStateEqual(prevHoverState, hoverState)) {
+      return;
     }
-  );
+    prevHoverState = hoverState;
+    handler(reference, hoverState);
+  });
   useEditorExtension(host, editor, extension);
 }
+function isHoverStateEqual(a, b) {
+  if (!a && !b) return true;
+  if (!a || !b) return false;
+  return a.element === b.element && a.pos === b.pos && a.node.eq(b.node);
+}
+
+// src/components/block-handle/block-handle-popover/state.ts
+function useBlockHandlePopover(host, state) {
+  useBlockPopover(host, state);
+}
+
+// src/components/block-handle/block-handle-popover/element.gen.ts
+var BlockHandlePopoverElement = class extends ElementBuilder4(useBlockHandlePopover, defaultBlockHandlePopoverProps) {
+};
+defineCustomElement("prosekit-block-handle-popover", BlockHandlePopoverElement);
 
 // src/components/block-handle/block-popover/element.gen.ts
-var BlockPopoverElement = class extends ElementBuilder2(useBlockPopover, defaultBlockPopoverProps) {
+import { ElementBuilder as ElementBuilder5 } from "@aria-ui/core";
+var BlockPopoverElement = class extends ElementBuilder5(useBlockPopover, defaultBlockPopoverProps) {
 };
 defineCustomElement("prosekit-block-popover", BlockPopoverElement);
 export {
   BlockDragHandleElement,
+  BlockHandleAddElement,
+  BlockHandleDraggableElement,
+  BlockHandlePopoverElement,
   BlockPopoverElement,
   defaultBlockDragHandleProps,
+  defaultBlockHandleAddProps,
+  defaultBlockHandleDraggableProps,
+  defaultBlockHandlePopoverProps,
   defaultBlockPopoverProps
 };

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';