wp>Nux: typo • Wikiploy

2026-01-25T19:44:18Z

New page

local p = {}
local priv = {} -- private functions scope
-- expose private for easy testing/debugging
p.__priv = priv

-- require exact colors for printing
local forPrinting = "-webkit-print-color-adjust: exact; print-color-adjust: exact;"
--[===[
Smooth piechart module.

Draws charts in HTML with an accessible legend (optional).
A list of all features is in the "TODO" section of the main `p.pie` function.

Module info:
- Changelog and TODO: [[:en:User:Nux/pie_chart_-_todo]] (Piechart 1.0, 2.0 and beyond).
- Author: [[:en:User:Nux|Maciej Nux]].

Use with a helper template that adds required CSS.

{{{1}}}:
[
{ "label": "pie: $v", "color": "wheat", "value": 40 },
{ "label": "cheese pizza $v", "color": "#fc0", "value": 20 },
{ "label": "mixed pizza: $v", "color": "#f60", "value": 20 },
{ "label": "raw pizza $v", "color": "#f30" }
]
Where $v is a formatted number (see `function prepareLabel`).

{{{meta}}}:
{"size":200, "autoscale":false, "legend":true}

All meta options are optional (see `function p.setupOptions`).
]===]

--[[
Debug:

-- labels and auto-value
local json_data = '[{"label": "k: $v", "value": 33.1}, {"label": "m: $v", "value": -1}]'
local html = p.renderPie(json_data)
mw.logObject(html)

-- autoscale values
local json_data = '[{"value": 700}, {"value": 300}]'
local html = p.renderPie(json_data, options)
mw.logObject(html)

-- size option
local json_data = '[{"label": "k: $v", "value": 33.1}, {"label": "m: $v", "value": -1}]'
local options = '{"size":200}'
local html = p.renderPie(json_data, options)
mw.logObject(html)

-- custom colors
local json_data = '[{"label": "k: $v", "value": 33.1, "color":"black"}, {"label": "m: $v", "value": -1, "color":"green"}]'
local html = p.renderPie(json_data)
mw.logObject(html)

-- 4-cuts
local entries = {
'{"label": "ciastka: $v", "value": 2, "color":"goldenrod"}',
'{"label": "słodycze: $v", "value": 4, "color":"darkred"}',
'{"label": "napoje: $v", "value": 1, "color":"lightblue"}',
'{"label": "kanapki: $v", "value": 3, "color":"wheat"}'
}
local json_data = '['..table.concat(entries, ',')..']'
local html = p.renderPie(json_data, '{"autoscale":true}')
mw.logObject(html)

-- colors
local fr = { args = { " 123 " } }
local ret = p.color(fr)
]]

--[[
Color for a slice (defaults).

{{{1}}}: slice number
]]
function p.color(frame)
local index = tonumber(priv.trim(frame.args[1]))
return ' ' .. priv.defaultColor(index)
end

