@prosekit/preact 0.6.8 → 0.7.0-beta.1

package/src/components/table-handle/table-handle-row-positioner.gen.ts

@@ -0,0 +1,201 @@
+/**
+ * This file is auto-generated by the "@aria-ui/cli" tool. Do not edit this file directly.
+ */
+
+import { registerTableHandleRowPositionerElement, type TableHandleRowPositionerElement, type TableHandleRowPositionerProps as TableHandleRowPositionerElementProps } from '@prosekit/web/table-handle';
+import { createElement, type HTMLAttributes, type Ref } from 'preact';
+import { forwardRef, type ForwardRefExoticComponent, type RefAttributes } from 'preact/compat';
+import { useCallback, useRef, useLayoutEffect } from 'preact/hooks';
+
+import { useEditorContext } from '../../contexts/editor-context.ts';
+
+/**
+ * Props for the {@link TableHandleRowPositioner} Preact component.
+ *
+ * @public
+ */
+export interface TableHandleRowPositionerProps extends HTMLAttributes<TableHandleRowPositionerElement> {
+  /**
+   * The placement of the popover, relative to the hovered table cell.
+   *
+   * @default "left"
+   */
+  placement?: TableHandleRowPositionerElementProps['placement'];
+  /**
+   * The strategy to use for positioning
+   *
+   * @default "absolute"
+   */
+  strategy?: TableHandleRowPositionerElementProps['strategy'];
+  /**
+   * Options to activate auto-update listeners
+   *
+   * @see https://floating-ui.com/docs/autoUpdate
+   *
+   * @default true
+   */
+  autoUpdate?: TableHandleRowPositionerElementProps['autoUpdate'];
+  /**
+   * Whether to use the browser [Popover API](https://developer.mozilla.org/en-US/docs/Web/API/Popover_API)
+   * to place the floating element on top of other page content.
+   *
+   * @default false
+   */
+  hoist?: TableHandleRowPositionerElementProps['hoist'];
+  /**
+   * @default 0
+   * @hidden
+   */
+  offset?: TableHandleRowPositionerElementProps['offset'];
+  /**
+   * @default false
+   * @hidden
+   */
+  flip?: TableHandleRowPositionerElementProps['flip'];
+  /**
+   * @default false
+   * @hidden
+   */
+  shift?: TableHandleRowPositionerElementProps['shift'];
+  /**
+   * Whether the floating element can overlap the reference element to keep it
+   * in view.
+   *
+   * @default false
+   */
+  overlap?: TableHandleRowPositionerElementProps['overlap'];
+  /**
+   * Whether to constrain the floating element's width and height to not exceed
+   * the viewport.
+   *
+   * @default false
+   */
+  fitViewport?: TableHandleRowPositionerElementProps['fitViewport'];
+  /**
+   * Whether to constrain the floating element's width so that it matches the
+   * reference element.
+   *
+   * @default false
+   */
+  sameWidth?: TableHandleRowPositionerElementProps['sameWidth'];
+  /**
+   * Whether to constrain the floating element's height so that it matches the
+   * reference element.
+   *
+   * @default false
+   */
+  sameHeight?: TableHandleRowPositionerElementProps['sameHeight'];
+  /**
+   * Whether to improve positioning for inline reference elements that span over
+   * multiple lines.
+   *
+   * @default false
+   */
+  inline?: TableHandleRowPositionerElementProps['inline'];
+  /**
+   * @default true
+   * @hidden
+   */
+  hide?: TableHandleRowPositionerElementProps['hide'];
+  /**
+   * Describes the clipping element(s) or area that overflow will be checked relative to.
+   * Please see https://floating-ui.com/docs/detectoverflow#boundary for more information.
+   *
+   * @default 'clippingAncestors'
+   */
+  boundary?: TableHandleRowPositionerElementProps['boundary'];
+  /**
+   * Describes the root boundary that the element will be checked for overflow relative to.
+   * Please see https://floating-ui.com/docs/detectoverflow#rootboundary for more information.
+   *
+   * @default 'viewport'
+   */
+  rootBoundary?: TableHandleRowPositionerElementProps['rootBoundary'];
+  /**
+   * Describes the virtual padding around the boundary to check for overflow.
+   * Please see https://floating-ui.com/docs/detectoverflow#padding for more information.
+   *
+   * @default 4
+   */
+  overflowPadding?: TableHandleRowPositionerElementProps['overflowPadding'];
+  /**
+   * The element that will be used to check for overflow. Please see
+   * https://floating-ui.com/docs/detectoverflow#elementcontext for more
+   * information.
+   *
+   * @default 'floating'
+   */
+  elementContext?: TableHandleRowPositionerElementProps['elementContext'];
+  /**
+   * Whether to check the alternate elementContext's boundary. Please see
+   * https://floating-ui.com/docs/detectoverflow#altboundary for more
+   * information.
+   *
+   * @default false
+   */
+  altBoundary?: TableHandleRowPositionerElementProps['altBoundary'];
+  /**
+   * The ProseKit editor instance.
+   *
+   * @default null
+   * @hidden
+   */
+  editor?: TableHandleRowPositionerElementProps['editor'];
+}
+
+function TableHandleRowPositionerComponent(props: TableHandleRowPositionerProps, forwardedRef: Ref<TableHandleRowPositionerElement>) {
+  registerTableHandleRowPositionerElement();
+
+  const elementRef = useRef<TableHandleRowPositionerElement>(null);
+
+  const p3Fallback = useEditorContext();
+
+  const { altBoundary: p0, autoUpdate: p1, boundary: p2, editor: p3, elementContext: p4, fitViewport: p5, flip: p6, hide: p7, hoist: p8, inline: p9, offset: p10, overflowPadding: p11, overlap: p12, placement: p13, rootBoundary: p14, sameHeight: p15, sameWidth: p16, shift: p17, strategy: p18, ...restProps } = props;
+
+  useLayoutEffect(() => {
+    const element = elementRef.current as Record<string, unknown> | null;
+    if (!element) return;
+    Object.assign(element, {
+      altBoundary: p0,
+      autoUpdate: p1,
+      boundary: p2,
+      editor: p3 ?? p3Fallback,
+      elementContext: p4,
+      fitViewport: p5,
+      flip: p6,
+      hide: p7,
+      hoist: p8,
+      inline: p9,
+      offset: p10,
+      overflowPadding: p11,
+      overlap: p12,
+      placement: p13,
+      rootBoundary: p14,
+      sameHeight: p15,
+      sameWidth: p16,
+      shift: p17,
+      strategy: p18,
+    });
+  });
+
+  const mergedRef = useCallback(
+    (element: TableHandleRowPositionerElement | null) => {
+      elementRef.current = element;
+      if (typeof forwardedRef === 'function') {
+        forwardedRef(element);
+      } else if (forwardedRef) {
+        forwardedRef.current = element;
+      }
+    },
+    [forwardedRef],
+  );
+
+  return createElement('prosekit-table-handle-row-positioner', { ...restProps, ref: mergedRef, suppressHydrationWarning: true });
+}
+
+/**
+ * A Preact component that renders an `prosekit-table-handle-row-positioner` custom element.
+ *
+ * @public
+ */
+export const TableHandleRowPositioner: ForwardRefExoticComponent<TableHandleRowPositionerProps & RefAttributes<TableHandleRowPositionerElement>> = /* @__PURE__ */ forwardRef(TableHandleRowPositionerComponent);

