LÖVE-API

The core love-api provides the complete LÖVE API documentation represented as a Lua table. The base structure organizes the API into version, functions (global functions), modules (containing name, description, types, functions, and enums), types (supertypes), and callbacks.

Each module contains its own functions and enums. Functions are defined using a variants system, allowing for different argument sets and return types for the same function name. Types can include constructors, functions, and supertypes.

return {
    version = '11.5',
    functions = { -- e.g. love.getVersion
    },
    modules = {
        {
            name = 'modulename',
            description = 'Description.',
            types = {},
            functions = {},
            enums = {
                {
                    name = 'EnumName',
                    constants = {
                        { name = 'constantname', description = 'Description.' }
                    }
                }
            }
        }
    },
    types = {},
    callbacks = {}
}

The extra.lua module is a wrapper that transforms the raw love-api table into a more developer-friendly format. It is highly recommended for tools that need to traverse or query the API easily.

Key enhancements provided by extra.lua:

• Unified Module Access: Moves top-level functions into a module named love (e.g., love.getVersion).
• Guaranteed Tables: Ensures optional fields like functions, types, enums, returns, arguments, constructors, and supertypes are always present as empty tables instead of nil.
• Relationship Mapping: Adds subtypes to types, and module, function_, and variant fields to arguments/returns to allow upward traversal.
• Metadata: Adds what (e.g., 'function', 'method', 'type'), id (unique string), fullname (e.g., 'love.graphics.draw'), and prefix (e.g., 'love.graphics.').
• Advanced Lookups: Provides api.everything (all tables with a what field), api.allfunctions, api.byfullname, and api.byid.

api = require('love-api.extra')(require('love-api.love_api'))

To prepare the data for the scraper, you must download specific export files from the LÖVE wiki into a folder named wiki.

Requirements & Constraints:

• Use the export URL format: https://www.love2d.org/wiki/Special:Export/<page_name>
• Do not include pages for module types or the love.conf page.
• If a page name starts with Image: or File:, you must transform the name by wrapping the prefix in parentheses (e.g., Image:Name becomes (Image):Name) to match the wiki's export requirements.

You can generate a list of valid URLs using the provided Lua script.

local api = require('love-api.extra')(require('love-api.love_api'))

for _, v in pairs(api.allfullnames) do
    local name = v.fullname

    if v.what ~= 'module' and v.fullname ~= 'love.conf' then
        if name:match('Image:') then
            name = name:gsub('^Image:(.+)', '(Image):%1')
        elseif name:match('File:') then
            name = name:gsub('^File:(.+)', '(File):%1')
        end

        print('https://www.love2d.org/wiki/Special:Export/'..name)
    end
end

The following schema describes the enriched structure provided by extra.lua. This is the authoritative format for consumers building tools like linters, IDE plugins, or documentation generators.

Modules: Include fullname, prefix, minidescription, and id. Functions: Include fullname, prefix, setter, getter, constructs (points to a type), and variants. Variants: Include returns, arguments, module, function_, and type_. Arguments/Returns: Include type, name, default, module, function_, variant, and value (for returns) or table (for arguments). Types: Include fullname, parenttype, supertypes, subtypes, and constructors. Enums: Include fullname, minidescription, and constants (which include module and enum references).

-- Example of the enriched function structure in extra.lua
{
    name = 'functionName',
    fullname = 'love.module.functionName',
    prefix = 'love.module.',
    description = 'Description.',
    minidescription = 'Description.',
    setter = setterTable, -- Optional
    getter = getterTable, -- Optional
    constructs = typeTable, -- Optional
    variants = {
        {
            description = 'Description.',
            returns = {},
            arguments = {},
            what = 'variant',
            id = 'love_module_functionName_rb_ast',
            module = moduleTable,
            function_ = functionTable,
            type_ = typeTable,
        }
    },
    what = 'function', -- 'function', 'method', or 'callback'
    id = 'love_module_functionName',
    module = moduleTable,
    type_ = typeTable,
}