This routine will return an array with the specified range.

dex.range(5); // returns [ 0, 1, 2, 3, 4 ]

This routine will return an array with the specified range.

dex.range(10, 4); // returns [ 10, 11, 12, 13 ]

This routine will return an array with the specified range.

dex.range(100, 4, 10); // returns [ 100, 110, 120, 130 ]
dex.range(100, 5, -10); // returns [ 100, 90, 80, 70, 60 ]

This routine is simply a convenience function as it simply wraps underscore's implementation of a shallow copy. This method will create a shallow-copied clone of the provided plain object. Any nested objects or arrays will be copied by reference, not duplicated.

Combine two arrays into one.

// returns [1, 2, 3, 4, 5]
dex.array.combine([1, 2], [3, 4, 5]);

Return a distinct deep copy of an array.

Returns an array of the mathematically smallest and largest elements within the array.

• Error: An error occurred.

Returns elements of an array where the supplied condition is matched.

// returns [ 0, 1, 2, 3]
dex.array.findIndexes([1,2,3,4,5],function(e){return e<5;}));
// returns [3, 5]
dex.array.findIndexes(["a", "b", "c", "d", "e", "d"],
  function(e) {return e=="d";}

Returns all possible combinations of length comboLength from the given array.

:

// returns: [[1,2], [1,3], [1,4], [2,3], [2,4], [3,4]]
dex.array.getCombinations([1, 1,2,3,4], 2)

Returns all possible permutations of length maxLen from the given array.

:

// returns: [[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]]
dex.array.getPermutations([1,2,3,4], 2)

Inspect each element of the array and guess the overall type of the array.

Returns whether every element in an array is numeric or not.

// Returns true
dex.array.isNumeric([1, 2, 3]);
// Returns false
dex.array.isNumeric(["A", 2, 3]);

Return the unique members of an array in the natural order they occur.

dex.array.naturalUnique(array) - Return an array containing the unique values within the array.

// Returns: [ 3, 2, 1 ]
dex.array.naturalUnique([3, 2, 1, 2, 3];

Remove the specified elements indicated by the removeIndex field.

Return the specified slice of an array without modifying the original array.

var myArray = [ 1, 2, 3, 4, 5 ];

// Returns: [ 3, 4, 5]
slice(myArray, 2);

// Returns: [ 1, 3, 5 ]
slice(myArray, [0, 2, 4]);

// returns a copy of the array:
slice(myArray);

Return the unique members of an array.

dex.array.unique(array) - Return an array containing the unique values within the array.

// Returns: [ 1, 2, 3]
dex.array.unique([1, 1, 2, 2, 3];

Given a color, lighten or darken it by the requested percent.

Given two colors, blend them together.

Given an palette or array of colors and some optional color assignmeents, create a colormap.

// Assigns a colormap of red, white and blue
var usColormap = dex.color.colormap(['red', 'white', 'blue']);

// Assigns a colormap of grey, brown and yellow and reserves red for
// Republicans and blue for Democrats.
var usPartyColors = dex.color.colormap(['grey', 'brown', 'yellow'],
  { 'Republican' : 'red', 'Democrat' : 'blue' });

Return the list of available named colormaps.

Given a domain of 2 or more items and a range of 2 colors, return a categorical interpolation across the two colors based upon the supplied range.

Get the named colormap with the assigned presets.

This routine supports a shorthand notation allowing the user to specify deeply nested configuration options without having to deal with nested json structures.

{
  'cell' : {
    'rect' : {
      'width' : 10,
      'height' : 20
    }
  }
}

becomes easier to read when expressed as:

{
  'cell.rect.width'            : 10,
  'cell.rect.height'           : 20,
}

This routine will take one or more objects and expand each one via dex.config.expand. The objects will then be overlaid on top of each other. Objects are supplied in descending precedence; meaning that object conflicts will be resolved by taking the value from the first supplied object defining it within the method call.

Given:

var first = {
  "name": "first",
  "screen.width" : 800
};

var second = {
  "name": "second",
  "screen.width": 100,
  "screen.height": 600,
  "secondField": "Only in 2nd"
};

var third = {
  "name": "third",
  "screen.width": 333,
  "screen.height": 333,
  "thirdField": "Only in 3rd"
};

Calling:

var combined = dex.config.expandAndOverlay(first, second, third);

Yields a combined value of:

{
  "name": "first",
  "screen": {
    "width": 800,
    "height": 600
  },
  "secondField": "Only in 2nd",
  "thirdField" : "Only in 3rd"
}

Return the configuration for a font after the user's customizations have been applied.

Configure the given font with the supplied font specification.

Construct a text specification.

var myText = dex.config.text({ "font.size" : 32 });

This routine will dynamically configure an SVG text entity based upon the supplied configuration.

var textSpec = dex.config.text({ "font.size": 32, "fill.fillColor": "red" });
d3.select("some-nodes")
  .call(dex.config.configureText, textSpec);

Construct a stroke specification.

Apply a stroke specification to a node.

Construct a fill specification which allow the user to override any its settings.

Apply a fill specification to a node.

Construct a link specification which allows the user to override any of the settings.

Apply a link specification to a node.

Construct a rectangle specification which allows the user to override any of the settings.

Construct an events specification which allows the user to override any of the settings.

Construct an line specification which allows the user to override any of the settings.

Construct an path specification which allows the user to override any of the settings.

Is this correct? It looks suspect to me.

Construct an point specification which allows the user to override any of the settings.

Construct an circle specification which allows the user to override any of the settings.

Construct an tick specification which allows the user to override any of the settings.

Configure the input parameters for configuring an axis. Certain defaults are imposed should the "custom" variable not specify that parameter.

Create an axis with the specified configuration.

Construct a {d3axis_spec} based on reasonable defaults with user customizations applied on top.

Given a scale specification, create, configure, and return a scale which meets that specification.

Construct a linear {d3scale_spec} based on reasonable defaults with user customizations applied on top.

Construct a power {d3scale_spec} based on reasonable defaults with user customizations applied on top.

Construct a sqrt {d3scale_spec} based on reasonable defaults with user customizations applied on top.

Construct a log {d3scale_spec} based on reasonable defaults with user customizations applied on top.

Construct a ordinal {d3scale_spec} based on reasonable defaults with user customizations applied on top.

Create a gui for setting dimensions.

Log this message if the current log level is greater than or equal to dex.console.logLevel.

Write one or more TRACE level messages.

Write one or more DEBUG level messages.

Write one or more NORMAL level messages.

Write one or more WARN level messages.

Write one or more FATAL level messages.

This function returns the current log level.

Returns the log levels.

Print a stack trace to the console.

Log the message if log level is equal to or greater than the supplied log level.

Log the message as a concatentated string to the console using NORMAL level logLeve.

Given a CSV, create a connection matrix suitable for feeding into a chord diagram. Ex, given CSV:

Given a csv and a column index, return the name of the column. If a string is supplied, return the string if it is the name of a header. If an integer is supplied, return the name of the header if that header exists. This allows us to enable users to index columns via header name or by index.

Retrieve the column referred to by the column index. The column index can be a header name or a value column number.

Make a copy of this csv.

A utility transform for dealing with some of D3's more finiky formats.

csv = { header : {C1,C2,C3}, data : [ [A,B,C], [A,B,D] ] } into: json = { "name" : rootName, "category" : category, "children" : [ "children" : [ { "name" : "A", "category" : "C1", "children" : [ { "name" : "B", "category" : "C2", "children" : [ { "name" : "C", "category" : "C3", "size" : 1 } { "name" : "D", "category" : "C3", "size" : 1 } ] } ] } ] ] }

Transforms: csv = { header : {C1,C2,C3}, data : [ [A,B,C], [A,B,D] ] } into: connections = { A:{B:{C:{},D:{}}}}

This routine will return a frames structure based on a csv and an index. It will first identify all unique values within the selected column, then sort them into an array of frame indexes. From there, it will return an array of csv where the elements contain the specified frame index at the cooresponding location. This routine supports things such as time/value filtering for things like a time or slicing dimension for various charts. IE: No need to write a motion bubble chart, simply combine a vcr-player with a regular bubble chart connected to play/rewind events and motion will follow.

Frame out a csv based on non-distinct permutations. Exclude the column pointed to by groupIndex from the permutations. This will be used to group and typically color the various series contained within the frames. A set of frames suitable for SPLOM might be generated via a call of getPermutationFrames(csv, 2). However, as this is written generically, it will also support higher order dimensions as well.

Generate frames based upon a grouping parameter, then

Given a series of categorical indices into a csv which contains some numeric data, create a new CSV where the first column is the aggregated categorical indices and the contents are the sum of numeric columns matching the aggregated categories.

Creates a matrix of random integers within the specified range.

Creates a matrix of random integers within the specified range.

This method will return an identity function meeting the supplied specification.

{@lang javascript}
// Returns: [['R1C1', 'R1C2' ], ['R2C1', 'R2C2'], ['R3C1', 'R3C2']]
identityMatrix({rows: 3, columns: 2});

Returns an identity header array.

// Returns: [ 'C1', 'C2', 'C3' ]
identityHeader({ columns: 3 });

This method returns the square distance between two points..

Converts JSON and a header to a CSV file. It is used for parallel coordinate brush events where the selected brush must be published to events as a csv.

For example, given:

json = [ { A: 1, B: 3, C: 5, D: 7 }, { A: 2, B: 4, C: 6, D: 8 } ]; header = [ 'A', 'B', 'C', 'D' ];

This will return a csv where:

csv = { header: [ 'A', 'B', 'C', 'D' ], data [[ 1, 4, 5, 7 ], [ 2, 4, 6, 8 ]];

Returns all keys found in a json structure or array of json structures.

Return the specified slice of the matrix. The original matrix is not altered.

Returns a matrix consisting of unique values relative to each column.

Returns a transposed matrix where the rows of the new matrix are transposed with it's columns.

{@lang javascript}
// Returns [['R1C1', 'R2C1', 'R3C1'], ['R1C2', 'R2C2', 'R3C2' ]]
transpose([['R1C1', 'R1C2'], ['R2C1', 'R2C2], ['R3C1', 'R3C2']]);

Return a flattened version of the matrix.

{@lang javascript}
// Define a simple matrix.
var matrix = [['r1c1', 'r1c2'], ['r2c1', 'r2c2']]

// Returns: ['r1c1', 'r1c2', 'r2c1', 'r2c2']
flatten(matrix);

Returns an array of the minimum and maximum value in the form of: [min,max] from the specified subset of the matrix.

Combine each column in matrix1 with each column in matrix2.

{@lang javascript}
var matrix1 = [['m1r1c1', 'm1r1c2'], ['m1r2c1', 'm1r2c2']]
var matrix2 = [['m2r1c1', 'm2r1c2'], ['m2r2c1', 'm2r2c2']]

// Returns: [['m1r1c1', 'm1r1c2', 'm2r1c1', 'm2r1c2'], ['m1r2c1', 'm1r2c2', 'm2r2c1', 'm2r2c2']]
var result = combine(matrix1, matrix2);

Return a copy of the supplied matrix.

Insert a new column at position 0 within this matrix which will contain integer values starting at 1, 2, 3, ... This is useful if your dataset lacks an existing unique index.

Determine whether the supplied columnNum within the supplied matrix is numeric or not.

Return the maximum value of the specified columnNum within the supplied matrix.

Return the minimum value of the specified columnNum within the supplied matrix.

Return the local keys of this object without the inherited ones.

A pretty good, but imperfect mechanism for performing a deep clone of an object.

Kind of misleading. This really signals when expand should quit expanding. I need to clean this up.

Overlay the top object on top of the bottom. This method will first clone the bottom object. Then it will drop the values within the top object into the clone.

This method returns whether or not the supplied object is a Node.

This method returns whether or not the supplied object is a DOM node.

This method returns a boolean representing whether obj is contained within container.

Return whether or not the supplied object is a function.

Construct a player component.

This creates a SqlQuery component which provides a SQL interface into retrieving data from a SQL Lite database.

Creates a Table component for visualizing tabular data.

{@lang javascript}
var myTable = new dex.ui.Table({
  'parent' : "#MyTableContainer",
  'id'     : "MyTableId"
  'csv'    : { header : [ "X", "Y", "Z" ],
               data   : [[ 1, 2, 3 ], [4, 5, 6], [7, 8, 9]]}
});

Creates a ConfigurationPane component.

Creates a Table component for visualizing tabular data.

{@lang javascript}
var myTable = new dex.ui.Table({
  'parent' : "#MyTableContainer",
  'id'     : "MyTableId"
  'csv'    : { header : [ "X", "Y", "Z" ],
               data   : [[ 1, 2, 3 ], [4, 5, 6], [7, 8, 9]]}
});

Given a d3 element, this routine will determine the parent's bounding box and annotate information related to the bounds in which this element can expand.

Refresh a component. This routine will take the minimal effort to refresh a component. Components with update capability (ie: the ability to take incremental change), will perform a miminimal update. Components which do not support incremental updates will perform a full render. This behavior is controlled by the "refreshType" component option which is set either to "update" or "render".

var someChart = dex.chart.SomeChart({ refreshType: 'update' }).render();
someChart.refresh(); // Calls update on refresh. ie: partial update.

var anotherChart = dex.chart.AnotherChart({ refreshType: 'render' )}.render();
// Calls render on refresh.  This means that the entire chart is recreated.
anotherChart.refresh();

Get reconstruct the saved component from the saved parameters.

Get or set a component's attribute. When called without arguments, retrieve all the attributes of that component.

• () - Return the component's configuration.
• (name) - Return the value of a specific named attribute.
• (name, value)- Set the value of an attribute.

// Return the chart's configuration.
var config = chart.attr();

// Return the height attribute of the chart.
var height = chart.attr("height");

// Set attribute name to value
chart.attr("name", value);

// Set param1, param2 and a nested parameter named param3
// using dot-notation.
chart.attr("param1", "value1")
  .attr("param2", "value2")
  .attr("nested.param3", { key: "value" };

By default, the setter form of attr (having 2 arguments) triggers an event notifying all concerned listeners that the attribute has changed. Sometimes we wish avoid the generation of this event.

Components must define a clone function. This is a placeholder to indicate that they have not done so should it get called.

Components should define a gui definition for platforms to modify their settings interactively. This provides a generic implementation consisting of common attributes for components which have not defined their interface.

Subscribe a component to the specified events of another component.

var handle = chart1.subscribe(chart2, 'select', function(event) {
  // do something
});

Get the component's margins.

Unsubscribe this component from the channel indicated in the handle.

Publish an event to the component's subscribers.

A default no-op implementation of render. Subclasses should override this method with one which provides an initial rendering of their specific component. This is a great place to put one-time only initialization logic.

A default no-op implementation of update. This will update the current component relative to any new setting or data changes.

Resize the component.

Render the chart asynchronously and ensure we don't attempt to render more than 1x / second via debounce.

Update the chart asynchronously and ensure we don't attempt to update more than 1x / second via debounce.

Refresh the chart asynchronously and ensure we don't attempt to refresh more than 1x / second via debounce.

Resize the chart asynchronously and ensure we don't attempt to resize more than 1x / second via debounce.

Default implementation for chart deletion.

Delete the chart. Unregister listeners and delete it gracefully.

Save a specified attribute.

Load component state from the DOM. It silently looks for the information within an attribute with id=dexjs-config descended from the HTML page body. Each chart configured is encapsulated in a div element with a chart-id attribute set to the id of that component as defined in it's config.id option. This means that if you wish to configure multiple instances of the same chart type on the same page, you must supply them with unique id's.

Save the user modified component state to the DOM. The information is stored in an element with selector path: "body div#dexjs-config". Under this element, individual charts are configured in a descending div element with attribute "chart-id" set to the component's config.id.

This is the base constructor for C3 charts.

This is the base constructor for a C3 Pie Chart.

This is the base constructor for a C3 Donut Chart.

This is the base constructor for a C3 Area Chart.

This is the base constructor for a C3 Bar Chart.

This is the base constructor for a C3 Line Chart.

This module provides a C3 ScatterPlot

This module provides a C3 StackedArea Chart.

This module provides a C3 StackedBar Chart.

This is the base constructor for a D3 BumpChart component.

This is the base constructor for a D3 Chord diagram.

This is the base constructor for a D3 Clustered Force visualization.

This is the base constructor for a D3 Dendrogram visualization.

This is the base constructor for a D3 HorizontalLegend component.

This is the base constructor for a D3 Icicle chart.

This is the base constructor for a D3 HorizontalLegend component.

This is the base constructor for a D3 MotionBarChart component.

This is the base constructor for a D3 OrbitalLayout component.

This is the base constructor for a D3 ParallelCoordinates component.

This is the base constructor for a D3 RadarChart component.

This is the base constructor for a D3 RadialTree component.

This is the base constructor for a D3 Sankey component.

This is the base constructor for a D3 Sankey component.

This is the base constructor for a D3 ScatterPlot component.

This is the base constructor for a D3 Sunburst component.

This is the base constructor for a D3 Treemap component.

This is the base constructor for a D3 VerticalLegend component.

This is the base constructor for a D3 TreemapBarChart component.

This is the base constructor for a D3 TopoJsonMap component.

This is the base constructor for a D3Plus RingNetwork.

The base constructor for an EChart.

Create an ECharts HeatMap with the given specification.

Create an ECharts LineChart with the given specification.

Create an ECharts LineChart with the given specification.

Create an ECharts Polar Plot with the given specification.

Create an ECharts Network with the given specification.

Create an ECharts Network with the given specification.

Create an ECharts Single Axis ScatterPlot with the given specification.

Create an ECharts Pie Chart with the given specification.

Create an ECharts SteamGraph with the given specification.

Create an ECharts Radar Chart with the given specification.

Create an ECharts Tree with the given specification.

Create an ECharts LineChart with the given specification.

This is the base constructor for a Elegans ScatterPlot.

This is the base constructor for a JS Grid.

This is the base constructor for Gridster base multiples.

This is the base constructor for Simple HTML based multiples.

This is the base constructor for a NVD3 StackedAreaChart.

This is the base constructor for a NVD3 BubbleChart.

This is the base constructor for a TauChart.

This is the base constructor for a TauChart AreaChart.

This is the base constructor for a TauChart LineChart.

This is the base constructor for a TauChart ScatterPlot.

This is the base constructor for a TauChart BarChart.

This is the base constructor for a TauChart StackedBarChart.

This is the base constructor for a TauChart HorizontalBarChart.

This is the base constructor for a TauChart HorizontalStackedBarChart.

This is the base constructor for a WebGL ScatterPlot component.

This is the base constructor for a VisJS Network component.

This is the base constructor for a VisJS Timeline component.