@kineviz/graphxr-api

Type declaration

• DIMENSIONS: Record<"x" | "y" | "z", "x" | "y" | "z">

• ExpandNodesEdgeDirection: typeof ExpandNodesEdgeDirection

• ExpandNodesStatusCode: typeof ExpandNodesStatusCode

• _minimumGraphxrVersion: string

• _version: string

• aggregate: ((options: AggregateOptions) => TransformFunction)

  • • (options: AggregateOptions): TransformFunction

    • For each Node in the aggregateTo Category, collect the value of the targetProperty from every neighbor of that Node connected by an Edge of the aggregateAlong Relationship into an array. Then, run a mapping function formula on the array and store the resulting value in a property of the Node.

      since

      0.0.25

      example

      // For each Season Node, make a new property "episodeNumbers" which is a concatentation of all the
      // episodeNumber property values from Episodes connected to the Season along the inSeason relationship
      api.getLayoutGraph().applyTransform(api.aggregate({
        aggregateTo: 'Season',
        aggregateAlong: 'inSeason',
        getPropertyFrom: 'node',
        sourceProperty: 'episodeNumber',
        targetProperty: 'episodeNumbers',
        formula: 'concatenate'
      }))
      
      // For each Season Node, make a new property "maxEpisodeNumber" which is the maximum of all the
      // episodeNumber property values from inSeason edges connected to the Season.
      api.getLayoutGraph().applyTransform(api.aggregate({
        aggregateTo: 'Season',
        aggregateAlong: 'inSeason',
        getPropertyFrom: 'edge',
        sourceProperty: 'episodeNumber',
        targetProperty: 'maxEpisodeNumber',
        formula: 'max'
      }))
      
      // aggregateTo can be a function, a category, an array of nodes, or an array of node ids
      api.getLayoutGraph().applyTransform(api.aggregate({
        // function
        aggregateTo: node => node.category === 'Season',
        // category
        aggregateTo: 'Season',
        // array of nodes
        aggregateTo: api.getLayoutGraph().getNodes().filter(node => node.category === 'Season'),
        // array of node ids
        aggregateTo: api.getLayoutGraph().getNodes().filter(node => node.category === 'Season').map(node => node.id),
      }))
      
      // formula can be a function or a string
      api.getLayoutGraph().applyTransform(api.aggregate({
       // function
       formula: (values) => values.reduce((a, b) => a + b, 0),
       // string
       formula: 'sum',
      }))
      

      Parameters

      • options: AggregateOptions

      Returns TransformFunction

• aggregateFormula: { average: ((values: any[]) => number); concatenate: ((values: any[]) => null | string); count: ((values: any[]) => number); max: ((values: any[]) => number); min: ((values: any[]) => number); range: ((values: any[]) => string); sum: ((values: any[]) => number); takeFirst: ((values: any[]) => any) }

  • average: ((values: any[]) => number)

    • • (values: any[]): number

      • Parameters

        • values: any[]

        Returns number

  • concatenate: ((values: any[]) => null | string)

    • • (values: any[]): null | string

      • Parameters

        • values: any[]

        Returns null | string

  • count: ((values: any[]) => number)

    • • (values: any[]): number

      • Parameters

        • values: any[]

        Returns number

  • max: ((values: any[]) => number)

    • • (values: any[]): number

      • Parameters

        • values: any[]

        Returns number

  • min: ((values: any[]) => number)

    • • (values: any[]): number

      • Parameters

        • values: any[]

        Returns number

  • range: ((values: any[]) => string)

    • • (values: any[]): string

      • Parameters

        • values: any[]

        Returns string

  • sum: ((values: any[]) => number)

    • • (values: any[]): number

      • Parameters

        • values: any[]

        Returns number

  • takeFirst: ((values: any[]) => any)

    • • (values: any[]): any

      • Parameters

        • values: any[]

        Returns any

• alignBy: ((options: AlignByOptions) => LayoutFunction)

  • • (options: AlignByOptions): LayoutFunction

    • Given one of x, y, or z, find the center of that dimension and align all Nodes to that center on that dimension only.

      since

      0.0.70

      example

      GraphXR.alignBy({
        dimension: 'x',
      })
      

      Parameters

      • options: AlignByOptions

      Returns LayoutFunction

• applyLayout: ((view: LayoutGraph, computeLayout: LayoutFunction, tweenOverrides?: Partial<TweenLayoutOptions>) => Promise<NodeIdToPosition>)

  • • (view: LayoutGraph, computeLayout: LayoutFunction, tweenOverrides?: Partial<TweenLayoutOptions>): Promise<NodeIdToPosition>

    • Sets the positions of Nodes. Optionally animate the position. If tween provided with the LayoutResult, use it. Override the default tweens returned by (for example) line() and circle() by providing TweenLayoutOverrides. If tween is undefined, set all the positions immediately

      since

      0.0.1

      example

      // Basic example
      GraphXR.applyLayout(GraphXR.getLayoutGraph(), GraphXR.line())
      
      // Layouts can be tweened, or not.
      GraphXR.applyLayout(GraphXR.getLayoutGraph(), GraphXR.circle(), {duration: 3000})
      GraphXR.applyLayout(GraphXR.getLayoutGraph(), GraphXR.cube(), {duration: 3000, interpolate: myInterpolate})
      
      // Define your own layout!
      GraphXR.applyLayout(
        GraphXR.getLayoutGraph(),
        {
          final: new Map(GraphXR.getNodes().map(n => [n, GraphXR.makeRandomPosition()])),
          tween: {
            duration: 3000,
            interpolate: myInterpolate,
          }
        }
      )
      
      // Sort and Filter can apply to the geometric layouts.
      // Also, note that you can call applyLayout on a LayoutGraph.
      GraphXR.getLayoutGraph().applyLayout(
        GraphXR.line({
          sort: 'price', // shorthand for GraphXR.sortByProperty({property: 'price', ascending: true})
          filter: GraphXR.nodesByCategory('Item'),
        })
      ))
      

      Parameters

      • view: LayoutGraph

      • computeLayout: LayoutFunction

      • Optional tweenOverrides: Partial<TweenLayoutOptions>

      Returns Promise<NodeIdToPosition>

