@prosekit/preact 0.5.0 → 0.6.0

package/src/components/autocomplete/autocomplete-popover.gen.ts

@@ -0,0 +1,34 @@
+import {
+  type AutocompletePopoverElement,
+  type AutocompletePopoverProps as Props,
+  type AutocompletePopoverEvents as Events,
+  autocompletePopoverProps,
+  autocompletePopoverEvents,
+} from '@prosekit/web/autocomplete'
+import type {
+  ForwardRefExoticComponent,
+  HTMLAttributes,
+  RefAttributes,
+} from 'preact/compat'
+
+import { createComponent } from '../create-component'
+import type { CreateProps } from '../create-props'
+
+/**
+ * Props for the {@link AutocompletePopover} component.
+ */
+export interface AutocompletePopoverProps extends Partial<CreateProps<Props, Events>> {}
+ 
+export const AutocompletePopover: ForwardRefExoticComponent<
+  Partial<AutocompletePopoverProps> &
+  RefAttributes<AutocompletePopoverElement> &
+  HTMLAttributes<AutocompletePopoverElement>
+> = createComponent<
+  AutocompletePopoverProps, 
+  AutocompletePopoverElement
+>(
+  'prosekit-autocomplete-popover',
+  'AutocompletePopover',
+  Object.keys(autocompletePopoverProps),
+  Object.keys(autocompletePopoverEvents),
+)

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

@@ -0,0 +1,7 @@
+export { AutocompleteEmpty, type AutocompleteEmptyProps } from './autocomplete-empty.gen'
+
+export { AutocompleteItem, type AutocompleteItemProps } from './autocomplete-item.gen'
+
+export { AutocompleteList, type AutocompleteListProps } from './autocomplete-list.gen'
+
+export { AutocompletePopover, type AutocompletePopoverProps } from './autocomplete-popover.gen'

package/src/components/block-handle/block-handle-add.gen.ts

@@ -0,0 +1,34 @@
+import {
+  type BlockHandleAddElement,
+  type BlockHandleAddProps as Props,
+  type BlockHandleAddEvents as Events,
+  blockHandleAddProps,
+  blockHandleAddEvents,
+} from '@prosekit/web/block-handle'
+import type {
+  ForwardRefExoticComponent,
+  HTMLAttributes,
+  RefAttributes,
+} from 'preact/compat'
+
+import { createComponent } from '../create-component'
+import type { CreateProps } from '../create-props'
+
+/**
+ * Props for the {@link BlockHandleAdd} component.
+ */
+export interface BlockHandleAddProps extends Partial<CreateProps<Props, Events>> {}
+ 
+export const BlockHandleAdd: ForwardRefExoticComponent<
+  Partial<BlockHandleAddProps> &
+  RefAttributes<BlockHandleAddElement> &
+  HTMLAttributes<BlockHandleAddElement>
+> = createComponent<
+  BlockHandleAddProps, 
+  BlockHandleAddElement
+>(
+  'prosekit-block-handle-add',
+  'BlockHandleAdd',
+  Object.keys(blockHandleAddProps),
+  Object.keys(blockHandleAddEvents),
+)

package/src/components/block-handle/block-handle-draggable.gen.ts

@@ -0,0 +1,34 @@
+import {
+  type BlockHandleDraggableElement,
+  type BlockHandleDraggableProps as Props,
+  type BlockHandleDraggableEvents as Events,
+  blockHandleDraggableProps,
+  blockHandleDraggableEvents,
+} from '@prosekit/web/block-handle'
+import type {
+  ForwardRefExoticComponent,
+  HTMLAttributes,
+  RefAttributes,
+} from 'preact/compat'
+
+import { createComponent } from '../create-component'
+import type { CreateProps } from '../create-props'
+
+/**
+ * Props for the {@link BlockHandleDraggable} component.
+ */
+export interface BlockHandleDraggableProps extends Partial<CreateProps<Props, Events>> {}
+ 
+export const BlockHandleDraggable: ForwardRefExoticComponent<
+  Partial<BlockHandleDraggableProps> &
+  RefAttributes<BlockHandleDraggableElement> &
+  HTMLAttributes<BlockHandleDraggableElement>
+> = createComponent<
+  BlockHandleDraggableProps, 
+  BlockHandleDraggableElement
+>(
+  'prosekit-block-handle-draggable',
+  'BlockHandleDraggable',
+  Object.keys(blockHandleDraggableProps),
+  Object.keys(blockHandleDraggableEvents),
+)

