y-rb 0.4.6-x86_64-linux → 0.5.0-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c5deaf53bc4859a4f4765b0e263d4c5993b0f707529e20e8d61ea5ad1eecea0
-  data.tar.gz: 004320cb2be843111b9243f5ac3d93ce1a5165d58754c9d3a217c832e191a2ee
+  metadata.gz: fd77db92508918fc11424cd830c80bfdecb435ba5623ebd0d0d8b9ed1adb7a37
+  data.tar.gz: a4b40ee84fde7646056ef81e67f8d7f978d43e1e22966f7a500633d014ca9381
 SHA512:
-  metadata.gz: 6bbdcf2ca893466bae039dd257103529aab5b71d622c0bf1075c06a90c95a3970f00613138bcf2e90588263f55186d1f0b08105daef2d9584490c73533a6f87c
-  data.tar.gz: c2744c9f4fd20d97751edce6feb0e030e1f0a5ff4b7407ae85464bf13917c79e7a45a253210e11822fb730865e20d21cf43de3be71083c9e62af0fbee9065086
+  metadata.gz: '08253c1cac2a5a1935fafb64a2f8891356880623cbfa43772290e8ca33359fdd8df2d323a10ae3de15e8e784d4d65484a6df35ab6cb3986b5af342535bbdfacb'
+  data.tar.gz: 1f9cdc2910c11c06d3c76c8bed8b79227c6684a9a5f3e286762b858c4f3202a29cacbe1593141f849f1598d9dbc9c16f57c65ced7ebe874fef29fc30d2056112

data/ext/yrb/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "yrb"
-version = "0.4.6"
+version = "0.5.0"
 authors = ["Hannes Moser <box@hannesmoser.at>", "Hannes Moser <hmoser@gitlab.com>"]
 edition = "2021"
 homepage = "https://github.com/y-crdt/yrb"
@@ -11,6 +11,7 @@ lib0 = "0.16.2" # must match yrs version
 magnus = { git = "https://github.com/matsadler/magnus", rev = "2c2024920a403daadbe23fe63270440dfac86288" }
 thiserror = "1.0.38"
 yrs = "0.16.2"
+y-sync = "0.2.0"
 
 [dev-dependencies]
 magnus = { git = "https://github.com/matsadler/magnus", rev = "2c2024920a403daadbe23fe63270440dfac86288", features = ["embed"] }

data/ext/yrb/src/lib.rs

@@ -11,7 +11,6 @@ use crate::yxml_fragment::YXmlFragment;
 use crate::yxml_text::YXmlText;
 use magnus::{define_module, function, method, Error, Module, Object};
 
-mod awareness;
 mod utils;
 mod yany;
 mod yarray;
@@ -578,12 +577,6 @@ fn init() -> Result<(), Error> {
             method!(YAwareness::yawareness_on_update, 1),
         )
         .expect("cannot define private method: yawareness_on_update");
