Reveal 3d

import type { Node3D } from '@cognite/sdk';
import type { DMInstanceRef } from '@cognite/reveal';
import { chunk, executeParallel } from '../utils/executeParallel';

const ASSET_MAPPING_CHUNK_SIZE = 1000;

/**
 * Multi-level asset mapping cache with split-chunk strategy.
 *
 * Three-way indexing:
 * - By model+revision: Fast lookup for all mappings in a model
 * - By asset instance (space:externalId): Fast lookup for all nodes belonging to an asset
 * - By node ID: Fast lookup for individual node metadata
 */
export class AssetMappingCache {
  private byModelCache = new Map<string, Map<string, Node3D[]>>();
  private byAssetCache = new Map<string, Node3D[]>();
  private byNodeCache = new Map<string, Node3D>();

  async getOrFetch(
    modelId: number,
    revisionId: number,
    assetInstances: DMInstanceRef[],
    fetchFn: (
      modelId: number,
      revisionId: number,
      instances: DMInstanceRef[]
    ) => Promise<Map<string, Node3D[]>>
  ): Promise<Map<string, Node3D[]>> {
    const modelKey = this.createModelKey(modelId, revisionId);

    const cachedModel = this.byModelCache.get(modelKey);
    if (cachedModel) {
      const { cached, uncached } = this.splitCachedAndMissing(
        assetInstances,
        cachedModel
      );

      if (uncached.length === 0) {
        return cached;
      }

      const fetched = await this.fetchAndCache(
        modelId,
        revisionId,
        uncached,
        fetchFn
      );

      return this.mergeMappings(cached, fetched);
    }

    return this.fetchAndCache(modelId, revisionId, assetInstances, fetchFn);
  }

  getCachedAssetMapping(instance: DMInstanceRef): Node3D[] | undefined {
    return this.byAssetCache.get(this.createAssetKey(instance));
  }

  getCachedNode(modelId: number, revisionId: number, treeIndex: number): Node3D | undefined {
    const key = this.createNodeKey(modelId, revisionId, treeIndex);
    return this.byNodeCache.get(key);
  }

  clear(): void {
    this.byModelCache.clear();
    this.byAssetCache.clear();
    this.byNodeCache.clear();
  }

  clearModel(modelId: number, revisionId: number): void {
    const modelKey = this.createModelKey(modelId, revisionId);
    this.byModelCache.delete(modelKey);
  }

  private createAssetKey(instance: DMInstanceRef): string {
    return `${instance.space}:${instance.externalId}`;
  }

  private createModelKey(modelId: number, revisionId: number): string {
    return `${modelId}/${revisionId}`;
  }

  private createNodeKey(modelId: number, revisionId: number, treeIndex: number): string {
    return `${modelId}/${revisionId}/${treeIndex}`;
  }

  private splitCachedAndMissing(
    assetInstances: DMInstanceRef[],
    cachedModel: Map<string, Node3D[]>
  ): {
    cached: Map<string, Node3D[]>;
    uncached: DMInstanceRef[];
  } {
    const cached = new Map<string, Node3D[]>();
    const uncached: DMInstanceRef[] = [];

    for (const instance of assetInstances) {
      const assetKey = this.createAssetKey(instance);
      const cachedNodes = cachedModel.get(assetKey);
      if (cachedNodes) {
        cached.set(assetKey, cachedNodes);
      } else {
        uncached.push(instance);
      }
    }

    return { cached, uncached };
  }

  private async fetchAndCache(
    modelId: number,
    revisionId: number,
    assetInstances: DMInstanceRef[],
    fetchFn: (
      modelId: number,
      revisionId: number,
      instances: DMInstanceRef[]
    ) => Promise<Map<string, Node3D[]>>
  ): Promise<Map<string, Node3D[]>> {
    const chunks = chunk(assetInstances, ASSET_MAPPING_CHUNK_SIZE);

    const results = await executeParallel(
      chunks.map((chunkInstances) => async () => {
        return fetchFn(modelId, revisionId, chunkInstances);
      }),
      3
    );

    const merged = new Map<string, Node3D[]>();
    for (const result of results) {
      if (result) {
        for (const [assetKey, nodes] of result.entries()) {
          merged.set(assetKey, nodes);
        }
      }
    }

    this.indexMappings(modelId, revisionId, merged);

    return merged;
  }

  private indexMappings(
    modelId: number,
    revisionId: number,
    mappings: Map<string, Node3D[]>
  ): void {
    const modelKey = this.createModelKey(modelId, revisionId);

    let modelCache = this.byModelCache.get(modelKey);
    if (!modelCache) {
      modelCache = new Map();
      this.byModelCache.set(modelKey, modelCache);
    }

    for (const [assetKey, nodes] of mappings.entries()) {
      modelCache.set(assetKey, nodes);
      this.byAssetCache.set(assetKey, nodes);

      for (const node of nodes) {
        if (node.treeIndex !== undefined) {
          const nodeKey = this.createNodeKey(modelId, revisionId, node.treeIndex);
          this.byNodeCache.set(nodeKey, node);
        }
      }
    }
  }

  private mergeMappings(
    map1: Map<string, Node3D[]>,
    map2: Map<string, Node3D[]>
  ): Map<string, Node3D[]> {
    const merged = new Map(map1);
    for (const [key, value] of map2.entries()) {
      merged.set(key, value);
    }
    return merged;
  }
}

import { createContext, useContext, useMemo } from 'react';
import { AssetMappingCache } from './AssetMappingCache';

interface CacheContextValue {
  assetMappingCache: AssetMappingCache;
}

const CacheContext = createContext<CacheContextValue | null>(null);

export function useCacheContext() {
  const context = useContext(CacheContext);
  if (!context) {
    throw new Error('useCacheContext must be used within CacheProvider');
  }
  return context;
}

export function useOptionalCacheContext() {
  return useContext(CacheContext);
}

interface CacheProviderProps {
  children: React.ReactNode;
}

/**
 * Provides shared cache instances to the component tree.
 * Wrap your app or 3D viewer area with this to enable cross-navigation caching
 * (70-90% reduction in API calls on subsequent visits).
 */
export function CacheProvider({ children }: CacheProviderProps) {
  const cacheValue = useMemo(() => ({
    assetMappingCache: new AssetMappingCache(),
  }), []);

  return (
    <CacheContext.Provider value={cacheValue}>
      {children}
    </CacheContext.Provider>
  );
}

import { useEffect, useRef } from 'react';
import {
  type CogniteCadModel,
  TreeIndexNodeCollection,
  NumericRange,
} from '@cognite/reveal';
import { useReveal } from '../hooks/useReveal';
import type { AddCadResourceOptions, InstanceStylingGroup } from '../types';
import { useFdmAssetMappings } from '../hooks/useFdmMappings';

interface Reveal3DResourcesProps {
  resources: AddCadResourceOptions[];
  instanceStyling?: InstanceStylingGroup[];
  onModelsLoaded?: () => void;
}

