|
| 1 | +import { useMemo } from 'react' |
| 2 | +import { area, stack as d3Stack } from 'd3-shape' |
| 3 | +import { scaleLinear, scalePoint } from 'd3-scale' |
| 4 | +import { |
| 5 | + useTheme, |
| 6 | + usePropertyAccessor, |
| 7 | + useValueFormatter, |
| 8 | + // @ts-ignore |
| 9 | + curveFromProp, |
| 10 | + // @ts-ignore |
| 11 | + stackOrderFromProp, |
| 12 | + // @ts-ignore |
| 13 | + stackOffsetFromProp, |
| 14 | +} from '@nivo/core' |
| 15 | +import { useInheritedColor, useOrdinalColorScale } from '@nivo/colors' |
| 16 | +import { |
| 17 | + StreamCommonProps, |
| 18 | + StreamDataProps, |
| 19 | + StreamDatum, |
| 20 | + StreamLayerData, |
| 21 | + StreamLayerDatum, |
| 22 | + StreamSliceData, |
| 23 | +} from './types' |
| 24 | +import { defaultProps } from './props' |
| 25 | + |
| 26 | +export const useStream = <RawDatum extends StreamDatum>({ |
| 27 | + width, |
| 28 | + height, |
| 29 | + data, |
| 30 | + keys, |
| 31 | + label = defaultProps.label, |
| 32 | + valueFormat, |
| 33 | + offsetType = defaultProps.offsetType, |
| 34 | + order = defaultProps.order, |
| 35 | + curve = defaultProps.curve, |
| 36 | + colors = defaultProps.colors, |
| 37 | + borderColor = defaultProps.borderColor, |
| 38 | + dotSize = defaultProps.dotSize, |
| 39 | + dotColor = defaultProps.dotColor, |
| 40 | + dotBorderWidth = defaultProps.dotBorderWidth, |
| 41 | + dotBorderColor = defaultProps.dotBorderColor, |
| 42 | +}: { |
| 43 | + width: number |
| 44 | + height: number |
| 45 | + data: StreamDataProps<RawDatum>['data'] |
| 46 | + keys: StreamDataProps<RawDatum>['keys'] |
| 47 | + label?: StreamCommonProps<RawDatum>['label'] |
| 48 | + valueFormat?: StreamCommonProps<RawDatum>['valueFormat'] |
| 49 | + offsetType?: StreamCommonProps<RawDatum>['offsetType'] |
| 50 | + order?: StreamCommonProps<RawDatum>['order'] |
| 51 | + curve?: StreamCommonProps<RawDatum>['curve'] |
| 52 | + colors?: StreamCommonProps<RawDatum>['colors'] |
| 53 | + dotSize?: StreamCommonProps<RawDatum>['dotSize'] |
| 54 | + dotColor?: StreamCommonProps<RawDatum>['dotColor'] |
| 55 | + dotBorderWidth?: StreamCommonProps<RawDatum>['dotBorderWidth'] |
| 56 | + dotBorderColor?: StreamCommonProps<RawDatum>['dotBorderColor'] |
| 57 | + borderColor?: StreamCommonProps<RawDatum>['borderColor'] |
| 58 | +}) => { |
| 59 | + const areaGenerator = useMemo( |
| 60 | + () => |
| 61 | + area<StreamLayerDatum>() |
| 62 | + .x(({ x }) => x) |
| 63 | + .y0(({ y1 }) => y1) |
| 64 | + .y1(({ y2 }) => y2) |
| 65 | + .curve(curveFromProp(curve)), |
| 66 | + [curve] |
| 67 | + ) |
| 68 | + |
| 69 | + const stack = useMemo( |
| 70 | + () => |
| 71 | + d3Stack<RawDatum, string | number>() |
| 72 | + .keys(keys) |
| 73 | + .offset(stackOffsetFromProp(offsetType)) |
| 74 | + .order(stackOrderFromProp(order)), |
| 75 | + [keys, offsetType, order] |
| 76 | + ) |
| 77 | + |
| 78 | + const [layers, xScale, yScale] = useMemo(() => { |
| 79 | + const allMin: number[] = [] |
| 80 | + const allMax: number[] = [] |
| 81 | + |
| 82 | + const layers = stack(data).map(layer => { |
| 83 | + return layer.map(point => { |
| 84 | + allMin.push(point[0]) |
| 85 | + allMax.push(point[1]) |
| 86 | + |
| 87 | + return { |
| 88 | + ...point, |
| 89 | + value: point.data[layer.key] as number, |
| 90 | + } |
| 91 | + }) |
| 92 | + }) |
| 93 | + |
| 94 | + const minValue = Math.min(...allMin) |
| 95 | + const maxValue = Math.max(...allMax) |
| 96 | + |
| 97 | + return [ |
| 98 | + layers, |
| 99 | + scalePoint<number>() |
| 100 | + .domain(Array.from({ length: data.length }, (_, i) => i)) |
| 101 | + .range([0, width]), |
| 102 | + scaleLinear().domain([minValue, maxValue]).range([height, 0]), |
| 103 | + ] |
| 104 | + }, [stack, data, width, height]) |
| 105 | + |
| 106 | + const theme = useTheme() |
| 107 | + const getColor = useOrdinalColorScale<Omit<StreamLayerData, 'label' | 'color' | 'data'>>( |
| 108 | + colors, |
| 109 | + 'id' |
| 110 | + ) |
| 111 | + const getBorderColor = useInheritedColor<StreamLayerData>(borderColor, theme) |
| 112 | + |
| 113 | + const getDotSize = useMemo(() => (typeof dotSize === 'function' ? dotSize : () => dotSize), [ |
| 114 | + dotSize, |
| 115 | + ]) |
| 116 | + const getDotColor = useInheritedColor(dotColor, theme) |
| 117 | + const getDotBorderWidth = useMemo( |
| 118 | + () => (typeof dotBorderWidth === 'function' ? dotBorderWidth : () => dotBorderWidth), |
| 119 | + [dotBorderWidth] |
| 120 | + ) |
| 121 | + const getDotBorderColor = useInheritedColor(dotBorderColor, theme) |
| 122 | + |
| 123 | + const getLabel = usePropertyAccessor< |
| 124 | + Omit<StreamLayerData, 'label' | 'color' | 'data'>, |
| 125 | + string | number |
| 126 | + >(label) |
| 127 | + const formatValue = useValueFormatter(valueFormat) |
| 128 | + |
| 129 | + const enhancedLayers: StreamLayerData[] = useMemo( |
| 130 | + () => |
| 131 | + layers.map((points, layerIndex) => { |
| 132 | + const computedPoints: StreamLayerDatum[] = points.map((point, i) => ({ |
| 133 | + layerId: keys[layerIndex], |
| 134 | + layerLabel: '', |
| 135 | + index: i, |
| 136 | + color: '', |
| 137 | + x: xScale(i) as number, |
| 138 | + value: point.value, |
| 139 | + formattedValue: formatValue(point.value), |
| 140 | + y1: yScale(point[0]), |
| 141 | + y2: yScale(point[1]), |
| 142 | + })) |
| 143 | + |
| 144 | + const layer: Omit<StreamLayerData, 'label' | 'color' | 'data'> = { |
| 145 | + id: keys[layerIndex] as string, |
| 146 | + path: areaGenerator(computedPoints) as string, |
| 147 | + } |
| 148 | + |
| 149 | + const layerWithComputedProperties: Omit<StreamLayerData, 'data'> = { |
| 150 | + ...layer, |
| 151 | + label: getLabel(layer), |
| 152 | + color: getColor(layer), |
| 153 | + } |
| 154 | + |
| 155 | + return { |
| 156 | + ...layerWithComputedProperties, |
| 157 | + data: computedPoints.map(point => { |
| 158 | + point.layerLabel = layerWithComputedProperties.label |
| 159 | + point.color = layerWithComputedProperties.color |
| 160 | + |
| 161 | + return point |
| 162 | + }), |
| 163 | + } |
| 164 | + }), |
| 165 | + [layers, keys, getLabel, areaGenerator, getColor, xScale, yScale] |
| 166 | + ) |
| 167 | + |
| 168 | + const slices: StreamSliceData[] = useMemo( |
| 169 | + () => |
| 170 | + Array.from({ length: data.length }, (_, i) => { |
| 171 | + const sliceStack = enhancedLayers |
| 172 | + .map(layer => layer.data[i]) |
| 173 | + .sort((a, b) => a.y2 - b.y2) |
| 174 | + |
| 175 | + return { |
| 176 | + index: i, |
| 177 | + x: enhancedLayers[0].data[i].x, |
| 178 | + stack: sliceStack, |
| 179 | + } |
| 180 | + }), |
| 181 | + [data.length, enhancedLayers] |
| 182 | + ) |
| 183 | + |
| 184 | + return { |
| 185 | + xScale, |
| 186 | + yScale, |
| 187 | + layers: enhancedLayers, |
| 188 | + slices, |
| 189 | + getBorderColor, |
| 190 | + getDotSize, |
| 191 | + getDotColor, |
| 192 | + getDotBorderWidth, |
| 193 | + getDotBorderColor, |
| 194 | + } |
| 195 | +} |
0 commit comments