@noita-ts/pollnet 0.3.8 → 0.5.0

package/dist/lualib_bundle.lua

@@ -1,46 +1,3 @@
-local function __TS__New(target, ...)
-    local instance = setmetatable({}, target.prototype)
-    instance:____constructor(...)
-    return instance
-end
-
-local __TS__Symbol, Symbol
-do
-    local symbolMetatable = {__tostring = function(self)
-        return ("Symbol(" .. (self.description or "")) .. ")"
-    end}
-    function __TS__Symbol(description)
-        return setmetatable({description = description}, symbolMetatable)
-    end
-    Symbol = {
-        asyncDispose = __TS__Symbol("Symbol.asyncDispose"),
-        dispose = __TS__Symbol("Symbol.dispose"),
-        iterator = __TS__Symbol("Symbol.iterator"),
-        hasInstance = __TS__Symbol("Symbol.hasInstance"),
-        species = __TS__Symbol("Symbol.species"),
-        toStringTag = __TS__Symbol("Symbol.toStringTag")
-    }
-end
-
-local function __TS__InstanceOf(obj, classTbl)
-    if type(classTbl) ~= "table" then
-        error("Right-hand side of 'instanceof' is not an object", 0)
-    end
-    if classTbl[Symbol.hasInstance] ~= nil then
-        return not not classTbl[Symbol.hasInstance](classTbl, obj)
-    end
-    if type(obj) == "table" then
-        local luaClass = obj.constructor
-        while luaClass ~= nil do
-            if luaClass == classTbl then
-                return true
-            end
-            luaClass = luaClass.____super
-        end
-    end
-    return false
-end
-
 local function __TS__Class(self)
     local c = {prototype = {}}
     c.prototype.__index = c.prototype
@@ -48,171 +5,6 @@ local function __TS__Class(self)
     return c
 end
 
