semiotic 2.0.2 → 3.0.0-beta.1

package/ai/dist/src/components/svg/ckbinsRenderer.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ckBinsRenderFn = ckBinsRenderFn;
+const d3_scale_1 = require("d3-scale");
+const ckmeans_1 = require("./ckmeans");
+function ckBinsRenderFn(props) {
+    const { data, type, renderMode, eventListenersGenerator, styleFn, classFn, projection, adjustedSize } = props;
+    const renderedSummaryMarks = [];
+    const summaryXYCoords = [];
+    const keys = Object.keys(data);
+    let maxClusterSize = 0;
+    const allBins = [];
+    keys.forEach((key, summaryI) => {
+        const summary = data[key];
+        const eventListeners = eventListenersGenerator(summary, summaryI);
+        const columnWidth = summary.width;
+        const thisSummaryData = summary.pieceData.sort((a, b) => a.value - b.value);
+        const firstElement = thisSummaryData[0];
+        const lastElement = thisSummaryData[thisSummaryData.length - 1];
+        const binScale = (0, d3_scale_1.scaleLinear)()
+            .domain([firstElement.value, lastElement.value])
+            .range([firstElement.scaledValue, lastElement.scaledValue]);
+        const calculatedSummaryStyle = styleFn(thisSummaryData[0].data, summaryI);
+        const calculatedSummaryClass = classFn(thisSummaryData[0].data, summaryI);
+        const binData = thisSummaryData.map((d) => d.value);
+        const clusters = 5;
+        const ckstops = (0, ckmeans_1.ckmeans)(binData, clusters);
+        let ckBins = [];
+        ckstops.forEach((ckstop, i) => {
+            const start = ckstop;
+            const end = ckstops[i + 1] ?? lastElement.value;
+            ckBins.push({
+                start,
+                end,
+                key,
+                summary,
+                calculatedSummaryStyle,
+                calculatedSummaryClass,
+                scaledStart: binScale(start),
+                scaledEnd: binScale(end),
+                values: []
+            });
+        });
+        allBins.push(ckBins);
+        let binI = 0;
+        for (const datapoint of thisSummaryData) {
+            if (ckBins[binI].end <= datapoint.value) {
+                if (ckBins[binI + 1]) {
+                    binI++;
+                }
+            }
+            ckBins[binI].values.push(datapoint);
+        }
+        ckBins.forEach((ckbin) => {
+            const clusterSize = ckbin.values.length;
+            maxClusterSize = Math.max(clusterSize, maxClusterSize);
+        });
+    });
+    allBins.forEach((ckBins, index) => {
+        const CKBinElements = ckBins.map((ckBin) => {
+            const { key, summary, calculatedSummaryStyle, calculatedSummaryClass } = ckBin;
+            const { fill = "black", stroke = "black" } = calculatedSummaryStyle;
+            const lightScale = (0, d3_scale_1.scaleLinear)()
+                .domain([1, maxClusterSize])
+                .range(["white", fill]);
+            return {
+                markType: "rect",
+                x: ckBin.scaledStart,
+                width: ckBin.scaledEnd - ckBin.scaledStart,
+                y: ckBin.summary.x,
+                height: ckBin.summary.width,
+                style: Object.assign({ strokeWidth: 2 }, calculatedSummaryStyle, {
+                    fill: lightScale(ckBin.values.length),
+                    strokeWidth: 1,
+                    stroke
+                })
+            };
+        });
+        renderedSummaryMarks.push({
+            containerProps: {
+                //        className: calculatedSummaryClass,
+                transform: "",
+                key: `summaryPiece-${index}`,
+                role: "img",
+                tabIndex: -1
+            },
+            //These are drawn items
+            elements: CKBinElements
+        });
+    });
+    return { marks: renderedSummaryMarks, xyPoints: summaryXYCoords };
+}

package/ai/dist/src/components/svg/ckmeans.js

