websocket-text-relay 1.1.2 → 1.1.3

package/.prettierignore

@@ -0,0 +1,3 @@
+# Ignore artifacts:
+build
+coverage

package/.prettierrc

@@ -0,0 +1,4 @@
+{
+  "semi": false,
+  "printWidth": 110
+}

package/changelog.md

@@ -1,3 +1,10 @@
+## 1.1.3 - 2025/08/13
+
+This change consisted entirely of updating dependencies and cleaning up code. There should be no user facing changes with this version.
+
+- Updated dependencies to remove all npm audit warnings
+- Added prettier for code formatting
+
 ## 1.1.0 - 2024/04/07
 
 Increased default security.

package/docs/code-structure.md

@@ -21,7 +21,7 @@ This is all abstracted away behind the websocket-interface, which is explained i
 
 ## Core Logic: The lsp and websocket events
 
-LSP: `initailze` / WS: `init`
+LSP: `initialize` / WS: `init`
 
 Whenever a new editor instance or front end client connects to the websocket, a websocket session is created for that client. These
 can be seen as the labeled blue wedges around the ring in the status UI. When the lsp client from the editor sends an

package/eslint.config.js

@@ -0,0 +1,28 @@
+import js from "@eslint/js"
+import globals from "globals"
+import { defineConfig } from "eslint/config"
+
+export default defineConfig([
+  {
+    files: ["**/*.{js,mjs,cjs}"],
+    plugins: { js },
+    extends: ["js/recommended"],
+    languageOptions: { globals: { ...globals.node, ...globals.browser } },
+  },
+  {
+    rules: {
+      semi: ["error", "never"],
+      indent: ["error", 2],
+      "no-multiple-empty-lines": ["error", { max: 1 }],
+      "no-unused-vars": 1,
+      "no-return-assign": 0,
+      "multiline-ternary": 0,
+      "object-curly-spacing": 0,
+      "object-property-newline": 0,
+      "object-curly-newline": 0,
+      quotes: 0,
+      "quote-props": 0,
+      "import/no-absolute-path": 0,
+    },
+  },
+])

package/package.json

@@ -1,17 +1,19 @@
 {
   "name": "websocket-text-relay",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "An LSP server for sending live file updates from your text editor to the front end via websockets.",
   "bin": {
     "websocket-text-relay": "./start.js"
   },
   "scripts": {
-    "lint": "eslint .",
-    "test": "vitest run --coverage",
-    "test-ui": "vitest --ui"
+    "format": "prettier src --write",
+    "lint": "eslint src",
+    "lint:fix": "eslint src --fix",
+    "test": "npm run lint && vitest run --coverage",
+    "test:ui": "vitest --ui"
   },
   "type": "module",
-  "main": "index.js",
+  "main": "./src/index.js",
   "directories": {
     "doc": "docs"
   },
@@ -34,12 +36,15 @@
   },
   "homepage": "https://github.com/niels4/websocket-text-relay#readme",
   "devDependencies": {
-    "@vitest/coverage-v8": "^1.4.0",
-    "@vitest/ui": "^1.4.0",
-    "eslint": "^8.57.0",
-    "vitest": "^1.4.0"
+    "@eslint/js": "^9.33.0",
+    "@vitest/coverage-v8": "^3.2.4",
+    "@vitest/ui": "^3.2.4",
+    "eslint": "^9.33.0",
+    "globals": "^16.3.0",
+    "prettier": "3.6.2",
+    "vitest": "^3.2.4"
   },
   "dependencies": {
-    "ws": "^8.16.0"
+    "ws": "^8.18.3"
   }
 }

package/{index.js → src/index.js}

@@ -4,44 +4,46 @@ import { WebsocketInterface } from "./src/websocket-interface/WebsocketInterface
 const DEFAULT_WS_PORT = 38378
 
 const resolvePort = (portParam) => {
-  if (portParam != null) { return portParam }
-  if (process.env["websocket_text_relay_port"] != null) { return process.env["websocket_text_relay_port"] }
+  if (portParam != null) {
+    return portParam
+  }
+  if (process.env["websocket_text_relay_port"] != null) {
+    return process.env["websocket_text_relay_port"]
+  }
   return DEFAULT_WS_PORT
 }
 