export function Reveal3DResources({
  resources,
  instanceStyling = [],
  onModelsLoaded,
}: Reveal3DResourcesProps) {
  const viewer = useReveal();
  const loadedModelsRef = useRef<CogniteCadModel[]>([]);

  useEffect(() => {
    if (!viewer || resources.length === 0) {
      return;
    }

    const cancelledRef = { current: false };

    const loadModels = async () => {
      const modelPromises = resources.map(async (resource) => {
        if (cancelledRef.current) return null;

        try {
          const existing = viewer.models.find(
            (m) =>
              m.modelId === resource.modelId &&
              m.revisionId === resource.revisionId
          );

          if (existing) {
            return existing as CogniteCadModel;
          }

          const addModelOptions: {
            modelId: number;
            revisionId: number;
            geometryFilter?: typeof resource.geometryFilter;
          } = {
            modelId: resource.modelId,
            revisionId: resource.revisionId,
          };
          if (resource.geometryFilter) {
            addModelOptions.geometryFilter = resource.geometryFilter;
          }
          const model = await viewer.addCadModel(addModelOptions);

          if (cancelledRef.current) {
            viewer.removeModel(model);
            return null;
          }

          if (resource.styling?.default) {
            const { renderGhosted, renderInFront } = resource.styling.default;
            if (renderGhosted !== undefined) {
              model.setDefaultNodeAppearance({
                renderGhosted,
                renderInFront: renderInFront ?? false,
              });
            }
          }

          return model;
        } catch (error) {
          console.error('Error loading CAD model:', error);
          return null;
        }
      });

      const loadedModels = (await Promise.all(modelPromises)).filter(
        (model): model is CogniteCadModel => model !== null
      );

      if (!cancelledRef.current) {
        loadedModelsRef.current = loadedModels;

        if (loadedModels.length > 0) {
          viewer.fitCameraToModels(loadedModels, 0);
        }

        if (onModelsLoaded) {
          onModelsLoaded();
        }
      }
    };

    loadModels();

    return () => {
      cancelledRef.current = true;
      const modelsToRemove = loadedModelsRef.current;
      for (const model of modelsToRemove) {
        try {
          viewer.removeModel(model);
        } catch (error) {
          console.error('Error removing model:', error);
        }
      }
      loadedModelsRef.current = [];
    };
  }, [viewer, resources, onModelsLoaded]);

  useApplyInstanceStyling(viewer, loadedModelsRef.current, instanceStyling);

  return null;
}

function useApplyInstanceStyling(
  viewer: ReturnType<typeof useReveal>,
  loadedModels: CogniteCadModel[],
  instanceStyling: InstanceStylingGroup[]
) {
  const appliedCollectionsRef = useRef<
    Map<CogniteCadModel, TreeIndexNodeCollection[]>
  >(new Map());

  const fdmInstances =
    instanceStyling.flatMap((group) => group.fdmAssetExternalIds || []) || [];

  const modelOptions = loadedModels.map((model) => ({
    type: 'cad' as const,
    modelId: model.modelId,
    revisionId: model.revisionId,
  }));

  const { data: assetMappings } = useFdmAssetMappings(
    fdmInstances,
    modelOptions
  );

  useEffect(() => {
    if (!viewer || loadedModels.length === 0) return;

    const hasFdmInstances = instanceStyling.some(
      (g) => g.fdmAssetExternalIds && g.fdmAssetExternalIds.length > 0
    );

    if (!hasFdmInstances) {
      for (const [model, collections] of appliedCollectionsRef.current.entries()) {
        for (const collection of collections) {
          try { model.unassignStyledNodeCollection(collection); } catch { /* already removed */ }
        }
      }
      appliedCollectionsRef.current.clear();
      return;
    }

    if (!assetMappings) return;

    for (const [model, collections] of appliedCollectionsRef.current.entries()) {
      for (const collection of collections) {
        try { model.unassignStyledNodeCollection(collection); } catch { /* already removed */ }
      }
    }
    appliedCollectionsRef.current.clear();

    for (const stylingGroup of instanceStyling) {
      if (!stylingGroup.fdmAssetExternalIds || !stylingGroup.style.cad) {
        continue;
      }

      const appearance = stylingGroup.style.cad;

      for (const model of loadedModels) {
        const modelMapping = assetMappings.find(
          (m) =>
            m.modelId === model.modelId && m.revisionId === model.revisionId
        );

        if (!modelMapping) continue;

        const nodeCollection = new TreeIndexNodeCollection();
        const indexSet = nodeCollection.getIndexSet();

        for (const instance of stylingGroup.fdmAssetExternalIds) {
          const nodes = modelMapping.mappings.get(`${instance.space}:${instance.externalId}`);
          if (!nodes) continue;

          for (const node of nodes) {
            if (
              node.treeIndex !== undefined &&
              node.subtreeSize !== undefined
            ) {
              const range = new NumericRange(node.treeIndex, node.subtreeSize);
              indexSet.addRange(range);
            }
          }
        }

        if (indexSet.count > 0) {
          nodeCollection.updateSet(indexSet);
          model.assignStyledNodeCollection(nodeCollection, appearance);

          const existing = appliedCollectionsRef.current.get(model) ?? [];
          existing.push(nodeCollection);
          appliedCollectionsRef.current.set(model, existing);
        }
      }
    }
  }, [viewer, loadedModels, instanceStyling, assetMappings]);
}

import { type ReactNode, type ReactElement, useRef, useEffect } from 'react';
import { createPortal } from 'react-dom';
import { useRevealContext } from '../hooks/useRevealContext';

export function RevealCanvas({
  children,
}: {
  children?: ReactNode;
}): ReactElement {
  const { viewer } = useRevealContext();
  const parentElement = useRef<HTMLDivElement>(null);

  useEffect(() => {
    if (parentElement.current !== null) {
      parentElement.current.appendChild(viewer.domElement);
    }
  }, [viewer]);

  return (
    <div
      style={{ width: '100%', height: '100%', overflow: 'hidden' }}
      ref={parentElement}
    >
      {createPortal(children, viewer.domElement)}
    </div>
  );
}

import { useRef, useEffect, createContext, useContext, useCallback } from 'react';
import type { Cognite3DViewer } from '@cognite/reveal';
import type { CogniteClient } from '@cognite/sdk';

interface RevealKeepAliveContextValue {
  getOrCreateViewer: (
    sdk: CogniteClient,
    createViewer: () => Cognite3DViewer
  ) => Cognite3DViewer;
  isMounted: () => boolean;
}

const RevealKeepAliveContext = createContext<RevealKeepAliveContextValue | null>(
  null
);

export function useRevealKeepAlive() {
  const context = useContext(RevealKeepAliveContext);
  if (!context) {
    throw new Error('useRevealKeepAlive must be used within RevealKeepAlive');
  }
  return context;
}

