export function reduceReceiveTickFormat(state, { data }) {
const scope = Object.keys(data)[0];
const receivedUpdate = data[scope];
const oldSettings = state.chartOptions.tickFormatSettings || {};
let newSettings;
const getMergedSettings = (scopeName) => Object.assign(
{},
defaultTickFormatSettings,
(oldSettings[scopeName] || {}),
receivedUpdate
);
if ('all' === scope) {
const globalSettings = getMergedSettings('all');
newSettings = formatScopes.reduce((acc, { name }) => {
acc[name] = globalSettings;
return acc;
}, {});
} else {
newSettings = Object.assign(
{},
oldSettings,
set(scope, getMergedSettings(scope), {})
);
}
// Update tickFormatSettings then applyTickFormatters
const newState = set('chartOptions.tickFormatSettings', newSettings, state);
return set(
'chartOptions',
applyTickFormatters(newState.chartOptions, newState.chartType.config),
newState
);
}
update: (store) => {
const data = store.readQuery({ query, variables });
store.writeQuery({
query,
variables,
data: set(arrayPath, get(arrayPath, data).filter(object => object.id !== id), data),
});
},
export function reduceReceiveChartType(state, { data, src }) {
const { chartType, dataFields } = state;
const typeChanged = get('config.type', chartType) !== data.config.type;
if (actionSourceContains(src, 'bootstrap') || !typeChanged) {
return merge(state, { chartType: cloneDeep(data) });
}
let newOptions = applyChartTypeDefaults(data.config, {});
if ('function' === typeof data.conditionalOpts) {
newOptions = merge(newOptions, data.conditionalOpts(state));
}
// Clear yDomain on chart type change to have a default one generated.
newOptions = set('yDomain', null, newOptions);
// Prepopulate labels and xDomain for scatter/bubble charts
if ('nvd3ScatterMultiSeries' === data.config.dataFormat) {
const [, xLabel, yLabel] = dataFields;
newOptions = merge(newOptions, {
xAxis: {
axisLabel: xLabel,
},
yAxis: {
axisLabel: yLabel,
orient: 'top',
},
});
// Set up xDomain if unset
if ('undefined' === typeof get('chartOptions.xDomain', state)) {
newOptions = merge(newOptions, {
xDomain: getXDomain(state.chartData),
});
}
}
return compose(
set('chartType', cloneDeep(data)),
set('chartOptions', mergeWithGlobal(state.chartOptions, newOptions))
)(state);
}
return (store, result) => {
const newObject = get(['data', ...newObjectPath], result);
const data = store.readQuery({ query, variables });
const existingObjects = get(arrayPath, data);
store.writeQuery({
query,
variables,
data: set(arrayPath, [...existingObjects, newObject], data),
});
};
updateFn = newValue => {
this.setState({
touched: true
});
this.checkErrorsAndWarnings(newValue);
return this.props.updateData(
_set(this.props.fieldLocation, newValue === '' ? null : newValue, this.props.data)
).then(() => {
if (this.props.updateSideEffects) {
return this.props.updateSideEffects(this.props.data);
}
});
};
module.exports = values => {
values = values || {};
const anchorProperties = [
"fileType",
"line",
"lineType",
"path",
"srcPath"
];
const parentProperties = ["id"];
return pipe(
result => isPlainObject(get("anchor", values)) ?
set("anchor", filterProperties(anchorProperties, get("anchor", values)), result) :
result,
result => isPlainObject(get("parent", values)) ?
set("parent", filterProperties(parentProperties, get("parent", values)), result) :
result,
set("text", get("text", values)),
Object.seal
)({});
};
export function set(object, path, value) {
return _set(path, value, object);
}
(from, to, src) => has(from, src) ? compose(omit(from), set(to, prop(from, src)))(src) : src
const triggerReducer = (state = {}, input) => {
let {
triggers = [],
groups = null,
filter = '',
trigger = undefined,
sensors = {},
instances = [],
} = state;
state = {
...state,
triggers,
groups,
filter,
trigger,
sensors,
instances,
};
switch (input.type) {
case 'FETCH_GROUPS': {
switch(input.status) {
case 'success':
triggers = input.payload;
trigger = trigger && triggers.find(item => item.ref === trigger.ref);
groups = makeGroups(triggers, filter);
break;
case 'error':
break;
default:
break;
}
return {
...state,
triggers,
groups,
trigger,
};
}
case 'FETCH_SENSORS': {
switch(input.status) {
case 'success':
sensors = {};
for (const sensor of input.payload) {
for (const trigger of sensor.trigger_types) {
sensors[trigger] = sensor;
}
}
break;
case 'error':
break;
default:
break;
}
return {
...state,
sensors,
};
}
case 'FETCH_INSTANCES': {
switch(input.status) {
case 'success':
instances = input.payload;
break;
case 'error':
break;
default:
break;
}
return {
...state,
instances,
};
}
case 'FETCH_ENFORCEMENTS': {
switch(input.status) {
case 'success':
const { id } = input;
const index = findIndex({ id })(instances);
if (index > -1) {
instances = set(`[${index}].enforcements`, input.payload)(instances);
}
break;
case 'error':
break;
default:
break;
}
return {
...state,
instances,
};
}
case 'TOGGLE_ENABLE': {
switch(input.status) {
case 'success':
for (const trigger of input.payload.trigger_types) {
sensors = {
...sensors,
[trigger]: {
...input.payload,
ref: sensors[trigger].ref,
},
};
}
break;
case 'error':
break;
default:
break;
}
return {
...state,
sensors,
};
}
case 'SET_FILTER': {
filter = input.filter;
groups = makeGroups(triggers, filter);
return {
...state,
groups,
filter,
};
}
default:
return state;
}
};
result => isPlainObject(get("parent", values)) ?
set("parent", filterProperties(parentProperties, get("parent", values)), result) :
result,
result => isPlainObject(get("anchor", values)) ?
set("anchor", filterProperties(anchorProperties, get("anchor", values)), result) :
result,