semiotic 2.0.3 → 3.0.0-beta.2

package/ai/dist/src/components/geometry/lineDrawing.js

@@ -0,0 +1,356 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dividedLine = exports.bumpChart = exports.cumulativeLine = exports.lineChart = exports.stackedArea = exports.differenceLine = exports.projectLineData = exports.projectSummaryData = void 0;
+exports.funnelize = funnelize;
+const d3_array_1 = require("d3-array");
+const datesForUnique = (d) => (d instanceof Date ? d.getTime() : d);
+const projectSummaryData = ({ data, summaryDataAccessor, xAccessor, yAccessor }) => {
+    const projectedData = [];
+    summaryDataAccessor.forEach((actualSummaryAccessor) => {
+        xAccessor.forEach((actualXAccessor) => {
+            yAccessor.forEach((actualYAccessor) => {
+                const projection = (d) => actualSummaryAccessor(d).map((p, q) => [
+                    actualXAccessor(p, q),
+                    actualYAccessor(p, q)
+                ]);
+                data.forEach((d) => {
+                    projectedData.push({
+                        ...d,
+                        _baseData: actualSummaryAccessor(d),
+                        _xyfCoordinates: projection(d)
+                    });
+                });
+            });
+        });
+    });
+    return projectedData;
+};
+exports.projectSummaryData = projectSummaryData;
+const projectLineData = ({ data, lineDataAccessor, xProp, xPropTop, xPropBottom, yProp, yPropTop, yPropBottom, xAccessor, yAccessor }) => {
+    if (!Array.isArray(data)) {
+        data = [data];
+    }
+    const projectedLine = [];
+    lineDataAccessor.forEach((actualLineAccessor, lineIndex) => {
+        xAccessor.forEach((actualXAccessor, xIndex) => {
+            yAccessor.forEach((actualYAccessor, yIndex) => {
+                data.forEach((d) => {
+                    const originalLineData = { ...d, xIndex, yIndex, lineIndex };
+                    originalLineData.data = actualLineAccessor(d).map((p, q) => {
+                        const originalCoords = { data: p };
+                        originalCoords[xProp] = actualXAccessor(p, q);
+                        originalCoords[xPropTop] = originalCoords[xProp];
+                        originalCoords[xPropBottom] = originalCoords[xProp];
+                        originalCoords[yProp] = actualYAccessor(p, q);
+                        originalCoords[yPropTop] = originalCoords[yProp];
+                        originalCoords[yPropBottom] = originalCoords[yProp];
+                        return originalCoords;
+                    });
+                    originalLineData.key = originalLineData.key || projectedLine.length;
+                    projectedLine.push(originalLineData);
+                });
+            });
+        });
+    });
+    return projectedLine;
+};
+exports.projectLineData = projectLineData;
+const differenceLine = ({ data, yProp, yPropTop, yPropBottom }) => {
+    data.forEach((l, i) => {
+        l.data.forEach((point, q) => {
+            const otherLine = i === 0 ? 1 : 0;
+            if (point[yProp] > data[otherLine].data[q][yProp]) {
+                point[yPropBottom] = data[otherLine].data[q][yProp];
+                point[yPropTop] = point[yProp];
+            }
+            else {
+                point[yPropTop] = point[yProp];
+                point[yPropBottom] = point[yProp];
+            }
+        });
+    });
+    return data;
+};
+exports.differenceLine = differenceLine;
+const stackedArea = ({ type = "stackedarea", data, xProp, yProp, yPropMiddle, sort, yPropTop, yPropBottom }) => {
+    const valueMap = new Map();
+    const lineSums = data.map(() => 0);
+    let lineIndex = 0;
+    for (const line of data) {
+        /*
+          After we calculate this, we then sort the lines (and the value used for the sorting is in this for loop)
+          So, we need to know their original index order in order to use the naively populated coordinate array in valueMap
+          Otherwise the coordinates in the map will be in different order than the sorted order of the lines
+        */
+        line.__lineIndex = lineIndex;
+        for (const coord of line.data) {
+            const coordX = datesForUnique(coord[xProp]);
+            lineSums[lineIndex] += coord[yProp];
+            if (!valueMap.has(coordX)) {
+                valueMap.set(coordX, []);
+            }
+            valueMap.get(coordX)[lineIndex] = coord;
+        }
+        lineIndex++;
+    }
+    let stackSort = (a, b) => lineSums[b.key] - lineSums[a.key];
+    if (type === "stackedpercent-invert" || type === "stackedarea-invert") {
+        stackSort = (a, b) => lineSums[a.key] - lineSums[b.key];
+    }
+    sort = sort === undefined ? stackSort : sort;
+    if (sort !== null) {
+        data = data.sort(sort);
+    }
+    const lineIndexSortLookup = data.map((line) => line.__lineIndex);
+    for (const [, coordsAtX] of valueMap) {
+        let negativeOffset = 0;
+        let positiveOffset = 0;
+        const positiveStepTotal = (0, d3_array_1.sum)(coordsAtX, (d) => d?.[yProp] > 0 ? d[yProp] : 0);
+        const negativeStepTotal = (0, d3_array_1.sum)(coordsAtX, (d) => d?.[yProp] < 0 ? d[yProp] : 0);
+        for (const newIndex of lineIndexSortLookup) {
+            const l = coordsAtX[newIndex];
+            if (l) {
+                if (l[yProp] < 0) {
+                    if (type === "linepercent" ||
+                        type === "stackedpercent" ||
+                        type === "stackedpercent-invert") {
+                        const percent = l[yProp] / negativeStepTotal;
+                        l.percent = percent;
+                        if (type === "linepercent") {
+                            l[yPropBottom] =
+                                l[yPropBottom] =
+                                    l[yPropTop] =
+                                        l[yPropMiddle] =
+                                            percent;
+                        }
+                        else {
+                            const adjustment = negativeStepTotal >= 0 ? 0 : percent;
+                            l[yPropBottom] =
+                                negativeStepTotal === 0
+                                    ? 0
+                                    : -(negativeOffset / negativeStepTotal);
+                            l[yPropTop] = l[yPropBottom] - adjustment;
+                            l[yPropMiddle] = l[yPropBottom] - adjustment / 2;
+                        }
+                    }
+                    else {
+                        l[yPropBottom] = negativeOffset;
+                        l[yPropTop] = negativeOffset + l[yProp];
+                        l[yPropMiddle] = negativeOffset + l[yProp] / 2;
+                    }
+                    negativeOffset += l[yProp];
+                }
+                else {
+                    if (type === "linepercent" ||
+                        type === "stackedpercent" ||
+                        type === "stackedpercent-invert") {
+                        const percent = l[yProp] / positiveStepTotal;
+                        l.percent = percent;
+                        if (type === "linepercent") {
+                            l[yPropBottom] = l[yPropTop] = l[yPropMiddle] = percent;
+                        }
+                        else {
+                            const adjustment = positiveStepTotal <= 0 ? 0 : percent;
+                            l[yPropBottom] =
+                                positiveStepTotal === 0 ? 0 : positiveOffset / positiveStepTotal;
+                            l[yPropTop] = l[yPropBottom] + adjustment;
+                            l[yPropMiddle] = l[yPropBottom] + adjustment / 2;
+                        }
+                    }
+                    else {
+                        l[yPropBottom] = positiveOffset;
+                        l[yPropTop] = positiveOffset + l[yProp];
+                        l[yPropMiddle] = positiveOffset + l[yProp] / 2;
+                    }
+                    positiveOffset += l[yProp];
+                }
+            }
+        }
+    }
+    return data;
+};
+exports.stackedArea = stackedArea;
+const lineChart = ({ data, y1, x1, yPropTop, yPropMiddle, yPropBottom, xPropTop, xPropMiddle, xPropBottom }) => {
+    if (y1) {
+        for (const line of data) {
+            for (const point of line.data) {
+                point[yPropBottom] = y1(point);
+                // Use top position for hover so overlapping-area hover points
+                // align with the visible line rather than compressing toward the baseline.
+                point[yPropMiddle] = point[yPropTop];
+            }
+        }
+    }
+    if (x1) {
+        for (const line of data) {
+            for (const point of line.data) {
+                point[xPropBottom] = x1(point);
+                point[xPropMiddle] = (point[xPropBottom] + point[xPropTop]) / 2;
+            }
+        }
+    }
+    return data;
+};
+exports.lineChart = lineChart;
+const cumulativeLine = ({ data, y1, yPropTop, yPropMiddle, yPropBottom, type = "cumulative" }) => {
+    for (const line of data) {
+        let cumulativeValue = 0;
+        const dataArray = type === "cumulative-reverse" ? line.data.reverse() : line.data;
+        for (const point of dataArray) {
+            cumulativeValue += point[yPropTop];
+            point[yPropBottom] =
+                point[yPropTop] =
+                    point[yPropMiddle] =
+                        cumulativeValue;
+            if (y1) {
+                point[yPropBottom] = y1(point);
+                point[yPropMiddle] = point[yPropBottom] + point[yPropTop] / 2;
+            }
+        }
+    }
+    return data;
+};
+exports.cumulativeLine = cumulativeLine;
+const bumpChart = ({ type = "bumpline", data, xProp, yProp, yPropMiddle, yPropTop, yPropBottom }) => {
+    const uniqXValues = new Map();
+    for (const line of data) {
+        for (const point of line.data) {
+            const xValue = datesForUnique(point[xProp]);
+            if (!uniqXValues.has(xValue)) {
+                uniqXValues.set(xValue, []);
+            }
+            uniqXValues.get(xValue).push(point);
+        }
+    }
+    let bumpSort = (a, b) => {
+        if (a[yProp] > b[yProp]) {
+            return 1;
+        }
+        if (a[yProp] < b[yProp]) {
+            return -1;
+        }
+        return -1;
+    };
+    if (type === "bumparea-invert" || type === "bumpline-invert") {
+        bumpSort = (a, b) => {
+            if (a[yProp] < b[yProp]) {
+                return 1;
+            }
+            if (a[yProp] > b[yProp]) {
+                return -1;
+            }
+            return -1;
+        };
+    }
+    for (const [, pointsAtXArray] of uniqXValues) {
+        let negativeOffset = 0;
+        let positiveOffset = 0;
+        pointsAtXArray.sort(bumpSort);
+        let rank = 1;
+        for (const point of pointsAtXArray) {
+            point._XYFrameRank;
+            if (type === "bumparea" || type === "bumparea-invert") {
+                if (point[yProp] < 0) {
+                    point[yPropTop] = negativeOffset + point[yProp];
+                    point[yPropMiddle] = negativeOffset + point[yProp] / 2;
+                    point[yPropBottom] = negativeOffset;
+                    negativeOffset += point[yProp];
+                }
+                else {
+                    point[yPropTop] = positiveOffset + point[yProp];
+                    point[yPropMiddle] = positiveOffset + point[yProp] / 2;
+                    point[yPropBottom] = positiveOffset;
+                    positiveOffset += point[yProp];
+                }
+            }
+            else {
+                point[yProp] = rank;
+                point[yPropTop] = rank;
+                point[yPropBottom] = rank;
+            }
+            rank++;
+        }
+    }
+    return data;
+};
+exports.bumpChart = bumpChart;
+const dividedLine = (parameters, points, searchIterations = 10) => {
+    let currentParameters = parameters(points[0], 0);
+    let currentPointsArray = [];
+    const dividedLinesData = [
+        { key: currentParameters, points: currentPointsArray }
+    ];
+    points.forEach((point, pointI) => {
+        const newParameters = parameters(point, pointI);
+        let matchingParams = newParameters === currentParameters;
+        const stringNewParams = JSON.stringify(newParameters);
+        const stringCurrentParams = JSON.stringify(currentParameters);
+        if (typeof currentParameters === "object") {
+            matchingParams = stringNewParams === stringCurrentParams;
+        }
+        if (matchingParams) {
+            currentPointsArray.push(point);
+        }
+        else {
+            const lastPoint = currentPointsArray[currentPointsArray.length - 1];
+            let pointA = lastPoint;
+            let pointB = point;
+            let stringBParams = stringNewParams;
+            let x = 0;
+            while (x < searchIterations && stringNewParams === stringBParams) {
+                const keys = Object.keys(pointA);
+                const findPoints = simpleSearchFunction({
+                    pointA,
+                    pointB,
+                    currentParameters,
+                    parameters,
+                    keys
+                });
+                pointA = findPoints[0];
+                pointB = findPoints[1];
+                stringBParams = JSON.stringify(parameters(pointB));
+                x++;
+            }
+            currentPointsArray.push(pointB);
+            currentPointsArray = [pointB, point];
+            dividedLinesData.push({ key: newParameters, points: currentPointsArray });
+            currentParameters = newParameters;
+        }
+    });
+    return dividedLinesData;
+};
+exports.dividedLine = dividedLine;
+function simpleSearchFunction({ pointA, pointB, currentParameters, parameters, keys }) {
+    const betweenPoint = {};
+    keys.forEach((key) => {
+        betweenPoint[key] =
+            typeof pointA[key] === "number"
+                ? (pointA[key] + pointB[key]) / 2
+                : undefined;
+    });
+    const stringBetween = JSON.stringify(parameters(betweenPoint));
+    const stringCurrent = JSON.stringify(currentParameters);
+    if (stringBetween === stringCurrent) {
+        return [betweenPoint, pointB];
+    }
+    return [pointA, betweenPoint];
+}
+function funnelize({ data, steps, key }) {
+    const funnelData = [];
+    if (!Array.isArray(data)) {
+        data = [data];
+    }
+    if (!steps) {
+        steps = data.map((d) => Object.keys(d)).reduce((a, b) => a.concat(b), []);
+    }
+    data.forEach((datum, i) => {
+        const datumKey = key ? datum[key] : i;
+        steps.forEach((step) => {
+            const funnelDatum = { funnelKey: datumKey, stepName: "", stepValue: 0 };
+            funnelDatum.stepName = step;
+            funnelDatum.stepValue = datum[step] ? datum[step] : 0;
+            funnelData.push(funnelDatum);
+        });
+    });
+    return funnelData;
+}

