charts

package module
v0.0.0-...-816fd83 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 12, 2017 License: MIT Imports: 2 Imported by: 0

README

GopherJS bindings for frappe/charts

Go Report Card GoDoc

"Simple, responsive, modern SVG Charts with zero dependencies"

This library provides a type-safe, builder-based API for the simple and awesome frappe/charts.

Event listener with navigable bar chart:

Alt text

Various chart operations (append, remove, pop) with (mock "realtime") randomized data and actions:

Alt text

Contents

Installation

Built on go 1.9

go get -u github.com/cnguy/gopherjs-frappe-charts

Make sure you also have the necessary JS files.

Currently, this API supports frappe/charts@0.0.7 (maybe 0.0.8 too, since it seems that they didn't change the API in that version).

Dependencies will be managed via dep in the future.

Unfortunately, gopherjs is not vendorable at the moment.

Breaking Changes

This libary seeks to be updated to always work with the latest version of frappe charts. It also seeks to have a clean API so that users can easily bring in charts into their GopherJS-based website. One can also expect that this library will improve as I improve at Go.

Frappe hasn't changed their API dramatically so far, so one can expect that this library won't change dramatically as well. If there are breaking changes, it should be easy to update one's code by simply following the type errors.

The Bare Minimum

Following examples assume an HTML file like so:

<!DOCTYPE html>
<html>
<head>
	<meta charset="utf-8">
	<title>GopherJS bindings for frappe-charts</title>
</head>
<body>
	<div id="chart"></div>
	<div id="chart-2"></div>
	<div id="heatmap"></div>
	<script src="https://unpkg.com/frappe-charts@0.0.7/dist/frappe-charts.min.iife.js"></script>
	<script src="static.js" data-cover></script>
</body>
</html>

where static.js is the name of your bundled JS file when your folder is named static and you run gopherjs build.

package main

import (
	charts "github.com/cnguy/gopherjs-frappe-charts"
)

func main() {
	chartData := charts.NewChartData()
	chartData.Labels = []string{
		"1", "2", "3",
	}
	chartData.Datasets = []*charts.Dataset{
		charts.NewDataset(
			"Some Data",
			[]float64{25, 40, 30},
		),
		charts.NewDataset(
			"Another Set",
			[]float64{25, 50, -10},
		),
	}

	_ = charts.NewBarChart("#chart", chartData).Render()
}

Alt text

This is the bare minimum needed to create a chart. Try swapping NewBarChart with other functions such as NewPercentageChart or NewPieChart.

frappe already sets defaults for a lot of properties. All New${Type}Chart calls handles the two necessary properties (the title and the chart data).

Everything else is optional (the title, colors, etc).

To learn how to provide more arguments, scroll down to Usage.

Usage

Simply declare chart data via NewChartData() and pass in array of *Datasets constructed by NewDataset().

This data can then be passed in to 99% of the charts (Heatmap is different).

This library uses the builder pattern to handle optional configurations. Every chart can be immediately rendered simply by doing

NewSomeChart("#parent", myData).Render()

If you would like to use optional configuration, check out the docs or simply just use your IDE (NewSomeChart returns a chainable object).

Tip: Prefer using the helpers instead of struct literals.

Hello World:
package main

import (
	charts "github.com/cnguy/gopherjs-frappe-charts"
)

func main() {
	// Prepare data
	chartData := charts.NewChartData()
	chartData.Labels = []string{
		"12am-3am", "3am-6pm", "6am-9am", "9am-12am",
		"12pm-3pm", "3pm-6pm", "6pm-9pm", "9am-12am",
	}
	chartData.Datasets = []*charts.Dataset{
		charts.NewDataset(
			"Some Data",
			[]float64{25, 40, 30, 35, 8, 52, 17, -4},
		),
		charts.NewDataset(
			"Another Set",
			[]float64{25, 50, -10, 15, 18, 32, 27, 14},
		),
	}

	chart := charts.NewBarChart("#chart", chartData).
		WithHeight(250). // `150` is default if this call is not applied.
		WithColors([]string{"light-blue", "violet"}).
		Render() // not calling Render returns a XXXChartArgs instance instead

	// TIP: Try swapping NewBarChart with NewPercentageChart or NewScatterChart
	// to see how easy it is to swap to a different type of chart.
	println(chart) // to suppress the annoying error
}

Output 1:

Alt text

Navigable:
package main

import (
	charts "github.com/cnguy/gopherjs-frappe-charts"
)

func main() {
	// Prepare data
	chartData := charts.NewChartData()
	chartData.Labels = []string{
		"2007", "2008", "2009", "2010", "2011", "2012", "2013", "2014", "2015", "2016", "2017",
	}
	values := []float64{17, 40, 33, 44, 126, 156, 324, 333, 478, 495, 373}
	dataset := charts.NewDataset("Events", values)
	chartData.Datasets = []*charts.Dataset{dataset}

	chartTitle := "Fireball/Bolide Events - Yearly (more than 5 reports)"
	chart := charts.NewBarChart("#chart", chartData).
		WithTitle(chartTitle).
		WithColors([]string{"orange"}).
		SetIsNavigable(true). // ChartArgs#IsNavigable = 1
		SetIsSeries(true).    // ChartArgs#IsSeries = 1
		Render()

	println(chart)
}

Output 2:

Using left/right arrow keys to traverse the graph

Alt text

Line Properties:
package main

import (
	charts "github.com/cnguy/gopherjs-frappe-charts"
	chartsUtils "github.com/cnguy/gopherjs-frappe-charts/utils"
)

func main() {
	// Prepare data
	chartData := charts.NewChartData()
	chartData.Labels = chartsUtils.NumberLabelsToStr([]int{
		1967, 1968, 1969, 1970, 1971, 1972, 1973, 1974, 1975, 1976,
		1977, 1978, 1979, 1980, 1981, 1982, 1983, 1984, 1985, 1986,
		1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
		1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
		2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016,
	})
	values := []float64{
		132.9, 150.0, 149.4, 148.0, 94.4, 97.6, 54.1, 49.2, 22.5, 18.4,
		39.3, 131.0, 220.1, 218.9, 198.9, 162.4, 91.0, 60.5, 20.6, 14.8,
		33.9, 123.0, 211.1, 191.8, 203.3, 133.0, 76.1, 44.9, 25.1, 11.6,
		28.9, 88.3, 136.3, 173.9, 170.4, 163.6, 99.3, 65.3, 45.8, 24.7,
		12.6, 4.2, 4.8, 24.9, 80.8, 84.5, 94.0, 113.3, 69.8, 39.8,
	}
	dataset := charts.NewDataset("", values)
	chartData.Datasets = []*charts.Dataset{dataset}

	chartTitle := "Mean Total Sunspot Count - Yearly"
	chart := charts.NewLineChart("#chart", chartData).
		WithTitle(chartTitle).
		WithColors([]string{"blue"}).
		SetShowDots(false).
		SetHeatline(true).
		SetRegionFill(true).
		SetXAxisMode("tick").
		SetYAxisMode("span").
		SetIsSeries(true).
		Render()

	println(chart)
}

Output 3:

Alt text

Simple Aggregations:
package main

import (
	"time"

	charts "github.com/cnguy/gopherjs-frappe-charts"
)

func main() {
	chartData := charts.NewChartData()
	chartData.Labels = []string{
		"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat",
	}
	chartData.Datasets = []*charts.Dataset{
		charts.NewDataset("", []float64{25, 40, 30, 35, 8, 52, 17}),
		charts.NewDataset("", []float64{25, 50, -10, 15, 18, 32, 27}),
	}

	chart := charts.NewBarChart("#chart", chartData).
		WithColors([]string{"purple", "orange"}).
		Render()

	time.Sleep(1 * time.Second)
	chart.ShowSums()

	time.Sleep(1 * time.Second)
	chart.HideSums()

	time.Sleep(1 * time.Second)
	chart.ShowAverages()

	time.Sleep(1 * time.Second)
	chart.HideAverages()
}

Output 4:

Alt text

Event Listener:
package main

import (
	charts "github.com/cnguy/gopherjs-frappe-charts"
)

func main() {
	// Make bar chart
	reportCountList := []float64{17, 40, 33, 44, 126, 156,
		324, 333, 478, 495, 373}
	barChartData := charts.NewChartData()
	barChartData.Labels = []string{
		"2007", "2008", "2009", "2010", "2011", "2012",
		"2013", "2014", "2015", "2016", "2017",
	}
	barChartData.Datasets = []*charts.Dataset{
		charts.NewDataset("Events", reportCountList),
	}
	barChartTitle := "Fireball/Bolide Events - Yearly (more than 5 reports"
	barChart := charts.NewBarChart("#chart", barChartData).
		WithTitle(barChartTitle).
		WithHeight(180).
		WithColors([]string{"orange"}).
		SetIsNavigable(true).
		SetIsSeries(true).
		Render()

	// Make line chart
	lineChartValues := []float64{36, 46, 45, 32, 27, 31, 30, 36, 39, 49, 0, 0}
	lineChartData := charts.NewChartData()
	lineChartData.Labels = []string{
		"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
	}
	lineChartData.Datasets = []*charts.Dataset{
		charts.NewDataset("", lineChartValues),
	}
	lineChart := charts.NewLineChart("#chart-2", lineChartData).
		WithHeight(180).
		WithColors([]string{"green"}).
		SetIsSeries(true).
		Render()

	// Prepare update values for event listener
	moreLineData := []*charts.UpdateValueSet{
		charts.NewUpdateValueSet([]float64{4, 0, 3, 1, 1, 2, 1, 2, 1, 0, 1, 1}),
		charts.NewUpdateValueSet([]float64{2, 3, 3, 2, 1, 4, 0, 1, 2, 7, 11, 4}),
		charts.NewUpdateValueSet([]float64{7, 7, 2, 4, 0, 1, 5, 3, 1, 2, 0, 1}),
		charts.NewUpdateValueSet([]float64{0, 2, 6, 2, 2, 1, 2, 3, 6, 3, 7, 10}),
		charts.NewUpdateValueSet([]float64{9, 10, 8, 10, 6, 5, 8, 8, 24, 15, 10, 13}),
		charts.NewUpdateValueSet([]float64{9, 13, 16, 9, 4, 5, 7, 10, 14, 22, 23, 24}),
		charts.NewUpdateValueSet([]float64{20, 22, 28, 19, 28, 19, 14, 19, 51, 37, 29, 38}),
		charts.NewUpdateValueSet([]float64{29, 20, 22, 16, 16, 19, 24, 26, 57, 31, 46, 2}),
		charts.NewUpdateValueSet([]float64{36, 24, 38, 27, 15, 22, 24, 38, 32, 57, 139, 26}),
		charts.NewUpdateValueSet([]float64{37, 36, 32, 33, 12, 34, 52, 45, 58, 57, 64, 35}),
		charts.NewUpdateValueSet([]float64{36, 46, 45, 32, 27, 31, 30, 36, 39, 49, 0, 0}),
	}

	barChart.AddDataSelectListener(func(event *charts.DataSelectEvent) {
		updateValues := &charts.UpdateValuesArgs{
			Values: []*charts.UpdateValueSet{moreLineData[event.Index]},
			// keep labels same as before
			Labels: lineChartData.Labels,
		}
		lineChart.UpdateValues(updateValues)
	})
}

Output 5:

Alt text

Heatmaps
package main

import (
	"math/rand"
	"strconv"

	charts "github.com/cnguy/gopherjs-frappe-charts"
)

func main() {
	data := make(map[string]int)
	currentTimestamp := 1477699200
	for i := 0; i < 375; i++ {
		data[strconv.Itoa(currentTimestamp)] = rand.Intn(10)
		currentTimestamp += 86400
	}
	charts.NewHeatmapChart("#chart", data).
		WithHeight(115).
		/* Halloween colors */
		// WithLegendColors([]string{"#ebedf0", "#fdf436", "#ffc700", "#ff9100", "#06001c"}).
		Render()
}
With discrete domains set to default

Alt text

With discrete domains set to 1 via chartArgs.SetDiscreteDomain(true)

Alt text

With different colors

Alt text

Realtime
package main

import (
	"math/rand"
	"strconv"
	"time"

	charts "github.com/cnguy/gopherjs-frappe-charts"
)

func main() {
	chartData := charts.NewChartData()
	chartData.Labels = []string{
		"1", "2", "3",
	}
	chartData.Datasets = []*charts.Dataset{
		charts.NewDataset(
			"Some Data",
			[]float64{25, 40, 30},
		),
		charts.NewDataset(
			"Another Set",
			[]float64{25, 50, -10},
		),
	}

	chart := charts.NewScatterChart("#chart", chartData).
		WithHeight(250).
		WithColors([]string{"red", "green"}).
		Render()
	temp := 4
	for i := 0; i < 100; i++ {
		go func(i interface{}) {
			val := rand.Intn(3) + 2*i.(int)
			println(i, "sleeping for", val)
			time.Sleep(time.Duration(val) * time.Second)
			newLabel := strconv.Itoa(temp)
			actionCond := rand.Intn(4)
			switch actionCond {
			case 0:
				chart.RemoveDataPoint(rand.Int())
			case 1:
				chart.PopDataPoint()
			case 2:
				chart.AppendDataPoint([]float64{float64(rand.Intn(1000)), float64(rand.Intn(1000))}, newLabel)
			case 3:
				chart.AddDataPoint([]float64{float64(rand.Intn(200)), float64(rand.Intn(200))}, newLabel, rand.Intn(200))
			}
			temp++
			println(temp)
		}(i)
	}

	println("is this async?")
}

Output 6:

Alt text

Disclaimer

I'm still a big Go noob, and so I don't know the proper way to manage releases and dependencies yet. I'll try to figure it out soon!

Contributions

Any contributions are welcome. :)

