@stesura/react-prosemirror 3.2.11-stesura.1

package/dist/types/ReactEditorView.d.ts

@@ -0,0 +1,102 @@
+import { EditorState } from "prosemirror-state";
+import { Decoration, DirectEditorProps, EditorProps, EditorView } from "prosemirror-view";
+import { AbstractEditorView, NodeViewSet } from "./AbstractEditorView.js";
+import { DOMNode, DOMSelection, DOMSelectionRange } from "./dom.js";
+import { NodeViewDesc, ViewDesc } from "./viewdesc.js";
+interface DOMObserver {
+    observer: MutationObserver | null;
+    queue: MutationRecord[];
+    start(): void;
+    stop(): void;
+    onSelectionChange(): void;
+    setCurSelection(): void;
+    disconnectSelection(): void;
+    connectSelection(): void;
+    flush(): void;
+    lastChangedTextNode: Text | null;
+}
+interface InputState {
+    composing: boolean;
+    compositionID: number;
+    compositionNode: Text | null;
+    compositionEndedAt: number;
+    compositionNodes: ViewDesc[];
+    compositionPendingChanges: number;
+    hideSelectionGuard: (() => void) | null;
+    lastClick: {
+        time: number;
+        x: number;
+        y: number;
+        type: string;
+        button: number;
+    };
+    lastFocus: number;
+    lastIOSEnter: number;
+    lastSelectionOrigin: string | null;
+    lastSelectionTime: number;
+    lastTouch: number;
+    mouseDown: {
+        allowDefault: boolean;
+        delayedSelectionSync: boolean;
+    } | null;
+}
+/**
+ * Extends EditorView to make prop and state updates pure, remove the DOM
+ * Mutation Observer, and use a custom document view managed by React.
+ *
+ * @privateRemarks
+ *
+ * The implementation relies on the base class using a private member to store
+ * the committed props and having a public getter that we override to return the
+ * latest, uncommitted props. The base class can then be told to update when the
+ * React effects are commit an update, applying the pending, uncommitted props.
+ */
+export declare class ReactEditorView extends EditorView implements AbstractEditorView {
+    cursorWrapper: {
+        dom: DOMNode;
+        deco: Decoration;
+    } | null;
+    nodeViews: NodeViewSet;
+    lastSelectedViewDesc: ViewDesc | undefined;
+    docView: NodeViewDesc;
+    input: InputState;
+    domObserver: DOMObserver;
+    domSelectionRange: () => DOMSelectionRange;
+    domSelection: () => DOMSelection | null;
+    private nextProps;
+    private prevState;
+    private _destroyed;
+    cursorWrapped: boolean;
+    constructor(place: {
+        mount: HTMLElement;
+    }, props: DirectEditorProps);
+    get props(): DirectEditorProps;
+    /**
+     * @privateremarks
+     *
+     * We override this getter because the base implementation
+     * relies on checking `docView === null`, but we unconditionally
+     * set view.docView in a layout effect in the DocNodeView.
+     * This has the effect of "un-destroying" the EditorView,
+     * making it impossible to determine whether it's been destroyed.
+     */
+    get isDestroyed(): boolean;
+    setProps(props: Partial<DirectEditorProps>): void;
+    update(props: DirectEditorProps): void;
+    updateState(state: EditorState): void;
+    someProp<PropName extends keyof EditorProps, Result>(propName: PropName, f: (value: NonNullable<EditorProps[PropName]>) => Result): Result | undefined;
+    someProp<PropName extends keyof EditorProps>(propName: PropName): NonNullable<EditorProps[PropName]> | undefined;
+    destroy(): void;
+    /**
+     * Commit effects by appling the pending props and state.
+     *
+     * Ensures the DOM selection is correct and updates plugin views.
+     *
+     * @privateRemarks
+     *
+     * The correctness of this depends on the pure update function ensuring that
+     * the node view set is up to date so that it does not try to redraw.
+     */
+    commitPendingEffects(): void;
+}
+export {};

package/dist/types/StaticEditorView.d.ts

