@kerebron/extension-server-hono 0.3.1

package/LICENSE

@@ -0,0 +1,23 @@
+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.

package/README.md

@@ -0,0 +1,63 @@
+# Kerebron - Prosemirror based online editor kit
+
+## Watch a Demo
+
+<a href="https://youtube.com/shorts/OdJjhAPj-wA?feature=share" target="_blank">
+  <img src="https://github.com/user-attachments/assets/b63ec84a-0ed2-4f98-920c-76f6d3215168" alt="Alt Text" width="200">
+</a>
+
+## Playground Demo
+
+[playground](https://editor-test.gitgis.com) - be nice.
+
+## Overview
+
+Using vanilla Prosemirror modules is often impossible because of
+incompatibilities.
+
+Kerebron forks several prosemirror projects into one monorepo in order to keep
+them in sync.
+
+Project is inspired on https://tiptap.dev/, but instead of building wrapper
+around a wrapper it borrows concept of extension and command manager.
+
+It has simplified tooling (deno), fewer dependencies and resulting in lower
+number of output npm modules.
+
+**Work in progress**
+
+## Development
+
+To start example server:
+
+```
+deno task -f example-server-hono start
+```
+
+## Build
+
+### Build static examples
+
+```shell
+deno task -r build
+```
+
+### NPM packages are generated using DNT
+
+- https://deno.com/blog/publish-esm-cjs-module-dnt - the easiest way to publish
+  a hybrid npm module for ESM and CommonJS
+- https://github.com/denoland/dnt
+- https://gaubee.com/article/Publishing-Your-Deno-Project-as-a-Monorepo-using-dnt/
+
+To generate npm packages
+
+```shell
+deno -A ./build/build_npm.ts
+```
+
+## Run through docker
+
+```
+docker build . -t editor-test
+docker run -it -p 8000:8000 -v $PWD:/usr/src/app editor-test
+```

package/esm/HonoYjsMemAdapter.d.ts

@@ -0,0 +1,41 @@
+import { WSEvents } from 'hono/ws';
+import * as Y from 'yjs';
+import * as awarenessProtocol from 'y-protocols/awareness';
+import { HonoWsAdapter } from './mod.js';
+export declare const messageType: {
+    sync: number;
+    awareness: number;
+};
+export declare const docs: Map<string, Y.Doc>;
+/**
+ * Gets a Y.Doc by name, whether in memory or on disk
+ *
+ * @param {string} docname - the name of the Y.Doc to find or create
+ * @param {boolean} gc - whether to allow gc on the doc (applies only when created)
+ * @return {WSSharedDoc}
+ */
+export declare const getYDoc: (docname: string, gc?: boolean) => Y.Doc;
+export declare class SocketContext {
+    readonly room: Room;
+    readonly socket: WebSocket;
+    readonly controlledIds: Set<number>;
+    constructor(room: Room, socket: WebSocket);
+}
+export declare class Room {
+    readonly roomName: string;
+    readonly doc: Y.Doc;
+    readonly socketContexts: Map<WebSocket, SocketContext>;
+    awareness: awarenessProtocol.Awareness;
+    constructor(roomName: string, doc: Y.Doc);
+}
+export declare class HonoYjsMemAdapter implements HonoWsAdapter {
+    #private;
+    readonly sockets: Map<WebSocket, SocketContext>;
+    readonly rooms: Map<string, Room>;
+    constructor();
+    getRoomNames(): Promise<string[]>;
+    upgradeWebSocket(roomName: string): WSEvents<WebSocket>;
+    send(conn: WebSocket, m: Uint8Array): void;
+    receiveMessage(messageBytes: Uint8Array, conn: WebSocket): void;
+}
+//# sourceMappingURL=HonoYjsMemAdapter.d.ts.map

package/esm/HonoYjsMemAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HonoYjsMemAdapter.d.ts","sourceRoot":"","sources":["../src/HonoYjsMemAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,QAAQ,EAAE,MAAM,SAAS,CAAC;AAE9C,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,OAAO,KAAK,iBAAiB,MAAM,uBAAuB,CAAC;AAI3D,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,eAAO,MAAM,WAAW;;;CAGvB,CAAC;AAEF,eAAO,MAAM,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,CAAa,CAAC;AAIlD;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,GAAI,SAAS,MAAM,EAAE,YAAS,KAAG,CAAC,CAAC,GAWtD,CAAC;AAEF,qBAAa,aAAa;aAGI,IAAI,EAAE,IAAI;aAAkB,MAAM,EAAE,SAAS;IAFzE,SAAgB,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,CAAa;gBAE3B,IAAI,EAAE,IAAI,EAAkB,MAAM,EAAE,SAAS;CAE1E;AAED,qBAAa,IAAI;aAIa,QAAQ,EAAE,MAAM;aAAkB,GAAG,EAAE,CAAC,CAAC,GAAG;IAHxE,SAAgB,cAAc,EAAE,GAAG,CAAC,SAAS,EAAE,aAAa,CAAC,CAAa;IAC1E,SAAS,EAAE,iBAAiB,CAAC,SAAS,CAAC;gBAEX,QAAQ,EAAE,MAAM,EAAkB,GAAG,EAAE,CAAC,CAAC,GAAG;CAuDzE;AAID,qBAAa,iBAAkB,YAAW,aAAa;;IACrD,QAAQ,CAAC,OAAO,EAAE,GAAG,CAAC,SAAS,EAAE,aAAa,CAAC,CAAa;IAC5D,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;;IAM5B,YAAY;IAIlB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAAC,SAAS,CAAC;IA0DvD,IAAI,CAAC,IAAI,EAAE,SAAS,EAAE,CAAC,EAAE,UAAU;IAUnC,cAAc,CAAC,YAAY,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS;CA+DzD"}

package/esm/HonoYjsMemAdapter.js

@@ -0,0 +1,241 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _HonoYjsMemAdapter_instances, _HonoYjsMemAdapter_terminate, _HonoYjsMemAdapter_removeSocket;
+import * as Y from 'yjs';
+import * as syncProtocol from 'y-protocols/sync';
+import * as awarenessProtocol from 'y-protocols/awareness';
+import * as encoding from 'lib0/encoding';
+import * as decoding from 'lib0/decoding';
+export const messageType = {
+    sync: 0,
+    awareness: 1,
+};
+export const docs = new Map();
+const gcEnabled = false;
+/**
+ * Gets a Y.Doc by name, whether in memory or on disk
+ *
+ * @param {string} docname - the name of the Y.Doc to find or create
+ * @param {boolean} gc - whether to allow gc on the doc (applies only when created)
+ * @return {WSSharedDoc}
+ */
+export const getYDoc = (docname, gc = true) => {
+    if (docs.has(docname)) {
+        return docs.get(docname);
+    }
+    const doc = new Y.Doc({ gc: gcEnabled });
+    doc.gc = gc;
+    // if (persistence !== null) {
+    //   persistence.bindState(docname, doc)
+    // }
+    docs.set(docname, doc);
+    return doc;
+};
+export class SocketContext {
+    constructor(room, socket) {
+        Object.defineProperty(this, "room", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: room
+        });
+        Object.defineProperty(this, "socket", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: socket
+        });
+        Object.defineProperty(this, "controlledIds", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+    }
+}
+export class Room {
+    constructor(roomName, doc) {
+        Object.defineProperty(this, "roomName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: roomName
+        });
+        Object.defineProperty(this, "doc", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: doc
+        });
+        Object.defineProperty(this, "socketContexts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "awareness", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.awareness = new awarenessProtocol.Awareness(doc);
+        this.awareness.setLocalState(null);
+        this.awareness.on('update', ({ added, updated, removed }, conn) => {
+            const changedClients = added.concat(updated, removed);
+            if (conn !== null) {
+                const socketContext = this.socketContexts.get(conn);
+                if (socketContext) {
+                    added.forEach((clientID) => {
+                        socketContext.controlledIds.add(clientID);
+                    });
+                    removed.forEach((clientID) => {
+                        socketContext.controlledIds.delete(clientID);
+                    });
+                }
+            }
+            // broadcast awareness update
+            const encoder = encoding.createEncoder();
+            encoding.writeVarUint(encoder, messageType.awareness);
+            encoding.writeVarUint8Array(encoder, awarenessProtocol.encodeAwarenessUpdate(this.awareness, changedClients));
+            const buff = encoding.toUint8Array(encoder);
+            for (const socket of this.socketContexts.keys()) {
+                socket.send(buff);
+            }
+        });
+        doc.on('update', (update) => {
+            const encoder = encoding.createEncoder();
+            encoding.writeVarUint(encoder, messageType.sync);
+            syncProtocol.writeUpdate(encoder, update);
+            const message = encoding.toUint8Array(encoder);
+            for (const socket of this.socketContexts.keys()) {
+                socket.send(message);
+            }
+        });
+    }
+}
+const rooms = new Map();
+export class HonoYjsMemAdapter {
+    constructor() {
+        _HonoYjsMemAdapter_instances.add(this);
+        Object.defineProperty(this, "sockets", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "rooms", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.rooms = rooms;
+    }
+    async getRoomNames() {
+        return Array.from(rooms.keys());
+    }
+    upgradeWebSocket(roomName) {
+        const doc = getYDoc(roomName, gcEnabled);
+        return {
+            onOpen: (evt, wsContext) => {
+                if (!wsContext.raw) {
+                    return;
+                }
+                if (!this.rooms.has(roomName)) {
+                    this.rooms.set(roomName, new Room(roomName, doc));
+                }
+                const room = this.rooms.get(roomName);
+                const socketContext = new SocketContext(room, wsContext.raw);
+                this.sockets.set(wsContext.raw, socketContext);
+                room.socketContexts.set(wsContext.raw, socketContext);
+                const encoder = encoding.createEncoder();
+                encoding.writeVarUint(encoder, messageType.sync);
+                syncProtocol.writeSyncStep1(encoder, doc);
+                this.send(wsContext.raw, encoding.toUint8Array(encoder));
+                const awarenessStates = room.awareness.getStates();
+                if (awarenessStates.size > 0) {
+                    const encoder = encoding.createEncoder();
+                    encoding.writeVarUint(encoder, messageType.awareness);
+                    encoding.writeVarUint8Array(encoder, awarenessProtocol.encodeAwarenessUpdate(room.awareness, Array.from(awarenessStates.keys())));
+                    this.send(wsContext.raw, encoding.toUint8Array(encoder));
+                }
+                // this.#forceReady();
+            },
+            onError: (error, wsContext) => {
+                console.error('onError', error);
+            },
+            onMessage: (message, wsContext) => {
+                if (!wsContext.raw) {
+                    return;
+                }
+                this.receiveMessage(new Uint8Array(message.data), wsContext.raw);
+            },
+            onClose: (event, wsContext) => {
+                if (!wsContext.raw) {
+                    return;
+                }
+                __classPrivateFieldGet(this, _HonoYjsMemAdapter_instances, "m", _HonoYjsMemAdapter_removeSocket).call(this, wsContext.raw);
+            },
+        };
+    }
+    send(conn, m) {
+        if (conn.readyState !== WebSocket.CONNECTING &&
+            conn.readyState !== WebSocket.OPEN) {
+            __classPrivateFieldGet(this, _HonoYjsMemAdapter_instances, "m", _HonoYjsMemAdapter_terminate).call(this, conn);
+        }
+        conn.send(m);
+    }
+    receiveMessage(messageBytes, conn) {
+        try {
+            const socketContext = this.sockets.get(conn);
+            if (!socketContext) {
+                return;
+            }
+            const room = socketContext.room;
+            const encoder = encoding.createEncoder();
+            const decoder = decoding.createDecoder(messageBytes);
+            const type = decoding.readVarUint(decoder);
+            switch (type) {
+                case messageType.sync:
+                    encoding.writeVarUint(encoder, messageType.sync);
+                    syncProtocol.readSyncMessage(decoder, encoder, room.doc, conn);
+                    // If the `encoder` only contains the type of reply message and no
+                    // message, there is no need to send the message. When `encoder` only
+                    // contains the type of reply, its length is 1.
+                    if (encoding.length(encoder) > 1) {
+                        this.send(conn, encoding.toUint8Array(encoder));
+                    }
+                    break;
+                case messageType.awareness: {
+                    awarenessProtocol.applyAwarenessUpdate(room.awareness, decoding.readVarUint8Array(decoder), conn);
+                    break;
+                }
+            }
+        }
+        catch (err) {
+            console.error(err);
+            // @ts-ignore
+            doc.emit('error', [err]);
+        }
+    }
+}
+_HonoYjsMemAdapter_instances = new WeakSet(), _HonoYjsMemAdapter_terminate = function _HonoYjsMemAdapter_terminate(socket) {
+    __classPrivateFieldGet(this, _HonoYjsMemAdapter_instances, "m", _HonoYjsMemAdapter_removeSocket).call(this, socket);
+    socket.close();
+}, _HonoYjsMemAdapter_removeSocket = function _HonoYjsMemAdapter_removeSocket(conn) {
+    const socketContext = this.sockets.get(conn);
+    if (socketContext) {
+        const room = socketContext.room;
+        room.socketContexts.delete(socketContext.socket);
+        awarenessProtocol.removeAwarenessStates(room.awareness, Array.from(socketContext.controlledIds), null);
+        if (room.socketContexts.size === 0) {
+            // TODO save to persistence
+            // TODO Destroy room
+        }
+        this.sockets.delete(conn);
+    }
+};

package/esm/mod.d.ts

@@ -0,0 +1,5 @@
+import { WSEvents } from 'hono/ws';
+export interface HonoWsAdapter {
+    upgradeWebSocket(roomName: string): WSEvents<WebSocket>;
+}
+//# sourceMappingURL=mod.d.ts.map

package/esm/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEnC,MAAM,WAAW,aAAa;IAC5B,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC;CACzD"}

package/esm/mod.js

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

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@kerebron/extension-server-hono",
+  "version": "0.3.1",
+  "license": "MIT",
+  "module": "./esm/mod.js",
+  "exports": {
+    ".": {
+      "import": "./esm/mod.js"
+    },
+    "./HonoYjsMemAdapter": {
+      "import": "./esm/HonoYjsMemAdapter.js"
+    }
+  },
+  "scripts": {},
+  "dependencies": {
+    "yjs": "13.6.24"
+  },
+  "devDependencies": {
+    "@types/node": "^20.9.0"
+  },
+  "_generatedBy": "dnt@dev"
+}