• areGraphSnapshotsEqual: ((left: GraphSnapshot, right: GraphSnapshot, options: Partial<AreGraphSnapshotsEqualOptions>) => boolean)

  • • (left: GraphSnapshot, right: GraphSnapshot, options: Partial<AreGraphSnapshotsEqualOptions>): boolean

    • Parameters

      • left: GraphSnapshot

      • right: GraphSnapshot

      • options: Partial<AreGraphSnapshotsEqualOptions>

      Returns boolean

• betweenness: ((graph: LayoutGraph) => BetweennessResult)

  • • (graph: LayoutGraph): BetweennessResult

    • Compute Betweenness score for each node in the graph

      since

      0.0.100

      example

      const result = api.betweenness(api.getLayoutGraph())
      view.applyTransform((graph) => {
        graph.getNodes().forEach(node => {
          node.properties.betweenness = result.get(node.id)
        })
        return graph;
      })
      

      Parameters

      • graph: LayoutGraph

      Returns BetweennessResult

• circle: ((options?: NodeFilterOptions) => LayoutFunction)

  • • (options?: NodeFilterOptions): LayoutFunction

    • All the Nodes spread on a circle

      since

      0.0.19

      example

      GraphXR.circle()
      

      Parameters

      • Optional options: NodeFilterOptions

      Returns LayoutFunction

• closeness: ((graph: LayoutGraph) => ClosenessResult)

  • • (graph: LayoutGraph): ClosenessResult

    • Compute Closeness score for each node in the graph

      since

      0.0.101

      example

      const result = api.closeness(api.getLayoutGraph())
      view.applyTransform((graph) => {
        graph.getNodes().forEach(node => {
          node.properties.closeness = result.get(node.id)
        })
        return graph;
      })
      

      Parameters

      • graph: LayoutGraph

      Returns ClosenessResult

• collectNodes: ((options?: CollectNodesOptions) => TransformFunction)

  • • (options?: CollectNodesOptions): TransformFunction

    • Merge input nodes into new or existing collection nodes

      since

      0.0.149

      example

      // These are the same
      api.getLayoutGraph().applyTransform(
        api.collectNodes()
      )
      api.getLayoutGraph().applyTransform(
        api.collectNodes({
          nodes: api.getLayoutGraph().getNodes()
        })
      )
      api.getLayoutGraph().applyTransform(
        api.collectNodes({
          nodes: api.getLayoutGraph().getNodes().map(node => node.id)
        })
      )
      

      Parameters

      • Optional options: CollectNodesOptions

      Returns TransformFunction

• colorNodesByProperty: ((options: ColorNodesByPropertyOptions) => void)

  • • (options: ColorNodesByPropertyOptions): void

    • Applies a color scale to all nodes by a certain property.

      since

      0.0.201

      example

      api.colorNodesByProperty({property: 'Episodes'});
      api.colorNodesByProperty({property: 'Episodes', scale: 'BuGn'});
      

      Parameters

      • options: ColorNodesByPropertyOptions

      Returns void

• comparePropertyValues: ((left: any, right: any, ascending?: boolean) => number)

  • • (left: any, right: any, ascending?: boolean): number

    • Returns -1 if left < right, 0 if left == right, and 1 if left > right Flips the sign if ascending = false.

      Parameters

      • left: any

      • right: any

      • ascending: boolean = true

      Returns number

• connectedComponent: ((graph: LayoutGraph) => ConnectedComponentResult)

  • • (graph: LayoutGraph): ConnectedComponentResult

    • Find all Connected Components in the graph

      since

      0.0.102

      example

      const result = api.connectedComponent(graph)
      console.log(result.get('a'))
      // 3
      

      Parameters

      • graph: LayoutGraph

      Returns ConnectedComponentResult

• convertToScreenCoordinates: ((position: Vector3) => Position)

  • • (position: Vector3): Position

    • Parameters

      • position: Vector3

      Returns Position

• createNodes: ((options: CreateNodesOptions) => TransformFunction)

  • • (options: CreateNodesOptions): TransformFunction

    • Create nodes from an Array of raw node data. The raw node data is supplied as a list of dictionaries. Then an object with the following properties must be provided:

      • category: The category of the nodes to be created.
      • keys: The keys of the properties to be created.

      Parameters

      • options: CreateNodesOptions

      Returns TransformFunction