package/src/components/tooltip/index.gen.ts

@@ -1,5 +1,13 @@
-export { TooltipContent, type TooltipContentProps } from './tooltip-content.gen.ts'
+/**
+ * This file is auto-generated by the "@aria-ui/cli" tool. Do not edit this file directly.
+ */
 
-export { TooltipRoot, type TooltipRootProps } from './tooltip-root.gen.ts'
+export { TooltipPopup, type TooltipPopupProps } from './tooltip-popup.gen.ts';
 
-export { TooltipTrigger, type TooltipTriggerProps } from './tooltip-trigger.gen.ts'
+export { TooltipPositioner, type TooltipPositionerProps } from './tooltip-positioner.gen.ts';
+
+export { TooltipRoot, type TooltipRootProps, type TooltipRootEvents } from './tooltip-root.gen.ts';
+
+export { TooltipTrigger, type TooltipTriggerProps } from './tooltip-trigger.gen.ts';
+
+export { OpenChangeEvent } from '@prosekit/web/tooltip';

package/src/components/tooltip/index.ts

@@ -0,0 +1,24 @@
+/**
+
+@module
+
+## Anatomy
+
+```jsx
+import {
+  TooltipPopup,
+  TooltipPositioner,
+  TooltipRoot,
+  TooltipTrigger,
+} from 'prosekit/preact/tooltip'
+
+<TooltipRoot>
+  <TooltipTrigger>...</TooltipTrigger>
+  <TooltipPositioner>
+    <TooltipPopup>...</TooltipPopup>
+  </TooltipPositioner>
+</TooltipRoot>
+```
+*/
+
+export * from './index.gen.ts'