package/src/components/block-handle/block-handle-popover.gen.ts

@@ -0,0 +1,34 @@
+import {
+  type BlockHandlePopoverElement,
+  type BlockHandlePopoverProps as Props,
+  type BlockHandlePopoverEvents as Events,
+  blockHandlePopoverProps,
+  blockHandlePopoverEvents,
+} from '@prosekit/web/block-handle'
+import type {
+  ForwardRefExoticComponent,
+  HTMLAttributes,
+  RefAttributes,
+} from 'preact/compat'
+
+import { createComponent } from '../create-component'
+import type { CreateProps } from '../create-props'
+
+/**
+ * Props for the {@link BlockHandlePopover} component.
+ */
+export interface BlockHandlePopoverProps extends Partial<CreateProps<Props, Events>> {}
+ 
+export const BlockHandlePopover: ForwardRefExoticComponent<
+  Partial<BlockHandlePopoverProps> &
+  RefAttributes<BlockHandlePopoverElement> &
+  HTMLAttributes<BlockHandlePopoverElement>
+> = createComponent<
+  BlockHandlePopoverProps, 
+  BlockHandlePopoverElement
+>(
+  'prosekit-block-handle-popover',
+  'BlockHandlePopover',
+  Object.keys(blockHandlePopoverProps),
+  Object.keys(blockHandlePopoverEvents),
+)

package/src/components/block-handle/index.gen.ts

@@ -0,0 +1,5 @@
+export { BlockHandleAdd, type BlockHandleAddProps } from './block-handle-add.gen'
+
+export { BlockHandleDraggable, type BlockHandleDraggableProps } from './block-handle-draggable.gen'
+
+export { BlockHandlePopover, type BlockHandlePopoverProps } from './block-handle-popover.gen'

package/src/components/create-component.ts

