semiotic 2.0.3 → 3.0.0-beta.2

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

@@ -0,0 +1,136 @@
+"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.drawSummaries = void 0;
+exports.orFrameSummaryRenderer = orFrameSummaryRenderer;
+exports.summaryInstructionsToMarks = summaryInstructionsToMarks;
+const React = __importStar(require("react"));
+function orFrameSummaryRenderer({ data, type, renderMode, eventListenersGenerator, styleFn, classFn, projection, adjustedSize, chartSize, margin, axisCreator }) {
+    if (typeof type.type === "function") {
+        return type.type({
+            data,
+            type,
+            renderMode,
+            eventListenersGenerator,
+            styleFn,
+            classFn,
+            projection,
+            adjustedSize,
+            chartSize,
+            margin,
+            axisCreator
+        });
+    }
+    console.error(`Invalid summary type: ${type.type} - Must be a function`);
+    return {};
+}
+/**
+ * Main drawing function for summary visualizations
+ */
+const drawSummaries = ({ data, type, renderMode, eventListenersGenerator, styleFn, classFn, projection, adjustedSize, margin, axisCreator }) => {
+    if (!type || !type.type)
+        return;
+    type = typeof type === "string" ? { type } : type;
+    const chartSize = projection === "vertical" ? adjustedSize[1] : adjustedSize[0];
+    return orFrameSummaryRenderer({
+        data: data,
+        type: type,
+        renderMode,
+        eventListenersGenerator,
+        styleFn,
+        classFn,
+        projection,
+        adjustedSize,
+        chartSize,
+        margin,
+        axisCreator
+    });
+};
+exports.drawSummaries = drawSummaries;
+/**
+ * Converts summary instructions to rendered SVG elements
+ */
+function summaryInstructionsToMarks(data) {
+    const renderedSummaries = [];
+    for (const container of data) {
+        const renderedElements = [];
+        const { elements, containerProps } = container;
+        if (container.Mark) {
+            renderedSummaries.push(container.Mark);
+        }
+        else {
+            for (let i = 0; i < elements.length; i++) {
+                const element = elements[i];
+                const { markType, style = {}, ...restProps } = element;
+                // Merge style object into direct props for cleaner SVG
+                const elementProps = { ...restProps };
+                if (style.fill !== undefined)
+                    elementProps.fill = style.fill;
+                if (style.stroke !== undefined)
+                    elementProps.stroke = style.stroke;
+                if (style.strokeWidth !== undefined)
+                    elementProps.strokeWidth = style.strokeWidth;
+                if (style.opacity !== undefined)
+                    elementProps.opacity = style.opacity;
+                if (style.fillOpacity !== undefined)
+                    elementProps.fillOpacity = style.fillOpacity;
+                if (style.strokeOpacity !== undefined)
+                    elementProps.strokeOpacity = style.strokeOpacity;
+                // Keep remaining styles
+                const remainingStyles = { ...style };
+                delete remainingStyles.fill;
+                delete remainingStyles.stroke;
+                delete remainingStyles.strokeWidth;
+                delete remainingStyles.opacity;
+                delete remainingStyles.fillOpacity;
+                delete remainingStyles.strokeOpacity;
+                if (Object.keys(remainingStyles).length > 0) {
+                    elementProps.style = remainingStyles;
+                }
+                elementProps.key = element.key || i;
+                if (markType) {
+                    renderedElements.push(React.createElement(markType, elementProps));
+                }
+            }
+            if (containerProps) {
+                renderedSummaries.push(React.createElement("g", { ...containerProps }, renderedElements));
+            }
+            else {
+                renderedSummaries.push(...renderedElements);
+            }
+        }
+    }
+    return renderedSummaries;
+}

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

@@ -0,0 +1,18 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Re-export everything from the main entry point
+__exportStar(require("./semiotic"), exports);

package/ai/dist/src/components/processing/InteractionItems.js

