@stesura/react-prosemirror 3.2.11-stesura.1

package/dist/types/contexts/__tests__/DeferredLayoutEffects.test.d.ts

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

package/dist/types/decorations/ReactWidgetType.d.ts

@@ -0,0 +1,40 @@
+import { Mark } from "prosemirror-model";
+import { Mappable } from "prosemirror-transform";
+import { Decoration } from "prosemirror-view";
+import { ForwardRefExoticComponent, RefAttributes } from "react";
+import { WidgetViewComponentProps } from "../components/WidgetViewComponentProps.js";
+import { DOMNode } from "../dom.js";
+export interface DecorationType {
+    spec: unknown;
+    map(mapping: Mappable, span: Decoration, offset: number, oldOffset: number): Decoration | null;
+    valid(node: Node, span: Decoration): boolean;
+    eq(other: DecorationType): boolean;
+    destroy(dom: DOMNode): void;
+}
+export type DecorationWithType = Decoration & {
+    type: DecorationType;
+};
+type ReactWidgetSpec = {
+    side?: number;
+    marks?: readonly Mark[];
+    stopEvent?: (event: Event) => boolean;
+    ignoreSelection?: boolean;
+    key?: string;
+    [key: string]: unknown;
+};
+export declare class ReactWidgetType implements DecorationType {
+    Component: ForwardRefExoticComponent<RefAttributes<HTMLElement> & WidgetViewComponentProps>;
+    side: number;
+    spec: ReactWidgetSpec;
+    constructor(Component: ForwardRefExoticComponent<RefAttributes<HTMLElement> & WidgetViewComponentProps>, spec?: ReactWidgetSpec);
+    map(mapping: Mappable, span: Decoration, offset: number, oldOffset: number): Decoration | null;
+    valid(): boolean;
+    eq(other: DecorationType): boolean;
+    destroy(): void;
+}
+export declare function widget<E extends HTMLElement>(pos: number, component: ForwardRefExoticComponent<RefAttributes<E> & WidgetViewComponentProps>, spec?: ReactWidgetSpec): Decoration;
+export interface ReactWidgetDecoration extends Decoration {
+    type: ReactWidgetType;
+    inline: false;
+}
+export {};

package/dist/types/decorations/computeDocDeco.d.ts

@@ -0,0 +1,14 @@
+import { Decoration } from "prosemirror-view";
+import { AbstractEditorView } from "../AbstractEditorView.js";
+/**
+ * Produces the outer decorations for the doc node, based
+ * on the attributes editor prop.
+ *
+ * The return value of this function is memoized; if it is to
+ * return an equivalent value to the last time it was called for
+ * a given EditorView, it will return exactly that previous value.
+ *
+ * This makes it safe to call in a React render function, even
+ * if its result is used in a dependencies array for a hook.
+ */
+export declare function computeDocDeco(view: AbstractEditorView): [Decoration];

package/dist/types/decorations/internalTypes.d.ts

@@ -0,0 +1,20 @@
+import { Node } from "prosemirror-model";
+import { Mapping } from "prosemirror-transform";
+import { Decoration, DecorationSet, DecorationSource } from "prosemirror-view";
+import { DecorationType } from "./ReactWidgetType.js";
+export interface InternalDecorationSource {
+    map: (mapping: Mapping, node: Node) => DecorationSource;
+    locals(node: Node): readonly Decoration[];
+    forChild(offset: number, child: Node): DecorationSource;
+    eq(other: DecorationSource): boolean;
+    forEachSet(f: (set: DecorationSet) => void): void;
+}
+export interface InternalDecorationSet extends InternalDecorationSource {
+    localsInner(node: Node): readonly Decoration[];
+}
+export interface InternalDecoration extends Decoration {
+    type: DecorationType;
+    copy(from: number, to: number): Decoration;
+    widget: boolean;
+    inline: boolean;
+}

package/dist/types/decorations/iterDeco.d.ts

@@ -0,0 +1,3 @@
+import { Node } from "prosemirror-model";
+import { Decoration, DecorationSource } from "prosemirror-view";
+export declare function iterDeco(parent: Node, deco: DecorationSource, onWidget: (widget: Decoration, isNative: boolean, offset: number, index: number, insideNode: boolean) => void, onNode: (node: Node, outerDeco: readonly Decoration[], innerDeco: DecorationSource, offset: number, index: number) => void): void;

package/dist/types/decorations/viewDecorations.d.ts

@@ -0,0 +1,14 @@
+import { DecorationSource } from "prosemirror-view";
+import { AbstractEditorView } from "../AbstractEditorView.js";
+/**
+ * Produces the DecorationSource for the current state, based
+ * on the decorations editor prop.
+ *
+ * The return value of this function is memoized; if it is to
+ * return an equivalent value to the last time it was called for
+ * a given EditorView, it will return exactly that previous value.
+ *
+ * This makes it safe to call in a React render function, even
+ * if its result is used in a dependencies array for a hook.
+ */
+export declare function viewDecorations(view: AbstractEditorView): DecorationSource;

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/findDOMNode.d.ts