• cube: ((options?: NodeFilterOptions) => LayoutFunction)

  • • (options?: NodeFilterOptions): LayoutFunction

    • All the Nodes spread on a cube.

      since

      0.0.19

      example

      GraphXR.cube()
      

      Parameters

      • Optional options: NodeFilterOptions

      Returns LayoutFunction

• dijkstra: ((graph: LayoutGraph, options: DijkstraOptions) => Path[])

  • • (graph: LayoutGraph, options: DijkstraOptions): Path[]

    • Returns all shortest paths from the source to target node.

      since

      0.95

      example

      const view = api.getLayoutGraph()
      const nodes = view.getNodes()
      const sourceId = nodes[0].id
      const targetId = nodes[nodes.length - 1].id
      const paths = api.dijkstra(view, {sourceId, targetId})
      // Optionally provide a custom weight property
      const weightProperty = 'weight_property'
      const paths = api.dijkstra(view, {sourceId, targetId, weightProperty})
      console.log(paths)
      // [[{nodeId: 'a', edgeId: 'ab'}, {nodeId: 'b'}]]
      

      Parameters

      • graph: LayoutGraph

      • options: DijkstraOptions

      Returns Path[]

• dispatchGraphDataUpdate: (() => void)

  • • (): void

    • Useful for forcing the UI to update after updating graph data.

      Returns void

• distributionBy: ((options: DistributionOptions) => LayoutFunction)

  • • (options: DistributionOptions): LayoutFunction

    • Equally space Nodes on one of the x, y, or z axes while keeping the other two dimensions constant. Optionally bin the Nodes by a property value. Optionally scale the spacing by a "spread" factor (the higher the spread, the farther apart).

      since

      0.0.69

      example

      // Equally space Nodes on the x-axis
      GraphXR.getLayoutGraph().applyLayout(GraphXR.distributionBy({
        dimension: 'x', // y or z
      }))
      
      // Equally space Nodes on the x-axis and bin the Nodes by "seasonNumber"
      GraphXR.getLayoutGraph().applyLayout(GraphXR.distributionBy({
        bin: 'seasonNumber',
        dimension: 'x',
      }))
      
      // Equally space Nodes on the x-axis and bin the Nodes by "seasonNumber" in descending order
      GraphXR.getLayoutGraph().applyLayout(GraphXR.distributionBy({
        bin: 'seasonNumber',
        dimension: 'x',
        reverse: true,
      }))
      

      Parameters

      • options: DistributionOptions

      Returns LayoutFunction

• edgesByRelationship: ((relationship: RelationshipId) => EdgeFilter)

  • • (relationship: RelationshipId): EdgeFilter

    • Returns a function which, given a Graph, returns all edges of a specific relationship

      since

      0.0.41

      Parameters

      • relationship: RelationshipId

      Returns EdgeFilter

• ego: ((options: EgoOptions) => LayoutFunction)

  • • (options: EgoOptions): LayoutFunction

    • Ego reveals hierarchal data by arranging nodes in a tree, where a node's depth in the tree is equal to the length of the shortest path to the node. The tree projects linearly in one direction, or radially around the root[s].

      since

      0.0.93

      example

      // The minimum requirements
      const graph = api.getLayoutGraph();
      graph.applyLayout(api.ego({
        filter: (node) => node.properties.Level === 1, // Find the root node[s]
      }));
      
      // Applying optional settings
      const graph = api.getLayoutGraph();
      graph.applyLayout(api.ego({
        depth: 3, // maximum depth of the tree; default 100
        edgeLength: 1 // visual length of the edges in the tree; default 0.2
        mode: 'rings' // 'tree' or 'rings'; default 'tree'
        orientation: 'down' // 'up', 'down', 'left', or 'right'; default 'right'
        sortByProperty: 'ComponentName' // arrange child nodes in ascending order by a property
        [sortByProperty: api.sortByProperty({property: "ComponentName", ascending: false})] // same as above, but descending
      }))
      

      Parameters

      • options: EgoOptions

      Returns LayoutFunction

• expandNodes: (() => Promise<ExpandNodesStatusCode>)

  • • (): Promise<ExpandNodesStatusCode>

    • Queries Neo4j for nodes connected to the source nodes and then adds them to the graph.

      See ExpandNodesOptions for options.

      It returns a status code indicating whether there are more results available. See ExpandNodesStatusCode.

      since

      0.0.187

      example

      const status = await api.expandNodes({sourceNodeIds: ['1']});
      if (status === api.ExpandNodeStatusCode.MAYBE_MORE_RESULTS_AVAILABLE) {
        // call api.expandNodes with same parameters
      } else if (status === api.ExpandNodeStatusCode.NO_MORE_RESULTS_AVAILABLE) {
        // all done
      }
      

      Returns Promise<ExpandNodesStatusCode>

• explodeCollections: ((options?: ExplodeCollectionsOptions) => TransformFunction)

  • • (options?: ExplodeCollectionsOptions): TransformFunction

    • For each collection node in the input, uncollect all nodes

      since

      0.0.153

      example

      // These are the same
      api.getLayoutGraph().applyTransform(
        api.explodeCollections()
      )
      api.getLayoutGraph().applyTransform(
        api.explodeCollections({
          nodes: api.getLayoutGraph().getNodes()
        })
      )
      api.getLayoutGraph().applyTransform(
        api.explodeCollections({
          nodes: api.getLayoutGraph().getNodes().map(node => node.id)
        })
      )
      

      Parameters

      • Optional options: ExplodeCollectionsOptions

      Returns TransformFunction