@@ -0,0 +1,26 @@
+import { EditorState } from "prosemirror-state";
+import { DirectEditorProps, EditorProps } from "prosemirror-view";
+import { AbstractEditorView, NodeViewSet } from "./AbstractEditorView.js";
+export declare class StaticEditorView implements AbstractEditorView {
+    props: DirectEditorProps;
+    readonly nodeViews: NodeViewSet;
+    constructor(props: DirectEditorProps);
+    get composing(): boolean;
+    get dom(): null;
+    get editable(): boolean;
+    get state(): EditorState;
+    get isDestroyed(): boolean;
+    setProps(props: Partial<DirectEditorProps>): void;
+    update(props: DirectEditorProps): void;
+    updateState(state: EditorState): void;
+    someProp<PropName extends keyof EditorProps, Result>(propName: PropName, f: (value: NonNullable<EditorProps[PropName]>) => Result): Result | undefined;
+    someProp<PropName extends keyof EditorProps>(propName: PropName): NonNullable<EditorProps[PropName]> | undefined;
+    destroy(): void;
+    domSelectionRange(): {
+        anchorNode: null;
+        anchorOffset: number;
+        focusNode: null;
+        focusOffset: number;
+    };
+    domSelection(): null;
+}

package/dist/types/__tests__/viewdesc.test.d.ts

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

package/dist/types/browser.d.ts

@@ -0,0 +1,15 @@
+export declare const browser: {
+    ie: boolean;
+    ie_version: any;
+    gecko: boolean;
+    gecko_version: number | false;
+    chrome: boolean;
+    chrome_version: number;
+    safari: boolean;
+    ios: boolean;
+    mac: boolean;
+    windows: boolean;
+    android: boolean;
+    webkit: boolean;
+    webkit_version: number;
+};

package/dist/types/commands/__tests__/reorderSiblings.test.d.ts

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

package/dist/types/commands/reorderSiblings.d.ts

@@ -0,0 +1,14 @@
+import { Command, EditorState, Transaction } from "prosemirror-state";
+import { EditorView } from "prosemirror-view";
+/**
+ * Create a command function that reorders the adjacent nodes starting
+ * at the provided position.
+ *
+ * @param pos - The `start` position of the parent of the nodes being reordered
+ * @param order - The new order for the nodes, expressed as an array of indices. For
+ *                example, to swap the first two nodes in a set of three, `order`
+ *                would be set to `[1, 0, 2]`. To move the first node to the end,
+ *                and keep the other two in relative order, set `order` to `[1, 2, 0]`.
+ */
+export declare function reorderSiblings(pos: number, order: number[]): Command;
+export declare function reorderSiblingsOnTransaction(pos: number, order: number[], tr: Transaction, state: EditorState, dispatch?: EditorView["dispatch"]): boolean;

package/dist/types/components/ChildNodeViews.d.ts

@@ -0,0 +1,9 @@
+import { Node } from "prosemirror-model";
+import { Decoration, DecorationSource } from "prosemirror-view";
+import React from "react";
+export declare function wrapInDeco(reactNode: JSX.Element | string, deco: Decoration): React.DetailedReactHTMLElement<React.HTMLProps<HTMLElement>, HTMLElement> | React.FunctionComponentElement<any>;
+export declare const ChildNodeViews: React.MemoExoticComponent<({ getPos, node, innerDecorations, }: {
+    getPos: () => number;
+    node: Node | undefined;
+    innerDecorations: DecorationSource;
+}) => React.JSX.Element | null>;

package/dist/types/components/CursorWrapper.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import { WidgetViewComponentProps } from "./WidgetViewComponentProps.js";
+export declare const CursorWrapper: React.ForwardRefExoticComponent<Omit<WidgetViewComponentProps, "ref"> & React.RefAttributes<HTMLImageElement>>;

package/dist/types/components/EditorStateSelectorsProvider.d.ts