Changelog

here when available

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type BarChart 

type BarChart struct {
	*js.Object
}

func (*BarChart) AddDataPoint 

func (chart *BarChart) AddDataPoint(values []float64, label string, index int)

func (*BarChart) AddDataSelectListener 

func (chart *BarChart) AddDataSelectListener(fn eventListenerCallback)

AddDataSelectListener is a helper function to allow users to quickly set a data-select event. This allows users to access the index, value, and label of any particular data point!

func (*BarChart) AddEventListener 

func (chart *BarChart) AddEventListener(eventName string, fn eventListenerCallback)

func (*BarChart) AppendDataPoint 

func (chart *BarChart) AppendDataPoint(values []float64, label string)

func (*BarChart) HideAverages 

func (chart *BarChart) HideAverages()

func (*BarChart) HideSums 

func (chart *BarChart) HideSums()

func (*BarChart) PopDataPoint 

func (chart *BarChart) PopDataPoint()

func (*BarChart) RemoveDataPoint 

func (chart *BarChart) RemoveDataPoint(index int)

func (*BarChart) ShowAverages 

func (chart *BarChart) ShowAverages()

func (*BarChart) ShowSums 

func (chart *BarChart) ShowSums()

func (*BarChart) UpdateValues 

func (chart *BarChart) UpdateValues(updateValues *UpdateValuesArgs)

