@handlewithcare/react-prosemirror 2.0.0

package/dist/types/dom.d.ts

@@ -0,0 +1,22 @@
+export type DOMNode = InstanceType<typeof window.Node>;
+export type DOMSelection = InstanceType<typeof window.Selection>;
+export type DOMSelectionRange = {
+    focusNode: DOMNode | null;
+    focusOffset: number;
+    anchorNode: DOMNode | null;
+    anchorOffset: number;
+};
+export declare const domIndex: (node: Node) => number;
+export declare const parentNode: (node: Node) => Node | null;
+export declare const textRange: (node: Text, from?: number, to?: number) => Range;
+export declare const isEquivalentPosition: (node: Node, off: number, targetNode: Node, targetOff: number) => boolean;
+export declare function nodeSize(node: Node): number;
+export declare function isOnEdge(node: Node, offset: number, parent: Node): boolean;
+export declare function hasBlockDesc(dom: Node): boolean | null | undefined;
+export declare const selectionCollapsed: (domSel: DOMSelectionRange) => boolean | null;
+export declare function keyEvent(keyCode: number, key: string): KeyboardEvent;
+export declare function deepActiveElement(doc: Document): Element | null;
+export declare function caretFromPoint(doc: Document, x: number, y: number): {
+    node: Node;
+    offset: number;
+} | undefined;

package/dist/types/hooks/__tests__/useEditorViewLayoutEffect.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/hooks/useClientOnly.d.ts

@@ -0,0 +1 @@
+export declare function useClientOnly(): boolean;

package/dist/types/hooks/useComponentEventListeners.d.ts

@@ -0,0 +1,33 @@
+import type { DOMEventMap } from "prosemirror-view";
+import { EventHandler } from "../plugins/componentEventListeners.js";
+/**
+ * Produces a plugin that can be used with ProseMirror to handle DOM
+ * events at the EditorView.dom element.
+ *
+ * - `reactEventsPlugin` is a ProseMirror plugin for handling DOM events
+ * at the EditorView.dom element. It should be passed to `useEditorView`,
+ * along with any other plugins.
+ *
+ * - `registerEventListener` and `unregisterEventListener` should be
+ * passed to `EditorContext.Provider`.
+ *
+ * @privateRemarks
+ *
+ * This hook uses a combination of mutable and immutable updates to give
+ * us precise control over when we re-create the ProseMirror plugin.
+ *
+ * The plugin has a mutable reference to the set of handlers for each
+ * event type, but the set of event types is static. This means that we
+ * need to produce a new ProseMirror plugin whenever a new event type is
+ * registered. We avoid producing a new ProseMirrer plugin in any other
+ * scenario to avoid the performance overhead of reconfiguring the plugins
+ * in the EditorView.
+ *
+ * To accomplish this, we shallowly clone the registry whenever a new event
+ * type is registered.
+ */
+export declare function useComponentEventListeners(): {
+    registerEventListener: (eventType: keyof DOMEventMap, handler: EventHandler) => void;
+    unregisterEventListener: (eventType: keyof DOMEventMap, handler: EventHandler) => void;
+    componentEventListenersPlugin: import("prosemirror-state").Plugin<any>;
+};

package/dist/types/hooks/useEditor.d.ts

@@ -0,0 +1,66 @@
+import { EditorState, Plugin, Transaction } from "prosemirror-state";
+import { Decoration, DirectEditorProps, EditorProps, EditorView } from "prosemirror-view";
+import { NodeViewDesc } from "../viewdesc.js";
+export declare class ReactEditorView extends EditorView {
+    private shouldUpdatePluginViews;
+    private oldProps;
+    private _props;
+    constructor(place: {
+        mount: HTMLElement;
+    } | null, props: DirectEditorProps & {
+        docView: NodeViewDesc;
+    });
+    /**
+     * Whether the EditorView's updateStateInner method thinks that the
+     * docView needs to be blown away and redrawn.
+     *
+     * @privateremarks
+     *
+     * When ProseMirror View detects that the EditorState has been reconfigured
+     * to provide new custom node views, it calls an internal function that
+     * we can't override in order to recreate the entire editor DOM.
+     *
+     * This property mimics that check, so that we can replace the EditorView
+     * with another of our own, preventing ProseMirror View from taking over
+     * DOM management responsibility.
+     */
+    get needsRedraw(): boolean;
+    /**
+     * Like setProps, but without executing any side effects.
+     * Safe to use in a component render method.
+     */
+    pureSetProps(props: Partial<DirectEditorProps>): void;
+    /**
+     * Triggers any side effects that have been queued by previous
+     * calls to pureSetProps.
+     */
+    runPendingEffects(): void;
+    update(props: DirectEditorProps): void;
+    updatePluginViews(prevState?: EditorState): void;
+    destroy(): void;
+}
+export interface UseEditorOptions extends EditorProps {
+    defaultState?: EditorState;
+    state?: EditorState;
+    plugins?: Plugin[];
+    dispatchTransaction?(this: EditorView, tr: Transaction): void;
+}
+/**
+ * Creates, mounts, and manages a ProseMirror `EditorView`.
+ *
+ * All state and props updates are executed in a layout effect.
+ * To ensure that the EditorState and EditorView are never out of
+ * sync, it's important that the EditorView produced by this hook
+ * is only accessed through the `useEditorViewEvent` and
+ * `useEditorViewLayoutEffect` hooks.
+ */
+export declare function useEditor<T extends HTMLElement = HTMLElement>(mount: T | null, options: UseEditorOptions): {
+    editor: {
+        view: EditorView | null;
+        registerEventListener: (eventType: keyof import("prosemirror-view").DOMEventMap, handler: import("../plugins/componentEventListeners.js").EventHandler<keyof import("prosemirror-view").DOMEventMap>) => void;
+        unregisterEventListener: (eventType: keyof import("prosemirror-view").DOMEventMap, handler: import("../plugins/componentEventListeners.js").EventHandler<keyof import("prosemirror-view").DOMEventMap>) => void;
+        cursorWrapper: Decoration | null;
+        docViewDescRef: import("react").MutableRefObject<NodeViewDesc>;
+    };
+    state: EditorState;
+};

