@liveblocks/yjs 1.0.12-yjs1 → 1.0.12-yjs2

package/dist/index.js

@@ -1,5 +1,10 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } }var __defProp = Object.defineProperty;
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -14,6 +19,27 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from2, except, desc) => {
+  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+    for (let key of __getOwnPropNames(from2))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
@@ -36,7 +62,13 @@ var __async = (__this, __arguments, generator) => {
 };
 
 // src/index.ts
-var _jsbase64 = require('js-base64');
+var src_exports = {};
+__export(src_exports, {
+  Awareness: () => Awareness,
+  default: () => LiveblocksProvider
+});
+module.exports = __toCommonJS(src_exports);
+var import_js_base64 = require("js-base64");
 
 // ../../node_modules/lib0/map.js
 var create = () => /* @__PURE__ */ new Map();
@@ -109,7 +141,7 @@ var Observable = class {
 };
 
 // src/index.ts
-var _yjs = require('yjs'); var Y = _interopRequireWildcard(_yjs);
+var Y = __toESM(require("yjs"));
 var Awareness = class extends Observable {
   constructor(doc, room) {
     super();
@@ -186,7 +218,7 @@ var LiveblocksProvider = class {
     this.unsubscribers = [];
     this.updateHandler = (update, origin) => __async(this, null, function* () {
       if (origin !== "backend") {
-        const encodedUpdate = _jsbase64.Base64.fromUint8Array(update);
+        const encodedUpdate = import_js_base64.Base64.fromUint8Array(update);
         this.room.updateDoc(encodedUpdate);
         if (this.httpEndpoint) {
           yield fetch(this.httpEndpoint, {
@@ -211,7 +243,7 @@ var LiveblocksProvider = class {
         if (e === "open") {
           this.doc.clientID = ((_a2 = this.room.getSelf()) == null ? void 0 : _a2.connectionId) || this.doc.clientID;
           this.awareness.clientID = this.doc.clientID;
-          const encodedVector = _jsbase64.Base64.fromUint8Array(
+          const encodedVector = import_js_base64.Base64.fromUint8Array(
             Y.encodeStateVector(this.doc)
           );
           this.room.getDoc(encodedVector);
@@ -220,7 +252,7 @@ var LiveblocksProvider = class {
     );
     this.unsubscribers.push(
       this.room.events.docUpdated.subscribe((updates) => {
-        const decodedUpdates = updates.map(_jsbase64.Base64.toUint8Array);
+        const decodedUpdates = updates.map(import_js_base64.Base64.toUint8Array);
         const update = Y.mergeUpdates(decodedUpdates);
         Y.applyUpdate(this.doc, update, "backend");
       })
@@ -251,7 +283,7 @@ var LiveblocksProvider = class {
         return;
       }
       this.lastUpdateDate = new Date(lastUpdate);
-      const update = Y.mergeUpdates(updates.map(_jsbase64.Base64.toUint8Array));
+      const update = Y.mergeUpdates(updates.map(import_js_base64.Base64.toUint8Array));
       Y.applyUpdate(this.doc, update, "backend");
     });
   }
@@ -261,7 +293,3 @@ var LiveblocksProvider = class {
     this.awareness.destroy();
   }
 };
-
-
-
-exports.Awareness = Awareness; exports.default = LiveblocksProvider;

package/dist/index.mjs

@@ -0,0 +1,267 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+import { Base64 } from "js-base64";
+
+// ../../node_modules/lib0/map.js
+var create = () => /* @__PURE__ */ new Map();
+var setIfUndefined = (map, key, createT) => {
+  let set = map.get(key);
+  if (set === void 0) {
+    map.set(key, set = createT());
+  }
+  return set;
+};
+
+// ../../node_modules/lib0/set.js
+var create2 = () => /* @__PURE__ */ new Set();
+
+// ../../node_modules/lib0/array.js
+var from = Array.from;
+var isArray = Array.isArray;
+
+// ../../node_modules/lib0/observable.js
+var Observable = class {
+  constructor() {
+    this._observers = create();
+  }
+  /**
+   * @param {N} name
+   * @param {function} f
+   */
+  on(name, f) {
+    setIfUndefined(this._observers, name, create2).add(f);
+  }
+  /**
+   * @param {N} name
+   * @param {function} f
+   */
+  once(name, f) {
+    const _f = (...args) => {
+      this.off(name, _f);
+      f(...args);
+    };
+    this.on(name, _f);
+  }
+  /**
+   * @param {N} name
+   * @param {function} f
+   */
+  off(name, f) {
+    const observers = this._observers.get(name);
+    if (observers !== void 0) {
+      observers.delete(f);
+      if (observers.size === 0) {
+        this._observers.delete(name);
+      }
+    }
+  }
+  /**
+   * Emit a named event. All registered event listeners that listen to the
+   * specified name will receive the event.
+   *
+   * @todo This should catch exceptions
+   *
+   * @param {N} name The event name.
+   * @param {Array<any>} args The arguments that are applied to the event listener.
+   */
+  emit(name, args) {
+    return from((this._observers.get(name) || create()).values()).forEach((f) => f(...args));
+  }
+  destroy() {
+    this._observers = create();
+  }
+};
+
+// src/index.ts
+import * as Y from "yjs";
+var Awareness = class extends Observable {
+  constructor(doc, room) {
+    super();
+    this.states = /* @__PURE__ */ new Map();
+    // Meta is used to keep track and timeout users who disconnect. Liveblocks provides this for us, so we don't need to
+    // manage it here. Unfortunately, it's expected to exist by various integrations, so it's an empty map.
+    this.meta = /* @__PURE__ */ new Map();
+    // _checkInterval this would hold a timer to remove users, but Liveblock's presence already handles this
+    // unfortunately it's expected to exist by various integrations.
+    this._checkInterval = 0;
+    this.doc = doc;
+    this.room = room;
+    this.clientID = doc.clientID;
+    this.othersUnsub = this.room.events.others.subscribe(({ event }) => {
+      if (event.type === "leave") {
+        this.emit("change", [
+          { added: [], updated: [], removed: [event.user.connectionId] },
+          "local"
+        ]);
+      }
+      if (event.type === "enter") {
+        this.emit("change", [
+          { added: [event.user.connectionId], updated: [], removed: [] },
+          "local"
+        ]);
+      }
+      if (event.type === "update") {
+        this.emit("change", [
+          { added: [], updated: [event.user.connectionId], removed: [] },
+          "local"
+        ]);
+      }
+    });
+  }
+  destroy() {
+    this.emit("destroy", [this]);
+    this.othersUnsub();
+    this.setLocalState(null);
+    super.destroy();
+  }
+  getLocalState() {
+    const presence = this.room.getPresence();
+    if (Object.keys(this.room.getPresence()).length === 0) {
+      return null;
+    }
+    return presence["__yjs"];
+  }
+  setLocalState(state) {
+    const self = this.room.getSelf();
+    if (!self) {
+      return;
+    }
+    this.room.updatePresence({ __yjs: __spreadValues({}, state || {}) });
+  }
+  setLocalStateField(field, value) {
+    const update = { [field]: value };
+    this.room.updatePresence({ __yjs: update });
+  }
+  // Translate
+  getStates() {
+    const others = this.room.getOthers();
+    const states = others.reduce((acc, currentValue) => {
+      if (currentValue.connectionId) {
+        acc.set(currentValue.connectionId, currentValue.presence["__yjs"]);
+      }
+      return acc;
+    }, /* @__PURE__ */ new Map());
+    return states;
+  }
+};
+var LiveblocksProvider = class {
+  constructor(room, doc, config) {
+    this.lastUpdateDate = null;
+    this.unsubscribers = [];
+    this.updateHandler = (update, origin) => __async(this, null, function* () {
+      if (origin !== "backend") {
+        const encodedUpdate = Base64.fromUint8Array(update);
+        this.room.updateDoc(encodedUpdate);
+        if (this.httpEndpoint) {
+          yield fetch(this.httpEndpoint, {
+            method: "POST",
+            body: encodedUpdate
+          });
+        }
+      }
+    });
+    var _a;
+    this.doc = doc;
+    this.room = room;
+    const connectionId = (_a = this.room.getSelf()) == null ? void 0 : _a.connectionId;
+    if (connectionId) {
+      this.doc.clientID = connectionId;
+    }
+    this.awareness = new Awareness(this.doc, this.room);
+    this.doc.on("update", this.updateHandler);
+    this.unsubscribers.push(
+      this.room.events.connection.subscribe((e) => {
+        var _a2;
+        if (e === "open") {
+          this.doc.clientID = ((_a2 = this.room.getSelf()) == null ? void 0 : _a2.connectionId) || this.doc.clientID;
+          this.awareness.clientID = this.doc.clientID;
+          const encodedVector = Base64.fromUint8Array(
+            Y.encodeStateVector(this.doc)
+          );
+          this.room.getDoc(encodedVector);
+        }
+      })
+    );
+    this.unsubscribers.push(
+      this.room.events.docUpdated.subscribe((updates) => {
+        const decodedUpdates = updates.map(Base64.toUint8Array);
+        const update = Y.mergeUpdates(decodedUpdates);
+        Y.applyUpdate(this.doc, update, "backend");
+      })
+    );
+    if (config == null ? void 0 : config.httpEndpoint) {
+      this.httpEndpoint = config.httpEndpoint + "?room=" + this.room.id;
+      this.unsubscribers.push(
+        this.room.events.customEvent.subscribe(({ event }) => {
+          if ((event == null ? void 0 : event.type) === "REFRESH") {
+            void this.resyncHttp();
+          }
+        })
+      );
+      void this.resyncHttp();
+    }
+    this.room.getDoc();
+  }
+  resyncHttp() {
+    return __async(this, null, function* () {
+      if (!this.httpEndpoint) {
+        return;
+      }
+      const response = yield fetch(
+        `${this.httpEndpoint}${this.lastUpdateDate !== null ? `&after=${this.lastUpdateDate.toISOString()}` : ""}`
+      );
+      const { updates, lastUpdate } = yield response.json();
+      if (updates.length === 0) {
+        return;
+      }
+      this.lastUpdateDate = new Date(lastUpdate);
+      const update = Y.mergeUpdates(updates.map(Base64.toUint8Array));
+      Y.applyUpdate(this.doc, update, "backend");
+    });
+  }
+  destroy() {
+    this.doc.off("update", this.updateHandler);
+    this.unsubscribers.forEach((unsub) => unsub());
+    this.awareness.destroy();
+  }
+};
+export {
+  Awareness,
+  LiveblocksProvider as default
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liveblocks/yjs",
-  "version": "1.0.12-yjs1",
+  "version": "1.0.12-yjs2",
   "description": "An integration with . Liveblocks is the all-in-one toolkit to build collaborative products like Figma, Notion, and more.",
   "license": "Apache-2.0",
   "main": "./dist/index.js",
@@ -19,8 +19,8 @@
     "test:watch": "jest --silent --verbose --color=always --watch"
   },
   "dependencies": {
-    "@liveblocks/client": "1.0.12-yjs1",
-    "@liveblocks/core": "1.0.12-yjs1",
+    "@liveblocks/client": "1.0.12-yjs2",
+    "@liveblocks/core": "1.0.12-yjs2",
     "js-base64": "^3.7.5"
   },
   "peerDependencies": {