Skip to content

Open source website builder and Webflow alternative. Webstudio is an advanced visual builder that connects to any headless CMS, supports all CSS properties, and can be hosted anywhere, including with us.

6.1 KB
Raw Blame
import { draftPersistence } from "./draft-persistence";
import { createNanoEvents } from "nanoevents";
import {
  $collaborators,
  $syncStatus,
  createMultiplayerRetryTracker,
  type ApplyMessage,
  type ErrorMessage,
  type PresenceMessage,
  type ReloadMessage,
  type SyncEmitter,
  type SyncMessage,
} from "@webstudio-is/sync-client";
import {
  createWebSocketSyncEmitter,
  type WebSocketEmitterOptions,
  type WebSocketSyncEmitter,
} from "@webstudio-is/sync-client/websocket";
import { $awareness, type Awareness } from "~/shared/awareness";

type MultiplayerSyncEmitterOptions = {
  projectId?: string;
  clientId: string;
  getAuthToken?: () => Promise<string | undefined>;
  url: string;
  onReload?: (message: ReloadMessage) => void;
  onUserMessage?: (message: string) => void;
  createTransport?: (options: WebSocketEmitterOptions) => WebSocketSyncEmitter;
};

export type MultiplayerSyncEmitter = SyncEmitter & {
  close(): void;
  connect(buildId: string): void;
  sendPresence(payload: Awareness): void;
};

const updateCollaborator = (clientId: string, payload: unknown) => {
  const next = new Map($collaborators.get());
  const previous = next.get(clientId);
  next.set(clientId, {
    ...previous,
    ...(typeof payload === "object" && payload !== null ? payload : {}),
    lastSeen: Date.now(),
  });
  $collaborators.set(next);
};

export const startMultiplayerPresenceSync = (
  emitter: Pick<MultiplayerSyncEmitter, "sendPresence">
) => {
  return $awareness.listen((awareness) => {
    emitter.sendPresence(awareness);
  });
};

export const createMultiplayerSyncEmitter = ({
  projectId,
  clientId,
  getAuthToken,
  url,
  onReload,
  onUserMessage,
  createTransport = createWebSocketSyncEmitter,
}: MultiplayerSyncEmitterOptions): MultiplayerSyncEmitter => {
  const events = createNanoEvents<{
    message: (message: SyncMessage) => void;
  }>();
  let clientSeq = 0;
  let durableSeq = 0;
  const remoteTransactions = new Map<string, number>();
  let tracker: ReturnType<typeof createMultiplayerRetryTracker>;
  let ws: WebSocketSyncEmitter | undefined;

  const updateUnsaved = () => {
    $syncStatus.set(
      tracker.getPendingCount() > 0 ? { status: "syncing" } : { status: "idle" }
    );
  };

  const sendApply = (message: ApplyMessage) => {
    if (ws === undefined) {
      return;
    }
    ws.sendToRelay(message);
  };

  const connect = (buildId: string) => {
    if (ws !== undefined) {
      return;
    }
    ws = createTransport({
      buildId,
      clientId,
      getAuthToken,
      url,
      onAck: (seq, version) => {
        durableSeq = Math.max(durableSeq, seq);
        for (const [id, transactionSeq] of remoteTransactions) {
          if (transactionSeq <= durableSeq) {
            if (projectId) {
              draftPersistence.complete(projectId, id, true);
            }
            remoteTransactions.delete(id);
          }
        }
        tracker.handleAck({ type: "ack", seq, version });
        updateUnsaved();
      },
      onApplied: (transactionId, seq, status, errors) => {
        tracker.handleApplied({
          type: "applied",
          transactionId,
          seq,
          status,
          errors,
        });
        updateUnsaved();
      },
      onBroadcast: (message) => {
        // Other collaborators' changes become visible before the database ACK too.
        if (
          projectId &&
          message.originClientId !== clientId &&
          message.seq > durableSeq
        ) {
          draftPersistence.begin(projectId, message.transaction.id);
          remoteTransactions.set(message.transaction.id, message.seq);
        }
        tracker.handleBroadcast(message);
        updateUnsaved();
        events.emit("message", {
          type: "apply",
          clientId: message.originClientId,
          transaction: message.transaction,
        });
      },
      onClose: () => {},
      onErrorMessage: (message: ErrorMessage) => {
        tracker.handleErrorMessage(message);
        updateUnsaved();
      },
      onOpen: () => {
        tracker.handleReconnect();
      },
      onPresence: (presenceClientId, payload) => {
        updateCollaborator(presenceClientId, payload);
      },
      onReload: (message) => {
        tracker.handleReload(message);
        updateUnsaved();
      },
    });
  };

  tracker = createMultiplayerRetryTracker({
    onDropped: ({ message }) => {
      if (projectId) {
        draftPersistence.complete(projectId, message.transactionId, false);
      }
      updateUnsaved();
    },
    onDurable: ({ message }) => {
      if (projectId) {
        draftPersistence.complete(projectId, message.transactionId, true);
      }
      updateUnsaved();
    },
    onReload: (message) => {
      if (projectId) {
        draftPersistence.invalidate(projectId);
      }
      onReload?.(message);
    },
    onUserMessage,
    sendApply,
  });

  return {
    close() {
      tracker.destroy();
      updateUnsaved();
      ws?.close();
      ws = undefined;
    },
    connect,
    emit(message) {
      // Preserve the regular in-browser SyncEmitter contract. The builder and
      // canvas iframe still use this emitter for local state handshakes and
      // client-only stores; multiplayer only adds remote relay for server patches.
      events.emit("message", message);

      if (message.type !== "apply") {
        return;
      }
      if (message.transaction.object !== "server") {
        return;
      }

      clientSeq += 1;
      const applyMessage: ApplyMessage = {
        type: "apply",
        transactionId: message.transaction.id,
        transaction: message.transaction,
        clientId,
        actorId: clientId,
        clientSeq,
      };
      if (projectId) {
        draftPersistence.begin(projectId, applyMessage.transactionId);
      }
      tracker.track(applyMessage);
      updateUnsaved();
    },
    on(handler) {
      return events.on("message", handler);
    },
    sendPresence(payload) {
      const message: PresenceMessage = {
        type: "presence",
        clientId,
        payload,
      };
      if (ws === undefined) {
        return;
      }
      ws.sendToRelay(message);
    },
  };
};