• extract: ((options: ExtractOptions) => TransformFunction)

  • • (options: ExtractOptions): TransformFunction

    • Extract creates a new Category and Relationship linked to the input Nodes, based on the input prop options.

      since

      0.0.1

      example

      api.getLayoutGraph().applyTransform(api.extract({
        category: "Episodes",
        props: [
          {
            name: "seasonNumber",
            newName: "seasonNumber",
            isSplit: false,
            splitChar: "",
            isKey: true,
          },
          {
            name: "millionViewers",
            newName: "millionViewers",
            isSplit: false,
            splitChar: "",
          },
          {
            name: "episodeAirDate",
            newName: "episodeAirDate",
            isSplit: false,
            splitChar: "",
          },
        ],
        newCategory: "Season Number",
        newRelationship: "inSeason",
        inheritLinks: false,
        skipEmpty: true,
      }));
      

      Parameters

      • options: ExtractOptions

      Returns TransformFunction

• flyToCenter: ((view?: LayoutGraph, nodeIds?: NodeId[], offset?: number, options?: TweenPositionOptions) => Promise<Position>)

  • • (view?: LayoutGraph, nodeIds?: NodeId[], offset?: number, options?: TweenPositionOptions): Promise<Position>

    • Fly the camera to the center of a slice of nodes, optionally with an offset, optionally with a custom duration or tween function

      since

      0.0.139

      example

      // Center of all nodes
      api.flyToCenter(); 
      
      // Center of a slice of nodes
      const view = api.getLayoutGraph();
      const slice = view.getNodes().slice(0, 10).map(node => node.id);
      api.flyToCenter(view, slice); 
      
      
      // Center of a slice of nodes with offset and duration
      const view = api.getLayoutGraph();
      const slice = view.getNodes().slice(0, 10).map(node => node.id);
      api.flyToCenter(view, slice, -3, { duration: 0 });); 
      

      Parameters

      • Optional view: LayoutGraph

      • Optional nodeIds: NodeId[]

      • offset: number = 0

      • Optional options: TweenPositionOptions

      Returns Promise<Position>

• flyToPosition: ((position: Vector3, offset?: number, options?: TweenPositionOptions) => Promise<Position>)

  • • (position: Vector3, offset?: number, options?: TweenPositionOptions): Promise<Position>

    • Fly the camera to a position, optionally with an offset, optionally with a custom duration or tween function

      since

      0.0.138

      example

      const view = api.getLayoutGraph();
      const firstNode = view.getNodes()[0];
      const position = firstNode.getStyle('position');
      api.flyToPosition(position); // no offset
      api.flyToPosition(position, -3); // with an offset
      api.flyToPosition(position, 0, { duration: 0 }); // instantly
      

      Parameters

      • position: Vector3

      • offset: number = 0

      • options: TweenPositionOptions = defaultTween

      Returns Promise<Position>

• getCategoryColor: ((categoryId: CategoryId) => Color)

  • • (categoryId: CategoryId): Color

    • Returns the default Node Color of a Category

      since

      0.0.8

      Parameters

      • categoryId: CategoryId

      Returns Color

• getCategoryConfig: ((category: CategoryId) => CategoryConfig)

  • • (category: CategoryId): CategoryConfig

    • Parameters

      • category: CategoryId

      Returns CategoryConfig

• getGraphView: (() => void)

  • • (): void

    • Returns void

• getLayoutGraph: (() => LegacyLayoutGraph)

  • • (): LegacyLayoutGraph

    • Returns a Graph which allows mutation of the Graph visualization.

      since

      0.0.1

      example

      const graph = api.getLayoutGraph();
      graph.addNodes([
        api.makeNode({category: "Episodes", properties: {episodeNumber: 1, seasonNumber: 1}}),
      ]);
      

      Returns LegacyLayoutGraph

• getObservableLayoutGraph: ((options?: ObservableLayoutGraphOptions) => ObservableLayoutGraph)

  • • (options?: ObservableLayoutGraphOptions): ObservableLayoutGraph

    • Returns a Generator which resolves to the LegacyLayoutGraph. The Generator emits whenever the window global GraphXR owned GraphObservable object emits. It's useful in Grove to create cells which react to graph data changes.

      since

      0.0.231

      example

      // This is a Grove cell
      selectedNodes = api.getObservableLayoutGraph().getVisibleNodes().filter(node => node.getStyle("selected"));
      

      Parameters

      • options: ObservableLayoutGraphOptions = {}

      Returns ObservableLayoutGraph

• getRuntime: (() => Runtime)

  • • (): Runtime

    • Returns Runtime

• getScene: (() => THREE.Group)

  • • (): THREE.Group

    • Returns a THREE.Group in which one can add new THREE objects to the 3d space

      since

      0.0.1

      example

      getScene().add(new THREE.DirectionalLight(0x404040));
      

      Returns THREE.Group

• grid: ((options?: NodeFilterOptions) => LayoutFunction)

  • • (options?: NodeFilterOptions): LayoutFunction

    • Equally space Nodes on the x-axis, y-axis, z=0.

      since

      0.0.19

      example

      GraphXR.grid()
      

      Parameters

      • Optional options: NodeFilterOptions

      Returns LayoutFunction

