max: setAnimationValue()

in web/frontend/libs/@deltix/hd.components-everchart/index.esm.js [2259:2528]
233 lines of code
27 McCabe index (conditional complexity)

        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 = 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 mergeReducer(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: [...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((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 = widthSelector(s);
  const scrollPosition = selectEverChartPositionScroll(s);
  const tickInterval = selectXAxisTickInterval(s);
  return getXAxisTicks(selectEverChartLastTime(s) + selectEverChartLastTimeStub(s), zoom, width, tickInterval, scrollPosition);
};
const getInterval = memoizeOne((width, zoom) => {
  const num = numberOfTicks(width, zoom);
  const duration = width * zoom;
  return Math.floor(duration / (num + 1));
});
const selectXAxisTickInterval = s => {
  const width = 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 = 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(time).toLocaleFormat(format);
};
const formatY = (value, formatter = noopFormatFunction) => formatter(value.toString());
const formatX = (value, interval, formatter = formatAxisDate) => formatter(value, interval);

class XAxisStage extends Container {
  constructor(stage, index) {
    super(stage, index);
    this.buffer = [];
    XAxisStage.symbolWidth = XAxisStage.symbolWidth || computeSymbolWidth(robotoMonoRegular10);
  }

  setState(state, context, dispatch) {
    const ticks = selectXAxisTicks(state);
    const interval = selectXAxisTickInterval(state);
    const height = heightSelector(state); // const lastTimeStub = selectEverChartLastTimeStub(state);
    // const last = selectEverChartLastTime(state) + lastTimeStub;

    const zoom = selectEverChartZoom(state, true);
    const width = widthSelector(state);
    const scroll = selectEverChartPositionScroll(state);
    const formatFunctions = selectEverChartFormatFunctions(state);
    const {
      XAxis: {