@@ -0,0 +1,238 @@
+"use strict";
+/**
+ * Ckmeans algorithm from d3-scale-cluster
+ *
+ * Much of the code that lies within was taken from the simple-statistics library,
+ * which offers a javascript implementation of the ckmeans algorithm originally
+ * designed by Haizhou Wang and Mingzhou Song
+ *
+ * https://cran.r-project.org/web/packages/Ckmeans.1d.dp/
+ * https://github.com/simple-statistics/simple-statistics
+ *
+ * The simple-statistics software license is included below
+ *
+ * --
+ *
+ * ISC License
+ *
+ * Copyright (c) 2014, Tom MacWright
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+ * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+ * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+ * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+ * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ckmeans = ckmeans;
+function numericSort(array) {
+    return (array
+        // ensure the array is not changed in-place
+        .slice()
+        // comparator function that treats input as numeric
+        .sort(function (a, b) {
+        return a - b;
+    }));
+}
+function uniqueCountSorted(input) {
+    var uniqueValueCount = 0;
+    var lastSeenValue;
+    for (var i = 0; i < input.length; i++) {
+        if (i === 0 || input[i] !== lastSeenValue) {
+            lastSeenValue = input[i];
+            uniqueValueCount++;
+        }
+    }
+    return uniqueValueCount;
+}
+function makeMatrix(columns, rows) {
+    var matrix = [];
+    for (var i = 0; i < columns; i++) {
+        var column = [];
+        for (var j = 0; j < rows; j++) {
+            column.push(0);
+        }
+        matrix.push(column);
+    }
+    return matrix;
+}
+function ssq(j, i, sumX, sumXsq) {
+    var sji; // s(j, i)
+    if (j > 0) {
+        var muji = (sumX[i] - sumX[j - 1]) / (i - j + 1); // mu(j, i)
+        sji = sumXsq[i] - sumXsq[j - 1] - (i - j + 1) * muji * muji;
+    }
+    else {
+        sji = sumXsq[i] - (sumX[i] * sumX[i]) / (i + 1);
+    }
+    return sji < 0 ? 0 : sji;
+}
+function fillMatrixColumn(imin, imax, column, matrix, backtrackMatrix, sumX, sumXsq) {
+    if (imin > imax) {
+        return;
+    }
+    // Start at midpoint between imin and imax
+    var i = Math.floor((imin + imax) / 2);
+    // Initialization of S[k][i]:
+    matrix[column][i] = matrix[column - 1][i - 1];
+    backtrackMatrix[column][i] = i;
+    var jlow = column; // the lower end for j
+    if (imin > column) {
+        jlow = Math.max(jlow, backtrackMatrix[column][imin - 1] || 0);
+    }
+    jlow = Math.max(jlow, backtrackMatrix[column - 1][i] || 0);
+    var jhigh = i - 1; // the upper end for j
+    if (imax < matrix[0].length - 1) {
+        jhigh = Math.min(jhigh, backtrackMatrix[column][imax + 1] || 0);
+    }
+    var sji;
+    var sjlowi;
+    var ssqjlow;
+    var ssqj;
+    for (var j = jhigh; j >= jlow; --j) {
+        // compute s(j,i)
+        sji = ssq(j, i, sumX, sumXsq);
+        // MS May 11, 2016 Added:
+        if (sji + matrix[column - 1][jlow - 1] >= matrix[column][i]) {
+            break;
+        }
+        // Examine the lower bound of the cluster border
+        // compute s(jlow, i)
+        sjlowi = ssq(jlow, i, sumX, sumXsq);
+        ssqjlow = sjlowi + matrix[column - 1][jlow - 1];
+        if (ssqjlow < matrix[column][i]) {
+            // shrink the lower bound
+            matrix[column][i] = ssqjlow;
+            backtrackMatrix[column][i] = jlow;
+        }
+        jlow++;
+        ssqj = sji + matrix[column - 1][j - 1];
+        if (ssqj < matrix[column][i]) {
+            matrix[column][i] = ssqj;
+            backtrackMatrix[column][i] = j;
+        }
+    }
+    fillMatrixColumn(imin, i - 1, column, matrix, backtrackMatrix, sumX, sumXsq);
+    fillMatrixColumn(i + 1, imax, column, matrix, backtrackMatrix, sumX, sumXsq);
+}
+function fillMatrices(data, matrix, backtrackMatrix) {
+    var nValues = matrix[0].length;
+    var sumX = new Array(nValues);
+    var sumXsq = new Array(nValues);
+    // Use the median to shift values of x to improve numerical stability
+    var shift = data[Math.floor(nValues / 2)];
+    // Initialize first row in matrix & backtrackMatrix
+    for (var i = 0; i < nValues; ++i) {
+        if (i === 0) {
+            sumX[0] = data[0] - shift;
+            sumXsq[0] = (data[0] - shift) * (data[0] - shift);
+        }
+        else {
+            sumX[i] = sumX[i - 1] + data[i] - shift;
+            sumXsq[i] = sumXsq[i - 1] + (data[i] - shift) * (data[i] - shift);
+        }
+        // Initialize for k = 0
+        matrix[0][i] = ssq(0, i, sumX, sumXsq);
+        backtrackMatrix[0][i] = 0;
+    }
+    // Initialize the rest of the columns
+    var imin;
+    for (var k = 1; k < matrix.length; ++k) {
+        if (k < matrix.length - 1) {
+            imin = k;
+        }
+        else {
+            // No need to compute matrix[K-1][0] ... matrix[K-1][N-2]
+            imin = nValues - 1;
+        }
+        fillMatrixColumn(imin, nValues - 1, k, matrix, backtrackMatrix, sumX, sumXsq);
+    }
+}
+/**
+ * Ckmeans clustering is an improvement on heuristic-based clustering
+ * approaches like Jenks. The algorithm was developed in
+ * [Haizhou Wang and Mingzhou Song](http://journal.r-project.org/archive/2011-2/RJournal_2011-2_Wang+Song.pdf)
+ * as a [dynamic programming](https://en.wikipedia.org/wiki/Dynamic_programming) approach
+ * to the problem of clustering numeric data into groups with the least
+ * within-group sum-of-squared-deviations.
+ *
+ * Minimizing the difference within groups - what Wang & Song refer to as
+ * `withinss`, or within sum-of-squares, means that groups are optimally
+ * homogenous within and the data is split into representative groups.
+ * This is very useful for visualization, where you may want to represent
+ * a continuous variable in discrete color or style groups. This function
+ * can provide groups that emphasize differences between data.
+ *
+ * Being a dynamic approach, this algorithm is based on two matrices that
+ * store incrementally-computed values for squared deviations and backtracking
+ * indexes.
+ *
+ * Unlike the [original implementation](https://cran.r-project.org/web/packages/Ckmeans.1d.dp/index.html),
+ * this implementation does not include any code to automatically determine
+ * the optimal number of clusters: this information needs to be explicitly
+ * provided.
+ *
+ * ### References
+ * _Ckmeans.1d.dp: Optimal k-means Clustering in One Dimension by Dynamic
+ * Programming_ Haizhou Wang and Mingzhou Song ISSN 2073-4859
+ *
+ * from The R Journal Vol. 3/2, December 2011
+ * @param {Array<number>} data input data, as an array of number values
+ * @param {number} nClusters number of desired classes. This cannot be
+ * greater than the number of values in the data array.
+ * @returns {Array<Array<number>>} clustered input
+ * @example
+ * ckmeans([-1, 2, -1, 2, 4, 5, 6, -1, 2, -1], 3);
+ * // The input, clustered into groups of similar numbers.
+ * //= [[-1, -1, -1, -1], [2, 2, 2], [4, 5, 6]]);
+ */
+function ckmeans(data, nClusters) {
+    if (nClusters > data.length) {
+        throw new Error("Cannot generate more classes than there are data values");
+    }
+    var nValues = data.length;
+    var sorted = numericSort(data);
+    // we'll use this as the maximum number of clusters
+    var uniqueCount = uniqueCountSorted(sorted);
+    // if all of the input values are identical, there's one cluster
+    // with all of the input in it.
+    if (uniqueCount === 1) {
+        return [sorted[0]];
+    }
+    nClusters = Math.min(uniqueCount, nClusters);
+    // named 'S' originally
+    var matrix = makeMatrix(nClusters, nValues);
+    // named 'J' originally
+    var backtrackMatrix = makeMatrix(nClusters, nValues);
+    // This is a dynamic programming way to solve the problem of minimizing
+    // within-cluster sum of squares. It's similar to linear regression
+    // in this way, and this calculation incrementally computes the
+    // sum of squares that are later read.
+    fillMatrices(sorted, matrix, backtrackMatrix);
+    // The real work of Ckmeans clustering happens in the matrix generation:
+    // the generated matrices encode all possible clustering combinations, and
+    // once they're generated we can solve for the best clustering groups
+    // very quickly.
+    var clusters = [];
+    var clusterRight = backtrackMatrix[0].length - 1;
+    // Backtrack the clusters from the dynamic programming matrix. This
+    // starts at the bottom-right corner of the matrix (if the top-left is 0, 0),
+    // and moves the cluster target with the loop.
+    for (var cluster = backtrackMatrix.length - 1; cluster >= 0; cluster--) {
+        var clusterLeft = backtrackMatrix[cluster][clusterRight];
+        // fill the cluster from the sorted input by taking a slice of the
+        // array. the backtrack matrix makes this easy - it stores the
+        // indexes where the cluster should start and end.
+        clusters[cluster] = sorted[clusterLeft];
+        if (cluster > 0) {
+            clusterRight = clusterLeft - 1;
+        }
+    }
+    return clusters;
+}