/**
 * Returns null when not inside a RevealKeepAlive provider.
 * Used by RevealProvider to conditionally reuse a kept-alive viewer.
 */
export function useOptionalRevealKeepAlive(): RevealKeepAliveContextValue | null {
  return useContext(RevealKeepAliveContext);
}

interface RevealKeepAliveProps {
  children: React.ReactNode;
}

/**
 * Keeps the Cognite3DViewer instance alive across component unmounts,
 * eliminating viewer reinitialization when navigating between assets (~2-3s saving).
 *
 * The viewer persists in a ref that survives child unmount/remount cycles.
 * Models are managed separately (added/removed as needed).
 * Disposal is deferred to survive React StrictMode's mount→unmount→remount cycle.
 */
export function RevealKeepAlive({ children }: RevealKeepAliveProps) {
  const viewerRef = useRef<Cognite3DViewer | null>(null);
  const mountedRef = useRef(false);

  const getOrCreateViewer = useCallback(
    (_sdk: CogniteClient, createViewer: () => Cognite3DViewer) => {
      if (!viewerRef.current) {
        viewerRef.current = createViewer();
      }
      return viewerRef.current;
    },
    []
  );

  const isMounted = useCallback(() => {
    return mountedRef.current;
  }, []);

  useEffect(() => {
    mountedRef.current = true;
    return () => {
      mountedRef.current = false;
    };
  }, []);

  useEffect(() => {
    return () => {
      if (viewerRef.current) {
        viewerRef.current.dispose();
        viewerRef.current = null;
      }
    };
  }, []);

  return (
    <RevealKeepAliveContext.Provider value={{ getOrCreateViewer, isMounted }}>
      {children}
    </RevealKeepAliveContext.Provider>
  );
}

import { createContext } from 'react';
import type { InstanceStylingGroup } from '../types';

export interface InstanceStylingController {
  getStylingGroups: () => InstanceStylingGroup[];
  addEventListener: (callback: () => void) => void;
  removeEventListener: (callback: () => void) => void;
  registerStylingGroup: (group: InstanceStylingGroup) => string;
  unregisterStylingGroup: (id: string) => void;
}

export const InstanceStylingContext = createContext<
  InstanceStylingController | undefined
>(undefined);

import { useRef, useCallback, type ReactNode, useMemo } from 'react';
import type { InstanceStylingGroup } from '../types';
import {
  InstanceStylingContext,
  type InstanceStylingController,
} from './instanceStylingContext';

interface InstanceStylingProviderProps {
  children: ReactNode;
}

/**
 * Provider for centralized instance styling management.
 * Components can register/unregister styling groups and listen for changes.
 */
export function InstanceStylingProvider({
  children,
}: InstanceStylingProviderProps) {
  const stylingGroupsRef = useRef<Map<string, InstanceStylingGroup>>(new Map());
  const listenersRef = useRef<Set<() => void>>(new Set());
  const nextIdRef = useRef(0);

  const getStylingGroups = useCallback(() => {
    return Array.from(stylingGroupsRef.current.values());
  }, []);

  const addEventListener = useCallback((callback: () => void): void => {
    listenersRef.current.add(callback);
    // Call once immediately to initialize with current state
    callback();
  }, []);

  const removeEventListener = useCallback((callback: () => void): void => {
    listenersRef.current.delete(callback);
  }, []);

  const notifyListeners = useCallback(() => {
    listenersRef.current.forEach((listener) => listener());
  }, []);

  const registerStylingGroup = useCallback(
    (group: InstanceStylingGroup): string => {
      const id = `styling-group-${nextIdRef.current++}`;
      stylingGroupsRef.current.set(id, group);
      notifyListeners();
      return id;
    },
    [notifyListeners]
  );

  const unregisterStylingGroup = useCallback(
    (id: string): void => {
      const deleted = stylingGroupsRef.current.delete(id);
      if (deleted) {
        notifyListeners();
      }
    },
    [notifyListeners]
  );

  const controller: InstanceStylingController = useMemo(
    () => ({
      getStylingGroups,
      addEventListener,
      removeEventListener,
      registerStylingGroup,
      unregisterStylingGroup,
    }),
    [
      getStylingGroups,
      addEventListener,
      removeEventListener,
      registerStylingGroup,
      unregisterStylingGroup,
    ]
  );

  return (
    <InstanceStylingContext.Provider value={controller}>
      {children}
    </InstanceStylingContext.Provider>
  );
}

import { createContext } from 'react';
import type { Cognite3DViewer } from '@cognite/reveal';
import type { CogniteClient } from '@cognite/sdk';

export interface RevealContextValue {
  viewer: Cognite3DViewer;
  sdk: CogniteClient;
}

export const RevealContext = createContext<RevealContextValue | undefined>(
  undefined
);

import { useEffect, useRef, useState } from 'react';
import { Cognite3DViewer } from '@cognite/reveal';
import type { RevealContextProps } from '../types';
import { RevealContext } from './revealContext';
import { InstanceStylingProvider } from './InstanceStylingProvider';
import { useOptionalRevealKeepAlive } from '../components/RevealKeepAlive';
import { RevealSettingsController } from '../settings/RevealSettingsController';

export function RevealProvider({
  children,
  sdk,
  color,
  viewerOptions,
}: RevealContextProps) {
  const keepAlive = useOptionalRevealKeepAlive();
  const keepAliveRef = useRef(keepAlive);
  keepAliveRef.current = keepAlive;

  const [viewerData] = useState(() => {
    const createViewer = () =>
      new Cognite3DViewer({
        sdk,
        useFlexibleCameraManager: true,
        ...viewerOptions,
      });

    const viewer = keepAlive
      ? keepAlive.getOrCreateViewer(sdk, createViewer)
      : createViewer();

    if (color) {
      viewer.setBackgroundColor({ color, alpha: 1 });
    }

    return { viewer, sdk };
  });

  useEffect(() => {
    const controller = new RevealSettingsController('medium');
    controller.applyToViewer(viewerData.viewer);
    return () => controller.dispose();
  }, [viewerData.viewer]);

  useEffect(() => {
    if (color) {
      viewerData.viewer.setBackgroundColor({ color, alpha: 1 });
    }
  }, [color, viewerData.viewer]);

  useEffect(() => {
    return () => {
      if (!keepAliveRef.current) {
        viewerData.viewer.dispose();
      }
    };
  }, []);

  return (
    <RevealContext.Provider value={viewerData}>
      <InstanceStylingProvider>{children}</InstanceStylingProvider>
    </RevealContext.Provider>
  );
}

import type { DMInstanceRef } from '@cognite/reveal';
import { useMemo } from 'react';
import {
  useInstancesWithBoundingBoxes,
  type InstancesWithBoxesAndOriginalInstance,
} from './useInstancesWithBoundingBoxes';
import { useFindRelated3dInstances } from './useFindRelated3dInstances';

