MediaWiki:Common.css

2025-04-06T06:18:59Z

Pynappo:

MediaWiki:Common.css

2025-04-06T06:18:17Z

Pynappo: add hover support

Template:Spoiler

2025-04-06T06:15:41Z

Pynappo:

<includeonly>
{{#vardefine:element|{{#if:{{{block|}}}|div|span}}}}<{{#var:element}} class="spoiler no-js {{#if:{{{hover|}}}|hover}} {{{class|}}}" id="{{{id|}}}" style="{{{css|{{{style|}}}}}}"><{{#var:element}}>{{{1|}}}</{{#var:element}}></{{#var:element}}></includeonly><noinclude>

</noinclude>

Pynappo: Reverted edit by Pynappo (talk) to last revision by CStatic

<includeonly>{{#invoke:Hatnote|hatnote}}</includeonly>

Template:Hatnote

2025-03-13T09:39:33Z

Pynappo:

MediaWiki:Lua/Navbox.css

2025-03-03T22:05:17Z

Pynappo: Created page with "/******************* * Navboxes *******************/ /* * CSS Vars * Note: The linter will throw an error. See [https://community.fandom.com/wiki/Help:Advanced_CSS_and_JS#Common_issues this page] for more info. */ .navbox { --navbox-bg-color: var(--theme-page-background-color); --navbox-text-color: var(--theme-page-text-color); --navbox-title-color: rgba(var(--theme-accent-color--rgb, rgb(102, 102, 102)), 0.5); --navbox-header-color: rgba(var(--theme-ac..."

/*******************
* Navboxes
*******************/
/*
* CSS Vars
* Note: The linter will throw an error. See [https://community.fandom.com/wiki/Help:Advanced_CSS_and_JS#Common_issues this page] for more info.
*/
.navbox {
--navbox-bg-color: var(--theme-page-background-color);
--navbox-text-color: var(--theme-page-text-color);
--navbox-title-color: rgba(var(--theme-accent-color--rgb, rgb(102, 102, 102)), 0.5);
--navbox-header-color: rgba(var(--theme-accent-color--rgb, rgb(102, 102, 102)), 0.3);
--navbox-alt-color: rgba(var(--theme-accent-color--rgb, rgb(85, 85, 85)), 0.1);
--navbox-border-color: var(--theme-border-color)
}
.navbox {
width: 100%;
background: var(--navbox-bg-color, white);
color: var(--navbox-text-color, black);
margin: 1em auto;
font-size: 84%;
text-align: center;
clear: both;
padding: 2px;
border-spacing: 0;
border: 1px solid var(--navbox-border-color, #AAA);
}

/* Merges navboxes that are directly under eachother */
.navbox + .navbox {
margin-top: -11px;
}

.navbox .navbox-title {
background: var(--navbox-title-color, #CCF);
color: var(--navbox-text-color, black);
font-weight: bold;
text-align: center;
}

.navbox .navbox-vde {
float: left;
width: 65px;
}

.navbox .navbox-title th {
padding: 2px 0;
}

.navbox .navbox-title th > div,
.navbox th.navbox-header > div {
padding: 0 4px;
}

.navbox .navbox-title th > .navbox-title-pad,
.navbox th.navbox-header > .navbox-header-pad {
padding: 0 65px;
}

.navbox .navbox-subgroup {
border-spacing: 0;
width: 100%;
}

.navbox .navbox-subgroup-with-title {
text-align: center;
}

.navbox .navbox-gutter {
height: 2px;
}

.navbox .navbox-section-row > td {
padding: 0;
height: 100%;
}

.navbox .navbox-section {
width: 100%;
border-spacing: 0;
text-align: center;
}

.navbox .navbox-above,
.navbox .navbox-below {
background: var(--navbox-header-color, #DDF);
text-align: center;
}

.navbox .navbox-above td,
.navbox .navbox-below td {
padding: 2px 4px;
}

.navbox .navbox-image {
background: var(--navbox-bg-color, white);
text-align: center;
}

.navbox .navbox-group,
.navbox .navbox-header,
.navbox .navbox-subgroup .navbox-title {
background: var(--navbox-header-color, #DDF);
color: var(--navbox-text-color, black);
font-weight: bold;
height: 100%;
padding: 2px 0;
}

.navbox .navbox-header {
text-align: center;
}

.navbox .navbox-group {
text-align: right;
padding-left: 1em;
padding-right: 1em;
word-wrap: normal;
}

.skin-fandomdesktop .navbox .navbox-group {
white-space: nowrap;
}

.navbox .navbox-group,
.navbox .navbox-image-left {
border-right: 2px solid var(--navbox-bg-color, white);
}

.navbox .navbox-image-right {
border-left: 2px solid var(--navbox-bg-color, white);
}

.navbox .navbox-list {
text-align: center;
}

.navbox .navbox-group + .navbox-list,
.navbox .navbox-group + .navbox-list > table:not(.navbox-subgroup-with-title) > tbody > tr > .navbox-list {
text-align: left;
}

.navbox .navbox-list {
background: var(--navbox-bg-color, white);
color: var(--navbox-text-color, black);
width: 100%;
height: 100%;
padding: 0;
}

.navbox .alt > .navbox-list {
background: var(--navbox-alt-color, #F7F7F7);
}

.navbox .navbox-list > div {
padding: 0px 4px;
}

.navbox .hlist dl,
.navbox .hlist ol,
.navbox .hlist ul {
font-size: inherit;
}

.navbox .navbox-list.no-group {
padding-top: 2px;
padding-bottom: 2px;
}

.navbox .mw-collapsible-toggle {
width: 65px;
}

/* hlist */
.hlist dl,
.hlist ol,
.hlist ul {
margin: 0;
padding: 0;
}

/* Display list items inline */
.hlist dd,
.hlist dt,
.hlist li {
margin: 0; /* don't trust the note that says margin doesn't work with inline
* removing margin: 0 makes dds have margins again */
display: inline;
}

/* Display nested lists inline */
.hlist.inline,
.hlist.inline dl,
.hlist.inline ol,
.hlist.inline ul,
.hlist dl dl,
.hlist dl ol,
.hlist dl ul,
.hlist ol dl,
.hlist ol ol,
.hlist ol ul,
.hlist ul dl,
.hlist ul ol,
.hlist ul ul {
display: inline;
}

/* Hide empty list items */
.hlist .mw-empty-li {
display: none;
}

/* Generate interpuncts */
.hlist dt:after {
content: ": ";
}

.hlist dd:after,
.hlist li:after {
content: " · ";
font-weight: bold;
}

.hlist dd:last-child:after,
.hlist dt:last-child:after,
.hlist li:last-child:after {
content: none;
}

/* Add parentheses around nested lists */
.hlist dd dd:first-child:before,
.hlist dd dt:first-child:before,
.hlist dd li:first-child:before,
.hlist dt dd:first-child:before,
.hlist dt dt:first-child:before,
.hlist dt li:first-child:before,
.hlist li dd:first-child:before,
.hlist li dt:first-child:before,
.hlist li li:first-child:before {
content: " (";
font-weight: normal;
}

.hlist dd dd:last-child:after,
.hlist dd dt:last-child:after,
.hlist dd li:last-child:after,
.hlist dt dd:last-child:after,
.hlist dt dt:last-child:after,
.hlist dt li:last-child:after,
.hlist li dd:last-child:after,
.hlist li dt:last-child:after,
.hlist li li:last-child:after {
content: ")";
font-weight: normal;
}

/* Put ordinals in front of ordered list items */
.hlist ol {
counter-reset: listitem;
}

.hlist ol > li {
counter-increment: listitem;
}

.hlist ol > li:before {
content: " " counter(listitem) "\a0";
}

.hlist dd ol > li:first-child:before,
.hlist dt ol > li:first-child:before,
.hlist li ol > li:first-child:before {
content: " (" counter(listitem) "\a0";
}

/* override Fandom CSS */
.page-content .hlist ol:not(.portable-infobox ol) {
margin: 0;
}

.plainlist ol,
.plainlist ul {
line-height: inherit;
list-style: none;
margin: 0;
padding: 0; /* Reset Minerva default */
}

.plainlist ol li,
.plainlist ul li {
margin-bottom: 0;
}

Module:Navbox/i18n

2025-03-03T21:51:16Z

Pynappo: Created page with "-- <nowiki> return { ["_metadata"] = { ["order"] = { "hide", "show" } }, ["en"] = { ["hide"] = "Hide", ["show"] = "Show" }, ["qqq"] = { ["hide"] = "\"Hide\" button (i.e. collapse the navbox).", ["show"] = "\"Show\" button (i.e. expand the navbox)." }, ["de"] = { ["hide"] = "Einklappen", ["show"] = "Ausklappen" }, ["es"] = { ["hide"] = "Ocult..."

-- <nowiki>
return {
["_metadata"] = {
["order"] = {
"hide",
"show"
}
},
["en"] = {
["hide"] = "Hide",
["show"] = "Show"
},
["qqq"] = {
["hide"] = "\"Hide\" button (i.e. collapse the navbox).",
["show"] = "\"Show\" button (i.e. expand the navbox)."
},
["de"] = {
["hide"] = "Einklappen",
["show"] = "Ausklappen"
},
["es"] = {
["hide"] = "Ocultar",
["show"] = "Mostrar"
},
["hi"] = {
["hide"] = "छिपाएँ",
["show"] = "दिखाएँ"
},
["ja"] = {
["hide"] = "隠す",
["show"] = "表示"
},
["pt-br"] = {
["hide"] = "Ocultar",
["show"] = "Mostrar"
},
["ru"] = {
["hide"] = "Скрыть",
["show"] = "Показать"
},
["zh-hans"] = {
["hide"] = "隐藏",
["show"] = "显示"
},
["zh-hant"] = {
["hide"] = "隱藏",
["show"] = "顯示"
},
["zh-hk"] = {
["hide"] = "隱藏",
["show"] = "顯示"
}
}
-- </nowiki>

Template:T

2025-03-03T10:53:43Z

Pynappo: Created page with "{{#invoke:T|main}}"

Module:T

2025-03-03T10:47:06Z

Pynappo:

-- <nowiki>
--------------------------------------------------------------------------------
-- A feature-packed example generator for brace-based wikitext.
--
-- @module T
-- @alias p
-- @version 0.6.4
-- @release experimental
-- @requires [[Global Lua Modules/Arguments|Module:Arguments]]
-- @requires [[Global Lua Modules/User error|Module:User error]]
-- @requires [[Global Lua Modules/Yesno|Module:Yesno]]
-- @author [[User:DarthKitty]]
-- @author [[User:Speedit]]
-- @author [[User:ExE Boss]]
--
-- @todo Extract CSS to stylesheet; transition from data-attributes to classes.
-- @todo Consider adding i18n for error messages, flags, &c.
-- @todo Consider adding generator(s?) for magic words and parser functions.
--------------------------------------------------------------------------------

local libraryUtil = require("libraryUtil")
local checkType = libraryUtil.checkType

local getArgs = require("Module:Arguments").getArgs
local userError = require("Module:User error")
local yesno = require("Module:Yesno")

local p = {}

--------------------------------------------------------------------------------
-- Parses a parameter to get its components: its name (optional), and either its
-- value or its description (but not both).
--
-- @param {string} param
-- A parameter.
-- @returns {table}
-- The components of a parameter.
--------------------------------------------------------------------------------
local function parseParam(param)
local tmp = param
local name, value, description

-- the parameter's name is anything to the left of the first equals sign;
-- the equals sign can be escaped, for wikis that don't have [[Template:=]]
if tmp:find("=") or tmp:find(mw.text.nowiki("=")) then
name, tmp = tmp
:gsub(mw.text.nowiki("="), "=", 1)
:match("^(.-)%s*=%s*(.-)$")
end

-- if the remaining text is wrapped in matching quotes, then it's a literal
-- value; otherwise, it's a description of the parameter
local first = tmp:sub(1, 1)
local last = tmp:sub(-1)

if (first == '"' and last == '"') or (first == "'" and last == "'") then
value = tmp:sub(2, -2)
elseif tmp == "" then
description = "..." -- the description cannot be an empty string
else
description = tmp
end

return {
name = name,
value = value,
description = description
}
end

--------------------------------------------------------------------------------
-- The heart of the module. Transforms a list of parameters into wikitext
-- syntax.
--
-- @param {string} mode
-- Which kind of brace-based wikitext we're dealing with.
-- @param {string} opener
-- Text to insert between the two left-braces and the first parameter.
-- @param[opt] {table|nil} params
-- A sequentual table of parameters.
-- @param[opt] {table|nil} options
-- A table with configuration flags.
-- @param[opt] {boolean|nil} options.multiline
-- @param[opt] {boolean|nil} options.subst
-- @returns {string}
-- A blob of wikitext describing any brace-based syntax.
--------------------------------------------------------------------------------
local function builder(mode, opener, params, options)
checkType("builder", 2, opener, "string")
checkType("builder", 3, params, "table", true)
checkType("builder", 4, options, "table", true)

params = params or {}
options = options or {}

local html = mw.html.create("code")
:attr("data-t-role", "wrapper")
:attr("data-t-mode", mode)
:css("all", "unset")
:css("font-family", "monospace")

local openerSpan =
html:tag("span")
:attr("data-t-role", "opener")
:wikitext(mw.text.nowiki("{"):rep(2))

if options.subst then
openerSpan:wikitext("subst:")
end

openerSpan:wikitext(opener)

if options.multiline then
html:attr("data-t-multiline", "data-t-multiline")
end

for i, param in ipairs(params) do
if type(param) ~= "string" then
error("invalid entry #" .. i .. " in parameter list", 3)
end

local components = parseParam(param)
local paramHtml = html:tag("span")
:attr("data-t-role", "parameter")
:attr("data-t-index", i)
:wikitext(mw.text.nowiki("|"))

if options.multiline then
paramHtml:css("display", "block")
end

if components.name then
paramHtml:tag("span")
:attr("data-t-role", "parameter-name")
:css("font-weight", "bold")
:wikitext(components.name)

paramHtml:wikitext(" = ")
end

if components.value then
paramHtml:tag("span")
:attr("data-t-role", "parameter-value")
:wikitext(components.value)
end

if components.description then
paramHtml:tag("span")
:attr("data-t-role", "parameter-description")
:css("opacity", "0.65")
:wikitext(mw.text.nowiki("<"))
:wikitext(components.description)
:wikitext(mw.text.nowiki(">"))
end
end

html:tag("span")
:attr("data-t-role", "closer")
:wikitext(mw.text.nowiki("}"):rep(2))

return tostring(html)
end

--------------------------------------------------------------------------------
-- Resolves a transclusion according to the MediaWiki
-- transclusion resolution algorithm.
--
-- @param {string} title
-- The name of the transclusion to resolve.
-- @return {string}
-- The resolved transclusion with the namespace prefix.
-- @see [[w:Template:Transclude]]
--------------------------------------------------------------------------------
local function resolveTransclusion(title)
checkType("resolveTransclusion", 1, title, "string")
local i = mw.ustring.find(title, "%:")
if i == 1 then
return mw.ustring.sub(title, 2)
elseif i ~= nil then
return title
end
return "Template:" .. title
end

--------------------------------------------------------------------------------
-- Generator for transclusion syntax, e.g. `{{foo}}`, `{{:foo}}`,
-- or `{{Template:Foo}}`.
--
-- @param {string} title
-- The name of the template to link to.
-- @param[opt] {table|nil} params
-- A sequentual table of parameters.
-- @param[opt] {table|nil} options
-- A table with configuration flags.
-- @param[opt] {boolean|nil} options.multiline
-- @param[opt] {boolean|nil} options.subst
-- @returns {string}
-- A blob of wikitext describing a template.
--------------------------------------------------------------------------------
function p.transclusion(title, params, options)
if type(title) ~= "string" or title == "" then
error("no title specified", 2)
end

return builder(
"transclusion",
"[[:" .. resolveTransclusion(title) .. "|" .. title .. "]]",
params,
options
)
end

--------------------------------------------------------------------------------
-- Generator for invocation syntax, e.g. `{{#invoke:foo|bar}}`.
--
-- @param {string} title
-- The name of the module to link to, without the namespace prefix.
-- @param {string} func
-- The name of the function to call.
-- @param[opt] {table|nil} params
-- A sequentual table of parameters.
-- @param[opt] {table|nil} options
-- A table with configuration flags.
-- @param[opt] {boolean|nil} options.multiline
-- @param[opt] {boolean|nil} options.subst
-- @returns {string}
-- A blob of wikitext describing a module.
--------------------------------------------------------------------------------
function p.invocation(title, func, params, options)
if type(title) ~= "string" or title == "" then
error("no module specified", 2)
end

if type(func) ~= "string" or func == "" then
error("no function specified", 2)
end

local link = "[[Module:" .. title .. "|" .. title .. "]]"

return builder(
"invocation",
"#invoke:" .. link .. mw.text.nowiki("|") .. func,
params,
options
)
end

--------------------------------------------------------------------------------
-- Entry point from the wikitext side. Determines which generator to use based
-- on the provided arguments.
--
-- @param {table|Frame} frame
-- A frame object whose arguments will determine the correct generator
-- to use.
-- @returns {string}
-- A blob of wikitext describing any brace-based syntax.
--------------------------------------------------------------------------------
function p.main(frame)
local args = getArgs(frame, {removeBlanks = false})
local mode, minimumArity

if yesno(args.invocation) or yesno(args.i) then
mode = "invocation"
minimumArity = 2
else
mode = "transclusion"
minimumArity = 1
end

local params = {}
local options = {
multiline = yesno(args.multiline) or yesno(args.m),
subst = yesno(args.subst) or yesno(args.s),
}

-- a dynamically-generated list of arguments to the generator
-- required arguments are inserted before `params` and `options`
local varargs = {params, options}

for i, value in ipairs(args) do
if i <= minimumArity then
-- pass the first few values directly to the generator
-- these are used to calculate the opener
table.insert(varargs, i, value)
else
-- put the remaining values in a table, and pass it to the generator
-- these are shown as parameters in the resulting wikitext
params[#params + 1] = value
end
end

local success, response = pcall(p[mode], unpack(varargs))

return success and response or userError(response)
end

return p

Module:User error

2025-03-03T10:46:36Z

Pynappo:

-- <nowiki>
--------------------------------------------------------------------------------
-- A less intimidating version of the built-in "error()" function, to help
-- editors fix their mistakes when transcluding a template.
--------------------------------------------------------------------------------
local checkType = require('libraryUtil').checkType

return function (message, ...)
checkType('Module:User error', 1, message, 'string')

local element = mw.html.create('strong')
:addClass('error')
:wikitext('Error: ' .. message .. '.')

for i = 1, select('#', ...) do
local category = select(i, ...)

checkType('Module:User error', i + 1, category, 'string')

if category ~= '' then
element:wikitext('[[Category:' .. category .. ']]')
end
end

return tostring(element)
end

-- </nowiki>
-- (Add categories here.)