@noita-ts/pollnet 0.3.7 → 0.4.0

package/dist/async.d.ts

@@ -1,3 +1,4 @@
+/** @noSelfInFile */
 import pollnet from ".";
 export declare namespace compat {
     /**
@@ -48,7 +49,6 @@ export declare class HttpResponse {
     headers: string;
     body: string;
     constructor(status: number, headers: string, body: string);
-    /** @noSelf */
     static read(socket: pollnet.Socket): HttpResponse;
     /**
      * Parse the raw header block into a map.
@@ -73,3 +73,20 @@ export declare class HttpClient {
      */
     post(url: string, headers?: Record<string, string | string[]> | string, body?: string): Promise<HttpResponse>;
 }
+/**
+ * Async WebSocket client built on top of an {@link AsyncReactor}.
+ * Messages are delivered via the `onmessage` callback, and errors via
+ * `onerror`.
+ * Call {@link send} to send a message, and {@link close} to close the
+ * connection and cleanup.
+ */
+export declare class WebSocket {
+    private socket;
+    timeout: number;
+    onmessage: ((msg: string) => void) | null;
+    onerror: ((msg: string) => void) | null;
+    constructor(reactor: AsyncReactor, url: string);
+    send(message: string): void;
+    send_binary(data: string): void;
+    close(): void;
+}

package/dist/async.lua

@@ -20,7 +20,7 @@ do
     --- Run `body` inside a reactor coroutine and get its completion as a Promise.
     -- `body` may freely use socket.await() / other yield-based pollnet APIs.
     -- Errors inside body reject the promise.
-    compat.asyncify = function(____, reactor, body)
+    compat.asyncify = function(reactor, body)
         return __TS__New(
             __TS__Promise,
             function(____, resolve, reject)
@@ -32,7 +32,7 @@ do
                         local ____try, ____hasReturned = pcall(function()
                             resolve(
                                 nil,
-                                body(nil)
+                                body()
                             )
                         end)
                         if not ____try then
@@ -46,7 +46,7 @@ do
     --- Parks the *current coroutine* until the promise settles, then returns its
     -- value or rethrows its rejection.
     -- Only call from inside a reactor coroutine (`reactor.run(() => { .. HERE .. })`).
-    compat.yieldPromise = function(____, p)
+    compat.yieldPromise = function(p)
         local done = false
         local ok = false
         local result
@@ -87,14 +87,14 @@ function AsyncReactor.prototype.poll(self)
     return self.reactor:update()
 end
 function AsyncReactor.prototype.spawn(self, body)
-    return ____exports.compat:asyncify(self.reactor, body)
+    return ____exports.compat.asyncify(self.reactor, body)
 end
 function AsyncReactor.prototype.runServer(self, server_sock, client_body)
     server_sock:on_connection(function(client_sock, addr)
         self.reactor:run(function()
-            local r = client_body(nil, client_sock, addr)
+            local r = client_body(client_sock, addr)
             if __TS__InstanceOf(r, __TS__Promise) then
-                ____exports.compat:yieldPromise(r)
+                ____exports.compat.yieldPromise(r)
             end
         end)
     end)
@@ -111,7 +111,7 @@ function HttpResponse.prototype.____constructor(self, status, headers, body)
     self.headers = headers
     self.body = body
 end
-function HttpResponse.read(socket)
+function HttpResponse.read(self, socket)
     local msgs, ____error = socket:await_n(3)
     if not msgs then
         error(
@@ -159,9 +159,91 @@ function HttpClient.prototype.____constructor(self, reactor)
     self.reactor = reactor
 end
 function HttpClient.prototype.get(self, url, headers)
-    return self.reactor:spawn(function() return ____exports.HttpResponse.read(pollnet.http_get(url, headers, false)) end)
+    return self.reactor:spawn(function() return ____exports.HttpResponse:read(pollnet.http_get(url, headers, false)) end)
 end
 function HttpClient.prototype.post(self, url, headers, body)
-    return self.reactor:spawn(function() return ____exports.HttpResponse.read(pollnet.http_post(url, headers, body, false)) end)
+    return self.reactor:spawn(function() return ____exports.HttpResponse:read(pollnet.http_post(url, headers, body, false)) end)
+end
+--- Async WebSocket client built on top of an {@link AsyncReactor}.
+-- Messages are delivered via the `onmessage` callback, and errors via
+-- `onerror`.
+-- Call {@link send} to send a message, and {@link close} to close the
+-- connection and cleanup.
+____exports.WebSocket = __TS__Class()
+local WebSocket = ____exports.WebSocket
+WebSocket.name = "WebSocket"
+function WebSocket.prototype.____constructor(self, reactor, url)
+    self.timeout = 3600
+    self.onmessage = nil
+    self.onerror = nil
+    self.socket = pollnet.open_ws(url)
+    reactor:spawn(function()
+        local timer = 0
+        while not not self.socket do
+            do
+                local ok = true
+                local msg
+                while true do
+                    ok, msg = self.socket:poll()
+                    if not ok or not msg then
+                        break
+                    end
+                    timer = 0
+                    local ____opt_0 = self.onmessage
+                    if ____opt_0 ~= nil then
+                        ____opt_0(msg)
+                    end
+                    if not self.socket then
+                        return
+                    end
+                end
+                local ____ok_2 = ok
+                if ____ok_2 then
+                    timer = timer + 1
+                    ____ok_2 = timer < self.timeout
+                end
+                if ____ok_2 then
+                    coroutine.yield()
+                    goto __continue39
+                end
+                timer = 0
+                self.socket:close()
+                local ____opt_3 = self.onerror
+                if ____opt_3 ~= nil then
+                    ____opt_3(msg or "timeout")
+                end
+                do
+                    local i = 0
+                    while i < 60 do
+                        coroutine.yield()
+                        i = i + 1
+                    end
+                end
+                if not not self.socket then
+                    self.socket = pollnet.open_ws(url)
+                end
+            end
+            ::__continue39::
+        end
+    end)
+end
+function WebSocket.prototype.send(self, message)
+    local ____opt_5 = self.socket
+    if ____opt_5 ~= nil then
+        ____opt_5:send(message)
+    end
+end
+function WebSocket.prototype.send_binary(self, data)
+    local ____opt_7 = self.socket
+    if ____opt_7 ~= nil then
+        ____opt_7:send_binary(data)
+    end
+end
+function WebSocket.prototype.close(self)
+    local ____opt_9 = self.socket
+    if ____opt_9 ~= nil then
+        ____opt_9:close()
+    end
+    self.socket = nil
 end
 return ____exports

package/dist/index.d.ts

@@ -146,11 +146,17 @@ declare namespace pollnet {
       callback?: (sock: Socket, addr: string) => void,
     ): this;
 
-    /** Sets a connection handler */
+    /** Sets a connection handler for server sockets */
     on_connection(callback: (sock: Socket, addr: string) => void): this;
 
-    /** Polls for socket events */
-    poll(): LuaMultiReturn<[true, undefined]> | LuaMultiReturn<[false, string]>;
+    /**
+     * Polls for socket events.
+     * Returns [ok, message], where on success the message may or may not be
+     * available (non-blocking), and on failure the message is an error string.
+     */
+    poll():
+      | LuaMultiReturn<[true, string | undefined]>
+      | LuaMultiReturn<[false, string]>;
 
     /** Awaits a message (coroutine.yield) */
     await():

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noita-ts/pollnet",
-  "version": "0.3.7",
+  "version": "0.4.0",
   "files": [
     "dist/**/*.{lua,dll,d.ts}",
     "LICENSE-pollnet"