@prosekit/web 0.8.0-beta.0 → 0.8.0-beta.2

package/src/components/table-handle/table-handle-popover-content/element.gen.ts

@@ -1,18 +0,0 @@
-import { defineCustomElement, registerCustomElement, type BaseElementConstructor } from "@aria-ui/core"
-
-import { useTableHandlePopoverContent } from "./setup.ts"
-import { tableHandlePopoverContentEvents, tableHandlePopoverContentProps, type TableHandlePopoverContentEvents, type TableHandlePopoverContentProps } from "./types.ts"
-
-const TableHandlePopoverContentElementBase: BaseElementConstructor<TableHandlePopoverContentProps> = defineCustomElement<
-  TableHandlePopoverContentProps,
-  TableHandlePopoverContentEvents
->({
-  props: tableHandlePopoverContentProps,
-  events: tableHandlePopoverContentEvents,
-  setup: useTableHandlePopoverContent,
-})
-class TableHandlePopoverContentElement extends TableHandlePopoverContentElementBase {}
-
-registerCustomElement('prosekit-table-handle-popover-content', TableHandlePopoverContentElement)
-  
-export { TableHandlePopoverContentElement }

package/src/components/table-handle/table-handle-popover-content/setup.ts

@@ -1,83 +0,0 @@
-import {
-  createComputed,
-  createSignal,
-  useEffect,
-  type ConnectableElement,
-  type ReadonlySignal,
-  type SetupOptions,
-  type SignalState,
-  type TypedEventTarget,
-} from '@aria-ui/core'
-import { menuContentProps, useMenuContent, type MenuContentProps } from '@aria-ui/menu/elements'
-
-import { getStateWithDefaults } from '../../../utils/get-default-state.ts'
-import { tableHandleRootContext } from '../context.ts'
-
-import type { TableHandlePopoverContentEvents, TableHandlePopoverContentProps } from './types.ts'
-
-/**
- * @internal
- */
-export function useTableHandlePopoverContent(
-  host: ConnectableElement,
-  {
-    state,
-    emit,
-  }: SetupOptions<
-    TableHandlePopoverContentProps,
-    TableHandlePopoverContentEvents
-  >,
-): void {
-  const rootContext = tableHandleRootContext.consume(host)
-  const open = createComputed(() => !!rootContext.get())
-  const keyDownTarget = useKeyDownTarget(host, open)
-
-  const menuContentState: SignalState<MenuContentProps> = getStateWithDefaults(
-    {
-      placement: state.placement,
-      offset: state.offset,
-      eventTarget: createSignal(keyDownTarget),
-    },
-    menuContentProps,
-  )
-
-  useMenuContent(host, { state: menuContentState, emit })
-}
-
-function useKeyDownTarget(
-  element: ConnectableElement,
-  open: ReadonlySignal<boolean>,
-): TypedEventTarget<'keydown'> {
-  const keydownHandlers: Array<(event: KeyboardEvent) => void> = []
-
-  useEffect(element, () => {
-    const handleKeydown = (event: KeyboardEvent) => {
-      if (event.isComposing || event.defaultPrevented || !open.get()) {
-        return false
-      }
-      keydownHandlers.forEach((handler) => handler(event))
-    }
-
-    document.addEventListener('keydown', handleKeydown)
-
-    return () => {
-      document.removeEventListener('keydown', handleKeydown)
-    }
-  })
-
-  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)
-        }
-      }
-    },
-  }
-}

package/src/components/table-handle/table-handle-popover-content/types.ts

@@ -1,32 +0,0 @@
-import type { EventDeclarations, PropDeclarations } from '@aria-ui/core'
-import { menuContentEvents, menuContentProps, type MenuContentEvents, type MenuContentProps } from '@aria-ui/menu/elements'
-import type { Editor } from '@prosekit/core'
-
-export interface TableHandlePopoverContentProps extends Omit<MenuContentProps, 'placement' | 'offset'> {
-  /**
-   * @default 'bottom-start'
-   */
-  placement: MenuContentProps['placement']
-
-  /**
-   * @default {mainAxis: -4, crossAxis: 4}
-   */
-  offset: MenuContentProps['offset']
-
-  editor: Editor | null
-}
-
-/** @internal */
-export const tableHandlePopoverContentProps: PropDeclarations<TableHandlePopoverContentProps> = Object.freeze({
-  ...menuContentProps,
-  placement: { default: 'right-start' },
-  offset: { default: { mainAxis: -4, crossAxis: 4 } },
-  editor: { default: null },
-})
-
-export interface TableHandlePopoverContentEvents extends MenuContentEvents {}
-
-/** @internal */
-export const tableHandlePopoverContentEvents: EventDeclarations<TableHandlePopoverContentEvents> = Object.freeze({
-  ...menuContentEvents,
-})