--[===[
Main pie chart function.

TODO (maybe):
[[:en:User:Nux/pie_chart_-_todo#Hopes_and_dreams]]
]===]
function p.pie(frame)
local json_data = priv.trim(frame.args[1])
local options = {}
if (frame.args.meta) then
options.meta = priv.trim(frame.args.meta)
end

local html = p.renderPie(json_data, options)
return priv.trim(html)
end

-- Setup chart options.
function p.setupOptions(user_options)
local options = {
-- circle size in [px]
size = 100,
-- autoscale values (otherwise assume they sum up to 100)
autoscale = false,
-- hide chart for screen readers (when you have a table, forced for legend)
ariahidechart = false,
-- show legend (defaults to the left side)
legend = false,
-- direction of legend-chart flexbox (flex-direction)
direction = "",
-- width of the main container
-- when direction is used defaults to max-width, otherwise it's not added
width = "",
-- caption above the labels
caption = "",
-- footer below the labels
footer = "",
-- formatting template for labels
labelformat = "",
-- percentage number formatting precision (number of digits; -1 = automatic mode)
precision = -1,
}
-- internals
options.style = ""
if user_options and user_options.meta then
local decodeSuccess, rawOptions = pcall(function()
return mw.text.jsonDecode(user_options.meta, mw.text.JSON_TRY_FIXING)
end)
if not decodeSuccess then
rawOptions = false
mw.log('invalid meta parameters')
end
if rawOptions then
if type(rawOptions.size) == "number" then
options.size = math.floor(rawOptions.size)
end
options.autoscale = rawOptions.autoscale or false
if rawOptions.legend then
options.legend = true
end
if rawOptions.ariahidechart then
options.ariahidechart = true
end
if (type(rawOptions.direction) == "string") then
-- Remove unsafe/invalid characters
local sanitized = rawOptions.direction:gsub("[^a-z0-9%-]", "")
-- also adjust width so that row-reverse won't push things to the right
options.direction = 'flex-direction: ' .. sanitized .. ';'
options.width = 'width: max-content;'
end
if (type(rawOptions.width) == "string") then
-- note, this intentionaly overwrites what was set for direction
local sanitized = rawOptions.width:gsub("[^a-z0-9%-]", "")
options.width = 'width: ' .. sanitized .. ';'
end
if (type(rawOptions.caption) == "string") then
options.caption = rawOptions.caption
end
if (type(rawOptions.footer) == "string") then
options.footer = rawOptions.footer
end
if (type(rawOptions.labelformat) == "string") then
options.labelformat = rawOptions.labelformat
end
if type(rawOptions.precision) == "number" then
options.precision = math.floor(rawOptions.precision)
end
end
-- build style
if options.width ~= "" then
options.style = options.style .. options.width
end
if options.direction ~= "" then
options.style = options.style .. options.direction
end
end
if (options.legend) then
options.ariahidechart = true
end
return options
end

-- internal for testing legend rendering
p.__priv.legendDebug = false

--[[
Render piechart.

@param json_data JSON string with pie data.
]]
function p.renderPie(json_data, user_options)
if type(json_data) ~= "string" then
error('invalid piechart data type: '..type(json_data))
end
if #json_data < 2 then
error('piechart data is empty')
end
local decodeSuccess, data = pcall(function()
return mw.text.jsonDecode(json_data, mw.text.JSON_TRY_FIXING)
end)
-- Handle decode error
if not decodeSuccess then
error('invalid piechart data: '..json_data)
end
local options = p.setupOptions(user_options)

-- prepare
local ok, total = p.prepareEntries(data, options)

-- init render
local html = "<div class='smooth-pie-container' style='"..options.style.."'>"

-- error info
if not ok then
html = html .. priv.renderErrors(data)
end

-- render legend
if options.legend then
html = html .. p.renderLegend(data, options)
end

if p.__priv.legendDebug then
return html
end

-- render items
local header, items, footer = p.renderEntries(ok, total, data, options)
html = html .. header .. items .. footer

-- end .smooth-pie-container
html = html .. "\n</div>"

return html
end

function priv.boundaryFormatting(diff)
local value = 0.0
if diff <= 1.0 then
value = math.ceil(diff / 0.2) * 0.2 -- 0.2 step
else
value = math.ceil(diff / 0.5) * 0.5 -- 0.5 step
end
return string.format("%.1f", value)
end

-- Check if sum will trigger autoscaling
function priv.willAutoscale(sum)
-- Compare with a number larger then 100% to avoid floating-point precision problems
--- ...and data precision problems https://en.wikipedia.org/wiki/Template_talk:Pie_chart#c-PrimeHunter-20250420202500-Allow_percentage_sum_slightly_above_100
local diff = sum - 100
local grace = 1
return diff > grace
end
-- Tracking errors in data (note: somewhat expensive, similar to a red link)
-- In short: ±0.3 is a reasonable deviation; ±1 when the errors accumulate
-- https://en.wikipedia.org/wiki/Template_talk:Pie_chart#c-Nux-20250429152000-Nux-20250422224600
function priv.sumErrorTracking(sum, items)
local diff = sum - 100
if diff >= 0.4 and diff <= 10 then
local firstItem = items[1]
local lastItem = items[#items]
mw.addWarning("pie chart: Σ (value) = "..sum.."% ("..firstItem.value.." + .. .+ "..lastItem.value..")")
if mw.title.getCurrentTitle().namespace == 0 then
local suffix = priv.boundaryFormatting(diff)
_ = mw.title.new("Module:Piechart/tracing/diff below "..suffix).id
end
end
end

-- Prepare data (slices etc)
function p.prepareEntries(data, options)
local sum = priv.sumValues(data);
-- force autoscale when over 100
if priv.willAutoscale(sum) then
options.autoscale = true
end
-- pre-format entries
local ok = true
local no = 0
local total = #data
for index, entry in ipairs(data) do
no = no + 1
if not priv.prepareSlice(entry, no, sum, total, options) then
no = no - 1
ok = false
end
end
total = no -- total valid

return ok, total
end

function priv.sumValues(data)
local sum = 0;
for _, entry in ipairs(data) do
local value = entry.value
if not (type(value) ~= "number" or value < 0) then
sum = sum + value
end
end
return sum
end

-- render error info
function priv.renderErrors(data)
local html = "\n<ol class='chart-errors' style='display:none'>"
for _, entry in ipairs(data) do
if entry.error then
local entryJson = mw.text.jsonEncode(entry)
html = html .. "\n<li>".. entryJson .."</li>"
end
end
return html .. "\n</ol>\n"
end

-- Prepare single slice data (modifies entry).
-- @param no = 1..total
function priv.prepareSlice(entry, no, sum, total, options)
local autoscale = options.autoscale
local value = entry.value
if (type(value) ~= "number" or value < 0) then
if autoscale then
entry.error = "cannot autoscale unknown value"
return false
end
value = 100 - sum
end
-- entry.raw only when scaled
if autoscale then
entry.raw = value
value = (value / sum) * 100
end
entry.value = value

-- prepare final label
entry.label = priv.prepareLabel(options.labelformat, entry, options.precision)
-- background, but also color for MW syntax linter
entry.bcolor = priv.backColor(entry, no, total) .. ";color:#000"

return true
end

-- render legend for pre-processed entries
function p.renderLegend(data, options)
local html = ""
if options.caption ~= "" or options.footer ~= "" then
html = "\n<div class='smooth-pie-legend-container'>"
end
if options.caption ~= "" then
html = html .. "<div class='smooth-pie-caption'>" .. options.caption .. "</div>"
end
html = html .. "\n<ol class='smooth-pie-legend'>"
for _, entry in ipairs(data) do
if not entry.error then
html = html .. priv.renderLegendItem(entry, options)
end
end
html = html .. "\n</ol>\n"
if options.footer ~= "" then
html = html .. "<div class='smooth-pie-footer'>" .. options.footer .. "</div>"
end
if options.caption ~= "" or options.footer ~= "" then
html = html .. "</div>\n"
end
return html
end
-- render legend item
function priv.renderLegendItem(entry, options)
-- invisible value (for a11y reasons this should not be used for important values!)
if entry.visible ~= nil and entry.visible == false then
return ""
end

local label = entry.label
local bcolor = entry.bcolor
local html = "\n<li>"
if p.__priv.legendDebug then
forPrinting = ""
end
html = html .. '<span class="l-color" style="'..forPrinting..bcolor..'"></span>'
html = html .. '<span class="l-label">'..label..'</span>'
return html .. "</li>"
end

-- Prepare data (slices etc)
function p.renderEntries(ok, total, data, options)
-- cache for some items (small slices)
p.cuts = mw.loadJsonData('Module:Piechart/cuts.json')

local first = true
local previous = 0
local items = ""
for index, entry in ipairs(data) do
if not entry.error then
items = items .. priv.renderItem(previous, entry, options)
previous = previous + entry.value
end
end

local header = priv.renderHeader(options)
local footer = '\n<div class="smooth-pie-border"></div></div>'

return header, items, footer
end
-- header of pie-items (class="smooth-pie")
function priv.renderHeader(options)
local bcolor = 'background:#888;color:#000'
local size = options.size

-- hide chart for readers, especially when legend is there
local aria = ""
if (options.ariahidechart) then
aria = 'aria-hidden="true"'
end

-- slices container and last slice
local style = 'width:'..size..'px;height:'..size..'px;'..bcolor..';'..forPrinting
local html = [[
<div class="smooth-pie"
style="]]..style..[["
]]..aria..[[
>]]
return html
end
-- Render pie-item
-- (previous is a sum of previous values)
function priv.renderItem(previous, entry, options)
local value = entry.value
local label = entry.label
local bcolor = entry.bcolor

-- value too small to see
if (value < 0.03) then
mw.log('value too small', value, label)
mw.addWarning("pie chart: Value too small ↆ "..value.."% ("..label..")")
return ""
end

-- minimize transformation defects
if value < 10 then
if previous > 1 then
previous = previous - 0.01
end
value = value + 0.02
else
if previous > 1 then
previous = previous - 0.1
end
value = value + 0.2
end
-- force sum to be below 100% (needed due to value errors)
if previous + value > 100 then
if previous >= 100 then
mw.log('previous is already at 100', value, label)
return ""
end
value = 100 - previous
end

local html = ""

local size = ''
-- mw.logObject({'v,p,l', value, previous, label})
if (value >= 50) then
html = priv.sliceWithClass('pie50', 50, value, previous, bcolor, label)
elseif (value >= 25) then
html = priv.sliceWithClass('pie25', 25, value, previous, bcolor, label)
elseif (value >= 12.5) then
html = priv.sliceWithClass('pie12-5', 12.5, value, previous, bcolor, label)
elseif (value >= 7) then
html = priv.sliceWithClass('pie7', 7, value, previous, bcolor, label)
elseif (value >= 5) then
html = priv.sliceWithClass('pie5', 5, value, previous, bcolor, label)
else
-- 0-5%
local cutIndex = priv.round(value*10)
if cutIndex < 1 then
cutIndex = 1
end
local cut = p.cuts[cutIndex]
local transform = priv.rotation(previous)
html = priv.sliceX(cut, transform, bcolor, label)
end
-- mw.log(html)

return html
end

-- round to int
function priv.round(number)
return math.floor(number + 0.5)
end

-- render full slice with specific class
function priv.sliceWithClass(sizeClass, sizeStep, value, previous, bcolor, label)
local transform = priv.rotation(previous)
local html = ""
html = html .. priv.sliceBase(sizeClass, transform, bcolor, label)
-- mw.logObject({'sliceWithClass:', sizeClass, sizeStep, value, previous, bcolor, label})
if (value > sizeStep) then
local extra = value - sizeStep
transform = priv.rotation(previous + extra)
-- mw.logObject({'sliceWithClass; extra, transform', extra, transform})
html = html .. priv.sliceBase(sizeClass, transform, bcolor, label)
end
return html
end

-- render single slice
function priv.sliceBase(sizeClass, transform, bcolor, label)
local style = bcolor
if transform ~= "" then
style = style .. '; ' .. transform
end
return '\n\t<div class="'..sizeClass..'" style="'..style..'" title="'..p.extract_text(label)..'"></div>'
end

-- small slice cut to fluid size.
-- range in theory: 0 to 24.(9)% reaching 24.(9)% for cut = +inf
-- range in practice: 0 to 5%
function priv.sliceX(cut, transform, bcolor, label)
local path = 'clip-path: polygon(0% 0%, '..cut..'% 0%, 0 100%)'
return '\n\t<div style="'..transform..'; '..bcolor..'; '..path..'" title="'..p.extract_text(label)..'"></div>'
end

-- translate value to turn rotation (v=100 => 1.0turn)
function priv.rotation(value)
if (value > 0.001) then
local f = string.format("%.7f", value / 100)
f = f:gsub("(%d)0+$", "%1") -- remove trailing zeros
return "transform: rotate("..f.."turn)"
end
return ''
end

-- Language sensitive float, small numbers.
function priv.formatNum(value, precision)
precision = precision or -1

local v = ""
if precision >= 0 then
-- custom format
v = string.format("%." .. precision .. "f", value)
else
-- automatic
if (value < 10) then
v = string.format("%.2f", value)
else
v = string.format("%.1f", value)
end
end

local lang = mw.language.getContentLanguage()
if (lang:getCode() == 'pl') then
v = v:gsub("%.", ",")
end
return v
end

-- Format large values.
function priv.formatLargeNum(value)
local lang = mw.language.getContentLanguage()
-- add thusands separators
local v = lang:formatNum(value)
return v
end
-- Testing formatLargeNum.
-- p.__priv.test_formatLargeNum()
function priv.test_formatLargeNum()
mw.log("must not add fractional part")
mw.log( p.__priv.formatLargeNum(12) )
mw.log( p.__priv.formatLargeNum(123) )

mw.log("should preserve fractional part for small numbers")
mw.log( p.__priv.formatLargeNum(1.1) )
mw.log( p.__priv.formatLargeNum(1.12) )
mw.log( p.__priv.formatLargeNum(12.1) )
mw.log("can preserve long fractional part")
mw.log( p.__priv.formatLargeNum(1.1234) )
mw.log( p.__priv.formatLargeNum(1.12345) )

mw.log("should add separators above 1k")
mw.log( p.__priv.formatLargeNum(999) )
mw.log( p.__priv.formatLargeNum(1234) )
mw.log( p.__priv.formatLargeNum(12345) )
mw.log( p.__priv.formatLargeNum(123456) )
mw.log( p.__priv.formatLargeNum(1234567) )

mw.log("must handle large float, but might round values")
mw.log( p.__priv.formatLargeNum(1234.123) )
mw.log( p.__priv.formatLargeNum(12345.123) )
mw.log( p.__priv.formatLargeNum(123456.123) )
mw.log( p.__priv.formatLargeNum(1234567.123) )
end

--[[
Prepare final label.

Typical tpl:
"$L: $v" (same as: "$label: $auto")
will result in:
"Abc: 23%" -- when values are percentages
"Abc: 1234 (23%)" -- when values are autoscaled

Advanced tpl:
"$L: $d ($p)" e.g. "Abc: 1234 (23%)" for {"label":"Abc", "value":1234}
"$L: $v" is the same as above when values are autoscaled

Long vs short variable names:
$label ($L)
$auto ($v)
$value ($d)
$percent ($p)
]]
function priv.prepareLabel(tpl, entry, precision)
-- setup default tpl
if not tpl or tpl == "" then
-- simple if no label
if not entry.label or entry.label == "" then
tpl = "$v"
else
if entry.label:find("%$[a-z]") then
tpl = entry.label
else
tpl = "$L: $v"
end
end
end

local labelLabel = entry.label and entry.label or priv.getLangOther()

-- format % value without %
local pRaw = priv.formatNum(entry.value, precision)
local pp = pRaw .. "%%"

local label = tpl
-- aliases
label = label
:gsub("%$label", "$L")
:gsub("%$auto", "$v")
:gsub("%$value", "$d")
:gsub("%$percent", "$p")
-- replace variables
label = label:gsub("%$L", labelLabel)
local d = priv.formatLargeNum(entry.raw and entry.raw or entry.value)
local v = entry.raw and (d .. " (" .. pp .. ")") or pp
label = label
:gsub("%$p", pp)
:gsub("%$d", d)
:gsub("%$v", v)

-- Report unknown variables
for var in label:gmatch("%$[a-zA-Z]+") do
-- in preview
mw.addWarning("pie chart: Unknown variable (wrong format of your label): " .. var)
-- tracing links
_ = mw.title.new("Module:Piechart/tracing/unknown-variable").id
end

return label
end

-- default colors
-- source: https://colorbrewer2.org/#type=diverging&scheme=PRGn&n=6
local colorGroupSize = 3 -- must be at least 3
local colorGroups = 4
local colorPalette = {
-- green (from dark)
'#1b7837',
'#7fbf7b',
'#d9f0d3',
-- violet
'#762a83',
'#af8dc3',
'#e7d4e8',
-- red
'#d73027',
'#fc8d59',
'#fee090',
-- blue
'#4575b4',
'#91bfdb',
'#e0f3f8',
}
local lastColor = '#fff'
-- background color from entry or the default colors
function priv.backColor(entry, no, total)
if (type(entry.color) == "string") then
-- Remove unsafe characters from entry.color
local sanitizedColor = entry.color
:gsub('#', '#') -- workaround Module:Political_party issue reported on talk
:gsub("[^a-zA-Z0-9#%-]", "")
return 'background:' .. sanitizedColor
else
local color = priv.defaultColor(no, total)
return 'background:' .. color
end
end
-- color from the default colors
function priv.defaultColor(no, total)
local color = lastColor
if no <= 0 then
return color
end
local size = #colorPalette
if not total or total == 0 then
total = size + 1
end
local colorNo = priv.defaultColorNo(no, total, size)
if colorNo > 0 then
color = colorPalette[colorNo]
end
return color
end
-- gets color number from default colors
-- trys to return a light color as the last one
-- 0 means white-ish color should be used
function priv.defaultColorNo(no, total, size)
local color = 0 -- special, lastColor
if total == 1 then
color = 1
elseif total <= colorGroupSize * (colorGroups - 1) then
if no < total then
color = no
else
local groupIndex = ((no - 1) % colorGroupSize)
if groupIndex == 0 then -- dark
color = no+1
elseif groupIndex == 1 then -- med
color = no+1
else
color = no
end
end
elseif no < total then
color = ((no - 1) % size) + 1
end
return color
end
--[[
Testing defaultColorNo:
p.__priv.test_defaultColorNo(1, 12)
p.__priv.test_defaultColorNo(2, 12)
p.__priv.test_defaultColorNo(3, 12)
p.__priv.test_defaultColorNo(4, 12)
p.__priv.test_defaultColorNo(5, 12)
p.__priv.test_defaultColorNo(6, 12)
]]
function priv.test_defaultColorNo(total, size)
for no=1,total do
local color = priv.defaultColorNo(no, total, size)
mw.logObject({no=no, color=color})
end
end

--[[
trim string

note:
`(s:gsub(...))` returns only a string
`s:gsub(...)` returns a string and a number
]]
function priv.trim(s)
return (s:gsub("^%s+", ""):gsub("%s+$", ""))
end

--[[
Extract text from simple wikitext.

For now only works with links.
]]
-- Tests:
-- mw.log(p.extract_text("[[candy|sweets]]: $v"))
-- mw.log(p.extract_text("[[sandwich]]es: $v"))
-- mw.log(p.extract_text("sandwich]]es: $v"))
-- mw.log(p.extract_text("sandwiches: $v"))
function p.extract_text(label)
label = label
-- replace links with pipe (e.g., [[candy|sweets]])
:gsub("%[%[[^|%]]+|(.-)%]%]", "%1")
-- replace simple links without pipe (e.g., [[sandwich]])
:gsub("%[%[(.-)%]%]", "%1")
-- remove templates?
-- :gsub("{.-}", "")
-- remove tags
:gsub("<[^>]+>", "")
-- escape special chars just in case
:gsub("<", "<"):gsub(">", ">")
:gsub("'", "'"):gsub("\"", """)
return label
end

--[[
Parse classic template params into JSON.

From:
|label1=cookies: $v |value1=11 |color1=goldenrod
|label2=sweets: $v |value2=20 |color2=darkred

To:
{"value":11,"color":"goldenrod","label":"cookies: $v"},
{"value":20,"color":"darkred","label":"sweets: $v"},

]]
function p.parseEnumParams(frame)
local args = frame:getParent().args
return priv.parseEnumParams(args)
end
function priv.parseEnumParams(args)
local result = {}

local i = 1
local sum = 0.0
local hasCustomColor = false -- has last custom color
while args["value" .. i] do
-- value is required in this mode; it's also assumed to be 0..100
local entry = { value = tonumber(args["value" .. i]) or 0 }
-- label and color is optional
local label = args["label" .. i]
if label and label ~= "" then
entry.label = label
end
hasCustomColor = false
local color = args["color" .. i]
if color and color ~= "" then
entry.color = color
hasCustomColor = true
end
table.insert(result, entry)
sum = sum + entry.value
i = i + 1
end
-- re-loop to set values in labels
local willAutoscale = priv.willAutoscale(sum)
for _, entry in ipairs(result) do
local label = entry.label
if label and not label:find("%$[a-z]") then
-- autoscale will be forced, so use $v in labels
if willAutoscale then
entry.label = label .. " $v"
else
entry.label = label .. " ($p)"
end
end
end
-- tracking data errors
priv.sumErrorTracking(sum, result)

-- support other value mapping
local langOther = priv.getLangOther()
local colorOther = "#FEFDFD" -- white-ish for custom colors for best chance and contrast

local otherValue = 100 - sum
if args["other"] and args["other"] ~= "" then
if otherValue < 0.001 then
otherValue = 0
end
local otherEntry = { label = (args["other-label"] or langOther) .. " ($p)" }
if args["other-color"] and args["other-color"] ~= "" then
otherEntry.color = args["other-color"]
else
otherEntry.color = colorOther
end
table.insert(result, otherEntry)
elseif otherValue > 0.01 then
if hasCustomColor then
table.insert(result, {visible = false, label = langOther .. " ($v)", color = colorOther})
else
table.insert(result, {visible = false, label = langOther .. " ($v)"})
end
end

local jsonString = mw.text.jsonEncode(result)
return jsonString
end

function priv.getLangOther()
-- support other value mapping
local lang = mw.language.getContentLanguage()
if (lang:getCode() == 'pl') then
return "Inne"
end
return "Other"
end

-- Function to check if a value is true-ish
local trueValues = { ["true"] = true, ["1"] = true, ["on"] = true, ["yes"] = true }
function priv.isTrueishValue(value)
-- should return nil for empty args (i.e. undefined i.e. default)
if not value or value == "" then return nil end
value = priv.trim(value)
if value == "" then return nil end
-- other non-empty are false
return trueValues[value:lower()] or false
end

--[[
Parse classic template params into JSON with chart meta data.
]]
function p.parseMetaParams(frame)
local args = frame:getParent().args
local meta = {}

-- default meta for value1..n parameters
-- ...and for thumb right/left
local thumb = args["thumb"]
if args["value1"] or (thumb and (thumb == "right" or thumb == "left")) then
meta.size = 200
meta.legend = true
end

-- explicit meta param
if args["meta"] then
local decodeSuccess, tempMeta = pcall(function()
return mw.text.jsonDecode(args["meta"], mw.text.JSON_TRY_FIXING)
end)
if not decodeSuccess then
mw.log('invalid meta parameter')
else
meta = tempMeta
end
end

if args["size"] then meta.size = tonumber(args["size"]) end
if args["radius"] and tonumber(args["radius"]) then
meta.size = 2 * tonumber(args["radius"])
end
if args["autoscale"] then meta.autoscale = priv.isTrueishValue(args["autoscale"]) end
if args["legend"] then meta.legend = priv.isTrueishValue(args["legend"]) end
if args["ariahidechart"] then meta.ariahidechart = priv.isTrueishValue(args["ariahidechart"]) end
if args["direction"] and args["direction"] ~= "" then
meta.direction = args["direction"]:gsub("[^a-z0-9%-]", "")
end
if args["width"] and args["width"] ~= "" then
meta.width = args["width"]:gsub("[^a-z0-9%-]", "")
end
if args["caption"] and args["caption"] ~= "" then
meta.caption = args["caption"]
end
if args["footer"] and args["footer"] ~= "" then
meta.footer = args["footer"]
end
if args["labelformat"] and args["labelformat"] ~= "" then
meta.labelformat = args["labelformat"]
end
if args["precision"] and args["precision"] ~= "" then
meta.precision = tonumber(args["precision"])
end

return mw.text.jsonEncode(meta)
end

return p

Module:Piechart - Revision history

RandomUser34: 1 revision imported

wp>Nux: typo • Wikiploy

← Older revision		Revision as of 05:40, 15 February 2026
(No difference)