@prosekit/web 0.3.19 → 0.4.1

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

@@ -1,33 +1,25 @@
+import {
+  getStateWithDefaults
+} from "./chunk-ZGQ225UP.js";
 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"
-});
+import { defineCustomElement, registerCustomElement } from "@aria-ui/core";
 
-// src/components/table-handle/table-handle-column-root/state.ts
+// src/components/table-handle/table-handle-column-root/setup.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 {
+  menuRootProps,
+  useMenuRoot
+} from "@aria-ui/menu/elements";
+import { useOverlayPositionerState } from "@aria-ui/overlay/elements";
 import { usePresence } from "@aria-ui/presence";
 
 // src/components/table-handle/context.ts
@@ -37,8 +29,8 @@ var tableHandleRootContext = createContext(
   null
 );
 
-// src/components/table-handle/table-handle-column-root/state.ts
-function useTableHandleColumnRoot(host, state) {
+// src/components/table-handle/table-handle-column-root/setup.ts
+function useTableHandleColumnRoot(host, { state }) {
   const { editor, ...overlayState } = state;
   const rootContext = tableHandleRootContext.consume(host);
   const colFirstCellPos = createComputed(() => {
@@ -63,32 +55,47 @@ function useTableHandleColumnRoot(host, state) {
   const presence = createComputed(() => !!referenceCell.get());
   useAttribute(host, "data-state", () => presence.get() ? "open" : "closed");
   usePresence(host, presence);
+  const menuRootState = getStateWithDefaults(
+    { open: contentOpen },
+    menuRootProps
+  );
   useMenuRoot(host, {
-    ...mapSignals(defaultMenuRootProps),
-    open: contentOpen
+    state: menuRootState,
+    emit: () => void 0
   });
 }
 
+// src/components/table-handle/table-handle-column-root/types.ts
+import {
+  overlayPositionerEvents,
+  overlayPositionerProps
+} from "@aria-ui/overlay";
+var tableHandleColumnRootProps = Object.freeze({
+  ...overlayPositionerProps,
+  editor: { default: null },
+  placement: { default: "top" }
+});
+var tableHandleColumnRootEvents = overlayPositionerEvents;
+
 // src/components/table-handle/table-handle-column-root/element.gen.ts
-var TableHandleColumnRootElement = class extends ElementBuilder(useTableHandleColumnRoot, defaultTableHandleColumnRootProps) {
+var TableHandleColumnRootElement = class extends defineCustomElement({
+  props: tableHandleColumnRootProps,
+  events: tableHandleColumnRootEvents,
+  setup: useTableHandleColumnRoot
+}) {
 };
-defineCustomElement("prosekit-table-handle-column-root", TableHandleColumnRootElement);
+registerCustomElement("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";
+import { defineCustomElement as defineCustomElement2, registerCustomElement as registerCustomElement2 } 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
+// src/components/table-handle/table-handle-column-trigger/setup.ts
 import {
   useEventListener
 } from "@aria-ui/core";
-import { useMenuTrigger } from "@aria-ui/menu";
+import { useMenuTrigger } from "@aria-ui/menu/elements";
 import { selectTableColumn } from "@prosekit/extensions/table";
-function useTableHandleColumnTrigger(host, state) {
+function useTableHandleColumnTrigger(host, { state }) {
   useMenuTrigger(host);
   const context = tableHandleRootContext.consume(host);
   useEventListener(host, "pointerdown", () => {
@@ -100,124 +107,144 @@ function useTableHandleColumnTrigger(host, state) {
   });
 }
 
+// src/components/table-handle/table-handle-column-trigger/types.ts
+var tableHandleColumnTriggerProps = {
+  editor: { default: null }
+};
+var tableHandleColumnTriggerEvents = {};
+
 // src/components/table-handle/table-handle-column-trigger/element.gen.ts
-var TableHandleColumnTriggerElement = class extends ElementBuilder2(useTableHandleColumnTrigger, defaultTableHandleColumnTriggerProps) {
+var TableHandleColumnTriggerElement = class extends defineCustomElement2({
+  props: tableHandleColumnTriggerProps,
+  events: tableHandleColumnTriggerEvents,
+  setup: useTableHandleColumnTrigger
+}) {
 };
-defineCustomElement("prosekit-table-handle-column-trigger", TableHandleColumnTriggerElement);
+registerCustomElement2("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
-});
+import { defineCustomElement as defineCustomElement3, registerCustomElement as registerCustomElement3 } from "@aria-ui/core";
 
-// src/components/table-handle/table-handle-popover-content/state.ts
+// src/components/table-handle/table-handle-popover-content/setup.ts
 import {
   createComputed as createComputed2,
   createSignal as createSignal2,
-  mapSignals as mapSignals2,
   useEffect as useEffect2
 } from "@aria-ui/core";
 import {
-  defaultMenuContentProps as defaultMenuContentProps2,
+  menuContentProps,
   useMenuContent
-} from "@aria-ui/menu";
-function useTableHandlePopoverContent(host, state) {
+} from "@aria-ui/menu/elements";
+function useTableHandlePopoverContent(host, {
+  state,
+  emit
+}) {
   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
+  const keyDownTarget = useKeyDownTarget(host, open);
+  const menuContentState = getStateWithDefaults(
+    {
+      placement: state.placement,
+      offset: state.offset,
+      eventTarget: createSignal2(keyDownTarget)
+    },
+    menuContentProps
   );
-  let disposeKeydownHandler;
+  useMenuContent(host, { state: menuContentState, emit });
+}
+function useKeyDownTarget(element, open) {
+  const keydownHandlers = [];
   useEffect2(element, () => {
-    const keydownHandlerValue = keydownHandler.get();
-    if (!keydownHandlerValue) {
-      return;
-    }
     const handleKeydown = (event) => {
       if (event.isComposing || event.defaultPrevented || !open.get()) {
         return false;
       }
-      keydownHandlerValue(event);
+      keydownHandlers.forEach((handler) => handler(event));
     };
     document.addEventListener("keydown", handleKeydown);
-    disposeKeydownHandler = () => {
+    return () => {
       document.removeEventListener("keydown", handleKeydown);
     };
   });
-  return (keydownHandlerValue) => {
-    keydownHandler.set(keydownHandlerValue);
-    return () => {
-      disposeKeydownHandler == null ? void 0 : disposeKeydownHandler();
-      disposeKeydownHandler = void 0;
-    };
+  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);
+        }
+      }
+    }
   };
 }
 
+// src/components/table-handle/table-handle-popover-content/types.ts
+import {
+  menuContentEvents,
+  menuContentProps as menuContentProps2
+} from "@aria-ui/menu/elements";
+var tableHandlePopoverContentProps = Object.freeze({
+  ...menuContentProps2,
+  placement: { default: "right-start" },
+  offset: { default: { mainAxis: -4, crossAxis: 4 } },
+  editor: { default: null }
+});
+var tableHandlePopoverContentEvents = Object.freeze({
+  ...menuContentEvents
+});
+
 // src/components/table-handle/table-handle-popover-content/element.gen.ts
-var TableHandlePopoverContentElement = class extends ElementBuilder3(useTableHandlePopoverContent, defaultTableHandlePopoverContentProps) {
+var TableHandlePopoverContentElement = class extends defineCustomElement3({
+  props: tableHandlePopoverContentProps,
+  events: tableHandlePopoverContentEvents,
+  setup: useTableHandlePopoverContent
+}) {
 };
-defineCustomElement("prosekit-table-handle-popover-content", TableHandlePopoverContentElement);
+registerCustomElement3("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
-});
+import { defineCustomElement as defineCustomElement4, registerCustomElement as registerCustomElement4 } from "@aria-ui/core";
+
+// src/components/table-handle/table-handle-popover-item/setup.ts
+import "@aria-ui/core";
+import { useMenuItem } from "@aria-ui/menu/elements";
+function useTableHandlePopoverItem(element, {
+  state,
+  emit
+}) {
+  useMenuItem(element, { state, emit });
+}
 
-// src/components/table-handle/table-handle-popover-item/state.ts
+// src/components/table-handle/table-handle-popover-item/types.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);
-}
+  menuItemEvents,
+  menuItemProps
+} from "@aria-ui/menu";
+var tableHandlePopoverItemProps = {
+  ...menuItemProps
+};
+var tableHandlePopoverItemEvents = {
+  ...menuItemEvents
+};
 
 // src/components/table-handle/table-handle-popover-item/element.gen.ts
-var TableHandlePopoverItemElement = class extends ElementBuilder4(useTableHandlePopoverItem, defaultTableHandlePopoverItemProps) {
+var TableHandlePopoverItemElement = class extends defineCustomElement4({
+  props: tableHandlePopoverItemProps,
+  events: tableHandlePopoverItemEvents,
+  setup: useTableHandlePopoverItem
+}) {
 };
-defineCustomElement("prosekit-table-handle-popover-item", TableHandlePopoverItemElement);
+registerCustomElement4("prosekit-table-handle-popover-item", TableHandlePopoverItemElement);
 
 // src/components/table-handle/table-handle-root/element.gen.ts
-import { ElementBuilder as ElementBuilder5 } from "@aria-ui/core";
+import { defineCustomElement as defineCustomElement5, registerCustomElement as registerCustomElement5 } 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
+// src/components/table-handle/table-handle-root/setup.ts
 import {
   createComputed as createComputed3,
   createSignal as createSignal4,
@@ -296,8 +323,8 @@ function getCellIndex(map, rowIndex, colIndex) {
   return map.width * rowIndex + colIndex;
 }
 
-// src/components/table-handle/table-handle-root/state.ts
-function useTableHandleRoot(host, state) {
+// src/components/table-handle/table-handle-root/setup.ts
+function useTableHandleRoot(host, { state }) {
   const { editor } = state;
   const context = createSignal4(null);
   const hoveringCell = useHoveringCell(host, editor);
@@ -361,36 +388,40 @@ function useSelecting(host, editor, isInTable) {
   return selecting;
 }
 
+// src/components/table-handle/table-handle-root/types.ts
+var tableHandleRootProps = {
+  editor: { default: null }
+};
+var tableHandleRootEvents = {};
+
 // src/components/table-handle/table-handle-root/element.gen.ts
-var TableHandleRootElement = class extends ElementBuilder5(useTableHandleRoot, defaultTableHandleRootProps) {
+var TableHandleRootElement = class extends defineCustomElement5({
+  props: tableHandleRootProps,
+  events: tableHandleRootEvents,
+  setup: useTableHandleRoot
+}) {
 };
-defineCustomElement("prosekit-table-handle-root", TableHandleRootElement);
+registerCustomElement5("prosekit-table-handle-root", TableHandleRootElement);
 
 // src/components/table-handle/table-handle-row-root/element.gen.ts
-import { ElementBuilder as ElementBuilder6 } from "@aria-ui/core";
+import { defineCustomElement as defineCustomElement6, registerCustomElement as registerCustomElement6 } 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
+// src/components/table-handle/table-handle-row-root/setup.ts
 import {
   createComputed as createComputed4,
   createSignal as createSignal5,
-  mapSignals as mapSignals3,
-  useAttribute as useAttribute3,
+  defineEmit,
+  useAttribute as useAttribute2,
   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 {
+  menuRootEvents,
+  menuRootProps as menuRootProps2,
+  useMenuRoot as useMenuRoot2
+} from "@aria-ui/menu/elements";
+import { useOverlayPositionerState as useOverlayPositionerState2 } from "@aria-ui/overlay/elements";
 import { usePresence as usePresence2 } from "@aria-ui/presence";
-function useTableHandleRowRoot(host, state) {
+function useTableHandleRowRoot(host, { state }) {
   const { editor, ...overlayState } = state;
   const rootContext = tableHandleRootContext.consume(host);
   const rowFirstCellPos = createComputed4(() => {
@@ -413,34 +444,52 @@ function useTableHandleRowRoot(host, state) {
     reference: referenceCell
   });
   const presence = createComputed4(() => !!referenceCell.get());
-  useAttribute3(host, "data-state", () => presence.get() ? "open" : "closed");
+  useAttribute2(host, "data-state", () => presence.get() ? "open" : "closed");
   usePresence2(host, presence);
+  const menuRootState = getStateWithDefaults(
+    {
+      open: contentOpen
+    },
+    menuRootProps2
+  );
   useMenuRoot2(host, {
-    ...mapSignals3(defaultMenuRootProps2),
-    open: contentOpen
+    state: menuRootState,
+    emit: defineEmit(host, menuRootEvents)
   });
 }
 
+// src/components/table-handle/table-handle-row-root/types.ts
+import {
+  overlayPositionerProps as overlayPositionerProps2
+} from "@aria-ui/overlay";
+var tableHandleRowRootProps = {
+  ...overlayPositionerProps2,
+  editor: { default: null },
+  placement: { default: "left" }
+};
+var tableHandleRowRootEvents = {};
+
 // src/components/table-handle/table-handle-row-root/element.gen.ts
-var TableHandleRowRootElement = class extends ElementBuilder6(useTableHandleRowRoot, defaultTableHandleRowRootProps) {
+var TableHandleRowRootElement = class extends defineCustomElement6({
+  props: tableHandleRowRootProps,
+  events: tableHandleRowRootEvents,
+  setup: useTableHandleRowRoot
+}) {
 };
-defineCustomElement("prosekit-table-handle-row-root", TableHandleRowRootElement);
+registerCustomElement6("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
-});
+import { defineCustomElement as defineCustomElement7, registerCustomElement as registerCustomElement7 } from "@aria-ui/core";
 
-// src/components/table-handle/table-handle-row-trigger/state.ts
+// src/components/table-handle/table-handle-row-trigger/setup.ts
 import {
   useEventListener as useEventListener2
 } from "@aria-ui/core";
-import { useMenuTrigger as useMenuTrigger2 } from "@aria-ui/menu";
+import { useMenuTrigger as useMenuTrigger2 } from "@aria-ui/menu/elements";
 import { selectTableRow } from "@prosekit/extensions/table";
-function useTableHandleRowTrigger(host, state) {
+function useTableHandleRowTrigger(host, {
+  state
+}) {
   useMenuTrigger2(host);
   const context = tableHandleRootContext.consume(host);
   useEventListener2(host, "pointerdown", () => {
@@ -452,10 +501,22 @@ function useTableHandleRowTrigger(host, state) {
   });
 }
 
+// src/components/table-handle/table-handle-row-trigger/types.ts
+var tableHandleRowTriggerProps = {
+  editor: { default: null }
+};
+var tableHandleRowTriggerEvents = {
+  select: {}
+};
+
 // src/components/table-handle/table-handle-row-trigger/element.gen.ts
-var TableHandleRowTriggerElement = class extends ElementBuilder7(useTableHandleRowTrigger, defaultTableHandleRowTriggerProps) {
+var TableHandleRowTriggerElement = class extends defineCustomElement7({
+  props: tableHandleRowTriggerProps,
+  events: tableHandleRowTriggerEvents,
+  setup: useTableHandleRowTrigger
+}) {
 };
-defineCustomElement("prosekit-table-handle-row-trigger", TableHandleRowTriggerElement);
+registerCustomElement7("prosekit-table-handle-row-trigger", TableHandleRowTriggerElement);
 export {
   TableHandleColumnRootElement,
   TableHandleColumnTriggerElement,
@@ -464,11 +525,18 @@ export {
   TableHandleRootElement,
   TableHandleRowRootElement,
   TableHandleRowTriggerElement,
-  defaultTableHandleColumnRootProps,
-  defaultTableHandleColumnTriggerProps,
-  defaultTableHandlePopoverContentProps,
-  defaultTableHandlePopoverItemProps,
-  defaultTableHandleRootProps,
-  defaultTableHandleRowRootProps,
-  defaultTableHandleRowTriggerProps
+  tableHandleColumnRootEvents,
+  tableHandleColumnRootProps,
+  tableHandleColumnTriggerEvents,
+  tableHandleColumnTriggerProps,
+  tableHandlePopoverContentEvents,
+  tableHandlePopoverContentProps,
+  tableHandlePopoverItemEvents,
+  tableHandlePopoverItemProps,
+  tableHandleRootEvents,
+  tableHandleRootProps,
+  tableHandleRowRootEvents,
+  tableHandleRowRootProps,
+  tableHandleRowTriggerEvents,
+  tableHandleRowTriggerProps
 };

package/dist/prosekit-web-tooltip.d.ts

@@ -1,9 +1,15 @@
 export { TooltipContentElement } from './_tsup-dts-rollup';
-export { defaultTooltipContentProps } from './_tsup-dts-rollup';
+export { tooltipContentEvents } from './_tsup-dts-rollup';
+export { tooltipContentProps } from './_tsup-dts-rollup';
+export { TooltipContentEvents } from './_tsup-dts-rollup';
 export { TooltipContentProps } from './_tsup-dts-rollup';
 export { TooltipRootElement } from './_tsup-dts-rollup';
-export { defaultTooltipRootProps } from './_tsup-dts-rollup';
+export { tooltipRootEvents } from './_tsup-dts-rollup';
+export { tooltipRootProps } from './_tsup-dts-rollup';
+export { TooltipRootEvents } from './_tsup-dts-rollup';
 export { TooltipRootProps } from './_tsup-dts-rollup';
 export { TooltipTriggerElement } from './_tsup-dts-rollup';
-export { defaultTooltipTriggerProps } from './_tsup-dts-rollup';
+export { tooltipTriggerEvents } from './_tsup-dts-rollup';
+export { tooltipTriggerProps } from './_tsup-dts-rollup';
+export { TooltipTriggerEvents } from './_tsup-dts-rollup';
 export { TooltipTriggerProps } from './_tsup-dts-rollup';

package/dist/prosekit-web-tooltip.js

@@ -1,65 +1,80 @@
-import {
-  defineCustomElement
-} from "./chunk-LCDA7GFP.js";
-
 // src/components/tooltip/tooltip-content/element.gen.ts
-import { ElementBuilder } from "@aria-ui/core";
+import { defineCustomElement, registerCustomElement } from "@aria-ui/core";
+
+// src/components/tooltip/tooltip-content/setup.ts
+import { useTooltipContent } from "@aria-ui/tooltip/elements";
 
-// src/components/tooltip/tooltip-content/props.ts
+// src/components/tooltip/tooltip-content/types.ts
 import {
-  defaultTooltipContentProps as defaultProps
+  tooltipContentProps as props,
+  tooltipContentEvents
 } from "@aria-ui/tooltip";
-var defaultTooltipContentProps = {
-  ...defaultProps,
-  shift: true,
-  flip: true,
-  offset: 6,
-  overflowPadding: 4,
+var tooltipContentProps = {
+  ...props,
+  shift: { default: true },
+  flip: { default: true },
+  offset: { default: 6 },
+  overflowPadding: { default: 4 },
   // Don't need boundary when hoist is true.
-  hoist: true,
-  boundary: []
+  hoist: { default: true },
+  boundary: { default: [] }
 };
 
-// src/components/tooltip/tooltip-content/state.ts
-import { useTooltipContent } from "@aria-ui/tooltip";
-
 // src/components/tooltip/tooltip-content/element.gen.ts
-var TooltipContentElement = class extends ElementBuilder(useTooltipContent, defaultTooltipContentProps) {
+var TooltipContentElement = class extends defineCustomElement({
+  props: tooltipContentProps,
+  events: tooltipContentEvents,
+  setup: useTooltipContent
+}) {
 };
-defineCustomElement("prosekit-tooltip-content", TooltipContentElement);
+registerCustomElement("prosekit-tooltip-content", TooltipContentElement);
 
 // src/components/tooltip/tooltip-root/element.gen.ts
-import { ElementBuilder as ElementBuilder2 } from "@aria-ui/core";
+import { defineCustomElement as defineCustomElement2, registerCustomElement as registerCustomElement2 } from "@aria-ui/core";
 
-// src/components/tooltip/tooltip-root/props.ts
-import { defaultTooltipRootProps } from "@aria-ui/tooltip";
+// src/components/tooltip/tooltip-root/setup.ts
+import { useTooltipRoot } from "@aria-ui/tooltip/elements";
 
-// src/components/tooltip/tooltip-root/state.ts
-import { useTooltipRoot } from "@aria-ui/tooltip";
+// src/components/tooltip/tooltip-root/types.ts
+import { tooltipRootEvents, tooltipRootProps } from "@aria-ui/tooltip/elements";
 
 // src/components/tooltip/tooltip-root/element.gen.ts
-var TooltipRootElement = class extends ElementBuilder2(useTooltipRoot, defaultTooltipRootProps) {
+var TooltipRootElement = class extends defineCustomElement2({
+  props: tooltipRootProps,
+  events: tooltipRootEvents,
+  setup: useTooltipRoot
+}) {
 };
-defineCustomElement("prosekit-tooltip-root", TooltipRootElement);
+registerCustomElement2("prosekit-tooltip-root", TooltipRootElement);
 
 // src/components/tooltip/tooltip-trigger/element.gen.ts
-import { ElementBuilder as ElementBuilder3 } from "@aria-ui/core";
+import { defineCustomElement as defineCustomElement3, registerCustomElement as registerCustomElement3 } from "@aria-ui/core";
 
-// src/components/tooltip/tooltip-trigger/props.ts
-import { defaultTooltipTriggerProps } from "@aria-ui/tooltip";
+// src/components/tooltip/tooltip-trigger/setup.ts
+import { useTooltipTrigger } from "@aria-ui/tooltip/elements";
 
-// src/components/tooltip/tooltip-trigger/state.ts
-import { useTooltipTrigger } from "@aria-ui/tooltip";
+// src/components/tooltip/tooltip-trigger/types.ts
+import {
+  tooltipTriggerEvents,
+  tooltipTriggerProps
+} from "@aria-ui/tooltip/elements";
 
 // src/components/tooltip/tooltip-trigger/element.gen.ts
-var TooltipTriggerElement = class extends ElementBuilder3(useTooltipTrigger, defaultTooltipTriggerProps) {
+var TooltipTriggerElement = class extends defineCustomElement3({
+  props: tooltipTriggerProps,
+  events: tooltipTriggerEvents,
+  setup: useTooltipTrigger
+}) {
 };
-defineCustomElement("prosekit-tooltip-trigger", TooltipTriggerElement);
+registerCustomElement3("prosekit-tooltip-trigger", TooltipTriggerElement);
 export {
   TooltipContentElement,
   TooltipRootElement,
   TooltipTriggerElement,
-  defaultTooltipContentProps,
-  defaultTooltipRootProps,
-  defaultTooltipTriggerProps
+  tooltipContentEvents,
+  tooltipContentProps,
+  tooltipRootEvents,
+  tooltipRootProps,
+  tooltipTriggerEvents,
+  tooltipTriggerProps
 };