How to use the d3-array.extent function in d3-array

let stackData = st(series);

    // Sum all of the values for each point to get max range. Technically
    // stackData contains this but I didn't find reliable documentation on
    // whether we can rely on the highest stacked area to always be first/last
    // in array etc. so this is simpler.
    let summed = series.map(d => {
      let sum = 0;
      keys.forEach(l => {
        sum = sum + d[l];
      });
      return sum;
    });

    let x = scaleTime()
      .domain(extent(series, d => d.time))
      .range([0, w]);

    let y = scaleLinear()
      .domain([0, max(summed)])
      .range([h, 0]);

    let a = area()
      .x(d => x(d.data.time))
      .y1(d => y(d[0]))
      .y0(d => y(d[1]));

    // Use the grey/red we prefer by default but have more colors available in
    // case user adds extra series with a custom provider.
    let colorScheme = ['#DCE0E6', '#C73445'].concat(schemeTableau10);
    let color = scaleOrdinal(colorScheme).domain(keys);

update(state) {
    const valAccessor = accessorFn(state.val);
    const yExtentAccessor = accessorFn(state.yExtent);
    const yScaleExpAccessor = accessorFn(state.yScaleExp);
    const positiveColorsAccessor = accessorFn(state.positiveColors);
    const negativeColorsAccessor = accessorFn(state.negativeColors);
    const positiveColorStopsAccessor = accessorFn(state.positiveColorStops);
    const negativeColorStopsAccessor = accessorFn(state.negativeColorStops);

    // memoize to prevent calling timeAccessor multiple times
    const tsMemo = memo(accessorFn(state.ts));

    const times = state.data.map(tsMemo);
    const timeScale = (state.useUtc ? d3ScaleUtc : d3ScaleTime)()
      .domain(d3Extent(times))
      .range([0, state.width]);

    // const timeAxis = d3AxisBottom(timeScale)
    state.timeAxis
      .scale(timeScale)
      .tickFormat(axisTimeFormatter({ useUtc: state.useUtc, use24h: state.use24h }));

    // set scale extent to 1 if zoom is disabled, to allow default wheel events to bubble
    state.zoom.scaleExtent([1, state.enableZoom ? MAX_ZOOM_SCALE : 1]);

    if (state.enableZoom) {
      state.zoom.translateExtent([[0, 0], [state.width, 0]]);

      // apply zoom
      const zoomTransform = d3ZoomTransform(state.zoom.__baseElem.node());
      const zoomedTimeLength = (timeScale.domain()[1] - timeScale.domain()[0]) / zoomTransform.k;

_setScales(yDomain, width, height, xPadding){
        if (undefined === yDomain){
            let allV = [];
            this.data.forEach((d) => allV = allV.concat(d.values));
            yDomain = extent(allV);
        }

        this.scale = {
            x: scaleBand()
                .rangeRound([0, width])
                .domain(this.data.map((d) => d.label))
                .padding(xPadding),
            y: scaleLinear()
                .rangeRound([height, 0])
                .domain(yDomain),
            z: scaleLinear() // the violin's width
        };
        return this.scale;
    }
    _drawViolin(entry, dom, scale){

.attr('width', width)
            .attr('height', height);

        selection.append('span')
            .attr('class', 'title')
            .text(title);

        selection.append('span')
            .attr('class', 'value');

        var context = canvas.node().getContext('2d');
        //context.imageSmoothingEnabled = false;
        //context.translate(margin.left, margin.top);

        // update the y scale, based on the data extents
        var _extent = extent || d3_extent(data);

        var max = Math.max(-_extent[0], _extent[1]);
        y.domain([0, max]);
        //x = d3.scaleTime().domain[];
        axis = axisTop(x).ticks(5);

        // Draw ----------------------------------------------------------------------------

        context.clearRect(0, 0, width, height);
        //context.translate(0.5, 0.5);

        // the data frame currently being shown:
        var increment = step + spacing,
            startIndex = ~~Math.max(0, -(offsetX / increment)),
            endIndex = ~~Math.min(data.length, startIndex + width / increment);

this.width = this.svg.attr('width') - this.margin.left - this.margin.right;
        this.height = this.svg.attr('height') - this.margin.top - this.margin.bottom;

        this.g = this.svg.append('g').attr('transform', 'translate(' + this.margin.left + ',' + this.margin.top + ')');

        this.x = d3Scale.scaleTime().range([0, this.width]);
        this.y = d3Scale.scaleLinear().range([this.height, 0]);
        this.z = d3Scale.scaleOrdinal(d3ScaleChromatic.schemeCategory10);

        this.line = d3Shape.line()
            .curve(d3Shape.curveBasis)
            .x( (d: any) => this.x(d.date) )
            .y( (d: any) => this.y(d.temperature) );

        this.x.domain(d3Array.extent(this.data, (d: Date) => d ));

        this.y.domain([
            d3Array.min(TEMPERATURES, function(c) { return d3Array.min(c.values, function(d) { return d.temperature; }); }),
            d3Array.max(TEMPERATURES, function(c) { return d3Array.max(c.values, function(d) { return d.temperature; }); })
        ]);

        this.z.domain(TEMPERATURES.map(function(c) { return c.id; }));
    }

) {
          const pointKey = `${xValue},${yValue}`
          if (!voronoiUniqueHash[pointKey]) {
            const voronoiPoint = {
              ...d,
              coincidentPoints: [d],
              voronoiX: xValue,
              voronoiY: yValue
            }
            voronoiDataset.push(voronoiPoint)
            voronoiUniqueHash[pointKey] = voronoiPoint
          } else voronoiUniqueHash[pointKey].coincidentPoints.push(d)
        }
      })

      const voronoiXExtent = d3Extent(voronoiDataset.map(d => d.voronoiX))
      const voronoiYExtent = d3Extent(voronoiDataset.map(d => d.voronoiY))

      const voronoiExtent = [
        [
          Math.min(voronoiXExtent[0], -interactionOverflow.left),
          Math.min(voronoiYExtent[0], -interactionOverflow.top)
        ],
        [
          Math.max(voronoiXExtent[1], size[0] + interactionOverflow.right),
          Math.max(voronoiYExtent[1], size[1] + interactionOverflow.bottom)
        ]
      ]

      const voronoiDiagram = voronoi()
        .extent(voronoiExtent)
        .x((d: VoronoiEntryType) => d.voronoiX)

