add pagerank

Author: yilinxia

src/lib/computedData.ts

@@ -3,6 +3,7 @@ import _, { max, min, sortBy } from "lodash";
 import { Dimensions } from "sigma/types";
 
 import { findRanges } from "../utils/number";
+import { calculatePageRank } from "../utils/graphAlgorithms";
 import {
   DEFAULT_NODE_COLOR,
   DEFAULT_NODE_SIZE_RATIO,
@@ -129,20 +130,62 @@ export function getNodeSizes(
 
   if (typeof nodeSizeField === "string") {
     nodeSizes = {};
-    const field = fieldsIndex[nodeSizeField];
-
-    if (field.type === "quanti") {
-      getSize = (value: any) => {
-        const size =
-          typeof value === "number"
-            ? ((NODE_SIZE_MAX - NODE_SIZE_MIN) * (value - field.min)) / (field.max - field.min) + NODE_SIZE_MIN
-            : NODE_DEFAULT_SIZE;
-        return size * ratio * screenSizeRatio * graphSizeRatio;
-      };
-      graph.forEachNode((node, nodeData) => {
-        nodeSizes![node] = getSize!(getValue(nodeData, field));
-      });
-      nodeSizeExtents = [field.min, field.max];
+
+    // Check if it's the PageRank option
+    if (nodeSizeField === "pagerank") {
+      try {
+        // Calculate PageRank scores
+        const pageRankScores = calculatePageRank(graph);
+        const scores = Object.values(pageRankScores);
+        const minScore = min(scores) as number;
+        const maxScore = max(scores) as number;
+
+        getSize = (value: any) => {
+          const size =
+            typeof value === "number"
+              ? ((NODE_SIZE_MAX - NODE_SIZE_MIN) * (value - minScore)) / (maxScore - minScore) + NODE_SIZE_MIN
+              : NODE_DEFAULT_SIZE;
+          return size * ratio * screenSizeRatio * graphSizeRatio;
+        };
+
+        graph.forEachNode((node) => {
+          const score = pageRankScores[node] || 0;
+          nodeSizes![node] = getSize!(score);
+        });
+
+        nodeSizeExtents = [minScore, maxScore];
+      } catch (error) {
+        // Fallback to default sizing
+        nodeSizes = {};
+        const values = graph.mapNodes((_node, attributes) => attributes.rawSize);
+        nodeSizeExtents = [min(values) as number, max(values) as number];
+        graph.forEachNode((node, { rawSize }) => {
+          nodeSizes[node] =
+            (((NODE_SIZE_MAX - NODE_SIZE_MIN) * (rawSize - nodeSizeExtents[0])) /
+              (nodeSizeExtents[1] - nodeSizeExtents[0]) +
+              NODE_SIZE_MIN) *
+            ratio *
+            screenSizeRatio *
+            graphSizeRatio;
+        });
+      }
+    } else {
+      // Handle regular field-based sizing
+      const field = fieldsIndex[nodeSizeField];
+
+      if (field.type === "quanti") {
+        getSize = (value: any) => {
+          const size =
+            typeof value === "number"
+              ? ((NODE_SIZE_MAX - NODE_SIZE_MIN) * (value - field.min)) / (field.max - field.min) + NODE_SIZE_MIN
+              : NODE_DEFAULT_SIZE;
+          return size * ratio * screenSizeRatio * graphSizeRatio;
+        };
+        graph.forEachNode((node, nodeData) => {
+          nodeSizes![node] = getSize!(getValue(nodeData, field));
+        });
+        nodeSizeExtents = [field.min, field.max];
+      }
     }
   } else {
     nodeSizes = {};

src/lib/graph.ts

@@ -47,7 +47,16 @@ export function applyNodeLabelSizes(
   const extentDelta = nodeSizeExtents[1] - nodeSizeExtents[0];
   const factor = (maxSize - minSize) / (extentDelta || 1);
   graph.forEachNode((node, nodeData) => {
-    const nodeSize = nodeSizeField ? getValue(nodeData, fieldsIndex[nodeSizeField]) : nodeData.rawSize;
+    let nodeSize: number;
+    if (nodeSizeField === "pagerank") {
+      // For PageRank, we need to get the size from the node's size attribute
+      // since PageRank values are already applied as sizes
+      nodeSize = graph.getNodeAttribute(node, "size") || nodeData.rawSize;
+    } else if (nodeSizeField && fieldsIndex[nodeSizeField]) {
+      nodeSize = getValue(nodeData, fieldsIndex[nodeSizeField]);
+    } else {
+      nodeSize = nodeData.rawSize;
+    }
     graph.setNodeAttribute(node, "labelSize", minSize + (nodeSize - nodeSizeExtents[0]) * factor);
   });
 }
@@ -59,10 +68,10 @@ export function applyNodeSubtitles({ graph, fieldsIndex }: Data, { subtitleField
       "subtitles",
       subtitleFields
         ? subtitleFields.flatMap((f) => {
-            const field = fieldsIndex[f];
-            const val = getValue(nodeData, field);
-            return isNil(val) ? [] : [`${field.label}: ${typeof val === "number" ? val.toLocaleString() : val}`];
-          })
+          const field = fieldsIndex[f];
+          const val = getValue(nodeData, field);
+          return isNil(val) ? [] : [`${field.label}: ${typeof val === "number" ? val.toLocaleString() : val}`];
+        })
         : [],
     ),
   );

src/lib/navState.ts

@@ -91,6 +91,16 @@ export interface NavState {
   edgeColoring?: EdgeColoring | undefined;
   edgeDirection?: EdgeDirection | undefined;
 
+  // Edge creation conditions:
+  edgeCreationTopicThreshold?: number | undefined;
+  edgeCreationContributorThreshold?: number | undefined;
+  edgeCreationStargazerThreshold?: number | undefined;
+  edgeCreationEnableTopicLinking?: boolean | undefined;
+  edgeCreationEnableContributorOverlap?: boolean | undefined;
+  edgeCreationEnableSharedOrganization?: boolean | undefined;
+  edgeCreationEnableCommonStargazers?: boolean | undefined;
+  edgeCreationEnableDependencies?: boolean | undefined;
+
   // Only for some specific transitions:
   preventBlocker?: boolean;
 }
@@ -131,6 +141,15 @@ export function cleanNavState(state: NavState, data: Data): NavState {
     labelThresholdRatio,
     disableDefaultSize,
     disableDefaultColor,
+    // Edge creation conditions
+    edgeCreationTopicThreshold,
+    edgeCreationContributorThreshold,
+    edgeCreationStargazerThreshold,
+    edgeCreationEnableTopicLinking,
+    edgeCreationEnableContributorOverlap,
+    edgeCreationEnableSharedOrganization,
+    edgeCreationEnableCommonStargazers,
+    edgeCreationEnableDependencies,
   } = state;
 
   const cleanedSubtitleFields = uniq((subtitleFields || []).filter((f) => fieldsIndex[f]));
@@ -171,7 +190,7 @@ export function cleanNavState(state: NavState, data: Data): NavState {
     subtitleFields: cleanedSubtitleFields.length ? cleanedSubtitleFields : undefined,
     // Viewer state:
     nodeSizeField:
-      (nodeSizeField && fieldsIndex[nodeSizeField] && cleanedSizeableIndex[nodeSizeField]
+      (nodeSizeField && (nodeSizeField === "pagerank" || (fieldsIndex[nodeSizeField] && cleanedSizeableIndex[nodeSizeField]))
         ? nodeSizeField
         : undefined) || (cleanedDisableDefaultSize ? cleanedSizeable[0] : undefined),
     nodeColorField:
@@ -205,9 +224,27 @@ export function cleanNavState(state: NavState, data: Data): NavState {
     maxLabelSize: cleanedMaxLabelSize !== DEFAULT_LABEL_SIZE ? cleanedMaxLabelSize : undefined,
     disableDefaultSize: cleanedDisableDefaultSize || undefined,
     disableDefaultColor: cleanedDisableDefaultColor || undefined,
+    // Edge creation conditions - preserve as-is since they don't need cleaning
+    edgeCreationTopicThreshold,
+    edgeCreationContributorThreshold,
+    edgeCreationStargazerThreshold,
+    edgeCreationEnableTopicLinking,
+    edgeCreationEnableContributorOverlap,
+    edgeCreationEnableSharedOrganization,
+    edgeCreationEnableCommonStargazers,
+    edgeCreationEnableDependencies,
   };
 
-  return omitBy(cleanedState, isNil) as NavState;
+  // Don't filter out edge creation conditions even if they're undefined initially
+  // This allows them to be set later and persist
+  const finalState = omitBy(cleanedState, (value, key) => {
+    // Don't filter out edge creation conditions
+    if (key.startsWith('edgeCreation')) return false;
+    // Filter out other undefined values
+    return isNil(value);
+  });
+
+  return finalState as NavState;
 }
 
 export function navStateToQueryURL(state: NavState): string {
@@ -247,11 +284,21 @@ export function navStateToQueryURL(state: NavState): string {
   if (state.minLabelSize) params.append("ls", state.minLabelSize + "");
   if (state.maxLabelSize) params.append("le", state.maxLabelSize + "");
 
+  // Edge creation conditions
+  if (state.edgeCreationTopicThreshold) params.append("ett", state.edgeCreationTopicThreshold + "");
+  if (state.edgeCreationContributorThreshold) params.append("ect", state.edgeCreationContributorThreshold + "");
+  if (state.edgeCreationStargazerThreshold) params.append("est", state.edgeCreationStargazerThreshold + "");
+  if (state.edgeCreationEnableTopicLinking) params.append("etl", "1");
+  if (state.edgeCreationEnableContributorOverlap) params.append("eco", "1");
+  if (state.edgeCreationEnableSharedOrganization) params.append("eso", "1");
+  if (state.edgeCreationEnableCommonStargazers) params.append("ecs", "1");
+  if (state.edgeCreationEnableDependencies) params.append("edp", "1");
+
   return urlSearchParamsToString(params);
 }
 
 export function queryURLToNavState(queryURL: string): NavState {
-  const { url, l, r, s, c, n, fa, ca, sa, le, ls, nr, er, ec, ed, gm, lt, ds, dc, st, ...query } =
+  const { url, l, r, s, c, n, fa, ca, sa, le, ls, nr, er, ec, ed, gm, lt, ds, dc, st, ett, ect, est, etl, eco, eso, ecs, edp, ...query } =
     queryStringToRecord(queryURL);
   const navState: NavState = {};
 
@@ -276,6 +323,16 @@ export function queryURLToNavState(queryURL: string): NavState {
   if (fa) navState.filterable = arrayify(fa);
   if (st) navState.subtitleFields = arrayify(st);
 
+  // Edge creation conditions
+  if (typeof ett === "string") navState.edgeCreationTopicThreshold = +ett;
+  if (typeof ect === "string") navState.edgeCreationContributorThreshold = +ect;
+  if (typeof est === "string") navState.edgeCreationStargazerThreshold = +est;
+  if (typeof etl === "string") navState.edgeCreationEnableTopicLinking = etl === "1";
+  if (typeof eco === "string") navState.edgeCreationEnableContributorOverlap = eco === "1";
+  if (typeof eso === "string") navState.edgeCreationEnableSharedOrganization = eso === "1";
+  if (typeof ecs === "string") navState.edgeCreationEnableCommonStargazers = ecs === "1";
+  if (typeof edp === "string") navState.edgeCreationEnableDependencies = edp === "1";
+
   const fields = groupBy(Object.keys(query), (key) => key.replace(/\.(v|t|min|max)$/, ""));
   const filters = map(fields, ([q0, q1], field): Filter => {
     // Terms case:

src/utils/graphAlgorithms.test.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect } from 'vitest';
+import { calculatePageRank } from './graphAlgorithms';
+
+// Mock graph object for testing
+const createMockGraph = () => {
+  const nodes = ['A', 'B', 'C', 'D'];
+  const edges = [
+    { source: 'A', target: 'B' },
+    { source: 'A', target: 'C' },
+    { source: 'B', target: 'C' },
+    { source: 'C', target: 'D' },
+    { source: 'D', target: 'A' },
+  ];
+  
+  return {
+    nodes: () => nodes,
+    outNeighbors: (node: string) => {
+      return edges
+        .filter(edge => edge.source === node)
+        .map(edge => edge.target);
+    }
+  };
+};
+
+describe('calculatePageRank', () => {
+  it('should calculate PageRank scores for a simple graph', () => {
+    const graph = createMockGraph();
+    const scores = calculatePageRank(graph);
+    
+    expect(scores).toBeDefined();
+    expect(Object.keys(scores)).toHaveLength(4);
+    expect(scores['A']).toBeGreaterThan(0);
+    expect(scores['B']).toBeGreaterThan(0);
+    expect(scores['C']).toBeGreaterThan(0);
+    expect(scores['D']).toBeGreaterThan(0);
+    
+    // All scores should sum to approximately 1
+    const totalScore = Object.values(scores).reduce((sum, score) => sum + score, 0);
+    expect(totalScore).toBeCloseTo(1, 2);
+  });
+  
+  it('should handle empty graph', () => {
+    const emptyGraph = {
+      nodes: () => [],
+      outNeighbors: () => []
+    };
+    
+    const scores = calculatePageRank(emptyGraph);
+    expect(scores).toEqual({});
+  });
+  
+  it('should handle single node graph', () => {
+    const singleNodeGraph = {
+      nodes: () => ['A'],
+      outNeighbors: () => []
+    };
+    
+    const scores = calculatePageRank(singleNodeGraph);
+    expect(scores).toEqual({ 'A': 1 });
+  });
+  
+  it('should converge within reasonable iterations', () => {
+    const graph = createMockGraph();
+    const scores = calculatePageRank(graph, 0.85, 50, 1e-6);
+    
+    // Should converge and produce valid scores
+    expect(Object.values(scores).every(score => score > 0 && score < 1)).toBe(true);
+  });
+});