@@ -0,0 +1,223 @@
+"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.calculateOverlay = exports.brushEnd = exports.brushing = exports.brushStart = exports.doubleclickVoronoi = exports.clickVoronoi = exports.changeVoronoi = void 0;
+const React = __importStar(require("react"));
+const coordinateNames_1 = require("../constants/coordinateNames");
+const d3_array_1 = require("d3-array");
+const d3_delaunay_1 = require("d3-delaunay");
+const constructDataObject = (d, points) => {
+    if (d === undefined)
+        return d;
+    return d && d.data ? { points, ...d.data, ...d } : { points, ...d };
+};
+const changeVoronoi = (voronoiHover, d, customHoverTypes, customHoverBehavior, points, e) => {
+    //Until semiotic 2
+    const dataObject = constructDataObject(d, points);
+    if (customHoverBehavior)
+        customHoverBehavior(dataObject);
+    if (!d)
+        voronoiHover(null);
+    else if (customHoverTypes === true) {
+        const vorD = Object.assign({}, dataObject);
+        vorD.type = vorD.type === "column-hover" ? "column-hover" : "frame-hover";
+        voronoiHover(vorD, e);
+    }
+    else if (customHoverTypes) {
+        const arrayWrappedHoverTypes = Array.isArray(customHoverTypes)
+            ? customHoverTypes
+            : [customHoverTypes];
+        const mappedHoverTypes = arrayWrappedHoverTypes
+            .map((c) => {
+            const finalC = typeof c === "function" ? c(dataObject) : c;
+            if (!finalC)
+                return undefined;
+            return Object.assign({}, dataObject, finalC);
+        })
+            .filter((d) => d);
+        voronoiHover(mappedHoverTypes, e);
+    }
+};
+exports.changeVoronoi = changeVoronoi;
+const clickVoronoi = (d, customClickBehavior, points, e) => {
+    //Until semiotic 2
+    const dataObject = constructDataObject(d, points);
+    if (customClickBehavior)
+        customClickBehavior(dataObject, e);
+};
+exports.clickVoronoi = clickVoronoi;
+const doubleclickVoronoi = (d, customDoubleClickBehavior, points, e) => {
+    //Until semiotic 2
+    const dataObject = constructDataObject(d, points);
+    if (customDoubleClickBehavior)
+        customDoubleClickBehavior(dataObject, e);
+};
+exports.doubleclickVoronoi = doubleclickVoronoi;
+const brushStart = (e, columnName, data, columnData, interaction) => {
+    if (interaction && interaction.start)
+        interaction.start(e, columnName, data, columnData);
+};
+exports.brushStart = brushStart;
+const brushing = (e, columnName, data, columnData, interaction) => {
+    if (interaction && interaction.during)
+        interaction.during(e, columnName, data, columnData);
+};
+exports.brushing = brushing;
+const brushEnd = (e, columnName, data, columnData, interaction) => {
+    if (interaction && interaction.end)
+        interaction.end(e, columnName, data, columnData);
+};
+exports.brushEnd = brushEnd;
+const calculateOverlay = (props, voronoiHover) => {
+    let voronoiPaths = [];
+    const { xScale, yScale, points, projectedX, showLinePoints, size, overlay, interactionOverflow = { top: 0, bottom: 0, left: 0, right: 0 }, customClickBehavior, customDoubleClickBehavior, customHoverBehavior, hoverAnnotation, margin, advancedSettings = {} } = props;
+    const whichPoints = {
+        top: coordinateNames_1.projectedYTop,
+        bottom: coordinateNames_1.projectedYBottom
+    };
+    const pointerStyle = customClickBehavior || customDoubleClickBehavior
+        ? { cursor: "pointer" }
+        : {};
+    if (points && hoverAnnotation && !overlay) {
+        const { voronoiFilter = () => true } = advancedSettings;
+        const voronoiDataset = [];
+        const voronoiUniqueMap = new Map();
+        for (const d of points) {
+            if (voronoiFilter({ ...d, ...d.data })) {
+                const xValue = Math.floor(xScale(d[projectedX]));
+                const yValue = Math.floor(yScale(showLinePoints && d[whichPoints[showLinePoints]] !== undefined
+                    ? d[whichPoints[showLinePoints]]
+                    : d[coordinateNames_1.projectedYMiddle] !== undefined
+                        ? d[coordinateNames_1.projectedYMiddle]
+                        : d[coordinateNames_1.projectedY]));
+                if (xValue >= 0 - margin.left &&
+                    xValue <= size[0] + margin.right &&
+                    yValue >= 0 - margin.top &&
+                    yValue <= size[1] + margin.bottom &&
+                    xValue !== undefined &&
+                    yValue !== undefined &&
+                    isNaN(xValue) === false &&
+                    isNaN(yValue) === false) {
+                    const pointKey = `${xValue},${yValue}`;
+                    if (!voronoiUniqueMap.has(pointKey)) {
+                        const voronoiPoint = {
+                            ...d,
+                            coincidentPoints: [d],
+                            voronoiX: xValue,
+                            voronoiY: yValue
+                        };
+                        voronoiDataset.push(voronoiPoint);
+                        voronoiUniqueMap.set(pointKey, voronoiPoint);
+                    }
+                    else
+                        voronoiUniqueMap.get(pointKey).coincidentPoints.push(d);
+                }
+            }
+        }
+        let voronoiXExtent = (0, d3_array_1.extent)(voronoiDataset.map((d) => d.voronoiX));
+        let voronoiYExtent = (0, d3_array_1.extent)(voronoiDataset.map((d) => d.voronoiY));
+        if (voronoiXExtent[0] == null || voronoiYExtent == null) {
+            voronoiXExtent = [0, 0];
+            voronoiYExtent = [0, 0];
+        }
+        const voronoiExtent = [
+            Math.min(voronoiXExtent[0] - 5, -interactionOverflow.left),
+            Math.min(voronoiYExtent[0] - 5, -interactionOverflow.top),
+            Math.max(voronoiXExtent[1] + 5, size[0] + interactionOverflow.right),
+            Math.max(voronoiYExtent[1] + 5, size[1] + interactionOverflow.bottom)
+        ];
+        const delaunay = d3_delaunay_1.Delaunay.from(voronoiDataset, (d) => d.voronoiX, (d) => d.voronoiY);
+        const voronoi = delaunay.voronoi(voronoiExtent);
+        voronoiPaths = voronoiDataset.map((d, i) => {
+            let clipPath = null;
+            if (advancedSettings.voronoiClipping) {
+                const circleSize = advancedSettings.voronoiClipping === true
+                    ? 50
+                    : advancedSettings.voronoiClipping;
+                clipPath = (React.createElement("clipPath", { id: `voronoi-${i}` },
+                    React.createElement("circle", { r: circleSize, cx: d.voronoiX, cy: d.voronoiY })));
+            }
+            return (React.createElement("g", { key: `voronoi-${i}` },
+                React.createElement("path", { onClick: (e) => {
+                        (0, exports.clickVoronoi)(voronoiDataset[i], customClickBehavior, points, e);
+                    }, onDoubleClick: (e) => {
+                        (0, exports.doubleclickVoronoi)(voronoiDataset[i], customDoubleClickBehavior, points, e);
+                    }, onMouseEnter: (e) => {
+                        (0, exports.changeVoronoi)(voronoiHover, voronoiDataset[i], hoverAnnotation, customHoverBehavior, points, e);
+                    }, onMouseLeave: (e) => {
+                        (0, exports.changeVoronoi)(voronoiHover, undefined, undefined, customHoverBehavior, undefined, e);
+                    }, key: `interactionVoronoi${i}`, d: voronoi.renderCell(i), style: {
+                        fillOpacity: 0,
+                        ...pointerStyle
+                    }, clipPath: `url(#voronoi-${i})` }),
+                clipPath));
+        }, this);
+        return voronoiPaths;
+    }
+    else if (overlay) {
+        const renderedOverlay = overlay.map((overlayRegion, i) => {
+            const { overlayData, ...rest } = overlayRegion;
+            const overlayProps = {
+                key: `overlay-${i}`,
+                onMouseEnter: (e) => {
+                    (0, exports.changeVoronoi)(voronoiHover, overlayData, props.hoverAnnotation, customHoverBehavior, points, e);
+                },
+                onMouseLeave: (e) => {
+                    (0, exports.changeVoronoi)(voronoiHover, undefined, undefined, customHoverBehavior, undefined, e);
+                },
+                onClick: (e) => {
+                    (0, exports.clickVoronoi)(overlayData, customClickBehavior, points, e);
+                },
+                onDoubleClick: (e) => {
+                    (0, exports.doubleclickVoronoi)(overlayData, customDoubleClickBehavior, points, e);
+                },
+                style: { opacity: 0, ...pointerStyle }
+            };
+            if (React.isValidElement(overlayRegion.renderElement)) {
+                return React.cloneElement(overlayRegion.renderElement, overlayProps);
+            }
+            else {
+                const { markType, ...restProps } = rest;
+                return React.createElement(markType || 'path', {
+                    ...restProps,
+                    key: `overlay-${i}`,
+                    ...overlayProps
+                });
+            }
+        });
+        return renderedOverlay;
+    }
+};
+exports.calculateOverlay = calculateOverlay;