package/ai/dist/src/components/geometry/sankeyLinks.js

@@ -0,0 +1,331 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.areaLink = void 0;
+exports.circularAreaLink = circularAreaLink;
+const d3_interpolate_1 = require("d3-interpolate");
+const d3_shape_1 = require("d3-shape");
+const dedupeRibbonPoints = (weight = 1) => (p, c) => {
+    const l = p[p.length - 1];
+    if (!l ||
+        Math.round(l.x / weight) !== Math.round(c.x / weight) ||
+        Math.round(l.y / weight) !== Math.round(c.y / weight)) {
+        p.push(c);
+    }
+    return p;
+};
+function linearRibbon() {
+    const _lineConstructor = (0, d3_shape_1.line)();
+    let _xAccessor = function (d) {
+        return d.x;
+    };
+    let _yAccessor = function (d) {
+        return d.y;
+    };
+    let _rAccessor = function (d) {
+        return d.r;
+    };
+    let _interpolator = d3_shape_1.curveLinearClosed;
+    function _ribbon(pathData) {
+        if (pathData.multiple) {
+            const original_r = _rAccessor;
+            const parallelTotal = pathData.multiple.reduce((p, c) => p + c.weight, 0);
+            _rAccessor = () => parallelTotal;
+            const totalPoints = buildRibbon(pathData.points);
+            let currentPoints = totalPoints
+                .filter((d) => d.direction === "forward")
+                .reduce(dedupeRibbonPoints(), []);
+            const allRibbons = [];
+            pathData.multiple.forEach((siblingPath, siblingI) => {
+                _rAccessor = () => siblingPath.weight;
+                const currentRibbon = buildRibbon(currentPoints);
+                allRibbons.push(currentRibbon);
+                const nextSibling = pathData.multiple[siblingI + 1];
+                if (nextSibling) {
+                    const currentLeftSide = currentRibbon
+                        .reverse()
+                        .filter((d) => d.direction === "back")
+                        .reduce(dedupeRibbonPoints(), []);
+                    _rAccessor = () => nextSibling.weight;
+                    const leftHandInflatedRibbon = buildRibbon(currentLeftSide);
+                    currentPoints = leftHandInflatedRibbon
+                        .reverse()
+                        .filter((d) => d.direction === "back")
+                        .reduce(dedupeRibbonPoints(), []);
+                }
+            });
+            _rAccessor = original_r;
+            return allRibbons.map((d) => _lineConstructor.x(_xAccessor).y(_yAccessor).curve(_interpolator)(d));
+        }
+        const bothPoints = buildRibbon(pathData).reduce(dedupeRibbonPoints(), []);
+        return _lineConstructor.x(_xAccessor).y(_yAccessor).curve(_interpolator)(bothPoints);
+    }
+    _ribbon.x = function (_value) {
+        if (!arguments.length)
+            return _xAccessor;
+        _xAccessor = _value;
+        return _ribbon;
+    };
+    _ribbon.y = function (_value) {
+        if (!arguments.length)
+            return _yAccessor;
+        _yAccessor = _value;
+        return _ribbon;
+    };
+    _ribbon.r = function (_value) {
+        if (!arguments.length)
+            return _rAccessor;
+        _rAccessor = _value;
+        return _ribbon;
+    };
+    _ribbon.interpolate = function (_value) {
+        if (!arguments.length)
+            return _interpolator;
+        _interpolator = _value;
+        return _ribbon;
+    };
+    return _ribbon;
+    function offsetEdge(d) {
+        const diffX = _yAccessor(d.target) - _yAccessor(d.source);
+        const diffY = _xAccessor(d.target) - _xAccessor(d.source);
+        const angle0 = Math.atan2(diffY, diffX) + Math.PI / 2;
+        const angle1 = angle0 + Math.PI * 0.5;
+        const angle2 = angle0 + Math.PI * 0.5;
+        const x1 = _xAccessor(d.source) + _rAccessor(d.source) * Math.cos(angle1);
+        const y1 = _yAccessor(d.source) - _rAccessor(d.source) * Math.sin(angle1);
+        const x2 = _xAccessor(d.target) + _rAccessor(d.target) * Math.cos(angle2);
+        const y2 = _yAccessor(d.target) - _rAccessor(d.target) * Math.sin(angle2);
+        return { x1: x1, y1: y1, x2: x2, y2: y2 };
+    }
+    function buildRibbon(points) {
+        const bothCode = [];
+        let x = 0;
+        let transformedPoints = { x1: 0, y1: 0, x2: 0, y2: 0 };
+        while (x < points.length) {
+            if (x !== points.length - 1) {
+                transformedPoints = offsetEdge({
+                    source: points[x],
+                    target: points[x + 1]
+                });
+                const p1 = {
+                    x: transformedPoints.x1,
+                    y: transformedPoints.y1,
+                    direction: "forward"
+                };
+                const p2 = {
+                    x: transformedPoints.x2,
+                    y: transformedPoints.y2,
+                    direction: "forward"
+                };
+                bothCode.push(p1, p2);
+                if (bothCode.length > 3) {
+                    const l = bothCode.length - 1;
+                    const lineA = { a: bothCode[l - 3], b: bothCode[l - 2] };
+                    const lineB = { a: bothCode[l - 1], b: bothCode[l] };
+                    const intersect = findIntersect(lineA.a.x, lineA.a.y, lineA.b.x, lineA.b.y, lineB.a.x, lineB.a.y, lineB.b.x, lineB.b.y);
+                    if (intersect.found === true) {
+                        lineA.b.x = intersect.x;
+                        lineA.b.y = intersect.y;
+                        lineB.a.x = intersect.x;
+                        lineB.a.y = intersect.y;
+                    }
+                }
+            }
+            x++;
+        }
+        x--;
+        //Back
+        while (x >= 0) {
+            if (x !== 0) {
+                transformedPoints = offsetEdge({
+                    source: points[x],
+                    target: points[x - 1]
+                });
+                const p1 = {
+                    x: transformedPoints.x1,
+                    y: transformedPoints.y1,
+                    direction: "back"
+                };
+                const p2 = {
+                    x: transformedPoints.x2,
+                    y: transformedPoints.y2,
+                    direction: "back"
+                };
+                bothCode.push(p1, p2);
+                if (bothCode.length > 3) {
+                    const l = bothCode.length - 1;
+                    const lineA = { a: bothCode[l - 3], b: bothCode[l - 2] };
+                    const lineB = { a: bothCode[l - 1], b: bothCode[l] };
+                    const intersect = findIntersect(lineA.a.x, lineA.a.y, lineA.b.x, lineA.b.y, lineB.a.x, lineB.a.y, lineB.b.x, lineB.b.y);
+                    if (intersect.found === true) {
+                        lineA.b.x = intersect.x;
+                        lineA.b.y = intersect.y;
+                        lineB.a.x = intersect.x;
+                        lineB.a.y = intersect.y;
+                    }
+                }
+            }
+            x--;
+        }
+        return bothCode;
+    }
+    function findIntersect(l1x1, l1y1, l1x2, l1y2, l2x1, l2y1, l2x2, l2y2) {
+        let a, b;
+        const result = {
+            x: null,
+            y: null,
+            found: false
+        };
+        const d = (l2y2 - l2y1) * (l1x2 - l1x1) - (l2x2 - l2x1) * (l1y2 - l1y1);
+        if (d === 0) {
+            return result;
+        }
+        a = l1y1 - l2y1;
+        b = l1x1 - l2x1;
+        const n1 = (l2x2 - l2x1) * a - (l2y2 - l2y1) * b;
+        const n2 = (l1x2 - l1x1) * a - (l1y2 - l1y1) * b;
+        a = n1 / d;
+        b = n2 / d;
+        result.x = l1x1 + a * (l1x2 - l1x1);
+        result.y = l1y1 + a * (l1y2 - l1y1);
+        if (a > 0 && a < 1 && b > 0 && b < 1) {
+            result.found = true;
+        }
+        return result;
+    }
+}
+const curvature = 0.5;
+const ribbonLink = (d) => {
+    const diff = d.direction === "down"
+        ? Math.abs(d.target.y - d.source.y)
+        : Math.abs(d.source.x - d.target.x);
+    // const halfWidth = d.width / 2
+    const testCoordinates = d.direction === "down"
+        ? [
+            {
+                x: d.y0,
+                y: d.source.y
+            },
+            {
+                x: d.y0,
+                y: d.source.y + diff / 3
+            },
+            {
+                x: d.y1,
+                y: d.target.y - diff / 3
+            },
+            {
+                x: d.y1,
+                y: d.target.y
+            }
+        ]
+        : [
+            {
+                x: d.source.x0,
+                y: d.y0
+            },
+            {
+                x: d.source.x0 + diff / 3,
+                y: d.y0
+            },
+            {
+                x: d.target.x0 - diff / 3,
+                y: d.y1
+            },
+            {
+                x: d.target.x0,
+                y: d.y1
+            }
+        ];
+    const linkGenerator = linearRibbon();
+    linkGenerator.x((d) => d.x);
+    linkGenerator.y((d) => d.y);
+    linkGenerator.r(() => d.sankeyWidth / 2);
+    return linkGenerator(testCoordinates);
+};
+const areaLink = (d) => {
+    let x0, x1, x2, x3, y0, y1, xi, y2, y3;
+    if (d.direction === "down") {
+        x0 = d.y0 - d.sankeyWidth / 2;
+        x1 = d.y1 - d.sankeyWidth / 2;
+        x2 = d.y1 + d.sankeyWidth / 2;
+        x3 = d.y0 + d.sankeyWidth / 2;
+        y0 = d.source.y1;
+        y1 = d.target.y0;
+        xi = (0, d3_interpolate_1.interpolateNumber)(y0, y1);
+        y2 = xi(curvature);
+        y3 = xi(1 - curvature);
+        return `M${x0},${y0}C${x0},${y2} ${x1},${y3} ${x1},${y1}L${x2},${y1}C${x2},${y3} ${x3},${y2} ${x3},${y0}Z`;
+    }
+    ;
+    (x0 = d.source.x1), // eslint-disable-line no-sequences
+        (x1 = d.target.x0),
+        (xi = (0, d3_interpolate_1.interpolateNumber)(x0, x1)),
+        (x2 = xi(curvature)),
+        (x3 = xi(1 - curvature)),
+        (y0 = d.y0 - d.sankeyWidth / 2),
+        (y1 = d.y1 - d.sankeyWidth / 2),
+        (y2 = d.y1 + d.sankeyWidth / 2),
+        (y3 = d.y0 + d.sankeyWidth / 2);
+    return `M${x0},${y0}C${x2},${y0} ${x3},${y1} ${x1},${y1}L${x1},${y2}C${x3},${y2} ${x2},${y3} ${x0},${y3}Z`;
+};
+exports.areaLink = areaLink;
+function circularAreaLink(link) {
+    const linkGenerator = linearRibbon();
+    linkGenerator.x((d) => d.x);
+    linkGenerator.y((d) => d.y);
+    linkGenerator.r(() => link.sankeyWidth / 2);
+    const xyForLink = link.direction === "down"
+        ? [
+            {
+                x: link.circularPathData.sourceY,
+                y: link.circularPathData.sourceX
+            },
+            {
+                x: link.circularPathData.sourceY,
+                y: link.circularPathData.leftFullExtent
+            },
+            {
+                x: link.circularPathData.verticalFullExtent,
+                y: link.circularPathData.leftFullExtent
+            },
+            {
+                x: link.circularPathData.verticalFullExtent,
+                y: link.circularPathData.rightFullExtent
+            },
+            {
+                x: link.circularPathData.targetY,
+                y: link.circularPathData.rightFullExtent
+            },
+            {
+                x: link.circularPathData.targetY,
+                y: link.circularPathData.targetX
+            }
+        ]
+        : [
+            {
+                x: link.circularPathData.sourceX,
+                y: link.circularPathData.sourceY
+            },
+            {
+                x: link.circularPathData.leftFullExtent,
+                y: link.circularPathData.sourceY
+            },
+            {
+                x: link.circularPathData.leftFullExtent,
+                y: link.circularPathData.verticalFullExtent
+            },
+            {
+                x: link.circularPathData.rightFullExtent,
+                y: link.circularPathData.verticalFullExtent
+            },
+            {
+                x: link.circularPathData.rightFullExtent,
+                y: link.circularPathData.targetY
+            },
+            {
+                x: link.circularPathData.targetX,
+                y: link.circularPathData.targetY
+            }
+        ];
+    return linkGenerator(xyForLink);
+}