@@ -0,0 +1,10 @@
+import React, { ReactNode } from "react";
+interface RegistrarProps {
+    children: ReactNode;
+}
+export declare function EditorStateSelectorsRegistrar({ children }: RegistrarProps): React.JSX.Element;
+interface ProviderProps {
+    children: JSX.Element | null;
+}
+export declare function EditorStateSelectorsProvider({ children }: ProviderProps): JSX.Element | null;
+export {};

package/dist/types/components/LayoutGroup.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+export interface LayoutGroupProps {
+    children: React.ReactNode;
+}
+/**
+ * Provides a boundary for grouping layout effects.
+ *
+ * Descendant components can invoke the `useLayoutGroupEffect` hook to register
+ * effects that run after all descendants within the group have processed their
+ * regular layout effects.
+ */
+export declare function LayoutGroup({ children }: LayoutGroupProps): React.JSX.Element;

package/dist/types/components/NativeWidgetView.d.ts

@@ -0,0 +1,8 @@
+import { Decoration } from "prosemirror-view";
+import React from "react";
+type Props = {
+    widget: Decoration;
+    getPos: () => number;
+};
+export declare function NativeWidgetView({ widget, getPos }: Props): React.JSX.Element;
+export {};

package/dist/types/components/OutputSpec.d.ts

@@ -0,0 +1,10 @@
+import { DOMOutputSpec } from "prosemirror-model";
+import React, { HTMLProps, ReactNode, Ref } from "react";
+type Props = HTMLProps<HTMLElement> & {
+    outputSpec: DOMOutputSpec;
+    isMark?: boolean;
+    children?: ReactNode;
+    contentDOMRef: Ref<HTMLElement | null>;
+};
+declare const ForwardedOutputSpec: React.MemoExoticComponent<React.ForwardRefExoticComponent<Omit<Props, "ref"> & React.RefAttributes<HTMLElement>>>;
+export { ForwardedOutputSpec as OutputSpec };

package/dist/types/components/ProseMirror.d.ts

@@ -0,0 +1,14 @@
+import React, { ComponentType, ReactNode } from "react";
+import { UseEditorOptions } from "../hooks/useEditor.js";
+import { MarkViewComponentProps } from "./marks/MarkViewComponentProps.js";
+import { NodeViewComponentProps } from "./nodes/NodeViewComponentProps.js";
+export type Props = UseEditorOptions & {
+    children?: ReactNode;
+    nodeViewComponents?: {
+        [nodeType: string]: ComponentType<NodeViewComponentProps>;
+    };
+    markViewComponents?: {
+        [markType: string]: ComponentType<MarkViewComponentProps>;
+    };
+};
+export declare function ProseMirror(props: Props): React.JSX.Element;

package/dist/types/components/ProseMirrorDoc.d.ts

@@ -0,0 +1,16 @@
+import { Node } from "prosemirror-model";
+import { Decoration, DecorationSource } from "prosemirror-view";
+import React, { ElementType, HTMLProps } from "react";
+export interface DocNodeViewContextValue {
+    node: Node;
+    getPos: () => number;
+    decorations: readonly Decoration[];
+    innerDecorations: DecorationSource;
+    setMount: (mount: HTMLElement | null) => void;
+}
+export declare const DocNodeViewContext: React.Context<DocNodeViewContextValue>;
+interface Props extends Omit<HTMLProps<HTMLElement>, "as"> {
+    as?: ElementType;
+}
+export declare const ProseMirrorDoc: React.ForwardRefExoticComponent<Omit<Props, "ref"> & React.RefAttributes<HTMLElement>>;
+export {};

package/dist/types/components/SeparatorHackView.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+type Props = {
+    getPos: () => number;
+};
+export declare function SeparatorHackView({ getPos }: Props): React.JSX.Element | null;
+export {};

package/dist/types/components/TextNodeView.d.ts