export const useInstancesWithBounds = (
  inputInstances: DMInstanceRef[],
  originalInstance: DMInstanceRef
): InstancesWithBoxesAndOriginalInstance | undefined => {
  const instancesWithBounds = useInstancesWithBoundingBoxes(inputInstances);

  return useMemo<InstancesWithBoxesAndOriginalInstance | undefined>(() => {
    if (inputInstances.length === 0 || instancesWithBounds.length === 0) {
      return undefined;
    }
    return { instancesWithBoxes: [...instancesWithBounds], originalInstance };
  }, [instancesWithBounds, inputInstances.length, originalInstance]);
};

export function use3dDataForSelectedInstance(
  instance: DMInstanceRef
): InstancesWithBoxesAndOriginalInstance | undefined {
  const threeDRelatedSelection = useFindRelated3dInstances(instance);
  const selectedInstancesWithBoundsAndCorrespondingInstance =
    useInstancesWithBounds(threeDRelatedSelection, instance);
  return selectedInstancesWithBoundsAndCorrespondingInstance;
}

import { useQuery } from '@tanstack/react-query';
import type { DMInstanceRef } from '@cognite/reveal';
import type { Node3D, CogniteClient } from '@cognite/sdk';
import { useRevealContext } from './useRevealContext';
import type { ThreeDModelFdmMappings, CadModelOptions } from '../types';
import {
  ASSET_VIEW,
  COGNITE_3D_OBJECT_VIEW,
  COGNITE_CAD_NODE_VIEW,
} from '../utils/views';
import { unwrapProperties } from '../utils/data-mapper';
import type { CDFNode } from '../utils/cdf-types';

interface DmsUniqueIdentifier {
  space: string;
  externalId: string;
}

interface CogniteAssetProperties {
  space: string;
  externalId: string;
  object3D: DmsUniqueIdentifier;
}

interface CogniteCADNodeProperties {
  space: string;
  externalId: string;
  object3D: DmsUniqueIdentifier;
  model3D: DmsUniqueIdentifier;
  revisions: DmsUniqueIdentifier[];
  treeIndexes: number[];
  subTreeSizes: number[];
}

/**
 * Fetches FDM-to-CAD mappings using Core DM connections.
 * This queries the data model for CAD nodes connected to assets via object3D references.
 */
export function useFdmAssetMappings(
  instances: DMInstanceRef[],
  models: CadModelOptions[]
) {
  const { sdk } = useRevealContext();
  return useQuery({
    queryKey: [
      'fdm-cad-connections',
      instances.map((i) => `${i.space}:${i.externalId}`).join(','),
      models.map((m) => `${m.modelId}:${m.revisionId}`).join(','),
    ],
    queryFn: async (): Promise<ThreeDModelFdmMappings[]> => {
      if (instances.length === 0 || models.length === 0) {
        return [];
      }

      try {
        // Step 1: Query DMS for CAD connections
        // This traverses: Assets → object3D → CAD nodes
        const queryResult = await sdk.instances.query({
          with: {
            // Start from the input instances (assets)
            assets: {
              nodes: {
                filter: {
                  and: [
                    {
                      in: {
                        property: ['node', 'space'],
                        values: [
                          ...new Set(instances.map((inst) => inst.space)),
                        ],
                      },
                    },
                    {
                      in: {
                        property: ['node', 'externalId'],
                        values: instances.map((inst) => inst.externalId),
                      },
                    },
                  ],
                },
              },
            },
            // Navigate to object3D (Cognite3DObject)
            object_3ds: {
              nodes: {
                from: 'assets',
                through: {
                  view: { type: 'view', ...ASSET_VIEW },
                  identifier: 'object3D',
                },
                direction: 'outwards',
                filter: {
                  hasData: [{ type: 'view', ...COGNITE_3D_OBJECT_VIEW }],
                },
              },
            },
            // Navigate back to CAD nodes that reference this object3D
            cad_nodes: {
              nodes: {
                from: 'object_3ds',
                through: {
                  view: { type: 'view', ...COGNITE_CAD_NODE_VIEW },
                  identifier: 'object3D',
                },
                direction: 'inwards',
              },
            },
          },
          select: {
            assets: {
              sources: [
                {
                  source: { type: 'view', ...ASSET_VIEW },
                  properties: ['object3D'],
                },
              ],
            },
            cad_nodes: {
              sources: [
                {
                  source: { type: 'view', ...COGNITE_CAD_NODE_VIEW },
                  properties: [
                    'object3D',
                    'model3D',
                    'revisions',
                    'treeIndexes',
                    'subTreeSizes',
                  ],
                },
              ],
            },
          },
        });

        // Step 2: Build mappings per model/revision
        const mappingsByModel = new Map<string, Map<string, Node3D[]>>();

        const cadNodes = queryResult.items.cad_nodes || [];

        // Group CAD nodes by which instances reference them
        const object3DToAssets = new Map<string, DMInstanceRef[]>();
        for (const asset of queryResult.items.assets || []) {
          const props = unwrapProperties<CogniteAssetProperties>(
            asset as CDFNode,
            ASSET_VIEW
          );
          if (props?.object3D) {
            const key = `${props.object3D.space}/${props.object3D.externalId}`;
            const existing = object3DToAssets.get(key) || [];
            existing.push({ space: asset.space, externalId: asset.externalId });
            object3DToAssets.set(key, existing);
          }
        }

        // Collect all (modelId, revisionId, treeIndex) tuples for batch fetching
        interface NodeRequest {
          modelId: number;
          revisionId: number;
          treeIndex: number;
          assetInstances: DMInstanceRef[];
        }

        const nodeRequests: NodeRequest[] = [];

        // Process CAD nodes to build Node3D mappings
        for (const cadNode of cadNodes) {
          const props = unwrapProperties<CogniteCADNodeProperties>(
            cadNode as CDFNode,
            COGNITE_CAD_NODE_VIEW
          );
          if (!props) continue;

          const { model3D, revisions, treeIndexes, object3D } = props;
          if (!model3D || !revisions || !treeIndexes) continue;

          // Find which assets reference this CAD node
          const object3DKey = `${object3D.space}/${object3D.externalId}`;
          const relatedAssets = object3DToAssets.get(object3DKey);
          if (!relatedAssets) continue;

          // Extract modelId and match with requested models
          const modelId = extractModelId(model3D.externalId);

          // For each revision/treeIndex pair
          for (let i = 0; i < revisions.length; i++) {
            const revision = revisions[i];
            const treeIndex = treeIndexes[i];
            const revisionId = extractRevisionId(revision.externalId);

            // Check if this model/revision is in our requested list
            const matchingModel = models.find(
              (m) => m.modelId === modelId && m.revisionId === revisionId
            );
            if (!matchingModel) continue;

            nodeRequests.push({
              modelId,
              revisionId,
              treeIndex,
              assetInstances: relatedAssets,
            });
          }
        }

        // Batch fetch nodes by revision
        const nodesByRevision = new Map<string, NodeRequest[]>();
        for (const req of nodeRequests) {
          const key = `${req.modelId}/${req.revisionId}`;
          const existing = nodesByRevision.get(key) || [];
          existing.push(req);
          nodesByRevision.set(key, existing);
        }

        // Fetch all nodes in parallel per revision
        const revisionFetchPromises = Array.from(nodesByRevision.entries()).map(
          async ([revisionKey, requests]) => {
            const [modelId, revisionId] = revisionKey.split('/').map(Number);
            const treeIndexes = requests.map((r) => r.treeIndex);

            const nodes = await fetchNodesByTreeIndex(
              sdk,
              modelId,
              revisionId,
              treeIndexes
            );

            return { revisionKey, nodes, requests };
          }
        );

        const allRevisionData = await Promise.all(revisionFetchPromises);

        for (const { revisionKey, nodes, requests } of allRevisionData) {
          const treeIndexToNode = new Map(
            nodes.map((node) => [node.treeIndex, node])
          );

          const modelMappings =
            mappingsByModel.get(revisionKey) ?? new Map<string, Node3D[]>();
          mappingsByModel.set(revisionKey, modelMappings);

          for (const req of requests) {
            const node3D = treeIndexToNode.get(req.treeIndex);
            if (!node3D) continue;

            for (const instance of req.assetInstances) {
              const instanceKey = `${instance.space}:${instance.externalId}`;
              const arr = modelMappings.get(instanceKey) ?? [];
              arr.push(node3D);
              modelMappings.set(instanceKey, arr);
            }
          }
        }

        // Convert to result format
        const results: ThreeDModelFdmMappings[] = [];
        for (const model of models) {
          const modelKey = `${model.modelId}/${model.revisionId}`;
          results.push({
            modelId: model.modelId,
            revisionId: model.revisionId,
            mappings: mappingsByModel.get(modelKey) ?? new Map(),
          });
        }

        return results;
      } catch (error) {
        console.error('Error fetching FDM CAD connections:', error);
        return [];
      }
    },
    enabled: !!sdk && instances.length > 0 && models.length > 0,
    staleTime: 5 * 60 * 1000, // 5 minutes
  });
}

