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

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 {}

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

@@ -1,18 +0,0 @@
-import { defineCustomElement, registerCustomElement, type BaseElementConstructor } from "@aria-ui/core"
-
-import { useTooltipTrigger } from "./setup.ts"
-import { tooltipTriggerEvents, tooltipTriggerProps, type TooltipTriggerEvents, type TooltipTriggerProps } from "./types.ts"
-
-const TooltipTriggerElementBase: BaseElementConstructor<TooltipTriggerProps> = defineCustomElement<
-  TooltipTriggerProps,
-  TooltipTriggerEvents
->({
-  props: tooltipTriggerProps,
-  events: tooltipTriggerEvents,
-  setup: useTooltipTrigger,
-})
-class TooltipTriggerElement extends TooltipTriggerElementBase {}
-
-registerCustomElement('prosekit-tooltip-trigger', TooltipTriggerElement)
-  
-export { TooltipTriggerElement }

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

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

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

@@ -1,6 +0,0 @@
-import type { TooltipTriggerEvents as Events, TooltipTriggerProps as Props } from '@aria-ui/tooltip/elements'
-
-export { tooltipTriggerEvents, tooltipTriggerProps } from '@aria-ui/tooltip/elements'
-
-export interface TooltipTriggerProps extends Props {}
-export interface TooltipTriggerEvents extends Events {}

package/src/hooks/use-first-rendering.ts

@@ -1,15 +0,0 @@
-import { createSignal, useEffect, type ConnectableElement, type ReadonlySignal } from '@aria-ui/core'
-
-export function useFirstRendering(
-  host: ConnectableElement,
-): ReadonlySignal<boolean> {
-  const firstRendering = createSignal(true)
-
-  useEffect(host, () => {
-    requestAnimationFrame(() => {
-      firstRendering.set(false)
-    })
-  })
-
-  return firstRendering
-}

package/src/utils/get-default-state.spec.ts

@@ -1,42 +0,0 @@
-import { createSignal, type PropDeclarations, type SignalState } from '@aria-ui/core'
-import { describe, expect, it } from 'vitest'
-
-import { getStateWithDefaults } from './get-default-state.ts'
-
-type TestProps = {
-  bool: boolean
-  num: number
-}
-
-describe('getStateWithDefaults', () => {
-  it('keeps falsy signal values from state', () => {
-    const props: PropDeclarations<TestProps> = {
-      bool: { default: true },
-      num: { default: 1 },
-    }
-
-    const state: Partial<SignalState<TestProps>> = {
-      bool: createSignal(false),
-      num: createSignal(0),
-    }
-
-    const merged = getStateWithDefaults(state, props)
-    expect(merged.bool.get()).toBe(false)
-    expect(merged.num.get()).toBe(0)
-  })
-
-  it('uses default value when state property is undefined', () => {
-    const props: PropDeclarations<TestProps> = {
-      bool: { default: true },
-      num: { default: 1 },
-    }
-
-    const state: Partial<SignalState<TestProps>> = {
-      bool: undefined,
-    }
-
-    const merged = getStateWithDefaults(state, props)
-    expect(merged.bool.get()).toBe(true)
-    expect(merged.num.get()).toBe(1)
-  })
-})

package/src/utils/get-default-state.ts

@@ -1,18 +0,0 @@
-import { createSignal, type PropDeclarations, type SignalState } from '@aria-ui/core'
-
-export function getStateWithDefaults<
-  Props extends Record<string, any> = Record<string, any>,
->(
-  state: Partial<SignalState<Props>>,
-  props: PropDeclarations<Props>,
-): SignalState<Props> {
-  const merged = { ...state } as SignalState<Props>
-
-  for (const key of Object.keys(props) as (keyof Props)[]) {
-    if (!merged[key]) {
-      merged[key] = createSignal(props[key].default)
-    }
-  }
-
-  return merged
-}