@hocuspocus/provider 2.9.0 → 2.9.2-rc.0

package/dist/hocuspocus-provider.cjs

@@ -2798,16 +2798,40 @@ class HocuspocusProvider extends EventEmitter {
     }
 }
 
+/* eslint-env browser */
+const getRandomValues = crypto.getRandomValues.bind(crypto);
+
+/**
+ * Isomorphic module for true random numbers / buffers / uuids.
+ *
+ * Attention: falls back to Math.random if the browser does not support crypto.
+ *
+ * @module random
+ */
+
+const uint32 = () => getRandomValues(new Uint32Array(1))[0];
+
+// @ts-ignore
+const uuidv4Template = [1e7] + -1e3 + -4e3 + -8e3 + -1e11;
+
+/**
+ * @return {string}
+ */
+const uuidv4 = () => uuidv4Template.replace(/[018]/g, /** @param {number} c */ c =>
+  (c ^ uint32() & 15 >> c / 4).toString(16)
+);
+
 class TiptapCollabProviderWebsocket extends HocuspocusProviderWebsocket {
     constructor(configuration) {
-        super({ ...configuration, url: `wss://${configuration.appId}.collab.tiptap.cloud` });
+        var _a;
+        super({ ...configuration, url: (_a = configuration.baseUrl) !== null && _a !== void 0 ? _a : `wss://${configuration.appId}.collab.tiptap.cloud` });
     }
 }
 
 class TiptapCollabProvider extends HocuspocusProvider {
     constructor(configuration) {
         if (!configuration.websocketProvider) {
-            configuration.websocketProvider = new TiptapCollabProviderWebsocket({ appId: configuration.appId });
+            configuration.websocketProvider = new TiptapCollabProviderWebsocket({ appId: configuration.appId, baseUrl: configuration.baseUrl });
         }
         if (!configuration.token) {
             configuration.token = 'notoken'; // need to send a token anyway (which will be ignored)
@@ -2856,6 +2880,132 @@ class TiptapCollabProvider extends HocuspocusProvider {
     disableAutoVersioning() {
         return this.configuration.document.getMap(`${this.tiptapCollabConfigurationPrefix}config`).set('autoVersioning', 0);
     }
+    getYThreads() {
+        return this.configuration.document.getArray(`${this.tiptapCollabConfigurationPrefix}threads`);
+    }
+    getThreads() {
+        return this.getYThreads().toJSON();
+    }
+    getThreadIndex(id) {
+        let index = null;
+        let i = 0;
+        // eslint-disable-next-line no-restricted-syntax
+        for (const thread of this.getThreads()) {
+            if (thread.id === id) {
+                index = i;
+                break;
+            }
+            i += 1;
+        }
+        return index;
+    }
+    getThread(id) {
+        const index = this.getThreadIndex(id);
+        if (index === null) {
+            return null;
+        }
+        return this.getYThreads().get(index).toJSON();
+    }
+    getYThread(id) {
+        const index = this.getThreadIndex(id);
+        if (index === null) {
+            return null;
+        }
+        return this.getYThreads().get(index);
+    }
+    createThread(data) {
+        const thread = new Y__namespace.Map();
+        thread.set('id', uuidv4());
+        thread.set('createdAt', (new Date()).toISOString());
+        thread.set('comments', new Y__namespace.Array());
+        this.getYThreads().push([thread]);
+        return this.updateThread(String(thread.get('id')), data);
+    }
+    updateThread(id, data) {
+        const thread = this.getYThread(id);
+        if (thread === null) {
+            return null;
+        }
+        thread.set('updatedAt', (new Date()).toISOString());
+        thread.set('data', data.data);
+        return thread.toJSON();
+    }
+    deleteThread(id) {
+        const index = this.getThreadIndex(id);
+        if (index === null) {
+            return;
+        }
+        this.getYThreads().delete(index, 1);
+    }
+    getThreadComments(threadId) {
+        var _a, _b;
+        const index = this.getThreadIndex(threadId);
+        if (index === null) {
+            return null;
+        }
+        return (_b = (_a = this.getThread(threadId)) === null || _a === void 0 ? void 0 : _a.comments) !== null && _b !== void 0 ? _b : [];
+    }
+    getThreadComment(threadId, commentId) {
+        var _a, _b;
+        const index = this.getThreadIndex(threadId);
+        if (index === null) {
+            return null;
+        }
+        return (_b = (_a = this.getThread(threadId)) === null || _a === void 0 ? void 0 : _a.comments.find(comment => comment.id === commentId)) !== null && _b !== void 0 ? _b : null;
+    }
+    addComment(threadId, data) {
+        const thread = this.getYThread(threadId);
+        if (thread === null)
+            return null;
+        const commentMap = new Y__namespace.Map();
+        commentMap.set('id', uuidv4());
+        commentMap.set('createdAt', (new Date()).toISOString());
+        thread.get('comments').push([commentMap]);
+        this.updateComment(threadId, String(commentMap.get('id')), data);
+        return thread.toJSON();
+    }
+    updateComment(threadId, commentId, data) {
+        const thread = this.getYThread(threadId);
+        if (thread === null)
+            return null;
+        let comment = null;
+        // eslint-disable-next-line no-restricted-syntax
+        for (const c of thread.get('comments')) {
+            if (c.get('id') === commentId) {
+                comment = c;
+                break;
+            }
+        }
+        if (comment === null)
+            return null;
+        comment.set('updatedAt', (new Date()).toISOString());
+        comment.set('data', data.data);
+        comment.set('content', data.content);
+        return thread.toJSON();
+    }
+    deleteComment(threadId, commentId) {
+        const thread = this.getYThread(threadId);
+        if (thread === null)
+            return null;
+        let commentIndex = 0;
+        // eslint-disable-next-line no-restricted-syntax
+        for (const c of thread.get('comments')) {
+            if (c.get('id') === commentId) {
+                break;
+            }
+            commentIndex += 1;
+        }
+        if (commentIndex >= 0) {
+            thread.get('comments').delete(commentIndex);
+        }
+        return thread.toJSON();
+    }
+    watchThreads(callback) {
+        this.getYThreads().observeDeep(callback);
+    }
+    unwatchThreads(callback) {
+        this.getYThreads().unobserveDeep(callback);
+    }
 }
 
 exports.AwarenessError = AwarenessError;