import type React from 'react'; import type { Value } from '../../facade'; import { getPlateRuntime } from '../../internal/plugin/compilePlateModel'; import { isEditOnly } from '../../internal/plugin/isEditOnlyDisabled'; import type { InternalReactEditorWithInstalledPlugins, Editor, } from '../editor/Editor'; import { type EditableHandlerContext, getHandlerView, } from '../internal/plite-components'; import type { AnyResolvedPlugin } from '../plugin'; import { createPluginContext } from '../plugin/createPluginContext.internal'; import type { DOMHandlers } from '../plugin/DOMHandlers'; import type { DOMHandlerProp } from './dom-attributes.internal'; type DOMHandlerName = keyof DOMHandlers; type PluginWithDOMHandlers = AnyResolvedPlugin & { on?: DOMHandlers; }; const getDOMHandlerName = (handlerKey: DOMHandlerProp): DOMHandlerName => { if (handlerKey === 'onDOMBeforeInput') return 'domBeforeInput'; return `${handlerKey[2].toLowerCase()}${handlerKey.slice(3)}` as DOMHandlerName; }; const convertDomEventToSyntheticEvent = ( domEvent: Event ): React.SyntheticEvent => { let propagationStopped = false; return { ...domEvent, // oxlint-disable-line typescript/no-misused-spread -- [P0 behavior-boundary] This fixture intentionally projects a class-backed host value into a plain synthetic object. bubbles: domEvent.bubbles, cancelable: domEvent.cancelable, currentTarget: domEvent.currentTarget as EventTarget, defaultPrevented: domEvent.defaultPrevented, eventPhase: domEvent.eventPhase, isTrusted: domEvent.isTrusted, nativeEvent: domEvent, target: domEvent.target as EventTarget, timeStamp: domEvent.timeStamp, type: domEvent.type, isDefaultPrevented: () => domEvent.defaultPrevented, isPropagationStopped: () => propagationStopped, persist: () => { throw new Error( 'persist is not implemented for synthetic events created using convertDomEventToSyntheticEvent' ); }, preventDefault: () => { domEvent.preventDefault(); }, stopPropagation: () => { propagationStopped = true; domEvent.stopPropagation(); }, }; }; /** Check if an event is overridden by a handler. */ const isEventHandled = ( event: EventType, context: EditableHandlerContext, handler?: ( event: EventType, context: EditableHandlerContext ) => boolean | void ) => { if (!handler) { return false; } // The custom event handler may return a boolean to specify whether the event // shall be treated as being handled or not. const shouldTreatEventAsHandled = handler(event, context); if (shouldTreatEventAsHandled != null) { return shouldTreatEventAsHandled; } if ( 'isPropagationStopped' in event && typeof event.isPropagationStopped === 'function' ) { return event.isPropagationStopped(); } const domEvent = event as Event; // Native Event has no non-deprecated propagation-stopped getter. // oxlint-disable-next-line typescript/no-deprecated return domEvent.defaultPrevented || domEvent.cancelBubble; }; /** * Generic pipe for DOM events. * * - Get every plugin event by the matching prefixless event name. * - If there is no plugin event or editable prop handler for this key, return * `undefined`. * - Return a handler calling every plugin event then the prop handler. * - Any callback returning true will stop the next callbacks, * including the Plite internal handler. */ type PipeHandlerOptions = { handlerKey: K; editableProps?: Partial> | null; }; type PipedDOMHandler = | ((event: any, context: EditableHandlerContext) => boolean | void) | undefined; export function pipeHandler( editor: InternalReactEditorWithInstalledPlugins, options: PipeHandlerOptions ): PipedDOMHandler; export function pipeHandler( editor: object, { editableProps, handlerKey }: PipeHandlerOptions ): PipedDOMHandler { const plateEditor = editor as Editor; const propsHandler = editableProps?.[handlerKey] as ( event: any, context: EditableHandlerContext ) => boolean | void; const pluginHandlerName = getDOMHandlerName(handlerKey); const relevantPlugins = ( getPlateRuntime(plateEditor).pluginList as unknown as AnyResolvedPlugin[] ).filter( (plugin) => (plugin as PluginWithDOMHandlers).on?.[pluginHandlerName] ); if (relevantPlugins.length === 0 && !propsHandler) return undefined; return (event: any, context: EditableHandlerContext) => { const view = getHandlerView(context); const isDomEvent = event instanceof Event; const handledEvent = isDomEvent && handlerKey !== 'onDOMBeforeInput' ? convertDomEventToSyntheticEvent(event) : event; const eventIsHandled = relevantPlugins.some((plugin) => { if (isEditOnly(view.read.view.isReadOnly(), plugin, 'on')) { return false; } const pluginHandler = (plugin as PluginWithDOMHandlers).on?.[ pluginHandlerName ] as ((ctx: any) => boolean | void) | undefined; if (!pluginHandler) return false; const shouldTreatEventAsHandled = pluginHandler({ ...createPluginContext(view, plugin), event: handledEvent, }); if (shouldTreatEventAsHandled != null) { return shouldTreatEventAsHandled; } return false; }); if (eventIsHandled) return true; return isEventHandled(handledEvent, context, propsHandler); }; }