@stesura/react-wordgard 0.0.0-stage → 0.2.0

package/dist/contexts/EditorContext.js

@@ -0,0 +1,87 @@
+// Named after react-prosemirror's EditorContext, rewritten for Wordgard. One value per editor,
+// which never changes, so memoised components aren't scanned for it.
+import { createContext, useContext } from "react";
+import { flushSync } from "react-dom";
+const editors = new WeakMap();
+export const editorOf = (wg) => {
+    const found = editors.get(wg);
+    if (found)
+        return found;
+    let state = wg.state;
+    const listeners = new Set();
+    const effects = new Set();
+    const measures = new Set();
+    let requested = false;
+    // After a flush the DOM shows `state`, even when a dispatch since then
+    // (an update listener's) has put `wg.state` ahead.
+    const runEffects = () => {
+        if (!wg.connected)
+            return;
+        const pending = [...effects];
+        effects.clear();
+        for (const effect of pending)
+            effect();
+    };
+    // Without a flush under way or pending, the DOM is up to date.
+    const requestEffects = () => {
+        if (requested)
+            return;
+        requested = true;
+        queueMicrotask(() => {
+            requested = false;
+            if (!editor.flushing && wg.state == state)
+                runEffects();
+        });
+    };
+    const readMeasures = (wg) => {
+        const writes = [...measures].flatMap((measure) => measure() ?? []);
+        // A scheduled write makes Wordgard measure again.
+        if (!writes.length)
+            return;
+        // React state set by a write commits now, on the same paint.
+        wg.scheduleDOMWrite(() => flushSync(() => {
+            for (const write of writes)
+                write();
+        }));
+    };
+    const editor = {
+        wg,
+        store: {
+            getState: () => state,
+            subscribe: (listener) => {
+                listeners.add(listener);
+                return () => listeners.delete(listener);
+            },
+        },
+        afterFlush: (effect) => {
+            effects.add(effect);
+            if (!editor.flushing)
+                requestEffects();
+        },
+        cancel: (effect) => effects.delete(effect),
+        measures,
+        requestMeasure: () => wg.scheduleDOMRead(readMeasures),
+        publish: (next) => {
+            if (next == state)
+                return;
+            state = next;
+            for (const listener of listeners)
+                listener();
+        },
+        readMeasures,
+        runEffects,
+        requestEffects,
+        flushing: false,
+    };
+    editors.set(wg, editor);
+    return editor;
+};
+// The editor's value when react-wordgard drives it (WordgardEditor made it).
+export const findEditor = (wg) => editors.get(wg);
+export const EditorContext = createContext(null);
+export const useEditorContext = () => {
+    const context = useContext(EditorContext);
+    if (!context)
+        throw new Error("Used outside a Wordgard editor");
+    return context;
+};

package/dist/contexts/RenderStoreContext.d.ts

@@ -0,0 +1,15 @@
+import type { NodeView } from "../decorations/iterDeco.js";
+import type { ReactKeys } from "../reactKeys.js";
+export type NodeCell = {
+    view: NodeView;
+    listener: (() => void) | null;
+};
+export type RenderStore = {
+    readonly keys: ReactKeys;
+    readonly pending: Map<NodeCell, NodeView>;
+};
+export declare const cellOf: (view: NodeView) => NodeCell;
+export declare const moveCell: (store: RenderStore, old: NodeView, view: NodeView) => void;
+export declare const publishCells: (store: RenderStore) => () => void;
+export declare const RenderStoreContext: import("react").Context<RenderStore | null>;
+export declare const useRenderStore: () => RenderStore;

package/dist/contexts/RenderStoreContext.js