package/src/components/table-handle/table-handle-popover-item/element.gen.ts

@@ -1,18 +0,0 @@
-import { defineCustomElement, registerCustomElement, type BaseElementConstructor } from "@aria-ui/core"
-
-import { useTableHandlePopoverItem } from "./setup.ts"
-import { tableHandlePopoverItemEvents, tableHandlePopoverItemProps, type TableHandlePopoverItemEvents, type TableHandlePopoverItemProps } from "./types.ts"
-
-const TableHandlePopoverItemElementBase: BaseElementConstructor<TableHandlePopoverItemProps> = defineCustomElement<
-  TableHandlePopoverItemProps,
-  TableHandlePopoverItemEvents
->({
-  props: tableHandlePopoverItemProps,
-  events: tableHandlePopoverItemEvents,
-  setup: useTableHandlePopoverItem,
-})
-class TableHandlePopoverItemElement extends TableHandlePopoverItemElementBase {}
-
-registerCustomElement('prosekit-table-handle-popover-item', TableHandlePopoverItemElement)
-  
-export { TableHandlePopoverItemElement }

package/src/components/table-handle/table-handle-popover-item/setup.ts

@@ -1,17 +0,0 @@
-import type { ConnectableElement, SetupOptions } from '@aria-ui/core'
-import { useMenuItem } from '@aria-ui/menu/elements'
-
-import type { TableHandlePopoverItemEvents, TableHandlePopoverItemProps } from './types.ts'
-
-/**
- * @internal
- */
-export function useTableHandlePopoverItem(
-  element: ConnectableElement,
-  {
-    state,
-    emit,
-  }: SetupOptions<TableHandlePopoverItemProps, TableHandlePopoverItemEvents>,
-): void {
-  useMenuItem(element, { state, emit })
-}

package/src/components/table-handle/table-handle-popover-item/types.ts

@@ -1,16 +0,0 @@
-import type { EventDeclarations, PropDeclarations } from '@aria-ui/core'
-import { menuItemEvents, menuItemProps, type MenuItemEvents, type MenuItemProps } from '@aria-ui/menu'
-
-export interface TableHandlePopoverItemProps extends MenuItemProps {}
-
-/** @internal */
-export const tableHandlePopoverItemProps: PropDeclarations<TableHandlePopoverItemProps> = {
-  ...menuItemProps,
-}
-
-export interface TableHandlePopoverItemEvents extends MenuItemEvents {}
-
-/** @internal */
-export const tableHandlePopoverItemEvents: EventDeclarations<TableHandlePopoverItemEvents> = {
-  ...menuItemEvents,
-}

package/src/components/table-handle/table-handle-root/element.gen.ts

@@ -1,18 +0,0 @@
-import { defineCustomElement, registerCustomElement, type BaseElementConstructor } from "@aria-ui/core"
-
-import { useTableHandleRoot } from "./setup.ts"
-import { tableHandleRootEvents, tableHandleRootProps, type TableHandleRootEvents, type TableHandleRootProps } from "./types.ts"
-
-const TableHandleRootElementBase: BaseElementConstructor<TableHandleRootProps> = defineCustomElement<
-  TableHandleRootProps,
-  TableHandleRootEvents
->({
-  props: tableHandleRootProps,
-  events: tableHandleRootEvents,
-  setup: useTableHandleRoot,
-})
-class TableHandleRootElement extends TableHandleRootElementBase {}
-
-registerCustomElement('prosekit-table-handle-root', TableHandleRootElement)
-  
-export { TableHandleRootElement }

package/src/components/table-handle/table-handle-root/setup.ts