type BarChartArgs 

type BarChartArgs struct {
	*js.Object
	Parent         string              `js:"parent"`
	Title          string              `js:"title"`
	Data           *ChartData          `js:"data"`
	Type           string              `js:"type"`
	Height         int                 `js:"height"`
	Colors         []string            `js:"colors"`
	XAxisMode      string              `js:"x_axis_mode"`
	YAxisMode      string              `js:"y_axis_mode"`
	IsSeries       int                 `js:"is_series"`
	IsNavigable    int                 `js:"is_navigable"`
	FormatTooltipX func(string) string `js:"format_tooltip_x"`
	FormatTooltipY func(string) string `js:"format_tooltip_y"`
}

func NewBarChart 

func NewBarChart(parent string, data *ChartData) *BarChartArgs

func (*BarChartArgs) Render 

func (chartArgs *BarChartArgs) Render() *BarChart

func (*BarChartArgs) SetBton 

func (chartArgs *BarChartArgs) SetBton(key string, val bool)

func (*BarChartArgs) SetIsNavigable 

func (chartArgs *BarChartArgs) SetIsNavigable(val bool) *BarChartArgs

func (*BarChartArgs) SetIsSeries 

func (chartArgs *BarChartArgs) SetIsSeries(val bool) *BarChartArgs