@@ -0,0 +1,135 @@
+import type { AnyFunction } from '@prosekit/core'
+import { createElement } from 'preact'
+import {
+  forwardRef,
+  type ForwardRefExoticComponent,
+  type HTMLAttributes,
+  type RefAttributes,
+} from 'preact/compat'
+import {
+  useEffect,
+  useLayoutEffect,
+  useMemo,
+  useRef,
+  useState,
+} from 'preact/hooks'
+
+import { useEditorContext } from '../contexts/editor-context'
+
+import { mergeRefs } from './merge-refs'
+
+const useIsomorphicLayoutEffect = typeof window !== 'undefined' ? useLayoutEffect : useEffect
+
+export function createComponent<
+  Props extends object,
+  CustomElement extends HTMLElement,
+>(
+  tagName: string,
+  displayName: string,
+  propNames: string[],
+  eventNames: string[],
+): ForwardRefExoticComponent<
+  Partial<Props> & RefAttributes<CustomElement> & HTMLAttributes<CustomElement>
+> {
+  const hasEditor = propNames.includes('editor')
+  const lowerCaseEventNameMap = new Map(
+    eventNames.map((name) => [name.toLowerCase(), name]),
+  )
+
+  const Component = forwardRef<any, any>((props: Props, ref) => {
+    const [el, setEl] = useState<HTMLElement | null>(null)
+
+    const properties: Record<string, unknown> = {}
+    const attributes: Record<string, unknown> = {}
+    const eventHandlersRef = useRef<Record<string, AnyFunction>>({})
+    const eventHandlers: Record<string, AnyFunction> = {}
+
+    for (const [name, value] of Object.entries(props)) {
+      if (value === undefined) {
+        continue
+      }
+
+      if (propNames.includes(name)) {
+        properties[name] = value
+        continue
+      }
+
+      if (name.startsWith('on')) {
+        const lowerCaseEventName = name.slice(2).toLowerCase()
+        const eventName = lowerCaseEventNameMap.get(lowerCaseEventName)
+        if (eventName) {
+          const extractDetail = eventName.endsWith('Change')
+          eventHandlers[eventName] = (event: Event) => {
+            const handler = value as AnyFunction | null
+            if (typeof handler === 'function') {
+              handler(extractDetail ? (event as CustomEvent).detail : event)
+            }
+          }
+          continue
+        }
+      }
+
+      if (name === 'className') {
+        attributes['class'] = value
+      } else {
+        attributes[name] = value
+      }
+    }
+
+    const editor = useEditorContext()
+
+    if (hasEditor && editor && !properties['editor']) {
+      properties['editor'] = editor
+    }
+
+    // Set all properties.
+    useIsomorphicLayoutEffect(() => {
+      if (!el) return
+      for (const [name, value] of Object.entries(properties)) {
+        if (value !== undefined) {
+          // @ts-expect-error: we know that name is a valid property name
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          el[name] = value as unknown as any
+        }
+      }
+    }, [el, ...propNames.map((name) => properties[name])])
+
+    // Put all event listeners extracted from `props` into `eventHandlersRef`.
+    useIsomorphicLayoutEffect(() => {
+      eventHandlersRef.current = eventHandlers
+    })
+
+    // Register the event listeners to the element.
+    useIsomorphicLayoutEffect(() => {
+      if (!el) {
+        return
+      }
+
+      const fixedEventHandlers: Record<string, AnyFunction> = {}
+
+      for (const eventName of eventNames) {
+        fixedEventHandlers[eventName] = (event: Event) => {
+          eventHandlersRef.current[eventName]?.(event)
+        }
+      }
+
+      for (const [name, handler] of Object.entries(fixedEventHandlers)) {
+        el.addEventListener(name, handler)
+      }
+
+      return () => {
+        for (const [name, handler] of Object.entries(fixedEventHandlers)) {
+          el.removeEventListener(name, handler)
+        }
+      }
+    }, [el])
+
+    const mergedRef = useMemo(() => mergeRefs([ref, setEl]), [ref])
+
+    return createElement(tagName, { ...attributes, ref: mergedRef })
+  })
+
+  Component.displayName = displayName
+
+  return Component
+}

package/src/components/create-props.ts

@@ -0,0 +1,13 @@
+export type CreateProps<
+  Props extends { [PropName in keyof Props]: unknown },
+  Events extends { [EventName in keyof Events]: CustomEvent },
+> = Props & CreateEventProps<Events>
+
+type CreateEventProps<
+  Events extends { [EventName in keyof Events]: CustomEvent },
+> = {
+  [EventName in keyof Events as `on${Capitalize<string & EventName>}`]: (
+    event: EventName extends `${string}Change` ? Events[EventName]['detail']
+      : Events[EventName],
+  ) => void
+}

package/src/components/drop-indicator/drop-indicator.gen.ts

@@ -0,0 +1,34 @@
+import {
+  type DropIndicatorElement,
+  type DropIndicatorProps as Props,
+  type DropIndicatorEvents as Events,
+  dropIndicatorProps,
+  dropIndicatorEvents,
+} from '@prosekit/web/drop-indicator'
+import type {
+  ForwardRefExoticComponent,
+  HTMLAttributes,
+  RefAttributes,
+} from 'preact/compat'
+
+import { createComponent } from '../create-component'
+import type { CreateProps } from '../create-props'
+
+/**
+ * Props for the {@link DropIndicator} component.
+ */
+export interface DropIndicatorProps extends Partial<CreateProps<Props, Events>> {}
+ 
+export const DropIndicator: ForwardRefExoticComponent<
+  Partial<DropIndicatorProps> &
+  RefAttributes<DropIndicatorElement> &
+  HTMLAttributes<DropIndicatorElement>
+> = createComponent<
+  DropIndicatorProps, 
+  DropIndicatorElement
+>(
+  'prosekit-drop-indicator',
+  'DropIndicator',
+  Object.keys(dropIndicatorProps),
+  Object.keys(dropIndicatorEvents),
+)