@@ -1,86 +0,0 @@
-import {
-  createComputed,
-  createSignal,
-  useEffect,
-  type ConnectableElement,
-  type ReadonlySignal,
-  type Signal,
-  type SignalState,
-} from '@aria-ui/core'
-import { defineDOMEventHandler, type Editor } from '@prosekit/core'
-import type { EditorView } from '@prosekit/pm/view'
-
-import { useEditorExtension } from '../../../hooks/use-editor-extension.ts'
-import { useEditorTyping } from '../../../hooks/use-editor-typing.ts'
-import { useScrolling } from '../../../hooks/use-scrolling.ts'
-import { useSelecting } from '../../../hooks/use-selecting.ts'
-import {
-  defaultTableHandleDndContext,
-  tableHandleDndContext,
-  tableHandleRootContext,
-  type TableHandleDndContext,
-  type TableHandleRootContext,
-} from '../context.ts'
-import { useDrop } from '../hooks/use-drop.ts'
-import { getHoveringCell, isHoveringCellInfoEqual, type HoveringCellInfo } from '../utils.ts'
-
-import type { TableHandleRootProps } from './types.ts'
-
-/**
- * @internal
- */
-export function useTableHandleRoot(
-  host: ConnectableElement,
-  { state }: { state: SignalState<TableHandleRootProps> },
-): void {
-  const { editor } = state
-
-  const context = createSignal<TableHandleRootContext>(null)
-  const dndContext = createSignal<TableHandleDndContext>(defaultTableHandleDndContext)
-
-  const hoveringCell = useHoveringCell(host, editor)
-  const typing = useEditorTyping(host, editor)
-  const isInTable = createComputed(() => !!hoveringCell.get())
-  const selecting = useSelecting(host, editor, isInTable)
-  const scrolling = useScrolling(host)
-  const canShow = createComputed(() => {
-    return !typing.get() && !selecting.get() && !scrolling.get()
-  })
-
-  useEffect(host, () => {
-    context.set(canShow.get() ? hoveringCell.get() : null)
-  })
-
-  tableHandleRootContext.provide(host, context)
-  tableHandleDndContext.provide(host, dndContext)
-
-  useDrop(host, editor, dndContext)
-}
-
-function useHoveringCell(
-  host: ConnectableElement,
-  editor: ReadonlySignal<Editor | null>,
-): Signal<HoveringCellInfo | null> {
-  const hoveringCell = createSignal<HoveringCellInfo | null>(null)
-
-  const extension = defineCellHoverHandler((curr: HoveringCellInfo | null) => {
-    const prev = hoveringCell.peek()
-    if (!isHoveringCellInfoEqual(prev, curr)) {
-      hoveringCell.set(curr)
-    }
-  })
-
-  useEditorExtension(host, editor, extension)
-
-  return hoveringCell
-}
-
-function defineCellHoverHandler(
-  handler: (hoveringCell: HoveringCellInfo | null) => void,
-) {
-  const pointerHandler = (view: EditorView, event: PointerEvent) => {
-    const hoveringCell = getHoveringCell(view, event)
-    return handler(hoveringCell ?? null)
-  }
-  return defineDOMEventHandler('pointerover', pointerHandler)
-}

package/src/components/table-handle/table-handle-root/types.ts

@@ -1,23 +0,0 @@
-import type { EventDeclarations, PropDeclarations } from '@aria-ui/core'
-import type { Editor } from '@prosekit/core'
-
-export interface TableHandleRootProps {
-  /**
-   * The ProseKit editor instance.
-   *
-   * @default null
-   * @hidden
-   */
-  editor: Editor | null
-}
-
-/** @internal */
-export const tableHandleRootProps: PropDeclarations<TableHandleRootProps> = {
-  editor: { default: null },
-}
-
-/** @internal */
-export interface TableHandleRootEvents {}
-
-/** @internal */
-export const tableHandleRootEvents: EventDeclarations<TableHandleRootEvents> = {}

package/src/components/table-handle/table-handle-row-root/element.gen.ts