// Helper to extract numeric modelId from externalId like "model_123_space"
function extractModelId(externalId: string): number {
  const match = externalId.match(/model_(\d+)/);
  return match ? parseInt(match[1], 10) : -1;
}

// Helper to extract numeric revisionId from externalId like "model_123_revision_456_space"
function extractRevisionId(externalId: string): number {
  const match = externalId.match(/revision_(\d+)/);
  return match ? parseInt(match[1], 10) : -1;
}

/**
 * Fetch 3D nodes by their tree indices using the optimized internal IDs endpoint.
 * This is much more efficient than fetching all nodes and filtering.
 */
async function fetchNodesByTreeIndex(
  sdk: CogniteClient,
  modelId: number,
  revisionId: number,
  treeIndexes: number[]
): Promise<Node3D[]> {
  if (treeIndexes.length === 0) {
    return [];
  }

  // Deduplicate tree indices
  const uniqueTreeIndexes = Array.from(new Set(treeIndexes));

  // Step 1: Convert tree indices to internal node IDs
  const nodeIdResponse = await sdk.post<{ items: number[] }>(
    `/api/v1/projects/${sdk.project}/3d/models/${modelId}/revisions/${revisionId}/nodes/internalids/bytreeindices`,
    {
      data: {
        items: uniqueTreeIndexes,
      },
    }
  );

  const nodeIds = nodeIdResponse.data.items;

  if (nodeIds.length === 0) {
    return [];
  }

  // Step 2: Retrieve full node details by internal IDs
  const nodes = await sdk.revisions3D.retrieve3DNodes(
    modelId,
    revisionId,
    nodeIds.map((id) => ({ id }))
  );

  return nodes;
}

import { useMemo } from 'react';
import {
  use3dRelatedDirectConnections,
  use3dRelatedEdgeConnections,
} from './useRelatedInstances';
import type { DMInstanceRef } from '@cognite/reveal';

export const useFindRelated3dInstances = (
  instance: DMInstanceRef
): DMInstanceRef[] => {
  const edgeRelationData = use3dRelatedEdgeConnections(instance);
  const directRelationData = use3dRelatedDirectConnections(instance);

  return useMemo<DMInstanceRef[]>(() => {
    const edgeDirectRelationData = [
      ...(edgeRelationData.data ?? []),
      ...(directRelationData.data ?? []),
    ];
    return [instance, ...edgeDirectRelationData];
  }, [instance, edgeRelationData.data, directRelationData.data]);
};

import { DefaultCameraManager, type DMInstanceRef } from '@cognite/reveal';
import { useReveal } from './useReveal';
import { useCallback, useEffect } from 'react';
import { Box3, Vector3 } from 'three';
import { use3dDataForSelectedInstance } from './use3dDataForSelectedInstance';
import type { InstanceWithBoundingBox } from './useInstancesWithBoundingBoxes';

/**
 * Calculate an angled camera position for a bounding box
 * @param box - The bounding box to frame
 * @returns Camera position and target vectors
 */
function calculateAngledCameraPosition(box: Box3): {
  position: Vector3;
  target: Vector3;
} {
  // Get bounding box center and size
  const center = new Vector3();
  box.getCenter(center);

  const size = new Vector3();
  box.getSize(size);

  // Calculate the maximum dimension to determine camera distance
  const maxDim = Math.max(size.x, size.y, size.z);
  const fov = 60; // Field of view in degrees
  const cameraDistance = (maxDim / (2 * Math.tan((fov * Math.PI) / 360))) * 1.5;

  // Position camera at 45-degree angle (above and to the side)
  // Using spherical coordinates: 45° elevation, 45° azimuth
  const angle = Math.PI / 4; // 45 degrees
  const cameraPosition = new Vector3(
    center.x + cameraDistance * Math.cos(angle) * Math.cos(angle),
    center.y + cameraDistance * Math.sin(angle),
    center.z + cameraDistance * Math.cos(angle) * Math.sin(angle)
  );

  return {
    position: cameraPosition,
    target: center,
  };
}

const useFocusCameraWithInstanceBox = (
  instancesWithBoundingBox: InstanceWithBoundingBox[]
) => {
  const viewer = useReveal();

  useEffect(() => {
    if (viewer.cameraManager instanceof DefaultCameraManager) {
      viewer.cameraManager.setCameraControlsOptions({
        mouseWheelAction: 'zoomToCursor',
      });
    }
  }, [viewer.cameraManager]);

  return useCallback(() => {
    if (instancesWithBoundingBox.length === 0) {
      return;
    }

    const box = instancesWithBoundingBox.reduce(
      (unionBox, instance) => unionBox.union(instance.boundingBox),
      new Box3()
    );

    if (!box.isEmpty()) {
      const cameraState = calculateAngledCameraPosition(box);
      viewer.cameraManager.setCameraState(cameraState);
    }
  }, [instancesWithBoundingBox, viewer]);
};