package/src/components/tooltip/tooltip-popup.gen.ts

@@ -0,0 +1,44 @@
+/**
+ * This file is auto-generated by the "@aria-ui/cli" tool. Do not edit this file directly.
+ */
+
+import { registerTooltipPopupElement, type TooltipPopupElement } from '@prosekit/web/tooltip';
+import { createElement, type HTMLAttributes, type Ref } from 'preact';
+import { forwardRef, type ForwardRefExoticComponent, type RefAttributes } from 'preact/compat';
+import { useCallback, useRef } from 'preact/hooks';
+
+/**
+ * Props for the {@link TooltipPopup} Preact component.
+ *
+ * @public
+ */
+export interface TooltipPopupProps extends HTMLAttributes<TooltipPopupElement> {}
+
+function TooltipPopupComponent(props: TooltipPopupProps, forwardedRef: Ref<TooltipPopupElement>) {
+  registerTooltipPopupElement();
+
+  const elementRef = useRef<TooltipPopupElement>(null);
+
+  const { ...restProps } = props;
+
+  const mergedRef = useCallback(
+    (element: TooltipPopupElement | null) => {
+      elementRef.current = element;
+      if (typeof forwardedRef === 'function') {
+        forwardedRef(element);
+      } else if (forwardedRef) {
+        forwardedRef.current = element;
+      }
+    },
+    [forwardedRef],
+  );
+
+  return createElement('prosekit-tooltip-popup', { ...restProps, ref: mergedRef, suppressHydrationWarning: true });
+}
+
+/**
+ * A Preact component that renders an `prosekit-tooltip-popup` custom element.
+ *
+ * @public
+ */
+export const TooltipPopup: ForwardRefExoticComponent<TooltipPopupProps & RefAttributes<TooltipPopupElement>> = /* @__PURE__ */ forwardRef(TooltipPopupComponent);

package/src/components/tooltip/tooltip-positioner.gen.ts

