semiotic 2.0.2 → 3.0.0-beta.1

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

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.softStack = void 0;
+exports.topologicalSort = topologicalSort;
+function topologicalSort(nodesArray, edgesArray) {
+    // adapted from https://simplapi.wordpress.com/2015/08/19/detect-graph-cycle-in-javascript/
+    const nodes = [];
+    const nodeMap = new Map();
+    for (const edge of edgesArray) {
+        if (!edge.source.id || !edge.target.id) {
+            return false;
+        }
+        if (!nodeMap.has(edge.source.id)) {
+            const newNode = { _id: edge.source.id, links: [] };
+            nodeMap.set(edge.source.id, newNode);
+            nodes.push(newNode);
+        }
+        if (!nodeMap.has(edge.target.id)) {
+            const newNode = { _id: edge.target.id, links: [] };
+            nodeMap.set(edge.target.id, newNode);
+            nodes.push(newNode);
+        }
+        nodeMap.get(edge.source.id).links.push(edge.target.id);
+    }
+    // Test if a node got any icoming edge
+    function hasIncomingEdge(list, node) {
+        for (let i = 0, l = list.length; i < l; ++i) {
+            if (list[i].links.indexOf(node._id) !== -1) {
+                return true;
+            }
+        }
+        return false;
+    }
+    // Kahn Algorithm
+    const L = [], S = nodes.filter((node) => !hasIncomingEdge(nodes, node));
+    let n = null;
+    while (S.length) {
+        // Remove a node n from S
+        n = S.pop();
+        // Add n to tail of L
+        L.push(n);
+        let i = n.links.length;
+        while (i--) {
+            // Getting the node associated to the current stored id in links
+            const m = nodes[nodes.map((d) => d._id).indexOf(n.links[i])];
+            // Remove edge e from the graph
+            n.links.pop();
+            if (!hasIncomingEdge(nodes, m)) {
+                S.push(m);
+            }
+        }
+    }
+    // If any of them still got links, there is cycle somewhere
+    const nodeWithEdge = nodes.find((node) => node.links.length !== 0);
+    return nodeWithEdge ? null : L;
+}
+const hierarchyDecorator = (hierarchy, hashEntries, nodeIDAccessor, nodes) => {
+    if (hierarchy.children) {
+        for (const child of hierarchy.children) {
+            const theseEntries = hashEntries.filter((entry) => entry[1] === child.id);
+            for (const entry of theseEntries) {
+                const idNode = nodes.find((node) => nodeIDAccessor(node) === entry[0]) || {};
+                const newNode = {
+                    id: entry[0],
+                    ...idNode,
+                    children: [],
+                    childMap: {}
+                };
+                child.childMap.set(entry[0], newNode);
+                child.children.push(newNode);
+            }
+            if (child.children.length > 0) {
+                hierarchyDecorator(child, hashEntries, nodeIDAccessor, nodes);
+            }
+        }
+    }
+};
+const softStack = (edges, nodes, sourceAccessor, targetAccessor, nodeIDAccessor) => {
+    let hierarchy = { id: "root-generated", children: [], childMap: new Map() };
+    const discoveredHierarchyMap = new Map();
+    const targetToSourceMap = new Map();
+    let hasLogicalRoot = true;
+    let isHierarchical = true;
+    for (let i = 0; i < edges.length; i++) {
+        const edge = edges[i];
+        const source = sourceAccessor(edge);
+        const target = targetAccessor(edge);
+        const sourceID = typeof source === "object" ? nodeIDAccessor(source) : source;
+        const targetID = typeof target === "object" ? nodeIDAccessor(target) : target;
+        targetToSourceMap.set(targetID, sourceID);
+        if (!discoveredHierarchyMap.has(sourceID)) {
+            discoveredHierarchyMap.set(sourceID, targetID);
+        }
+        else {
+            isHierarchical = false;
+            break;
+        }
+    }
+    if (isHierarchical) {
+        const hashEntries = [];
+        for (const entry of discoveredHierarchyMap) {
+            hashEntries.push(entry);
+            const target = entry[1];
+            if (!discoveredHierarchyMap.has(target)) {
+                discoveredHierarchyMap.set(target, "root-generated");
+                const idNode = nodes.find((node) => nodeIDAccessor(node) === target) || {};
+                const newNode = {
+                    id: target,
+                    ...idNode,
+                    children: [],
+                    childMap: new Map()
+                };
+                hierarchy.childMap.set(target, newNode);
+                hierarchy.children.push(newNode);
+            }
+        }
+        hierarchyDecorator(hierarchy, hashEntries, nodeIDAccessor, nodes);
+        nodes.forEach((node) => {
+            const nodeID = nodeIDAccessor(node);
+            if (!discoveredHierarchyMap.has(nodeID) &&
+                !targetToSourceMap.has(nodeID)) {
+                hierarchy.children.push({
+                    id: nodeID,
+                    ...node,
+                    children: [],
+                    childMap: new Map()
+                });
+            }
+        });
+        if (hierarchy.children.length === 1) {
+            hierarchy = hierarchy.children[0];
+            hasLogicalRoot = false;
+        }
+        return { hierarchy, isHierarchical: true, hasLogicalRoot };
+    }
+    return { hierarchy: {}, isHierarchical: false, hasLogicalRoot: false };
+};
+exports.softStack = softStack;

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