func (*BarChartArgs) SetXAxisMode 

func (chartArgs *BarChartArgs) SetXAxisMode(mode string) *BarChartArgs

func (*BarChartArgs) SetYAxisMode 

func (chartArgs *BarChartArgs) SetYAxisMode(mode string) *BarChartArgs

func (*BarChartArgs) WithColors 

func (chartArgs *BarChartArgs) WithColors(colors []string) *BarChartArgs

func (*BarChartArgs) WithFormatTooltipX 

func (chartArgs *BarChartArgs) WithFormatTooltipX(callback func(string) string) *BarChartArgs

func (*BarChartArgs) WithFormatTooltipY 

func (chartArgs *BarChartArgs) WithFormatTooltipY(callback func(string) string) *BarChartArgs

func (*BarChartArgs) WithHeight 

func (chartArgs *BarChartArgs) WithHeight(height int) *BarChartArgs

func (*BarChartArgs) WithTitle 

func (chartArgs *BarChartArgs) WithTitle(title string) *BarChartArgs

type ChartData 

type ChartData struct {
	*js.Object
	Labels         []string         `js:"labels"`
	Datasets       []*Dataset       `js:"datasets"`
	SpecificValues []*SpecificValue `js:"specific_values"`
}

ChartData represents the "data" object that is passed into any of the charts except Heatmap. https://frappe.github.io/charts/ Ctrl + F "let data ="

