Módulo:Message box

Este é um metamódulo que implementa as predefinições de message box , , , , , e . Destina-se a ser usado a partir de módulos Lua e não deve ser usado diretamente de páginas wiki. Se quiser usar a funcionalidade deste módulo, por favor use as predefinições de message box individuais em vez disso.

Uso

Para usar este módulo a partir de um outro módulo Lua, primeiro deve carregá-lo.

local messageBox = require('Módulo:Message box')

Para criar uma message box (caixa de mensagem), use a função main. Ela leva dois parâmetros: o primeiro é o tipo da caixa (como um string), e o segundo é uma tabela que contém os parâmetros da message box.

local box = messageBox.main( boxType, {
    param1 = param1,
    param2 = param2,
    -- Mais parêmetros...
})

Há sete tipos de caixa disponíveis:

Tipo de caixa	Predefinição	Propósito
mbox		Para message boxes para serem usadas em múltiplos espaços nominais
ambox		Para message boxes para artigos
cmbox		Para message boxes para categorias
fmbox		Para message boxes de interface
imbox		Para message boxes para o espaço nominal ficheiro
tmbox		Para message boxes para páginas de discussão
ombox		Para message boxes noutros espaços nominais

Veja a página de predefinição de cada tipo de caixa para os parâmetros disponíveis.

Uso a partir de #invoke

