@noita-ts/pollnet 0.2.0 → 0.3.0

package/dist/async.d.ts

@@ -1,31 +1,73 @@
-import pollnet from "./index";
-/**
- * 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.
- */
-export declare const spawn: <T>(reactor: pollnet.Reactor, body: () => T) => Promise<T>;
+import pollnet from ".";
+export declare namespace compat {
+    /**
+     * 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.
+     */
+    const asyncify: <T>(reactor: pollnet.Reactor, body: () => T) => Promise<T>;
+    /**
+     * 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 .. })`).
+     */
+    const yieldPromise: <T>(p: Promise<T>) => T;
+}
 /**
- * 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 .. })`).
+ * Promise-friendly wrapper around a {@link pollnet.Reactor}.
+ *
+ * Lets you drive yield-based pollnet coroutines while exposing their results
+ * as Promises. Call {@link poll} regularly (e.g. once per frame) to advance
+ * all running coroutines.
  */
-export declare const blockOn: <T>(p: Promise<T>) => T;
+export declare class AsyncReactor {
+    private reactor;
+    constructor();
+    /**
+     * Advance every coroutine currently running on the reactor by one step.
+     * Must be called periodically for spawned work to make progress.
+     */
+    poll(): number;
+    /**
+     * Run `body` as a reactor coroutine and return its result as a Promise.
+     * `body` may use yield-based pollnet APIs (e.g. `socket.await()`).
+     */
+    spawn<T>(body: () => T): Promise<T>;
+    /**
+     * Async version of `pollnet.Reactor.run_server`.
+     *
+     * Accept connections on `server_sock`, spawning a coroutine that runs
+     * `client_body` for each incoming client. `client_body` receives the client
+     * socket and its remote address, and may itself return a Promise which the
+     * coroutine parks on until it settles.
+     */
+    runServer(server_sock: pollnet.Socket, client_body: (sock: pollnet.Socket, addr: string) => Promise<void>): void;
+}
 export declare class HttpResponse {
     status: number;
     headers: string;
     body: string;
     constructor(status: number, headers: string, body: string);
+    /**
+     * Parse the raw header block into a map.
+     * Header names seen more than once collapse into an array of their values, in
+     * order.
+     */
     parseHeaders(): Record<string, string | string[]>;
 }
-export default class AsyncReactor {
+/**
+ * Tiny async HTTP client built on top of an {@link AsyncReactor}.
+ * Requests run as reactor coroutines and resolve to an {@link HttpResponse}.
+ */
+export declare class HttpClient {
     private reactor;
-    constructor();
-    update(): number;
-    /** Runs a coroutine thread */
-    run(thread_body: (this: pollnet.Reactor) => void): void;
-    /** Runs a server with client handler */
-    run_server(server_sock: pollnet.Socket, client_body: (sock: pollnet.Socket, addr: string) => void): void;
-    http_get(url: string, headers?: Record<string, string | string[]> | string): Promise<HttpResponse>;
-    http_post(url: string, headers?: Record<string, string | string[]> | string, body?: string): Promise<HttpResponse>;
+    constructor(reactor: AsyncReactor);
+    /**
+     * Perform an HTTP GET.
+     */
+    get(url: string, headers?: Record<string, string | string[]> | string): Promise<HttpResponse>;
+    /**
+     * Perform an HTTP POST with an optional request `body`.
+     */
+    post(url: string, headers?: Record<string, string | string[]> | string, body?: string): Promise<HttpResponse>;
 }

package/dist/async.lua

@@ -11,61 +11,91 @@ local SyntaxError = ____lualib.SyntaxError
 local TypeError = ____lualib.TypeError
 local URIError = ____lualib.URIError
 local ____exports = {}
-local ____index = require("index")
-local pollnet = ____index.default
---- 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.
-____exports.spawn = function(____, reactor, body)
-    return __TS__New(
-        __TS__Promise,
-        function(____, resolve, reject)
-            reactor:run(function()
-                do
-                    local function ____catch(e)
-                        reject(nil, e)
+local _____2E = require("index")
+local pollnet = _____2E.default
+____exports.compat = {}
+local compat = ____exports.compat
+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)
+        return __TS__New(
+            __TS__Promise,
+            function(____, resolve, reject)
+                reactor:run(function()
+                    do
+                        local function ____catch(e)
+                            reject(nil, e)
+                        end
+                        local ____try, ____hasReturned = pcall(function()
+                            resolve(
+                                nil,
+                                body(nil)
+                            )
+                        end)
+                        if not ____try then
+                            ____catch(____hasReturned)
+                        end
                     end
-                    local ____try, ____hasReturned = pcall(function()
-                        resolve(
-                            nil,
-                            body(nil)
-                        )
-                    end)
-                    if not ____try then
-                        ____catch(____hasReturned)
-                    end
-                end
-            end)
+                end)
+            end
+        )
+    end
+    --- 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)
+        local done = false
+        local ok = false
+        local result
+        p["then"](
+            p,
+            function(____, v)
+                done = true
+                ok = true
+                result = v
+            end,
+            function(____, e)
+                done = true
+                ok = false
+                result = e
+            end
+        )
+        while not done do
+            coroutine.yield()
         end