export const useFocusCamera = (instance: DMInstanceRef) => {
  const selectedInstanceData = use3dDataForSelectedInstance(instance);
  return useFocusCameraWithInstanceBox(
    selectedInstanceData?.instancesWithBoxes ?? []
  );
};

import { useMemo } from 'react';
import { useEffect, useState } from 'react';
import { useRenderTarget } from './useRenderTarget';
import type { FdmAssetStylingGroup, InstanceStylingGroup } from '../types';
import { DefaultNodeAppearance, type DMInstanceRef } from '@cognite/reveal';
import { use3dDataForSelectedInstance } from './use3dDataForSelectedInstance';
import type { InstanceWithBoundingBox } from './useInstancesWithBoundingBoxes';

const useCentralizedInstanceStyling = (): InstanceStylingGroup[] => {
  const [instanceStylingGroups, setInstanceStylingGroups] = useState<
    InstanceStylingGroup[]
  >([]);
  const instanceStylingController = useRenderTarget().instanceStylingController;

  useEffect(() => {
    const onStylingChange = () => {
      setInstanceStylingGroups([
        ...instanceStylingController.getStylingGroups(),
      ]);
    };

    instanceStylingController.addEventListener(onStylingChange);
    return () => {
      instanceStylingController.removeEventListener(onStylingChange);
    };
  }, [instanceStylingController]);

  return instanceStylingGroups;
};

const getInstanceStyling = (
  instances: InstanceWithBoundingBox[]
): FdmAssetStylingGroup[] =>
  instances.length === 0
    ? []
    : [
        {
          fdmAssetExternalIds: instances.map(({ instance }) => instance),
          style: {
            cad: DefaultNodeAppearance.Highlighted,
            pointcloud: DefaultNodeAppearance.Highlighted,
          },
        },
      ];

export const useInstanceStyling = (instance: DMInstanceRef) => {
  const selectedInstancesAndOriginalInstance =
    use3dDataForSelectedInstance(instance);

  const centralizedInstanceStyling = useCentralizedInstanceStyling();

  return useMemo(
    () => [
      ...centralizedInstanceStyling,
      ...getInstanceStyling(
        selectedInstancesAndOriginalInstance?.instancesWithBoxes ?? []
      ),
    ],
    [
      selectedInstancesAndOriginalInstance?.instancesWithBoxes,
      centralizedInstanceStyling,
    ]
  );
};

import type { DMInstanceRef } from '@cognite/reveal';
import { use3dModels } from './useModels';
import { useFdmAssetMappings } from './useFdmMappings';
import type { CadModelOptions, ThreeDModelFdmMappings, CogniteModel } from '../types';
import type { Node3D } from '@cognite/sdk';
import { useMemo } from 'react';
import { Box3 } from 'three';

export type InstanceWithBoundingBox = {
  instance: DMInstanceRef;
  boundingBox: Box3;
};

export type InstancesWithBoxesAndOriginalInstance = {
  instancesWithBoxes: InstanceWithBoundingBox[];
  originalInstance: DMInstanceRef;
};

export type NodesWithModelInfo = {
  nodes: Node3D[];
  instance: DMInstanceRef;
  modelId: number;
  revisionId: number;
};

const combineNodeBoundingBoxes = (nodes: Node3D[]): Box3 =>
  nodes.reduce(
    (currentBox, nextNode) =>
      currentBox.union(
        nextNode.boundingBox !== undefined
          ? new Box3().setFromArray([
              ...nextNode.boundingBox.min,
              ...nextNode.boundingBox.max,
            ])
          : new Box3()
      ),
    new Box3()
  );

const getFdmDataWithBoundingBoxes = (
  modelsWithRelevantNodes: NodesWithModelInfo[],
  models: CogniteModel[]
): InstanceWithBoundingBox[] => {
  const cdfCoordinateBoundingBoxes = modelsWithRelevantNodes.map(
    (nodesWithModel) => combineNodeBoundingBoxes(nodesWithModel.nodes)
  );

  const selectedNodeCadModels = modelsWithRelevantNodes.map((nodeModelData) =>
    models.find(
      ({ modelId, revisionId }) =>
        modelId === nodeModelData.modelId &&
        revisionId === nodeModelData.revisionId
    )
  );

  if (
    selectedNodeCadModels.length === 0 ||
    cdfCoordinateBoundingBoxes.length === 0
  ) {
    return [];
  }

  const viewerCoordinateBoundingBoxes = selectedNodeCadModels
    .map((model, ind) =>
      model?.mapBoxFromCdfToModelCoordinates(cdfCoordinateBoundingBoxes[ind])
    )
    .filter((val) => val !== undefined);

  return viewerCoordinateBoundingBoxes.map((boundingBox, ind) => ({
    instance: modelsWithRelevantNodes[ind].instance!,
    boundingBox,
  }));
};

export function getNodesFromModelsFdmMappings(
  instances: DMInstanceRef[],
  mappings?: ThreeDModelFdmMappings[]
): NodesWithModelInfo[] {
  const nodesWithModelIds = mappings?.flatMap((modelMappings) =>
    instances.reduce((infoArray, instance) => {
      const nodes = modelMappings.mappings.get(`${instance.space}:${instance.externalId}`);
      if (nodes === undefined) {
        return infoArray;
      }
      infoArray.push({
        instance,
        modelId: modelMappings.modelId,
        revisionId: modelMappings.revisionId,
        nodes,
      });
      return infoArray;
    }, new Array<NodesWithModelInfo>())
  );
  return nodesWithModelIds ?? [];
}

const getBoundingBoxInstancesFromFdmAndModelMappings = (
  instances: DMInstanceRef[],
  modelMappings: ThreeDModelFdmMappings[] | undefined,
  models: CogniteModel[]
): InstanceWithBoundingBox[] => {
  const modelsWithRelevantNodes = getNodesFromModelsFdmMappings(
    instances,
    modelMappings
  );
  if (modelsWithRelevantNodes.length === 0) {
    return [];
  }
  return getFdmDataWithBoundingBoxes(modelsWithRelevantNodes, models);
};

export const useInstancesWithBoundingBoxes = (
  inputInstances: DMInstanceRef[]
) => {
  const models = use3dModels();
  const { data: modelNodeMappings } = useFdmAssetMappings(
    inputInstances,
    models as CadModelOptions[]
  );

  return useMemo(
    () =>
      getBoundingBoxInstancesFromFdmAndModelMappings(
        inputInstances,
        modelNodeMappings,
        models
      ),
    [modelNodeMappings, inputInstances, models]
  );
};

import { useQuery } from '@tanstack/react-query';
import type { DMInstanceRef } from '@cognite/reveal';
import { useRevealContext } from './useRevealContext';
import type { TaggedAddResourceOptions } from '../types';
import { useReveal } from './useReveal';
import {
  COGNITE_VISUALIZABLE_VIEW,
  COGNITE_CAD_NODE_VIEW,
} from '../utils/views';
import { unwrapProperties } from '../utils/data-mapper';
import type { CDFNode } from '../utils/cdf-types';