inputTable.getColumn(yColumnKey, 'number'),
    yDomain
  )

  const table = bin2d(
    inputTable,
    xColumnKey,
    yColumnKey,
    resolvedXDomain,
    resolvedYDomain,
    width,
    height,
    binSize
  )

  const countDomain = extent(table.getColumn(COUNT, 'number'))
  const fillScale = getContinuousColorScale(countDomain, colors)

  return {
    type: 'rect',
    inputTable,
    table,
    binDimension: 'xy',
    xDomain: resolvedXDomain,
    yDomain: resolvedYDomain,
    xColumnKey,
    yColumnKey,
    xColumnType: inputTable.getColumnType(xColumnKey),
    yColumnType: 'number',
    scales: {fill: fillScale},
    columnGroupMaps: {},
  }

      const extents = this.dataSources.map(key => extent(this.data, d => +d[key]));
      const dataMin = min(extents, d => d[0]);

render() {
		const { data: unsortedData, type, width, ratio } = this.props;

		const data = unsortedData.slice().sort((a, b) => a.income - b.income);
		const r = scaleLinear()
			.range([2, 20])
			.domain(extent(data, d => d.population));

		const f = scaleOrdinal(schemeCategory10)
			.domain(set(data.map(d => d.region)));

		const fill = d => f(d.region);
		const radius = d => r(d.population);
		return (
			 d.income}
					xScale={scaleLog()}
					padding={{ left: 20, right: 20 }}
					>