LCOV - code coverage report
Current view: top level - src/extensions/core/load3d/services - load3dService.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 72.0 % 50 36
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : /**
       2              :  * Load3D Service - provides access to Load3D instances
       3              :  *
       4              :  * This service uses lazy imports to avoid pulling THREE.js into the main bundle.
       5              :  * The nodeToLoad3dMap is accessed lazily - it will only be available after
       6              :  * the load3d extension has been loaded.
       7              :  */
       8              : import { toRaw } from 'vue'
       9              : 
      10              : import type Load3d from '@comfyorg/viewport3d/load3d/Load3d'
      11              : import {
      12              :   cacheNodeToLoad3dMap,
      13              :   getNodeToLoad3dMapSync,
      14              :   removeLoad3d
      15              : } from '@/extensions/core/load3d/load3dInstances'
      16              : import type {
      17              :   AnimationItem,
      18              :   BackgroundRenderModeType,
      19              :   CameraType,
      20              :   MaterialMode,
      21              :   UpDirection
      22              : } from '@comfyorg/viewport3d/load3d/interfaces'
      23              : import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
      24              : import type { NodeId } from '@comfyorg/graph-model/nodeId'
      25              : 
      26              : // Type for the useLoad3dViewer composable function
      27              : // Using explicit type to avoid import() type annotations (lint rule)
      28              : type UseLoad3dViewerFn = (node?: LGraphNode) => {
      29              :   backgroundColor: { value: string }
      30              :   showGrid: { value: boolean }
      31              :   cameraType: { value: CameraType }
      32              :   fov: { value: number }
      33              :   lightIntensity: { value: number }
      34              :   backgroundImage: { value: string }
      35              :   hasBackgroundImage: { value: boolean }
      36              :   backgroundRenderMode: { value: BackgroundRenderModeType }
      37              :   upDirection: { value: UpDirection }
      38              :   materialMode: { value: MaterialMode }
      39              :   needApplyChanges: { value: boolean }
      40              :   isPreview: { value: boolean }
      41              :   isStandaloneMode: { value: boolean }
      42              :   isSplatModel: { value: boolean }
      43              :   isPlyModel: { value: boolean }
      44              :   sourceFormat: { value: string | null }
      45              :   animations: { value: AnimationItem[] }
      46              :   playing: { value: boolean }
      47              :   selectedSpeed: { value: number }
      48              :   selectedAnimation: { value: number }
      49              :   animationProgress: { value: number }
      50              :   animationDuration: { value: number }
      51              : 
      52              :   initializeViewer: (containerRef: HTMLElement, source: Load3d) => Promise<void>
      53              :   initializeStandaloneViewer: (
      54              :     containerRef: HTMLElement,
      55              :     modelUrl: string
      56              :   ) => Promise<void>
      57              :   cleanup: () => void
      58              :   handleResize: () => void
      59              :   handleMouseEnter: () => void
      60              :   handleMouseLeave: () => void
      61              :   applyChanges: () => Promise<boolean>
      62              :   restoreInitialState: () => void
      63              :   refreshViewport: () => void
      64              :   exportModel: (format: string) => Promise<void>
      65              :   handleBackgroundImageUpdate: (file: File | null) => Promise<void>
      66              :   handleModelDrop: (file: File) => Promise<void>
      67              :   handleSeek: (progress: number) => void
      68              : }
      69              : 
      70              : // Cache for lazy-loaded modules
      71           24 : let cachedUseLoad3dViewer: UseLoad3dViewerFn | null = null
      72              : 
      73              : // Async loader for nodeToLoad3dMap - also caches for sync access
      74            2 : async function loadNodeToLoad3dMap(): Promise<Map<LGraphNode, Load3d>> {
      75            2 :   const cached = getNodeToLoad3dMapSync()
      76            2 :   if (cached) return cached
      77            2 :   const module = await import('@/extensions/core/load3d/composables/useLoad3d')
      78            2 :   cacheNodeToLoad3dMap(module.nodeToLoad3dMap)
      79            2 :   return module.nodeToLoad3dMap
      80              : }
      81              : 
      82            0 : async function loadUseLoad3dViewer() {
      83            0 :   if (!cachedUseLoad3dViewer) {
      84              :     const module =
      85              :       await import('@/extensions/core/load3d/composables/useLoad3dViewer')
      86            0 :     cachedUseLoad3dViewer = module.useLoad3dViewer
      87              :   }
      88            0 :   return cachedUseLoad3dViewer
      89              : }
      90              : 
      91              : // Type definitions for Load3D node
      92              : interface Load3DNode extends LGraphNode {
      93              :   syncLoad3dConfig?: () => void
      94              : }
      95              : 
      96           24 : const viewerInstances = new Map<NodeId, ReturnType<UseLoad3dViewerFn>>()
      97              : 
      98           24 : class Load3dService {
      99              :   private static instance: Load3dService | undefined
     100              : 
     101              :   private constructor() {}
     102              : 
     103              :   static getInstance(): Load3dService {
     104           19 :     if (!Load3dService.instance) {
     105            6 :       Load3dService.instance = new Load3dService()
     106              :     }
     107           19 :     return Load3dService.instance
     108              :   }
     109              : 
     110              :   /**
     111              :    * Get Load3d instance for a node (synchronous).
     112              :    * Returns null if the load3d module hasn't been loaded yet.
     113              :    */
     114              :   getLoad3d(node: LGraphNode): Load3d | null {
     115           12 :     const rawNode = toRaw(node)
     116           12 :     const map = getNodeToLoad3dMapSync()
     117           12 :     if (!map) return null
     118           12 :     return map.get(rawNode) || null
     119              :   }
     120              : 
     121              :   /**
     122              :    * Get Load3d instance for a node (async, loads module if needed).
     123              :    */
     124              :   async getLoad3dAsync(node: LGraphNode): Promise<Load3d | null> {
     125            2 :     const rawNode = toRaw(node)
     126              :     const map = await loadNodeToLoad3dMap()
     127            2 :     return map.get(rawNode) || null
     128              :   }
     129              : 
     130              :   clear() {
     131            0 :     const map = getNodeToLoad3dMapSync()
     132            0 :     if (!map) return
     133            0 :     for (const [node] of map) {
     134            0 :       removeLoad3d(node)
     135              :     }
     136              :   }
     137              : 
     138              :   /**
     139              :    * Get or create viewer (async, loads module if needed).
     140              :    * Use this for initial viewer creation.
     141              :    */
     142              :   async getOrCreateViewer(node: LGraphNode) {
     143            1 :     const nodeId = node.id
     144            1 :     if (!viewerInstances.has(nodeId)) {
     145            0 :       const useLoad3dViewer = await loadUseLoad3dViewer()
     146            0 :       viewerInstances.set(nodeId, useLoad3dViewer(node))
     147              :     }
     148              : 
     149            1 :     return viewerInstances.get(nodeId)
     150              :   }
     151              : 
     152              :   /**
     153              :    * Get or create viewer (sync version).
     154              :    * Only works after useLoad3dViewer has been loaded.
     155              :    * Returns null if module not yet loaded - use async version instead.
     156              :    */
     157              :   getOrCreateViewerSync<T extends UseLoad3dViewerFn>(
     158              :     node: LGraphNode,
     159              :     useLoad3dViewer: T
     160              :   ): ReturnType<T> {
     161            2 :     const nodeId = node.id
     162            2 :     if (!viewerInstances.has(nodeId)) {
     163            2 :       viewerInstances.set(nodeId, useLoad3dViewer(node))
     164              :     }
     165              : 
     166            2 :     return viewerInstances.get(nodeId) as ReturnType<T>
     167              :   }
     168              : 
     169              :   removeViewer(node: LGraphNode) {
     170            1 :     const nodeId = node.id
     171            1 :     const viewer = viewerInstances.get(nodeId)
     172              : 
     173            1 :     if (viewer) {
     174            1 :       viewer.cleanup()
     175              :     }
     176              : 
     177            1 :     viewerInstances.delete(nodeId)
     178              :   }
     179              : 
     180              :   async handleViewerClose(node: LGraphNode) {
     181            1 :     const viewer = await useLoad3dService().getOrCreateViewer(node)
     182            1 :     if (!viewer) return
     183              : 
     184            1 :     if (viewer.needApplyChanges.value) {
     185            0 :       await viewer.applyChanges()
     186              : 
     187              :       // Sync configuration back to the node's UI
     188            0 :       const load3DNode = node as Load3DNode
     189            0 :       if (load3DNode.syncLoad3dConfig) {
     190            0 :         load3DNode.syncLoad3dConfig()
     191              :       }
     192              :     }
     193              : 
     194            1 :     useLoad3dService().removeViewer(node)
     195              :   }
     196              : }
     197              : 
     198           24 : export const useLoad3dService = () => {
     199           19 :   return Load3dService.getInstance()
     200              : }
        

Generated by: LCOV version 2.0-1