@@ -1,18 +0,0 @@
-import { defineCustomElement, registerCustomElement, type BaseElementConstructor } from "@aria-ui/core"
-
-import { useTableHandleRowRoot } from "./setup.ts"
-import { tableHandleRowRootEvents, tableHandleRowRootProps, type TableHandleRowRootEvents, type TableHandleRowRootProps } from "./types.ts"
-
-const TableHandleRowRootElementBase: BaseElementConstructor<TableHandleRowRootProps> = defineCustomElement<
-  TableHandleRowRootProps,
-  TableHandleRowRootEvents
->({
-  props: tableHandleRowRootProps,
-  events: tableHandleRowRootEvents,
-  setup: useTableHandleRowRoot,
-})
-class TableHandleRowRootElement extends TableHandleRowRootElementBase {}
-
-registerCustomElement('prosekit-table-handle-row-root', TableHandleRowRootElement)
-  
-export { TableHandleRowRootElement }

package/src/components/table-handle/table-handle-row-root/setup.ts

@@ -1,70 +0,0 @@
-import {
-  createComputed,
-  createSignal,
-  defineEmit,
-  useAttribute,
-  useEffect,
-  type ConnectableElement,
-  type SetupOptions,
-} from '@aria-ui/core'
-import { menuRootEvents, menuRootProps, useMenuRoot } from '@aria-ui/menu/elements'
-import { useOverlayPositionerState } from '@aria-ui/overlay/elements'
-import { usePresence } from '@aria-ui/presence'
-
-import { getStateWithDefaults } from '../../../utils/get-default-state.ts'
-import { getSafeEditorView } from '../../../utils/get-safe-editor-view.ts'
-import { tableHandleRootContext } from '../context.ts'
-
-import type { TableHandleRowRootEvents, TableHandleRowRootProps } from './types.ts'
-
-/**
- * @internal
- */
-export function useTableHandleRowRoot(
-  host: ConnectableElement,
-  { state }: SetupOptions<TableHandleRowRootProps, TableHandleRowRootEvents>,
-): void {
-  const { editor, ...overlayState } = state
-
-  const rootContext = tableHandleRootContext.consume(host)
-
-  const rowFirstCellPos = createComputed<number | undefined>(() => {
-    return rootContext.get()?.rowFirstCellPos
-  })
-
-  const referenceCell = createComputed<HTMLElement | null>(() => {
-    const pos = rowFirstCellPos.get()
-    const view = getSafeEditorView(editor.get())
-    if (!pos || !view) return null
-    return view.nodeDOM(pos) as HTMLElement | null
-  })
-
-  const contentOpen = createSignal(false)
-
-  // Close the menu when the hovering element is changed
-  // TODO: add a delay
-  useEffect(host, () => {
-    rowFirstCellPos.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)
-
-  const menuRootState = getStateWithDefaults(
-    {
-      open: contentOpen,
-    },
-    menuRootProps,
-  )
-
-  useMenuRoot(host, {
-    state: menuRootState,
-    emit: defineEmit(host, menuRootEvents),
-  })
-}

package/src/components/table-handle/table-handle-row-root/types.ts

@@ -1,68 +0,0 @@
-import type { EventDeclarations, PropDeclarations } from '@aria-ui/core'
-import { overlayPositionerProps, type OverlayPositionerEvents, type OverlayPositionerProps } from '@aria-ui/overlay'
-import type { Placement } from '@floating-ui/dom'
-import type { Editor } from '@prosekit/core'
-
-export interface TableHandleRowRootProps extends Omit<OverlayPositionerProps, 'placement' | 'hoist' | 'flip' | 'shift' | 'hide'> {
-  /**
-   * The ProseKit editor instance.
-   *
-   * @default null
-   * @hidden
-   */
-  editor: Editor | null
-
-  /**
-   * The placement of the popover, relative to the hovered table cell.
-   *
-   * @default "left"
-   */
-  placement: Placement
-
-  /**
-   * 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: boolean
-
-  /**
-   * @default false
-   * @hidden
-   */
-  flip: boolean
-
-  /**
-   * @default false
-   * @hidden
-   */
-  shift: boolean
-
-  /**
-   * @default true
-   * @hidden
-   */
-  hide: boolean
-}
-
-/** @internal */
-export const tableHandleRowRootProps: PropDeclarations<TableHandleRowRootProps> = {
-  ...overlayPositionerProps,
-  editor: { default: null },
-  placement: { default: 'left' },
-
-  // Enabling `hoist` will cause the popover to have a small delay when
-  // scrolling the page.
-  hoist: { default: false },
-
-  flip: { default: false },
-  shift: { default: false },
-  hide: { default: true },
-}
-
-/** @internal */
-export interface TableHandleRowRootEvents extends OverlayPositionerEvents {}
-
-/** @internal */
-export const tableHandleRowRootEvents: EventDeclarations<TableHandleRowRootEvents> = {}

package/src/components/table-handle/table-handle-row-trigger/element.gen.ts

@@ -1,18 +0,0 @@
-import { defineCustomElement, registerCustomElement, type BaseElementConstructor } from "@aria-ui/core"
-
-import { useTableHandleRowTrigger } from "./setup.ts"
-import { tableHandleRowTriggerEvents, tableHandleRowTriggerProps, type TableHandleRowTriggerEvents, type TableHandleRowTriggerProps } from "./types.ts"
-
-const TableHandleRowTriggerElementBase: BaseElementConstructor<TableHandleRowTriggerProps> = defineCustomElement<
-  TableHandleRowTriggerProps,
-  TableHandleRowTriggerEvents
->({
-  props: tableHandleRowTriggerProps,
-  events: tableHandleRowTriggerEvents,
-  setup: useTableHandleRowTrigger,
-})
-class TableHandleRowTriggerElement extends TableHandleRowTriggerElementBase {}
-
-registerCustomElement('prosekit-table-handle-row-trigger', TableHandleRowTriggerElement)
-  
-export { TableHandleRowTriggerElement }

package/src/components/table-handle/table-handle-row-trigger/setup.ts

@@ -1,63 +0,0 @@
-import { useEffect, useEventListener, type ConnectableElement, type SetupOptions } from '@aria-ui/core'
-import { useMenuTrigger } from '@aria-ui/menu/elements'
-import { selectTableRow } from '@prosekit/extensions/table'
-
-import { tableHandleDndContext, tableHandleRootContext } from '../context.ts'
-import { useEmptyImage } from '../hooks/use-empty-image.ts'
-
-import type { TableHandleRowTriggerEvents, TableHandleRowTriggerProps } from './types.ts'
-
-/**
- * @internal
- */
-export function useTableHandleRowTrigger(
-  host: ConnectableElement,
-  { state }: SetupOptions<TableHandleRowTriggerProps, TableHandleRowTriggerEvents>,
-): void {
-  useMenuTrigger(host)
-
-  const context = tableHandleRootContext.consume(host)
-
-  const dndContext = tableHandleDndContext.consume(host)
-
-  useEventListener(host, 'pointerdown', () => {
-    const editor = state.editor.peek()
-    const cellPos = context.peek()?.cellPos
-    if (!editor || !cellPos) return
-    editor.exec(selectTableRow({ head: cellPos }))
-  })
-
-  useEffect(host, () => {
-    host.draggable = true
-  })
-
-  const getEmptyImage = useEmptyImage(host)
-
-  useEventListener(host, 'dragstart', (event: DragEvent) => {
-    const dataTransfer = event.dataTransfer
-    if (dataTransfer) {
-      dataTransfer.effectAllowed = 'move'
-      const emptyImage = getEmptyImage()
-      if (emptyImage) {
-        dataTransfer.setDragImage(emptyImage, 0, 0)
-      }
-    }
-    const prev = dndContext.peek()
-    const index = context.peek()?.rowIndex
-
-    if (index == null || index < 0) {
-      console.warn('[prosekit] Invalid row index for drag operation:', index)
-      event.preventDefault()
-      return
-    }
-
-    dndContext.set({
-      ...prev,
-      direction: 'row',
-      dragging: true,
-      draggingIndex: index,
-      startX: event.clientX,
-      startY: event.clientY,
-    })
-  })
-}

package/src/components/table-handle/table-handle-row-trigger/types.ts

@@ -1,23 +0,0 @@
-import type { EventDeclarations, PropDeclarations } from '@aria-ui/core'
-import type { Editor } from '@prosekit/core'
-import type { defineTableCommands } from '@prosekit/extensions/table'
-
-type TableCommandsExtension = ReturnType<typeof defineTableCommands>
-
-export interface TableHandleRowTriggerProps {
-  editor: Editor<TableCommandsExtension> | null
-}
-
-/** @internal */
-export const tableHandleRowTriggerProps: PropDeclarations<TableHandleRowTriggerProps> = {
-  editor: { default: null },
-}
-
-export interface TableHandleRowTriggerEvents {
-  select: CustomEvent<void>
-}
-
-/** @internal */
-export const tableHandleRowTriggerEvents: EventDeclarations<TableHandleRowTriggerEvents> = {
-  select: {},
-}

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

@@ -1,13 +0,0 @@
-// This file is generated by packages/dev/src/gen-components.ts
-
-export { TooltipContentElement } from './tooltip-content/element.gen.ts'
-export { tooltipContentEvents, tooltipContentProps, type TooltipContentEvents, type TooltipContentProps } from './tooltip-content/types.ts'
-export { useTooltipContent } from './tooltip-content/setup.ts'
-
-export { TooltipRootElement } from './tooltip-root/element.gen.ts'
-export { tooltipRootEvents, tooltipRootProps, type TooltipRootEvents, type TooltipRootProps } from './tooltip-root/types.ts'
-export { useTooltipRoot } from './tooltip-root/setup.ts'
-
-export { TooltipTriggerElement } from './tooltip-trigger/element.gen.ts'
-export { tooltipTriggerEvents, tooltipTriggerProps, type TooltipTriggerEvents, type TooltipTriggerProps } from './tooltip-trigger/types.ts'
-export { useTooltipTrigger } from './tooltip-trigger/setup.ts'

package/src/components/tooltip/tooltip-content/element.gen.ts

@@ -1,18 +0,0 @@
-import { defineCustomElement, registerCustomElement, type BaseElementConstructor } from "@aria-ui/core"
-
-import { useTooltipContent } from "./setup.ts"
-import { tooltipContentEvents, tooltipContentProps, type TooltipContentEvents, type TooltipContentProps } from "./types.ts"
-
-const TooltipContentElementBase: BaseElementConstructor<TooltipContentProps> = defineCustomElement<
-  TooltipContentProps,
-  TooltipContentEvents
->({
-  props: tooltipContentProps,
-  events: tooltipContentEvents,
-  setup: useTooltipContent,
-})
-class TooltipContentElement extends TooltipContentElementBase {}
-
-registerCustomElement('prosekit-tooltip-content', TooltipContentElement)
-  
-export { TooltipContentElement }

package/src/components/tooltip/tooltip-content/setup.ts

@@ -1 +0,0 @@
-export { useTooltipContent } from '@aria-ui/tooltip/elements'

package/src/components/tooltip/tooltip-content/types.ts

@@ -1,6 +0,0 @@
-import type { TooltipContentEvents as Events, TooltipContentProps as Props } from '@aria-ui/tooltip/elements'
-
-export { tooltipContentEvents, tooltipContentProps } from '@aria-ui/tooltip/elements'
-
-export interface TooltipContentProps extends Props {}
-export interface TooltipContentEvents extends Events {}

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

@@ -1,18 +0,0 @@
-import { defineCustomElement, registerCustomElement, type BaseElementConstructor } from "@aria-ui/core"
-
-import { useTooltipRoot } from "./setup.ts"
-import { tooltipRootEvents, tooltipRootProps, type TooltipRootEvents, type TooltipRootProps } from "./types.ts"
-
-const TooltipRootElementBase: BaseElementConstructor<TooltipRootProps> = defineCustomElement<
-  TooltipRootProps,
-  TooltipRootEvents
->({
-  props: tooltipRootProps,
-  events: tooltipRootEvents,
-  setup: useTooltipRoot,
-})
-class TooltipRootElement extends TooltipRootElementBase {}
-
-registerCustomElement('prosekit-tooltip-root', TooltipRootElement)
-  
-export { TooltipRootElement }

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

@@ -1 +0,0 @@
-export { useTooltipRoot } from '@aria-ui/tooltip/elements'

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

@@ -1,6 +0,0 @@
-import type { TooltipRootEvents as Events, TooltipRootProps as Props } from '@aria-ui/tooltip/elements'
-
-export { tooltipRootEvents, tooltipRootProps } from '@aria-ui/tooltip/elements'
-
-export interface TooltipRootProps extends Props {}
-export interface TooltipRootEvents extends Events {}