@@ -0,0 +1,27 @@
+import { Node } from "prosemirror-model";
+import { Decoration } from "prosemirror-view";
+import { Component, MutableRefObject } from "react";
+import { AbstractEditorView } from "../AbstractEditorView.js";
+import { TextViewDesc, ViewDesc } from "../viewdesc.js";
+type Props = {
+    view: AbstractEditorView;
+    node: Node;
+    getPos: () => number;
+    siblingsRef: MutableRefObject<ViewDesc[]>;
+    parentRef: MutableRefObject<ViewDesc | undefined>;
+    decorations: readonly Decoration[];
+};
+export declare class TextNodeView extends Component<Props> {
+    viewDescRef: MutableRefObject<TextViewDesc | null>;
+    create(): TextViewDesc | null;
+    update(): boolean;
+    destroy(): void;
+    updateEffect(): void;
+    shouldComponentUpdate(nextProps: Props): boolean;
+    constructor(props: Props);
+    componentDidMount(): void;
+    componentDidUpdate(): void;
+    componentWillUnmount(): void;
+    render(): JSX.Element;
+}
+export {};

package/dist/types/components/TrailingHackView.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+type Props = {
+    getPos: () => number;
+};
+export declare function TrailingHackView({ getPos }: Props): React.JSX.Element;
+export {};

package/dist/types/components/WidgetView.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+import { ReactWidgetDecoration } from "../decorations/ReactWidgetType.js";
+type Props = {
+    widget: ReactWidgetDecoration;
+    getPos: () => number;
+};
+export declare function WidgetView({ widget, getPos }: Props): React.JSX.Element;
+export {};

package/dist/types/components/WidgetViewComponentProps.d.ts

@@ -0,0 +1,7 @@
+import { AllHTMLAttributes, LegacyRef } from "react";
+import { ReactWidgetDecoration } from "../decorations/ReactWidgetType.js";
+export type WidgetViewComponentProps<Attributes = AllHTMLAttributes<HTMLElement>> = Attributes & {
+    widget: ReactWidgetDecoration;
+    getPos: () => number;
+    ref: LegacyRef<any>;
+};

package/dist/types/components/__tests__/ProseMirror.composition.test.d.ts

@@ -0,0 +1,17 @@
+import "@wdio/types";
+declare global {
+    namespace WebdriverIO {
+        interface Browser {
+            imeSetComposition(params: {
+                text: string;
+                selectionStart?: number;
+                selectionEnd?: number;
+                replacementStart?: number;
+                replacementEnd?: number;
+            }): Promise<void>;
+            imeInsertText(params: {
+                text: string;
+            }): Promise<void>;
+        }
+    }
+}

package/dist/types/components/__tests__/ProseMirror.domchange.test.d.ts

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

package/dist/types/components/__tests__/ProseMirror.draw-decoration.test.d.ts

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

package/dist/types/components/__tests__/ProseMirror.draw.test.d.ts

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

package/dist/types/components/__tests__/ProseMirror.memory-leak.test.d.ts

@@ -0,0 +1,6 @@
+declare global {
+    interface Window {
+        gc?: () => void;
+    }
+}
+export {};

package/dist/types/components/__tests__/ProseMirror.mobile.test.d.ts

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

package/dist/types/components/__tests__/ProseMirror.node-view.test.d.ts

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

package/dist/types/components/__tests__/ProseMirror.selection.test.d.ts

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

package/dist/types/components/__tests__/ProseMirror.test.d.ts

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

package/dist/types/components/__tests__/stableContexts.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The `stableContexts` option relies on a `useSyncExternalStore` consumer
+ * landing in the same commit as its parent's state update when the store is
+ * notified inside flushSync. The pure-React cases pin that down; the editor
+ * cases are the invariants the option must keep, run with it off and on.
+ */
+declare global {
+    var IS_REACT_ACT_ENVIRONMENT: boolean | undefined;
+}
+export {};

package/dist/types/components/marks/DefaultMarkView.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import { MarkViewComponentProps } from "./MarkViewComponentProps.js";
+export declare const DefaultMarkView: React.ForwardRefExoticComponent<Omit<MarkViewComponentProps, "ref"> & React.RefAttributes<HTMLElement>>;

package/dist/types/components/marks/MarkView.d.ts

