src/y-union.js

+/* global Y */
+
+import { combineErasureIntervals } from "./erasure.js"
+
+export const Union = {
+  create: function(id) {
+    return {
+      id: id,
+      union: null,
+      struct: "Union",
+    }
+  },
+  encode: function(op) {
+    const e = {
+      struct: "Union",
+      type: op.type,
+      id: op.id,
+      union: null,
+    }
+    if (op.requires != null) {
+      e.requires = op.requires
+    }
+    if (op.info != null) {
+      e.info = op.info
+    }
+    return e
+  },
+  requiredOps: function() {
+    return []
+  },
+  execute: function*() {},
+}
+
+export default function extendYUnion(Y) {
+  class YUnion extends Y.utils.CustomType {
+    constructor(os, model, contents) {
+      super()
+      this._model = model.id
+      this._parent = null
+      this._deepEventHandler = new Y.utils.EventListenerHandler()
+      this.os = os
+      this.union = model.union ? Y.utils.copyObject(model.union) : null
+      this.contents = contents
+      this.eventHandler = new Y.utils.EventHandler((op) => {
+        // compute op event
+        if (op.struct === "Insert") {
+          if (!Y.utils.compareIds(op.id, this.union)) {
+            const mergedContents = this._merge(JSON.parse(op.content[0]))
+            this.union = op.id
+            if (this.contents == mergedContents) {
+              return
+            }
+            this.contents = mergedContents
+            Y.utils.bubbleEvent(this, {
+              object: this,
+              type: "merge",
+            })
+          }
+        } else {
+          throw new Error("Unexpected Operation!")
+        }
+      })
+    }
+    _getPathToChild(/*childId*/) {
+      return undefined
+    }
+    _destroy() {
+      this.eventHandler.destroy()
+      this.eventHandler = null
+      this.contents = null
+      this._model = null
+      this._parent = null
+      this.os = null
+      this.union = null
+    }
+    get() {
+      return JSON.parse(this.contents)
+    }
+    _merge(newIntervals) {
+      const prevIntervals = this.get()
+
+      const mergedIntervals = combineErasureIntervals(
+        [prevIntervals],
+        [newIntervals],
+      )[0]
+
+      return JSON.stringify(mergedIntervals)
+    }
+    merge(newIntervals) {
+      const mergedContents = this._merge(newIntervals)
+
+      if (this.contents == mergedContents) {
+        return
+      }
+
+      const insert = {
+        id: this.os.getNextOpId(1),
+        left: null,
+        right: this.union,
+        origin: null,
+        parent: this._model,
+        content: [mergedContents],
+        struct: "Insert",
+      }
+
+      const eventHandler = this.eventHandler
+      this.os.requestTransaction(function*() {
+        yield* eventHandler.awaitOps(this, this.applyCreatedOperations, [
+          [insert],
+        ])
+      })
+      // always remember to do that after this.os.requestTransaction
+      // (otherwise values might contain a undefined reference to type)
+      eventHandler.awaitAndPrematurelyCall([insert])
+    }
+    observe(f) {
+      this.eventHandler.addEventListener(f)
+    }
+    observeDeep(f) {
+      this._deepEventHandler.addEventListener(f)
+    }
+    unobserve(f) {
+      this.eventHandler.removeEventListener(f)
+    }
+    unobserveDeep(f) {
+      this._deepEventHandler.removeEventListener(f)
+    }
+    // eslint-disable-next-line require-yield
+    *_changed(transaction, op) {
+      this.eventHandler.receivedOp(op)
+    }
+  }
+  Y.extend(
+    "Union",
+    new Y.utils.CustomTypeDefinition({
+      name: "Union",
+      class: YUnion,
+      struct: "Union",
+      initType: function* YUnionInitializer(os, model) {
+        const union = model.union
+        const contents =
+          union !== null ? (yield* this.getOperation(union)).content[0] : "[]"
+        return new YUnion(os, model, contents)
+      },
+      createType: function YUnionCreator(os, model) {
+        const union = new YUnion(os, model, "[]")
+        return union
+      },
+    }),
+  )
+}
+
+if (typeof Y !== "undefined") {
+  extendYUnion(Y)
+}

src/y-webrtc/LICENSE

-The MIT License (MIT)
-
-Copyright (c) 2014 Kevin Jahns <kevin.jahns@rwth-aachen.de>.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

src/y-webrtc/index.js