@@ -0,0 +1,178 @@
+/**
+ * This file is auto-generated by the "@aria-ui/cli" tool. Do not edit this file directly.
+ */
+
+import { registerTooltipPositionerElement, type TooltipPositionerElement, type TooltipPositionerProps as TooltipPositionerElementProps } from '@prosekit/web/tooltip';
+import { createElement, type HTMLAttributes, type Ref } from 'preact';
+import { forwardRef, type ForwardRefExoticComponent, type RefAttributes } from 'preact/compat';
+import { useCallback, useRef, useLayoutEffect } from 'preact/hooks';
+
+/**
+ * Props for the {@link TooltipPositioner} Preact component.
+ *
+ * @public
+ */
+export interface TooltipPositionerProps extends HTMLAttributes<TooltipPositionerElement> {
+  /**
+   * The strategy to use for positioning
+   *
+   * @default "absolute"
+   */
+  strategy?: TooltipPositionerElementProps['strategy'];
+  /**
+   * The initial placement of the floating element
+   *
+   * @default "top"
+   */
+  placement?: TooltipPositionerElementProps['placement'];
+  /**
+   * Options to activate auto-update listeners
+   *
+   * @see https://floating-ui.com/docs/autoUpdate
+   *
+   * @default true
+   */
+  autoUpdate?: TooltipPositionerElementProps['autoUpdate'];
+  /**
+   * Whether to use the browser Popover API to place the floating element on
+   * top of other page content.
+   *
+   * @default true
+   */
+  hoist?: TooltipPositionerElementProps['hoist'];
+  /**
+   * The distance between the reference and floating element.
+   *
+   * @default 6
+   */
+  offset?: TooltipPositionerElementProps['offset'];
+  /**
+   * Whether to flip the `placement` in order to keep it in view when the
+   * preferred placement(s) will overflow the clipping boundary. You can also
+   * provide an array of placements to try sequentially if the preferred
+   * `placement` does not fit.
+   *
+   * @default true
+   */
+  flip?: TooltipPositionerElementProps['flip'];
+  /**
+   * Whether the floating element should shift to keep it in view.
+   *
+   * @default true
+   */
+  shift?: TooltipPositionerElementProps['shift'];
+  /**
+   * Whether the floating element can overlap the reference element to keep it
+   * in view.
+   *
+   * @default false
+   */
+  overlap?: TooltipPositionerElementProps['overlap'];
+  /**
+   * Whether to constrain the floating element's width and height to not exceed
+   * the viewport.
+   *
+   * @default false
+   */
+  fitViewport?: TooltipPositionerElementProps['fitViewport'];
+  /**
+   * Whether to constrain the floating element's width so that it matches the
+   * reference element.
+   *
+   * @default false
+   */
+  sameWidth?: TooltipPositionerElementProps['sameWidth'];
+  /**
+   * Whether to constrain the floating element's height so that it matches the
+   * reference element.
+   *
+   * @default false
+   */
+  sameHeight?: TooltipPositionerElementProps['sameHeight'];
+  /**
+   * Whether to improve positioning for inline reference elements that span over
+   * multiple lines.
+   *
+   * @default false
+   */
+  inline?: TooltipPositionerElementProps['inline'];
+  /**
+   * Whether to hide the floating element when the reference element or the
+   * floating element is fully clipped.
+   *
+   * @default false
+   */
+  hide?: TooltipPositionerElementProps['hide'];
+  /**
+   * Describes the clipping element(s) or area that overflow will be checked relative to.
+   * Please see https://floating-ui.com/docs/detectoverflow#boundary for more information.
+   *
+   * @default 'clippingAncestors'
+   */
+  boundary?: TooltipPositionerElementProps['boundary'];
+  /**
+   * Describes the root boundary that the element will be checked for overflow relative to.
+   * Please see https://floating-ui.com/docs/detectoverflow#rootboundary for more information.
+   *
+   * @default 'viewport'
+   */
+  rootBoundary?: TooltipPositionerElementProps['rootBoundary'];
+  /**
+   * Describes the virtual padding around the boundary to check for overflow.
+   * Please see https://floating-ui.com/docs/detectoverflow#padding for more information.
+   *
+   * @default 4
+   */
+  overflowPadding?: TooltipPositionerElementProps['overflowPadding'];
+  /**
+   * The element that will be used to check for overflow. Please see
+   * https://floating-ui.com/docs/detectoverflow#elementcontext for more
+   * information.
+   *
+   * @default 'floating'
+   */
+  elementContext?: TooltipPositionerElementProps['elementContext'];
+  /**
+   * Whether to check the alternate elementContext's boundary. Please see
+   * https://floating-ui.com/docs/detectoverflow#altboundary for more
+   * information.
+   *
+   * @default false
+   */
+  altBoundary?: TooltipPositionerElementProps['altBoundary'];
+}
+
+function TooltipPositionerComponent(props: TooltipPositionerProps, forwardedRef: Ref<TooltipPositionerElement>) {
+  registerTooltipPositionerElement();
+
+  const elementRef = useRef<TooltipPositionerElement>(null);
+
+  const { altBoundary: p0, autoUpdate: p1, boundary: p2, elementContext: p3, fitViewport: p4, flip: p5, hide: p6, hoist: p7, inline: p8, offset: p9, overflowPadding: p10, overlap: p11, placement: p12, rootBoundary: p13, sameHeight: p14, sameWidth: p15, shift: p16, strategy: p17, ...restProps } = props;
+
+  useLayoutEffect(() => {
+    const element = elementRef.current as Record<string, unknown> | null;
+    if (!element) return;
+    Object.assign(element, { altBoundary: p0, autoUpdate: p1, boundary: p2, elementContext: p3, fitViewport: p4, flip: p5, hide: p6, hoist: p7, inline: p8, offset: p9, overflowPadding: p10, overlap: p11, placement: p12, rootBoundary: p13, sameHeight: p14, sameWidth: p15, shift: p16, strategy: p17 });
+  });
+
+  const mergedRef = useCallback(
+    (element: TooltipPositionerElement | null) => {
+      elementRef.current = element;
+      if (typeof forwardedRef === 'function') {
+        forwardedRef(element);
+      } else if (forwardedRef) {
+        forwardedRef.current = element;
+      }
+    },
+    [forwardedRef],
+  );
+
+  return createElement('prosekit-tooltip-positioner', { ...restProps, ref: mergedRef, suppressHydrationWarning: true });
+}
+
+/**
+ * A Preact component that renders an `prosekit-tooltip-positioner` custom element.
+ *
+ * @public
+ */
+export const TooltipPositioner: ForwardRefExoticComponent<TooltipPositionerProps & RefAttributes<TooltipPositionerElement>> = /* @__PURE__ */ forwardRef(TooltipPositionerComponent);