@@ -0,0 +1,163 @@
+"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.hexbinning = hexbinning;
+const React = __importStar(require("react"));
+const d3_hexbin_1 = require("d3-hexbin");
+const d3_scale_1 = require("d3-scale");
+function hexbinning({ preprocess = true, processedData = false, summaryType: baseSummaryType, data: baseData, finalXExtent: baseXExtent, finalYExtent: baseYExtent, size, xScaleType = (0, d3_scale_1.scaleLinear)(), yScaleType = (0, d3_scale_1.scaleLinear)(), margin, styleFn, classFn, renderFn, chartSize }) {
+    let finalXExtent = baseXExtent;
+    let finalYExtent = baseYExtent;
+    if (!finalXExtent) {
+        const xData = baseData.coordinates.map((p) => p.x);
+        finalXExtent = [Math.min(...xData), Math.max(...xData)];
+    }
+    if (!finalYExtent) {
+        const yData = baseData.coordinates.map((p) => p.y);
+        finalYExtent = [Math.min(...yData), Math.max(...yData)];
+    }
+    if (processedData && baseData) {
+        return baseData.coordinates;
+    }
+    let projectedSummaries = [];
+    let summaryType;
+    if (!baseSummaryType.type) {
+        summaryType = { type: summaryType };
+    }
+    else {
+        summaryType = baseSummaryType;
+    }
+    const { bins = 0.05, cellPx, binValue = (d) => d.length, binMax, customMark } = summaryType;
+    if (baseData.coordinates && !baseData._xyfCoordinates) {
+        baseData._xyfCoordinates = baseData.coordinates.map((d) => [d.x, d.y]);
+    }
+    const data = Array.isArray(baseData) ? baseData : [baseData];
+    const hexBinXScale = xScaleType.domain(finalXExtent).range([0, size[0]]);
+    const hexBinYScale = yScaleType.domain(finalYExtent).range([0, size[1]]);
+    const actualResolution = (cellPx && cellPx / 2) || ((bins > 1 ? 1 / bins : bins) * size[0]) / 2;
+    const hexbinner = (0, d3_hexbin_1.hexbin)()
+        .x((d) => hexBinXScale(d._xyfPoint[0]))
+        .y((d) => hexBinYScale(d._xyfPoint[1]))
+        .radius(actualResolution)
+        .size(size);
+    let hexMax;
+    const allHexes = hexbinner.centers();
+    data.forEach((hexbinData) => {
+        hexMax = 0;
+        const hexes = hexbinner(hexbinData._xyfCoordinates.map((d, i) => ({
+            _xyfPoint: d,
+            ...hexbinData.coordinates[i]
+        })));
+        const centerHash = {};
+        hexes.forEach((d) => {
+            centerHash[`${parseInt(d.x)}-${parseInt(d.y)}`] = true;
+        });
+        allHexes.forEach((hexCenter) => {
+            if (!centerHash[`${parseInt(hexCenter[0])}-${parseInt(hexCenter[1])}`]) {
+                const newHex = [];
+                newHex.x = hexCenter[0];
+                newHex.y = hexCenter[1];
+                hexes.push(newHex);
+            }
+        });
+        hexMax = Math.max(...hexes.map((d) => binValue(d)));
+        if (binMax) {
+            binMax(hexMax);
+        }
+        const hexBase = [
+            [0, -1],
+            [0.866, -0.5],
+            [0.866, 0.5],
+            [0, 1],
+            [-0.866, 0.5],
+            [-0.866, -0.5]
+        ];
+        const hexWidth = hexBinXScale.invert(actualResolution) - finalXExtent[0];
+        const hexHeight = hexBinYScale.invert(actualResolution) - finalYExtent[0];
+        const hexacoordinates = hexBase.map((d) => [
+            d[0] * hexWidth,
+            d[1] * hexHeight
+        ]);
+        const hexbinProjectedSummaries = hexes.map((d) => {
+            const hexValue = binValue(d);
+            const gx = d.x;
+            const gy = d.y;
+            d.x = hexBinXScale.invert(d.x);
+            d.y = hexBinYScale.invert(d.y);
+            const percent = hexValue / hexMax;
+            return {
+                customMark: customMark && (React.createElement("g", { transform: `translate(${gx},${size[1] - gy})` }, customMark({
+                    d: {
+                        ...d,
+                        binItems: d,
+                        percent,
+                        value: hexValue,
+                        radius: actualResolution,
+                        hexCoordinates: hexBase.map((d) => [
+                            d[0] * actualResolution,
+                            d[1] * actualResolution
+                        ])
+                    },
+                    margin,
+                    styleFn,
+                    classFn,
+                    renderFn,
+                    chartSize,
+                    adjustedSize: size
+                }))),
+                _xyfCoordinates: hexacoordinates.map((p) => [p[0] + d.x, p[1] + d.y]),
+                value: hexValue,
+                percent,
+                data: d,
+                parentSummary: hexbinData,
+                centroid: true
+            };
+        });
+        projectedSummaries = [...projectedSummaries, ...hexbinProjectedSummaries];
+    });
+    if (preprocess) {
+        projectedSummaries.forEach((d) => {
+            d.x = d.data.x;
+            d.y = d.data.y;
+        });
+        return {
+            type: "hexbin",
+            processedData: true,
+            coordinates: projectedSummaries,
+            binMax: hexMax
+        };
+    }
+    return projectedSummaries;
+}