@@ -0,0 +1,10 @@
+import { Mark } from "prosemirror-model";
+import React, { ReactNode } from "react";
+type Props = {
+    mark: Mark;
+    inline: boolean;
+    getPos: () => number;
+    children: ReactNode;
+};
+export declare const MarkView: React.MemoExoticComponent<(props: Props) => React.JSX.Element>;
+export {};

package/dist/types/components/marks/MarkViewComponentProps.d.ts

@@ -0,0 +1,11 @@
+import { Mark } from "prosemirror-model";
+import { AllHTMLAttributes, LegacyRef, Ref } from "react";
+export type MarkViewComponentProps<Attributes = AllHTMLAttributes<HTMLElement>> = Attributes & {
+    markProps: {
+        mark: Mark;
+        inline: boolean;
+        getPos: () => number;
+        contentDOMRef: Exclude<Ref<any>, null>;
+    };
+    ref: LegacyRef<any>;
+};

package/dist/types/components/marks/MarkViewConstructorView.d.ts

@@ -0,0 +1,12 @@
+import { Mark } from "prosemirror-model";
+import { MarkViewConstructor } from "prosemirror-view";
+import React, { ReactNode } from "react";
+interface Props {
+    constructor: MarkViewConstructor;
+    mark: Mark;
+    inline: boolean;
+    getPos: () => number;
+    children: ReactNode;
+}
+export declare const MarkViewConstructorView: React.MemoExoticComponent<({ constructor, mark, inline, getPos, children, }: Props) => React.JSX.Element>;
+export {};

package/dist/types/components/marks/ReactMarkView.d.ts

@@ -0,0 +1,12 @@
+import { Mark } from "prosemirror-model";
+import React, { ComponentType, ReactNode } from "react";
+import { MarkViewComponentProps } from "./MarkViewComponentProps.js";
+interface Props {
+    component: ComponentType<MarkViewComponentProps>;
+    mark: Mark;
+    getPos: () => number;
+    inline: boolean;
+    children: ReactNode;
+}
+export declare const ReactMarkView: React.MemoExoticComponent<({ component: Component, mark, inline, getPos, children, }: Props) => React.JSX.Element>;
+export {};

package/dist/types/components/nodes/DefaultNodeView.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import { NodeViewComponentProps } from "../nodes/NodeViewComponentProps.js";
+export declare const DefaultNodeView: React.ForwardRefExoticComponent<Omit<NodeViewComponentProps, "ref"> & React.RefAttributes<HTMLElement>>;

package/dist/types/components/nodes/DocNodeView.d.ts

@@ -0,0 +1,12 @@
+import { Node } from "prosemirror-model";
+import { Decoration, DecorationSource } from "prosemirror-view";
+import React, { ElementType, HTMLProps } from "react";
+export interface DocNodeViewProps extends Omit<HTMLProps<HTMLElement>, "as"> {
+    as?: ElementType;
+    node: Node;
+    getPos: () => number;
+    decorations: readonly Decoration[];
+    innerDecorations: DecorationSource;
+    setMount: (mount: HTMLElement | null) => void;
+}
+export declare const DocNodeView: React.MemoExoticComponent<React.ForwardRefExoticComponent<Omit<DocNodeViewProps, "ref"> & React.RefAttributes<HTMLElement>>>;

package/dist/types/components/nodes/NodeView.d.ts

@@ -0,0 +1,14 @@
+import { Node } from "prosemirror-model";
+import { Decoration, DecorationSource } from "prosemirror-view";
+import React from "react";
+type Props = {
+    node: Node;
+    getPos: () => number;
+    outerDeco: readonly Decoration[];
+    innerDeco: DecorationSource;
+    forceRemount: () => void;
+};
+export declare const NodeView: React.MemoExoticComponent<({ forceRemount, ...props }: Props) => JSX.Element | null>;
+export declare const GetPosContext: React.Context<() => number>;
+export declare function RemountableNodeView(props: Omit<Props, "forceRemount">): React.JSX.Element;
+export {};

package/dist/types/components/nodes/NodeViewComponentProps.d.ts