interface CogniteCADNodeProperties {
  space: string;
  externalId: string;
  model3D: { externalId: string; space: string };
  revisions: Array<{ externalId: string; space: string }>;
}

/**
 * Extracts numeric ID from CDF external ID format (e.g., "cog_3d_model_12345" -> 12345)
 */
function extractNumericId(externalId: string): number | undefined {
  const lastUnderscoreIndex = externalId.lastIndexOf('_');
  if (lastUnderscoreIndex === -1) return undefined;

  const numericPart = externalId.substring(lastUnderscoreIndex + 1);
  const id = parseInt(numericPart, 10);
  return isNaN(id) ? undefined : id;
}

/**
 * Fetches 3D CAD models associated with an FDM instance via the Cognite Core Data Model.
 * Traverses: Asset -> object3D (CogniteVisualizable) -> CogniteCADNode -> models/revisions
 */
export function useModelsForInstanceQuery(instance: DMInstanceRef) {
  const { sdk } = useRevealContext();

  const result = useQuery({
    queryKey: ['3d-models-for-instance', instance.space, instance.externalId],
    queryFn: async () => {
      try {
        const response = await sdk.instances.query({
          with: {
            asset: {
              nodes: {
                filter: {
                  and: [
                    {
                      equals: {
                        property: ['node', 'externalId'],
                        value: instance.externalId,
                      },
                    },
                    {
                      equals: {
                        property: ['node', 'space'],
                        value: instance.space,
                      },
                    },
                  ],
                },
              },
            },
            object_3ds: {
              nodes: {
                from: 'asset',
                through: {
                  view: { type: 'view', ...COGNITE_VISUALIZABLE_VIEW },
                  identifier: 'object3D',
                },
                direction: 'outwards',
              },
            },
            cad_nodes: {
              nodes: {
                from: 'object_3ds',
                through: {
                  view: { type: 'view', ...COGNITE_CAD_NODE_VIEW },
                  identifier: 'object3D',
                },
                direction: 'inwards',
              },
            },
          },
          select: {
            cad_nodes: {
              sources: [
                {
                  source: { type: 'view', ...COGNITE_CAD_NODE_VIEW },
                  properties: ['model3D', 'revisions'],
                },
              ],
            },
          },
        });

        const models: TaggedAddResourceOptions[] = [];
        const seenModels = new Set<string>();

        // Extract model/revision info from CAD nodes
        const cadNodes = response.items?.cad_nodes || [];

        for (const node of cadNodes) {
          const props = unwrapProperties<CogniteCADNodeProperties>(
            node as CDFNode,
            COGNITE_CAD_NODE_VIEW
          );
          if (!props?.model3D || !Array.isArray(props.revisions)) {
            continue;
          }

          const modelId = extractNumericId(props.model3D.externalId);
          if (!modelId) continue;

          // Process each revision
          for (const revision of props.revisions) {
            const revisionId = extractNumericId(revision.externalId);
            if (!revisionId) continue;

            const modelKey = `${modelId}:${revisionId}`;
            if (seenModels.has(modelKey)) continue;

            seenModels.add(modelKey);
            models.push({ type: 'cad', addOptions: { modelId, revisionId } });
          }
        }

        return models;
      } catch (error) {
        console.error('[useModelsForInstanceQuery] Error:', error);
        return [] as TaggedAddResourceOptions[];
      }
    },
    enabled: !!sdk,
    staleTime: 5 * 60 * 1000, // 5 minutes
    gcTime: 10 * 60 * 1000, // 10 minutes
  });

  return result;
}

/**
 * Returns all loaded 3D models in the viewer.
 * Models are only present after Reveal3DResources has loaded them.
 *
 * Note: This returns the viewer.models array directly without polling.
 * Components should be structured so that model loading triggers re-renders naturally.
 */
export function use3dModels() {
  const viewer = useReveal();
  return viewer.models || [];
}

import { useMemo } from 'react';
import { useQuery } from '@tanstack/react-query';
import type { DMInstanceRef } from '@cognite/reveal';
import type { Node3D, CogniteClient } from '@cognite/sdk';
import { useRevealContext } from './useRevealContext';
import type { ThreeDModelFdmMappings } from '../types';
import {
  ASSET_VIEW,
  COGNITE_3D_OBJECT_VIEW,
  COGNITE_CAD_NODE_VIEW,
} from '../utils/views';
import { unwrapProperties } from '../utils/data-mapper';
import type { CDFNode } from '../utils/cdf-types';
import { executeParallel, chunk } from '../utils/executeParallel';

const TREE_INDEX_CHUNK_SIZE = 1000;
const NODE_ID_CHUNK_SIZE = 100;

interface ModelRef {
  modelId: number;
  revisionId: number;
}

interface DmsUniqueIdentifier {
  space: string;
  externalId: string;
}

interface CogniteAssetProperties {
  space: string;
  externalId: string;
  object3D: DmsUniqueIdentifier;
}

interface CogniteCADNodeProperties {
  space: string;
  externalId: string;
  object3D: DmsUniqueIdentifier;
  model3D: DmsUniqueIdentifier;
  revisions: DmsUniqueIdentifier[];
  treeIndexes: number[];
  subTreeSizes: number[];
}

/**
 * Prefetch FDM asset mappings using model IDs from the query result,
 * NOT waiting for models to be loaded into the viewer.
 *
 * This eliminates 1-3 seconds from the critical path by running mapping fetch
 * in parallel with model loading instead of sequentially after.
 */
