@automerge/automerge-repo-network-messagechannel 0.0.1

package/.mocharc.json

@@ -0,0 +1,5 @@
+{
+  "extension": ["ts"],
+  "spec": "test/*.test.ts",
+  "loader": "ts-node/esm"
+}

package/dist/MessagePortRef.d.ts

@@ -0,0 +1,11 @@
+import EventEmitter from "eventemitter3";
+export interface PortRefEvents {
+    message: (event: MessageEvent) => void;
+    close: () => void;
+}
+export interface MessagePortRef extends EventEmitter<PortRefEvents> {
+    start(): void;
+    postMessage(message: any, transferable?: Transferable[]): void;
+    isAlive(): boolean;
+}
+//# sourceMappingURL=MessagePortRef.d.ts.map

package/dist/MessagePortRef.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessagePortRef.d.ts","sourceRoot":"","sources":["../src/MessagePortRef.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,MAAM,eAAe,CAAA;AAExC,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAA;IACtC,KAAK,EAAE,MAAM,IAAI,CAAA;CAClB;AAED,MAAM,WAAW,cAAe,SAAQ,YAAY,CAAC,aAAa,CAAC;IACjE,KAAK,IAAI,IAAI,CAAA;IACb,WAAW,CAAC,OAAO,EAAE,GAAG,EAAE,YAAY,CAAC,EAAE,YAAY,EAAE,GAAG,IAAI,CAAA;IAC9D,OAAO,IAAI,OAAO,CAAA;CACnB"}

package/dist/MessagePortRef.js

@@ -0,0 +1 @@
+export {};

package/dist/StrongMessagePortRef.d.ts

@@ -0,0 +1,10 @@
+import EventEmitter from "eventemitter3";
+import { PortRefEvents, MessagePortRef } from "./MessagePortRef.js";
+export declare class StrongMessagePortRef extends EventEmitter<PortRefEvents> implements MessagePortRef {
+    private port;
+    constructor(port: MessagePort);
+    postMessage(message: any, transfer: Transferable[]): void;
+    start(): void;
+    isAlive(): boolean;
+}
+//# sourceMappingURL=StrongMessagePortRef.d.ts.map

package/dist/StrongMessagePortRef.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StrongMessagePortRef.d.ts","sourceRoot":"","sources":["../src/StrongMessagePortRef.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,MAAM,eAAe,CAAA;AACxC,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAEnE,qBAAa,oBACX,SAAQ,YAAY,CAAC,aAAa,CAClC,YAAW,cAAc;IAEb,OAAO,CAAC,IAAI;gBAAJ,IAAI,EAAE,WAAW;IAQrC,WAAW,CAAC,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,YAAY,EAAE,GAAG,IAAI;IAIzD,KAAK,IAAI,IAAI;IAIb,OAAO,IAAI,OAAO;CAGnB"}

package/dist/StrongMessagePortRef.js

@@ -0,0 +1,20 @@
+import EventEmitter from "eventemitter3";
+export class StrongMessagePortRef extends EventEmitter {
+    port;
+    constructor(port) {
+        port.addEventListener("message", event => {
+            this.emit("message", event);
+        });
+        super();
+        this.port = port;
+    }
+    postMessage(message, transfer) {
+        this.port.postMessage(message, transfer);
+    }
+    start() {
+        this.port.start();
+    }
+    isAlive() {
+        return true;
+    }
+}

package/dist/WeakMessagePortRef.d.ts

@@ -0,0 +1,12 @@
+import EventEmitter from "eventemitter3";
+import { PortRefEvents, MessagePortRef } from "./MessagePortRef.js";
+export declare class WeakMessagePortRef extends EventEmitter<PortRefEvents> implements MessagePortRef {
+    private weakRef;
+    private isDisconnected;
+    constructor(port: MessagePort);
+    postMessage(message: any, transfer: Transferable[]): void;
+    start(): void;
+    private disconnnect;
+    isAlive(): boolean;
+}
+//# sourceMappingURL=WeakMessagePortRef.d.ts.map