func NewChartData 

func NewChartData() *ChartData

NewChartData just instantiates a ChartData JS object.

type DataSelectEvent 

type DataSelectEvent struct {
	*js.Object
	Value interface{} `js:"value"`
	Label interface{} `js:"label"`
	Index int         `js:"index"`
}

type Dataset 

type Dataset struct {
	*js.Object
	Title  string        `js:"title"`
	Values []interface{} `js:"values"`
}

Dataset represents a single dataset of the JS object 'data'. https://frappe.github.io/charts/ Ctrl + F "datasets". Wrap this inside a dataset array.

func NewDataset 

func NewDataset(title string, values []float64) (dataset *Dataset)

NewDataset allows us to quickly create Dataset objects with the required values.

type HeatmapArgs 

type HeatmapArgs struct {
	*js.Object
	Parent          string                 `js:"parent"`
	Data            map[string]interface{} `js:"data"`
	Type            string                 `js:"type"`
	Height          int                    `js:"height"`
	DiscreteDomains int                    `js:"discrete_domains"`
	Start           *js.Object             `js:"start"` // TODO
	LegendColors    []string               `js:"legend_colors"`
}

func NewHeatmapChart 

func NewHeatmapChart(parent string, data map[string]int) *HeatmapArgs

func (*HeatmapArgs) Render 

func (chartArgs *HeatmapArgs) Render()

func (*HeatmapArgs) SetDiscreteDomain 

func (chartArgs *HeatmapArgs) SetDiscreteDomain(val bool) *HeatmapArgs

func (*HeatmapArgs) WithHeight 

func (chartArgs *HeatmapArgs) WithHeight(height int) *HeatmapArgs

func (*HeatmapArgs) WithLegendColors 

