diffdown-app / static / collab-client.js

// static/collab-client.js
//
// Lightweight step-authority client for Diffdown's prosemirror-collab protocol.
// Works with both source (text-patch steps) and rich (PM steps) modes.

export class CollabClient {
    /**
     * @param {string} rkey - Document rkey
     * @param {number} initialVersion - Version the client started at
     * @param {function(steps: object[]): void} applyRemoteSteps - Called when server confirms steps from others
     */
    constructor(rkey, initialVersion, applyRemoteSteps) {
        this.rkey = rkey;
        this.version = initialVersion;
        this.applyRemoteSteps = applyRemoteSteps;
        this._inflight = false;
        this._queue = [];
    }

    /**
     * Queue local steps and attempt to flush to the server.
     * @param {object[]} steps - Array of step objects (text-patch or PM step JSON)
     */
    sendSteps(steps) {
        this._queue.push(...steps);
        this._flush();
    }

    async _flush() {
        if (this._inflight || this._queue.length === 0) return;
        this._inflight = true;
        const toSend = this._queue.slice();
        try {
            const resp = await fetch(`/api/docs/${this.rkey}/steps`, {
                method: 'POST',
                headers: {'Content-Type': 'application/json'},
                body: JSON.stringify({
                    clientVersion: this.version,
                    steps: toSend.map(s => JSON.stringify(s)),
                    clientID: this._clientID || '',
                }),
            });

            if (resp.ok) {
                const {version} = await resp.json();
                this.version = version;
                // Remove the steps we just confirmed.
                this._queue = this._queue.slice(toSend.length);
            } else if (resp.status === 409) {
                // Server has steps we haven't seen yet.
                const {version, steps: missedJSON} = await resp.json();
                const missed = missedJSON.map(s => JSON.parse(s));
                // Let the editor rebase local steps on top of missed ones.
                this.applyRemoteSteps(missed);
                this.version = version;
                // Don't clear _queue — resubmit after rebase.
            } else {
                console.error('CollabClient: unexpected status', resp.status);
            }
        } catch (e) {
            console.error('CollabClient: fetch error', e);
        } finally {
            this._inflight = false;
            if (this._queue.length > 0) {
                setTimeout(() => this._flush(), 50);
            }
        }
    }

    /**
     * Call when a WebSocket "steps" message arrives from the server.
     * Advances local version and notifies the editor.
     * @param {object} msg - {type:"steps", steps:[...], version:N, clientID:string}
     * @param {string} myClientID
     */
    handleWSMessage(msg, myClientID) {
        if (msg.type !== 'steps') return;
        if (msg.clientID === myClientID) {
            // Our own steps confirmed — just advance version.
            this.version = msg.version;
            return;
        }
        const steps = msg.steps.map(s => JSON.parse(s));
        this.version = msg.version;
        this.applyRemoteSteps(steps);
    }

    setClientID(id) { this._clientID = id; }
}