package/src/components/drop-indicator/index.gen.ts

@@ -0,0 +1 @@
+export { DropIndicator, type DropIndicatorProps } from './drop-indicator.gen'

package/src/components/inline-popover/index.gen.ts

@@ -0,0 +1 @@
+export { InlinePopover, type InlinePopoverProps } from './inline-popover.gen'

package/src/components/inline-popover/inline-popover.gen.ts

@@ -0,0 +1,34 @@
+import {
+  type InlinePopoverElement,
+  type InlinePopoverProps as Props,
+  type InlinePopoverEvents as Events,
+  inlinePopoverProps,
+  inlinePopoverEvents,
+} from '@prosekit/web/inline-popover'
+import type {
+  ForwardRefExoticComponent,
+  HTMLAttributes,
+  RefAttributes,
+} from 'preact/compat'
+
+import { createComponent } from '../create-component'
+import type { CreateProps } from '../create-props'
+
+/**
+ * Props for the {@link InlinePopover} component.
+ */
+export interface InlinePopoverProps extends Partial<CreateProps<Props, Events>> {}
+ 
+export const InlinePopover: ForwardRefExoticComponent<
+  Partial<InlinePopoverProps> &
+  RefAttributes<InlinePopoverElement> &
+  HTMLAttributes<InlinePopoverElement>
+> = createComponent<
+  InlinePopoverProps, 
+  InlinePopoverElement
+>(
+  'prosekit-inline-popover',
+  'InlinePopover',
+  Object.keys(inlinePopoverProps),
+  Object.keys(inlinePopoverEvents),
+)

package/src/components/merge-refs.ts

@@ -0,0 +1,35 @@
+import type { Ref } from 'preact'
+
+/**
+ * Assigns a value to a ref.
+ * @returns The ref cleanup callback, if any.
+ */
+function assignRef<T>(
+  ref: Ref<T> | undefined,
+  value: T | null,
+): VoidFunction | undefined | void {
+  if (typeof ref === 'function') {
+    return ref(value)
+  } else if (ref) {
+    ref.current = value
+  }
+}
+
+/**
+ * Merges multiple refs into a single one.
+ */
+export function mergeRefs<T>(refs: (Ref<T> | undefined)[]): Ref<T> {
+  return (value: T | null) => {
+    const cleanups: VoidFunction[] = []
+
+    for (const ref of refs) {
+      const cleanup = assignRef(ref, value)
+      const isCleanup = typeof cleanup === 'function'
+      cleanups.push(isCleanup ? cleanup : () => assignRef(ref, null))
+    }
+
+    return () => {
+      for (const cleanup of cleanups) cleanup()
+    }
+  }
+}

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

@@ -0,0 +1,5 @@
+export { PopoverContent, type PopoverContentProps } from './popover-content.gen'
+
+export { PopoverRoot, type PopoverRootProps } from './popover-root.gen'
+
+export { PopoverTrigger, type PopoverTriggerProps } from './popover-trigger.gen'

package/src/components/popover/popover-content.gen.ts