func (chartArgs *HeatmapArgs) WithLegendColors(colors []string) *HeatmapArgs

type LineChart 

type LineChart struct {
	*js.Object
}

func (*LineChart) AddDataPoint 

func (chart *LineChart) AddDataPoint(values []float64, label string, index int)

AddDataPoint allows us to add a data point to anywhere in the chart.

func (*LineChart) AppendDataPoint 

func (chart *LineChart) AppendDataPoint(values []float64, label string)

AppendDataPoint calls add_data_point without an index (which defaults to the end).

func (*LineChart) HideAverages 

func (chart *LineChart) HideAverages()

HideAverages simply hides the averages displayed using ShowAverages.

func (*LineChart) PopDataPoint 

func (chart *LineChart) PopDataPoint()

PopDataPoint calls remove_data_point without arguments, which defaults to removing the element at index 0.

func (*LineChart) RemoveDataPoint 

func (chart *LineChart) RemoveDataPoint(index int)

RemoveDataPoint allows users to remove a data point anywhere in the array.

func (*LineChart) ShowAverages 

func (chart *LineChart) ShowAverages()

ShowAverages calls show_averages which makes a new horizontal line representing the average for every dataset.

func (*LineChart) UpdateValues 

func (chart *LineChart) UpdateValues(updateValues *UpdateValuesArgs)

UpdateValues allows us to batch update the values of the chart. Make sure to pass in the original labels if you want to keep the structure of your chart. This should be improved.

type LineChartArgs 

type LineChartArgs struct {
	*js.Object
	Parent         string              `js:"parent"`
	Title          string              `js:"title"`
	Data           *ChartData          `js:"data"`
	Type           string              `js:"type"`
	Height         int                 `js:"height"`
	Colors         []string            `js:"colors"`
	XAxisMode      string              `js:"x_axis_mode"`
	YAxisMode      string              `js:"y_axis_mode"`
	IsSeries       int                 `js:"is_series"`
	ShowDots       int                 `js:"show_dots"`
	Heatline       int                 `js:"heatline"`
	RegionFill     int                 `js:"region_fill"`
	FormatTooltipX func(string) string `js:"format_tooltip_x"`
	FormatTooltipY func(string) string `js:"format_tooltip_y"`
}

LineChartArgs represents the configuration arguments that can be used to instantiate a line chart.

func NewLineChart 

func NewLineChart(parent string, data *ChartData) *LineChartArgs

func (*LineChartArgs) Render 

func (chartArgs *LineChartArgs) Render() *LineChart

Render returns a LineChart that allows users to call the above functions.

func (*LineChartArgs) SetBton 

func (chartArgs *LineChartArgs) SetBton(key string, val bool)

func (*LineChartArgs) SetHeatline 

func (chartArgs *LineChartArgs) SetHeatline(val bool) *LineChartArgs

SetHeatline allows us to set heatline using a boolean instead of 1/0's.

func (*LineChartArgs) SetIsSeries 

func (chartArgs *LineChartArgs) SetIsSeries(val bool) *LineChartArgs

SetIsSeries allows us to set is_series using a boolean instead of 1/0's.

func (*LineChartArgs) SetRegionFill 

func (chartArgs *LineChartArgs) SetRegionFill(val bool) *LineChartArgs

SetRegionFill allows us to set region_fill using a boolean instead of 1/0's.

func (*LineChartArgs) SetShowDots 

func (chartArgs *LineChartArgs) SetShowDots(val bool) *LineChartArgs

SetShowDots allows us to set show_dots using a boolean instead of 1/0's.

func (*LineChartArgs) SetXAxisMode 

func (chartArgs *LineChartArgs) SetXAxisMode(mode string) *LineChartArgs

func (*LineChartArgs) SetYAxisMode 

func (chartArgs *LineChartArgs) SetYAxisMode(mode string) *LineChartArgs

func (*LineChartArgs) WithColors 

func (chartArgs *LineChartArgs) WithColors(colors []string) *LineChartArgs