package/dist/WeakMessagePortRef.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WeakMessagePortRef.d.ts","sourceRoot":"","sources":["../src/WeakMessagePortRef.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,MAAM,eAAe,CAAA;AACxC,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAEnE,qBAAa,kBACX,SAAQ,YAAY,CAAC,aAAa,CAClC,YAAW,cAAc;IAEzB,OAAO,CAAC,OAAO,CAAsB;IACrC,OAAO,CAAC,cAAc,CAAQ;gBAElB,IAAI,EAAE,WAAW;IAU7B,WAAW,CAAC,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,YAAY,EAAE,GAAG,IAAI;IAezD,KAAK,IAAI,IAAI;IAeb,OAAO,CAAC,WAAW;IAOnB,OAAO,IAAI,OAAO;CAYnB"}

package/dist/WeakMessagePortRef.js

@@ -0,0 +1,54 @@
+import EventEmitter from "eventemitter3";
+export class WeakMessagePortRef extends EventEmitter {
+    weakRef;
+    isDisconnected = false;
+    constructor(port) {
+        super();
+        this.weakRef = new WeakRef(port);
+        port.addEventListener("message", event => {
+            this.emit("message", event);
+        });
+    }
+    postMessage(message, transfer) {
+        const port = this.weakRef.deref();
+        if (!port) {
+            this.disconnnect();
+            return;
+        }
+        try {
+            port.postMessage(message, transfer);
+        }
+        catch (err) {
+            this.disconnnect();
+        }
+    }
+    start() {
+        const port = this.weakRef.deref();
+        if (!port) {
+            this.disconnnect();
+            return;
+        }
+        try {
+            port.start();
+        }
+        catch (err) {
+            this.disconnnect();
+        }
+    }
+    disconnnect() {
+        if (!this.isDisconnected) {
+            this.emit("close");
+            this.isDisconnected = true;
+        }
+    }
+    isAlive() {
+        if (this.isDisconnected) {
+            return false;
+        }
+        if (!this.weakRef.deref()) {
+            this.disconnnect();
+            return false;
+        }
+        return true;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+import { ChannelId, NetworkAdapter, PeerId } from "@automerge/automerge-repo";
+import { MessagePortRef } from "./MessagePortRef.js";
+export declare class MessageChannelNetworkAdapter extends NetworkAdapter {
+    channels: {};
+    messagePortRef: MessagePortRef;
+    constructor(messagePort: MessagePort, config?: MessageChannelNetworkAdapterConfig);
+    connect(peerId: PeerId): void;
+    sendMessage(peerId: PeerId, channelId: ChannelId, uint8message: Uint8Array, broadcast: boolean): void;
+    announceConnection(channelId: ChannelId, peerId: PeerId): void;
+    join(channelId: string): void;
+    leave(docId: string): void;
+}
+interface MessageChannelNetworkAdapterConfig {
+    /**
+     * This is an optional parameter to use a weak ref to reference the message port that is passed to
+     * the adapter. This option is useful when using a message channel with a shared worker. If you
+     * use a network adapter with `useWeakRef = true` in the shared worker and in the main thread
+     * network adapters with strong refs the network adapter will be automatically garbage collected
+     * if you close a page. The garbage collection doesn't happen immediately; there might be some
+     * time in between when the page is closed and when the port is garbage collected
+     */
+    useWeakRef?: boolean;
+}
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAA;AAC7E,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAOpD,qBAAa,4BAA6B,SAAQ,cAAc;IAC9D,QAAQ,KAAK;IACb,cAAc,EAAE,cAAc,CAAA;gBAG5B,WAAW,EAAE,WAAW,EACxB,MAAM,GAAE,kCAAuC;IAWjD,OAAO,CAAC,MAAM,EAAE,MAAM;IA4CtB,WAAW,CACT,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,SAAS,EACpB,YAAY,EAAE,UAAU,EACxB,SAAS,EAAE,OAAO;IAmBpB,kBAAkB,CAAC,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM;IAIvD,IAAI,CAAC,SAAS,EAAE,MAAM;IAQtB,KAAK,CAAC,KAAK,EAAE,MAAM;CAMpB;AAED,UAAU,kCAAkC;IAC1C;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB"}

package/dist/index.js

@@ -0,0 +1,80 @@
+import { NetworkAdapter } from "@automerge/automerge-repo";
+import { StrongMessagePortRef } from "./StrongMessagePortRef.js";
+import { WeakMessagePortRef } from "./WeakMessagePortRef.js";
+import debug from "debug";
+const log = debug("automerge-repo:messagechannel");
+export class MessageChannelNetworkAdapter extends NetworkAdapter {
+    channels = {};
+    messagePortRef;
+    constructor(messagePort, config = {}) {
+        super();
+        const useWeakRef = config.useWeakRef ?? false;
+        this.messagePortRef = useWeakRef
+            ? new WeakMessagePortRef(messagePort)
+            : new StrongMessagePortRef(messagePort);
+    }
+    connect(peerId) {
+        log("messageport connecting");
+        this.peerId = peerId;
+        this.messagePortRef.start();
+        this.messagePortRef.addListener("message", e => {
+            log("message port received", e.data);
+            const { origin, destination, type, channelId, message, broadcast } = e.data;
+            if (destination && !(destination === this.peerId || broadcast)) {
+                throw new Error("MessagePortNetwork should never receive messages for a different peer.");
+            }
+            switch (type) {
+                case "arrive":
+                    this.messagePortRef.postMessage({
+                        origin: this.peerId,
+                        destination: origin,
+                        type: "welcome",
+                    });
+                    this.announceConnection(channelId, origin);
+                    break;
+                case "welcome":
+                    this.announceConnection(channelId, origin);
+                    break;
+                case "message":
+                    this.emit("message", {
+                        senderId: origin,
+                        targetId: destination,
+                        channelId,
+                        message: new Uint8Array(message),
+                        broadcast,
+                    });
+                    break;
+                default:
+                    throw new Error("unhandled message from network");
+            }
+        });
+        this.messagePortRef.addListener("close", () => {
+            this.emit("close");
+        });
+    }
+    sendMessage(peerId, channelId, uint8message, broadcast) {
+        const message = uint8message.buffer.slice(uint8message.byteOffset, uint8message.byteOffset + uint8message.byteLength);
+        this.messagePortRef.postMessage({
+            origin: this.peerId,
+            destination: peerId,
+            channelId: channelId,
+            type: "message",
+            message,
+            broadcast,
+        }, [message]);
+    }
+    announceConnection(channelId, peerId) {
+        this.emit("peer-candidate", { peerId, channelId });
+    }
+    join(channelId) {
+        this.messagePortRef.postMessage({
+            origin: this.peerId,
+            channelId,
+            type: "arrive",
+        });
+    }
+    leave(docId) {
+        // TODO
+        throw new Error("Unimplemented: leave on MessagePortNetworkAdapter: " + docId);
+    }
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@automerge/automerge-repo-network-messagechannel",
+  "version": "0.0.1",
+  "description": "MessageChannel network adapter for Automerge Repo",
+  "repository": "https://github.com/pvh/automerge-repo",
+  "author": "Peter van Hardenberg <pvh@pvh.ca>",
+  "license": "MIT",
+  "private": false,
+  "type": "module",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "watch": "npm-watch",
+    "test": "mocha --no-warnings --experimental-specifier-resolution=node --exit"
+  },
+  "dependencies": {
+    "@automerge/automerge-repo": "^0.0.1"
+  },
+  "watch": {
+    "build": {
+      "patterns": "./src/**/*",
+      "extensions": [
+        ".ts"
+      ]
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "e572f26ae416140b025c3ba557d9f781abbdada1"
+}

package/readme.md

@@ -0,0 +1,4 @@
+## @automerge/automerge-repo-network-message
+
+This is a network adapter for automerge-repo that uses the [MessageChannel
+API](https://developer.mozilla.org/en-US/docs/Web/API/MessageChannel) to communicate between tabs.

package/src/MessagePortRef.ts

@@ -0,0 +1,12 @@
+import EventEmitter from "eventemitter3"
+
+export interface PortRefEvents {
+  message: (event: MessageEvent) => void
+  close: () => void
+}
+
+export interface MessagePortRef extends EventEmitter<PortRefEvents> {
+  start(): void
+  postMessage(message: any, transferable?: Transferable[]): void
+  isAlive(): boolean
+}

package/src/StrongMessagePortRef.ts

@@ -0,0 +1,27 @@
+import EventEmitter from "eventemitter3"
+import { PortRefEvents, MessagePortRef } from "./MessagePortRef.js"
+
+export class StrongMessagePortRef
+  extends EventEmitter<PortRefEvents>
+  implements MessagePortRef
+{
+  constructor(private port: MessagePort) {
+    port.addEventListener("message", event => {
+      this.emit("message", event)
+    })
+
+    super()
+  }
+
+  postMessage(message: any, transfer: Transferable[]): void {
+    this.port.postMessage(message, transfer)
+  }
+
+  start(): void {
+    this.port.start()
+  }
+
+  isAlive(): boolean {
+    return true
+  }
+}

package/src/WeakMessagePortRef.ts

@@ -0,0 +1,70 @@
+import EventEmitter from "eventemitter3"
+import { PortRefEvents, MessagePortRef } from "./MessagePortRef.js"
+
+export class WeakMessagePortRef
+  extends EventEmitter<PortRefEvents>
+  implements MessagePortRef
+{
+  private weakRef: WeakRef<MessagePort>
+  private isDisconnected = false
+
+  constructor(port: MessagePort) {
+    super()
+
+    this.weakRef = new WeakRef<MessagePort>(port)
+
+    port.addEventListener("message", event => {
+      this.emit("message", event)
+    })
+  }
+
+  postMessage(message: any, transfer: Transferable[]): void {
+    const port = this.weakRef.deref()
+
+    if (!port) {
+      this.disconnnect()
+      return
+    }
+
+    try {
+      port.postMessage(message, transfer)
+    } catch (err) {
+      this.disconnnect()
+    }
+  }
+
+  start(): void {
+    const port = this.weakRef.deref()
+
+    if (!port) {
+      this.disconnnect()
+      return
+    }
+
+    try {
+      port.start()
+    } catch (err) {
+      this.disconnnect()
+    }
+  }
+
+  private disconnnect() {
+    if (!this.isDisconnected) {
+      this.emit("close")
+      this.isDisconnected = true
+    }
+  }
+
+  isAlive(): boolean {
+    if (this.isDisconnected) {
+      return false
+    }
+
+    if (!this.weakRef.deref()) {
+      this.disconnnect()
+      return false
+    }
+
+    return true
+  }
+}

package/src/index.ts

@@ -0,0 +1,123 @@
+import { ChannelId, NetworkAdapter, PeerId } from "@automerge/automerge-repo"
+import { MessagePortRef } from "./MessagePortRef.js"
+import { StrongMessagePortRef } from "./StrongMessagePortRef.js"
+import { WeakMessagePortRef } from "./WeakMessagePortRef.js"
+
+import debug from "debug"
+const log = debug("automerge-repo:messagechannel")
+
+export class MessageChannelNetworkAdapter extends NetworkAdapter {
+  channels = {}
+  messagePortRef: MessagePortRef
+
+  constructor(
+    messagePort: MessagePort,
+    config: MessageChannelNetworkAdapterConfig = {}
+  ) {
+    super()
+
+    const useWeakRef = config.useWeakRef ?? false
+
+    this.messagePortRef = useWeakRef
+      ? new WeakMessagePortRef(messagePort)
+      : new StrongMessagePortRef(messagePort)
+  }
+
+  connect(peerId: PeerId) {
+    log("messageport connecting")
+    this.peerId = peerId
+    this.messagePortRef.start()
+    this.messagePortRef.addListener("message", e => {
+      log("message port received", e.data)
+      const { origin, destination, type, channelId, message, broadcast } =
+        e.data
+      if (destination && !(destination === this.peerId || broadcast)) {
+        throw new Error(
+          "MessagePortNetwork should never receive messages for a different peer."
+        )
+      }
+      switch (type) {
+        case "arrive":
+          this.messagePortRef.postMessage({
+            origin: this.peerId,
+            destination: origin,
+            type: "welcome",
+          })
+          this.announceConnection(channelId, origin)
+          break
+        case "welcome":
+          this.announceConnection(channelId, origin)
+          break
+        case "message":
+          this.emit("message", {
+            senderId: origin,
+            targetId: destination,
+            channelId,
+            message: new Uint8Array(message),
+            broadcast,
+          })
+          break
+        default:
+          throw new Error("unhandled message from network")
+      }
+    })
+
+    this.messagePortRef.addListener("close", () => {
+      this.emit("close")
+    })
+  }
+
+  sendMessage(
+    peerId: PeerId,
+    channelId: ChannelId,
+    uint8message: Uint8Array,
+    broadcast: boolean
+  ) {
+    const message = uint8message.buffer.slice(
+      uint8message.byteOffset,
+      uint8message.byteOffset + uint8message.byteLength
+    )
+    this.messagePortRef.postMessage(
+      {
+        origin: this.peerId,
+        destination: peerId,
+        channelId: channelId,
+        type: "message",
+        message,
+        broadcast,
+      },
+      [message]
+    )
+  }
+
+  announceConnection(channelId: ChannelId, peerId: PeerId) {
+    this.emit("peer-candidate", { peerId, channelId })
+  }
+
+  join(channelId: string) {
+    this.messagePortRef.postMessage({
+      origin: this.peerId,
+      channelId,
+      type: "arrive",
+    })
+  }
+
+  leave(docId: string) {
+    // TODO
+    throw new Error(
+      "Unimplemented: leave on MessagePortNetworkAdapter: " + docId
+    )
+  }
+}
+
+interface MessageChannelNetworkAdapterConfig {
+  /**
+   * This is an optional parameter to use a weak ref to reference the message port that is passed to
+   * the adapter. This option is useful when using a message channel with a shared worker. If you
+   * use a network adapter with `useWeakRef = true` in the shared worker and in the main thread
+   * network adapters with strong refs the network adapter will be automatically garbage collected
+   * if you close a page. The garbage collection doesn't happen immediately; there might be some
+   * time in between when the page is closed and when the port is garbage collected
+   */
+  useWeakRef?: boolean
+}

package/test/index.test.ts

@@ -0,0 +1,53 @@
+import { runAdapterTests } from "@automerge/automerge-repo"
+import { MessageChannelNetworkAdapter as Adapter } from "../src"
+
+// bob is the hub, alice and charlie are spokes
+describe("MessageChannelNetworkAdapter", () => {
+  runAdapterTests(async () => {
+    const aliceBobChannel = new MessageChannel()
+    const bobCharlieChannel = new MessageChannel()
+
+    const { port1: aliceToBob, port2: bobToAlice } = aliceBobChannel
+    const { port1: bobToCharlie, port2: charlieToBob } = bobCharlieChannel
+
+    const a = new Adapter(aliceToBob)
+    const b = [new Adapter(bobToAlice), new Adapter(bobToCharlie)]
+    const c = new Adapter(charlieToBob)
+
+    const teardown = () => {
+      const ports = [aliceToBob, bobToAlice, bobToCharlie, charlieToBob]
+      ports.forEach(port => port.close())
+    }
+
+    return { adapters: [a, b, c], teardown }
+  }, "hub and spoke")
+
+  // all 3 peers connected directly to each other
+  runAdapterTests(async () => {
+    const aliceBobChannel = new MessageChannel()
+    const bobCharlieChannel = new MessageChannel()
+    const aliceCharlieChannel = new MessageChannel()
+
+    const { port1: aliceToBob, port2: bobToAlice } = aliceBobChannel
+    const { port1: bobToCharlie, port2: charlieToBob } = bobCharlieChannel
+    const { port1: aliceToCharlie, port2: charlieToAlice } = aliceCharlieChannel
+
+    const a = [new Adapter(aliceToBob), new Adapter(aliceToCharlie)]
+    const b = [new Adapter(bobToAlice), new Adapter(bobToCharlie)]
+    const c = [new Adapter(charlieToBob), new Adapter(charlieToAlice)]
+
+    const teardown = () => {
+      const ports = [
+        aliceToBob,
+        bobToAlice,
+        bobToCharlie,
+        charlieToBob,
+        aliceToCharlie,
+        charlieToAlice,
+      ]
+      ports.forEach(port => port.close())
+    }
+
+    return { adapters: [a, b, c], teardown }
+  }, "all-to-all")
+})

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "jsx": "react",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./dist",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": false,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*.ts"]
+}