@@ -0,0 +1,34 @@
+import {
+  type PopoverContentElement,
+  type PopoverContentProps as Props,
+  type PopoverContentEvents as Events,
+  popoverContentProps,
+  popoverContentEvents,
+} from '@prosekit/web/popover'
+import type {
+  ForwardRefExoticComponent,
+  HTMLAttributes,
+  RefAttributes,
+} from 'preact/compat'
+
+import { createComponent } from '../create-component'
+import type { CreateProps } from '../create-props'
+
+/**
+ * Props for the {@link PopoverContent} component.
+ */
+export interface PopoverContentProps extends Partial<CreateProps<Props, Events>> {}
+ 
+export const PopoverContent: ForwardRefExoticComponent<
+  Partial<PopoverContentProps> &
+  RefAttributes<PopoverContentElement> &
+  HTMLAttributes<PopoverContentElement>
+> = createComponent<
+  PopoverContentProps, 
+  PopoverContentElement
+>(
+  'prosekit-popover-content',
+  'PopoverContent',
+  Object.keys(popoverContentProps),
+  Object.keys(popoverContentEvents),
+)

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

@@ -0,0 +1,34 @@
+import {
+  type PopoverRootElement,
+  type PopoverRootProps as Props,
+  type PopoverRootEvents as Events,
+  popoverRootProps,
+  popoverRootEvents,
+} from '@prosekit/web/popover'
+import type {
+  ForwardRefExoticComponent,
+  HTMLAttributes,
+  RefAttributes,
+} from 'preact/compat'
+
+import { createComponent } from '../create-component'
+import type { CreateProps } from '../create-props'
+
+/**
+ * Props for the {@link PopoverRoot} component.
+ */
+export interface PopoverRootProps extends Partial<CreateProps<Props, Events>> {}
+ 
+export const PopoverRoot: ForwardRefExoticComponent<
+  Partial<PopoverRootProps> &
+  RefAttributes<PopoverRootElement> &
+  HTMLAttributes<PopoverRootElement>
+> = createComponent<
+  PopoverRootProps, 
+  PopoverRootElement
+>(
+  'prosekit-popover-root',
+  'PopoverRoot',
+  Object.keys(popoverRootProps),
+  Object.keys(popoverRootEvents),
+)

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

@@ -0,0 +1,34 @@
+import {
+  type PopoverTriggerElement,
+  type PopoverTriggerProps as Props,
+  type PopoverTriggerEvents as Events,
+  popoverTriggerProps,
+  popoverTriggerEvents,
+} from '@prosekit/web/popover'
+import type {
+  ForwardRefExoticComponent,
+  HTMLAttributes,
+  RefAttributes,
+} from 'preact/compat'
+
+import { createComponent } from '../create-component'
+import type { CreateProps } from '../create-props'
+
+/**
+ * Props for the {@link PopoverTrigger} component.
+ */
+export interface PopoverTriggerProps extends Partial<CreateProps<Props, Events>> {}
+ 
+export const PopoverTrigger: ForwardRefExoticComponent<
+  Partial<PopoverTriggerProps> &
+  RefAttributes<PopoverTriggerElement> &
+  HTMLAttributes<PopoverTriggerElement>
+> = createComponent<
+  PopoverTriggerProps, 
+  PopoverTriggerElement
+>(
+  'prosekit-popover-trigger',
+  'PopoverTrigger',
+  Object.keys(popoverTriggerProps),
+  Object.keys(popoverTriggerEvents),
+)

package/src/components/prosekit.ts

@@ -0,0 +1,37 @@
+import type { Editor } from '@prosekit/core'
+import { ProsemirrorAdapterProvider } from '@prosemirror-adapter/preact'
+import {
+  h,
+  type ComponentChildren,
+  type ComponentType,
+} from 'preact'
+
+import { EditorContextProvider } from '../contexts/editor-context'
+import { PreactMarkViewConsumer } from '../extensions/preact-mark-view'
+import { PreactNodeViewConsumer } from '../extensions/preact-node-view'
+
+export interface ProseKitProps {
+  editor: Editor
+  children?: ComponentChildren
+}
+
+/**
+ * The root component for a ProseKit editor.
+ *
+ * @public
+ */
+export const ProseKit: ComponentType<ProseKitProps> = (props) => {
+  const { editor, children } = props
+
+  return h(
+    ProsemirrorAdapterProvider,
+    null,
+    h(
+      EditorContextProvider,
+      { value: editor },
+      h(PreactNodeViewConsumer, null),
+      h(PreactMarkViewConsumer, null),
+      children,
+    ),
+  )
+}

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