func (*LineChartArgs) WithFormatTooltipX 

func (chartArgs *LineChartArgs) WithFormatTooltipX(callback func(string) string) *LineChartArgs

func (*LineChartArgs) WithFormatTooltipY 

func (chartArgs *LineChartArgs) WithFormatTooltipY(callback func(string) string) *LineChartArgs

func (*LineChartArgs) WithHeight 

func (chartArgs *LineChartArgs) WithHeight(height int) *LineChartArgs

func (*LineChartArgs) WithTitle 

func (chartArgs *LineChartArgs) WithTitle(title string) *LineChartArgs

type PercentageChartArgs 

type PercentageChartArgs struct {
	*js.Object
	Parent string     `js:"parent"`
	Title  string     `js:"title"`
	Data   *ChartData `js:"data"`
	Type   string     `js:"type"`
	Height int        `js:"height"`
	Colors []string   `js:"colors"`
}

PercentageChartArgs represents the args needed to instantiate a percentage chart. PercentageChart does not have as many configuration arguments as other charts in frappe-charts.

func NewPercentageChart 

func NewPercentageChart(parent string, data *ChartData) *PercentageChartArgs

func (*PercentageChartArgs) Render 

func (chartArgs *PercentageChartArgs) Render()

Render simply renders a percentage chart without returning anything, because percentage charts don't seem to have any methods yet (in 0.0.3 frappe-charts).

func (*PercentageChartArgs) WithColors 

func (chartArgs *PercentageChartArgs) WithColors(colors []string) *PercentageChartArgs

func (*PercentageChartArgs) WithHeight 

func (chartArgs *PercentageChartArgs) WithHeight(height int) *PercentageChartArgs

func (*PercentageChartArgs) WithTitle 

func (chartArgs *PercentageChartArgs) WithTitle(title string) *PercentageChartArgs

type PieChartArgs 

type PieChartArgs struct {
	*js.Object
	Parent string     `js:"parent"`
	Title  string     `js:"title"`
	Data   *ChartData `js:"data"`
	Type   string     `js:"type"`
	Height int        `js:"height"`
	Colors []string   `js:"colors"`
}

PieChartArgs represents the args needed to instantiate a pie chart. PieChart does not have as many configuration arguments as other charts in frappe-charts.

func NewPieChart 

func NewPieChart(parent string, data *ChartData) *PieChartArgs

func (*PieChartArgs) Render 

func (chartArgs *PieChartArgs) Render()

Render simply renders a pie chart without returning anything, because pie charts don't seem to have any methods yet (in 0.0.3 frappe-charts).

func (*PieChartArgs) WithColors 

func (chartArgs *PieChartArgs) WithColors(colors []string) *PieChartArgs

func (*PieChartArgs) WithHeight 

func (chartArgs *PieChartArgs) WithHeight(height int) *PieChartArgs

func (*PieChartArgs) WithTitle 

func (chartArgs *PieChartArgs) WithTitle(title string) *PieChartArgs

type ScatterChart 

type ScatterChart struct {
	*js.Object
}

func (*ScatterChart) AddDataPoint 

func (chart *ScatterChart) AddDataPoint(values []float64, label string, index int)

func (*ScatterChart) AppendDataPoint 

func (chart *ScatterChart) AppendDataPoint(values []float64, label string)

func (*ScatterChart) HideAverages 

func (chart *ScatterChart) HideAverages()

HideAverages simply hides the averages displayed using ShowAverages.

func (*ScatterChart) PopDataPoint 

func (chart *ScatterChart) PopDataPoint()

PopDataPoint calls remove_data_point without arguments, which defaults to removing the element at index 0.

func (*ScatterChart) RemoveDataPoint 

func (chart *ScatterChart) RemoveDataPoint(index int)

RemoveDataPoint allows users to remove a data point anywhere in the array.

func (*ScatterChart) ShowAverages 

func (chart *ScatterChart) ShowAverages()