@@ -0,0 +1,3 @@
+import { Component } from "react";
+export declare function getInstance(key: Component): unknown;
+export declare function findDOMNode(componentOrElement: Component<unknown, unknown>): null | Element | Text;

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

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

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

@@ -0,0 +1,2 @@
+import { useLayoutEffect } from "react";
+export declare function useClientLayoutEffect(...args: Parameters<typeof useLayoutEffect>): void;

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

@@ -0,0 +1,34 @@
+import type { DOMEventMap, EditorView } from "prosemirror-view";
+export type EventHandler<EventType extends keyof DOMEventMap = keyof DOMEventMap> = (view: EditorView, event: DOMEventMap[EventType]) => boolean | void;
+export type HandleDOMEvents = Record<keyof DOMEventMap, EventHandler | undefined>;
+/**
+ * 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 event listeners.
+ *
+ * The hook 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 handleDOMEVents record whenever a new event type is
+ * registered. We avoid producing a new record in any other
+ * scenario to avoid the performance overhead of re-registering the event
+ * listeners in the EditorView.
+ *
+ * To accomplish this, we shallowly clone the registry whenever a new event
+ * type is registered.
+ */
+export declare function useComponentEventListeners(handleDOMEventsProp: HandleDOMEvents | undefined): {
+    registerEventListener: (eventType: keyof DOMEventMap, handler: EventHandler) => void;
+    unregisterEventListener: (eventType: keyof DOMEventMap, handler: EventHandler) => void;
+    handleDOMEvents: HandleDOMEvents;
+};

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

@@ -0,0 +1,37 @@
+import { EditorState, Plugin, Transaction } from "prosemirror-state";
+import { EditorProps, EditorView } from "prosemirror-view";
+import { AbstractEditorView } from "../AbstractEditorView.js";
+export interface UseEditorOptions extends EditorProps {
+    defaultState?: EditorState;
+    state?: EditorState;
+    plugins?: readonly Plugin[];
+    dispatchTransaction?(this: EditorView, tr: Transaction): void;
+    static?: boolean;
+    /**
+     * Keep the editor's state and doc contexts stable across transactions
+     * dispatched synchronously, so that a transaction does not make React scan
+     * every memoised node view. Leave off when transactions carry the `async`
+     * meta.
+     */
+    stableContexts?: boolean;
+}
+/**
+ * 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: AbstractEditorView;
+        flushSyncRef: import("react").MutableRefObject<boolean>;
+        registerEventListener: (eventType: keyof import("prosemirror-view").DOMEventMap, handler: import("./useComponentEventListeners.js").EventHandler) => void;
+        unregisterEventListener: (eventType: keyof import("prosemirror-view").DOMEventMap, handler: import("./useComponentEventListeners.js").EventHandler) => void;
+        isStatic: boolean;
+    };
+    state: EditorState;
+    renderStore: import("../contexts/RenderStoreContext.js").RenderStore | null;
+};

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

@@ -0,0 +1,21 @@
+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.
+ *
+ * This hook can only be used in a component that is mounted
+ * as a child of the TiptapEditorView component, including
+ * React node view components.
+ */
+export declare function useEditorEffect(effect: (editorView: EditorView) => void | (() => void), dependencies?: DependencyList): void;

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

@@ -0,0 +1,13 @@
+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 can only be used in a component that is mounted
+ * as a child of the TiptapEditorView component, including
+ * React node view components.
+ */
+export declare function useEditorEventCallback<This, T extends unknown[], R>(callback: (this: This, view: EditorView, ...args: T) => R): (this: This, ...args: T) => R;

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

@@ -0,0 +1,8 @@
+import type { DOMEventMap } from "prosemirror-view";
+import type { EventHandler } from "./useComponentEventListeners.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/useEditorStateSelector.d.ts

@@ -0,0 +1,10 @@
+import { EditorState } from "prosemirror-state";
+/**
+ * Select a piece of the EditorState, a la Redux’s
+ * `useSelector`.
+ *
+ * This hook will only trigger a re-render of the
+ * consuming component if the return value of the selector
+ * changes.
+ */
+export declare function useEditorStateSelector<Result>(selector: (state: EditorState) => Result): Result;

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

@@ -0,0 +1 @@
+export declare function useEffectEvent<P extends unknown[], R>(fn: (...args: P) => R): (...funcArgs: P) => R;

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/useIgnoreMutation.d.ts

@@ -0,0 +1,2 @@
+import { EditorView, MarkView, NodeView, ViewMutationRecord } from "prosemirror-view";
+export declare function useIgnoreMutation(ignoreMutation: (this: NodeView | MarkView, view: EditorView, mutation: ViewMutationRecord) => boolean): void;

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

@@ -0,0 +1,4 @@
+/**
+ * Returns true while an IME composition is active inside the current node.
+ */
+export declare function useIsComposingIn(): boolean;

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

@@ -0,0 +1,5 @@
+/**
+ * Returns true if the nearest ProseMirror component
+ * is rendered with the `static` prop set to `true`.
+ */
+export declare function useIsEditorStatic(): boolean;

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

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

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/useMarkViewDescription.d.ts