• layout: ((computeLayout: LayoutNodesFunction, options?: NodeFilterOptions) => LayoutFunction)

  • • (computeLayout: LayoutNodesFunction, options?: NodeFilterOptions): LayoutFunction

    • A decorator for the circle, cube, grid, line, and spiral layouts. You can construct your own layout by providing a layout function.

      Parameters

      • computeLayout: LayoutNodesFunction

      • Optional options: NodeFilterOptions

      Returns LayoutFunction

• line: ((options?: NodeFilterOptions) => LayoutFunction)

  • • (options?: NodeFilterOptions): LayoutFunction

    • Equally space Nodes on the x-axis, y=0, z=0.

      since

      0.0.1

      example

      GraphXR.line()
      

      Parameters

      • Optional options: NodeFilterOptions

      Returns LayoutFunction

• link: ((options: LinkOptions) => TransformFunction)

  • • (options: LinkOptions): TransformFunction

    • For each Node A in the source category, create an edge to a Node B in the target category, where A.sourceProperty === B.targetProperty

      since

      0.0.36

      example

      const graph = api.getLayoutGraph();
      graph.applyTransform(api.link({
        sourceCategory: "Roles",
        sourceProperty: "ParentName",
        targetCategory: "Roles",
        targetProperty: "ComponentName",
        relationship: "IS_PARENT_OF"
      }))
      

      Parameters

      • options: LinkOptions

      Returns TransformFunction

• louvain: ((graph: LayoutGraph) => LouvainResult)

  • • (graph: LayoutGraph): LouvainResult

    • Find all Louvain components in the graph

      since

      0.0.102

      example

      const result = api.louvain(graph)
      console.log(result.get('a'))
      // 3
      

      Parameters

      • graph: LayoutGraph

      Returns LouvainResult

• makeCollectionNode: ((category: CategoryId, __namedParameters: NodeCollection) => ApiNode)

  • • (category: CategoryId, __namedParameters: NodeCollection): ApiNode

    • Parameters

      • category: CategoryId

      • __namedParameters: NodeCollection

      Returns ApiNode

• makeColor: ((hexOrR: number, g?: number, b?: number) => Color)

  • • (hexOrR: number, g?: number, b?: number): Color

    • Parameters

      • hexOrR: number

      • Optional g: number

      • Optional b: number

      Returns Color

• makeEdge: ((__namedParameters: Partial<ApiEdge>) => ApiEdge)

  • • (__namedParameters: Partial<ApiEdge>): ApiEdge

    • Creates an Edge object but does not add it to the graph space

      since

      0.0.1

      Parameters

      • __namedParameters: Partial<ApiEdge>

      Returns ApiEdge

• makeGraph: (() => LayoutGraph)

  • • (): LayoutGraph

    • Returns a Graph useful for in-memory Graph operations

      since

      0.0.42

      Returns LayoutGraph

• makeNode: ((__namedParameters?: Partial<ApiNode>) => ApiNode)

  • • (__namedParameters?: Partial<ApiNode>): ApiNode

    • Creates a Node object but does not add it to the graph space

      since

      0.0.1

      Parameters

      • __namedParameters: Partial<ApiNode> = {}

      Returns ApiNode

• makeNodeId: (() => NodeId)

  • • (): NodeId

    • Creates a random NodeId

      since

      0.0.8

      Returns NodeId

• makePosition: ((__namedParameters: Partial<Vector3>) => Position)

  • • (__namedParameters: Partial<Vector3>): Position

    • Creates a Position (x,y,z)

      since

      0.0.1

      Parameters

      • __namedParameters: Partial<Vector3>

      Returns Position

• makeRandomPosition: (() => Position)

  • • (): Position

    • Creates a random Position (x,y,z)

      since

      0.0.16

      Returns Position

• map: ((options: MapOptions) => TransformFunction)

  • • (options: MapOptions): TransformFunction

    • For each Node in the category, or each Edge in the relationship, map the mappedProperties using formula provided in the options. Optionally create a new name for the property.

      since

      0.0.35

      example

      // Convert every episodeAirDate property to a week value, in Nodes of the Episodes category
      map({
        category: 'Episode',
        mappedProperties: [
          {
            name: "episodeAirDate",
            newName: "newEpisodeAirDate",
            formula: GraphXR.mapFormula.toWeek,
          }
        ]
      })
      
      // Add 5 to every millionViewers property in Nodes belonging to the Episodes Category
      map({
        category: 'Episode',
        mappedProperties: [
          {
            name: "millionViewers",
            newName: "newMillionViewers",
            formula: (millionViewers, properties) => Number(millionViewers) + 1,
          }
        ]
      })
      
      // Add 1 to every seasonNumber property in Edges belonging to the inSeason Relationship
      map({
        relationship: 'inSeason',
        mappedProperties: [
          {
            name: "seasonNumber",
            newName: "newSeasonNumber",
            formula: (seasonNumber, properties) => Number(seasonNumber) + 1,
          }
        ]
      })
      

      Parameters

      • options: MapOptions

      Returns TransformFunction