ShowAverages calls show_averages which makes a new horizontal line representing the average for every dataset.

func (*ScatterChart) UpdateValues 

func (chart *ScatterChart) UpdateValues(updateValues *UpdateValuesArgs)

type ScatterChartArgs 

type ScatterChartArgs struct {
	*js.Object
	Parent         string              `js:"parent"`
	Title          string              `js:"title"`
	Data           *ChartData          `js:"data"`
	Type           string              `js:"type"`
	Height         int                 `js:"height"`
	Colors         []string            `js:"colors"`
	XAxisMode      string              `js:"x_axis_mode"`
	YAxisMode      string              `js:"y_axis_mode"`
	IsSeries       int                 `js:"is_series"`
	FormatTooltipX func(string) string `js:"format_tooltip_x"`
	FormatTooltipY func(string) string `js:"format_tooltip_y"`
}

ScatterChartArgs represents the relevant arguments that are used to instantiate a scatter chart.

func NewScatterChart 

func NewScatterChart(parent string, data *ChartData) *ScatterChartArgs

func (*ScatterChartArgs) Render 

func (chartArgs *ScatterChartArgs) Render() *ScatterChart

Render returns a ScatterChart that allows users to call the above functions.

func (*ScatterChartArgs) SetBton 

func (chartArgs *ScatterChartArgs) SetBton(key string, val bool)

func (*ScatterChartArgs) SetIsSeries 

func (chartArgs *ScatterChartArgs) SetIsSeries(val bool) *ScatterChartArgs

SetIsSeries allows us to set is_series using a boolean instead of 1/0's.

func (*ScatterChartArgs) SetXAxisMode 

func (chartArgs *ScatterChartArgs) SetXAxisMode(mode string) *ScatterChartArgs

func (*ScatterChartArgs) SetYAxisMode 

func (chartArgs *ScatterChartArgs) SetYAxisMode(mode string) *ScatterChartArgs

func (*ScatterChartArgs) WithColors 

func (chartArgs *ScatterChartArgs) WithColors(colors []string) *ScatterChartArgs

func (*ScatterChartArgs) WithFormatTooltipX 

func (chartArgs *ScatterChartArgs) WithFormatTooltipX(callback func(string) string) *ScatterChartArgs

func (*ScatterChartArgs) WithFormatTooltipY 

func (chartArgs *ScatterChartArgs) WithFormatTooltipY(callback func(string) string) *ScatterChartArgs

func (*ScatterChartArgs) WithHeight 

func (chartArgs *ScatterChartArgs) WithHeight(height int) *ScatterChartArgs

func (*ScatterChartArgs) WithTitle 

func (chartArgs *ScatterChartArgs) WithTitle(title string) *ScatterChartArgs

type SpecificValue 

type SpecificValue struct {
	*js.Object
	Title    string  `js:"title"`
	LineType string  `js:"line_type"`
	Value    float64 `js:"value"`
}

SpecificValue represents a frappe-chart specific value object. https://frappe.github.io/charts/ Ctrl + F "specific_values"

func NewSpecificValue 

func NewSpecificValue(title string, lineType string, value float64) *SpecificValue

NewSpecificValue is a helper to create a Specific Value JS object.

type UpdateValueSet 

type UpdateValueSet struct {
	*js.Object
	Values []interface{} `js:"values"`
}

UpdateValueSet represents the JS object frappe-chart uses as parameters for chart.update_values(values, labels). e.g. { values: [1, 2, 3, 4] }

func NewUpdateValueSet 

func NewUpdateValueSet(values []float64) *UpdateValueSet

NewUpdateValueSet is a helper to conveniently create an UpdateValueSet.

type UpdateValuesArgs 

type UpdateValuesArgs struct {
	Values []*UpdateValueSet
	Labels []string
}

UpdateValuesArgs is a wrapper that contains the two parameters that chart.update_values(values, labels) requires. https://frappe.github.io/charts/ Ctrl + F "update_values"

Source Files

View all Source files

Directories

Path Synopsis
static

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.