Assim como a função main, este módulo possui funções separadas para cada tipo de caixa. Elas são acessadas ao usar o código {{#invoke:Message box|mbox|...}}, {{#invoke:Message box|ambox|...}}, etc. Estas irão funcionar quando chamadas de outros módulos, mas elas acessam código para processar argumentos passados desde #invoke, e, assim, chamá-las fará com que sejam menos eficientes do que chamar main.

Detalhes técnicos

O módulo usa o mesmo código básico para cada uma das predefinições listadas acima; as diferenças entre cada uma delas são configuradas ao usar os dados em Módulo:Message box/configuration. Aqui estão as várias opções de configuração e o que significam:

• types - uma tabela que contém dados usados pelo parâmetro tipo da message box. As chaves da tabela são valores que podem ser passados ao parâmetro tipo, e os valores da tabela são tabelas que contêm a classe e a imagem usada por esse tipo.
• default - o tipo para usar caso nenhum valor foi passado ao parâmetro tipo ou se um valor inválido foi especificado.
• showInvalidTypeError - se mostrar um erro caso o valor passado ao parâmetro tipo foi inválido.
• allowBlankParams - normalmente valores em branco são retirados de parâmetros passados ao nódulo. Contudo, whitespce (espaço em branco) é preservado para os parâmetros incluídos na tabela allowBlankParams.
• allowSmall - se uma versão pequena da message box pode ser produzida com "pequeno=sim".
• smallParam - um nome personalizado para o parâmetro small. Por exemplo, se definido como "esquerda" pode produzir uma message box pequena ao usar "pequeno=esquerda".
• smallClass - a classe para usar para message boxes pequenas.
• substCheck - se performar uma checagem de subst ou não.
• classes - um array de classes para usar com a message box.
• imageEmptyCell - se usar uma célula <td>...</td> vazia caso não haja imagem definida. É usada para preservar espaçamento para message boxes com uma largura de menos de 100% do ecrã.
• imageEmptyCellStyle - se as células de imagem vazias devem ser estilizadas.
• imageCheckBlank - se "imagem=em branco" resulta em nenhuma imagem a ser exibida.
• imageSmallSize - normalmente, imagens usadas em message boxes peqenas são definidas para 30x30px. Isto define um tamanho personalizado.
• imageCellDiv - se colocar a imagem numa div para forçar um tamanho de imagem máximo.
• useCollapsibleTextFields - se usar campos de texto que podem ser desmontados, i.e "problema", "conserto", "discussão" etc. Atualmente somente usado em ambox.
• imageRightNone - se imagemdireita=nenhuma resulta em nenhuma imagem a ser exibida no lado direto da message box.
• sectionDefault - o nome padrão para o parâmetro "secção". Depende de useCollapsibleTextFields.
• allowMainspaceCategories - permitir categorização no espaço nominal principal.
• templateCategory - o nome da the name of a category to be placed on the template page.
• templateCategoryRequireName - se o parâmetro nome é requerido para exibir a categoria da predefinição.
• templateErrorCategory - o nome da categoria de erro a ser usada na página da predefinição.
• templateErrorParamsToCheck - um array de nomes de parâmetros para checar. Caso não haja algum, a templateErrorCategory é aplicada à página da predefinição.

---

-- This is a meta-module for producing message box templates, including
-- {{mbox}}, {{ambox}}, {{imbox}}, {{tmbox}}, {{ombox}}, {{cmbox}} and {{fmbox}}.

-- Load necessary modules.
require('Módulo:No globals')
local getArgs
local yesno = require('Módulo:Yesno')

-- Get a language object for formatDate and ucfirst.
local lang = mw.language.getContentLanguage()

-- Define constants
local CONFIG_MODULE = 'Módulo:Message box/configuration'
local DEMOSPACES = {
	talk = 'tmbox',
	image = 'imbox',
	file = 'imbox',
	category = 'cmbox',
	article = 'ambox',
	main = 'ambox',
	['discussão'] = 'tmbox',
	imagem = 'imbox',
	ficheiro = 'imbox',
	categoria = 'cmbox',
	artigo = 'ambox',
	principal = 'ambox',
}

--------------------------------------------------------------------------------
-- Helper functions
--------------------------------------------------------------------------------

local function getTitleObject(...)
	-- Get the title object, passing the function through pcall
	-- in case we are over the expensive function count limit.
	local success, title = pcall(mw.title.new, ...)
	if success then
		return title
	end
end

local function union(t1, t2)
	-- Returns the union of two arrays.
	local vals = {}
	for i, v in ipairs(t1) do
		vals[v] = true
	end
	for i, v in ipairs(t2) do
		vals[v] = true
	end
	local ret = {}
	for k in pairs(vals) do
		table.insert(ret, k)
	end
	table.sort(ret)
	return ret
end

local function getArgNums(args, prefix)
	local nums = {}
	for k, v in pairs(args) do
		local num = mw.ustring.match(tostring(k), '^' .. prefix .. '([1-9]%d*)$')
		if num then
			table.insert(nums, tonumber(num))
		end
	end
	table.sort(nums)
	return nums
end

--------------------------------------------------------------------------------
-- Box class definition
--------------------------------------------------------------------------------

local MessageBox = {}
MessageBox.__index = MessageBox

function MessageBox.new(boxType, args, cfg)
	args = args or {}
	local obj = {}

	-- Set the title object and the namespace.
	obj.title = getTitleObject(args.page) or getTitleObject(args['página']) or mw.title.getCurrentTitle()

	-- Set the config for our box type.
	obj.cfg = cfg[boxType]
	if not obj.cfg then
		local ns = obj.title.namespace
		-- boxType is "mbox" or invalid input
		if args.demospace and args.demospace ~= '' then
			-- implement demospace parameter of mbox
			local demospace = string.lower(args.demospace)
			if DEMOSPACES[demospace] then
				-- use template from DEMOSPACES
				obj.cfg = cfg[DEMOSPACES[demospace]]
			elseif string.find( demospace, 'talk' ) or string.find( demospace, 'Discussão' ) or string.find( demospace, 'discussão' ) then
				-- demo as a talk page
				obj.cfg = cfg.tmbox
			else
				-- default to ombox
				obj.cfg = cfg.ombox
			end
		elseif ns == 0 then
			obj.cfg = cfg.ambox -- main namespace
		elseif ns == 6 then
			obj.cfg = cfg.imbox -- file namespace
		elseif ns == 14 then
			obj.cfg = cfg.cmbox -- category namespace
		else
			local nsTable = mw.site.namespaces[ns]
			if nsTable and nsTable.isTalk then
				obj.cfg = cfg.tmbox -- any talk namespace
			else
				obj.cfg = cfg.ombox -- other namespaces or invalid input
			end
		end
	end

	-- Set the arguments, and remove all blank arguments except for the ones
	-- listed in cfg.allowBlankParams.
	do
		local newArgs = {}
		for k, v in pairs(args) do
			if v ~= '' then
				newArgs[k] = v
			end
		end
		for i, param in ipairs(obj.cfg.allowBlankParams or {}) do
			newArgs[param] = args[param]
		end
		obj.args = newArgs
	end

	-- Define internal data structure.
	obj.categories = {}
	obj.classes = {}
	-- For lazy loading of [[Module:Category handler]].
	obj.hasCategories = false

	return setmetatable(obj, MessageBox)
end

function MessageBox:addCat(ns, cat, sort)
	if not cat then
		return nil
	end
	if sort then
		cat = string.format('[[Categoria:%s|%s]]', cat, sort)
	else
		cat = string.format('[[Categoria:%s]]', cat)
	end
	self.hasCategories = true
	self.categories[ns] = self.categories[ns] or {}
	table.insert(self.categories[ns], cat)
end

function MessageBox:addClass(class)
	if not class then
		return nil
	end
	table.insert(self.classes, class)
end

function MessageBox:setParameters()
	local args = self.args
	local cfg = self.cfg

	-- Get type data.
	self.type = args.type or args.tipo
	local typeData = cfg.types[self.type]
	self.invalidTypeError = cfg.showInvalidTypeError
		and self.type
		and not typeData
	typeData = typeData or cfg.types[cfg.default]
	self.typeClass = typeData.class or typeData.classe
	self.typeImage = typeData.image or typeData.imagem

	-- Find if the box has been wrongly substituted.
	self.isSubstituted = cfg.substCheck and args.subst == 'SUBST'

	-- Find whether we are using a small message box.
	self.isSmall = cfg.allowSmall and (
		cfg.smallParam and args.small == cfg.smallParam
		or cfg.smallParam and args.small == 'esquerda'
		or not cfg.smallParam and yesno(args.small)
		or cfg.smallParam and args.pequeno == cfg.smallParam
		or cfg.smallParam and args.pequeno == 'esquerda'
		or not cfg.smallParam and yesno(args.pequeno)
		or cfg.smallParam and args.pequena == cfg.smallParam
		or cfg.smallParam and args.pequena == 'esquerda'
		or not cfg.smallParam and yesno(args.pequena)
	)

	-- Add attributes, classes and styles.
	self.id = args.id
	self.name = args.name or args.nome
	if self.name then
		self:addClass('box-' .. string.gsub(self.name,' ','_'))
	end
	if yesno(args.plainlinks) ~= false then
		self:addClass('plainlinks')
	end
	for _, class in ipairs(cfg.classes or {}) do
		self:addClass(class)
	end
	if self.isSmall then
		self:addClass(cfg.smallClass or 'mbox-small')
	end
	self:addClass(self.typeClass)
	if args.class then
		self:addClass(args.class)
	elseif args.classe then
		self:addClass(args.classe)
	end
	if args.style then
		self.style = args.style
	elseif args.estilo then
		self.style = args.estilo
	end
	if args.attrs then
		self.attrs = args.attrs
	elseif args.atrs then
		self.attrs = args.atrs
	end
	
	-- Set text style.
	if args.textstyle then
		self.textstyle = args.textstyle or args.estilotexto or args['estilo-texto'] or args['estilo_texto']
	end
	
	-- Find if we are on the template page or not. This functionality is only
	-- used if useCollapsibleTextFields is set, or if both cfg.templateCategory
	-- and cfg.templateCategoryRequireName are set.
	self.useCollapsibleTextFields = cfg.useCollapsibleTextFields
	if self.useCollapsibleTextFields
		or cfg.templateCategory
		and cfg.templateCategoryRequireName
	then
		if self.name then
			local templateName = mw.ustring.match(
				self.name,
				'^[pP][rR][eE][dD][eE][fF][iI][nI][çÇ][ãÃ][oO][%s_]*:[%s_]*(.*)$'
			) or self.name
			templateName = 'Predefinição:' .. templateName
			self.templateTitle = getTitleObject(templateName)
		end
		self.isTemplatePage = self.templateTitle
			and mw.title.equals(self.title, self.templateTitle)
	end
	
	-- Process data for collapsible text fields. At the moment these are only
	-- used in {{ambox}}.
	if self.useCollapsibleTextFields then
		-- Get the self.issue value.
		local textoPequeno = args.smalltext or args.textopequeno or args['texto-pequeno'] or args['texto_pequeno']
		if self.isSmall and textoPequeno then
			self.issue = textoPequeno
		else
			local sect
			local seccao = args.sect or args['secção'] or args['seção']
			if seccao == '' then
				if cfg.sectionDefault then
					sect = 'Este ' .. cfg.sectionDefault
				else
					sect = 'Esta página'
				end
			elseif type(seccao) == 'string' then
				sect = seccao
			end
			local issue = args.issue or args.problema
			issue = type(issue) == 'string' and issue ~= '' and issue or nil
			local text = args.text or args.texto
			text = type(text) == 'string' and text or nil
			local issues = {}
			table.insert(issues, sect)
			table.insert(issues, issue)
			table.insert(issues, text)
			self.issue = table.concat(issues, ' ')
		end

		-- Get the self.talk value.
		local talk = args.talk or args['discussão']
		-- Show talk links on the template page or template subpages if the talk
		-- parameter is blank.
		if talk == ''
			and self.templateTitle
			and (
				mw.title.equals(self.templateTitle, self.title)
				or self.title:isSubpageOf(self.templateTitle)
			)
		then
			talk = '#'
		elseif talk == '' then
			talk = nil
		end
		if talk then
			-- If the talk value is a talk page, make a link to that page. Else
			-- assume that it's a section heading, and make a link to the talk
			-- page of the current page with that section heading.
			local talkTitle = getTitleObject(talk)
			local talkArgIsTalkPage = true
			if not talkTitle or not talkTitle.isTalkPage then
				talkArgIsTalkPage = false
				talkTitle = getTitleObject(
					self.title.text,
					mw.site.namespaces[self.title.namespace].talk.id
				)
			end
			if talkTitle and talkTitle.exists then
				local talkText = 'Discussão relevante pode ser encontrada'
				if talkArgIsTalkPage then
					talkText = string.format(
						'%s [[%s|%s]].',
						talkText,
						talk,
						talkTitle.prefixedText
					)
				else
					talkText = string.format(
						'%s na [[%s#%s|página de discussão]].',
						talkText,
						talkTitle.prefixedText,
						talk
					)
				end
				self.talk = talkText
			end
		end

		-- Get other values.
		self.fix = args.fix ~= '' and args.fix or args.conserto ~= '' and args.conserto or nil 
		local date
		if args.date then
			if args.date ~= '' then
				date = args.date
			elseif args.date == '' and self.isTemplatePage then
				date = lang:formatDate('F "de" Y')
			end
		else
			if args.data ~= '' then
				date = args.data
			elseif args.data == '' and self.isTemplatePage then
				date = lang:formatDate('F "de" Y')
			end
		end
		if date then
			self.date = string.format(" <small class='date-container'>''(<span class='date'>%s</span>)''</small>", lang:ucfirst(date))
		end
		self.info = args.info
		if yesno(args.removalnotice or args['avisoderemoção'] or args['aviso-de-remoção'] or args['aviso_de_remoção'] or args['avisoremoção'] or args['aviso-remoção'] or args['aviso_remoção']) then
			self.removalNotice = cfg.removalNotice
		end
	end

	-- Set the non-collapsible text field. At the moment this is used by all box
	-- types other than ambox, and also by ambox when small=yes.
	if self.isSmall then
		self.text = args.smalltext or args.text or args.textopequeno or args['texto-pequeno'] or args['texto_pequeno'] or args.texto
	else
		self.text = args.text or args.texto
	end

	-- Set the below row.
	self.below = (cfg.below and args.below) or (cfg.below and args.abaixo)

	-- General image settings.
	self.imageCellDiv = not self.isSmall and cfg.imageCellDiv
	self.imageEmptyCell = cfg.imageEmptyCell
	if cfg.imageEmptyCellStyle then
		self.imageEmptyCellStyle = 'border: none; padding: 0px; width:1px'
	end

	-- Left image settings.
	local imageLeft = (self.isSmall and args.smallimage
					   or self.isSmall and args.imagempequena
					   or self.isSmall and args['imagem-pequena']
					   or self.isSmall and args['imagem_pequena']
					   or args.image
					   or args.imagem)
	if cfg.imageCheckBlank and imageLeft ~= 'blank' and imageLeft ~= 'none' and imageLeft ~= 'em branco' and imageLeft ~= 'nenhuma'
	   or not cfg.imageCheckBlank and imageLeft ~= 'none' and imageLeft ~= 'nenhuma'
	then
		self.imageLeft = imageLeft
		if not imageLeft then
			local imageSize = self.isSmall
				and (cfg.imageSmallSize or '30x30px')
				or '40x40px'
			self.imageLeft = string.format('[[Ficheiro:%s|%s|link=|alt=]]', self.typeImage
				or 'Imbox notice.png', imageSize)
		end
	end

	-- Right image settings.
	local imageRight = (self.isSmall and args.smallimageright)
	or (self.isSmall and args.imagemdireitapequena)
	or (self.isSmall and args['imagem-direita-pequena'])
	or (self.isSmall and args['imagem_direita_pequena'])
	or args.imageright or args.imagemdireita or args['imagem-direita'] or args['imagem_direita']
	if not ((cfg.imageRightNone and imageRight == 'none') or (cfg.imageRightNone and imageRight == 'nenhuma')) then
		self.imageRight = imageRight
	end
end

function MessageBox:setMainspaceCategories()
	local args = self.args
	local cfg = self.cfg

	if not cfg.allowMainspaceCategories then
		return nil
	end

	local nums = {}
	for _, prefix in ipairs{'cat', 'category', 'all', 'categoria', 'todos'} do
		args[prefix .. '1'] = args[prefix]
		nums = union(nums, getArgNums(args, prefix))
	end

	-- The following is roughly equivalent to the old {{Ambox/category}}.
	local date = args.date or args.data
	date = type(date) == 'string' and date
	local preposition = 'desde'
	for _, num in ipairs(nums) do
		local mainCat = args['cat' .. tostring(num)]
			or args['category' .. tostring(num)] or args['categoria' .. tostring(num)]
		local allCat = args['all' .. tostring(num)] or args['todos' .. tostring(num)]
		mainCat = type(mainCat) == 'string' and mainCat
		allCat = type(allCat) == 'string' and allCat
		if mainCat and date and date ~= '' then
			local catTitle = string.format('%s %s %s', mainCat, preposition, mw.ustring.lower(date))
			self:addCat(0, catTitle)
			catTitle = getTitleObject('Categoria:' .. catTitle)
			if not catTitle or not catTitle.exists then
				self:addCat(0, '!Artigos com parâmetro de data inválido em predefinições')
			end
		elseif mainCat and (not date or date == '') then
			self:addCat(0, mainCat)
		end
		if allCat then
			self:addCat(0, allCat)
		end
	end
end

function MessageBox:setTemplateCategories()
	local args = self.args
	local cfg = self.cfg

	-- Add template categories.
	if cfg.templateCategory then
		if cfg.templateCategoryRequireName then
			if self.isTemplatePage then
				self:addCat(10, cfg.templateCategory)
			end
		elseif not self.title.isSubpage then
			self:addCat(10, cfg.templateCategory)
		end
	end

	-- Add template error categories.
	if cfg.templateErrorCategory then
		local templateErrorCategory = cfg.templateErrorCategory
		local templateCat, templateSort
		if not self.name and not self.title.isSubpage then
			templateCat = templateErrorCategory
		elseif self.isTemplatePage then
			local paramsToCheck = cfg.templateErrorParamsToCheck or {}
			local count = 0
			for i, param in ipairs(paramsToCheck) do
				if not args[param] then
					count = count + 1
				end
			end
			if count > 0 then
				templateCat = templateErrorCategory
				templateSort = tostring(count)
			end
			if self.categoryNums and #self.categoryNums > 0 then
				templateCat = templateErrorCategory
				templateSort = 'C'
			end
		end
		self:addCat(10, templateCat, templateSort)
	end
end

function MessageBox:setAllNamespaceCategories()
	-- Set categories for all namespaces.
	if self.invalidTypeError then
		local allSort = (self.title.namespace == 0 and 'Principal:' or '') .. self.title.prefixedText
		self:addCat('all', '!Parâmetro de message box que precisa de conserto', allSort)
	end
	if self.isSubstituted then
		self:addCat('all', '!Páginas com predefinições substituídas incorretamente')
	end
end

function MessageBox:setCategories()
	if self.title.namespace == 0 then
		self:setMainspaceCategories()
	elseif self.title.namespace == 10 then
		self:setTemplateCategories()
	end
	self:setAllNamespaceCategories()
end

function MessageBox:renderCategories()
	if not self.hasCategories then
		-- No categories added, no need to pass them to Category handler so,
		-- if it was invoked, it would return the empty string.
		-- So we shortcut and return the empty string.
		return ""
	end
	-- Convert category tables to strings and pass them through
	-- [[Module:Category handler]].
	return require('Módulo:Category handler')._main{
		main = table.concat(self.categories[0] or {}),
		template = table.concat(self.categories[10] or {}),
		all = table.concat(self.categories.all or self.categories.todos or {}),
		nocat = self.args.nocat or self.args.semcat,
		page = self.args.page or self.args['página']
	}
end

function MessageBox:export()
	local root = mw.html.create()
	root:wikitext(mw.getCurrentFrame():extensionTag('templatestyles', '', {src = 'Ambox/styles.css'}))

	-- Add the subst check error.
	if self.isSubstituted and self.name then
		root:tag('b')
			:addClass('error')
			:wikitext(string.format(
				'Predefinição <code>%s[[Predefinição:%s|%s]]%s</code> foi substituída incorretamente.',
				mw.text.nowiki('{{'), self.name, self.name, mw.text.nowiki('}}')
			))
	end

	-- Create the box table.
	local boxTable = root:tag('table')
	boxTable:attr('id', self.id or nil)
	for i, class in ipairs(self.classes or {}) do
		boxTable:addClass(class or nil)
	end
	boxTable
		:cssText(self.style or nil)
		:attr('role', 'presentation')

	if self.attrs then
		boxTable:attr(self.attrs)
	end

	-- Add the left-hand image.
	local row = boxTable:tag('tr')
	if self.imageLeft then
		local imageLeftCell = row:tag('td'):addClass('mbox-image')
		if self.imageCellDiv then
			-- If we are using a div, redefine imageLeftCell so that the image
			-- is inside it. Divs use style="width: 52px;", which limits the
			-- image width to 52px. If any images in a div are wider than that,
			-- they may overlap with the text or cause other display problems.
			imageLeftCell = imageLeftCell:tag('div'):css('width', '52px')
		end
		imageLeftCell:wikitext(self.imageLeft or nil)
	elseif self.imageEmptyCell then
		-- Some message boxes define an empty cell if no image is specified, and
		-- some don't. The old template code in templates where empty cells are
		-- specified gives the following hint: "No image. Cell with some width
		-- or padding necessary for text cell to have 100% width."
		row:tag('td')
			:addClass('mbox-empty-cell')
			:cssText(self.imageEmptyCellStyle or nil)
	end

	-- Add the text.
	local textCell = row:tag('td'):addClass('mbox-text')
	if self.useCollapsibleTextFields then
		-- The message box uses advanced text parameters that allow things to be
		-- collapsible. At the moment, only ambox uses this.
		textCell:cssText(self.textstyle or nil)
		local textCellDiv = textCell:tag('div')
		textCellDiv
			:addClass('mbox-text-span')
			:wikitext(self.issue or nil)
		if (self.talk or self.fix) and not self.isSmall then
			textCellDiv:tag('span')
				:addClass('hide-when-compact')
				:wikitext(self.talk and (' ' .. self.talk) or nil)
				:wikitext(self.fix and (' ' .. self.fix) or nil)
		end
		textCellDiv:wikitext(self.date and (' ' .. self.date) or nil)
		if self.info and not self.isSmall then
			textCellDiv
				:tag('span')
				:addClass('hide-when-compact')
				:wikitext(self.info and (' ' .. self.info) or nil)
		end
		if self.removalNotice then
			textCellDiv:tag('small')
				:addClass('hide-when-compact')
				:tag('i')
					:wikitext(string.format(" (%s)", self.removalNotice))
		end
	else
		-- Default text formatting - anything goes.
		textCell
			:cssText(self.textstyle or nil)
			:wikitext(self.text or nil)
	end

	-- Add the right-hand image.
	if self.imageRight then
		local imageRightCell = row:tag('td'):addClass('mbox-imageright')
		if self.imageCellDiv then
			-- If we are using a div, redefine imageRightCell so that the image
			-- is inside it.
			imageRightCell = imageRightCell:tag('div'):css('width', '52px')
		end
		imageRightCell
			:wikitext(self.imageRight or nil)
	end

	-- Add the below row.
	if self.below then
		boxTable:tag('tr')
			:tag('td')
				:attr('colspan', self.imageRight and '3' or '2')
				:addClass('mbox-text')
				:cssText(self.textstyle or nil)
				:wikitext(self.below or nil)
	end

	-- Add error message for invalid type parameters.
	if self.invalidTypeError then
		root:tag('div')
			:css('text-align', 'center')
			:wikitext(string.format(
				'Esta message box está a utilizar um parâmetro "type=%s" inválido e necessita de conserto.',
				self.type or ''
			))
	end

	-- Add categories.
	root:wikitext(self:renderCategories() or nil)

	return tostring(root)
end

--------------------------------------------------------------------------------
-- Exports
--------------------------------------------------------------------------------

local p, mt = {}, {}

function p._exportClasses()
	-- For testing.
	return {
		MessageBox = MessageBox
	}
end

function p.main(boxType, args, cfgTables)
	local box = MessageBox.new(boxType, args, cfgTables or mw.loadData(CONFIG_MODULE))
	box:setParameters()
	box:setCategories()
	return box:export()
end

function mt.__index(t, k)
	return function (frame)
		if not getArgs then
			getArgs = require('Módulo:Arguments').getArgs
		end
		return t.main(k, getArgs(frame, {trim = false, removeBlanks = false}))
	end
end

return setmetatable(p, mt)