@@ -0,0 +1,15 @@
+import { MarkViewConstructor } from "prosemirror-view";
+import { MarkViewComponentProps } from "../components/marks/MarkViewComponentProps.js";
+import { MarkViewDesc, ViewDesc } from "../viewdesc.js";
+type Props = Omit<MarkViewComponentProps["markProps"], "contentDOMRef">;
+export declare function useMarkViewDescription(getDOM: () => HTMLElement | null, getContentDOM: (markView: {
+    contentDOM?: HTMLElement | null;
+} | null) => HTMLElement | null, constructor: MarkViewConstructor, props: Props): {
+    childContextValue: {
+        parentRef: import("react").MutableRefObject<MarkViewDesc | undefined>;
+        siblingsRef: import("react").MutableRefObject<ViewDesc[]>;
+    };
+    contentDOM: HTMLElement | undefined;
+    refUpdated: () => void;
+};
+export {};

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

@@ -0,0 +1,9 @@
+/**
+ * Get this node's current position in the document.
+ *
+ * Using this hook will subscribe this node to the
+ * EditorState, which means that it will be re-rendered
+ * on every EditorState update. This may have performance
+ * implications for large documents.
+ */
+export declare function useNodePos(): number;

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

@@ -0,0 +1,16 @@
+import { NodeViewConstructor } from "prosemirror-view";
+import { NodeViewComponentProps } from "../components/nodes/NodeViewComponentProps.js";
+import { NodeViewDesc, ViewDesc } from "../viewdesc.js";
+type Props = Omit<NodeViewComponentProps["nodeProps"], "contentDOMRef">;
+export declare function useNodeViewDescription(getDOM: () => HTMLElement | null, getContentDOM: (nodeView: {
+    contentDOM?: HTMLElement | null;
+} | null) => HTMLElement | null, constructor: NodeViewConstructor, props: Props): {
+    childContextValue: {
+        parentRef: import("react").MutableRefObject<NodeViewDesc | undefined>;
+        siblingsRef: import("react").MutableRefObject<ViewDesc[]>;
+    };
+    contentDOM: HTMLElement | null;
+    refUpdated: () => void;
+    isMounted: () => boolean;
+};
+export {};

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

@@ -0,0 +1,2 @@
+import { ReactKeysPluginState } from "../plugins/reactKeys.js";
+export declare function useReactKeys(): ReactKeysPluginState | undefined;

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

@@ -0,0 +1,2 @@
+import { EditorView } from "prosemirror-view";
+export declare function useSelectNode(selectNode: (view: EditorView) => void, deselectNode?: (view: EditorView) => void): void;

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

@@ -0,0 +1,2 @@
+import { MutableRefObject } from "react";
+export declare function useSetDom(domRef: MutableRefObject<HTMLElement | null>, refUpdated: () => void, isMounted?: () => boolean, forceUpdate?: () => void): (el: HTMLElement | null) => void;

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

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

package/dist/types/index.d.ts

@@ -0,0 +1,21 @@
+export { ProseMirror } from "./components/ProseMirror.js";
+export { ProseMirrorDoc } from "./components/ProseMirrorDoc.js";
+export { reorderSiblings } from "./commands/reorderSiblings.js";
+export { useIsComposingIn } from "./hooks/useIsComposingIn.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 { useNodePos } from "./hooks/useNodePos.js";
+export { useEditorStateSelector } from "./hooks/useEditorStateSelector.js";
+export { useStopEvent } from "./hooks/useStopEvent.js";
+export { useSelectNode } from "./hooks/useSelectNode.js";
+export { useIgnoreMutation } from "./hooks/useIgnoreMutation.js";
+export { useIsEditorStatic } from "./hooks/useIsEditorStatic.js";
+export { useIsNodeSelected } from "./hooks/useIsNodeSelected.js";
+export { reactKeys } from "./plugins/reactKeys.js";
+export { widget } from "./decorations/ReactWidgetType.js";
+export { useMergedDOMRefs } from "./refs.js";
+export type { NodeViewComponentProps } from "./components/nodes/NodeViewComponentProps.js";
+export type { MarkViewComponentProps } from "./components/marks/MarkViewComponentProps.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,2 @@
+import { Plugin } from "prosemirror-state";
+export declare function beforeInputPlugin(): Plugin<any>;

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

@@ -0,0 +1,23 @@
+import { Plugin, PluginKey } from "prosemirror-state";
+import { Decoration } from "prosemirror-view";
+export declare function createNodeKey(): string;
+export interface ReactKeysPluginState {
+    posToKey: Map<number, string>;
+    keyToPos: Map<string, number>;
+    cursorWrapper: Decoration | null;
+    freezeFrom: number | null;
+}
+export declare const reactKeysPluginKey: PluginKey<ReactKeysPluginState>;
+export type ReactKeysPluginMeta = {
+    overrides?: Record<number, number>;
+    cursorWrapper?: Decoration | null;
+    freezeFrom?: number | null;
+} | undefined;
+/**
+ * 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<ReactKeysPluginState>;