semiotic 2.0.2 → 3.0.0-beta.1

package/ai/dist/src/components/processing/layouts/forceLayout.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.motifsLayout = exports.forceLayout = void 0;
+const d3_force_1 = require("d3-force");
+const d3_scale_1 = require("d3-scale");
+const d3_array_1 = require("d3-array");
+const hierarchyUtils_1 = require("../hierarchyUtils");
+const forceLayout = ({ projectedNodes, projectedEdges, networkSettings, adjustedSize, nodeSizeAccessor }) => {
+    // Adaptive iteration count for force layout: reduce iterations for large networks
+    const nodeCount = projectedNodes.length;
+    const adaptiveIterations = Math.max(50, Math.min(300, Math.floor(300 - (nodeCount - 30) * 2)));
+    const { iterations = adaptiveIterations, edgeStrength = 0.1, distanceMax = Infinity, edgeDistance, forceManyBody: nsForceMB = (d) => -25 * nodeSizeAccessor(d) } = networkSettings;
+    // Set deterministic initial positions for nodes that don't have x/y yet.
+    // d3-force uses Math.random() for unpositioned nodes which produces
+    // different layouts on every render. A phyllotaxis spiral gives
+    // evenly-distributed starting positions based on index alone.
+    const cx = adjustedSize[0] / 2;
+    const cy = adjustedSize[1] / 2;
+    const goldenAngle = Math.PI * (3 - Math.sqrt(5));
+    projectedNodes.forEach((node, i) => {
+        if (node.x == null || node.y == null) {
+            const r = Math.sqrt(i + 0.5) * 10;
+            const theta = i * goldenAngle;
+            node.x = cx + r * Math.cos(theta);
+            node.y = cy + r * Math.sin(theta);
+        }
+    });
+    const linkForce = (0, d3_force_1.forceLink)().strength((d) => Math.min(2.5, d.weight ? d.weight * edgeStrength : edgeStrength));
+    if (edgeDistance) {
+        linkForce.distance(edgeDistance);
+    }
+    const simulation = networkSettings.simulation ||
+        (0, d3_force_1.forceSimulation)().force("charge", (0, d3_force_1.forceManyBody)().distanceMax(distanceMax).strength(nsForceMB));
+    simulation.nodes(projectedNodes);
+    const forceMod = adjustedSize[1] / adjustedSize[0];
+    if (!simulation.force("x")) {
+        simulation.force("x", (0, d3_force_1.forceX)(adjustedSize[0] / 2).strength(forceMod * 0.1));
+    }
+    if (!simulation.force("y")) {
+        simulation.force("y", (0, d3_force_1.forceY)(adjustedSize[1] / 2).strength(0.1));
+    }
+    if (projectedEdges.length !== 0 && !simulation.force("link")) {
+        simulation.force("link", linkForce);
+        simulation.force("link").links(projectedEdges);
+    }
+    //reset alpha if it's too cold
+    if (simulation.alpha() < 0.1) {
+        simulation.alpha(1);
+    }
+    simulation.stop();
+    for (let i = 0; i < iterations; ++i) {
+        simulation.tick();
+    }
+    return { projectedNodes, projectedEdges };
+};
+exports.forceLayout = forceLayout;
+const motifsLayout = ({ projectedNodes, projectedEdges, networkSettings, adjustedSize, nodeSizeAccessor, size }) => {
+    const componentMap = new Map();
+    projectedEdges.forEach((edge) => {
+        ;
+        [edge.source, edge.target].forEach((node) => {
+            if (!componentMap.get(node)) {
+                componentMap.set(node, {
+                    node,
+                    component: -99,
+                    connectedNodes: [],
+                    edges: []
+                });
+            }
+        });
+        componentMap.get(edge.source).connectedNodes.push(edge.target);
+        componentMap.get(edge.target).connectedNodes.push(edge.source);
+        componentMap.get(edge.source).edges.push(edge);
+    });
+    const components = (0, hierarchyUtils_1.breadthFirstCompontents)(projectedNodes, componentMap);
+    const largestComponent = Math.max(projectedNodes.length / 3, components[0].componentNodes.length);
+    const layoutSize = size[0] > size[1] ? size[1] : size[0];
+    const layoutDirection = size[0] > size[1] ? "horizontal" : "vertical";
+    // Adaptive iteration count for motifs layout (same as force layout)
+    const nodeCount = projectedNodes.length;
+    const adaptiveIterations = Math.max(50, Math.min(300, Math.floor(300 - (nodeCount - 30) * 2)));
+    const { iterations = adaptiveIterations, edgeStrength = 0.1, edgeDistance, padding = 0 } = networkSettings;
+    let currentX = padding;
+    let currentY = padding;
+    components.forEach(({ componentNodes, componentEdges }) => {
+        const linkForce = (0, d3_force_1.forceLink)().strength((d) => Math.min(2.5, d.weight ? d.weight * edgeStrength : edgeStrength));
+        if (edgeDistance) {
+            linkForce.distance(edgeDistance);
+        }
+        const componentLayoutSize = Math.max(componentNodes.length / largestComponent, 0.2) * layoutSize;
+        const xBound = componentLayoutSize + currentX;
+        const yBound = componentLayoutSize + currentY;
+        if (layoutDirection === "horizontal") {
+            if (yBound > size[1]) {
+                currentX = componentLayoutSize + currentX + padding;
+                currentY = componentLayoutSize + padding;
+            }
+            else {
+                currentY = componentLayoutSize + currentY + padding;
+            }
+        }
+        else {
+            if (xBound > size[0]) {
+                currentY = componentLayoutSize + currentY + padding;
+                currentX = componentLayoutSize + padding;
+            }
+            else {
+                currentX = componentLayoutSize + currentX + padding;
+            }
+        }
+        const xCenter = currentX - componentLayoutSize / 2;
+        const yCenter = currentY - componentLayoutSize / 2;
+        const simulation = (0, d3_force_1.forceSimulation)()
+            .force("charge", (0, d3_force_1.forceManyBody)().strength(networkSettings.forceManyBody ||
+            ((d) => -25 * nodeSizeAccessor(d))))
+            .force("link", linkForce);
+        simulation
+            .force("x", (0, d3_force_1.forceX)(xCenter))
+            .force("y", (0, d3_force_1.forceY)(yCenter))
+            .nodes(componentNodes);
+        simulation.force("link").links(componentEdges);
+        simulation.stop();
+        for (let i = 0; i < iterations; ++i)
+            simulation.tick();
+        const maxX = (0, d3_array_1.max)(componentNodes.map((d) => d.x));
+        const maxY = (0, d3_array_1.max)(componentNodes.map((d) => d.y));
+        const minX = (0, d3_array_1.min)(componentNodes.map((d) => d.x));
+        const minY = (0, d3_array_1.min)(componentNodes.map((d) => d.y));
+        const resetX = (0, d3_scale_1.scaleLinear)()
+            .domain([minX, maxX])
+            .range([currentX - componentLayoutSize, currentX - 20]);
+        const resetY = (0, d3_scale_1.scaleLinear)()
+            .domain([minY, maxY])
+            .range([currentY - componentLayoutSize, currentY - 20]);
+        componentNodes.forEach((node) => {
+            node.x = resetX(node.x);
+            node.y = resetY(node.y);
+        });
+    });
+    return { projectedNodes, projectedEdges, components };
+};
+exports.motifsLayout = motifsLayout;