package/ai/dist/src/components/svg/contourLayout.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contouring = contouring;
+const d3_contour_1 = require("d3-contour");
+const d3_scale_1 = require("d3-scale");
+function shapeBounds(coordinates) {
+    let left = [Infinity, 0];
+    let right = [-Infinity, 0];
+    let top = [0, Infinity];
+    let bottom = [0, -Infinity];
+    coordinates.forEach((d) => {
+        left = d[0] < left[0] ? d : left;
+        right = d[0] > right[0] ? d : right;
+        bottom = d[1] > bottom[1] ? d : bottom;
+        top = d[1] < top[1] ? d : top;
+    });
+    return {
+        center: [(left[0] + right[0]) / 2, (top[1] + bottom[1]) / 2],
+        top,
+        left,
+        right,
+        bottom
+    };
+}
+function contouring({ summaryType, data, finalXExtent, finalYExtent }) {
+    let projectedSummaries = [];
+    if (!summaryType.type) {
+        summaryType = { type: summaryType };
+    }
+    const { resolution = 500, thresholds = 10, bandwidth = 20, neighborhood } = summaryType;
+    const xScale = (0, d3_scale_1.scaleLinear)()
+        .domain(finalXExtent)
+        .rangeRound([0, resolution])
+        .nice();
+    const yScale = (0, d3_scale_1.scaleLinear)()
+        .domain(finalYExtent)
+        .rangeRound([resolution, 0])
+        .nice();
+    data.forEach((contourData) => {
+        let contourProjectedSummaries = (0, d3_contour_1.contourDensity)()
+            .size([resolution, resolution])
+            .x((d) => xScale(d[0]))
+            .y((d) => yScale(d[1]))
+            .thresholds(thresholds)
+            .bandwidth(bandwidth)(contourData._xyfCoordinates);
+        if (neighborhood) {
+            contourProjectedSummaries = [contourProjectedSummaries[0]];
+        }
+        const max = Math.max(...contourProjectedSummaries.map((d) => d.value));
+        contourProjectedSummaries.forEach((summary) => {
+            summary.parentSummary = contourData;
+            summary.bounds = [];
+            summary.percent = summary.value / max;
+            summary.coordinates.forEach((poly) => {
+                poly.forEach((subpoly, i) => {
+                    poly[i] = subpoly.map((coordpair) => {
+                        coordpair = [
+                            xScale.invert(coordpair[0]),
+                            yScale.invert(coordpair[1])
+                        ];
+                        return coordpair;
+                    });
+                    //Only push bounds for the main poly, not its interior rings, otherwise you end up labeling interior cutouts
+                    if (i === 0) {
+                        summary.bounds.push(shapeBounds(poly[i]));
+                    }
+                });
+            });
+        });
+        projectedSummaries = [...projectedSummaries, ...contourProjectedSummaries];
+    });
+    return projectedSummaries;
+}

