api.lua

local existing = rawget(_ENV, 'mnr')
if existing and existing.name == 'mnr_api' then
    error(('mnr_api already loaded in %s - remove duplicate "@mnr_api/api.lua" from fxmanifest.lua'):format(GetCurrentResourceName()))
end

local buildResolver = LoadResourceFile('mnr_api', 'api/loader.lua')
buildResolver = assert(load(buildResolver, '@@mnr_api/api/loader.lua', 't'))()

local pending = {}
local pendingCount = 0
local ready = false
local subscribed = {}

local TIMEOUT = GetConvarInt('mnr_api:api_timeout', 30000)
local scope = IsDuplicityVersion() and 'server' or 'client'

msgpack.setoption('ignore_invalid', true)

local resolveKey, registry, loading = buildResolver({
    resource = 'mnr_api',
    scope = scope,
    readFile = function(path)
        return LoadResourceFile('mnr_api', path)
    end,
})

local function abortPending()
    local snapshot = pending
    local count = pendingCount
    pending = {}
    pendingCount = 0

    for i = 1, count do
        coroutine.resume(snapshot[i], nil, 'Aborted: mnr_api did not start in time')
    end
end

local function preloadAPI()
    local resource = GetCurrentResourceName()
    local keys = {}

    local count = GetNumResourceMetadata(resource, 'mnr_preload')
    for i = 0, count - 1 do
        local key = GetResourceMetadata(resource, 'mnr_preload', i)

        if key and key ~= '' then
            keys[#keys + 1] = key
        end
    end

    local extraCount = GetNumResourceMetadata(resource, 'mnr_preload_extra')
    for i = 0, extraCount - 1 do
        local extra = GetResourceMetadata(resource, 'mnr_preload_extra', i)

        if extra then
            local decoded = json.decode(extra)

            if type(decoded) == 'table' then
                for _, key in ipairs(decoded) do
                    if type(key) == 'string' and key ~= '' then
                        keys[#keys + 1] = key
                    end
                end
            end
        end
    end

    for i = 1, #keys do
        resolveKey(keys[i])
    end
end

local function initAPI()
    ready = true

    local snapshot = pending
    local count = pendingCount
    pending = {}
    pendingCount = 0

    for i = 1, count do
        coroutine.resume(snapshot[i])
    end
end

local function waitReady(key)
    if ready then return end

    local co = coroutine.running()
    if not co then
        error(('mnr.%s accessed outside a coroutine before mnr_api was ready'):format(key), 2)
    end

    pendingCount = pendingCount + 1
    pending[pendingCount] = co

    local _, err = coroutine.yield()
    if err then error(err, 2) end
end

---@type MnrAPI
local mnr = setmetatable({}, {
    __index = function(_, key)
        if key == 'name' then
            return 'mnr_api'
        end

        if key == 'scope' then
            return scope
        end

        local cached = registry[key]
        if cached and cached ~= loading then
            return cached
        end

        if ready then
            return resolveKey(key)
        end

        local stub = setmetatable({}, {
            __index = function(_, field)
                waitReady(key)
                local api = resolveKey(key)
                rawset(mnr, key, api)
                return api[field]
            end,
            __call = function(_, ...)
                waitReady(key)
                local api = resolveKey(key)
                rawset(mnr, key, api)
                return api(...)
            end,
            __metatable = false,
        })

        rawset(mnr, key, stub)

        return stub
    end,
    __newindex = function(_, key, value)
        registry[key] = value
    end,
    __metatable = false,
})

local mnrEnv = setmetatable({ resource = GetCurrentResourceName() }, {
    __index = function(self, field)
        local ok, value = pcall(function()
            return exports.mnr_api:getEnv(field)
        end)
        if not ok then
            error(('mnrEnv.%s is not available'):format(field), 2)
        end

        if not subscribed[field] then
            subscribed[field] = true

            AddEventHandler(('mnr_api:update:%s'):format(field), function(newValue)
                rawset(self, field, newValue)
            end)
        end

        rawset(self, field, value)

        return value
    end,
    __metatable = false,
})

local startEvent = IsDuplicityVersion() and 'onResourceStart' or 'onClientResourceStart'
local timer
local handler

handler = AddEventHandler(startEvent, function(name)
    if name ~= 'mnr_api' then return end

    RemoveEventHandler(handler)
    if timer then
        ClearTimeout(timer)
    end

    initAPI()
    preloadAPI()
end)

CreateThread(function()
    if GetResourceState('mnr_api') == 'started' then
        RemoveEventHandler(handler)
        initAPI()
        preloadAPI()
        return
    end

    timer = SetTimeout(TIMEOUT, function()
        RemoveEventHandler(handler)
        abortPending()

        error(('Timeout: mnr_api did not start within %dms - stopping %s'):format(TIMEOUT, GetCurrentResourceName()), 0)
    end)
end)

rawset(_ENV, 'mnr', mnr)
rawset(_ENV, 'mnrEnv', mnrEnv)