package/ai/dist/src/components/processing/layouts/hierarchyLayout.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hierarchyLayouts = exports.hierarchicalTypeHash = void 0;
+const d3_hierarchy_1 = require("d3-hierarchy");
+exports.hierarchicalTypeHash = {
+    dendrogram: d3_hierarchy_1.tree,
+    tree: d3_hierarchy_1.tree,
+    circlepack: d3_hierarchy_1.pack,
+    cluster: d3_hierarchy_1.cluster,
+    treemap: d3_hierarchy_1.treemap,
+    partition: d3_hierarchy_1.partition
+};
+// Hierarchy layouts don't use the standard layout handler pattern because
+// they are applied during data loading (via hierarchicalTypeHash), not during
+// the layout dispatch phase. These entries exist so the layout map recognizes
+// these types as valid and falls through to the default node positioning.
+const hierarchyFallthrough = ({ projectedNodes, projectedEdges }) => {
+    projectedNodes.forEach((node) => {
+        node.x = node.x === undefined ? (node.x0 + node.x1) / 2 : node.x;
+        node.y = node.y === undefined ? node.y0 : node.y;
+    });
+    return { projectedNodes, projectedEdges };
+};
+exports.hierarchyLayouts = {
+    tree: hierarchyFallthrough,
+    dendrogram: hierarchyFallthrough,
+    cluster: hierarchyFallthrough,
+    treemap: hierarchyFallthrough,
+    circlepack: hierarchyFallthrough,
+    partition: hierarchyFallthrough
+};