package/ai/dist/src/components/svg/contourRenderer.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contourRenderFn = contourRenderFn;
+const areaDrawing_1 = require("../svg/areaDrawing");
+const contourMap = (d) => [d.xy.x, d.xy.y];
+function contourRenderFn({ data, type, renderMode, eventListenersGenerator, styleFn, classFn, adjustedSize }) {
+    const keys = Object.keys(data);
+    const renderedSummaryMarks = [];
+    const summaryXYCoords = [];
+    keys.forEach((key, ordsetI) => {
+        const ordset = data[key];
+        type.thresholds = type.thresholds || 8;
+        type.bandwidth = type.bandwidth || 12;
+        type.resolution = type.resolution || 1000;
+        const projectedOrd = [
+            { id: ordset, _xyfCoordinates: ordset.xyData.map(contourMap) }
+        ];
+        const oContours = (0, areaDrawing_1.contouring)({
+            summaryType: type,
+            data: projectedOrd,
+            finalXExtent: [0, adjustedSize[0]],
+            finalYExtent: [0, adjustedSize[1]]
+        });
+        const contourMarks = [];
+        oContours.forEach((d, i) => {
+            d.coordinates.forEach((coords, ii) => {
+                const eventListeners = eventListenersGenerator(d, i);
+                contourMarks.push({
+                    ...eventListeners,
+                    key: `${i}-${ii}`,
+                    style: styleFn(ordset.pieceData[0].data, ordsetI),
+                    className: classFn(ordset.pieceData[0].data, ordsetI),
+                    markType: "path",
+                    d: `M${d.coordinates[0].map((p) => p.join(",")).join("L")}Z`
+                });
+            });
+        });
+        renderedSummaryMarks.push({
+            containerProps: {
+                key: `contour-container-${ordsetI}`,
+                role: "img",
+                tabIndex: -1,
+                "data-o": key,
+                "aria-label": `${key} boxplot showing ${summaryXYCoords
+                    .filter((d) => d.key === key)
+                    .map((d) => `${d.label} ${d.value}`)}`
+            },
+            //These are drawn items
+            elements: contourMarks
+        });
+    });
+    return { marks: renderedSummaryMarks, xyPoints: summaryXYCoords };
+}

