scoundrel-remote-eval 1.0.8 → 1.0.10

package/src/client/reference-proxy.js

@@ -1,53 +0,0 @@
-// @ts-check
-
-/**
- * @param {import("./reference.js").default} reference
- * @param {string} prop
- * @returns {(...args: any[]) => Promise<any>}
- */
-const proxyMethodSpawner = (reference, prop) => (...args) => reference.callMethodWithReference(prop, ...args)
-
-const proxyObjectHandler = {
-  /**
-   * @param {import("./reference.js").default|(() => import("./reference.js").default)} reference
-   * @param {string} prop
-   * @returns {any}
-   */
-  get(reference, prop) {
-    if (typeof reference == "function") reference = reference()
-
-    if (prop == "__serialize") {
-      const method = reference.serialize
-      const boundMethod = method.bind(reference)
-
-      return boundMethod
-    }
-
-    return proxyMethodSpawner(reference, prop)
-  },
-
-  /**
-   * @param {import("./reference.js").default|(() => import("./reference.js").default)} receiver
-   * @param {string} prop
-   * @param {any} newValue
-   */
-  set(receiver, prop, newValue) {
-    throw new Error("set property isn't supported yet")
-
-    // @ts-expect-error
-    if (typeof receiver == "function") receiver = receiver() // eslint-disable-line no-unreachable
-
-    // @ts-expect-error
-    if (!(prop in receiver)) throw new PropertyNotFoundError(`Property not found: ${prop}`) // eslint-disable-line no-undef
-
-    return Reflect.set(receiver, prop, newValue)
-  }
-}
-
-/**
- * @param {any} wrappedObject
- * @returns {Proxy}
- */
-const referenceProxy = (wrappedObject) => new Proxy(wrappedObject, proxyObjectHandler)
-
-export default referenceProxy

package/src/client/reference.js

@@ -1,69 +0,0 @@
-// @ts-check
-
-export default class Reference {
-  /**
-   * Creates a new Reference
-   *
-   * @param {any} client The client instance
-   * @param {string} id The reference ID
-   */
-  constructor(client, id) {
-    this.client = client
-    this.id = id
-
-    if (!id) throw new Error(`Invalid ID given: ${id}`)
-  }
-
-  /**
-   * Calls a method on the reference
-   *
-   * @param {string} methodName
-   * @param  {...any} args
-   * @returns {Promise<any>}
-   */
-  async callMethod(methodName, ...args) {
-    return await this.client.callMethodOnReference(this.id, methodName, ...args)
-  }
-
-  /**
-   * Calls a method on the reference using another reference as argument
-   *
-   * @param {string} methodName
-   * @param  {...any} args
-   * @returns {Promise<any>}
-   */
-  async callMethodWithReference(methodName, ...args) {
-    return await this.client.callMethodOnReferenceWithReference(this.id, methodName, ...args)
-  }
-
-  /**
-   * Reads an attribute from the reference
-   *
-   * @param {string} attributeName
-   * @param  {...any} args
-   * @returns {Promise<any>}
-   */
-  async readAttribute(attributeName, ...args) {
-    return await this.client.readAttributeOnReference(this.id, attributeName, ...args)
-  }
-
-  /**
-   * Reads an attribute from the reference using another reference as argument
-   *
-   * @param {string} attributeName
-   * @param  {...any} args
-   * @returns {Promise<any>}
-   */
-  async readAttributeWithReference(attributeName, ...args) {
-    return await this.client.readAttributeOnReferenceWithReference(this.id, attributeName, ...args)
-  }
-
-  /**
-   * Serializes the reference and returns the result directly
-   *
-   * @returns {Promise<any>}
-   */
-  async serialize() {
-    return await this.client.serializeReference(this.id)
-  }
-}

package/src/logger.js