@@ -0,0 +1,13 @@
+import { Node } from "prosemirror-model";
+import { Decoration, DecorationSource } from "prosemirror-view";
+import { AllHTMLAttributes, LegacyRef, Ref } from "react";
+export type NodeViewComponentProps<Attributes = AllHTMLAttributes<HTMLElement>> = Attributes & {
+    nodeProps: {
+        decorations: readonly Decoration[];
+        innerDecorations: DecorationSource;
+        node: Node;
+        getPos: () => number;
+        contentDOMRef: Exclude<Ref<any>, null>;
+    };
+    ref: LegacyRef<any>;
+};

package/dist/types/components/nodes/NodeViewConstructorView.d.ts

@@ -0,0 +1,12 @@
+import { Node } from "prosemirror-model";
+import { Decoration, DecorationSource, NodeViewConstructor } from "prosemirror-view";
+import React from "react";
+interface Props {
+    constructor: NodeViewConstructor;
+    node: Node;
+    getPos: () => number;
+    innerDeco: DecorationSource;
+    outerDeco: readonly Decoration[];
+}
+export declare const NodeViewConstructorView: React.MemoExoticComponent<({ constructor, node, getPos, innerDeco, outerDeco, }: Props) => React.FunctionComponentElement<any>>;
+export {};

package/dist/types/components/nodes/ReactNodeView.d.ts

@@ -0,0 +1,13 @@
+import { Node } from "prosemirror-model";
+import { Decoration, DecorationSource } from "prosemirror-view";
+import React, { ComponentType } from "react";
+import { NodeViewComponentProps } from "../nodes/NodeViewComponentProps.js";
+type Props = {
+    component: ComponentType<NodeViewComponentProps>;
+    outerDeco: readonly Decoration[];
+    getPos: () => number;
+    node: Node;
+    innerDeco: DecorationSource;
+};
+export declare const ReactNodeView: React.MemoExoticComponent<({ component: Component, outerDeco, getPos, node, innerDeco, }: Props) => React.JSX.Element>;
+export {};

package/dist/types/constants.d.ts

@@ -0,0 +1,4 @@
+import { Schema } from "prosemirror-model";
+import { EditorState } from "prosemirror-state";
+export declare const EMPTY_SCHEMA: Schema<"text" | "doc", any>;
+export declare const EMPTY_STATE: EditorState;

package/dist/types/contexts/ChildDescriptionsContext.d.ts

@@ -0,0 +1,7 @@
+import { MutableRefObject } from "react";
+import { ViewDesc } from "../viewdesc.js";
+export type ChildDescriptionsContextValue = {
+    parentRef: MutableRefObject<ViewDesc | undefined>;
+    siblingsRef: MutableRefObject<ViewDesc[]>;
+};
+export declare const ChildDescriptionsContext: import("react").Context<ChildDescriptionsContextValue>;

package/dist/types/contexts/EditorContext.d.ts

@@ -0,0 +1,18 @@
+import type { DOMEventMap } from "prosemirror-view";
+import { MutableRefObject } from "react";
+import { AbstractEditorView } from "../AbstractEditorView.js";
+import type { EventHandler } from "../hooks/useComponentEventListeners.js";
+export interface EditorContextValue {
+    view: AbstractEditorView;
+    flushSyncRef: MutableRefObject<boolean>;
+    registerEventListener<EventType extends keyof DOMEventMap>(eventType: EventType, handler: EventHandler<EventType>): void;
+    unregisterEventListener<EventType extends keyof DOMEventMap>(eventType: EventType, handler: EventHandler<EventType>): void;
+    isStatic: boolean;
+}
+/**
+ * Provides the EditorView, as well as the current
+ * EditorState. Should not be consumed directly; instead
+ * see `useEditorState`, `useEditorViewEvent`, and
+ * `useEditorViewLayoutEffect`.
+ */
+export declare const EditorContext: import("react").Context<EditorContextValue>;

package/dist/types/contexts/EditorStateContext.d.ts

@@ -0,0 +1,2 @@
+import { EditorState } from "prosemirror-state";
+export declare const EditorStateContext: import("react").Context<EditorState>;

