The ViewDesc classes are where prosemirror-view actually does all of
its rendering work. We are introducing stubs of these classes that
reproduce all of the functionality of the originals, but do not provide
update or destroy methods, which means that they do not actually do any
DOM manipulation.

The goal is to later introduce React components that replicate the
rendering functionality of the original ViewDesc classes.

This commit adds a new React component for each ViewDesc subclass
(NodeView, MarkView, etc.). These React components take the place of
the update methods from prosemirror-view's original ViewDesc classes.

In order to maintain React element and DOM node stability, this commit
also introduces a more robust reactKeys plugin that accounts for text
nodes in addition to non-text nodes.

The useBeforeInput hook replaces the DOMObserver functionality that
we plan to remove from EditorView.

usePluginViews manages plugin view updates, to ensure that they occur
after the DOM has been updated to match the state.

useSyncSelection similarly ensures that the ProseMirror selection is
synced to the DOM after the DOM has been updated to match the state.

EditorView's DOMObserver uses a Mutation Observer to detect changes to
the contenteditable, and then attempts to deduce the intended change to
state from that. This introduces challenges when applied to React's
unidirection data flow model.

To work around this, we use a beforeinput handler to detect changes
before they're committed to the DOM. This means our DOMObserver only
needs to worry about syncing the selection, so we added a custom one
that only has that concern, but matches the API of the original
implementation.

Fully integrates the new components and hooks into the ProseMirror
component. This includes subclassing EditorView to override some of
its properties, like the docNodeView and domObserver.

This commit also adds a full test suite for the ProseMirror component's
editing functionality.

Rather than attempting to map the new node positions backward to
determine what the key used to be for that node, start with the previous
positions and map them forward, taking care to skip any positions that
are deleted by the transaction, and adding any new nodes that didn't
exist in the old doc. This improves stability and correctness in more
complex cases, such as splitting or wrapping nodes, and nested
deletions.

This resolves an issue where LayoutGroup effects were not cleaned up
when the LayoutGroup itself was unmounted. React executes layout effect
destroy functions from parent to child on unmount, which is opposite how
it runs during normal render. The result was that the destroyQueue was
never processed on unmount.

Now, if the LayoutGroup is being unmounted, we call destroy functions
immediately, without queuing.

This tracks a few PRs from main that update hooks like useEditorState and
useEditorEffect to always provide non-null state and view objects.

It also updates the useEditorView hook (now useEditor) to look more like
that on main, inlining several function calls and moving most hook usage
from the ProseMirror component into the useEditor hook.

* Add a component for rendering ProseMirror-native widgets

* Support plugin-provided custom node views

When rendering nested ProseMirror editors, e.g.
when taking control over an atom node's content,
the nested DocNodeView would register itself as
the child of the atom node in the view descriptor
tree. This could cause subtle issues when, e.g.,
ProseMirror attempts to determine whether the
content is ltr or rtl, because it would treat the
nested editor as the contentDOM of the atom, even
if it was rendered in a portal into a non-
contiguous part of the page. Presumably other
issues could also arise from the fact that
ProseMirror thought this node had a contentDOM
when it actually does not.

This change resolves this by simply providing a top-
level ChildDescriptorContext, so that nested
editors never accidentally cross the boundary up
into their parents' view descriptor tree.

Browsers have very particular opinions about where they will allow
users to place selections in contenteditable elements. ProseMirror
manages this in part by placing <br> elements in locations that
browsers otherwise wouldn't allow user selections.

This PR brings react-prosemirror closer to matching all of the
situations that ProseMirror itself uses these "trailing hacks". Rather
than only in empty textblocks, we now also place trailing hacks when
a textblock node ends with a non-text node, a widget, or a text node
that ends with a newline.

Also, Safari and Chrome both have cursor drawing/selection bugs that
prevent users from making selections after non-contenteditable
inline nodes in some situations. To work around this, in these
browsers, we add an empty image element between the trailing non-
contenteditable node and the "trailing hack", which allows users
to place cursors there.

There were a few places where we incorrectly used view.someProp to
retrieve a prop value, and then did something with the value. This will
_always_ result in the first value being returned, even in cases where
multiple plugins provide a value for the prop, and only some of them
are relevant at the callsite.

Instead, we now pass a function to view.someProp that only returns a
truthy value when it has found a prop provider that provides the
relevant value, so that we can fallback through the entire list of
plugins.

Previously, `deleteContentBackward|Forward` inputs would delete exactly
one code point. This created invalid strings when the last code point
was part of a multi-code-point character.

To resolve this, we now determine the length of the unicode character,
and delete by that many code points, which matches default
contentEditable behavior.

Rather than using Slate.js's more manual approach for determining how
many code points to delete when handling a deleteContentBackward|Forward
input type, rely on the browser's default determination via
getTargetRanges.

* Disable react/prop-types lint rule

* Flesh out conversion from html attributes to react props

* Properly merge decorations/props with outputspecs

* Use CSSOM to parse style attributes

* Re-enable react/prop-types rule

and running yarn version prerelease

…reate and update

The primary goal of these changes is to allow a single node view component to re-render in isolation without affecting the correctness of the view descriptor tree.

Previously, it was required that the entire ProseMirror component tree re-render on every document update in order to maintain the view descriptor tree. The trees are built from the leaves up in useLayoutEffects, and the tree was built from scratch on each render cycle.

Now, the view descriptors are maintained in refs across renders, and mutated as needed, rather than built from scratch. This fixes an issue with strict mode (#128), since strict mode will render each component twice when it's first mounted. It also allows us to wrap each view component in React.memo, which quite dramatically improves the performance of the editor on very long documents.