Method jsFunc

src/type-extensions/function.ts:182–229

(...args: any[])

        const func = thread.lua.luaL_ref(thread.address, LUA_REGISTRYINDEX)

        const jsFunc = (...args: any[]): any => {
            // Calling a function would ideally be in the Lua context that's calling it. For example if the JS function
            // setInterval were exposed to Lua then the calling thread would be created in that Lua context for executing
            // the function call back to Lua through JS. However, if getValue were called in a thread, the thread then
            // destroyed, and then this JS func were called it would be calling from a dead context. That means the safest
            // thing to do is to have a thread you know will always exist.
            if (this.callbackContext.isClosed()) {
                console.warn('Tried to call a function after closing lua state')
                return
            }

            // Function calls back to value should always be within a new thread because
            // they can be left in inconsistent states.
            const callThread = this.callbackContext.newThread()
            try {
                const internalType = callThread.lua.lua_rawgeti(callThread.address, LUA_REGISTRYINDEX, BigInt(func))
                if (internalType !== LuaType.Function) {
                    const callMetafieldType = callThread.lua.luaL_getmetafield(callThread.address, -1, '__call')
                    callThread.pop()
                    if (callMetafieldType !== LuaType.Function) {
                        throw new Error(`A value of type '${internalType}' was pushed but it is not callable`)
                    }
                }

                for (const arg of args) {
                    callThread.pushValue(arg)
                }

                if (this.options?.functionTimeout) {
                    callThread.setTimeout(Date.now() + this.options.functionTimeout)
                }

                const status: LuaReturn = callThread.lua.lua_pcallk(callThread.address, args.length, 1, 0, 0, null)
                if (status === LuaReturn.Yield) {
                    throw new Error('cannot yield in callbacks from javascript')
                }
                callThread.assertOk(status)

                if (callThread.getTop() > 0) {
                    return callThread.getValue(-1)
                }
                return undefined
            } finally {
                callThread.close()
                // Pop thread used for function call.
                this.callbackContext.pop()
            }
        }

        this.functionRegistry?.register(jsFunc, func)