-const resolveIoStreams = ({inputStreamParam, outputStreamParam}) => {
-  const inputStream = inputStreamParam || process.stdin
-  const outputStream = outputStreamParam || process.stdout
-  return {inputStream, outputStream}
-}
-
 const fileProtocolPrefix = "file://"
 
 const getNormalizedFileName = (uri) => {
-  if (uri.startsWith(fileProtocolPrefix)) { return uri.substring(fileProtocolPrefix.length) }
+  if (uri.startsWith(fileProtocolPrefix)) {
+    return uri.substring(fileProtocolPrefix.length)
+  }
   return uri
 }
 
 const lspInitializeResponse = {
   serverInfo: {
     name: "Websocket Text Relay LSP Server",
-    version: "1.0.0"
+    version: "1.0.0",
   },
   capabilities: {
-    textDocumentSync: 1 // full text sync
-  }
+    textDocumentSync: 1, // full text sync
+  },
 }
 
 export const startLanguageServer = (options = {}) => {
-  const {inputStream: inputStreamParam, outputStream: outputStreamParam, port: portParam} = options
+  const { inputStream: inputStreamParam, outputStream: outputStreamParam, port: portParam } = options
+  const outputStream = outputStreamParam || process.stdout
+  const inputStream = inputStreamParam || process.stdin
 
-  const jsonRpc = new JsonRpcInterface(resolveIoStreams({inputStreamParam, outputStreamParam}))
+  const jsonRpc = new JsonRpcInterface({ inputStream, outputStream })
 
-  const wsInterface = new WebsocketInterface({port: resolvePort(portParam)})
+  const wsInterface = new WebsocketInterface({ port: resolvePort(portParam) })
 
-  wsInterface.emitter.on('message', (message) => {
+  wsInterface.emitter.on("message", (message) => {
     if (message.method === "watch-editor-active-files") {
-      jsonRpc.sendNotification("wtr/update-active-files", {files: message.files})
+      jsonRpc.sendNotification("wtr/update-active-files", { files: message.files })
     }
   })
 
@@ -50,7 +52,7 @@ export const startLanguageServer = (options = {}) => {
       method: "init",
       name: params.clientInfo?.name || "Unnamed Editor",
       editorPid: params.processId,
-      lsPid: process.pid
+      lsPid: process.pid,
     }
 
     const initOptions = params.initializationOptions || {}
@@ -74,19 +76,19 @@ export const startLanguageServer = (options = {}) => {
     process.exit(0)
   })
 
-  jsonRpc.onNotification('wtr/update-open-files', ({files}) => {
+  jsonRpc.onNotification("wtr/update-open-files", ({ files }) => {
     wsInterface.sendOpenFileList(files)
   })
 
   jsonRpc.onNotification("textDocument/didOpen", (params) => {
     const file = getNormalizedFileName(params.textDocument.uri)
     const contents = params.textDocument.text
-    wsInterface.sendText({file, contents})
+    wsInterface.sendText({ file, contents })
   })
 
   jsonRpc.onNotification("textDocument/didChange", (params) => {
     const file = getNormalizedFileName(params.textDocument.uri)
     const contents = params.contentChanges[0]?.text
-    wsInterface.sendText({file, contents})
+    wsInterface.sendText({ file, contents })
   })
 }

package/src/language-server/JsonRpcInterface.js

@@ -1,11 +1,19 @@
-import { EventEmitter } from 'node:events'
+import { EventEmitter } from "node:events"
 import { LspReader } from "./LspReader.js"
-import { writeNotification, writeRequest, writeResponse } from './LspWriter.js'
-import { invalidRequestErrorCode, invalidRequestErrorMessage, methodNotFoundErrorCode, methodNotFoundErrorMessage, unexpectedNotificationErrorCode,
-  unexpectedNotificationErrorMessage, unexpectedRequestErrorCode, unexpectedRequestErrorMessage } from './constants.js'
+import { writeNotification, writeRequest, writeResponse } from "./LspWriter.js"
+import {
+  invalidRequestErrorCode,
+  invalidRequestErrorMessage,
+  methodNotFoundErrorCode,
+  methodNotFoundErrorMessage,
+  unexpectedNotificationErrorCode,
+  unexpectedNotificationErrorMessage,
+  unexpectedRequestErrorCode,
+  unexpectedRequestErrorMessage,
+} from "./constants.js"
 
 export class JsonRpcInterface {
-  constructor ({inputStream, outputStream}) {
+  constructor({ inputStream, outputStream }) {
     this.inputStream = inputStream
     this.outputStream = outputStream
 
@@ -16,40 +24,44 @@ export class JsonRpcInterface {
     this.lspInputStream = new LspReader()
     this.inputStream.pipe(this.lspInputStream)
 
-    this.lspInputStream.on('data', this._handleIncomingLspMessage.bind(this))
+    this.lspInputStream.on("data", this._handleIncomingLspMessage.bind(this))
 
-    this.lspInputStream.on('parse-error', (error) => {
+    this.lspInputStream.on("parse-error", (error) => {
       writeResponse(this.outputStream, null, error)
     })
   }
 
-  onNotification (method, handler) {
+  onNotification(method, handler) {
     if (this.notificationHandlers.has(method)) {
-      throw new Error("Can only register one notification handler at a time. Duplicate method handlers for " + method)
+      throw new Error(
+        "Can only register one notification handler at a time. Duplicate method handlers for " + method,
+      )
     }
     this.notificationHandlers.set(method, handler)
   }
 
-  removeNotificationHandler (method) {
+  removeNotificationHandler(method) {
     return this.notificationHandlers.delete(method)
   }
 
-  onRequest (method, handler) {
+  onRequest(method, handler) {
     if (this.requestHandlers.has(method)) {
-      throw new Error("Can only register one request handler at a time. Duplicate method handlers for " + method)
+      throw new Error(
+        "Can only register one request handler at a time. Duplicate method handlers for " + method,
+      )
     }
     this.requestHandlers.set(method, handler)
   }
 
-  removeRequestHandler (method) {
+  removeRequestHandler(method) {
     return this.requestHandlers.delete(method)
   }
 
-  sendNotification (method, params) {
+  sendNotification(method, params) {
     writeNotification(this.outputStream, method, params)
   }
 
-  sendRequest (method, params) {
+  sendRequest(method, params) {
     const responseHandler = {}
     const promise = new Promise((resolve, reject) => {
       responseHandler.resolve = resolve
@@ -60,8 +72,8 @@ export class JsonRpcInterface {
     return promise
   }
 
-  _handleIncomingLspMessage (message) {
-    const {method, params, id, error, result} = message
+  _handleIncomingLspMessage(message) {
+    const { method, params, id, error, result } = message
     if (id != null) {
       if (method != null) {
         this._handleIncomingRequest(method, params, id)
@@ -75,47 +87,65 @@ export class JsonRpcInterface {
       this._handleIncomingNotification(method, params)
       return
     }
-    const rpcError = {code: invalidRequestErrorCode, message: invalidRequestErrorMessage}
-    this.events.emit('rpc-error', rpcError)
+    const rpcError = { code: invalidRequestErrorCode, message: invalidRequestErrorMessage }
+    this.events.emit("rpc-error", rpcError)
     writeResponse(this.outputStream, null, rpcError)
   }
 
-  _handleIncomingNotification (method, params) {
+  _handleIncomingNotification(method, params) {
     const handler = this.notificationHandlers.get(method)
     if (!handler) {
-      const errorObject = {code: methodNotFoundErrorCode, message: methodNotFoundErrorMessage, data: {method}}
+      const errorObject = {
+        code: methodNotFoundErrorCode,
+        message: methodNotFoundErrorMessage,
+        data: { method },
+      }
       this.events.emit("notification-error", errorObject)
       return
     }
     try {
       handler(params)
     } catch (error) {
-      const errorObject = {code: unexpectedNotificationErrorCode, message: unexpectedNotificationErrorMessage, data: {method, params, error: error.message}}
+      const errorObject = {
+        code: unexpectedNotificationErrorCode,
+        message: unexpectedNotificationErrorMessage,
+        data: { method, params, error: error.message },
+      }
       this.events.emit("notification-error", errorObject)
     }
   }
 
-  async _handleIncomingRequest (method, params, id) {
+  async _handleIncomingRequest(method, params, id) {
     const handler = this.requestHandlers.get(method)
     if (!handler) {
-      const errorObject = {code: methodNotFoundErrorCode, message: methodNotFoundErrorMessage, data: {method}}
+      const errorObject = {
+        code: methodNotFoundErrorCode,
+        message: methodNotFoundErrorMessage,
+        data: { method },
+      }
       writeResponse(this.outputStream, id, errorObject)
-      this.events.emit("request-error", {id, error: errorObject})
+      this.events.emit("request-error", { id, error: errorObject })
       return
     }
     try {
       const result = await handler(params)
       writeResponse(this.outputStream, id, null, result)
     } catch (error) {
-      const errorObject = {code: unexpectedRequestErrorCode, message: unexpectedRequestErrorMessage, data: {method, params, error: error.message}}
-      this.events.emit("request-error", {id, error: errorObject})
+      const errorObject = {
+        code: unexpectedRequestErrorCode,
+        message: unexpectedRequestErrorMessage,
+        data: { method, params, error: error.message },
+      }
+      this.events.emit("request-error", { id, error: errorObject })
       writeResponse(this.outputStream, id, errorObject)
     }
   }
 
-  _handleRequestResponse (id, error, result) {
+  _handleRequestResponse(id, error, result) {
     const responseHandler = this.outstandingRequests.get(id)
-    if (!responseHandler) { return }
+    if (!responseHandler) {
+      return
+    }
     this.outstandingRequests.delete(id)
     if (error != null) {
       responseHandler.reject(error)