export function usePrefetchedFdmMappings(
  instances: DMInstanceRef[],
  modelRefs: ModelRef[]
) {
  const { sdk } = useRevealContext();

  const instancesKey = useMemo(
    () => instances.map((i) => `${i.space}:${i.externalId}`).join(','),
    [instances]
  );
  const modelRefsKey = useMemo(
    () => modelRefs.map((m) => `${m.modelId}:${m.revisionId}`).join(','),
    [modelRefs]
  );

  return useQuery({
    queryKey: ['fdm-cad-connections-prefetched', instancesKey, modelRefsKey],
    queryFn: async (): Promise<ThreeDModelFdmMappings[]> => {
      if (instances.length === 0 || modelRefs.length === 0) {
        return [];
      }

      try {
        const queryResult = await sdk.instances.query({
          with: {
            assets: {
              nodes: {
                filter: {
                  and: [
                    {
                      in: {
                        property: ['node', 'space'],
                        values: [
                          ...new Set(instances.map((inst) => inst.space)),
                        ],
                      },
                    },
                    {
                      in: {
                        property: ['node', 'externalId'],
                        values: instances.map((inst) => inst.externalId),
                      },
                    },
                  ],
                },
              },
            },
            object_3ds: {
              nodes: {
                from: 'assets',
                through: {
                  view: { type: 'view', ...ASSET_VIEW },
                  identifier: 'object3D',
                },
                direction: 'outwards',
                filter: {
                  hasData: [{ type: 'view', ...COGNITE_3D_OBJECT_VIEW }],
                },
              },
            },
            cad_nodes: {
              nodes: {
                from: 'object_3ds',
                through: {
                  view: { type: 'view', ...COGNITE_CAD_NODE_VIEW },
                  identifier: 'object3D',
                },
                direction: 'inwards',
              },
            },
          },
          select: {
            assets: {
              sources: [
                {
                  source: { type: 'view', ...ASSET_VIEW },
                  properties: ['object3D'],
                },
              ],
            },
            cad_nodes: {
              sources: [
                {
                  source: { type: 'view', ...COGNITE_CAD_NODE_VIEW },
                  properties: [
                    'object3D',
                    'model3D',
                    'revisions',
                    'treeIndexes',
                    'subTreeSizes',
                  ],
                },
              ],
            },
          },
        });

        const mappingsByModel = new Map<string, Map<string, Node3D[]>>();
        const cadNodes = queryResult.items.cad_nodes || [];

        const object3DToAssets = new Map<string, DMInstanceRef[]>();
        for (const asset of queryResult.items.assets || []) {
          const props = unwrapProperties<CogniteAssetProperties>(
            asset as CDFNode,
            ASSET_VIEW
          );
          if (props?.object3D) {
            const key = `${props.object3D.space}/${props.object3D.externalId}`;
            const existing = object3DToAssets.get(key) || [];
            existing.push({ space: asset.space, externalId: asset.externalId });
            object3DToAssets.set(key, existing);
          }
        }

        interface NodeRequest {
          modelId: number;
          revisionId: number;
          treeIndex: number;
          assetInstances: DMInstanceRef[];
        }

        const nodeRequests: NodeRequest[] = [];

        for (const cadNode of cadNodes) {
          const props = unwrapProperties<CogniteCADNodeProperties>(
            cadNode as CDFNode,
            COGNITE_CAD_NODE_VIEW
          );
          if (!props) continue;

          const { model3D, revisions, treeIndexes, object3D } = props;
          if (!model3D || !revisions || !treeIndexes) continue;

          const object3DKey = `${object3D.space}/${object3D.externalId}`;
          const relatedAssets = object3DToAssets.get(object3DKey);
          if (!relatedAssets) continue;

          const modelId = extractModelId(model3D.externalId);

          for (let i = 0; i < revisions.length; i++) {
            const revision = revisions[i];
            const treeIndex = treeIndexes[i];
            const revisionId = extractRevisionId(revision.externalId);

            const matchingModel = modelRefs.find(
              (m) => m.modelId === modelId && m.revisionId === revisionId
            );
            if (!matchingModel) continue;

            nodeRequests.push({
              modelId,
              revisionId,
              treeIndex,
              assetInstances: relatedAssets,
            });
          }
        }

        const nodesByRevision = new Map<string, NodeRequest[]>();
        for (const req of nodeRequests) {
          const key = `${req.modelId}/${req.revisionId}`;
          const existing = nodesByRevision.get(key) || [];
          existing.push(req);
          nodesByRevision.set(key, existing);
        }

        const revisionFetchPromises = Array.from(nodesByRevision.entries()).map(
          async ([revisionKey, requests]) => {
            const [modelId, revisionId] = revisionKey.split('/').map(Number);
            const treeIndexes = requests.map((r) => r.treeIndex);

            const nodes = await fetchNodesByTreeIndex(
              sdk,
              modelId,
              revisionId,
              treeIndexes
            );

            return { revisionKey, nodes, requests };
          }
        );

        const allRevisionData = await Promise.all(revisionFetchPromises);

        for (const { revisionKey, nodes, requests } of allRevisionData) {
          const treeIndexToNode = new Map(
            nodes.map((node) => [node.treeIndex, node])
          );

          const modelMappings =
            mappingsByModel.get(revisionKey) ?? new Map<string, Node3D[]>();
          mappingsByModel.set(revisionKey, modelMappings);

          for (const req of requests) {
            const node3D = treeIndexToNode.get(req.treeIndex);
            if (!node3D) continue;

            for (const instance of req.assetInstances) {
              const instanceKey = `${instance.space}:${instance.externalId}`;
              const arr = modelMappings.get(instanceKey) ?? [];
              arr.push(node3D);
              modelMappings.set(instanceKey, arr);
            }
          }
        }

        const results: ThreeDModelFdmMappings[] = [];
        for (const modelRef of modelRefs) {
          const modelKey = `${modelRef.modelId}/${modelRef.revisionId}`;
          results.push({
            modelId: modelRef.modelId,
            revisionId: modelRef.revisionId,
            mappings: mappingsByModel.get(modelKey) ?? new Map(),
          });
        }

        return results;
      } catch (error) {
        console.error('Error prefetching FDM CAD connections:', error);
        return [];
      }
    },
    enabled: !!sdk && instances.length > 0 && modelRefs.length > 0,
    staleTime: 5 * 60 * 1000,
  });
}

function extractModelId(externalId: string): number {
  const match = externalId.match(/model_(\d+)/);
  return match ? parseInt(match[1], 10) : -1;
}

function extractRevisionId(externalId: string): number {
  const match = externalId.match(/revision_(\d+)/);
  return match ? parseInt(match[1], 10) : -1;
}

async function fetchNodesByTreeIndex(
  sdk: CogniteClient,
  modelId: number,
  revisionId: number,
  treeIndexes: number[]
): Promise<Node3D[]> {
  if (treeIndexes.length === 0) return [];

  const uniqueTreeIndexes = Array.from(new Set(treeIndexes));
  const treeIndexChunks = chunk(uniqueTreeIndexes, TREE_INDEX_CHUNK_SIZE);

  const results = await executeParallel(
    treeIndexChunks.map((indexChunk) => async () => {
      const nodeIdResponse = await sdk.post<{ items: number[] }>(
        `/api/v1/projects/${sdk.project}/3d/models/${modelId}/revisions/${revisionId}/nodes/internalids/bytreeindices`,
        {
          data: { items: indexChunk },
        }
      );

      const nodeIds = nodeIdResponse.data.items;
      if (nodeIds.length === 0) return [];

      const nodeIdChunks = chunk(nodeIds, NODE_ID_CHUNK_SIZE);
      const nodeResults = await executeParallel(
        nodeIdChunks.map((idChunk) => async () => {
          const nodes = await sdk.revisions3D.retrieve3DNodes(
            modelId,
            revisionId,
            idChunk.map((id) => ({ id }))
          );
          return Array.isArray(nodes) ? nodes : [];
        }),
        3
      );

      return nodeResults.flat().filter((node): node is Node3D => node !== undefined);
    }),
    3
  );

  return results.flat().filter((node): node is Node3D => node !== undefined);
}