Combine the layers resulting from a d3.nest operation into a single, aggregated layer.

This can be used to combine all sources of a single data type, for example to show all "power" sources as a single layer of chart data. The resulting object has the same structure as the input layerData parameter, with just a single layer of data.

For example:

const layerData = [
  { key : 'A', values : [{watts : 123, foo : 1}, {watts : 234, foo : 2}] },
  { key : 'B', values : [{watts : 345, foo : 3}, {watts : 456, foo : 4}] }
];

const result = aggregateNestedDataLayers(layerData,
    'A and B', ['foo'], ['watts'], {'combined' : true});

Then result would look like this:

[
  { key : 'A and B', values : [{watts : 468, foo : 1, combined : true},
                               {watts : 690, foo : 2, combined : true}] }
]

Transform raw SolarNetwork timeseries data by combining datum from multiple sources into a single data per time key.

This method produces a single array of objects with metric properties derived by grouping that property within a single time slot across one or more source IDs. Conceptually this is similar to module:data~aggregateNestedDataLayers except groups of source IDs can be produced in the final result.

The data will be passed through module:data~normalizeNestedStackDataByDate so that every result object will contain every configured output group, but missing data will result in a null value.

Here's an example where two sources A and B are combined into a single group Generation and a third source C is passed through as another group Consumption:

const queryData = [
    {localDate: '2018-05-05', localTime: '11:00', sourceId: 'A', watts : 123},
    {localDate: '2018-05-05', localTime: '11:00', sourceId: 'B', watts : 234},
    {localDate: '2018-05-05', localTime: '11:00', sourceId: 'C', watts : 345},
    {localDate: '2018-05-05', localTime: '12:00', sourceId: 'A', watts : 456},
    {localDate: '2018-05-05', localTime: '12:00', sourceId: 'B', watts : 567},
    {localDate: '2018-05-05', localTime: '12:00', sourceId: 'C', watts : 678},
];
const sourceMap = new Map([
    ['A', 'Generation'],
    ['B', 'Generation'],
    ['C', 'Consumption'],
]);

const result = groupedBySourceMetricDataArray(queryData, 'watts', sourceMap);

Then result would look like this:

[
    {date : new Date('2018-05-05T11:00Z'), Generation : 357, Consumption: 345},
    {date : new Date('2018-05-05T12:00Z'), Generation : 1023, Consumption: 678}
]

Normalize the data arrays resulting from a d3.nest operation so that all group value arrays have the same number of elements, based on a Date property named date.

The data values are assumed to be sorted by date already, and are modified in-place. This makes the data suitable to passing to d3.stack, which expects all stack data arrays to have the same number of values, for the same keys. When querying for data in SolarNetwork there might be gaps in the results, so this function can be used to "fill in" those gaps with "dummy" values so that there are no more gaps.

Filled-in data objects are automatically populated with an appropriate date property and a sourceId property taken from the key of the layer the gap if found in. You can pass a fillTemplate object with static properties to also include on all filled-in data objects. You can also pass a fillFn function to populate the filled-in objects with dynamic data.

For example, given:

const layerData = [
  { key : 'A', values : [{date : new Date('2011-12-02 12:00')}, {date : new Date('2011-12-02 12:10')}] },
  { key : 'B', values : [{date : new Date('2011-12-02 12:00')}] }
];

normalizeNestedStackDataByDate(layerData);

The layerData would be modified in-place and look like this (notice the filled in second data value in the B group):

[
  { key : 'A', values : [{date : new Date('2011-12-02 12:00')}, {date : new Date('2011-12-02 12:10')}] },
  { key : 'B', values : [{date : new Date('2011-12-02 12:00')}, {date : new Date('2011-12-02 12:10'), sourceId : 'B'}] }
]

Normalize a data array of time series data based on an aggregate time step.

This method is useful for "filling in" gaps of data in situations where something expects the data include placeholders for the gaps. Charting applications often expect this, for example.

Each element in the data array is expected to provide a date property that is a Date object. When gaps are discovered in the array, "filler" objects will be inserted with an approprate date value and all other properties copied from the previous element but set to null.

Here's an example where a new element is added to an array to fill in a missing time slot:

const queryData = [
    {date : new Date('2018-05-05T11:00Z'), Generation : 357, Consumption: 345},
    {date : new Date('2018-05-05T12:00Z'), Generation : 1023, Consumption: 678}
]

timeNormalizeDataArray(queryData, Aggregations.ThirtyMinute);

Then queryData would look like this:

[
    {date : new Date('2018-05-05T11:00Z'), Generation : 357, Consumption: 345},
    {date : new Date('2018-05-05T11:30Z'), Generation : null, Consumption: null},
    {date : new Date('2018-05-05T12:00Z'), Generation : 1023, Consumption: 678}
]

A callback function that operates on a nested data layer datum object.