@@ -0,0 +1,3 @@
+export { ResizableHandle, type ResizableHandleProps } from './resizable-handle.gen'
+
+export { ResizableRoot, type ResizableRootProps } from './resizable-root.gen'

package/src/components/resizable/resizable-handle.gen.ts

@@ -0,0 +1,34 @@
+import {
+  type ResizableHandleElement,
+  type ResizableHandleProps as Props,
+  type ResizableHandleEvents as Events,
+  resizableHandleProps,
+  resizableHandleEvents,
+} from '@prosekit/web/resizable'
+import type {
+  ForwardRefExoticComponent,
+  HTMLAttributes,
+  RefAttributes,
+} from 'preact/compat'
+
+import { createComponent } from '../create-component'
+import type { CreateProps } from '../create-props'
+
+/**
+ * Props for the {@link ResizableHandle} component.
+ */
+export interface ResizableHandleProps extends Partial<CreateProps<Props, Events>> {}
+ 
+export const ResizableHandle: ForwardRefExoticComponent<
+  Partial<ResizableHandleProps> &
+  RefAttributes<ResizableHandleElement> &
+  HTMLAttributes<ResizableHandleElement>
+> = createComponent<
+  ResizableHandleProps, 
+  ResizableHandleElement
+>(
+  'prosekit-resizable-handle',
+  'ResizableHandle',
+  Object.keys(resizableHandleProps),
+  Object.keys(resizableHandleEvents),
+)

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

@@ -0,0 +1,34 @@
+import {
+  type ResizableRootElement,
+  type ResizableRootProps as Props,
+  type ResizableRootEvents as Events,
+  resizableRootProps,
+  resizableRootEvents,
+} from '@prosekit/web/resizable'
+import type {
+  ForwardRefExoticComponent,
+  HTMLAttributes,
+  RefAttributes,
+} from 'preact/compat'
+
+import { createComponent } from '../create-component'
+import type { CreateProps } from '../create-props'
+
+/**
+ * Props for the {@link ResizableRoot} component.
+ */
+export interface ResizableRootProps extends Partial<CreateProps<Props, Events>> {}
+ 
+export const ResizableRoot: ForwardRefExoticComponent<
+  Partial<ResizableRootProps> &
+  RefAttributes<ResizableRootElement> &
+  HTMLAttributes<ResizableRootElement>
+> = createComponent<
+  ResizableRootProps, 
+  ResizableRootElement
+>(
+  'prosekit-resizable-root',
+  'ResizableRoot',
+  Object.keys(resizableRootProps),
+  Object.keys(resizableRootEvents),
+)

package/src/components/table-handle/index.gen.ts

@@ -0,0 +1,17 @@
+export { TableHandleColumnRoot, type TableHandleColumnRootProps } from './table-handle-column-root.gen'
+
+export { TableHandleColumnTrigger, type TableHandleColumnTriggerProps } from './table-handle-column-trigger.gen'
+
+export { TableHandleDragPreview, type TableHandleDragPreviewProps } from './table-handle-drag-preview.gen'
+
+export { TableHandleDropIndicator, type TableHandleDropIndicatorProps } from './table-handle-drop-indicator.gen'
+
+export { TableHandlePopoverContent, type TableHandlePopoverContentProps } from './table-handle-popover-content.gen'
+
+export { TableHandlePopoverItem, type TableHandlePopoverItemProps } from './table-handle-popover-item.gen'
+
+export { TableHandleRoot, type TableHandleRootProps } from './table-handle-root.gen'
+
+export { TableHandleRowRoot, type TableHandleRowRootProps } from './table-handle-row-root.gen'
+
+export { TableHandleRowTrigger, type TableHandleRowTriggerProps } from './table-handle-row-trigger.gen'