I have some 15-20 highcharts on a single page (using a slider, 1-2 charts per slide), some bar charts, some column charts, some pie charts, with different display options. What I was using was having multiple methods inside my closure where I had methods like `self.drawColumnChart(xPlotColor, yPlotColor, xPlotLabelSize, yPlotLabelSize, ...10 more arguments)`. Inside the same object I have methods like 'drawRevenueChart(), drawLossChart()' etc. `drawRevenueChart()` was calling `self.drawColumnChart(` with 15 arguments. As the number of charts grew, I ended up passing more and more arguments to `self.drawColumnChart(` so I thought I could refactor this by changing the `drawRevenueChart()` as 

```
("$id").highcharts(
    {chart: {
        plotOptions: {
            labelSize: '2em'
        },
        xAxis:{
          labelSize: '1.3em',
          formatter: function(){
               return '% ' + this.value;
          }
          ...and so on
        }
    })'

```

I don't need the `self.drawColumnChart(xPlotColor, yPlotColor, xPlotLabelSize, yPlotLabelSize, ...10 more arguments)` any more but I just passed that complexity to `drawRevenueChart()`. `drawRevenueChart()` used to be 2 lines long, but now it's 25 lines long. Same with `drawLossChart()`, it used to be 3 lines long, just calling `self.drawColumnChart(`, but it turned into a 15 line long method after refactor. 

Can you guys think of any other way how I can refactor/shorten this? Maybe `drawRevenueChart()` calls `self.drawChart("column", [plotOptions.labelSize: '2em', xAxis: {labelSize: '1.e em'}...`

It just seems that I have to keep repeating 

```
plotOptions: {
    labelSize: '2em'
    },
    xAxis:{
        labelSize: '1.3em',

```

all over my closure for each chart with different options. Is there a way to shorten this? I'm already using jQuery `extend()` to extend default chart options with custom options. It's all inside a closure. But regardless of how I refactor this, I find myself repeating the same lines with different options. Any ideas are welcome.

**Update:**

As requested by TrueBlueAussie:

**it used to be:**

```
myClosure{

    var self = this;

    self.drawColumnChart = function(selector, xPlotColour, yPlotColour, xAxisName, yAxisName, xPlotOptionsSize....10 more arguments)
    {
          $(selector).highcharts({
              chart: {
                  type: 'column'
              },
              xPlot:{
                  style:{
                     color: xPlotColour
                  }
              },
              yPlot: {
                  labels: {
                      style:{
                          color: yPlotColour
                      }
                  }
              },
              xAxis:{
                  labels: { 
                     name: xAxisName,
                  }
              }    
          })
    }

    drawRevenueChart: function(data){
        self.drawColumnChart("#chartid1", 'blue', 'red', 'profit', 'month', '1.2em', null, false, null....);
    }

    drawLossChart: function(data){
        self.drawColumnChart("#chartid2", 'orange', 'yellow, 'loss', 'month', '2em' ...);
    }
}

```

**After refactor**

```
drawRevenueChart: function(data){
        $("#chartid1").highcharts({
              chart: {
                  type: 'column'
              },
            xPlot:{
                  style:{
                     color: 'blue'
                  }
              },
              yPlot: {
                  labels: {
                      style:{
                          color: 'red'
                      }
                  }
              },
              xAxis:{
                  labels: { 
                     name: 'profit',
                  }
              }    
        });
    }

drawLossChart: function(data){
    $("chartid2").highcharts({
        xplot:{
            style:{
               color: 'orange'
            }
        },
        xAxis:{
           labels:{
               name: 'loss',
               color: 'puke'
           }
        }
    }
};

```

So I just moved the 3 level deep object setting from one method to another, no real gain.