• mapFormula: { toDate: ((value: any) => string); toNumber: ((value: any) => number); toString: ((value: any) => string); toWeek: ((value: any) => string) }

  • toDate: ((value: any) => string)

    • • (value: any): string

      • Parameters

        • value: any

        Returns string

  • toNumber: ((value: any) => number)

    • • (value: any): number

      • Parameters

        • value: any

        Returns number

  • toString: ((value: any) => string)

    • • (value: any): string

      • Parameters

        • value: any

        Returns string

  • toWeek: ((value: any) => string)

    • • (value: any): string

      • Parameters

        • value: any

        Returns string

• merge: ((options: MergeOptions) => TransformFunction)

  • • (options: MergeOptions): TransformFunction

    • Combine Nodes or Edges which have equivalent key properties.

      since

      0.0.37

      example

      // Combine all Nodes with equal seasonNumber into one Node
      merge({
        category: "Episodes",
        keyProperties: ['seasonNumber'],
        clearUnselectedProperties: false,
      })
      
      // Combine all emails between two persons sent on the same day (thus removing directionality)
      merge({
        relationship: "SENT_MAIL_TO"
        keyProperties: ['sendDate'],
        clearUnselectedProperties: false,
      })
      
      // Combine all emails between two persons sent on the same day and preserve directionality
      merge({
        relationship: "SENT_MAIL_TO"
        keyProperties: ['sendDate'],
        clearUnselectedProperties: false,
        directional: true,
      })
      

      Parameters

      • options: MergeOptions

      Returns TransformFunction

• mergeNodes: ((options: MergeNodesOptions) => TransformFunction)

  • • (options: MergeNodesOptions): TransformFunction

    • Merge nodes from an Array of raw node data. The raw node data is supplied as a list of dictionaries. Then an object with the following properties must be provided:

      • category: The category of the nodes to be created.
      • keys: The keys of the properties to be created.
      • inputs: Tha JSON Objects to be created.

      Parameters

      • options: MergeNodesOptions

      Returns TransformFunction

• mergeRelationships: ((options: MergeRelationshipsOptions) => TransformFunction)

  • • (options: MergeRelationshipsOptions): TransformFunction

    • Merge Relationships from an Array of raw node data. The raw node data is supplied as a list of dictionaries. Then an object with the following properties must be provided:

      • edge:
        • relationship: The keys of the properties to be merged.
        • keys: The keys of the properties to be merged.
      • source:
        • category: The category of the nodes to be merged.
        • keys: The keys of the properties to be merged.
      • target:
        • category: The category of the nodes to be merged.
        • keys: The keys of the properties to be merged.
      • inputs: Tha JSON Objects to be merged.

      Parameters

      • options: MergeRelationshipsOptions

      Returns TransformFunction

• neo4j: ((query: Neo4jQuery, options?: Neo4jOptions) => void)

  • • (query: Neo4jQuery, options?: Neo4jOptions): void

    • Execute a Neo4j query. Results appear in the graph workspace

      since

      0.0.114

      example

      api.neo4j(`MATCH (n) RETURN n LIMIT 10`)
      

      Parameters

      • query: Neo4jQuery

      • options: Neo4jOptions = {}

      Returns void

• nodesByCategory: ((category: CategoryId) => NodeFilter)

  • • (category: CategoryId): NodeFilter

    • Returns a function which, given a Node, returns true if the Node is in a certain category

      since

      0.0.41

      example

      aggregate({
        aggregateTo: nodesByCategory('Season'),
        aggregateAlong: "inSeason",
        getPropertyFrom: "node",
        sourceProperty: "millionViewers",
        targetProperty: "minMillionViewers",
        formula: "min",
      })
      

      Parameters

      • category: CategoryId

      Returns NodeFilter

• observe: (<T>(event: GraphxrEvent, compute: ObserveCallback) => Iterator<T>)

  • • <T>(event: GraphxrEvent, compute: ObserveCallback): Iterator<T>

    • Convert an async API event, like 'change', into an Iterator. Useful in Grove to define variables which react to data changes

      since

      0.0.53

      example

      personaNodes = observe(
        'change',
        () => api.getLayoutGraph().getNodes().filter(api.nodesByCategory('Persona'))
      )
      

      Type Parameters

      • T

      Parameters

      • event: GraphxrEvent

      • compute: ObserveCallback

      Returns Iterator<T>

• on: ((event: GraphxrEvent, callback: GraphxrEventCallback, callbackId?: GraphxrEventCallbackId) => GraphxrEventCallbackId)

  • • (event: GraphxrEvent, callback: GraphxrEventCallback, callbackId?: GraphxrEventCallbackId): GraphxrEventCallbackId

    • Parameters

      • event: GraphxrEvent

      • callback: GraphxrEventCallback

      • Optional callbackId: GraphxrEventCallbackId

      Returns GraphxrEventCallbackId

• onChange: (<T>(cb: ObserveCallback) => Iterator<T, any, undefined>)

  • • <T>(cb: ObserveCallback): Iterator<T, any, undefined>

    • Convert graph data change into an observable Grove variable.

      since

      0.0.249

      example

      personaNodes = onChange(
        () => api.getLayoutGraph().getNodes().filter(api.nodesByCategory('Persona'))
      )
      

      Type Parameters

      • T

      Parameters

      • cb: ObserveCallback

      Returns Iterator<T, any, undefined>

