semiotic 3.0.0-beta.2 → 3.0.0-beta.4

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

@@ -1,356 +0,0 @@
-"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

@@ -1,331 +0,0 @@
-"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);
-}