package/ai/dist/src/components/processing/layouts/index.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allNetworkLayouts = exports.arcLayout = exports.matrixLayout = exports.simpleLayouts = exports.hierarchicalTypeHash = exports.hierarchyLayouts = exports.motifsLayout = exports.forceLayout = exports.sankeyOrientHash = exports.sankeyLayout = exports.chordLayout = void 0;
+const chordLayout_1 = require("./chordLayout");
+const sankeyLayout_1 = require("./sankeyLayout");
+const forceLayout_1 = require("./forceLayout");
+const hierarchyLayout_1 = require("./hierarchyLayout");
+const simpleLayouts_1 = require("./simpleLayouts");
+var chordLayout_2 = require("./chordLayout");
+Object.defineProperty(exports, "chordLayout", { enumerable: true, get: function () { return chordLayout_2.chordLayout; } });
+var sankeyLayout_2 = require("./sankeyLayout");
+Object.defineProperty(exports, "sankeyLayout", { enumerable: true, get: function () { return sankeyLayout_2.sankeyLayout; } });
+Object.defineProperty(exports, "sankeyOrientHash", { enumerable: true, get: function () { return sankeyLayout_2.sankeyOrientHash; } });
+var forceLayout_2 = require("./forceLayout");
+Object.defineProperty(exports, "forceLayout", { enumerable: true, get: function () { return forceLayout_2.forceLayout; } });
+Object.defineProperty(exports, "motifsLayout", { enumerable: true, get: function () { return forceLayout_2.motifsLayout; } });
+var hierarchyLayout_2 = require("./hierarchyLayout");
+Object.defineProperty(exports, "hierarchyLayouts", { enumerable: true, get: function () { return hierarchyLayout_2.hierarchyLayouts; } });
+Object.defineProperty(exports, "hierarchicalTypeHash", { enumerable: true, get: function () { return hierarchyLayout_2.hierarchicalTypeHash; } });
+var simpleLayouts_2 = require("./simpleLayouts");
+Object.defineProperty(exports, "simpleLayouts", { enumerable: true, get: function () { return simpleLayouts_2.simpleLayouts; } });
+Object.defineProperty(exports, "matrixLayout", { enumerable: true, get: function () { return simpleLayouts_2.matrixLayout; } });
+Object.defineProperty(exports, "arcLayout", { enumerable: true, get: function () { return simpleLayouts_2.arcLayout; } });
+exports.allNetworkLayouts = {
+    chord: chordLayout_1.chordLayout,
+    sankey: sankeyLayout_1.sankeyLayout,
+    flowchart: sankeyLayout_1.sankeyLayout,
+    force: forceLayout_1.forceLayout,
+    motifs: forceLayout_1.motifsLayout,
+    ...hierarchyLayout_1.hierarchyLayouts,
+    ...simpleLayouts_1.simpleLayouts
+};