• pageRank: ((graph: LayoutGraph, options?: PageRankOptions) => PageRankResult)

  • • (graph: LayoutGraph, options?: PageRankOptions): PageRankResult

    • Compute PageRank for the entire graph

      since

      0.0.98

      example

      const result = GraphXR.pageRank()
      view.applyTransform((graph) => {
        graph.getNodes().forEach(node => {
          node.properties.pageRank = result.get(node.id)
        })
        return graph;
      })
      

      Parameters

      • graph: LayoutGraph

      • options: PageRankOptions = defaultOptions

      Returns PageRankResult

• parametric: ((options: ParametricOptions) => LayoutFunction)

  • • (options: ParametricOptions): LayoutFunction

    • Map the x, y, and/or z dimensions to the range [-2, 2] by applying a linear scale to all or a subset of the domain of a property.

      If a dimension is omitted, it is flattened to align with the grid.

      since

      0.0.68

      example

      // Line up Nodes on the x-axis, ordered by seasonNumber.
      // Also set y and z to 0
      GraphXR.parametric({
        x: 'seasonNumber',
        y: 0,
        z: 0,
      })
      
      // Line up Nodes on the x-axis, ordered by seasonNumber descending. Align y and z to the grid.
      GraphXR.parametric({
        x: 'seasonNumber',
        reverse: true,
      })
      
      // Linearly scale seasonNumber, episodeNumber, and millionViewers on the x, y, and z dimensions respectively
      GraphXR.parametric({
        x: 'seasonNumber',
        y: 'episodeNumber',
        z: 'millionViewers',
      })
      

      Parameters

      • options: ParametricOptions

      Returns LayoutFunction

• random: ((options?: NodeFilterOptions) => LayoutFunction)

  • • (options?: NodeFilterOptions): LayoutFunction

    • Set each node to a random point.

      since

      0.0.93

      example

      GraphXR.random()
      

      Parameters

      • Optional options: NodeFilterOptions

      Returns LayoutFunction

• rotate: ((options: RotateOptions) => LayoutFunction)

  • • (options: RotateOptions): LayoutFunction

    • Given one of the x, y, or z dimensions, find the center point of all the Nodes and rotate all Nodes around the axis passing through the center point and lying on the dimension given.

      since

      0.0.72

      example

      GraphXR.rotate({
        dimension: 'x',
        theta: 90,
      })
      
      GraphXR.rotate({
        dimension: 'z',
        theta: 45
      })
      

      Parameters

      • options: RotateOptions

      Returns LayoutFunction

• scale: ((options?: ScaleOptions) => LayoutFunction)

  • • (options?: ScaleOptions): LayoutFunction

    • Scale the distance of each node from a computed center by a constant factor.

      since

      0.0.90

      example

      // Expand a set of nodes from its center by a factor of 2
      GraphXR.scale({
        x: 2,
        y: 2,
        z: 2,
      })
      

      Parameters

      • options: ScaleOptions = defaultOptions

      Returns LayoutFunction

• setAutoShowImage: ((value: boolean) => boolean)

  • • (value: boolean): boolean

    • Enable or disable auto-show image on Nodes.

      since

      0.0.138

      example

      api.setAutoShowImage(true);
      

      Parameters

      • value: boolean

      Returns boolean

• setCameraOptions: ((options: CameraOptions) => void)

  • • (options: CameraOptions): void

    • Set camera rotation, rotation axes visibility, camera speed

      since

      0.0.249

      example

      api.setCameraOptions({
        hideAxes: true,
        rotating: true,
        speed: 0.5,
      });
      

      Parameters

      • options: CameraOptions

      Returns void

• setCameraRotating: ((rotating: boolean) => void)

  • • (rotating: boolean): void

    • Enable or disable rotating of the graph scene

      since

      0.0.138

      example

      api.setCameraRotating(true);
      

      Parameters

      • rotating: boolean

      Returns void

• setCategoryCaptionProperties: ((__namedParameters: SetCategoryCaptionPropertiesOptions) => Promise<unknown>)

  • • (__namedParameters: SetCategoryCaptionPropertiesOptions): Promise<unknown>

    • Set the properties which will display as captions for the given category.

      since

      0.0.138

      example

      api.setCategoryCaptionProperties('Episodes', ['millionViewers']);
      

      Parameters

      • __namedParameters: SetCategoryCaptionPropertiesOptions

      Returns Promise<unknown>

• setCategorySizeProperty: ((__namedParameters: SetCategorySizePropertyOptions) => Promise<unknown>)

  • • (__namedParameters: SetCategorySizePropertyOptions): Promise<unknown>

    • Set the property which will affect the size of the nodes in the category.

      since

      0.0.198

      example

      api.setCategorySizeProperty({category: 'Movie', property: 'released'});
      

      Parameters

      • __namedParameters: SetCategorySizePropertyOptions

      Returns Promise<unknown>

• setEdgeScale: ((value: number) => number)

  • • (value: number): number

    • Set the edge scale

      since

      0.0.138

      example

      api.setEdgeScale(5);
      

      Parameters

      • value: number

      Returns number

• setFullscreen: ((value: boolean) => boolean)

  • • (value: boolean): boolean

    • Hide panels and controls if fullscreen is enabled

      since

      0.0.138

      example

      api.setFullscreen(true);
      

      Parameters

      • value: boolean

      Returns boolean