-local __TS__Promise
-do
-    local function makeDeferredPromiseFactory()
-        local resolve
-        local reject
-        local function executor(____, res, rej)
-            resolve = res
-            reject = rej
-        end
-        return function()
-            local promise = __TS__New(__TS__Promise, executor)
-            return promise, resolve, reject
-        end
-    end
-    local makeDeferredPromise = makeDeferredPromiseFactory()
-    local function isPromiseLike(value)
-        return __TS__InstanceOf(value, __TS__Promise)
-    end
-    local function doNothing(self)
-    end
-    local ____pcall = _G.pcall
-    __TS__Promise = __TS__Class()
-    __TS__Promise.name = "__TS__Promise"
-    function __TS__Promise.prototype.____constructor(self, executor)
-        self.state = 0
-        self.fulfilledCallbacks = {}
-        self.rejectedCallbacks = {}
-        local success, ____error = ____pcall(
-            executor,
-            nil,
-            function(____, v) return self:resolve(v) end,
-            function(____, err) return self:reject(err) end
-        )
-        if not success then
-            self:reject(____error)
-        end
-    end
-    function __TS__Promise.resolve(value)
-        if __TS__InstanceOf(value, __TS__Promise) then
-            return value
-        end
-        local promise = __TS__New(__TS__Promise, doNothing)
-        promise.state = 1
-        promise.value = value
-        return promise
-    end
-    function __TS__Promise.reject(reason)
-        local promise = __TS__New(__TS__Promise, doNothing)
-        promise.state = 2
-        promise.rejectionReason = reason
-        return promise
-    end
-    __TS__Promise.prototype["then"] = function(self, onFulfilled, onRejected)
-        local promise, resolve, reject = makeDeferredPromise()
-        self:addCallbacks(
-            onFulfilled and self:createPromiseResolvingCallback(onFulfilled, resolve, reject) or resolve,
-            onRejected and self:createPromiseResolvingCallback(onRejected, resolve, reject) or reject
-        )
-        return promise
-    end
-    function __TS__Promise.prototype.addCallbacks(self, fulfilledCallback, rejectedCallback)
-        if self.state == 1 then
-            return fulfilledCallback(nil, self.value)
-        end
-        if self.state == 2 then
-            return rejectedCallback(nil, self.rejectionReason)
-        end
-        local ____self_fulfilledCallbacks_0 = self.fulfilledCallbacks
-        ____self_fulfilledCallbacks_0[#____self_fulfilledCallbacks_0 + 1] = fulfilledCallback
-        local ____self_rejectedCallbacks_1 = self.rejectedCallbacks
-        ____self_rejectedCallbacks_1[#____self_rejectedCallbacks_1 + 1] = rejectedCallback
-    end
-    function __TS__Promise.prototype.catch(self, onRejected)
-        return self["then"](self, nil, onRejected)
-    end
-    function __TS__Promise.prototype.finally(self, onFinally)
-        if type(onFinally) ~= "function" then
-            return self["then"](self, onFinally, onFinally)
-        end
-        return self["then"](
-            self,
-            function(____, x)
-                local ____self_2 = __TS__New(
-                    __TS__Promise,
-                    function(____, resolve) return resolve(
-                        nil,
-                        onFinally(nil)
-                    ) end
-                )
-                return ____self_2["then"](
-                    ____self_2,
-                    function() return x end
-                )
-            end,
-            function(____, e)
-                local ____self_3 = __TS__New(
-                    __TS__Promise,
-                    function(____, resolve) return resolve(
-                        nil,
-                        onFinally(nil)
-                    ) end
-                )
-                return ____self_3["then"](
-                    ____self_3,
-                    function()
-                        error(e, 0)
-                    end
-                )
-            end
-        )
-    end
-    function __TS__Promise.prototype.resolve(self, value)
-        if isPromiseLike(value) then
-            return value:addCallbacks(
-                function(____, v) return self:resolve(v) end,
-                function(____, err) return self:reject(err) end
-            )
-        end
-        if self.state == 0 then
-            self.state = 1
-            self.value = value
-            return self:invokeCallbacks(self.fulfilledCallbacks, value)
-        end
-    end
-    function __TS__Promise.prototype.reject(self, reason)
-        if self.state == 0 then
-            self.state = 2
-            self.rejectionReason = reason
-            return self:invokeCallbacks(self.rejectedCallbacks, reason)
-        end
-    end
-    function __TS__Promise.prototype.invokeCallbacks(self, callbacks, value)
-        local callbacksLength = #callbacks
-        if callbacksLength ~= 0 then
-            for i = 1, callbacksLength - 1 do
-                callbacks[i](callbacks, value)
-            end
-            return callbacks[callbacksLength](callbacks, value)
-        end
-    end
-    function __TS__Promise.prototype.createPromiseResolvingCallback(self, f, resolve, reject)
-        return function(____, value)
-            local success, resultOrError = ____pcall(f, nil, value)
-            if not success then
-                return reject(nil, resultOrError)
-            end
-            return self:handleCallbackValue(resultOrError, resolve, reject)
-        end
-    end
-    function __TS__Promise.prototype.handleCallbackValue(self, value, resolve, reject)
-        if isPromiseLike(value) then
-            local nextpromise = value
-            if nextpromise.state == 1 then
-                return resolve(nil, nextpromise.value)
-            elseif nextpromise.state == 2 then
-                return reject(nil, nextpromise.rejectionReason)
-            else
-                return nextpromise:addCallbacks(resolve, reject)
-            end
-        else
-            return resolve(nil, value)
-        end
-    end
-end
-
 local function __TS__StringIncludes(self, searchString, position)
     if not position then
         position = 1
@@ -223,6 +15,12 @@ local function __TS__StringIncludes(self, searchString, position)
     return index ~= nil
 end
 
+local function __TS__New(target, ...)
+    local instance = setmetatable({}, target.prototype)
+    instance:____constructor(...)
+    return instance
+end
+
 local function __TS__ClassExtends(target, base)
     target.____super = base
     local staticMetatable = setmetatable({__index = base}, base)
@@ -375,16 +173,14 @@ local function __TS__ArrayIsArray(value)
 end
 
 return {
-  __TS__Promise = __TS__Promise,
-  __TS__New = __TS__New,
   __TS__Class = __TS__Class,
-  __TS__InstanceOf = __TS__InstanceOf,
   Error = Error,
   RangeError = RangeError,
   ReferenceError = ReferenceError,
   SyntaxError = SyntaxError,
   TypeError = TypeError,
   URIError = URIError,
+  __TS__New = __TS__New,
   __TS__StringSplit = __TS__StringSplit,
   __TS__ArrayIsArray = __TS__ArrayIsArray
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noita-ts/pollnet",
-  "version": "0.3.8",
+  "version": "0.5.0",
   "files": [
     "dist/**/*.{lua,dll,d.ts}",
     "LICENSE-pollnet"
@@ -13,9 +13,9 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index"
     },
-    "./async": {
-      "types": "./dist/async.d.ts",
-      "default": "./dist/async"
+    "./api": {
+      "types": "./dist/api.d.ts",
+      "default": "./dist/api"
     }
   },
   "scripts": {

package/dist/async.d.ts

@@ -1,76 +0,0 @@
-/** @noSelfInFile */
-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;
-}
-/**
- * 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 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): void;
-}
-export declare class HttpResponse {
-    status: number;
-    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.
-     * Header names seen more than once collapse into an array of their values, in
-     * order.
-     */
-    parseHeaders(): Record<string, string | string[]>;
-}
-/**
- * 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(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

@@ -1,167 +0,0 @@
-local ____lualib = require("lualib_bundle")
-local __TS__Promise = ____lualib.__TS__Promise
-local __TS__New = ____lualib.__TS__New
-local __TS__Class = ____lualib.__TS__Class
-local __TS__InstanceOf = ____lualib.__TS__InstanceOf
-local Error = ____lualib.Error
-local RangeError = ____lualib.RangeError
-local ReferenceError = ____lualib.ReferenceError
-local SyntaxError = ____lualib.SyntaxError
-local TypeError = ____lualib.TypeError
-local URIError = ____lualib.URIError
-local __TS__StringSplit = ____lualib.__TS__StringSplit
-local __TS__ArrayIsArray = ____lualib.__TS__ArrayIsArray
-local ____exports = {}
-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()
-                            )
-                        end)
-                        if not ____try then
-                            ____catch(____hasReturned)
-                        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
-        if not ok then
-            error(result, 0)
-        end
-        return result
-    end
-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()
-            local r = client_body(client_sock, addr)
-            if __TS__InstanceOf(r, __TS__Promise) then
-                ____exports.compat.yieldPromise(r)
-            end
-        end)
-    end)
-    self.reactor:run(function()
-        while (server_sock:await()) do
-        end
-    end)
-end
-____exports.HttpResponse = __TS__Class()
-local HttpResponse = ____exports.HttpResponse
-HttpResponse.name = "HttpResponse"
-function HttpResponse.prototype.____constructor(self, status, headers, body)
-    self.status = status
-    self.headers = headers
-    self.body = body
-end
-function HttpResponse.read(socket)
-    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(statusStr, "^%d+"))) or 500
-    return __TS__New(____exports.HttpResponse, status, headersStr, respBody)
-end
-function HttpResponse.prototype.parseHeaders(self)
-    local headers = {}
-    for ____, line in ipairs(__TS__StringSplit(self.headers, "\n")) do
-        do
-            local key, value = unpack(
-                __TS__StringSplit(line, ": ", 2),
-                1,
-                2
-            )
-            if not key or not value then
-                goto __continue26
-            end
-            local prev = headers[key]
-            if not prev then
-                headers[key] = value
-                goto __continue26
-            end
-            if __TS__ArrayIsArray(prev) then
-                prev[#prev + 1] = value
-            else
-                headers[key] = {prev, value}
-            end
-        end
-        ::__continue26::
-    end
-    return headers
-end
---- 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 HttpClient.prototype.get(self, url, headers)
-    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)
-end
-return ____exports