package/ai/dist/src/components/svg/edgeGenerators.js

@@ -0,0 +1,181 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dagreEdgeGenerator = exports.chordEdgeGenerator = exports.sankeyArrowGenerator = exports.arcEdgeGenerator = exports.matrixEdgeGenerator = exports.genericLineGenerator = exports.customEdgeHashD = exports.sigmoidLinks = void 0;
+exports.sankeyEdgeSort = sankeyEdgeSort;
+const React = __importStar(require("react"));
+const react_1 = require("react");
+const d3_selection_1 = require("d3-selection");
+const d3_glyphedge_1 = require("d3-glyphedge");
+const d3_path_arrows_1 = require("d3-path-arrows");
+const d3_shape_1 = require("d3-shape");
+const SvgHelper_1 = require("./SvgHelper");
+const d3_interpolate_1 = require("d3-interpolate");
+const nodeGenerators_1 = require("./nodeGenerators");
+const curvature = 0.5;
+const horizontalDagreLineGenerator = (0, d3_shape_1.line)()
+    .curve(d3_shape_1.curveMonotoneX)
+    .x((d) => d.x)
+    .y((d) => d.y);
+const verticalDagreLineGenerator = (0, d3_shape_1.line)()
+    .curve(d3_shape_1.curveMonotoneY)
+    .x((d) => d.x)
+    .y((d) => d.y);
+function sankeyEdgeSort(a, b, direction) {
+    if (a.circular && !b.circular)
+        return -1;
+    if (b.circular && !a.circular)
+        return 1;
+    const first = direction === "down" ? "y" : "x";
+    const second = direction === "down" ? "x" : "y";
+    return a.source[first] === b.source[first]
+        ? a.sankeyWidth === b.sankeyWidth
+            ? a.source[second] - b.source[second]
+            : b.sankeyWidth - a.sankeyWidth
+        : a.source[first] - b.source[first];
+}
+exports.sigmoidLinks = {
+    horizontal: (0, d3_shape_1.linkHorizontal)()
+        .x((d) => d.x)
+        .y((d) => d.y),
+    vertical: (0, d3_shape_1.linkVertical)()
+        .x((d) => d.x)
+        .y((d) => d.y),
+    radial: d3_glyphedge_1.d.lineArc
+};
+exports.customEdgeHashD = {
+    curve: (d, projection = "vertical") => exports.sigmoidLinks[projection](d),
+    linearc: (d) => d3_glyphedge_1.d.lineArc(d),
+    ribbon: (d) => d3_glyphedge_1.d.ribbon(d, d.width),
+    arrowhead: (d) => d3_glyphedge_1.d.arrowHead(d, d.target.nodeSize, d.width, d.width * 1.5),
+    halfarrow: (d) => d3_glyphedge_1.d.halfArrow(d, d.target.nodeSize, d.width, d.width * 1.5),
+    nail: (d) => d3_glyphedge_1.d.nail(d, d.source.nodeSize),
+    comet: (d) => d3_glyphedge_1.d.comet(d, d.target.nodeSize),
+    taffy: (d) => d3_glyphedge_1.d.taffy(d, d.source.nodeSize / 2, d.target.nodeSize / 2, (d.source.nodeSize + d.target.nodeSize) / 4)
+};
+const genericLineGenerator = (d) => `M${d.source.x},${d.source.y}L${d.target.x},${d.target.y}`;
+exports.genericLineGenerator = genericLineGenerator;
+const matrixEdgeGenerator = (size, nodes) => ({ d, i, styleFn, renderMode, key, className }) => {
+    const gridSize = Math.min(...size) / nodes.length;
+    const style = styleFn(d, i);
+    return (React.createElement("g", { key: key },
+        React.createElement("rect", { key: key, className: className, transform: `translate(${d.source.y},${d.target.y})`, ...style, style: style, "aria-label": `Connection from ${d.source.id} to ${d.target.id}`, tabIndex: -1, ...(0, nodeGenerators_1.gridProps)(gridSize) })));
+};
+exports.matrixEdgeGenerator = matrixEdgeGenerator;
+const arcEdgeGenerator = (size) => {
+    const yAdjust = size[1] / size[0];
+    function arcDiagramArc(d) {
+        const draw = (0, d3_shape_1.line)().curve(d3_shape_1.curveBasis);
+        const midX = (d.source.x + d.target.x) / 2;
+        const midY = d.source.x - d.target.x;
+        return draw([
+            [d.source.x, 0],
+            [midX, midY * yAdjust],
+            [d.target.x, 0]
+        ]);
+    }
+    return ({ d, i, styleFn, renderMode, key, className }) => {
+        const style = styleFn(d, i);
+        return (React.createElement("path", { key: key, className: className, transform: `translate(0,${size[1] / 2})`, d: arcDiagramArc(d), ...style, style: style, "aria-label": `Connection from ${d.source.id} to ${d.target.id}`, tabIndex: -1 }));
+    };
+};
+exports.arcEdgeGenerator = arcEdgeGenerator;
+const ArrowedPath = (props) => {
+    const { d, width, edgeLength, circular } = props;
+    const pathRef = (0, react_1.useRef)(null);
+    (0, react_1.useEffect)(() => {
+        if (pathRef?.current) {
+            const circularMod = circular ? width : edgeLength;
+            const arrowHeadSize = Math.max(Math.min(width, circularMod) / 5, 2);
+            let arrows = (0, d3_path_arrows_1.pathArrows)()
+                .arrowLength(arrowHeadSize * 2.5)
+                .gapLength(100)
+                .arrowHeadSize(arrowHeadSize)
+                .path(d);
+            (0, d3_selection_1.select)(pathRef.current).selectAll("*").remove();
+            (0, d3_selection_1.select)(pathRef.current).call(arrows);
+            (0, d3_selection_1.select)(pathRef.current)
+                .selectAll(":not(.arrow-head)")
+                .style("fill", "none")
+                .style("stroke-width", arrowHeadSize / 4)
+                .style("stroke", "white");
+            (0, d3_selection_1.select)(pathRef.current).selectAll(".arrow-head").style("fill", "white");
+        }
+    }, [d]);
+    return React.createElement("g", { ref: pathRef });
+};
+const sankeyArrowGenerator = (props) => {
+    const { d, i, styleFn, renderMode, key, className, generatedPath } = props;
+    const { showArrows } = d;
+    let arrowPath = "";
+    if (d.circular) {
+        const { circularPathData } = d;
+        const { sourceX, sourceY, leftFullExtent, rightFullExtent, verticalFullExtent, targetX, targetY } = circularPathData;
+        arrowPath = `M${sourceX},${sourceY}L${leftFullExtent},${sourceY}L${leftFullExtent},${verticalFullExtent}L${rightFullExtent},${verticalFullExtent}L${rightFullExtent},${targetY}L${targetX},${targetY}`;
+    }
+    else {
+        let x0 = d.source.x1, x1 = d.target.x0, xi = (0, d3_interpolate_1.interpolateNumber)(x0, x1), x2 = xi(curvature), x3 = xi(1 - curvature), y0 = d.y0, y1 = d.y1;
+        arrowPath = `M${x0},${y0}C${x2},${y0} ${x3},${y1} ${x1},${y1}`;
+    }
+    return (React.createElement(React.Fragment, { key: key },
+        React.createElement("path", { className: className, d: generatedPath, style: styleFn(d, i), "aria-label": `Connection from ${d.source.id} to ${d.target.id}`, tabIndex: -1 }),
+        showArrows && (React.createElement(ArrowedPath, { d: arrowPath, width: d.sankeyWidth, edgeLength: Math.abs(d.target.x - d.source.x), circular: d.circular }))));
+};
+exports.sankeyArrowGenerator = sankeyArrowGenerator;
+const chordEdgeGenerator = (size) => ({ d, i, styleFn, renderMode, key, className }) => (React.createElement("path", { key: key, className: className, transform: `translate(${size[0] / 2},${size[1] / 2})`, d: d.d, style: styleFn(d, i), "aria-label": `Connection from ${d.source.id} to ${d.target.id}`, tabIndex: -1 }));
+exports.chordEdgeGenerator = chordEdgeGenerator;
+const dagreEdgeGenerator = (direction) => {
+    const dagreLineGenerator = direction === "LR" || direction === "RL"
+        ? horizontalDagreLineGenerator
+        : verticalDagreLineGenerator;
+    return ({ d, i, styleFn, renderMode, key, className }) => {
+        if (d.ribbon || d.parallelEdges) {
+            const ribbonGenerator = (0, SvgHelper_1.linearRibbon)();
+            ribbonGenerator.x((p) => p.x);
+            ribbonGenerator.y((p) => p.y);
+            ribbonGenerator.r(() => d.weight || 1);
+            if (d.parallelEdges) {
+                const sortedParallelEdges = d.parallelEdges.sort((a, b) => b.weight - a.weight);
+                return (React.createElement("g", { key: `${key}` }, ribbonGenerator({
+                    points: d.points,
+                    multiple: d.parallelEdges
+                }).map((ribbonD, ribbonI) => (React.createElement("path", { key: `${key}-${ribbonI}`, className: className, d: ribbonD, style: styleFn(sortedParallelEdges[ribbonI], i), "aria-label": `Connection from ${d.source.id} to ${d.target.id}`, tabIndex: -1 })))));
+            }
+            return (React.createElement("path", { key: key, className: className, d: ribbonGenerator(d.points), style: styleFn(d, i), "aria-label": `Connection from ${d.source.id} to ${d.target.id}`, tabIndex: -1 }));
+        }
+        return (React.createElement("path", { key: key, className: className, d: dagreLineGenerator(d.points), style: styleFn(d, i), "aria-label": `Connection from ${d.source.id} to ${d.target.id}`, tabIndex: -1 }));
+    };
+};
+exports.dagreEdgeGenerator = dagreEdgeGenerator;