diff --git a/react-components/src/components/NodeCacheProvider/FdmNodeCache.ts b/react-components/src/components/NodeCacheProvider/FdmNodeCache.ts
index cb9be4a1e1c..079911708af 100644
--- a/react-components/src/components/NodeCacheProvider/FdmNodeCache.ts
+++ b/react-components/src/components/NodeCacheProvider/FdmNodeCache.ts
@@ -5,21 +5,33 @@
 import { type Node3D, type CogniteClient } from '@cognite/sdk';
 import { type EdgeItem, type FdmSDK } from '../../utilities/FdmSDK';
 import { RevisionFdmNodeCache } from './RevisionFdmNodeCache';
-import { type FdmEdgeWithNode, type Fdm3dNodeData, FdmCadEdge, RevisionKey, RevisionTreeIndex, FdmKey, FdmId, RevisionId, NodeId, ModelNodeIdKey, ModelId } from './types';
+import {
+  type FdmEdgeWithNode,
+  type Fdm3dNodeData,
+  type FdmCadEdge,
+  type RevisionKey,
+  type RevisionTreeIndex,
+  type FdmKey,
+  type FdmId,
+  type RevisionId,
+  type NodeId,
+  type ModelNodeIdKey,
+  type ModelId
+} from './types';
 import {
   type InModel3dEdgeProperties,
   SYSTEM_3D_EDGE_SOURCE,
   SYSTEM_SPACE_3D_SCHEMA
 } from '../../utilities/globalDataModels';
 
-export type ModelRevisionKey = `${number}-${number}`;
-export type ModelRevisionToEdgeMap = Map<ModelRevisionKey, FdmEdgeWithNode[]>;
-
 import { partition } from 'lodash';
 
 import assert from 'assert';
 import { fetchNodesForNodeIds } from './requests';
 