package/ai/dist/src/components/processing/hierarchyUtils.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matrixify = exports.nodesEdgesFromHierarchy = exports.defaultHierarchicalIDAccessor = void 0;
+exports.recursiveIDAccessor = recursiveIDAccessor;
+exports.breadthFirstCompontents = breadthFirstCompontents;
+const d3_hierarchy_1 = require("d3-hierarchy");
+function recursiveIDAccessor(idAccessor, node, accessorString) {
+    if (node.parent) {
+        accessorString = `${accessorString}-${recursiveIDAccessor(idAccessor, { ...node.parent, ...node.parent.data }, accessorString)}`;
+    }
+    return `${accessorString}-${idAccessor({ ...node, ...node.data })}`;
+}
+const defaultHierarchicalIDAccessor = (d) => d.id || d.descendantIndex;
+exports.defaultHierarchicalIDAccessor = defaultHierarchicalIDAccessor;
+const nodesEdgesFromHierarchy = (baseRootNode, idAccessor = exports.defaultHierarchicalIDAccessor) => {
+    const edges = [];
+    const nodes = [];
+    const rootNode = baseRootNode.descendants
+        ? baseRootNode
+        : (0, d3_hierarchy_1.hierarchy)(baseRootNode);
+    const descendants = rootNode.descendants();
+    let i = 0;
+    for (const node of descendants) {
+        node.descendantIndex = i;
+        i++;
+    }
+    for (const node of descendants) {
+        const generatedID = `${idAccessor({
+            ...node,
+            ...node.data
+        }) ?? (0, exports.defaultHierarchicalIDAccessor)(node)}-${node.parent
+            ? recursiveIDAccessor(idAccessor, { ...node.parent, ...node.parent.data }, "") ?? node.parent.name
+            : "root"}`;
+        const dataD = Object.assign(node, node.data || {}, {
+            hierarchicalID: generatedID
+        });
+        nodes.push(dataD);
+        if (node.parent !== null) {
+            const dataParent = Object.assign(node.parent, node.parent.data || {});
+            edges.push({
+                source: dataParent,
+                target: dataD,
+                depth: node.depth,
+                weight: 1,
+                value: 1,
+                _NWFEdgeKey: generatedID
+            });
+        }
+    }
+    return { edges, nodes };
+};
+exports.nodesEdgesFromHierarchy = nodesEdgesFromHierarchy;
+function breadthFirstCompontents(baseNodes, hash) {
+    const componentMap = {
+        "0": { componentNodes: [], componentEdges: [] }
+    };
+    const components = [componentMap["0"]];
+    let componentID = 0;
+    traverseNodesBF(baseNodes, true);
+    function traverseNodesBF(nodes, top) {
+        for (const node of nodes) {
+            const hashNode = hash.get(node);
+            if (!hashNode) {
+                componentMap["0"].componentNodes.push(node);
+            }
+            else if (hashNode.component === -99) {
+                if (top === true) {
+                    componentID++;
+                    componentMap[componentID] = {
+                        componentNodes: [],
+                        componentEdges: []
+                    };
+                    components.push(componentMap[componentID]);
+                }
+                hashNode.component = componentID;
+                componentMap[componentID].componentNodes.push(node);
+                componentMap[componentID].componentEdges.push(...hashNode.edges);
+                const traversibleNodes = [...hashNode.connectedNodes];
+                traverseNodesBF(traversibleNodes, hash);
+            }
+        }
+    }
+    return components.sort((a, b) => b.componentNodes.length - a.componentNodes.length);
+}
+const matrixify = ({ edgeHash, nodes, edgeWidthAccessor, nodeIDAccessor }) => {
+    const matrix = [];
+    for (const nodeSource of nodes) {
+        const nodeSourceID = nodeIDAccessor(nodeSource);
+        const sourceRow = [];
+        matrix.push(sourceRow);
+        for (const nodeTarget of nodes) {
+            const nodeTargetID = nodeIDAccessor(nodeTarget);
+            const theEdge = edgeHash.get(`${nodeSourceID}|${nodeTargetID}`);
+            if (theEdge) {
+                sourceRow.push(edgeWidthAccessor(theEdge));
+            }
+            else {
+                sourceRow.push(0);
+            }
+        }
+    }
+    return matrix;
+};
+exports.matrixify = matrixify;

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

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chordLayout = void 0;
+const d3_chord_1 = require("d3-chord");
+const d3_shape_1 = require("d3-shape");
+const svg_path_bounding_box_1 = __importDefault(require("svg-path-bounding-box"));
+const hierarchyUtils_1 = require("../hierarchyUtils");
+const chordLayout = ({ projectedNodes, projectedEdges, networkSettings, adjustedSize, edgeHash, nodeIDAccessor, edgeWidthAccessor }) => {
+    const radius = adjustedSize[1] / 2;
+    const { groupWidth = 20, padAngle = 0.01, sortGroups } = networkSettings;
+    const arcGenerator = (0, d3_shape_1.arc)()
+        .innerRadius(radius - groupWidth)
+        .outerRadius(radius);
+    const ribbonGenerator = (0, d3_chord_1.ribbon)().radius(radius - groupWidth);
+    const matrixifiedNetwork = (0, hierarchyUtils_1.matrixify)({
+        edgeHash: edgeHash,
+        nodes: projectedNodes,
+        edgeWidthAccessor,
+        nodeIDAccessor
+    });
+    const chordGenerator = (0, d3_chord_1.chord)().padAngle(padAngle);
+    if (sortGroups) {
+        chordGenerator.sortGroups(sortGroups);
+    }
+    const chords = chordGenerator(matrixifiedNetwork);
+    const groups = chords.groups;
+    groups.forEach((group) => {
+        const groupCentroid = arcGenerator.centroid(group);
+        const groupD = arcGenerator(group);
+        const groupNode = projectedNodes[group.index];
+        groupNode.d = groupD;
+        groupNode.index = group.index;
+        groupNode.x = groupCentroid[0] + adjustedSize[0] / 2;
+        groupNode.y = groupCentroid[1] + adjustedSize[1] / 2;
+    });
+    chords.forEach((generatedChord) => {
+        const chordD = ribbonGenerator(generatedChord);
+        const nodeSourceID = nodeIDAccessor(projectedNodes[generatedChord.source.index]);
+        const nodeTargetID = nodeIDAccessor(projectedNodes[generatedChord.target.index]);
+        // d3-chord always emits source.index < target.index, which may
+        // not match the original edge direction. Try both key orders.
+        const chordEdge = edgeHash.get(`${nodeSourceID}|${nodeTargetID}`) ||
+            edgeHash.get(`${nodeTargetID}|${nodeSourceID}`);
+        if (chordEdge) {
+            chordEdge.d = chordD;
+            const chordBounds = (0, svg_path_bounding_box_1.default)(chordD);
+            chordEdge.x =
+                adjustedSize[0] / 2 + (chordBounds.x1 + chordBounds.x2) / 2;
+            chordEdge.y =
+                adjustedSize[1] / 2 + (chordBounds.y1 + chordBounds.y2) / 2;
+        }
+    });
+    return { projectedNodes, projectedEdges };
+};
+exports.chordLayout = chordLayout;

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;