• setParametricAxesOptions: ((options: Partial<AxesOptions>) => void)

  • • (options: Partial<AxesOptions>): void

    • Sets the axes options. Parametric layout automatically sets these.

      since

      0.0.143

      example

      // Hide the axes api.setParametricAxesOptions({ showAxes: false, })

      Parameters

      • options: Partial<AxesOptions>

      Returns void

• setRuntime: ((value: Runtime) => void)

  • • (value: Runtime): void

    • An optional function which enables test runners to inject a mock Window object into the API. Most of the time, you won't call this function because the API runtime object defaults to window.

      since

      0.0.1

      Parameters

      • value: Runtime

        typically a mock of the Window

      Returns void

• shift: ((options: ShiftOptions) => LayoutFunction)

  • • (options: ShiftOptions): LayoutFunction

    • Add a constant vector to the position of each node.

      since

      0.0.90

      example

      GraphXR.shift({
        x: 1,
      })
      

      Parameters

      • options: ShiftOptions

      Returns LayoutFunction

• shortcut: ((options: ShortcutOptions) => TransformFunction)

  • • (options: ShortcutOptions): TransformFunction

    • Given incomingRelationship, centerCategory, and outgoingRelationship, Shortcut finds all unique paths from node A to node C, traveling first along incomingRelationship, passing through centerCategory, and travelling lastly through outgoingRelationship to arrive at C. Once it finds all unique paths from A to C, Shortcut creates an edge A -> C with properties aggregated from the center nodes.

      Written differently, A -R0-> [B] -R1-> C => A -R2-> C where R0 is incomingRelationship, B is centerCategory, R1 is outgoingRelationship, and R2 is the new relationship. [B] means the set of all nodes B which are between A and C.

      since

      0.0.43

      example

      shortcut({
        incomingRelationship: 'IS_PARENT_OF',
        centerCategory: 'Node',
        outgoingRelationship: 'IS_PARENT_OF',
        shortcutRelationship: "IS_GRANDPARENT_OF",
        directional: true,
        aggregateProperties: [
          {
            sourceProperty: "age",
            targetProperty: "averageAge",
            formula: "average",
          },
        ],
        countLinks: false,
      })
      

      Parameters

      • options: ShortcutOptions

      Returns TransformFunction

• sleep: ((ms: number) => Promise<number>)

  • • (ms: number): Promise<number>

    • Returns a promise that resolves after the given amount of milliseconds.

      since

      0.0.143

      example

      await sleep(1000); // Sleep for 1 second

      Parameters

      • ms: number

      Returns Promise<number>

• sortByProperty: ((__namedParameters: SortByPropertyOptions) => Sort<ApiNode>)

  • • (__namedParameters: SortByPropertyOptions): Sort<ApiNode>

    • Returns a function which compares two property values.

      example

      nodes.sort(GraphXR.sortByProperty({property: 'size'}))
      

      Parameters

      • __namedParameters: SortByPropertyOptions

      Returns Sort<ApiNode>

• spiral: ((options?: NodeFilterOptions) => LayoutFunction)

  • • (options?: NodeFilterOptions): LayoutFunction

    • All the Nodes spread on a spiral

      since

      0.0.19

      example

      GraphXR.spiral()
      

      Parameters

      • Optional options: NodeFilterOptions

      Returns LayoutFunction

• stronglyConnectedComponent: ((graph: LayoutGraph) => ConnectedComponentResult)

  • • (graph: LayoutGraph): ConnectedComponentResult

    • Find all Strongly Connected Components in the graph

      since

      0.0.102

      example

      const result = api.stronglyConnectedComponent(graph)
      console.log(result.get('a'))
      // 3
      

      Parameters

      • graph: LayoutGraph

      Returns ConnectedComponentResult

• traceNeighbors: ((view: LayoutGraph, rootId: NodeId, options?: TraceNeighborsOptions) => MapPolyfill<NodeId, boolean>)

  • • (view: LayoutGraph, rootId: NodeId, options?: TraceNeighborsOptions): MapPolyfill<NodeId, boolean>

    • Highlight the root Node and all connected Edges and neighboring Nodes up to a specified depth.

      since

      0.0.146

      example

      api.traceNeighbors(view, view.getNodes()[0].id, {depth: 3})
      

      Parameters

      • view: LayoutGraph

      • rootId: NodeId

      • options: TraceNeighborsOptions = defaultOptions

      Returns MapPolyfill<NodeId, boolean>

• triggerForceLayout: (() => void)

  • • (): void

    • Returns void

• uncollectNodes: ((options?: UncollectNodesOptions) => TransformFunction)

  • • (options?: UncollectNodesOptions): TransformFunction

    • Remove the input nodes from their collection nodes

      since

      0.0.153

      example

      // These are the same
      api.getLayoutGraph().applyTransform(
        api.uncollectNodes()
      )
      api.getLayoutGraph().applyTransform(
        api.uncollectNodes({
          nodes: api.getLayoutGraph().getNodes()
        })
      )
      api.getLayoutGraph().applyTransform(
        api.uncollectNodes({
          nodes: api.getLayoutGraph().getNodes().map(node => node.id)
        })
      )
      

      Parameters

      • Optional options: UncollectNodesOptions

      Returns TransformFunction