@@ -1,70 +0,0 @@
-// @ts-check
-
-export default class Logger {
-  /**
-   * Creates a new Logger instance
-   *
-   * @param {string} scopeName The name of the scope for the logger
-   */
-  constructor(scopeName) {
-    this.debug = false
-    this.scopeName = scopeName
-  }
-
-  /**
-   * Enables or disables debug logging
-   *
-   * @param {boolean} newValue
-   */
-  setDebug(newValue) {
-    this.debug = newValue
-  }
-
-  /**
-   * Logs an error message to the console if debug is enabled
-   *
-   * @param  {...any} args
-   */
-  error(...args) {
-    return this._sendToConsole("error", ...args)
-  }
-
-  /**
-   * Logs a message to the console if debug is enabled
-   * @param  {...any} args
-   */
-  log(...args) {
-    return this._sendToConsole("log", ...args)
-  }
-
-  /**
-   * Logs a warning message to the console if debug is enabled
-   * @param  {...any} args
-   */
-  warn(...args) {
-    return this._sendToConsole("warn", ...args)
-  }
-
-  /**
-   * Sends the log message to the console
-   * @param {string} logType
-   * @param  {...any} args
-   */
-  _sendToConsole(logType, ...args) {
-    if (!this.debug) {
-      return
-    }
-
-    if (args.length == 1 && typeof args[0] == "function") {
-      const callbackArgs = args[0]()
-
-      if (Array.isArray(callbackArgs)) {
-        console[logType](this.scopeName, ...callbackArgs)
-      } else {
-        console[logType](this.scopeName, callbackArgs)
-      }
-    } else {
-      console[logType](this.scopeName, ...args)
-    }
-  }
-}

package/src/python-web-socket-runner.js

@@ -1,116 +0,0 @@
-// @ts-check
-
-import {exec, spawn} from "child_process"
-import Logger from "./logger.js"
-import {realpath} from "fs/promises"
-
-const logger = new Logger("Scoundrel PythonWebSocketRunner")
-
-// logger.setDebug(true)
-
-export default class PythonWebSocketRunner {
-  /** @type {Error | null} */
-  waitForPidRejectError = null
-
-  /** @type {((value: any) => void) | null} */
-  waitForPidResolve = null
-
-  /** @type {((value: any) => void) | null} */
-  waitForPidReject = null
-
-  constructor() {
-    process.on("exit", this.onProcessExit)
-  }
-
-  runAndWaitForPid() {
-    return new Promise((resolve, reject) => {
-      this.waitForPidResolve = resolve
-      this.waitForPidReject = reject
-      this.run()
-    })
-  }
-
-  async run() {
-    const filePath = `${process.cwd()}/../python/server/web-socket.py`
-    const fileRealPath = await realpath(filePath)
-    const child = spawn("python3", [fileRealPath])
-
-    child.on("exit", this.onChildExit)
-    child.stdout.on("data", this.onChildStdout)
-    child.stderr.on("data", this.onChildStderr)
-  }
-
-  onProcessExit = () => {
-    if (this.pid) {
-      this.close()
-      logger.log(() => `onProcessExit: Killing Python process with PID ${this.pid}`)
-    }
-  }
-
-  /**
-   * @param {number} code
-   * @param {string} signal
-   */
-  onChildExit = (code, signal) => {
-    logger.log(() => `Child process exited with code ${code} and signal ${signal}`)
-
-    if (this.waitForPidRejectError) {
-      if (!this.waitForPidReject) {
-        throw new Error("waitForPidReject is undefined while waitForPidRejectError is set")
-      }
-
-      this.waitForPidReject(this.waitForPidRejectError)
-      this.waitForPidResolve = null
-      this.waitForPidReject = null
-      this.waitForPidRejectError = null
-    } else if (this.waitForPidReject) {
-      this.waitForPidReject(new Error(`Python process exited before PID was received (code: ${code}, signal: ${signal})`))
-      this.waitForPidResolve = null
-      this.waitForPidReject = null
-      this.waitForPidRejectError = null
-    }
-  }
-
-  /**
-   * @param {string | Buffer} data
-   */
-  onChildStderr = (data) => {
-    logger.error(() => `stderr: ${data}`)
-
-    if (this.waitForPidReject) {
-      this.waitForPidRejectError = new Error(`Python process stderr before PID was received: ${data}`)
-    }
-  }
-
-  /**
-   * @param {string | Buffer} data
-   */
-  onChildStdout = (data) => {
-    logger.log(() => `stdout: ${data}`)
-
-    const match = (`${data}`).match(/^Started with PID (\d+) on (.+):(.+)\n$/)
-
-    if (match) {
-      this.pid = match[1]
-
-      logger.log(() => `Registered PID ${this.pid}`)
-
-      if (this.waitForPidResolve) {
-        if (!this.waitForPidResolve) {
-          throw new Error("waitForPidResolve is undefined while waitForPidRejectError is set")
-        }
-
-        this.waitForPidResolve(null)
-        this.waitForPidResolve = null
-        this.waitForPidReject = null
-        this.waitForPidRejectError = null
-      }
-    }
-  }
-
-  close() {
-    if (this.pid) {
-      exec(`kill ${this.pid}`)
-    }
-  }
-}