-/* global Y */
-"use strict"
-
-import { peerjs } from "peerjs"
-const { Peer } = peerjs
-
-function extend(Y) {
-  class WebRTC extends Y.AbstractConnector {
-    constructor(y, options) {
-      if (options === undefined) {
-        throw new Error("Options must not be undefined!")
-      }
-
-      options.role = "slave"
-      super(y, options)
-      this.webrtcOptions = options
-
-      this.initialiseConnection()
-    }
-
-    initialiseConnection() {
-      var peer = new Peer({
-        host: this.webrtcOptions.host,
-        port: this.webrtcOptions.port,
-        path: this.webrtcOptions.path,
-      })
-
-      this.peer = peer
-      var self = this
-      this.peers = new Map()
-
-      peer.on("open", function(id) {
-        //console.log("My peer ID is: " + id)
-
-        for (var f of self.userEventListeners) {
-          f({ action: "userID", id: id })
-        }
-
-        self.setUserId(id)
-      })
-
-      peer.on("connection", function(dataConnection) {
-        self.initialiseChannel(dataConnection)
-      })
-    }
-
-    connectToPeer(uid) {
-      this.initialiseChannel(this.peer.connect(uid))
-    }
-
-    initialiseChannel(dataConnection) {
-      var self = this
-
-      dataConnection.on("open", function() {
-        //console.log("Connected to peer " + dataConnection.peer)
-
-        self.peers.set(dataConnection.peer, dataConnection)
-        self.userJoined(dataConnection.peer, "master")
-      })
-
-      dataConnection.on("data", function(data) {
-        //console.log("Message from peer " + dataConnection.peer + ":", data)
-
-        self.receiveMessage(dataConnection.peer, data)
-      })
-
-      dataConnection.on("close", function() {
-        //console.log("Disconnected from peer " + dataConnection.peer)
-
-        self.peers.delete(dataConnection.peer)
-        self.userLeft(dataConnection.peer)
-      })
-    }
-
-    disconnect() {
-      this.peer.destroy()
-      this.peers = new Map()
-
-      super.disconnect()
-    }
-
-    reconnect() {
-      this.initialiseConnection()
-
-      super.reconnect()
-    }
-
-    send(uid, message) {
-      //console.log("Sending message", message, "to " + uid)
-
-      var self = this
-
-      var send = function() {
-        // check if the clients still exists
-        var peer = self.peers.get(uid)
-
-        if (peer) {
-          try {
-            peer.send(message)
-          } catch (error) {
-            setTimeout(send, 500)
-          }
-        }
-      }
-
-      // try to send the message
-      send()
-    }
-
-    broadcast(message) {
-      //console.log("Broadcasting message", message)
-
-      for (const uid of this.peers.keys()) {
-        this.send(uid, message)
-      }
-    }
-
-    isDisconnected() {
-      return false
-    }
-  }
-
-  Y.extend("webrtc", WebRTC)
-}
-
-export default extend
-if (typeof Y !== "undefined") {
-  extend(Y)
-}

yjs @ 44aa194d

+Subproject commit 44aa194d19217cbc1d8e0828cf8fdf39fc4dcdd3

start_server.sh

+npm run build && npm start

webpack.bench.js

+const merge = require("webpack-merge")
+const common = require("./webpack.common.js")
+const BundleAnalyzerPlugin = require("webpack-bundle-analyzer")
+  .BundleAnalyzerPlugin
+
+module.exports = (env) => {
+  const config = merge(common, {
+    mode: "production",
+    entry: {
+      benchmarks: "./__benchmarks__/benchmarks.js",
+    },
+    plugins: env && env.analyze ? [new BundleAnalyzerPlugin()] : [],
+  })
+
+  delete config.entry.app
+
+  return config
+}

webpack.common.js

+const path = require("path")
+const webpack = require("webpack")
+
+module.exports = {
+  mode: "development",
+  entry: {
+    app: "./src/app.js",
+    queue: "./src/queue.js",
+  },
+  output: {
+    filename: "[name].js",
+    path: path.resolve(__dirname, "public/js"),
+    publicPath: "js/",
+  },
+  plugins: [
+    new webpack.ProvidePlugin({
+      EventTarget: ["@ungap/event-target", "default"],
+    }),
+  ],
+  module: {
+    rules: [
+      {
+        test: /.(ttf|otf|eot|svg|woff(2)?)(\?[a-z0-9]+)?$/,
+        use: [
+          {
+            loader: "file-loader",
+            options: {
+              name: "../assets/fonts/font-awesome/[name].[ext]",
+              publicPath: "font-awesome/",
+            },
+          },
+        ],
+      },
+      {
+        test: /\.css$/,
+        use: ["style-loader", "css-loader"],
+      },
+    ],
+  },
+}

webpack.dev.js

+const merge = require("webpack-merge")
+const common = require("./webpack.common.js")
+
+module.exports = merge(common, {
+  mode: "development",
+  watch: true,
+  devtool: "inline-source-map",
+
+  devServer: {
+    contentBase: "./public/js",
+  },
+})

webpack.prod.js

+const merge = require("webpack-merge")
+const common = require("./webpack.common.js")
+const BundleAnalyzerPlugin = require("webpack-bundle-analyzer")
+  .BundleAnalyzerPlugin
+
+module.exports = (env) =>
+  merge(common, {
+    mode: "production",
+    plugins: env && env.analyze ? [new BundleAnalyzerPlugin()] : [],
+  })