@@ -0,0 +1,41 @@
+// Named after our react-prosemirror fork's RenderStoreContext, rewritten for Wordgard: one object
+// per content element, which ReactDocTile writes inside the flush. Its value never changes, so
+// memoised node views aren't scanned for it.
+import { createContext, useContext } from "react";
+const cells = new WeakMap();
+export const cellOf = (view) => {
+    let cell = cells.get(view);
+    if (!cell)
+        cells.set(view, (cell = { view, listener: null }));
+    return cell;
+};
+// `view` takes the place of `old`, its node's view in the last layout.
+export const moveCell = (store, old, view) => {
+    const cell = cellOf(old);
+    cells.set(view, cell);
+    if (cell.view == view)
+        store.pending.delete(cell);
+    else
+        store.pending.set(cell, view);
+};
+// Gives the cells their views, inside the commit's flushSync. Returns what
+// takes them back, for an update React refused.
+export const publishCells = (store) => {
+    const before = [];
+    for (const [cell, view] of store.pending) {
+        before.push([cell, cell.view]);
+        cell.view = view;
+        cell.listener?.();
+    }
+    return () => {
+        for (const [cell, view] of before)
+            cell.view = view;
+    };
+};
+export const RenderStoreContext = createContext(null);
+export const useRenderStore = () => {
+    const store = useContext(RenderStoreContext);
+    if (!store)
+        throw new Error("Rendered outside a ReactDocTile");
+    return store;
+};

package/dist/contexts/editorEvents.d.ts

@@ -0,0 +1,12 @@
+import { Wordgard } from "wordgard/editor";
+import { GardState } from "wordgard/state";
+export declare const editorEvents: readonly ["keydown", "keyup", "keypress", "beforeinput", "input", "mousedown", "mouseup", "mouseover", "mouseout", "click", "dblclick", "contextmenu", "focus", "blur", "copy", "cut", "paste", "dragstart", "dragend", "dragenter", "dragover", "dragleave", "drop", "compositionstart", "compositionupdate", "compositionend"];
+export type EditorEvent = (typeof editorEvents)[number];
+type Listener<Type extends EditorEvent> = (event: HTMLElementEventMap[Type]) => boolean | void;
+type Listeners = {
+    [Type in EditorEvent]: Listener<Type>[];
+};
+export declare const listenersOf: <Type extends EditorEvent>(wg: Wordgard, type: Type) => Listeners[Type];
+export declare const hasEditorEventHandlers: (state: GardState) => boolean;
+export declare const editorEventHandlers: GardState.Extension;
+export {};

package/dist/contexts/editorEvents.js

@@ -0,0 +1,92 @@
+// The DOM events useEditorEventListener can listen to. Wordgard fixes its handlers' event types at
+// creation, and a handler makes its listener non-passive: scroll-blocking events (touch, wheel) and
+// frequent ones (mousemove, pointer events) are left out.
+import { Wordgard } from "wordgard/editor";
+import { GardState } from "wordgard/state";
+export const editorEvents = [
+    "keydown",
+    "keyup",
+    "keypress",
+    "beforeinput",
+    "input",
+    "mousedown",
+    "mouseup",
+    "mouseover",
+    "mouseout",
+    "click",
+    "dblclick",
+    "contextmenu",
+    "focus",
+    "blur",
+    "copy",
+    "cut",
+    "paste",
+    "dragstart",
+    "dragend",
+    "dragenter",
+    "dragover",
+    "dragleave",
+    "drop",
+    "compositionstart",
+    "compositionupdate",
+    "compositionend",
+];
+// Every type's list made at once: the type checks none is missing, and they're
+// then only read.
+const createListeners = () => ({
+    keydown: [],
+    keyup: [],
+    keypress: [],
+    beforeinput: [],
+    input: [],
+    mousedown: [],
+    mouseup: [],
+    mouseover: [],
+    mouseout: [],
+    click: [],
+    dblclick: [],
+    contextmenu: [],
+    focus: [],
+    blur: [],
+    copy: [],
+    cut: [],
+    paste: [],
+    dragstart: [],
+    dragend: [],
+    dragenter: [],
+    dragover: [],
+    dragleave: [],
+    drop: [],
+    compositionstart: [],
+    compositionupdate: [],
+    compositionend: [],
+});
+const registries = new WeakMap();
+export const listenersOf = (wg, type) => {
+    let registry = registries.get(wg);
+    if (!registry) {
+        registry = createListeners();
+        registries.set(wg, registry);
+    }
+    return registry[type];
+};
+const handler = (type) => Wordgard.domEventHandler(type, (event, wg) => {
+    // A copy: a listener may unregister one.
+    for (const listener of [...listenersOf(wg, type)])
+        if (listener(event) || event.defaultPrevented)
+            return true;
+    return false;
+});
+// Whether a state has the handlers: `GardState.reconfigure` drops them.
+const installed = GardState.Facet.define({
+    combine: (values) => values.length > 0,
+});
+export const hasEditorEventHandlers = (state) => state.facet(installed);
+// Wordgard redoes its handlers only when its plugins change: this one makes
+// adding or dropping the handlers such a change.
+const refresh = Wordgard.Plugin.define(() => ({}));
+export const editorEventHandlers = GardState.prec.highest([
+    editorEvents.map(handler),
+    installed.of(true),
+    refresh,
+]);