+export type ModelRevisionKey = `${number}-${number}`;
+export type ModelRevisionToEdgeMap = Map<ModelRevisionKey, FdmEdgeWithNode[]>;
+
 export class FdmNodeCache {
   private readonly _revisionNodeCaches = new Map<RevisionKey, RevisionFdmNodeCache>();
 
@@ -175,12 +187,16 @@ export function insertIntoSetMap<T, U>(key: T, value: U, globalMap: Map<T, U[]>)
 }
 
 async function groupToModelRevision(
-  edges: Array<FdmCadEdge>,
+  edges: FdmCadEdge[],
   modelRevisionIds: Array<{ modelId: number; revisionId: number }>,
   cdfClient: CogniteClient
 ): Promise<Map<RevisionKey, FdmEdgeWithNode[]>> {
   const revisionToNodeIdsMap = createRevisionToNodeIdMap(edges);
-  const modelNodeIdToNodeMap = await createModelNodeIdToNodeMap(revisionToNodeIdsMap, modelRevisionIds, cdfClient);
+  const modelNodeIdToNodeMap = await createModelNodeIdToNodeMap(
+    revisionToNodeIdsMap,
+    modelRevisionIds,
+    cdfClient
+  );
 
   return edges.reduce((map, edge) => {
     const edgeRevisionId = edge.properties.revisionId;
@@ -196,10 +212,11 @@ async function groupToModelRevision(
   }, new Map<ModelRevisionKey, FdmEdgeWithNode[]>());
 }
 
-function createFdmEdgeWithNode(modelRevisionId: { modelId: number, revisionId: number },
-                               edge: FdmCadEdge,
-                               modelNodeIdToNodeMap: Map<ModelNodeIdKey, Node3D>): FdmEdgeWithNode {
-
+function createFdmEdgeWithNode(
+  modelRevisionId: { modelId: number; revisionId: number },
+  edge: FdmCadEdge,
+  modelNodeIdToNodeMap: Map<ModelNodeIdKey, Node3D>
+): FdmEdgeWithNode {
   const revisionNodeIdKey =
     `${modelRevisionId.modelId}-${modelRevisionId.revisionId}-${edge.properties.revisionNodeId}` as const;
 
@@ -209,9 +226,11 @@ function createFdmEdgeWithNode(modelRevisionId: { modelId: number, revisionId: n
   return { edge, node };
 }
 
-function insertEdgeIntoMapList(value: FdmEdgeWithNode, map: Map<ModelRevisionKey, FdmEdgeWithNode[]>, modelRevisionId: { modelId: number, revisionId: number }): void {
-
-
+function insertEdgeIntoMapList(
+  value: FdmEdgeWithNode,
+  map: Map<ModelRevisionKey, FdmEdgeWithNode[]>,
+  modelRevisionId: { modelId: number; revisionId: number }
+): void {
   const modelRevisionIdKey: ModelRevisionKey = createRevisionKey(
     modelRevisionId.modelId,
     modelRevisionId.revisionId
@@ -226,31 +245,31 @@ function insertEdgeIntoMapList(value: FdmEdgeWithNode, map: Map<ModelRevisionKey
   }
 }
 
-async function createModelNodeIdToNodeMap(revisionToNodeIdsMap: Map<RevisionId, NodeId[]>, modelRevisionIds: Array<{ modelId: ModelId; revisionId: RevisionId }>, cdfClient: CogniteClient): Promise<Map<ModelNodeIdKey, Node3D>> {
-
+async function createModelNodeIdToNodeMap(
+  revisionToNodeIdsMap: Map<RevisionId, NodeId[]>,
+  modelRevisionIds: Array<{ modelId: ModelId; revisionId: RevisionId }>,
+  cdfClient: CogniteClient
+): Promise<Map<ModelNodeIdKey, Node3D>> {
   const revisionNodeIdToNode = new Map<ModelNodeIdKey, Node3D>();
 
-  const nodePromises = [...revisionToNodeIdsMap.entries()].map(
-    async ([revisionId, nodeIds]) => {
-      const modelId = modelRevisionIds.find((p) => p.revisionId === revisionId)?.modelId;
-      assert(modelId !== undefined);
+  const nodePromises = [...revisionToNodeIdsMap.entries()].map(async ([revisionId, nodeIds]) => {
+    const modelId = modelRevisionIds.find((p) => p.revisionId === revisionId)?.modelId;
+    assert(modelId !== undefined);
 
-      const nodes = await fetchNodesForNodeIds(modelId, revisionId, nodeIds, cdfClient);
-      nodeIds.forEach((e, ind) => {
-        const modelNodeIdKey = `${modelId}-${revisionId}-${e}` as const;
-        revisionNodeIdToNode.set(modelNodeIdKey, nodes[ind]);
-      });
-    }
-  );
+    const nodes = await fetchNodesForNodeIds(modelId, revisionId, nodeIds, cdfClient);
+    nodeIds.forEach((e, ind) => {
+      const modelNodeIdKey = `${modelId}-${revisionId}-${e}` as const;
+      revisionNodeIdToNode.set(modelNodeIdKey, nodes[ind]);
+    });
+  });
 
   await Promise.all(nodePromises);
 
   return revisionNodeIdToNode;
 }
 
-function createRevisionToNodeIdMap(edges: Array<FdmCadEdge>): Map<RevisionId, NodeId[]> {
+function createRevisionToNodeIdMap(edges: FdmCadEdge[]): Map<RevisionId, NodeId[]> {
   return edges.reduce((revisionNodeIdMap, edge) => {
-
     const nodeIdsInRevision = revisionNodeIdMap.get(edge.properties.revisionId);
 
     if (nodeIdsInRevision !== undefined) {
diff --git a/react-components/src/components/NodeCacheProvider/NodeCacheProvider.tsx b/react-components/src/components/NodeCacheProvider/NodeCacheProvider.tsx
index 35fe34ab589..4b7cc2e015c 100644
--- a/react-components/src/components/NodeCacheProvider/NodeCacheProvider.tsx
+++ b/react-components/src/components/NodeCacheProvider/NodeCacheProvider.tsx
@@ -3,7 +3,7 @@
  */
 
 import { type ReactElement, type ReactNode, createContext, useContext, useMemo } from 'react';
-import { FdmNodeCache, ModelRevisionToEdgeMap } from './FdmNodeCache';
+import { FdmNodeCache, type ModelRevisionToEdgeMap } from './FdmNodeCache';
 import { type UseQueryResult, useQuery } from '@tanstack/react-query';
 import { useFdmSdk, useSDK } from '../RevealContainer/SDKProvider';
 import { type Fdm3dNodeData } from './types';
diff --git a/react-components/src/components/NodeCacheProvider/RevisionFdmNodeCache.ts b/react-components/src/components/NodeCacheProvider/RevisionFdmNodeCache.ts
index 22086537050..02b75e531e1 100644
--- a/react-components/src/components/NodeCacheProvider/RevisionFdmNodeCache.ts
+++ b/react-components/src/components/NodeCacheProvider/RevisionFdmNodeCache.ts
@@ -4,7 +4,7 @@
 
 import { type CogniteClient, type Node3D } from '@cognite/sdk';
 import { type FdmSDK } from '../../utilities/FdmSDK';
-import { type TreeIndex } from './types';
+import { type TreeIndex, type Fdm3dNodeData, type FdmEdgeWithNode, type FdmCadEdge } from './types';
 
 import {
   fetchAncestorNodesForTreeIndex,
@@ -15,7 +15,6 @@ import {
 import { max } from 'lodash';
 
 import assert from 'assert';
-import { type Fdm3dNodeData, type FdmEdgeWithNode, type FdmCadEdge } from './types';
 
 export class RevisionFdmNodeCache {
   private readonly _cogniteClient: CogniteClient;
@@ -73,19 +72,19 @@ export class RevisionFdmNodeCache {
     }
 
     const firstMappedAncestor = ancestorsWithSameMapping.find(
-      (a) => a.treeIndex === firstMappedAncestorTreeIndex
+      (ancestor) => ancestor.treeIndex === firstMappedAncestorTreeIndex
     );
 
     assert(firstMappedAncestor !== undefined);
 
-    const nodeEdges = edges.map((e) => ({ edge: e, node: firstMappedAncestor }));
+    const nodeEdges = edges.map((edge) => ({ edge, node: firstMappedAncestor }));
 
     return await this.getDataWithViewsForFdmEdges(nodeEdges, ancestorsWithSameMapping);
   }
 
   private setCacheForNodes(nodes: Node3D[], nodeData: Fdm3dNodeData[]): void {
-    nodes.forEach((n) => {
-      this._treeIndexToFdmData.set(n.treeIndex, nodeData);
+    nodes.forEach((node) => {
+      this._treeIndexToFdmData.set(node.treeIndex, nodeData);
     });
   }
 
@@ -147,7 +146,9 @@ export class RevisionFdmNodeCache {
     nodes: Node3D[]
   ): Array<{ edge: FdmCadEdge; treeIndex: TreeIndex }> {
     return mappingEdges.map((edge) => {
-      const ancestorConnectedToEdge = nodes.find((a) => a.id === edge.properties.revisionNodeId);
+      const ancestorConnectedToEdge = nodes.find(
+        (ancestor) => ancestor.id === edge.properties.revisionNodeId
+      );
 
       assert(ancestorConnectedToEdge !== undefined);
 
@@ -160,8 +161,8 @@ export class RevisionFdmNodeCache {
 
   private async getMappingEdgesForAncestors(ancestors: Node3D[]): Promise<FdmCadEdge[]> {
     const cachedFirstMappedAncestor = ancestors
-      .filter((a) => this._treeIndexToFdmEdges.has(a.treeIndex))
-      .sort((a, b) => b.treeIndex - a.treeIndex)[0];
+      .filter((ancestor) => this._treeIndexToFdmEdges.has(ancestor.treeIndex))
+      .sort((nodeA, nodeB) => nodeB.treeIndex - nodeA.treeIndex)[0];
 
     if (cachedFirstMappedAncestor !== undefined) {
       const edgesAndNodes = this._treeIndexToFdmEdges.get(cachedFirstMappedAncestor.treeIndex);
@@ -219,9 +220,11 @@ function getAncestorDataForTreeIndex(
   ancestorsWithSameMapping: Node3D[];
   firstMappedAncestorTreeIndex: number;
 } {
-  const edgesForFirstMappedAncestor = edgesWithTreeIndex.filter((a) => a.treeIndex === treeIndex);
+  const edgesForFirstMappedAncestor = edgesWithTreeIndex.filter(
+    (edgeAndTreeIndex) => edgeAndTreeIndex.treeIndex === treeIndex
+  );
   const ancestorsBetweenSearchNodeAndFirstMappedAncestor = ancestors.filter(
-    (a) => a.treeIndex >= treeIndex
+    (ancestor) => ancestor.treeIndex >= treeIndex
   );
 
   return {