@stesura/react-wordgard 0.1.0 → 0.2.1

package/dist/decorations/ReactWrapperType.js

@@ -1,9 +1,5 @@
-// Named after ReactWidgetType: a React wrapper is a real Wordgard `Elt` with a
-// hole, the wrapper plain Wordgard draws (`Decoration.Tag.wrapper`,
-// `Decoration.Point.wrapper`), registered as drawn by a component, which
-// renders what it wraps as `children`. Registered as React shapes are (the
-// reserved attribute); its props are a React shape's without `contentDOMRef`:
-// `children` goes where the hole is.
+// Named after ReactWidgetType. A React wrapper is a real Wordgard `Elt` with a hole, registered as
+// React shapes are (the reserved attribute).
 import { createElement, } from "react";
 import { Elt } from "wordgard/doc";
 import { takesRef } from "../helpers/refs.js";
@@ -12,6 +8,7 @@ import { idOf, reserved } from "./ReactShapeType.js";
 const draws = new Map();
 // By component, then root element, as React shapes are.
 const wrappers = new WeakMap();
+/** A wrapper, for `Decoration.Tag.wrapper` and `Decoration.Point.wrapper`. */
 export const createWrapper = (component, { element = "div" } = {}) => {
     let registered = wrappers.get(component);
     if (!registered) {

package/dist/decorations/iterDeco.js

@@ -1,9 +1,6 @@
-// Named after react-prosemirror's iterDeco, rewritten for Wordgard: lays out a
-// plot's content from Wordgard's DecoIterator (copied in ./DecoIterator.ts),
-// the way its ContentUpdate.build does (src/editor/tile.ts in its repo), for
-// React to render and ReactDocTile to build tiles over. Each plot is laid out
-// on its own; a plot that kept its identity outside the ranges an update
-// redraws keeps its previous layout.
+// Named after react-prosemirror's iterDeco, rewritten for Wordgard: lays out a plot's content from
+// DecoIterator, as Wordgard's ContentUpdate.build does. A plot that kept its identity outside the
+// redrawn ranges keeps its previous layout.
 import { Attributes, Elt, Leaf, Mark } from "wordgard/doc";
 import { Widget } from "wordgard/editor";
 import { isKept, pointMapper, samePlace, unchangedEnds } from "../changes.js";

package/dist/hooks/useEditorEffect.d.ts

@@ -1,3 +1,10 @@
 import { type DependencyList } from "react";
 import type { Wordgard } from "wordgard/editor";
+/**
+ * Runs `effect` once the editor's DOM is up to date: after the flush under way or pending, else in
+ * a microtask, never inside React's commit. It may read layout and dispatch; what it sets shows a
+ * frame later. For focus, follow-up dispatches and menus. The dependencies work as React's. Don't
+ * read the editor's layout from a plain React effect: it can run inside Wordgard's update, before
+ * the editor's view of the new DOM exists.
+ */
 export declare const useEditorEffect: (effect: (wg: Wordgard) => void | (() => void), dependencies?: DependencyList) => void;

package/dist/hooks/useEditorEffect.js

@@ -1,10 +1,13 @@
-// Named after react-prosemirror's useEditorEffect, rewritten for Wordgard: an
-// effect that runs once the editor's DOM is up to date, after the flush under
-// way or pending, else in a microtask, never inside React's commit, so it may
-// read the editor's layout and dispatch. A plain React effect may run inside
-// the flush, before the tiles over the new DOM exist.
+// Named after react-prosemirror's useEditorEffect, rewritten for Wordgard.
 import { useLayoutEffect } from "react";
 import { useEditorContext } from "../contexts/EditorContext.js";
+/**
+ * Runs `effect` once the editor's DOM is up to date: after the flush under way or pending, else in
+ * a microtask, never inside React's commit. It may read layout and dispatch; what it sets shows a
+ * frame later. For focus, follow-up dispatches and menus. The dependencies work as React's. Don't
+ * read the editor's layout from a plain React effect: it can run inside Wordgard's update, before
+ * the editor's view of the new DOM exists.
+ */
 export const useEditorEffect = (effect, dependencies) => {
     const { wg, afterFlush, cancel } = useEditorContext();
     useLayoutEffect(() => {
@@ -18,7 +21,8 @@ export const useEditorEffect = (effect, dependencies) => {
             if (typeof cleanup == "function")
                 cleanup();
         };
-        // The caller's dependencies, as with React's own effects.
+        // The caller's dependencies, as with React's own effects, and the editor:
+        // a WordgardScope can change it.
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, dependencies);
+    }, dependencies && [wg, ...dependencies]);
 };

package/dist/hooks/useEditorEventCallback.d.ts

@@ -1,2 +1,8 @@
 import type { Wordgard } from "wordgard/editor";
+/**
+ * A stable function calling the latest `callback` with the editor first, for event handlers. There,
+ * `wg.state` is the latest state, dispatches not yet drawn included. See the `SaveButton` in
+ * [Accessing the state outside the
+ * editor](https://github.com/stesura/react-wordgard#accessing-the-state-outside-the-editor).
+ */
 export declare const useEditorEventCallback: <Args extends unknown[], Result>(callback: (wg: Wordgard, ...args: Args) => Result) => (...args: Args) => Result;

package/dist/hooks/useEditorEventCallback.js

@@ -1,8 +1,12 @@
-// Named after react-prosemirror's useEditorEventCallback, rewritten for
-// Wordgard: a stable function calling the latest `callback` with the editor,
-// for event handlers.
+// Named after react-prosemirror's useEditorEventCallback, rewritten for Wordgard.
 import { useCallback, useLayoutEffect, useRef } from "react";
 import { useEditorContext } from "../contexts/EditorContext.js";
+/**
+ * A stable function calling the latest `callback` with the editor first, for event handlers. There,
+ * `wg.state` is the latest state, dispatches not yet drawn included. See the `SaveButton` in
+ * [Accessing the state outside the
+ * editor](https://github.com/stesura/react-wordgard#accessing-the-state-outside-the-editor).
+ */
 export const useEditorEventCallback = (callback) => {
     const { wg } = useEditorContext();
     const latest = useRef(callback);

package/dist/hooks/useEditorEventListener.d.ts

@@ -1,3 +1,10 @@
 import type { Wordgard } from "wordgard/editor";
 import { type EditorEvent } from "../contexts/editorEvents.js";
+/**
+ * Listens to the editor's DOM events of `type`, before Wordgard's handlers and keymaps. Returning
+ * `true` handles the event: Wordgard calls `preventDefault` and skips its own handling. The event
+ * types are listed under [Limits](https://github.com/stesura/react-wordgard#limits). Key events
+ * during a composition don't come; handling `input`, `beforeinput` or a composition event skips
+ * Wordgard's own handling of it, so leave typing to Wordgard.
+ */
 export declare const useEditorEventListener: <Type extends EditorEvent>(type: Type, handler: (wg: Wordgard, event: HTMLElementEventMap[Type]) => boolean | void) => void;

package/dist/hooks/useEditorEventListener.js

@@ -1,18 +1,18 @@
-// Named after react-prosemirror's useEditorEventListener, rewritten for
-// Wordgard: `handler` gets the editor's DOM events of `type` before Wordgard's
-// own handlers and keymaps, as react-prosemirror's `handleDOMEvents` came
-// before plugins: ReactWordgard installs a Wordgard.domEventHandler for each
-// type, at the highest precedence. Returning true says it handled the event:
-// Wordgard then calls `preventDefault` and goes no further. The latest
-// registered runs first, as in react-prosemirror. Unlike there, key events
-// during a composition don't come (Wordgard ignores them first), and handling
-// `input`, `beforeinput` or a composition event skips Wordgard's own tracking
-// of it. Among `prec.highest` handlers, these come first in an editor made
-// from `config`, after the state's own in one made from a `state`.
+// Named after react-prosemirror's useEditorEventListener, rewritten for Wordgard: ReactWordgard
+// installs a `prec.highest` Wordgard.domEventHandler per type, first in an editor made from
+// `config`, after the state's own in one made from a `state`. The latest registered runs first, as
+// in react-prosemirror.
 import { useLayoutEffect } from "react";
 import { useEditorContext } from "../contexts/EditorContext.js";
 import { listenersOf } from "../contexts/editorEvents.js";
 import { useEditorEventCallback } from "./useEditorEventCallback.js";
+/**
+ * Listens to the editor's DOM events of `type`, before Wordgard's handlers and keymaps. Returning
+ * `true` handles the event: Wordgard calls `preventDefault` and skips its own handling. The event
+ * types are listed under [Limits](https://github.com/stesura/react-wordgard#limits). Key events
+ * during a composition don't come; handling `input`, `beforeinput` or a composition event skips
+ * Wordgard's own handling of it, so leave typing to Wordgard.
+ */
 export const useEditorEventListener = (type, handler) => {
     const { wg } = useEditorContext();
     const listener = useEditorEventCallback(handler);

package/dist/hooks/useEditorLayoutEffect.d.ts

@@ -1,6 +1,15 @@
 import type { Wordgard } from "wordgard/editor";
+/** The `read` and `write` pair `useEditorLayoutEffect` takes. */
 export type EditorLayoutEffect<T> = {
     read: (wg: Wordgard) => T | undefined;
     write: (value: T, wg: Wordgard) => void;
 };
+/**
+ * Runs inside every editor update, without re-rendering: `read` in Wordgard's read phase, then
+ * `write` with its value in the write phase, on the same paint as the document. For what moves with
+ * the text (markers in the margin, pagination). It can't dispatch: Wordgard throws during its
+ * update. A `read` returning `undefined` skips its write, and when no read asks for a write, none
+ * is scheduled, which spares Wordgard measuring again. Reads run in the order the effects were
+ * registered.
+ */
 export declare const useEditorLayoutEffect: <T>(measure: EditorLayoutEffect<T>) => void;

package/dist/hooks/useEditorLayoutEffect.js

@@ -1,22 +1,18 @@
-// The other half of react-prosemirror's useEditorEffect, which ran inside
-// React's commit: what it set showed on the same paint. Here React commits
-// inside Wordgard's flush, so useEditorEffect runs after it, and this hook
-// runs in it, as React's useLayoutEffect to useEffect. It measures the
-// editor's layout and writes from it on the same paint as the document update:
-// `read` runs in every flush's read phase, `write` with its result in the
-// write phase after (Wordgard's scheduleDOMRead and scheduleDOMWrite), React
-// state it sets committing there too. A write that changes the size of the
-// editor's content makes Wordgard update and measure again within the flush,
-// so pagination can settle there. A `read` returning undefined skips its write;
-// with no write to do, none is scheduled, which spares Wordgard measuring
-// again. Reads run in registration order: an engine whose parts must run in
-// another order registers one effect and drives them. Neither may dispatch
-// (Wordgard throws during
-// its flush): dispatch from useEditorEffect or an event handler. Writes into
-// the document's own DOM are foreign edits to Wordgard: write inside widgets,
-// outside the editor, or through decorations.
+// The other half of react-prosemirror's useEditorEffect, which ran inside React's commit. Here
+// React commits inside Wordgard's flush: useEditorEffect runs after it, this hook in it, through
+// Wordgard's scheduleDOMRead and scheduleDOMWrite. A write resizing the content makes Wordgard
+// measure again within the flush, so pagination settles there. Writes into the document's own DOM
+// are foreign edits to Wordgard: write inside widgets, outside the editor, or through decorations.
 import { useLayoutEffect, useRef } from "react";
 import { useEditorContext } from "../contexts/EditorContext.js";
+/**
+ * Runs inside every editor update, without re-rendering: `read` in Wordgard's read phase, then
+ * `write` with its value in the write phase, on the same paint as the document. For what moves with
+ * the text (markers in the margin, pagination). It can't dispatch: Wordgard throws during its
+ * update. A `read` returning `undefined` skips its write, and when no read asks for a write, none
+ * is scheduled, which spares Wordgard measuring again. Reads run in the order the effects were
+ * registered.
+ */
 export const useEditorLayoutEffect = (measure) => {
     const { wg, measures, requestMeasure } = useEditorContext();
     const latest = useRef(measure);

package/dist/hooks/useEditorState.d.ts

@@ -1 +1,6 @@
+/**
+ * The state as of the editor's last flush, rendered in the same React commit as the document. The
+ * component re-renders on every flush: for a part of the state, use `useEditorStateSelector`; in a
+ * handler, `wg.state` is the latest.
+ */
 export declare const useEditorState: () => import("wordgard/state").GardState;

package/dist/hooks/useEditorState.js

@@ -1,9 +1,11 @@
-// Named after react-prosemirror's useEditorState, rewritten for Wordgard: the
-// state the editor's DOM shows, as of its last flush. Re-renders on every
-// state change, in the same commit as the document; `wg.state` is ahead of it
-// between a dispatch and the flush.
+// Named after react-prosemirror's useEditorState, rewritten for Wordgard.
 import { useSyncExternalStore } from "react";
 import { useEditorContext } from "../contexts/EditorContext.js";
+/**
+ * The state as of the editor's last flush, rendered in the same React commit as the document. The
+ * component re-renders on every flush: for a part of the state, use `useEditorStateSelector`; in a
+ * handler, `wg.state` is the latest.
+ */
 export const useEditorState = () => {
     const { store } = useEditorContext();
     return useSyncExternalStore(store.subscribe, store.getState);

package/dist/hooks/useEditorStateSelector.d.ts

@@ -1,2 +1,7 @@
 import type { GardState } from "wordgard/state";
+/**
+ * A part of the last flush's state, like Redux's `useSelector`: the component re-renders only when
+ * the result changes, by `Object.is` or by `isEqual`. A selector building a new object or array
+ * each time re-renders on every flush unless you pass `isEqual`.
+ */
 export declare const useEditorStateSelector: <Result>(selector: (state: GardState) => Result, isEqual?: (a: Result, b: Result) => boolean) => Result;

package/dist/hooks/useEditorStateSelector.js

@@ -1,5 +1,10 @@
 import { useSyncExternalStoreWithSelector } from "use-sync-external-store/with-selector";
 import { useEditorContext } from "../contexts/EditorContext.js";
+/**
+ * A part of the last flush's state, like Redux's `useSelector`: the component re-renders only when
+ * the result changes, by `Object.is` or by `isEqual`. A selector building a new object or array
+ * each time re-renders on every flush unless you pass `isEqual`.
+ */
 export const useEditorStateSelector = (selector, isEqual) => {
     const { store } = useEditorContext();
     return useSyncExternalStoreWithSelector(store.subscribe, store.getState, store.getState, selector, isEqual);

package/dist/hooks/useIgnoreMutation.d.ts

@@ -1,2 +1,6 @@
 import type { Wordgard } from "wordgard/editor";
-export declare const useIgnoreMutation: (ignoreMutation: (wg: Wordgard, mutation: MutationRecord) => boolean) => void;
+/**
+ * Wordgard doesn't read the DOM mutations `ignore` returns `true` for, typing aside (Wordgard takes
+ * it from `beforeinput`). Mutations in chrome and React widgets never reach Wordgard anyway.
+ */
+export declare const useIgnoreMutation: (ignore: (wg: Wordgard, mutation: MutationRecord) => boolean) => void;

package/dist/hooks/useIgnoreMutation.js

@@ -1,18 +1,19 @@
-// Named after react-prosemirror's useIgnoreMutation, rewritten for Wordgard:
-// when `ignoreMutation` returns true for a DOM mutation inside the React
-// decoration (its content included), Wordgard doesn't read it. Mutations in
-// the decoration's chrome never reach Wordgard anyway (`sortRecords`). Typing
-// isn't stopped: Wordgard takes it from `beforeinput`, not the mutation.
+// Named after react-prosemirror's useIgnoreMutation, rewritten for Wordgard. Chrome mutations are
+// dropped before, by `sortRecords`.
 import { useLayoutEffect } from "react";
 import { useDecorationContext } from "../contexts/DecorationContext.js";
 import { useEditorEventCallback } from "./useEditorEventCallback.js";
-export const useIgnoreMutation = (ignoreMutation) => {
+/**
+ * Wordgard doesn't read the DOM mutations `ignore` returns `true` for, typing aside (Wordgard takes
+ * it from `beforeinput`). Mutations in chrome and React widgets never reach Wordgard anyway.
+ */
+export const useIgnoreMutation = (ignore) => {
     const { handlers } = useDecorationContext("useIgnoreMutation");
-    const ignore = useEditorEventCallback(ignoreMutation);
+    const callback = useEditorEventCallback(ignore);
     useLayoutEffect(() => {
-        handlers.ignoreMutation.add(ignore);
+        handlers.ignoreMutation.add(callback);
         return () => {
-            handlers.ignoreMutation.delete(ignore);
+            handlers.ignoreMutation.delete(callback);
         };
-    }, [handlers, ignore]);
+    }, [handlers, callback]);
 };

package/dist/hooks/useIsNodeSelected.d.ts

@@ -1 +1,2 @@
+/** Whether the node the decoration draws is the editor's node selection. */
 export declare const useIsNodeSelected: () => boolean;

package/dist/hooks/useIsNodeSelected.js

@@ -1,6 +1,5 @@
-// Named after react-prosemirror's useIsNodeSelected, rewritten for Wordgard:
-// whether the node the React decoration a component is drawn in draws is the
-// node selection, read from the class Wordgard draws it with
-// (`wg-selected-node`), so the component renders with it, without an effect.
+// Named after react-prosemirror's useIsNodeSelected, rewritten for Wordgard: read from the
+// `wg-selected-node` class Wordgard draws, so the component renders with it, without an effect.
 import { useDecorationContext } from "../contexts/DecorationContext.js";
+/** Whether the node the decoration draws is the editor's node selection. */
 export const useIsNodeSelected = () => useDecorationContext("useIsNodeSelected").selected;

package/dist/hooks/useMergedDOMRefs.d.ts

@@ -1,2 +1,6 @@
 import { type Ref, type RefCallback } from "react";
+/**
+ * One ref setting several, as for a root that's also the content element (`ref` and
+ * `contentDOMRef`).
+ */
 export declare const useMergedDOMRefs: <Value>(...refs: (Ref<Value> | undefined)[]) => RefCallback<Value>;

package/dist/hooks/useMergedDOMRefs.js

@@ -1,8 +1,9 @@
-// Adapted from react-prosemirror's useMergedDOMRefs (src/refs.ts there),
-// without its typecast: one ref callback setting each of `refs`, as a React
-// decoration's component gives its root both the forwarded `ref` and
-// `contentDOMRef`, or a measuring ref.
+// Adapted from react-prosemirror's useMergedDOMRefs (src/refs.ts there), without its typecast.
 import { useCallback } from "react";
+/**
+ * One ref setting several, as for a root that's also the content element (`ref` and
+ * `contentDOMRef`).
+ */
 export const useMergedDOMRefs = (...refs) => useCallback((value) => {
     for (const ref of refs) {
         if (typeof ref == "function")

package/dist/hooks/useNodePos.d.ts

@@ -1 +1,4 @@
+/**
+ * A function giving the position of what the decoration draws, to call in handlers and effects.
+ */
 export declare const useNodePos: () => () => number;

package/dist/hooks/useNodePos.js

@@ -1,8 +1,7 @@
-// Named after react-prosemirror's useNodePos, rewritten for Wordgard: the
-// position of what the React decoration a component is drawn in draws (a
-// shape's, wrapper's or widget's node, or where a mark or point widget
-// starts), read from its tile. Returns a stable function, for event handlers
-// and effects, rather than the position: during render the tile may not be
-// built yet.
+// Named after react-prosemirror's useNodePos, rewritten for Wordgard: read from the decoration's
+// tile. A function rather than the position: during render, the tile may not be built yet.
 import { useDecorationContext } from "../contexts/DecorationContext.js";
+/**
+ * A function giving the position of what the decoration draws, to call in handlers and effects.
+ */
 export const useNodePos = () => useDecorationContext("useNodePos").handlers.getPos;

package/dist/hooks/useSelectNode.d.ts

@@ -1,2 +1,6 @@
 import type { Wordgard } from "wordgard/editor";
+/**
+ * Calls `selectNode` when the node becomes the node selection, and `deselectNode` when it stops
+ * being it, once the editor's DOM is up to date (as `useEditorEffect`).
+ */
 export declare const useSelectNode: (selectNode: (wg: Wordgard) => void, deselectNode?: (wg: Wordgard) => void) => void;

package/dist/hooks/useSelectNode.js

@@ -1,12 +1,13 @@
-// Named after react-prosemirror's useSelectNode, rewritten for Wordgard:
-// `selectNode` runs once the node the React decoration draws becomes the node
-// selection, `deselectNode` once it stops being it, after the flush that draws
-// the change, as ProseMirror's NodeView.selectNode and deselectNode.
+// Named after react-prosemirror's useSelectNode, rewritten for Wordgard.
 import { useRef } from "react";
 import { useEditorEffect } from "./useEditorEffect.js";
 import { useEditorEventCallback } from "./useEditorEventCallback.js";
 import { useIsNodeSelected } from "./useIsNodeSelected.js";
 const noop = () => { };
+/**
+ * Calls `selectNode` when the node becomes the node selection, and `deselectNode` when it stops
+ * being it, once the editor's DOM is up to date (as `useEditorEffect`).
+ */
 export const useSelectNode = (selectNode, deselectNode = noop) => {
     const selected = useIsNodeSelected();
     const select = useEditorEventCallback(selectNode);

package/dist/hooks/useStopEvent.d.ts

@@ -1,2 +1,8 @@
 import type { Wordgard } from "wordgard/editor";
+/**
+ * Asked for events in the decoration's chrome (its root and the elements around its content
+ * element, unless the root is the content element) and in React widgets; never for those in its
+ * content. For an event it stops, Wordgard's handlers and keymaps are skipped and the browser's
+ * default goes ahead: for a control in the chrome, such as an input.
+ */
 export declare const useStopEvent: (stopEvent: (wg: Wordgard, event: Event) => boolean) => void;

package/dist/hooks/useStopEvent.js

@@ -1,13 +1,14 @@
-// Named after react-prosemirror's useStopEvent, rewritten for Wordgard: when
-// `stopEvent` returns true, Wordgard doesn't handle the event, nor do its
-// handlers and keymaps, and the browser's default goes ahead. It's consulted
-// through widget types' `propagateEvent`, for events in a React decoration's
-// chrome or in a React widget, its own or a nested one's, and through its own
-// elements' tiles (tile.ts `ownTile`), for events on them; not for those in
-// its content.
+// Named after react-prosemirror's useStopEvent, rewritten for Wordgard: consulted through widget
+// types' `propagateEvent`, and through the decoration's own elements' tiles (tile.ts `ownTile`).
 import { useLayoutEffect } from "react";
 import { useDecorationContext } from "../contexts/DecorationContext.js";
 import { useEditorEventCallback } from "./useEditorEventCallback.js";
+/**
+ * Asked for events in the decoration's chrome (its root and the elements around its content
+ * element, unless the root is the content element) and in React widgets; never for those in its
+ * content. For an event it stops, Wordgard's handlers and keymaps are skipped and the browser's
+ * default goes ahead: for a control in the chrome, such as an input.
+ */
 export const useStopEvent = (stopEvent) => {
     const { handlers } = useDecorationContext("useStopEvent");
     const stop = useEditorEventCallback(stopEvent);

package/dist/hooks/useWordgard.d.ts

@@ -1 +1,2 @@
+/** The editor. */
 export declare const useWordgard: () => import("wordgard/editor").Wordgard;

package/dist/hooks/useWordgard.js

@@ -1,4 +1,3 @@
-// The editor a component is drawn in, or under (WordgardEditor): what a
-// widget's `render` gets.
 import { useEditorContext } from "../contexts/EditorContext.js";
+/** The editor. */
 export const useWordgard = () => useEditorContext().wg;

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export { DecorationRoot, type DecorationRootProps } from "./components/DecorationRoot.js";
 export { WordgardDoc } from "./components/WordgardDoc.js";
 export { WordgardEditor } from "./components/WordgardEditor.js";
+export { WordgardScope } from "./components/WordgardScope.js";
 export { type MarkComponentProps, type MarkShapeOptions, createMarkShape, } from "./decorations/ReactMarkType.js";
 export { type ReactShape, type ShapeComponentProps, createShape, } from "./decorations/ReactShapeType.js";
 export { type WidgetTypeSpec, type WidgetComponentProps, createWidgetType, } from "./decorations/ReactWidgetType.js";

package/dist/index.js

@@ -1,6 +1,8 @@
+"use client";
 export { DecorationRoot } from "./components/DecorationRoot.js";
 export { WordgardDoc } from "./components/WordgardDoc.js";
 export { WordgardEditor } from "./components/WordgardEditor.js";
+export { WordgardScope } from "./components/WordgardScope.js";
 export { createMarkShape, } from "./decorations/ReactMarkType.js";
 export { createShape, } from "./decorations/ReactShapeType.js";
 export { createWidgetType, } from "./decorations/ReactWidgetType.js";

package/dist/tile.js

@@ -1,11 +1,6 @@
-// Takes the role of Wordgard's own DocTile (src/editor/tile.ts in its repo):
-// React draws the document and the tiles are built over React's DOM, as
-// react-prosemirror's view descriptions are built over the DOM its components
-// render. Native widgets aren't React's: their DOM is rendered, reused,
-// connected and placed here, following Wordgard's ContentUpdate;
-// `setUneditable` is copied from it. React widgets are drawn by React, and
-// connected here. React commits into a root of its own, or, for an editor
-// WordgardEditor hosts, a portal in the app's tree (WordgardDoc).
+// Takes the role of Wordgard's DocTile (src/editor/tile.ts in its repo): the tiles are built over
+// React's DOM, as react-prosemirror's view descriptions are. Native widgets' DOM is placed here,
+// following Wordgard's ContentUpdate (`setUneditable` is copied from it).
 import { createElement } from "react";
 import { flushSync } from "react-dom";
 import { createRoot } from "react-dom/client";

package/dist/viewRoots.js

@@ -1,6 +1,5 @@
-// The elements React drew for node views and mark wrappers: what a container's
-// content is made of, so a React shape's chrome beside its content (in the
-// same element) can be told apart from it.
+// The elements React drew for node views and mark wrappers, to tell a React shape's chrome from its
+// content.
 export const viewRoots = new WeakSet();
 export const viewRoot = (dom) => {
     if (dom)

package/dist/wordgardInternals.js

@@ -1,8 +1,5 @@
-// The one place that depends on Wordgard internals missing from its typings
-// (src/editor/tile.ts, decoration.ts and editor.ts, and src/doc/node.ts in its
-// repo, at the pinned version). The declarations below are trusted, not
-// checked: re-read them against Wordgard's source after `npm run
-// update-wordgard`.
+// The one place depending on Wordgard internals missing from its typings. The declarations are
+// trusted, not checked: re-read them against Wordgard's source after `npm run update-wordgard`.
 import { Elt } from "wordgard/doc";
 import { Decoration, Widget, Wordgard } from "wordgard/editor";
 import { basicSchema } from "wordgard/schema";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stesura/react-wordgard",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "A React view for the Wordgard rich text editor",
   "keywords": [
     "react",