package/dist/decorations/DecoIterator.d.ts

@@ -0,0 +1,43 @@
+import { type Mark, type Node, type Plot, type Pos } from "wordgard/doc";
+import { Decoration, Widget } from "wordgard/editor";
+import { type Set } from "wordgard/set";
+import type { GardState } from "wordgard/state";
+import { type DecoElt, type DecoSet, type TagAttribute, type TagWidget, type TagWrapper, type WrapperRangeDecoration } from "../wordgardInternals.js";
+declare const enum WidgetPlace {
+    Before = 0,
+    After = 1,
+    Start = 2,
+    End = 3
+}
+export type WrapperSource = Mark | WrapperRangeDecoration;
+export interface DecoWalker {
+    enter(node: Plot, shape: DecoElt, wrappers: readonly WrapperSource[], pos: number): boolean;
+    leave(): void;
+    node(node: Node, shape: Decoration.Shape, wrappers: readonly WrapperSource[], partial: number | undefined, pos: number): void;
+    nodePart(node: Node, length: number, done: boolean): void;
+    widget(widget: Widget, side: number, point: boolean): void;
+}
+export declare const getDecoSet: (state: GardState) => DecoSet;
+export declare const renderMarkWrapper: (arg: Mark<unknown>) => DecoElt;
+export declare const documentMark: (mark: Mark) => Mark<unknown>;
+export declare const renderWrapper: (src: WrapperSource) => DecoElt;
+export declare class DecoIterator {
+    readonly state: GardState;
+    readonly decoSet: DecoSet;
+    tagShapes: Map<Node.Type, (tag: Node.Tag) => Decoration.Shape>;
+    globalWidgets: readonly TagWidget[];
+    globalWrappers: readonly TagWrapper[];
+    globalAttrs: readonly TagAttribute[];
+    markShapes: Map<Mark.Type, Mark.Type>;
+    pos: Pos;
+    rangeCursor: Set.Cursor<Decoration.Range>;
+    pointSets: readonly Decoration.Point.Set[];
+    pointCursor: Set.Cursor<Decoration.Point>;
+    constructor(state: GardState, decoSet: DecoSet);
+    widgets(tag: Node.Tag, place: WidgetPlace, walker: DecoWalker): void;
+    nodeWrappers(tag: Node.Tag, active: readonly Decoration.Range[], atom: boolean): readonly WrapperSource[];
+    walk(from: number, inclusiveStart: boolean, to: number, walker: DecoWalker): void;
+    tagShape(tag: Node.Tag, active: readonly Decoration.Range[]): Decoration.Shape;
+}
+export declare const spanningOf: (src: WrapperSource) => boolean;
+export {};