package/ai/dist/src/components/processing/layouts/sankeyLayout.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sankeyLayout = exports.sankeyOrientHash = void 0;
+const d3_sankey_circular_1 = require("d3-sankey-circular");
+exports.sankeyOrientHash = {
+    left: d3_sankey_circular_1.sankeyLeft,
+    right: d3_sankey_circular_1.sankeyRight,
+    center: d3_sankey_circular_1.sankeyCenter,
+    justify: d3_sankey_circular_1.sankeyJustify
+};
+const sankeyLayout = ({ projectedNodes, projectedEdges, networkSettings, adjustedSize, nodeIDAccessor }) => {
+    const { orient = "center", iterations = 100, nodePadding, nodePaddingRatio = nodePadding ? undefined : 0.5, nodeWidth = networkSettings.type === "flowchart" ? 2 : 24, customSankey, direction = "right", showArrows = false } = networkSettings;
+    const sankeyOrient = exports.sankeyOrientHash[orient];
+    const actualSankey = customSankey || d3_sankey_circular_1.sankeyCircular;
+    let frameExtent = [[0, 0], adjustedSize];
+    if (networkSettings.direction === "up" ||
+        networkSettings.direction === "down") {
+        frameExtent = [
+            [0, 0],
+            [adjustedSize[1], adjustedSize[0]]
+        ];
+    }
+    // CREATE FAKE EDGES TO GET UP TO PASSED VALUE
+    let resultEdges = projectedEdges;
+    const generateEphemeralEdges = projectedNodes.some((n) => !n.createdByFrame && n.value > 0);
+    if (generateEphemeralEdges) {
+        const edgeValueMap = new Map();
+        for (const edge of projectedEdges) {
+            if (!edgeValueMap.has(edge.source.id)) {
+                edgeValueMap.set(edge.source.id, {
+                    source: 0,
+                    target: 0
+                });
+            }
+            if (!edgeValueMap.has(edge.target.id)) {
+                edgeValueMap.set(edge.target.id, {
+                    source: 0,
+                    target: 0
+                });
+            }
+            edgeValueMap.get(edge.source.id).source += edge.value;
+            edgeValueMap.get(edge.target.id).target += edge.value;
+        }
+        for (const node of projectedNodes) {
+            if (!node.createdByFrame) {
+                let maxEdgeValue = 0;
+                if (edgeValueMap.has(node.id)) {
+                    maxEdgeValue = Math.max(edgeValueMap.get(node.id).source, edgeValueMap.get(node.id).target);
+                }
+                if (node.value > maxEdgeValue) {
+                    projectedEdges.push({
+                        source: node,
+                        target: node,
+                        value: node.value - maxEdgeValue,
+                        ephemeral: true
+                    });
+                }
+            }
+        }
+    }
+    const frameSankey = actualSankey()
+        .extent(frameExtent)
+        .links(projectedEdges)
+        .nodes(projectedNodes)
+        .nodeAlign(sankeyOrient)
+        .nodeId(nodeIDAccessor)
+        .nodeWidth(nodeWidth)
+        .iterations(iterations);
+    if (generateEphemeralEdges) {
+        resultEdges = projectedEdges.filter((e) => !e.ephemeral);
+    }
+    if (frameSankey.nodePaddingRatio && nodePaddingRatio) {
+        frameSankey.nodePaddingRatio(nodePaddingRatio);
+    }
+    else if (nodePadding) {
+        frameSankey.nodePadding(nodePadding);
+    }
+    frameSankey();
+    projectedNodes.forEach((d) => {
+        d.height = d.y1 - d.y0;
+        d.width = d.x1 - d.x0;
+        d.x = d.x0 + d.width / 2;
+        d.y = d.y0 + d.height / 2;
+        d.radius = d.height / 2;
+        d.direction = direction;
+    });
+    const finalEdges = generateEphemeralEdges ? resultEdges : projectedEdges;
+    finalEdges.forEach((d) => {
+        d.showArrows = showArrows;
+        d.sankeyWidth = d.width;
+        d.direction = direction;
+        d.width = undefined;
+    });
+    return { projectedNodes, projectedEdges: finalEdges };
+};
+exports.sankeyLayout = sankeyLayout;

package/ai/dist/src/components/processing/layouts/simpleLayouts.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simpleLayouts = exports.arcLayout = exports.matrixLayout = void 0;
+const matrixLayout = ({ projectedNodes, projectedEdges, networkSettings, adjustedSize }) => {
+    let sortedNodes = projectedNodes;
+    if (networkSettings.sort) {
+        sortedNodes = [...projectedNodes].sort(networkSettings.sort);
+    }
+    const gridSize = Math.min(...adjustedSize);
+    const stepSize = gridSize / (sortedNodes.length + 1);
+    sortedNodes.forEach((node, index) => {
+        node.x = 0;
+        node.y = (index + 1) * stepSize;
+    });
+    return { projectedNodes: sortedNodes, projectedEdges };
+};
+exports.matrixLayout = matrixLayout;
+const arcLayout = ({ projectedNodes, projectedEdges, networkSettings, adjustedSize }) => {
+    let sortedNodes = projectedNodes;
+    if (networkSettings.sort) {
+        sortedNodes = [...projectedNodes].sort(networkSettings.sort);
+    }
+    const stepSize = adjustedSize[0] / (sortedNodes.length + 2);
+    sortedNodes.forEach((node, index) => {
+        node.x = (index + 1) * stepSize;
+        node.y = adjustedSize[1] / 2;
+    });
+    return { projectedNodes: sortedNodes, projectedEdges };
+};
+exports.arcLayout = arcLayout;
+exports.simpleLayouts = {
+    matrix: exports.matrixLayout,
+    arc: exports.arcLayout
+};

package/ai/dist/src/components/processing/layouts/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });