Alex: Created page with "-- ---@class chart local chart = {} ---@class dataSet local dataSet = {} local libraryUtil = require( 'Module:libraryUtil' ) local rgba = require( 'Module:Rgba' ) local isEmpty = require( 'Module:Paramtest' ).is_empty local arr = require( 'Module:Array' ) ---@alias xyData table ---@alias xyDataSet xyData[] ---@alias dataArr number[] ---@alias options_t table ---@param val any ---@param default any ---@return a..."

2024-10-15T17:22:05Z

Created page with "-- <nowiki> ---@class chart local chart = {} ---@class dataSet local dataSet = {} local libraryUtil = require( 'Module:libraryUtil' ) local rgba = require( 'Module:Rgba' ) local isEmpty = require( 'Module:Paramtest' ).is_empty local arr = require( 'Module:Array' ) ---@alias xyData table<string, number> ---@alias xyDataSet xyData[] ---@alias dataArr number[] ---@alias options_t table<string, string|number|options_t> ---@param val any ---@param default any ---@return a..."

New page

-- <nowiki>
---@class chart
local chart = {}

---@class dataSet
local dataSet = {}

local libraryUtil = require( 'Module:libraryUtil' )
local rgba = require( 'Module:Rgba' )
local isEmpty = require( 'Module:Paramtest' ).is_empty
local arr = require( 'Module:Array' )

---@alias xyData table<string, number>
---@alias xyDataSet xyData[]
---@alias dataArr number[]
---@alias options_t table<string, string|number|options_t>

---@param val any
---@param default any
---@return any
local function default( val, default )
if val == nil or (type( val ) == 'string' and isEmpty( val )) then
return default
else
return val
end
end

---@param obj chart | dataSet
---@param options options_t
local function defaultOptions( obj, options )
local function _setOptions( tbl, options )
for k, v in pairs( options ) do
if type( v ) == 'table' and type( tbl[k] ) == 'table' then
_setOptions( tbl[k], v )
else
tbl[k] = default( tbl[k], v )
end
end
end

_setOptions( obj, options )
end

local function stripNonChartJsVariables( tbl )
local stripVarNames = {
colorPallet = true,
backgroundAlpha = true,
hoverLightenValue = true,
hoverSaturateValue = true,
hoverAlpha = true,
widthVal = true,
heightVal = true,
flippedXY = true
}

local function _strip( tbl )
for k, v in pairs( tbl ) do
if stripVarNames[k] then
tbl[k] = nil
elseif type( v ) == 'table' then
_strip( v )
end
end
end

_strip( tbl )
end

---@param tbl table
---@param seen table | nil @Only for internal use
local function stripInvalidValues( tbl, seen )
seen = seen or {}
seen[tbl] = true

for k, v in pairs( tbl ) do
if type( k ) == 'table' or type( k ) == 'function' then
tbl[k] = nil
elseif type( v ) == 'function' then
tbl[k] = nil
elseif seen[v] then
tbl[k] = nil
elseif type( v ) == 'table' then
local mt = getmetatable( v )
if mt and mt.__tostring then
tbl[k] = tostring( v )
else
stripInvalidValues( v, seen )
end
end
end

setmetatable( tbl, nil )
stripNonChartJsVariables( tbl )
end

-- =====================
-- Chart class
-- =====================
local checkChartClass = libraryUtil.makeCheckClassFunction( 'Module:Chart data' , 'chart', chart, 'chart object' )
chart.rgba = rgba
chart.colorPallets = {
qualitative = {
name = 'qualitative',
rgba.new( 166,206,227 ),
rgba.new( 31,120,180 ),
rgba.new( 178,223,138 ),
rgba.new( 51,160,44 ),
rgba.new( 251,154,153 ),
rgba.new( 227,26,28 ),
rgba.new( 253,191,111 ),
rgba.new( 255,127,0 ),
rgba.new( 202,178,214 ),
rgba.new( 106,61,154 )
},
blue = {
name = 'blue',
rgba.new( 208,209,230 ),
rgba.new( 166,189,219 ),
rgba.new( 103,169,207 ),
rgba.new( 54,144,192 ),
rgba.new( 2,129,138 ),
rgba.new( 1,108,89 ),
rgba.new( 1,70,54 )
},
green = {
name = 'green',
rgba.new( 217,240,163 ),
rgba.new( 173,221,142 ),
rgba.new( 120,198,121 ),
rgba.new( 65,171,93 ),
rgba.new( 35,132,67 ),
rgba.new( 0,104,55 ),
rgba.new( 0,69,41 )
},
blueGreen = {
name = 'blueGreen',
rgba.new( 204,236,230 ),
rgba.new( 153,216,201 ),
rgba.new( 102,194,164 ),
rgba.new( 65,174,118 ),
rgba.new( 35,139,69 ),
rgba.new( 0,109,44 ),
rgba.new( 0,68,27 )
},
orange = {
name = 'orange',
rgba.new( 254,227,145 ),
rgba.new( 254,196,79 ),
rgba.new( 254,153,41 ),
rgba.new( 236,112,20 ),
rgba.new( 204,76,2 ),
rgba.new( 153,52,4 ),
rgba.new( 102,37,6 )
}
}

local colorPalletMt = {
__index = function ( self, i ) -- Use the next color pallet if one pallet is too small for all the lines
local pallet = next( chart.colorPallets, self.name ) or next( chart.colorPallets )
pallet = chart.colorPallets[ pallet ]
return pallet[ i - #self ]
end,
__tostring = function ( t ) return t.name end
}

for _, set in pairs( chart.colorPallets ) do
if type( set ) == 'table' then
setmetatable( set, colorPalletMt )
end
end

function chart.main( frame )
return chart._main( (frame:getParent() or frame).args )
end

---@param args options_t
---@return string
function chart._main( args )
libraryUtil.checkType( 'Module:Chart_data._main', 1, args, 'table' )

local data = args

if not data.isChartObj then
local moduleName = args.dataModule or args[1]
local funcName = args['function'] or args[2]

if isEmpty( moduleName ) then
error( 'Data module was not provided or is empty' )
end

if moduleName:find( '[Mm]odule:' ) == nil then
moduleName = 'Module:' .. moduleName
end

if funcName then
data = require( moduleName )[ funcName ]( args )

assert( type( data )=='table', string.format(
"Error: function '%s' from module '%s' returned an invalid type (table expected, got %s)",
funcName, moduleName, type( data ) ) )

if data.isChartObj and not data.isFinished then
data:finish()
end
else
data = mw.loadData( moduleName )
end
end

local width = args.width or data.width or '60vw'
local height = args.height or data.height or '60vh'
local minWidth = args.minWidth or args.min_width or data.minWidth or '400px'
local minHeight = args.minHeight or args.min_height or data.minHeight or '400px'

return string.format(
'<div class="rsw-chartjs rsw-chartjs-config" style="position:relative; margin:1em 0; width:%s; height:%s; min-width:%s; min-height:%s;%s"><pre>%s</pre></div>',
width,
height,
minWidth,
minHeight,
data.resizable and ' resize:both; overflow:hidden; padding:0 5px 5px 0;' or '',
mw.text.jsonEncode( data )
)
end

---@param ys number[]
---@param xs number[] | nil
---@return xyDataSet
function chart.convertToXYFormat( ys, xs )
libraryUtil.checkType( 'Module:Chart_data.convertToXYFormat', 1, ys, 'table' )
libraryUtil.checkType( 'Module:Chart_data.convertToXYFormat', 2, xs, 'table', true )

xs = xs or {}
local ret = {}

for i,v in ipairs( ys ) do
table.insert( ret, { x=(xs[i] or i), y=v } )
end

return ret
end

---@param func function
---@param start_x number
---@param end_x number
---@param step number
---@return xyDataSet
function chart.generateXYFromFunc( func, start_x, end_x, step )
libraryUtil.checkType( 'Module:Chart_data.generateXYFromFunc', 1, func, 'function' )
libraryUtil.checkType( 'Module:Chart_data.generateXYFromFunc', 2, start_x, 'number' )
libraryUtil.checkType( 'Module:Chart_data.generateXYFromFunc', 3, end_x, 'number' )
libraryUtil.checkType( 'Module:Chart_data.generateXYFromFunc', 4, step, 'number', true )

step = step or 1
local ret = {}

for i = start_x, end_x, step do
table.insert( ret, { x=i, y=func( i ) } )
end

return ret
end

---@param low_chance number
---@param high_chance number
---@param start_level number
---@param end_level number
---@return xyDataSet
function chart.jagexInterpolation( low_chance, high_chance, start_level, end_level )
libraryUtil.checkType( 'Module:Chart_data.jagexInterpolation', 1, low_chance, 'number' )
libraryUtil.checkType( 'Module:Chart_data.jagexInterpolation', 2, high_chance, 'number' )
libraryUtil.checkType( 'Module:Chart_data.jagexInterpolation', 3, start_level, 'number' )
libraryUtil.checkType( 'Module:Chart_data.jagexInterpolation', 4, end_level, 'number' )

local function interpolate( x )
return math.floor( ( (99-x)*low_chance + (x-1)*high_chance ) / 98 )
end

return chart.generateXYFromFunc( interpolate, start_level, end_level )
end

---@param setup options_t
---@return chart
function chart.newChart( setup )
libraryUtil.checkType( 'Module:Chart_data.newChart', 1, setup, 'table', true )
local obj = setup or {}

if obj.type == 'bar' then
defaultOptions( obj, {
options = {
fill = true,
backgroundAlpha = 0.4,
hoverLightenValue = 0.95,
hoverAlpha = 0.5,
hoverSaturateValue = 1,
scales = {
x = { -- This is used for horizontal bar graphs
ticks = {
beginAtZero = true
}
},
y = {
ticks = {
beginAtZero = true
}
}
}
}
} )
elseif obj.type == 'bubble' then
defaultOptions( obj, {
options = {
fill = true,
backgroundAlpha = 0.4,
hoverLightenValue = 0.95,
hoverAlpha = 0.5,
hoverSaturateValue = 1
}
} )
elseif obj.type == 'radar' then
defaultOptions( obj, {
options = {
scale = {
ticks = {
showLabelBackdrop = false,
z = 1
}
}
}
} )
elseif obj.type == 'pie' or obj.type == 'doughnut' then
defaultOptions( obj, {
options = {
fill = true,
backgroundAlpha = 0.8,
hoverLightenValue = 0.95,
hoverAlpha = 0.9,
hoverSaturateValue = 1
}
} )
elseif obj.type == 'polarArea' then
defaultOptions( obj, {
options = {
fill = true,
backgroundAlpha = 0.5,
hoverLightenValue = 0.95,
hoverAlpha = 0.6,
hoverSaturateValue = 1,
scale = {
ticks = {
showLabelBackdrop = false,
z = 1
}
}
}
} )
end

defaultOptions( obj, {
isChartObj = true,
type = 'scatter',
widthVal = '60vw',
heightVal = '60vh',
minWidth = 400,
resizable = true,
data = {
datasets = {}
},
options = {
fill = false,
colorPallet = chart.colorPallets.qualitative,
backgroundAlpha = 0.3,
hoverLightenValue = 0.95,
hoverAlpha = 0.5,
hoverSaturateValue = 1,
maintainAspectRatio = false,
title = {
font = {
size = 18
}
},
tooltips = {
intersect = false
}
}
} )

setmetatable( obj, chart )

obj:setDimensions( obj.widthVal, obj.heightVal, obj.minWidth, obj.minHeight, obj.resizable )

return obj
end

---@vararg xyDataSet | dataArr
---@return chart
function chart:addDataSets( ... )
checkChartClass( self, 'addDataSets' )
local sets = { ... }

for i, set in ipairs( sets ) do
libraryUtil.checkType( 'chart.addDataSets', i, set, 'table' )

if not arr.contains( self.data.datasets, set, false ) then
table.insert( self.data.datasets, set )
end
end

return self
end

---@param labels string
---@return chart
function chart:addDataLabels( labels )
checkChartClass( self, 'addDataLabels' )
libraryUtil.checkType( 'Module:Chart_data.addDataLabels', 1, labels, 'table' )

self.data.labels = default( self.data.labels, {} )

for _, label in ipairs( labels ) do
table.insert( self.data.labels, label )
end

return self
end

---@param width number | string
---@param height number | string | nil
---@param minWidth number | string | nil
---@param minHeight number | string | nil
---@param resizable boolean | nil
---@return chart
function chart:setDimensions( width, height, minWidth, minHeight, resizable )
checkChartClass( self, 'setDimensions' )
libraryUtil.checkTypeMulti( 'chart.setDimensions', 1, width, {'number', 'string'} )
libraryUtil.checkTypeMulti( 'chart.setDimensions', 2, height, {'number', 'string', 'nil'} )
libraryUtil.checkTypeMulti( 'chart.setDimensions', 3, minWidth, {'number', 'string', 'nil'} )
libraryUtil.checkTypeMulti( 'chart.setDimensions', 4, minHeight, {'number', 'string', 'nil'} )
libraryUtil.checkType( 'chart.setDimensions', 5, resizable, 'boolean', true )

if type( width ) == 'number' then
self.widthVal = width
self.width = width .. 'px'
elseif type( width ) == 'string' then
self.width = width
self.widthVal = tonumber( width:match( '%d+' ) )

if type( self.widthVal ) ~= 'number' then
error( "bad argument #1 to 'chart.setDimensions' (input doesn't contain a number)", 2 )
end
else
self.widthVal = nil
self.width = ''
end

if type( height ) == 'number' then
self.heightVal = height
self.height = height .. 'px'
elseif type( height ) == 'string' then
self.height = height
self.heightVal = tonumber( height:match( '%d+' ) )

if type( self.heightVal ) ~= 'number' then
error( "bad argument #2 to 'chart.setDimensions' (input doesn't contain a number)", 2 )
end
else
self.heightVal = nil
self.height = ''
end

if type( minWidth ) == 'number' then
self.minWidth = minWidth .. 'px'
elseif type( minWidth ) == 'string' then
self.minWidth = minWidth
else
self.minWidth = nil
end

if type( minHeight ) == 'number' then
self.minHeight = minHeight .. 'px'
elseif type( minHeight ) == 'string' then
self.minHeight = minHeight
else
self.minHeight = nil
end

self.resizable = default( resizable, self.resizable )

if arr.contains( {'pie', 'doughnut', 'radar', 'polarArea'}, self.type ) then
self.height = self.width
self.minHeight = self.minWidth
self.options.aspectRatio = 1
else
if self.widthVal and self.heightVal then
self.options.aspectRatio = self.widthVal / self.heightVal
elseif self.widthVal then
self.height = self.width
self.options.aspectRatio = 1
else
self.options.aspectRatio = 1
end
end

return self
end

---@param text string | table | nil
---@param position string | nil
---@return chart
function chart:setTitle( text, position )
checkChartClass( self, 'setTitle' )
libraryUtil.checkTypeMulti( 'chart.setTitle', 1, text, {'string', 'table', 'nil'} )
libraryUtil.checkType( 'chart.setTitle', 1, position, 'string', true )

self:setOptions{
title = {
display = text and true or false,
text = text,
position = position or 'top'
}
}

return self
end

---@param label string | nil
---@return chart
function chart:setXLabel( label )
checkChartClass( self, 'setXLabel' )
libraryUtil.checkType( 'chart.setXLabel', 1, label, 'string', true )

if arr.contains( {'line', 'bar', 'bubble', 'scatter'}, self.type ) then
self:setOptions{
scales = {
x = {
scaleLabel = {
display = label and true or false,
labelString = label
}
}
}
}
end

return self
end

---@param label string | nil
---@return chart
function chart:setYLabel( label )
checkChartClass( self, 'setYLabel' )
libraryUtil.checkType( 'chart.setYLabel', 1, label, 'string', true )

if arr.contains( {'line', 'bar', 'bubble', 'scatter'}, self.type ) then
self:setOptions{
scales = {
y = {
scaleLabel = {
display = label and true or false,
labelString = label
}
}
}
}
end

return self
end

---@param min number | nil
---@param max number | nil
---@param step number | nil
---@return chart
function chart:setXLimits( min, max, step )
checkChartClass( self, 'setXLimits' )
libraryUtil.checkType( 'chart.setXLimits', 1, min, 'number', true )
libraryUtil.checkType( 'chart.setXLimits', 2, max, 'number', true )
libraryUtil.checkType( 'chart.setXLimits', 3, step, 'number', true )

if arr.contains( {'bubble', 'scatter'}, self.type ) then
self:setOptions{
scales = {
x = {
min = min,
max = max,
ticks = {
stepSize = step
}
}
}
}
end

return self
end

---@param min number | nil
---@param max number | nil
---@param step number | nil
---@return chart
function chart:setYLimits( min, max, step )
checkChartClass( self, 'setYLimits' )
libraryUtil.checkType( 'chart.setYLimits', 1, min, 'number', true )
libraryUtil.checkType( 'chart.setYLimits', 2, max, 'number', true )
libraryUtil.checkType( 'chart.setYLimits', 3, step, 'number', true )

if arr.contains( {'line', 'bar', 'bubble', 'scatter'}, self.type ) then
self:setOptions{
scales = {
y = {
min = min,
max = max,
ticks = {
stepSize = step
}
}
}
}
end

return self
end

---@param format string
---@return chart
function chart:setYFormat( format )
checkChartClass( self, 'setYFormat' )
libraryUtil.checkType( 'chart.setYFormat', 1, format, 'string', true )

self:setOptions{
scales = {
y = {
ticks = {
format = format
}
}
}
}

return self
end

---@param min number | nil
---@param max number | nil
---@param step number | nil
---@return chart
function chart:setRadialLimits( min, max, step )
checkChartClass( self, 'setRadialLimits' )
libraryUtil.checkType( 'chart.setRadialLimits', 1, min, 'number', true )
libraryUtil.checkType( 'chart.setRadialLimits', 2, max, 'number', true )
libraryUtil.checkType( 'chart.setRadialLimits', 3, step, 'number', true )

if arr.contains( {'radar', 'polarArea'}, self.type ) then
self:setOptions{
scale = {
min = min,
max = max,
ticks = {
stepSize = step
}
}
}
end

return self
end

---@param type string | nil
---@return chart
function chart:setXAxisType( type )
checkChartClass( self, 'setXAxisType' )
libraryUtil.checkType( 'chart.setXAxisType', 1, type, 'string', true )

if arr.contains( {'bar', 'bubble', 'line', 'scatter'}, self.type ) then
self:setOptions{
scales = {
x = {
type = type
}
}
}
end

return self
end

---@param type string | nil
---@return chart
function chart:setYAxisType( type )
checkChartClass( self, 'setYAxisType' )
libraryUtil.checkType( 'chart.setYAxisType', 1, type, 'string', true )

if arr.contains( {'bar', 'bubble', 'line', 'scatter'}, self.type ) then
self:setOptions{
scales = {
y = {
type = type
}
}
}
end

return self
end

---@param val boolean
---@return chart
function chart:showLegend( val )
checkChartClass( self, 'showLegend' )
libraryUtil.checkType( 'chart.showLegend', 1, val, 'boolean' )

self:setOptions{
legend = {
display = val
}
}

return self
end

---@param format string
---@return chart
function chart:setTooltipFormat( format )
checkChartClass( self, 'setTooltipFormat' )
libraryUtil.checkType( 'chart.setTooltipFormat', 1, format, 'string', true )

self:setOptions{
tooltips = {
format = format
}
}

return self
end

---@param count number
---@return chart
function chart:setDatasetsPerGroup( count )
checkChartClass( self, 'setDatasetsPerGroup' )
libraryUtil.checkType( 'chart.setDatasetsPerGroup', 1, label, 'number', true )

self:setOptions{
datasetsPerGroup = count
}

return self
end

---@return chart
function chart:flipXY()
checkChartClass( self, 'flipXY' )

if self.type == 'bar' then
self:setXAxisType( 'linear' )
:setYAxisType( 'category' )
:setOptions{
scales = {
x = {
offset = false,
gridLines = {
offsetGridLines = false
}
}
}
}

self.flippedXY = true

for _, v in ipairs( self.data.datasets ) do
v.indexAxis = 'y'
end
end

return self
end

---@param options options_t
---@return chart
function chart:setOptions( options )
checkChartClass( self, 'setOptions' )
libraryUtil.checkType( 'chart.setOptions', 1, options, 'table' )

local function _setOptions( tbl, options )
for k, v in pairs( options ) do
if type( v ) == 'table' and type( tbl[k] ) == 'table' then
_setOptions( tbl[k], v )
else
tbl[k] = v
end
end
end

_setOptions( self.options, options )

return self
end

---@return string | table
function chart:finish()
checkChartClass( self, 'finish' )

for i, set in ipairs( self.data.datasets ) do
if (self.options.colorPallet or set.colorPallet) and
self.options.backgroundAlpha and
self.options.hoverLightenValue and
self.options.hoverSaturateValue and
self.options.hoverAlpha
then
if arr.contains( {'bar', 'pie', 'doughnut', 'polarArea'}, self.type ) then
if set.color and not set.colorPallet then
set.borderColor = tostring( set.color )
set.hoverBorderColor = tostring( set.color:lighten( self.options.hoverLightenValue )
:saturate( self.options.hoverSaturateValue ) )

set.backgroundColor = tostring( set.color:fade( self.options.backgroundAlpha ) )
set.hoverBackgroundColor = tostring( set.color:lighten( self.options.hoverLightenValue )
:saturate( self.options.hoverSaturateValue )
:fade( self.options.hoverAlpha ) )
else
set.borderColor = {}
set.hoverBorderColor = {}
set.backgroundColor = {}
set.hoverBackgroundColor = {}

local pallet = default( set.colorPallet, self.options.colorPallet )

for j = 1, #set.data do
table.insert( set.borderColor, tostring( pallet[j] ) )
table.insert( set.hoverBorderColor,
tostring( pallet[j]:lighten( self.options.hoverLightenValue )
:saturate( self.options.hoverSaturateValue ) ) )

table.insert( set.backgroundColor, tostring( pallet[j]:fade( self.options.backgroundAlpha ) ) )
table.insert( set.hoverBackgroundColor,
tostring( pallet[j]:lighten( self.options.hoverLightenValue )
:saturate( self.options.hoverSaturateValue )
:fade( self.options.hoverAlpha ) ) )
end
end
else
local pallet = default( set.colorPallet, self.options.colorPallet )
set.borderColor = default( set.borderColor, pallet[i] )

if not set.hoverBorderColor then
set.hoverBorderColor = set.borderColor:lighten( self.options.hoverLightenValue )
:saturate( self.options.hoverSaturateValue )
end

set.backgroundColor =
default( set.backgroundColor, self.options.colorPallet[i]:fade( self.options.backgroundAlpha ) )

if not set.hoverBackgroundColor then
set.hoverBackgroundColor = set.backgroundColor:lighten( self.options.hoverLightenValue )
:saturate( self.options.hoverSaturateValue )
:fade( self.options.hoverAlpha )
end

set.fill = default( default( set.fill, self.options.fill ), false )
end
end
end

stripInvalidValues( self )
self.isFinished = true

return self
end

---@return string
function chart:tostring()
checkChartClass( self, 'tostring' )
self:finish()
return chart._main( self )
end

function chart:debug()
checkChartClass( self, 'debug' )
local temp = colorPalletMt.__index -- By design this makes the color pallet tables behave like they are infinitely long,
-- so we have to turn this off first
local temp2 = chart.__tostring -- Prevent chart from being turned into a json
colorPalletMt.__index = nil
chart.__tostring = nil
mw.logObject( self )
colorPalletMt.__index = temp
chart.__tostring = temp2
end

chart.__index = chart
chart.__tostring = chart.tostring
chart.__concat = function( x, y )
return tostring( x ) .. tostring( y )
end

-- =======================
-- DataSet class
-- =======================
local checkDataSetClass = libraryUtil.makeCheckClassFunction( 'Module:Chart data' , 'dataSet', dataSet, 'dataSet object' )

---@param setup options_t
---@return dataSet
function chart:newDataSet( setup )
checkChartClass( self, 'newDataSet' )
libraryUtil.checkType( 'chart.newDataSet', 1, setup, 'table', true )
local obj = setup or {}

if self.type == 'scatter' then
obj.showLine = default( obj.showLine, true )
end

if self.type == 'bar' then
obj.borderWidth = default( obj.borderWidth, 1 )

if self.flippedXY then
obj.indexAxis = 'y'
end
end

obj.data = default( obj.data, {} )
obj.clip = 5
obj.parent = self

self:addDataSets( obj )

return setmetatable( obj, dataSet )
end

---@param data xyDataSet | dataArr
---@return dataSet
function dataSet:addData( data )
checkDataSetClass( self, 'addData' )
libraryUtil.checkType( 'dataSet.addData', 1, data, 'table' )

for _, v in ipairs( data ) do
table.insert( self.data, v )
end

return self
end

---@param data xyData | number
---@return dataSet
function dataSet:addDataPoint( data )
checkDataSetClass( self, 'addDataPoint' )
libraryUtil.checkTypeMulti( 'dataSet.addDataPoint', 1, data, {'table', 'number'} )
table.insert( self.data, data )

return self
end

---@param options options_t
---@return dataSet
function dataSet:setOptions( options )
checkDataSetClass( self, 'setOptions' )
libraryUtil.checkType( 'dataSet.setOptions', 1, options, 'table' )

local function _setOptions( tbl, options )
for k, v in pairs( options ) do
if type( v ) == 'table' and type( tbl[k] ) == 'table' then
_setOptions( tbl[k], v )
else
tbl[k] = v
end
end
end

_setOptions( self, options )

return self
end

---@return chart
function dataSet:done()
checkDataSetClass( self, 'done' )
return self.parent
end

dataSet.__index = dataSet

return chart
-- </nowiki>

Module:Chart data - Revision history