in web/frontend/libs/@deltix/hd.components-everchart/index.umd.js [2276:2545]
max: setAnimationValue(pads[id].max, extremums[id].max),
min: setAnimationValue(pads[id].min, extremums[id].min)
});
}
}
return applyState(state, {
pads
});
};
const everChartHistoryDataReducer = (state, {
payload: {
data,
time,
interval,
end
}
}) => {
const lastTime = selectEverChartLastTime(state);
const maxTime = selectEverChartMaxTime(state);
const maxBucketSize = selectEverChartMaxBucketSize(state);
const currentData = appendTimeSeries(selectEverChartData(state), data, interval, time, end, maxBucketSize);
let newLastTime = 0;
for (let i = currentData.length - 1; i >= 0; i--) {
if (currentData[i].interval === interval) {
newLastTime = currentData[i].to;
break;
}
}
newLastTime = Math.max(lastTime, newLastTime);
if (maxTime != null) {
newLastTime = Math.min(newLastTime, maxTime);
}
return applyState(state, {
data: currentData,
lastRequestedTime: time,
lastTime: newLastTime
});
};
const everChartLastTimeReducer = (state, {
payload: {
lastTime
}
}) => {
return applyState(state, {
lastTime: Math.max(state.app.lastTime, lastTime)
});
};
const everChartLastTimeStubReducer = (state, {
payload: {
lastTimeStub,
animate
}
}) => {
const lastTime = selectEverChartLastTime(state);
const zoom = selectEverChartZoom(state, true);
const width = hd_componentsMultiApp.widthSelector(state);
const scroll = selectEverChartPositionScroll(state);
const defaultLastTimeStubGap = zoom * (width / 3);
const minTime = selectEverChartMinTime(state);
const maxTime = selectEverChartMaxTime(state) || lastTime + defaultLastTimeStubGap;
const max = maxTime - lastTime + scroll * zoom;
const min = Math.max(minTime - lastTime + width * zoom + scroll * zoom, 0);
return applyState(state, {
lastTimeStub: setAnimationValue(state.app.lastTimeStub, Math.max(min, Math.min(lastTimeStub, max)), animate)
});
};
const everChartScrollReducer = (state, {
payload: {
scroll
}
}) => {
const lastTime = selectEverChartLastTime(state);
const minTime = selectEverChartMinTime(state);
const maxTime = selectEverChartMaxTime(state);
const original = selectEverChartPositionScroll(state);
if (!isFinite(scroll)) {
scroll = lastTime;
} // maxTime -> min zoom
// minTime -> max zoom
if (minTime != null && minTime > scroll) {
scroll = minTime;
}
if (maxTime != null && maxTime < scroll) {
scroll = maxTime;
}
if (original === scroll) {
return state;
}
return applyState(state, {
scrollPosition: scroll
});
};
const everChartTickReducer = (state, {
payload: {
tick
}
}) => {
return applyState(state, {
tick
});
};
const everChartZoomReducer = (state, {
payload: {
zoom
}
}) => {
return applyState(state, {
zoom: setAnimationValue(state.app.zoom, zoom)
});
};
const everChartReducer = initialState => {
return hd_componentsUtils.mergeReducer(hd_componentsUtils.createRootReducer([[everChartChangeViewportReducer, everChartChangeViewportAction], [everChartDataReducer, everChartDataAction], [everChartExtremumReducer, everChartExtremumAction], [everChartZoomReducer, everChartZoomAction], [everChartScrollReducer, everChartScrollToTimeAction], [everChartHistoryDataReducer, everChartHistoryDataAction], [everChartCrosshairReducer, everChartCrosshairAction], [everChartCrosshairResetReducer, everChartPointerOutAction], [everChartTickReducer, everChartTickAction], [everChartCleanReducer, everChartNewIntervalAction], [everChartLastTimeStubReducer, everChartLastTimeStubAction], [everChartChangeConfigurationReducer, everChartChangeConfigurationAction], [everChartLastTimeReducer, everChartLastTimeAction]], initialState));
};
const everChartParameters = {
default: {
// name of extension
resource: {
resources: [...hd_componentsCommon.commonFonts]
}
}
};
const MINUTE = 60 * 1000;
const HOUR = 60 * MINUTE;
const DAY = 24 * HOUR;
const MONTH = DAY * 30; // avg
const YEAR = MONTH * 12;
const getNumber = (width, from, to, averageLabelWidth = 50) => {
for (let i = to; i >= from; i--) {
if (width / i >= averageLabelWidth) {
// ???
return i;
}
}
return Math.floor(width / averageLabelWidth);
};
const numberOfTicks = (width, interval) => {
if (interval > YEAR) {
return getNumber(width, 1, 3);
} else if (interval > MONTH) {
return getNumber(width, 2, 4);
} else if (interval > DAY) {
return getNumber(width, 2, 4);
} else if (interval > HOUR) {
return getNumber(width, 2, 4, 80);
} else if (interval > MINUTE) {
return getNumber(width, 2, 4, 100);
} else {
return getNumber(width, 2, 4, 120);
}
};
const getXAxisTicks = memoizeOne__default["default"]((lastTime, zoom, width, tickInterval, scrollPosition) => {
const num = numberOfTicks(width, zoom);
const startOffset = scrollPosition;
const tickStartOffset = startOffset % tickInterval;
const ticks = [];
for (let i = num; i >= 0; i--) {
ticks.push(startOffset - tickInterval * i - tickStartOffset);
}
return ticks;
});
const selectXAxisTicks = s => {
// const lastTime = selectEverChartDataLastTime(s);
const zoom = selectEverChartZoom(s, true);
const width = hd_componentsMultiApp.widthSelector(s);
const scrollPosition = selectEverChartPositionScroll(s);
const tickInterval = selectXAxisTickInterval(s);
return getXAxisTicks(selectEverChartLastTime(s) + selectEverChartLastTimeStub(s), zoom, width, tickInterval, scrollPosition);
};
const getInterval = memoizeOne__default["default"]((width, zoom) => {
const num = numberOfTicks(width, zoom);
const duration = width * zoom;
return Math.floor(duration / (num + 1));
});
const selectXAxisTickInterval = s => {
const width = hd_componentsMultiApp.widthSelector(s);
const zoom = selectEverChartZoom(s, true);
return getInterval(width, zoom);
};
const selectYAxisTicks = (s, pad) => {
const min = selectEverChartMin(s, pad);
const max = selectEverChartMax(s, pad);
const height = hd_componentsMultiApp.heightSelector(s);
const num = Math.max(Math.min(Math.ceil(height / 25), 5), 3);
const interval = (max - min) / num;
const ticks = new Set();
for (let i = 1; i < num; i++) {
ticks.add(min + interval * i);
}
return Array.from(ticks);
};
const SECOND_FORMAT = 'HH:mm:ss.fff';
const MINUTE_FORMAT = 'HH:mm:ss';
const HOUR_FORMAT = 'HH:mm:ss';
const DAY_FORMAT = 'yyyy-MM-dd';
const MONTH_FORMAT = 'yyyy-MM-dd';
const YEAR_FORMAT = 'yyyy-MM';
const FULL_FORMAT = 'yyyy-MM-dd HH:mm:ss.fff';
const formatAxisDate = (time, interval) => {
let format;
if (interval == null) {
format = FULL_FORMAT;
} else if (interval > YEAR) {
format = YEAR_FORMAT;
} else if (interval > MONTH) {
format = MONTH_FORMAT;
} else if (interval > DAY) {
format = DAY_FORMAT;
} else if (interval > HOUR) {
format = HOUR_FORMAT;
} else if (interval > MINUTE) {
format = MINUTE_FORMAT;
} else {
format = SECOND_FORMAT;
}
return new hdDate.HdDate(time).toLocaleFormat(format);
};
const formatY = (value, formatter = hd_componentsCommon.noopFormatFunction) => formatter(value.toString());
const formatX = (value, interval, formatter = formatAxisDate) => formatter(value, interval);
class XAxisStage extends hd_componentsMultiApp.Container {
constructor(stage, index) {
super(stage, index);
this.buffer = [];
XAxisStage.symbolWidth = XAxisStage.symbolWidth || hd_componentsMultiApp.computeSymbolWidth(hd_componentsCommon.robotoMonoRegular10);
}
setState(state, context, dispatch) {
const ticks = selectXAxisTicks(state);
const interval = selectXAxisTickInterval(state);
const height = hd_componentsMultiApp.heightSelector(state); // const lastTimeStub = selectEverChartLastTimeStub(state);
// const last = selectEverChartLastTime(state) + lastTimeStub;
const zoom = selectEverChartZoom(state, true);
const width = hd_componentsMultiApp.widthSelector(state);
const scroll = selectEverChartPositionScroll(state);
const formatFunctions = selectEverChartFormatFunctions(state);
const {
XAxis: {