@thomasfosterau/effect-richtext 0.0.0-stage → 0.1.0

package/dist/view/view.d.ts

@@ -0,0 +1,699 @@
+import { ResolvedPos } from "../model/resolvedpos.js";
+import { Slice } from "../model/replace.js";
+import { DOMParser } from "../model/from_dom.js";
+import { DOMSerializer } from "../model/to_dom.js";
+import { AnySchema, MarkNames, NodeNames } from "../model/schema.js";
+import { Mark } from "../model/mark.js";
+import { Node } from "../model/node.js";
+import "../model.js";
+import { StateFailure } from "../state/errors.js";
+import "../state.js";
+import { parseFromClipboard } from "./clipboard.js";
+import { Decoration, DecorationSource } from "./decoration.js";
+import { DOMNode, DOMSelection, DOMSelectionRange } from "./dom.js";
+import { Rect, TextblockDir } from "./domcoords.js";
+import { DOMObserver } from "./domobserver.js";
+import { ViewError } from "./errors.js";
+import { InputState, endComposition } from "./input.js";
+import { Transaction } from "../state/transaction.js";
+import { Selection } from "../state/selection.js";
+import { EditorState } from "../state/state.js";
+import { Plugin } from "../state/plugin.js";
+import { MarkViewConstructor, NodeViewConstructor, NodeViewDesc, ViewDesc } from "./viewdesc.js";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Cause from "effect/Cause";
+import * as Exit from "effect/Exit";
+import * as Context from "effect/Context";
+import * as Scope from "effect/Scope";
+/** @internal */
+export declare const __parseFromClipboard: typeof parseFromClipboard;
+/** @internal */
+export declare const __endComposition: typeof endComposition;
+/**
+ * The value an event-handling prop may return: `true` when it handled
+ * the event, `false`/`undefined` when it didn't, or an `Effect` that
+ * produces that boolean.
+ *
+ * Effects are run with the context captured when the view was created.
+ * When the effect completes synchronously, its result is used exactly
+ * like a plain boolean. When it suspends (is asynchronous), the event is
+ * treated as handled (`true`) and the effect keeps running in the
+ * background. Failures are reported to the view's `onError` prop and
+ * treated as "not handled".
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type HandlerResult<R = never, E = never> = boolean | void | Effect.Effect<boolean, E, R>;
+/**
+ * Helper type that maps event names to event object types, but includes
+ * events that TypeScript's `HTMLElementEventMap` doesn't know about.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface DOMEventMap extends HTMLElementEventMap {
+  [event: string]: any;
+}
+/**
+ * Node view constructors, keyed (and typed) by node name.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type NodeViews<Sc extends AnySchema = AnySchema> = { readonly [N in NodeNames<Sc>]?: NodeViewConstructor<Sc, N> | undefined; };
+/**
+ * Mark view constructors, keyed (and typed) by mark name.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type MarkViews<Sc extends AnySchema = AnySchema> = { readonly [M in MarkNames<Sc>]?: MarkViewConstructor<Sc, M> | undefined; };
+/**
+ * Something that can serialize a fragment for the clipboard (usually a
+ * `DOMSerializer`).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type ClipboardSerializer<Sc extends AnySchema = AnySchema> = Pick<DOMSerializer<Sc>, "serializeFragment">;
+/**
+ * Props are configuration values that can be passed to an editor view
+ * or included in a plugin. This interface lists the supported props.
+ *
+ * The various event-handling functions may all return `true` to
+ * indicate that they handled the given event, or an `Effect` producing
+ * that boolean (see `HandlerResult`). The view will then take care to
+ * call `preventDefault` on the event, except with `handleDOMEvents`,
+ * where the handler itself is responsible for that.
+ *
+ * How a prop is resolved depends on the prop. Handler functions are
+ * called one at a time, starting with the base props and then searching
+ * through the plugins (in order of appearance) until one of them returns
+ * true. For some props, the first plugin that yields a value gets
+ * precedence.
+ *
+ * The view passed to props is typed `EditorView<Sc, any, any>`:
+ * handler effects run with the view's captured context anyway.
+ *
+ * The optional `P` type parameter refers to the type of `this` in prop
+ * functions, and is used to pass in the plugin type when defining a
+ * plugin.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface EditorProps<Sc extends AnySchema = AnySchema, R = never, E = never, P = any> {
+  /**
+   * Can be an object mapping DOM event type names to functions that
+   * handle them. Such functions will be called before any handling the
+   * view does of events fired on the editable DOM element. Contrary to
+   * the other event handling props, when returning true from such a
+   * function, you are responsible for calling `preventDefault` yourself
+   * (or not, if you want to allow the default behavior).
+   */
+  readonly handleDOMEvents?: { readonly [event in keyof DOMEventMap]?: ((this: P, view: EditorView<Sc, any, any>, event: DOMEventMap[event]) => HandlerResult<R, E>) | undefined; } | undefined;
+  /** Called when the editor receives a `keydown` event. */
+  readonly handleKeyDown?: ((this: P, view: EditorView<Sc, any, any>, event: KeyboardEvent) => HandlerResult<R, E>) | undefined;
+  /** Handler for `keypress` events. */
+  readonly handleKeyPress?: ((this: P, view: EditorView<Sc, any, any>, event: KeyboardEvent) => HandlerResult<R, E>) | undefined;
+  /**
+   * Whenever the user directly input text, this handler is called before
+   * the input is applied. If it returns `true`, the default behavior of
+   * actually inserting the text is suppressed.
+   */
+  readonly handleTextInput?: ((this: P, view: EditorView<Sc, any, any>, from: number, to: number, text: string, deflt: () => Transaction<Sc>) => HandlerResult<R, E>) | undefined;
+  /**
+   * Called for each node around a click, from the inside out. The
+   * `direct` flag will be true for the inner node.
+   */
+  readonly handleClickOn?: ((this: P, view: EditorView<Sc, any, any>, pos: number, node: Node<Sc>, nodePos: number, event: MouseEvent, direct: boolean) => HandlerResult<R, E>) | undefined;
+  /** Called when the editor is clicked, after `handleClickOn` handlers have been called. */
+  readonly handleClick?: ((this: P, view: EditorView<Sc, any, any>, pos: number, event: MouseEvent) => HandlerResult<R, E>) | undefined;
+  /** Called for each node around a double click. */
+  readonly handleDoubleClickOn?: ((this: P, view: EditorView<Sc, any, any>, pos: number, node: Node<Sc>, nodePos: number, event: MouseEvent, direct: boolean) => HandlerResult<R, E>) | undefined;
+  /** Called when the editor is double-clicked, after `handleDoubleClickOn`. */
+  readonly handleDoubleClick?: ((this: P, view: EditorView<Sc, any, any>, pos: number, event: MouseEvent) => HandlerResult<R, E>) | undefined;
+  /** Called for each node around a triple click. */
+  readonly handleTripleClickOn?: ((this: P, view: EditorView<Sc, any, any>, pos: number, node: Node<Sc>, nodePos: number, event: MouseEvent, direct: boolean) => HandlerResult<R, E>) | undefined;
+  /** Called when the editor is triple-clicked, after `handleTripleClickOn`. */
+  readonly handleTripleClick?: ((this: P, view: EditorView<Sc, any, any>, pos: number, event: MouseEvent) => HandlerResult<R, E>) | undefined;
+  /**
+   * Can be used to override the behavior of pasting. `slice` is the
+   * pasted content parsed by the editor, but you can directly access the
+   * event to get at the raw content.
+   */
+  readonly handlePaste?: ((this: P, view: EditorView<Sc, any, any>, event: ClipboardEvent, slice: Slice<Sc>) => HandlerResult<R, E>) | undefined;
+  /**
+   * Called when something is dropped on the editor. `moved` will be true
+   * if this drop moves from the current selection (which should thus be
+   * deleted).
+   */
+  readonly handleDrop?: ((this: P, view: EditorView<Sc, any, any>, event: DragEvent, slice: Slice<Sc>, moved: boolean) => HandlerResult<R, E>) | undefined;
+  /**
+   * Called when the view, after updating its state, tries to scroll the
+   * selection into view. A handler function may return false to indicate
+   * that it did not handle the scrolling and further handlers or the
+   * default behavior should be tried.
+   */
+  readonly handleScrollToSelection?: ((this: P, view: EditorView<Sc, any, any>) => HandlerResult<R, E>) | undefined;
+  /**
+   * Determines whether an in-editor drag event should copy or move the
+   * selection. When not given, the event's `altKey` property is used on
+   * macOS, `ctrlKey` on other platforms.
+   */
+  readonly dragCopies?: ((event: DragEvent) => boolean) | undefined;
+  /**
+   * Can be used to override the way a selection is created when reading
+   * a DOM selection between the given anchor and head.
+   */
+  readonly createSelectionBetween?: ((this: P, view: EditorView<Sc, any, any>, anchor: ResolvedPos<Sc>, head: ResolvedPos<Sc>) => Selection<Sc> | null | undefined) | undefined;
+  /**
+   * The parser to use when reading editor changes from the DOM. Defaults
+   * to calling `DOMParser.fromSchema` on the editor's schema.
+   */
+  readonly domParser?: DOMParser<Sc> | undefined;
+  /**
+   * Can be used to transform pasted HTML text, _before_ it is parsed, for
+   * example to clean it up.
+   */
+  readonly transformPastedHTML?: ((this: P, html: string, view: EditorView<Sc, any, any>) => string) | undefined;
+  /**
+   * The parser to use when reading content from the clipboard. When not
+   * given, the value of the `domParser` prop is used.
+   */
+  readonly clipboardParser?: DOMParser<Sc> | undefined;
+  /**
+   * Transform pasted plain text. The `plain` flag will be true when the
+   * text is pasted as plain text.
+   */
+  readonly transformPastedText?: ((this: P, text: string, plain: boolean, view: EditorView<Sc, any, any>) => string) | undefined;
+  /**
+   * A function to parse text from the clipboard into a document slice.
+   * Called after `transformPastedText`. The default behavior is to split
+   * the text into lines, wrap them in `<p>` tags, and call
+   * `clipboardParser` on it. The `plain` flag will be true when the text
+   * is pasted as plain text.
+   */
+  readonly clipboardTextParser?: ((this: P, text: string, $context: ResolvedPos<Sc>, plain: boolean, view: EditorView<Sc, any, any>) => Slice<Sc> | null | undefined) | undefined;
+  /**
+   * Can be used to transform pasted or dragged-and-dropped content
+   * before it is applied to the document. The `plain` flag will be true
+   * when the text is pasted as plain text.
+   */
+  readonly transformPasted?: ((this: P, slice: Slice<Sc>, view: EditorView<Sc, any, any>, plain: boolean) => Slice<Sc>) | undefined;
+  /**
+   * Can be used to transform copied or cut content before it is
+   * serialized to the clipboard.
+   */
+  readonly transformCopied?: ((this: P, slice: Slice<Sc>, view: EditorView<Sc, any, any>) => Slice<Sc>) | undefined;
+  /**
+   * Allows you to pass custom rendering and behavior logic for nodes.
+   * Should map node names to constructor functions that produce a
+   * `NodeView` object implementing the node's display behavior. The
+   * constructors are typed per node name, so `node.attrs` is typed.
+   *
+   * The `getPos` argument is a function that can be called to get the
+   * node's current position, which can be useful when creating
+   * transactions to update it. Note that if the node is not in the
+   * document, the position returned by this function will be
+   * `undefined`.
+   *
+   * `decorations` is an array of node or inline decorations that are
+   * active around the node. `innerDecorations` holds the decorations for
+   * the node's content.
+   */
+  readonly nodeViews?: NodeViews<Sc> | undefined;
+  /**
+   * Pass custom mark rendering functions. Note that these cannot provide
+   * the kind of dynamic behavior that node views can—they just provide
+   * custom rendering logic. The third argument indicates whether the
+   * mark's content is inline.
+   */
+  readonly markViews?: MarkViews<Sc> | undefined;
+  /**
+   * The DOM serializer to use when putting content onto the clipboard.
+   * If not given, the result of `DOMSerializer.fromSchema` will be used.
+   * This object will only have its `serializeFragment` method called.
+   */
+  readonly clipboardSerializer?: ClipboardSerializer<Sc> | undefined;
+  /**
+   * A function that will be called to get the text for the current
+   * selection when copying text to the clipboard. By default, the editor
+   * will use `textBetween` on the selected range.
+   */
+  readonly clipboardTextSerializer?: ((this: P, content: Slice<Sc>, view: EditorView<Sc, any, any>) => string) | undefined;
+  /** A set of document decorations to show in the view. */
+  readonly decorations?: ((this: P, state: EditorState<Sc>) => DecorationSource | null | undefined) | undefined;
+  /** When this returns false, the content of the view is not directly editable. */
+  readonly editable?: ((this: P, state: EditorState<Sc>) => boolean) | undefined;
+  /**
+   * Control the DOM attributes of the editable element. May be either an
+   * object or a function going from an editor state to an object. By
+   * default, the element will get a class `"ProseMirror"`, and will have
+   * its `contentEditable` attribute determined by the `editable` prop.
+   * Additional classes provided here will be added to the class. For
+   * other attributes, the value provided first (as in `someProp`) will
+   * be used.
+   */
+  readonly attributes?: {
+    readonly [name: string]: string;
+  } | ((state: EditorState<Sc>) => {
+    readonly [name: string]: string;
+  } | null | undefined) | undefined;
+  /**
+   * Determines the distance (in pixels) between the cursor and the end
+   * of the visible viewport at which point, when scrolling the cursor
+   * into view, scrolling takes place. Defaults to 0.
+   */
+  readonly scrollThreshold?: number | Rect | undefined;
+  /**
+   * Determines the extra space (in pixels) that is left above or below
+   * the cursor when it is scrolled into view. Defaults to 5.
+   */
+  readonly scrollMargin?: number | Rect | undefined;
+}
+/**
+ * The props object given directly to the editor view supports some
+ * fields that can't be used in plugins.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface DirectEditorProps<Sc extends AnySchema = AnySchema, R = never, E = never> extends EditorProps<Sc, R, E> {
+  /** The current state of the editor. */
+  readonly state: EditorState<Sc, R, E>;
+  /**
+   * A set of plugins to use in the view, applying their plugin view and
+   * props. Passing plugins with a state component (a state field or a
+   * transaction filter or appender) will result in an error (a defect),
+   * since such plugins must be present in the state to work.
+   */
+  readonly plugins?: ReadonlyArray<Plugin<any, any, E, R>> | undefined;
+  /**
+   * The callback over which to send transactions (state updates)
+   * produced by the view. If you specify this, you probably want to make
+   * sure this ends up calling the view's `updateState` method with a new
+   * state that has the transaction applied. The callback will be bound
+   * to have the view instance as its `this` binding. It may return an
+   * `Effect`, which is run with the view's captured context.
+   */
+  readonly dispatchTransaction?: ((tr: Transaction<Sc>) => void | Effect.Effect<void, E, R>) | undefined;
+  /**
+   * Called with the cause of failures of effects run by the view on
+   * behalf of DOM events: event handler effects, dispatched
+   * transactions (including failing plugin hooks) and
+   * `dispatchTransaction` effects. Defaults to logging the cause with
+   * `Effect.logError` (run with the view's captured context).
+   */
+  readonly onError?: ((cause: Cause.Cause<unknown>) => void) | undefined;
+}
+/**
+ * Describes a state update of an editor view, as passed to the listeners
+ * registered with `EditorView.subscribe`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface ViewUpdate<Sc extends AnySchema = AnySchema, R = never, E = never> {
+  /** The view's new state. */
+  readonly state: EditorState<Sc, R, E>;
+  /** The view's state before the update. */
+  readonly prevState: EditorState<Sc, R, E>;
+  /**
+   * The transactions that produced the update, when it was caused by a
+   * dispatch: the dispatched transaction followed by those appended by
+   * plugins (with a custom `dispatchTransaction` prop, only the
+   * dispatched transaction is known). Empty for updates made directly
+   * through `updateState`, `update` or `setProps`.
+   */
+  readonly transactions: ReadonlyArray<Transaction<Sc>>;
+}
+/**
+ * Where to put the editor: a DOM node that the editor should be appended
+ * to, a function that will place it into the document, an object whose
+ * `mount` property holds the node to use as the document container, or
+ * `null` to not add it to the document.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type ViewPlace = null | DOMNode | ((editor: HTMLElement) => void) | {
+  readonly mount: HTMLElement;
+};
+type NodeViewSet = {
+  [name: string]: NodeViewConstructor<any, any> | MarkViewConstructor<any, any>;
+};
+/**
+ * The result of `EditorView.posAtCoords`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface PosAtCoords {
+  /** The position nearest to the coordinates. */
+  readonly pos: number;
+  /**
+   * The position of the inner node that the position falls inside of,
+   * or -1 if it is at the top level, not in any node.
+   */
+  readonly inside: number;
+}
+/**
+ * The result of `EditorView.serializeForClipboard`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface ClipboardSerialization<Sc extends AnySchema = AnySchema> {
+  readonly dom: HTMLElement;
+  readonly text: string;
+  readonly slice: Slice<Sc>;
+}
+/**
+ * @since 0.1.0
+ * @category symbols
+ */
+export declare const EditorViewTypeId: unique symbol;
+/**
+ * @since 0.1.0
+ * @category symbols
+ */
+export type EditorViewTypeId = typeof EditorViewTypeId;
+/**
+ * An editor view manages the DOM structure that represents an editable
+ * document. Its state and behavior are determined by its props.
+ *
+ * `R` and `E` are the requirements and errors of the effects the view
+ * runs: those of its state's plugins and of its effectful props. Create
+ * a view with `EditorView.make`, inside an Effect that provides `R` and a
+ * `Scope`: the view captures the current context to run handler effects
+ * later, and is destroyed when the scope closes.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class EditorView<Sc extends AnySchema = AnySchema, R = never, E = never> {
+  readonly [EditorViewTypeId]: {
+    readonly _R: (_: never) => R;
+    readonly _E: (_: never) => E;
+  };
+  /** @internal */
+  _props: DirectEditorProps<Sc, R, E>;
+  private directPlugins;
+  private _root;
+  /** @internal */
+  focused: boolean;
+  /** Kludge used to work around a Chrome bug @internal */
+  trackWrites: DOMNode | null;
+  private mounted;
+  /** @internal */
+  markCursor: ReadonlyArray<Mark<any, any>> | null;
+  /** @internal */
+  cursorWrapper: {
+    dom: DOMNode;
+    deco: Decoration;
+  } | null;
+  /** @internal */
+  nodeViews: NodeViewSet;
+  /** @internal */
+  lastSelectedViewDesc: ViewDesc | undefined;
+  /** @internal */
+  docView: NodeViewDesc;
+  /** @internal */
+  input: InputState;
+  private prevDirectPlugins;
+  private pluginViews;
+  private listeners;
+  private dispatching;
+  /** @internal */
+  domObserver: DOMObserver;
+  /**
+   * Holds `true` when a hack node is needed in Firefox to prevent the
+   * space is eaten issue.
+   *
+   * @internal
+   */
+  requiresGeckoHackNode: boolean;
+  /**
+   * The context captured when the view was created, used to run effects.
+   *
+   * @internal
+   */
+  readonly context: Context.Context<any>;
+  private readonly runContext;
+  /** The view's current state. */
+  state: EditorState<Sc, R, E>;
+  /** @internal */
+  constructor(place: ViewPlace, props: DirectEditorProps<Sc, R, E>, context: Context.Context<R>);
+  /**
+   * Create a view inside a scope. `place` may be a DOM node that the
+   * editor should be appended to, a function that will place it into the
+   * document, or an object whose `mount` property holds the node to use
+   * as the document container. If it is `null`, the editor will not be
+   * added to the document.
+   *
+   * The view captures the current context (which must provide `R`) to
+   * run the effects of its plugins and props, and is destroyed when the
+   * scope closes.
+   *
+   * When props' handlers require services that the state's plugins
+   * don't, pass the type arguments explicitly
+   * (`EditorView.make<typeof schema, ServiceA | ServiceB>(...)`).
+   */
+  static make<Sc extends AnySchema, R = never, E = never>(place: ViewPlace, props: DirectEditorProps<Sc, R, E>): Effect.Effect<EditorView<Sc, R, E>, never, Scope.Scope | R>;
+  /**
+   * Create a view without a scope. The caller is responsible for calling
+   * `destroy`. When `R` is not `never`, a context providing it must be
+   * passed; it is used to run the effects of plugins and props.
+   */
+  static makeUnsafe<Sc extends AnySchema, E = never>(place: ViewPlace, props: DirectEditorProps<Sc, never, E>): EditorView<Sc, never, E>;
+  static makeUnsafe<Sc extends AnySchema, R, E = never>(place: ViewPlace, props: DirectEditorProps<Sc, R, E>, context: Context.Context<R>): EditorView<Sc, R, E>;
+  /**
+   * An editable DOM node containing the document. (You probably should
+   * not directly interfere with its content.)
+   */
+  readonly dom: HTMLElement;
+  /** Indicates whether the editor is currently editable. */
+  editable: boolean;
+  /**
+   * When editor content is being dragged, this object contains
+   * information about the dragged slice and whether it is being copied
+   * or moved. At any other time, it is null.
+   */
+  dragging: null | {
+    readonly slice: Slice<Sc>;
+    readonly move: boolean;
+  };
+  /** Holds `true` when a composition is active. */
+  get composing(): boolean;
+  /** The view's current props. */
+  get props(): DirectEditorProps<Sc, R, E>;
+  /** Update the view's props. Will immediately cause an update to the DOM. */
+  update(props: DirectEditorProps<Sc, R, E>): void;
+  /**
+   * Update the view by updating existing props object with the object
+   * given as argument. Equivalent to
+   * `view.update(Object.assign({}, view.props, props))`.
+   */
+  setProps(props: Partial<DirectEditorProps<Sc, R, E>>): void;
+  /** Update the editor's `state` prop, without touching any of the other props. */
+  updateState(state: EditorState<Sc, R, E>): void;
+  private updateStateInner;
+  private notifyListeners;
+  /**
+   * Register a listener called after every state update of the view
+   * (once the DOM and plugin views have been updated). Returns a
+   * function that removes the listener. Exceptions thrown by listeners
+   * are reported to `onError`.
+   */
+  subscribe(listener: (update: ViewUpdate<Sc, R, E>) => void): () => void;
+  private withDispatching;
+  /** @internal */
+  scrollToSelection(): void;
+  private destroyPluginViews;
+  private updatePluginViews;
+  private updateDraggedNode;
+  /**
+   * Goes over the values of a prop, first those provided directly, then
+   * those from plugins given to the view, then from plugins in the state
+   * (in order), and calls `f` every time a non-undefined value is found.
+   * When `f` returns a truthy value, that is immediately returned. When
+   * `f` isn't provided, it is treated as the identity function (the prop
+   * value is returned directly).
+   *
+   * Note that event handler props may return Effects, which are returned
+   * as-is (and are truthy).
+   */
+  someProp<PropName extends keyof EditorProps<Sc, R, E>, Result>(propName: PropName, f: (value: NonNullable<EditorProps<Sc, R, E>[PropName]>) => Result): Result | undefined;
+  someProp<PropName extends keyof EditorProps<Sc, R, E>>(propName: PropName): NonNullable<EditorProps<Sc, R, E>[PropName]> | undefined;
+  /**
+   * Like `someProp`, but for event handler props, whose results may be
+   * Effects: those are run (see `HandlerResult`) and their results used.
+   *
+   * @internal
+   */
+  someHandler<PropName extends keyof EditorProps<Sc, R, E>>(propName: PropName, f: (value: NonNullable<EditorProps<Sc, R, E>[PropName]>) => HandlerResult<any, any>): boolean;
+  /**
+   * Interpret the result of an event handler prop, running it with the
+   * view's context when it is an Effect.
+   *
+   * @internal
+   */
+  runHandler(result: HandlerResult<any, any>): boolean;
+  /**
+   * Run an effect with the view's captured context. Returns its exit
+   * when it completed synchronously (reporting failures to `onError`),
+   * or `undefined` when it is still running in the background (in which
+   * case failures are reported when it completes).
+   *
+   * @internal
+   */
+  runEffect<A>(effect: Effect.Effect<A, unknown, R>): Exit.Exit<A, unknown> | undefined;
+  /** @internal */
+  reportError(cause: Cause.Cause<unknown>): void;
+  /** Query whether the view has focus. */
+  hasFocus(): boolean;
+  /** Focus the editor. */
+  focus(): void;
+  /**
+   * Get the document root in which the editor exists. This will usually
+   * be the top-level `document`, but might be a shadow DOM root if the
+   * editor is inside one.
+   */
+  get root(): Document | ShadowRoot;
+  /**
+   * When an existing editor view is moved to a new document or shadow
+   * tree, call this to make it recompute its root.
+   */
+  updateRoot(): void;
+  /**
+   * Given a pair of viewport coordinates, return the document position
+   * that corresponds to them. Returns `None` if the given coordinates
+   * aren't inside of the editor.
+   */
+  posAtCoords(coords: {
+    readonly left: number;
+    readonly top: number;
+  }): Option.Option<PosAtCoords>;
+  /**
+   * Returns the viewport rectangle at a given document position. `left`
+   * and `right` will be the same number, as this returns a flat
+   * cursor-ish rectangle. If the position is between two things that
+   * aren't directly adjacent, `side` determines which element is used.
+   * When < 0, the element before the position is used, otherwise the
+   * element after.
+   */
+  coordsAtPos(pos: number, side?: number): Rect;
+  /**
+   * Find the DOM position that corresponds to the given document
+   * position. When `side` is negative, find the position as close as
+   * possible to the content before the position. When positive, prefer
+   * positions close to the content after the position. When zero,
+   * prefer as shallow a position as possible.
+   *
+   * Note that you should **not** mutate the editor's internal DOM, only
+   * inspect it (and even that is usually not necessary).
+   */
+  domAtPos(pos: number, side?: number): {
+    node: DOMNode;
+    offset: number;
+  };
+  /**
+   * Find the DOM node that represents the document node after the given
+   * position. Returns `None` when the position doesn't point in front of
+   * a node or if the node is inside an opaque node view.
+   *
+   * This is intended to be able to call things like
+   * `getBoundingClientRect` on that DOM node. Do **not** mutate the
+   * editor DOM directly, or add styling this way, since that will be
+   * immediately overriden by the editor as it redraws the node.
+   */
+  nodeDOM(pos: number): Option.Option<DOMNode>;
+  /**
+   * Find the document position that corresponds to a given DOM position.
+   * (Whenever possible, it is preferable to inspect the document
+   * structure directly, rather than poking around in the DOM, but
+   * sometimes—for example when interpreting an event target—you don't
+   * have a choice.)
+   *
+   * The `bias` parameter can be used to influence which side of a DOM
+   * node to use when the position is inside a leaf node. Fails with a
+   * `ViewError` when the DOM position is not inside the editor.
+   */
+  posAtDOM(node: DOMNode, offset: number, bias?: number): Effect.Effect<number, ViewError>;
+  /** Like `posAtDOM`, but throws a `ViewError` when the position is not inside the editor. */
+  posAtDOMUnsafe(node: DOMNode, offset: number, bias?: number): number;
+  /**
+   * Find out whether the selection is at the end of a textblock when
+   * moving in a given direction. When, for example, given `"left"`, it
+   * will return true if moving left from the current cursor position
+   * would leave that position's parent textblock. Will apply to the
+   * view's current state by default, but it is possible to pass a
+   * different state.
+   */
+  endOfTextblock(dir: TextblockDir, state?: EditorState<any, any, any>): boolean;
+  /**
+   * Run the editor's paste logic with the given HTML string. The
+   * `event`, if given, will be passed to the `handlePaste` hook.
+   */
+  pasteHTML(html: string, event?: ClipboardEvent): boolean;
+  /** Run the editor's paste logic with the given plain-text input. */
+  pasteText(text: string, event?: ClipboardEvent): boolean;
+  /**
+   * Serialize the given slice as it would be if it was copied from this
+   * editor. Returns a DOM element that contains a representation of the
+   * slice as its children, a textual representation, and the
+   * transformed slice (which can be different from the given input due
+   * to hooks like `transformCopied`).
+   */
+  serializeForClipboard(slice: Slice<Sc>): ClipboardSerialization<Sc>;
+  /** Removes the editor from the DOM and destroys all node views. */
+  destroy(): void;
+  /**
+   * This is true when the view has been destroyed (and thus should not
+   * be used anymore).
+   */
+  get isDestroyed(): boolean;
+  /** Used for testing. */
+  dispatchEvent(event: Event): void;
+  /**
+   * Dispatch a transaction. Will call `dispatchTransaction` when given,
+   * and otherwise defaults to applying the transaction to the current
+   * state and calling `updateState` with the result.
+   *
+   * The returned effect runs with the view's captured context (so it
+   * requires nothing), and failures (of plugin hooks or of a
+   * `dispatchTransaction` effect) are reported to the `onError` prop
+   * rather than to the error channel—use `tryDispatch` to observe them.
+   * This is a bound function, usable as a command's `Dispatch`.
+   */
+  readonly dispatch: (tr: Transaction<Sc>) => Effect.Effect<void>;
+  /**
+   * Like `dispatch`, but fails with the errors of the plugin hooks and
+   * of `dispatchTransaction` instead of reporting them to `onError`.
+   * Runs with the view's captured context.
+   */
+  tryDispatch(tr: Transaction<Sc>): Effect.Effect<void, E | StateFailure>;
+  /**
+   * Dispatch a transaction synchronously, throwing its failure (as
+   * `tryDispatch` would fail). When the dispatch is asynchronous (a
+   * plugin hook suspends), it keeps running in the background and
+   * failures are reported to `onError`. Bound to the view instance.
+   */
+  readonly dispatchUnsafe: (tr: Transaction<Sc>) => void;
+  /**
+   * Dispatch a transaction on behalf of a DOM event: like
+   * `dispatchUnsafe`, but failures are reported to `onError` instead of
+   * thrown.
+   *
+   * @internal
+   */
+  dispatchInternal(tr: Transaction<any>): void;
+  /** @internal */
+  domSelectionRange(): DOMSelectionRange;
+  /** @internal */
+  domSelection(): DOMSelection | null;
+}
+export {};