-    yawareness
-        .define_private_method(
-            "yawareness_remove_on_update",
-            method!(YAwareness::yawareness_remove_on_update, 1),
-        )
-        .expect("cannot define private method: yawareness_remove_on_update");
     yawareness
         .define_private_method(
             "yawareness_remove_state",

data/ext/yrb/src/yawareness.rs

@@ -1,12 +1,12 @@
-use crate::awareness::{Awareness, AwarenessUpdate, Event};
 use magnus::{block::Proc, exception, Error, Value};
 use std::borrow::Borrow;
 use std::cell::RefCell;
 use std::collections::HashMap;
+use y_sync::awareness::{Awareness, AwarenessUpdate, Event, Subscription};
 use yrs::block::ClientID;
 use yrs::updates::decoder::Decode;
 use yrs::updates::encoder::Encode;
-use yrs::Doc;
+use yrs::{Doc, OffsetKind, Options};
 
 #[magnus::wrap(class = "Y::Awareness")]
 pub(crate) struct YAwareness(pub(crate) RefCell<Awareness>);
@@ -16,7 +16,14 @@ unsafe impl Send for YAwareness {}
 
 impl YAwareness {
     pub(crate) fn yawareness_new() -> Self {
-        let doc = Doc::new();
+        let mut options = Options {
+            offset_kind: OffsetKind::Utf32,
+            ..Default::default()
+        };
+        options.offset_kind = OffsetKind::Utf32;
+
+        let doc = Doc::with_options(options);
+
         let awareness = Awareness::new(doc);
 
         Self(RefCell::new(awareness))
@@ -48,24 +55,18 @@ impl YAwareness {
         self.0.borrow().local_state().map(|value| value.to_string())
     }
 
-    pub(crate) fn yawareness_on_update(&self, block: Proc) -> Result<u32, Error> {
-        let subscription_id = self
-            .0
-            .borrow_mut()
-            .on_update(move |_awareness, event| {
-                let awareness_event = YAwarenessEvent::from(event);
-                let args = (awareness_event,);
-                block
-                    .call::<(YAwarenessEvent,), Value>(args)
-                    .expect("cannot call block: on_update");
-            })
-            .into();
+    pub(crate) fn yawareness_on_update(&self, block: Proc) -> YAwarenessSubscription {
+        let subscription = self.0.borrow_mut().on_update(move |_awareness, event| {
+            let awareness_event = YAwarenessEvent::from(event);
+            let args = (awareness_event,);
+            block
+                .call::<(YAwarenessEvent,), Value>(args)
+                .expect("cannot call block: on_update");
+        });
 
-        Ok(subscription_id)
-    }
-
-    pub(crate) fn yawareness_remove_on_update(&self, subscription_id: u32) {
-        self.0.borrow_mut().remove_on_update(subscription_id)
+        // we need to make sure the event handler "survives" and is not being
+        // dropped after leaving this scope, so we pass it back to Ruby.
+        YAwarenessSubscription::from(subscription)
     }
 
     pub(crate) fn yawareness_remove_state(&self, client_id: ClientID) {
@@ -135,3 +136,16 @@ impl From<&Event> for YAwarenessEvent {
         Self(value.clone())
     }
 }
+
+#[magnus::wrap(class = "Y::AwarenessEvent")]
+pub(crate) struct YAwarenessSubscription(Subscription<Event>);
+
+unsafe impl Send for YAwarenessSubscription {}
+
+impl YAwarenessSubscription {}
+
+impl From<Subscription<Event>> for YAwarenessSubscription {
+    fn from(v: Subscription<Event>) -> Self {
+        YAwarenessSubscription(v)
+    }
+}

data/lib/y/array.rb

@@ -38,7 +38,7 @@ module Y
 
     # Retrieves element at position
     #
-    # @return [true|false|Float|Integer|String|Array|Hash]
+    # @return [true, false, Float, Integer, String, Array, Hash]
     def [](index)
       document.current_transaction { |tx| yarray_get(tx, index) }
     end
@@ -46,7 +46,7 @@ module Y
     # Inserts value at position
     #
     # @param index [Integer]
-    # @param value [true|false|Float|Integer|String|Array|Hash]
+    # @param value [true, false, Float, Integer, String, Array, Hash]
     # @return [void]
     def []=(index, value)
       document.current_transaction { |tx| yarray_insert(tx, index, value) }
@@ -54,7 +54,7 @@ module Y
 
     # Adds an element to the end of the array
     #
-    # @param value [true|false|Float|Integer|String|::Array|Hash]
+    # @param value [true, false, Float, Integer, String, ::Array, Hash]
     # @return [void]
     def <<(value, *values)
       document.current_transaction do |tx|
@@ -121,21 +121,21 @@ module Y
 
     # Check if the array is empty
     #
-    # @return [true|false]
+    # @return [true, false]
     def empty?
       size.zero?
     end
 
     # Returns first element in array if there is at least one
     #
-    # @return [true|false|Float|Integer|String|::Array|Hash|nil]
+    # @return [true, false, Float, Integer, String, ::Array, Hash, nil]
     def first
       document.current_transaction { |tx| yarray_get(tx, 0) }
     end
 
     # Returns last element in array if there is at least one element
     #
-    # @return [true|false|Float|Integer|String|::Array|Hash|nil]
+    # @return [true, false, Float, Integer, String, ::Array, Hash, nil]
     def last
       document.current_transaction do |tx|
         len = yarray_length(tx)
@@ -149,7 +149,7 @@ module Y
 
     # Removes last (n) element(s) from array
     #
-    # @param n [Integer|nil] Number of elements to remove
+    # @param n [Integer, nil] Number of elements to remove
     # @return [void]
     def pop(n = nil)
       document.current_transaction do |tx|
@@ -167,7 +167,7 @@ module Y
 
     # Removes first (n) element(s) from array
     #
-    # @param n [Integer|nil] Number of elements to remove
+    # @param n [Integer, nil] Number of elements to remove
     # @return [void]
     def shift(n = nil)
       document.current_transaction do |tx|
@@ -264,7 +264,7 @@ module Y
 
     # Convert this array to a Ruby Array
     #
-    # @return [Array<true|false|Float|Integer|String|::Array|Hash>]
+    # @return [Array<true, false, Float, Integer, String, ::Array, Hash>]
     def to_a
       document.current_transaction { |tx| yarray_to_a(tx) }
     end
@@ -306,7 +306,7 @@ module Y
     #
     # @param transaction [Y::Transaction]
     # @param index [Integer]
-    # @param arr [Array<Boolean|Float|Integer|Array|Hash|Text>]
+    # @param arr [Array<Boolean, Float, Integer, Array, Hash, Text>]
     # @return [void]
     # @!visibility private
 

data/lib/y/awareness.rb

@@ -93,25 +93,28 @@ module Y
     #
     # @return [Hash] All clients and their current state
     def clients
-      yawareness_clients
+      transform = yawareness_clients.map do |client_id, state|
+        [client_id, JSON.parse!(state)]
+      end
+      transform.to_h
     end
 
-    # Returns a JSON string state representation of a current Awareness
-    # instance.
+    # Returns the state of the local Awareness instance.
     #
     # @example Create local state and inspect it
     #   local_state = {
     #     editing: { field: "description", pos: 0 },
     #     name: "Hannes Moser"
-    #   }.to_json
+    #   }
     #
     #   awareness = Y::Awareness.new
     #   awareness.local_state = local_state
-    #   local_state # "{\"editing\":{\"field\":\"description\",\"pos\":0}, …
+    #   awareness.local_state # {  editing: { field: "description", ...
     #
     # @return [String] The current state of the local client
     def local_state
-      yawareness_local_state
+      json = yawareness_local_state
+      JSON.parse!(json) if json
     end
 
     # Sets a current Awareness instance state to a corresponding JSON string.
@@ -127,28 +130,23 @@ module Y
     #   awareness = Y::Awareness.new
     #   awareness.local_state = local_state
     #
+    # @param [#to_json] state
     # @return [void]
-    def local_state=(json)
-      yawareness_set_local_state(json)
+    def local_state=(state)
+      raise "state cannot be encoded to JSON" unless state.respond_to? :to_json
+
+      yawareness_set_local_state(state.to_json)
     end
 
     # Subscribes to changes
     #
     # @return [Integer] The subscription ID
-    def attach(callback, &block)
+    def attach(callback = nil, &block)
       return yawareness_on_update(callback) unless callback.nil?
 
       yawareness_on_update(block.to_proc) unless block.nil?
     end
 
-    # Unsubscribe from changes
-    #
-    # @param subscription_id [Integer]
-    # @return [void]
-    def detach(subscription_id)
-      yawareness_remove_on_update(subscription_id)
-    end
-
     # Clears out a state of a given client, effectively marking it as
     # disconnected.
     #
@@ -216,7 +214,7 @@ module Y
 
     # @!method yawareness_local_state
     #
-    # @return [String|nil] Returns a JSON string state representation of a
+    # @return [String, nil] Returns a JSON string state representation of a
     #   current Awareness instance.
     # @!visibility private
 
@@ -236,7 +234,7 @@ module Y
     #   disconnected.
     #
     # @param client_id [Integer] A Client ID
-    # @return [String|nil] Returns a JSON string state representation of a
+    # @return [String, nil] Returns a JSON string state representation of a
     #   current Awareness instance.
     # @!visibility private
 

data/lib/y/map.rb

@@ -70,7 +70,7 @@ module Y
     #   m.delete(:nosuch) { |key| "Key #{key} not found" }# => "Key nosuch not found"
     #   m # => {}
     #
-    # @param key [String|Symbol]
+    # @param key [String, Symbol]
     # @return [void]
     def delete(key)
       value = document.current_transaction { |tx| ymap_remove(tx, key) }
@@ -96,7 +96,7 @@ module Y
       document.current_transaction { |tx| ymap_each(tx, block) }
     end
 
-    # @return [true|false]
+    # @return [true, false]
     def key?(key)
       document.current_transaction { |tx| ymap_contains(tx, key) }
     end
@@ -143,7 +143,7 @@ module Y
     #   Check if a certain key is in the Map
     #
     # @param tx [Y::Transaction]
-    # @param key [String|Symbol]
+    # @param key [String, Symbol]
     # @return [Boolean] True, if and only if the key exists
 
     # @!method ymap_each(tx, proc)
@@ -151,21 +151,21 @@ module Y
     #   with the key and the value as arguments.
     #
     # @param tx [Y::Transaction]
-    # @param proc [Proc<String|Any>] A proc that is called for every element
+    # @param proc [Proc<String, Any>] A proc that is called for every element
 
     # @!method ymap_get(tx, key)
     #   Returns stored value for key or nil if none is present
     #
     # @param tx [Y::Transaction]
-    # @param key [String|Symbol]
-    # @return [Object|nil] Value or nil
+    # @param key [String, Symbol]
+    # @return [Object, nil] Value or nil
 
     # @!method ymap_insert(tx, key, value)
     #   Insert value for key. In case the key already exists, the previous value
     #   will be overwritten.
     #
     # @param tx [Y::Transaction]
-    # @param key [String|Symbol]
+    # @param key [String, Symbol]
     # @param value [Object]
 
     # @!method ymap_observe(callback)
@@ -177,7 +177,7 @@ module Y
     #   Removes key-value pair from Map if key exists.
     #
     # @param tx [Y::Transaction]
-    # @param key [String|Symbol]
+    # @param key [String, Symbol]
 
     # @!method ymap_size(tx)
     #   Returns number of key-value pairs stored in map

data/lib/y/text.rb

@@ -116,8 +116,8 @@ module Y
     # - Hash (where the the types of key and values must be supported)
     #
     # @param index [Integer]
-    # @param value [String|Numeric|Array|Hash]
-    # @param attrs [Hash|nil]
+    # @param value [String, Numeric, Array, Hash]
+    # @param attrs [Hash, nil]
     # @return [void]
     def insert(index, value, attrs = nil)
       document.current_transaction do |tx|

data/lib/y/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Y
-  VERSION = "0.4.6"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: y-rb
 version: !ruby/object:Gem::Version
-  version: 0.4.6
+  version: 0.5.0
 platform: x86_64-linux
 authors:
 - Hannes Moser
@@ -78,7 +78,6 @@ extra_rdoc_files: []
 files:
 - ext/yrb/Cargo.toml
 - ext/yrb/extconf.rb
-- ext/yrb/src/awareness.rs
 - ext/yrb/src/lib.rs
 - ext/yrb/src/utils.rs
 - ext/yrb/src/yany.rs

data/ext/yrb/src/awareness.rs

@@ -1,425 +0,0 @@
-use std::cell::RefCell;
-use std::collections::hash_map::Entry;
-use std::collections::HashMap;
-use std::rc::{Rc, Weak};
-use std::time::Instant;
-use thiserror::Error;
-use yrs::block::ClientID;
-use yrs::updates::decoder::{Decode, Decoder};
-use yrs::updates::encoder::{Encode, Encoder};
-use yrs::{Doc, SubscriptionId};
-
-const NULL_STR: &str = "null";
-
-/// The Awareness class implements a simple shared state protocol that can be used for non-persistent
-/// data like awareness information (cursor, username, status, ..). Each client can update its own
-/// local state and listen to state changes of remote clients.
-///
-/// Each client is identified by a unique client id (something we borrow from `doc.clientID`).
-/// A client can override its own state by propagating a message with an increasing timestamp
-/// (`clock`). If such a message is received, it is applied if the known state of that client is
-/// older than the new state (`clock < new_clock`). If a client thinks that a remote client is
-/// offline, it may propagate a message with `{ clock, state: null, client }`. If such a message is
-/// received, and the known clock of that client equals the received clock, it will clean the state.
-///
-/// Before a client disconnects, it should propagate a `null` state with an updated clock.
-pub struct Awareness {
-    doc: Doc,
-    states: HashMap<ClientID, String>,
-    meta: HashMap<ClientID, MetaClientState>,
-    on_update: Option<EventHandler<Event>>,
-}
-
-unsafe impl Send for Awareness {}
-unsafe impl Sync for Awareness {}
-
-impl Awareness {
-    /// Creates a new instance of [Awareness] struct, which operates over a given document.
-    /// Awareness instance has full ownership of that document. If necessary it can be accessed
-    /// using either [Awareness::doc] or [Awareness::doc_mut] methods.
-    pub fn new(doc: Doc) -> Self {
-        Awareness {
-            doc,
-            on_update: None,
-            states: HashMap::new(),
-            meta: HashMap::new(),
-        }
-    }
-
-    /// Returns a channel receiver for an incoming awareness events. This channel can be cloned.
-    pub fn on_update<F>(&mut self, f: F) -> Subscription<Event>
-    where
-        F: Fn(&Awareness, &Event) + 'static,
-    {
-        let eh = self.on_update.get_or_insert_with(EventHandler::default);
-        eh.subscribe(f)
-    }
-
-    /// Removes a receiver for incoming awareness events.
-    pub fn remove_on_update(&mut self, subscription_id: u32) {
-        if let Some(eh) = self.on_update.as_mut() {
-            eh.unsubscribe(subscription_id);
-        }
-    }
-
-    /// Returns a globally unique client ID of an underlying [Doc].
-    pub fn client_id(&self) -> ClientID {
-        self.doc.client_id()
-    }
-
-    /// Returns a state map of all of the clients tracked by current [Awareness] instance. Those
-    /// states are identified by their corresponding [ClientID]s. The associated state is
-    /// represented and replicated to other clients as a JSON string.
-    pub fn clients(&self) -> &HashMap<ClientID, String> {
-        &self.states
-    }
-
-    /// Returns a JSON string state representation of a current [Awareness] instance.
-    pub fn local_state(&self) -> Option<&str> {
-        Some(self.states.get(&self.doc.client_id())?.as_str())
-    }
-
-    /// Sets a current [Awareness] instance state to a corresponding JSON string. This state will
-    /// be replicated to other clients as part of the [AwarenessUpdate] and it will trigger an event
-    /// to be emitted if current instance was created using [Awareness::with_observer] method.
-    ///
-    pub fn set_local_state<S: Into<String>>(&mut self, json: S) {
-        let client_id = self.doc.client_id();
-        self.update_meta(client_id);
-        let new: String = json.into();
-        match self.states.entry(client_id) {
-            Entry::Occupied(mut e) => {
-                e.insert(new);
-                if let Some(eh) = self.on_update.as_ref() {
-                    eh.trigger(self, &Event::new(vec![], vec![client_id], vec![]));
-                }
-            }
-            Entry::Vacant(e) => {
-                e.insert(new);
-                if let Some(eh) = self.on_update.as_ref() {
-                    eh.trigger(self, &Event::new(vec![client_id], vec![], vec![]));
-                }
-            }
-        }
-    }
-
-    /// Clears out a state of a given client, effectively marking it as disconnected.
-    pub fn remove_state(&mut self, client_id: ClientID) {
-        let prev_state = self.states.remove(&client_id);
-        self.update_meta(client_id);
-        if let Some(eh) = self.on_update.as_ref() {
-            if prev_state.is_some() {
-                eh.trigger(
-                    self,
-                    &Event::new(Vec::default(), Vec::default(), vec![client_id]),
-                );
-            }
-        }
-    }
-
-    /// Clears out a state of a current client (see: [Awareness::client_id]),
-    /// effectively marking it as disconnected.
-    pub fn clean_local_state(&mut self) {
-        let client_id = self.doc.client_id();
-        self.remove_state(client_id);
-    }
-
-    fn update_meta(&mut self, client_id: ClientID) {
-        match self.meta.entry(client_id) {
-            Entry::Occupied(mut e) => {
-                let clock = e.get().clock + 1;
-                let meta = MetaClientState::new(clock, Instant::now());
-                e.insert(meta);
-            }
-            Entry::Vacant(e) => {
-                e.insert(MetaClientState::new(1, Instant::now()));
-            }
-        }
-    }
-
-    /// Returns a serializable update object which is representation of a current Awareness state.
-    pub fn update(&self) -> Result<AwarenessUpdate, Error> {
-        let clients = self.states.keys().cloned();
-        self.update_with_clients(clients)
-    }
-
-    /// Returns a serializable update object which is representation of a current Awareness state.
-    /// Unlike [Awareness::update], this method variant allows to prepare update only for a subset
-    /// of known clients. These clients must all be known to a current [Awareness] instance,
-    /// otherwise a [Error::ClientNotFound] error will be returned.
-    pub fn update_with_clients<I: IntoIterator<Item = ClientID>>(
-        &self,
-        clients: I,
-    ) -> Result<AwarenessUpdate, Error> {
-        let mut res = HashMap::new();
-        for client_id in clients {
-            let clock = if let Some(meta) = self.meta.get(&client_id) {
-                meta.clock
-            } else {
-                return Err(Error::ClientNotFound(client_id));
-            };
-            let json = if let Some(json) = self.states.get(&client_id) {
-                json.clone()
-            } else {
-                String::from(NULL_STR)
-            };
-            res.insert(client_id, AwarenessUpdateEntry { clock, json });
-        }
-        Ok(AwarenessUpdate { clients: res })
-    }
-
-    /// Applies an update (incoming from remote channel or generated using [Awareness::update] /
-    /// [Awareness::update_with_clients] methods) and modifies a state of a current instance.
-    ///
-    /// If current instance has an observer channel (see: [Awareness::with_observer]), applied
-    /// changes will also be emitted as events.
-    pub fn apply_update(&mut self, update: AwarenessUpdate) -> Result<(), Error> {
-        let now = Instant::now();
-
-        let mut added = Vec::new();
-        let mut updated = Vec::new();
-        let mut removed = Vec::new();
-
-        for (client_id, entry) in update.clients {
-            let mut clock = entry.clock;
-            let is_null = entry.json.as_str() == NULL_STR;
-            match self.meta.entry(client_id) {
-                Entry::Occupied(mut e) => {
-                    let prev = e.get();
-                    let is_removed =
-                        prev.clock == clock && is_null && self.states.contains_key(&client_id);
-                    let is_new = prev.clock < clock;
-                    if is_new || is_removed {
-                        if is_null {
-                            // never let a remote client remove this local state
-                            if client_id == self.doc.client_id()
-                                && self.states.get(&client_id).is_some()
-                            {
-                                // remote client removed the local state. Do not remote state. Broadcast a message indicating
-                                // that this client still exists by increasing the clock
-                                clock += 1;
-                            } else {
-                                self.states.remove(&client_id);
-                                if self.on_update.is_some() {
-                                    removed.push(client_id);
-                                }
-                            }
-                        } else {
-                            match self.states.entry(client_id) {
-                                Entry::Occupied(mut e) => {
-                                    if self.on_update.is_some() {
-                                        updated.push(client_id);
-                                    }
-                                    e.insert(entry.json);
-                                }
-                                Entry::Vacant(e) => {
-                                    e.insert(entry.json);
-                                    if self.on_update.is_some() {
-                                        updated.push(client_id);
-                                    }
-                                }
-                            }
-                        }
-                        e.insert(MetaClientState::new(clock, now));
-                        true
-                    } else {
-                        false
-                    }
-                }
-                Entry::Vacant(e) => {
-                    e.insert(MetaClientState::new(clock, now));
-                    self.states.insert(client_id, entry.json);
-                    if self.on_update.is_some() {
-                        added.push(client_id);
-                    }
-                    true
-                }
-            };
-        }
-
-        if let Some(eh) = self.on_update.as_ref() {
-            if !added.is_empty() || !updated.is_empty() || !removed.is_empty() {
-                eh.trigger(self, &Event::new(added, updated, removed));
-            }
-        }
-
-        Ok(())
-    }
-}
-
-impl Default for Awareness {
-    fn default() -> Self {
-        Awareness::new(Doc::new())
-    }
-}
-
-#[allow(clippy::type_complexity)]
-struct EventHandler<T> {
-    seq_nr: u32,
-    subscribers: Rc<RefCell<HashMap<u32, Box<dyn Fn(&Awareness, &T)>>>>,
-}
-
-impl<T> EventHandler<T> {
-    pub fn subscribe<F>(&mut self, f: F) -> Subscription<T>
-    where
-        F: Fn(&Awareness, &T) + 'static,
-    {
-        let subscription_id = self.seq_nr;
-        self.seq_nr += 1;
-        {
-            let func = Box::new(f);
-            let mut subs = self.subscribers.borrow_mut();
-            subs.insert(subscription_id, func);
-        }
-        Subscription {
-            subscription_id,
-            subscribers: Rc::downgrade(&self.subscribers),
-        }
-    }
-
-    pub fn unsubscribe(&mut self, subscription_id: u32) {
-        let mut subs = self.subscribers.borrow_mut();
-        subs.remove(&subscription_id);
-    }
-
-    pub fn trigger(&self, awareness: &Awareness, arg: &T) {
-        let subs = self.subscribers.borrow();
-        for func in subs.values() {
-            func(awareness, arg);
-        }
-    }
-}
-
-impl<T> Default for EventHandler<T> {
-    fn default() -> Self {
-        EventHandler {
-            seq_nr: 0,
-            subscribers: Rc::new(RefCell::new(HashMap::new())),
-        }
-    }
-}
-
-/// Whenever a new callback is being registered, a [Subscription] is made. Whenever this
-/// subscription a registered callback is cancelled and will not be called any more.
-#[allow(clippy::type_complexity)]
-pub struct Subscription<T> {
-    subscription_id: u32,
-    subscribers: Weak<RefCell<HashMap<u32, Box<dyn Fn(&Awareness, &T)>>>>,
-}
-
-#[allow(clippy::from_over_into)]
-impl<T> Into<SubscriptionId> for Subscription<T> {
-    fn into(self) -> SubscriptionId {
-        let id = self.subscription_id;
-        std::mem::forget(self);
-        id
-    }
-}
-
-impl<T> Drop for Subscription<T> {
-    fn drop(&mut self) {
-        if let Some(subs) = self.subscribers.upgrade() {
-            let mut s = subs.borrow_mut();
-            s.remove(&self.subscription_id);
-        }
-    }
-}
-
-/// A structure that represents an encodable state of an [Awareness] struct.
-#[derive(Debug, Eq, PartialEq)]
-pub struct AwarenessUpdate {
-    clients: HashMap<ClientID, AwarenessUpdateEntry>,
-}
-
-impl Encode for AwarenessUpdate {
-    fn encode<E: Encoder>(&self, encoder: &mut E) {
-        encoder.write_var(self.clients.len());
-        for (&client_id, e) in self.clients.iter() {
-            encoder.write_var(client_id);
-            encoder.write_var(e.clock);
-            encoder.write_string(&e.json);
-        }
-    }
-}
-
-impl Decode for AwarenessUpdate {
-    fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, lib0::error::Error> {
-        let len: usize = decoder.read_var()?;
-        let mut clients = HashMap::with_capacity(len);
-        for _ in 0..len {
-            let client_id: ClientID = decoder.read_var()?;
-            let clock: u32 = decoder.read_var()?;
-            let json = decoder.read_string()?.to_string();
-            clients.insert(client_id, AwarenessUpdateEntry { clock, json });
-        }
-
-        Ok(AwarenessUpdate { clients })
-    }
-}
-
-/// A single client entry of an [AwarenessUpdate]. It consists of logical clock and JSON client
-/// state represented as a string.
-#[derive(Debug, Eq, PartialEq)]
-pub struct AwarenessUpdateEntry {
-    clock: u32,
-    json: String,
-}
-
-/// Errors generated by an [Awareness] struct methods.
-#[derive(Error, Debug)]
-pub enum Error {
-    /// Client ID was not found in [Awareness] metadata.
-    #[error("client ID `{0}` not found")]
-    ClientNotFound(ClientID),
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-struct MetaClientState {
-    clock: u32,
-    last_updated: Instant,
-}
-
-impl MetaClientState {
-    fn new(clock: u32, last_updated: Instant) -> Self {
-        MetaClientState {
-            clock,
-            last_updated,
-        }
-    }
-}
-
-/// Event type emitted by an [Awareness] struct.
-#[derive(Debug, Default, Clone, Eq, PartialEq)]
-pub struct Event {
-    added: Vec<ClientID>,
-    updated: Vec<ClientID>,
-    removed: Vec<ClientID>,
-}
-
-impl Event {
-    pub fn new(added: Vec<ClientID>, updated: Vec<ClientID>, removed: Vec<ClientID>) -> Self {
-        Event {
-            added,
-            updated,
-            removed,
-        }
-    }
-
-    /// Collection of new clients that have been added to an [Awareness] struct, that was not known
-    /// before. Actual client state can be accessed via `awareness.clients().get(client_id)`.
-    pub fn added(&self) -> &[ClientID] {
-        &self.added
-    }
-
-    /// Collection of new clients that have been updated within an [Awareness] struct since the last
-    /// update. Actual client state can be accessed via `awareness.clients().get(client_id)`.
-    pub fn updated(&self) -> &[ClientID] {
-        &self.updated
-    }
-
-    /// Collection of new clients that have been removed from [Awareness] struct since the last
-    /// update.
-    pub fn removed(&self) -> &[ClientID] {
-        &self.removed
-    }
-}