package/dist/types/hooks/useEditorEffect.d.ts

@@ -0,0 +1,17 @@
+import type { EditorView } from "prosemirror-view";
+import type { DependencyList } from "react";
+/**
+ * Registers a layout effect to run after the EditorView has
+ * been updated with the latest EditorState and Decorations.
+ *
+ * Effects can take an EditorView instance as an argument.
+ * This hook should be used to execute layout effects that
+ * depend on the EditorView, such as for positioning DOM
+ * nodes based on ProseMirror positions.
+ *
+ * Layout effects registered with this hook still fire
+ * synchronously after all DOM mutations, but they do so
+ * _after_ the EditorView has been updated, even when the
+ * EditorView lives in an ancestor component.
+ */
+export declare function useEditorEffect(effect: (editorView: EditorView) => void | (() => void), dependencies?: DependencyList): void;

package/dist/types/hooks/useEditorEventCallback.d.ts

@@ -0,0 +1,15 @@
+import type { EditorView } from "prosemirror-view";
+/**
+ * Returns a stable function reference to be used as an
+ * event handler callback.
+ *
+ * The callback will be called with the EditorView instance
+ * as its first argument.
+ *
+ * This hook is dependent on both the
+ * `EditorViewContext.Provider` and the
+ * `DeferredLayoutEffectProvider`. It can only be used in a
+ * component that is mounted as a child of both of these
+ * providers.
+ */
+export declare function useEditorEventCallback<T extends unknown[], R>(callback: (view: EditorView, ...args: T) => R): (...args: T) => R | undefined;

package/dist/types/hooks/useEditorEventListener.d.ts

@@ -0,0 +1,8 @@
+import type { DOMEventMap } from "prosemirror-view";
+import type { EventHandler } from "../plugins/componentEventListeners.js";
+/**
+ * Attaches an event listener at the `EditorView`'s DOM node. See
+ * [the ProseMirror docs](https://prosemirror.net/docs/ref/#view.EditorProps.handleDOMEvents)
+ * for more details.
+ */
+export declare function useEditorEventListener<EventType extends keyof DOMEventMap>(eventType: EventType, handler: EventHandler<EventType>): void;

package/dist/types/hooks/useEditorState.d.ts

@@ -0,0 +1,5 @@
+import type { EditorState } from "prosemirror-state";
+/**
+ * Provides access to the current EditorState value.
+ */
+export declare function useEditorState(): EditorState;

package/dist/types/hooks/useForceUpdate.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Provides a function that forces an update of the
+ * component.
+ */
+export declare function useForceUpdate(): () => void;

package/dist/types/hooks/useLayoutGroupEffect.d.ts

@@ -0,0 +1,3 @@
+import type { DependencyList, EffectCallback } from "react";
+/** Registers a layout effect to run at the nearest `LayoutGroup` boundary. */
+export declare function useLayoutGroupEffect(effect: EffectCallback, deps?: DependencyList): void;

package/dist/types/hooks/useNodeViewDescriptor.d.ts