package/src/components/tooltip/tooltip-root.gen.ts

@@ -1,34 +1,88 @@
-import {
-  type TooltipRootElement,
-  type TooltipRootProps as Props,
-  type TooltipRootEvents as Events,
-  tooltipRootProps,
-  tooltipRootEvents,
-} from '@prosekit/web/tooltip'
-import type {
-  ForwardRefExoticComponent,
-  HTMLAttributes,
-  RefAttributes,
-} from 'preact/compat'
-
-import { createComponent } from '../create-component.ts'
-import type { CreateProps } from '../create-props.ts'
+/**
+ * This file is auto-generated by the "@aria-ui/cli" tool. Do not edit this file directly.
+ */
+
+import { registerTooltipRootElement, type TooltipRootElement, type TooltipRootProps as TooltipRootElementProps, type TooltipRootEvents } from '@prosekit/web/tooltip';
+import { createElement, type HTMLAttributes, type Ref } from 'preact';
+import { forwardRef, type ForwardRefExoticComponent, type RefAttributes } from 'preact/compat';
+import { useCallback, useRef, useLayoutEffect } from 'preact/hooks';
+
+/**
+ * Props for the {@link TooltipRoot} Preact component.
+ *
+ * @public
+ */
+export interface TooltipRootProps extends HTMLAttributes<TooltipRootElement> {
+  /**
+   * Whether the overlay is initially open.
+   * @default false
+   */
+  defaultOpen?: TooltipRootElementProps['defaultOpen'];
+  /**
+   * Whether the overlay is currently open.
+   * @default null
+   */
+  open?: TooltipRootElementProps['open'];
+  /**
+   * Whether the component should ignore user interaction.
+   * @default false
+   */
+  disabled?: TooltipRootElementProps['disabled'];
+  /** Emitted when the tooltip is opened or closed. */
+  onOpenChange?: (event: TooltipRootEvents['openChange']) => void;
+}
+
+function TooltipRootComponent(props: TooltipRootProps, forwardedRef: Ref<TooltipRootElement>) {
+  registerTooltipRootElement();
+
+  const elementRef = useRef<TooltipRootElement>(null);
+  const handlersRef = useRef<Array<((event: Event) => void) | undefined>>([]);
+
+  const { defaultOpen: p0, disabled: p1, open: p2, onOpenChange: e0, ...restProps } = props;
+
+  useLayoutEffect(() => {
+    const element = elementRef.current as Record<string, unknown> | null;
+    if (!element) return;
+    Object.assign(element, { defaultOpen: p0, disabled: p1, open: p2 });
+    handlersRef.current = [e0] as Array<((event: Event) => void) | undefined>;
+  });
+
+  useLayoutEffect(() => {
+    const element = elementRef.current;
+    if (!element) return;
+    const ac = new AbortController();
+    for (const [index, eventName] of ['openChange'].entries()) {
+      element.addEventListener(
+        eventName,
+        (event: Event) => {
+          handlersRef.current[index]?.(event);
+        },
+        { signal: ac.signal },
+      );
+    }
+    return () => ac.abort();
+  }, []);
+
+  const mergedRef = useCallback(
+    (element: TooltipRootElement | null) => {
+      elementRef.current = element;
+      if (typeof forwardedRef === 'function') {
+        forwardedRef(element);
+      } else if (forwardedRef) {
+        forwardedRef.current = element;
+      }
+    },
+    [forwardedRef],
+  );
+
+  return createElement('prosekit-tooltip-root', { ...restProps, ref: mergedRef, suppressHydrationWarning: true });
+}
 
 /**
- * Props for the {@link TooltipRoot} component.
+ * A Preact component that renders an `prosekit-tooltip-root` custom element.
+ *
+ * @public
  */