-    )
-end
---- 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 .. })`).
-____exports.blockOn = function(____, p)
-    local done = false
-    local ok = false
-    local result
-    p["then"](
-        p,
-        function(____, v)
-            done = true
-            ok = true
-            result = v
-        end,
-        function(____, e)
-            done = true
-            ok = false
-            result = e
+        if not ok then
+            error(result, 0)
         end
-    )
-    while not done do
-        coroutine.yield()
-    end
-    if not ok then
-        error(result, 0)
+        return result
     end
-    return result
+end
+--- Promise-friendly wrapper around a {@link pollnet.Reactor}.
+-- 
+-- Lets you drive yield-based pollnet coroutines while exposing their results
+-- as Promises. Call {@link poll} regularly (e.g. once per frame) to advance
+-- all running coroutines.
+____exports.AsyncReactor = __TS__Class()
+local AsyncReactor = ____exports.AsyncReactor
+AsyncReactor.name = "AsyncReactor"
+function AsyncReactor.prototype.____constructor(self)
+    self.reactor = pollnet.Reactor()
+end
+function AsyncReactor.prototype.poll(self)
+    return self.reactor:update()
+end
+function AsyncReactor.prototype.spawn(self, 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() return ____exports.compat:yieldPromise(client_body(nil, client_sock, addr)) end)
+    end)
+    self.reactor:run(function()
+        while (server_sock:await()) do
+        end
+    end)
 end
 ____exports.HttpResponse = __TS__Class()
 local HttpResponse = ____exports.HttpResponse
@@ -85,12 +115,12 @@ function HttpResponse.prototype.parseHeaders(self)
                 2
             )
             if not key or not value then
-                goto __continue14
+                goto __continue23
             end
             local prev = headers[key]
             if not prev then
                 headers[key] = value
-                goto __continue14
+                goto __continue23
             end
             if __TS__ArrayIsArray(prev) then
                 prev[#prev + 1] = value
@@ -98,61 +128,46 @@ function HttpResponse.prototype.parseHeaders(self)
                 headers[key] = {prev, value}
             end
         end
-        ::__continue14::
+        ::__continue23::
     end
     return headers
 end
-____exports.default = __TS__Class()
-local AsyncReactor = ____exports.default
-AsyncReactor.name = "AsyncReactor"
-function AsyncReactor.prototype.____constructor(self)
-    self.reactor = pollnet.Reactor()
-end
-function AsyncReactor.prototype.update(self)
-    return self.reactor:update()
+--- Tiny async HTTP client built on top of an {@link AsyncReactor}.
+-- Requests run as reactor coroutines and resolve to an {@link HttpResponse}.
+____exports.HttpClient = __TS__Class()
+local HttpClient = ____exports.HttpClient
+HttpClient.name = "HttpClient"
+function HttpClient.prototype.____constructor(self, reactor)
+    self.reactor = reactor
 end
-function AsyncReactor.prototype.run(self, thread_body)
-    self.reactor:run(thread_body)
-end
-function AsyncReactor.prototype.run_server(self, server_sock, client_body)
-    self.reactor:run_server(server_sock, client_body)
-end
-function AsyncReactor.prototype.http_get(self, url, headers)
-    return ____exports.spawn(
-        nil,
-        self.reactor,
-        function()
-            local socket = pollnet.http_get(url, headers, false)
-            local msgs, ____error = socket:await_n(3)
-            if not msgs then
-                error(
-                    __TS__New(Error, "socket error: " .. ____error),
-                    0
-                )
-            end
-            local statusStr, headersStr, respBody = unpack(msgs, 1, 3)
-            local status = tonumber({string.match("^%d+", statusStr)}) or 500
-            return __TS__New(____exports.HttpResponse, status, headersStr, respBody)
+function HttpClient.prototype.get(self, url, headers)
+    return self.reactor:spawn(function()
+        local socket = pollnet.http_get(url, headers, false)
+        local msgs, ____error = socket:await_n(3)
+        if not msgs then
+            error(
+                __TS__New(Error, "socket error: " .. ____error),
+                0
+            )
         end
-    )
+        local statusStr, headersStr, respBody = unpack(msgs, 1, 3)
+        local status = tonumber({string.match("^%d+", statusStr)}) or 500
+        return __TS__New(____exports.HttpResponse, status, headersStr, respBody)
+    end)
 end
-function AsyncReactor.prototype.http_post(self, url, headers, body)
-    return ____exports.spawn(
-        nil,
-        self.reactor,
-        function()
-            local socket = pollnet.http_post(url, headers, body, false)
-            local msgs, ____error = socket:await_n(3)
-            if not msgs then
-                error(
-                    __TS__New(Error, "socket error: " .. ____error),
-                    0
-                )
-            end
-            local statusStr, headersStr, respBody = unpack(msgs, 1, 3)
-            local status = tonumber({string.match("^%d+", statusStr)}) or 500
-            return __TS__New(____exports.HttpResponse, status, headersStr, respBody)
+function HttpClient.prototype.post(self, url, headers, body)
+    return self.reactor:spawn(function()
+        local socket = pollnet.http_post(url, headers, body, false)
+        local msgs, ____error = socket:await_n(3)
+        if not msgs then
+            error(
+                __TS__New(Error, "socket error: " .. ____error),
+                0
+            )
         end
-    )
+        local statusStr, headersStr, respBody = unpack(msgs, 1, 3)
+        local status = tonumber({string.match("^%d+", statusStr)}) or 500
+        return __TS__New(____exports.HttpResponse, status, headersStr, respBody)
+    end)
 end
 return ____exports