package/dist/types/contexts/EditorStateStoreContext.d.ts

@@ -0,0 +1,9 @@
+import { EditorState } from "prosemirror-state";
+export interface EditorStateStore {
+    getState: () => EditorState;
+    subscribe: (listener: () => void) => () => void;
+    setState: (state: EditorState) => void;
+    notifyListeners: () => void;
+}
+export declare function createEditorStateStore(): EditorStateStore;
+export declare const EditorStateStoreContext: import("react").Context<EditorStateStore>;

package/dist/types/contexts/IgnoreMutationContext.d.ts

@@ -0,0 +1,5 @@
+import { MarkView, NodeView, ViewMutationRecord } from "prosemirror-view";
+export type IgnoreMutation = (this: NodeView | MarkView, mutation: ViewMutationRecord) => boolean;
+type IgnoreMutationtContextValue = (ignoreMutation: IgnoreMutation) => void;
+export declare const IgnoreMutationContext: import("react").Context<IgnoreMutationtContextValue>;
+export {};

package/dist/types/contexts/LayoutGroupContext.d.ts

@@ -0,0 +1,5 @@
+import type { EffectCallback } from "react";
+export interface LayoutGroupContextValue {
+    (effect: EffectCallback): ReturnType<EffectCallback>;
+}
+export declare const LayoutGroupContext: import("react").Context<LayoutGroupContextValue>;

package/dist/types/contexts/NodeViewContext.d.ts

@@ -0,0 +1,9 @@
+import { ComponentType } from "react";
+import { NodeViewSet } from "../AbstractEditorView.js";
+import { MarkViewComponentProps } from "../components/marks/MarkViewComponentProps.js";
+import { NodeViewComponentProps } from "../components/nodes/NodeViewComponentProps.js";
+export type NodeViewContextValue = {
+    components: Record<string, ComponentType<NodeViewComponentProps> | ComponentType<MarkViewComponentProps>>;
+    constructors: NodeViewSet;
+};
+export declare const NodeViewContext: import("react").Context<NodeViewContextValue>;

package/dist/types/contexts/RenderStoreContext.d.ts

@@ -0,0 +1,24 @@
+import { EditorState } from "prosemirror-state";
+import type { DocNodeViewContextValue } from "../components/ProseMirrorDoc.js";
+/**
+ * Backs the `stableContexts` option. With it on, EditorStateContext and
+ * DocNodeViewContext keep their values across a transaction dispatched
+ * through flushSync, so React does not scan every memoised node view for
+ * their consumers. The consumers subscribe here instead: `announce` runs
+ * inside that flushSync, before React renders, so they re-render in the same
+ * commit as the doc and read the values ProseMirrorInner wrote during its
+ * render.
+ */
+export interface RenderStore {
+    state: EditorState | null;
+    doc: DocNodeViewContextValue | null;
+    /** Set by `announce`, consumed by the next ProseMirrorInner render. */
+    announced: boolean;
+    getVersion: () => number;
+    subscribe: (listener: () => void) => () => void;
+    announce: () => void;
+}
+export declare const createRenderStore: () => RenderStore;
+export declare const RenderStoreContext: import("react").Context<RenderStore | null>;
+/** Subscribes to announced transactions; null when `stableContexts` is off. */
+export declare const useRenderStore: () => RenderStore | null;

package/dist/types/contexts/SelectNodeContext.d.ts

@@ -0,0 +1,5 @@
+export type SelectNode = () => void;
+export type DeselectNode = () => void;
+type SelectNodeContextValue = (selectNode: SelectNode, deselectNode: DeselectNode) => void;
+export declare const SelectNodeContext: import("react").Context<SelectNodeContextValue>;
+export {};

package/dist/types/contexts/StopEventContext.d.ts

@@ -0,0 +1,5 @@
+import { NodeView } from "prosemirror-view";
+export type StopEvent = (event: Event) => boolean;
+type StopEventContextValue = (stopEvent: (this: NodeView, event: Event) => boolean) => void;
+export declare const StopEventContext: import("react").Context<StopEventContextValue>;
+export {};