package/src/server/connections/web-socket/client.js

@@ -1,46 +0,0 @@
-// @ts-check
-
-export default class WebSocketClient {
-  /**
-   * Creates a new WebSocketClient
-   * @param {import("ws").WebSocket} ws The WebSocket instance
-   */
-  constructor(ws) {
-    this.ws = ws
-
-    ws.on("error", this.onError)
-    ws.on("message", this.onMessage)
-  }
-
-  /**
-   * @param {(data: any) => void} callback
-   */
-  onCommand(callback) {
-    this.onCommandCallback = callback
-  }
-
-  /**
-   * @param {Error} error
-   */
-  onError = (error) => {
-    console.error("WebSocketClient error", error)
-  }
-
-  /**
-   * @param {string} rawData
-   */
-  onMessage = (rawData) => {
-    const data = JSON.parse(rawData)
-
-    if (!this.onCommandCallback) throw new Error("Command callback hasn't been set")
-
-    this.onCommandCallback(data)
-  }
-
-  /**
-   * @param {any} data
-   */
-  async send(data) {
-    await this.ws.send(JSON.stringify(data))
-  }
-}

package/src/server/connections/web-socket/index.js

@@ -1,34 +0,0 @@
-// @ts-check
-
-import WebSocketClient from "./client.js"
-
-export default class WebSocket {
-  /**
-   * Creates a new WebSocket connection handler
-   * @param {import("ws").Server} webSocketServer The WebSocket server instance
-   */
-  constructor(webSocketServer) {
-    this.wss = webSocketServer
-    this.wss.on("connection", this.onConnection)
-  }
-
-  close() { this.wss.close() }
-
-  /**
-   * @param {import("ws").WebSocket} ws
-   */
-  onConnection = (ws) => {
-    if (!this.onNewClientCallback) throw new Error("'onNewClient' hasn't been called")
-
-    this.onNewClientCallback(new WebSocketClient(ws))
-  }
-
-  /**
-   * @param {(client: import("./client.js").default) => void} callback
-   */
-  onNewClient(callback) {
-    if (!callback) throw new Error("No callback was given")
-
-    this.onNewClientCallback = callback
-  }
-}

package/src/server/index.js

@@ -1,33 +0,0 @@
-// @ts-check
-
-import Client from "../client/index.js"
-import EventEmitter from "events"
-
-export default class ScoundrelServer {
-  /**
-   * Creates a new Scoundrel server
-   * @param {import("./connections/web-socket/index.js").default} backend The backend connection handler
-   */
-  constructor(backend) {
-    this.backend = backend
-    this.backend.onNewClient(this.onNewClient)
-
-    /** @type {Client[]} */
-    this.clients = []
-
-    this.events = new EventEmitter()
-  }
-
-  close() { this.backend.close() }
-  getClients() { return this.clients }
-
-  /**
-   * @param {import("./connections/web-socket/client.js").default} clientBackend
-   */
-  onNewClient = (clientBackend) => {
-    const client = new Client(clientBackend)
-
-    this.clients.push(client)
-    this.events.emit("newClient", client)
-  }
-}

package/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "compilerOptions": {
-    "checkJs": true,
-    "noEmit": true,
-    "target": "ES2020",
-
-    "moduleResolution": "nodenext",
-    "module": "nodenext",
-
-    "lib": ["dom", "ES2020"],
-    "types": ["jasmine", "node"]
-  }
-}