@@ -0,0 +1,11 @@
+import { Node } from "prosemirror-model";
+import { Decoration, DecorationSource } from "prosemirror-view";
+import { MutableRefObject } from "react";
+import { NodeViewDesc, ViewDesc } from "../viewdesc.js";
+export declare function useNodeViewDescriptor(node: Node | undefined, getPos: () => number, domRef: undefined | MutableRefObject<HTMLElement | null>, nodeDomRef: MutableRefObject<HTMLElement | null>, innerDecorations: DecorationSource, outerDecorations: readonly Decoration[], viewDesc?: NodeViewDesc, contentDOMRef?: MutableRefObject<HTMLElement | null>): {
+    hasContentDOM: boolean;
+    childDescriptors: MutableRefObject<ViewDesc[]>;
+    nodeViewDescRef: MutableRefObject<NodeViewDesc | undefined>;
+    setStopEvent: (newStopEvent: (event: Event) => boolean | undefined) => void;
+    setSelectNode: (newSelectNode: () => void, newDeselectNode: () => void) => void;
+};

package/dist/types/hooks/useReactKeys.d.ts

@@ -0,0 +1,5 @@
+export declare function useReactKeys(): {
+    posToKey: Map<number, string>;
+    keyToPos: Map<string, number>;
+    posToNode: Map<number, import("prosemirror-model").Node>;
+} | null | undefined;

package/dist/types/hooks/useSelectNode.d.ts

@@ -0,0 +1 @@
+export declare function useSelectNode(selectNode: () => void, deselectNode?: () => void): void;

package/dist/types/hooks/useStopEvent.d.ts

@@ -0,0 +1,2 @@
+import { EditorView } from "prosemirror-view";
+export declare function useStopEvent(stopEvent: (view: EditorView, event: Event) => boolean): void;

package/dist/types/index.d.ts

@@ -0,0 +1,12 @@
+export { ProseMirror } from "./components/ProseMirror.js";
+export { ProseMirrorDoc } from "./components/ProseMirrorDoc.js";
+export { useEditorEffect } from "./hooks/useEditorEffect.js";
+export { useEditorEventCallback } from "./hooks/useEditorEventCallback.js";
+export { useEditorEventListener } from "./hooks/useEditorEventListener.js";
+export { useEditorState } from "./hooks/useEditorState.js";
+export { useStopEvent } from "./hooks/useStopEvent.js";
+export { useSelectNode } from "./hooks/useSelectNode.js";
+export { reactKeys } from "./plugins/reactKeys.js";
+export { widget } from "./decorations/ReactWidgetType.js";
+export type { NodeViewComponentProps } from "./components/NodeViewComponentProps.js";
+export type { WidgetViewComponentProps } from "./components/WidgetViewComponentProps.js";

package/dist/types/plugins/__tests__/reactKeys.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/plugins/beforeInputPlugin.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from "prosemirror-state";
+import { Decoration } from "prosemirror-view";
+export declare function beforeInputPlugin(setCursorWrapper: (deco: Decoration | null) => void): Plugin<any>;

package/dist/types/plugins/componentEventListeners.d.ts

@@ -0,0 +1,4 @@
+import { Plugin } from "prosemirror-state";
+import { DOMEventMap, EditorView } from "prosemirror-view";
+export type EventHandler<EventType extends keyof DOMEventMap = keyof DOMEventMap> = (this: Plugin, view: EditorView, event: DOMEventMap[EventType]) => boolean | void;
+export declare function componentEventListeners(eventHandlerRegistry: Map<keyof DOMEventMap, Iterable<EventHandler>>): Plugin<any>;

package/dist/types/plugins/componentEventListenersPlugin.d.ts

@@ -0,0 +1,4 @@
+import { Plugin } from "prosemirror-state";
+import { DOMEventMap, EditorView } from "prosemirror-view";
+export type EventHandler<EventType extends keyof DOMEventMap = keyof DOMEventMap> = (this: Plugin, view: EditorView, event: DOMEventMap[EventType]) => boolean | void;
+export declare function createComponentEventListenersPlugin(eventHandlerRegistry: Map<keyof DOMEventMap, Set<EventHandler>>): Plugin<any>;

package/dist/types/plugins/reactKeys.d.ts

@@ -0,0 +1,19 @@
+import { Node } from "prosemirror-model";
+import { Plugin, PluginKey } from "prosemirror-state";
+export declare function createNodeKey(): string;
+export declare const reactKeysPluginKey: PluginKey<{
+    posToKey: Map<number, string>;
+    keyToPos: Map<string, number>;
+    posToNode: Map<number, Node>;
+}>;
+/**
+ * Tracks a unique key for each (non-text) node in the
+ * document, identified by its current position. Keys are
+ * (mostly) stable across transaction applications. The
+ * key for a given node can be accessed by that node's
+ * current position in the document, and vice versa.
+ */
+export declare function reactKeys(): Plugin<{
+    posToKey: Map<number, string>;
+    keyToPos: Map<string, number>;
+}>;