-export interface TooltipRootProps extends Partial<CreateProps<Props, Events>> {}
-
-export const TooltipRoot: ForwardRefExoticComponent<
-  Partial<TooltipRootProps> &
-  RefAttributes<TooltipRootElement> &
-  HTMLAttributes<TooltipRootElement>
-> = createComponent<
-  TooltipRootProps,
-  TooltipRootElement
->(
-  'prosekit-tooltip-root',
-  'TooltipRoot',
-  Object.keys(tooltipRootProps),
-  Object.keys(tooltipRootEvents),
-)
+export const TooltipRoot: ForwardRefExoticComponent<TooltipRootProps & RefAttributes<TooltipRootElement>> = /* @__PURE__ */ forwardRef(TooltipRootComponent);
+
+export type { TooltipRootEvents };

package/src/components/tooltip/tooltip-trigger.gen.ts

@@ -1,34 +1,66 @@
-import {
-  type TooltipTriggerElement,
-  type TooltipTriggerProps as Props,
-  type TooltipTriggerEvents as Events,
-  tooltipTriggerProps,
-  tooltipTriggerEvents,
-} from '@prosekit/web/tooltip'
-import type {
-  ForwardRefExoticComponent,
-  HTMLAttributes,
-  RefAttributes,
-} from 'preact/compat'
-
-import { createComponent } from '../create-component.ts'
-import type { CreateProps } from '../create-props.ts'
+/**
+ * This file is auto-generated by the "@aria-ui/cli" tool. Do not edit this file directly.
+ */
+
+import { registerTooltipTriggerElement, type TooltipTriggerElement, type TooltipTriggerProps as TooltipTriggerElementProps } from '@prosekit/web/tooltip';
+import { createElement, type HTMLAttributes, type Ref } from 'preact';
+import { forwardRef, type ForwardRefExoticComponent, type RefAttributes } from 'preact/compat';
+import { useCallback, useRef, useLayoutEffect } from 'preact/hooks';
+
+/**
+ * Props for the {@link TooltipTrigger} Preact component.
+ *
+ * @public
+ */
+export interface TooltipTriggerProps extends HTMLAttributes<TooltipTriggerElement> {
+  /**
+   * Whether the component should ignore user interaction.
+   * @default false
+   */
+  disabled?: TooltipTriggerElementProps['disabled'];
+  /**
+   * The delay in milliseconds before opening the tooltip on hover.
+   * @default 600
+   */
+  openDelay?: TooltipTriggerElementProps['openDelay'];
+  /**
+   * The delay in milliseconds before closing the tooltip when hover/focus ends.
+   * @default 0
+   */
+  closeDelay?: TooltipTriggerElementProps['closeDelay'];
+}
+
+function TooltipTriggerComponent(props: TooltipTriggerProps, forwardedRef: Ref<TooltipTriggerElement>) {
+  registerTooltipTriggerElement();
+
+  const elementRef = useRef<TooltipTriggerElement>(null);
+
+  const { closeDelay: p0, disabled: p1, openDelay: p2, ...restProps } = props;
+
+  useLayoutEffect(() => {
+    const element = elementRef.current as Record<string, unknown> | null;
+    if (!element) return;
+    Object.assign(element, { closeDelay: p0, disabled: p1, openDelay: p2 });
+  });
+
+  const mergedRef = useCallback(
+    (element: TooltipTriggerElement | null) => {
+      elementRef.current = element;
+      if (typeof forwardedRef === 'function') {
+        forwardedRef(element);
+      } else if (forwardedRef) {
+        forwardedRef.current = element;
+      }
+    },
+    [forwardedRef],
+  );
+
+  return createElement('prosekit-tooltip-trigger', { ...restProps, ref: mergedRef, suppressHydrationWarning: true });
+}
 
 /**
- * Props for the {@link TooltipTrigger} component.
+ * A Preact component that renders an `prosekit-tooltip-trigger` custom element.
+ *
+ * @public
  */
-export interface TooltipTriggerProps extends Partial<CreateProps<Props, Events>> {}
-
-export const TooltipTrigger: ForwardRefExoticComponent<
-  Partial<TooltipTriggerProps> &
-  RefAttributes<TooltipTriggerElement> &
-  HTMLAttributes<TooltipTriggerElement>
-> = createComponent<
-  TooltipTriggerProps,
-  TooltipTriggerElement
->(
-  'prosekit-tooltip-trigger',
-  'TooltipTrigger',
-  Object.keys(tooltipTriggerProps),
-  Object.keys(tooltipTriggerEvents),
-)
+export const TooltipTrigger: ForwardRefExoticComponent<TooltipTriggerProps & RefAttributes<TooltipTriggerElement>> = /* @__PURE__ */ forwardRef(TooltipTriggerComponent);