threedviewer 2.3.0 → 2.4.0

package/dist/core/ViewerCore.d.ts

@@ -1,5 +1,4 @@
 import { IRenderer, IRendererOptions, IScene, IModelLoader, ICamera, IControls, IObject3D, Result } from './interfaces';
-import { ViewerState } from './entities/ViewerState';
 import { TypedEventEmitter } from '../events/EventEmitter';
 import { ViewerEventMap } from './events/ViewerEvents';
 import { SimpleViewerOptions } from '../types/SimpleViewerOptions';
@@ -7,6 +6,7 @@ import { IPathTracingService } from './services/IPathTracingService';
 import { IEnvironmentService } from './services/IEnvironmentService';
 import { ISceneSetupService } from './services/ISceneSetupService';
 import { IFloorAlignmentService } from './services/IFloorAlignmentService';
+import { ViewerState } from './entities/ViewerState';
 export interface ViewerDependencies {
     renderer: IRenderer;
     scene: IScene;
@@ -25,31 +25,26 @@ export interface ViewerDependencies {
  * Independent of UI framework and rendering engine
  */
 export declare class ViewerCore {
-    private state;
     private readonly events;
     private readonly renderLoopManager;
     private lastFrameTime;
     private frameCount;
-    private stateChangeCallback?;
     private pathTracingStartTime?;
-    private screenshotElement;
-    private isShowingScreenshot;
-    private screenshotResizeHandler?;
-    private serializedSceneState?;
-    private lastModelUrl?;
     private pathTracingCompleteHandled;
     private disposed;
+    private readonly stateManager;
+    private readonly screenshotManager;
+    private readonly modelManager;
+    private readonly resourceManager;
     private readonly renderer;
     private readonly scene;
     private readonly camera;
     private readonly controls;
-    private readonly modelLoader;
     private readonly options;
     private readonly rendererOptions?;
     private readonly sceneSetupService?;
     private environmentService?;
     private pathTracingService?;
-    private readonly floorAlignmentService?;
     constructor(dependencies: ViewerDependencies);
     /**
      * Initialize the viewer
@@ -99,14 +94,6 @@ export declare class ViewerCore {
      * Restore the 3D scene from screenshot
      */
     private restoreFromScreenshot;
-    /**
-     * Dispose scene resources while keeping the screenshot
-     */
-    private disposeSceneResources;
-    /**
-     * Recursively dispose of an object and its children
-     */
-    private disposeObject;
     /**
      * Dispose of all resources
      */

package/dist/core/managers/ModelManager.d.ts

@@ -0,0 +1,53 @@
+import { IModelLoader, IObject3D, IScene, ICamera, IControls, Result } from '../interfaces';
+import { IFloorAlignmentService } from '../services/IFloorAlignmentService';
+import { ISceneSetupService } from '../services/ISceneSetupService';
+import { TypedEventEmitter } from '../../events/EventEmitter';
+import { ViewerEventMap } from '../events/ViewerEvents';
+export interface ModelManagerDependencies {
+    modelLoader: IModelLoader;
+    scene: IScene;
+    camera: ICamera;
+    controls: IControls;
+    floorAlignmentService?: IFloorAlignmentService;
+    sceneSetupService?: ISceneSetupService;
+    autoFitToObject?: boolean;
+}
+/**
+ * Manages model loading, disposal, and scene setup
+ */
+export declare class ModelManager {
+    private currentModel;
+    private lastModelUrl?;
+    private readonly modelLoader;
+    private readonly scene;
+    private readonly camera;
+    private readonly controls;
+    private readonly floorAlignmentService?;
+    private readonly sceneSetupService?;
+    private readonly autoFitToObject;
+    constructor(dependencies: ModelManagerDependencies);
+    /**
+     * Get current model
+     */
+    getCurrentModel(): IObject3D | null;
+    /**
+     * Get last loaded model URL
+     */
+    getLastModelUrl(): string | undefined;
+    /**
+     * Load a 3D model
+     */
+    loadModel(source: string | IObject3D, events: TypedEventEmitter<ViewerEventMap>): Promise<Result<IObject3D>>;
+    /**
+     * Dispose current model
+     */
+    disposeCurrentModel(): void;
+    /**
+     * Recursively dispose of an object and its children
+     */
+    private disposeObject;
+    /**
+     * Dispose all resources
+     */
+    dispose(): void;
+}

package/dist/core/managers/ResourceManager.d.ts

@@ -0,0 +1,40 @@
+import { IScene } from '../interfaces';
+import { IPathTracingService } from '../services/IPathTracingService';
+import { IEnvironmentService } from '../services/IEnvironmentService';
+export interface ResourceManagerDependencies {
+    scene: IScene;
+    pathTracingService?: IPathTracingService;
+    environmentService?: IEnvironmentService;
+}
+/**
+ * Manages resource disposal and cleanup
+ */
+export declare class ResourceManager {
+    private readonly scene;
+    private pathTracingService?;
+    private environmentService?;
+    constructor(dependencies: ResourceManagerDependencies);
+    /**
+     * Update services (needed after screenshot restoration)
+     */
+    updateServices(services: {
+        pathTracingService?: IPathTracingService;
+        environmentService?: IEnvironmentService;
+    }): void;
+    /**
+     * Dispose scene resources (for screenshot mode)
+     */
+    disposeSceneResources(preservePathTracing?: boolean): void;
+    /**
+     * Dispose all services
+     */
+    disposeServices(): void;
+    /**
+     * Complete disposal of all resources
+     */
+    dispose(): void;
+    /**
+     * Trigger garbage collection hint
+     */
+    private triggerGarbageCollection;
+}

package/dist/core/managers/ScreenshotManager.d.ts

@@ -0,0 +1,38 @@
+import { IRenderer, ICamera, IControls } from '../interfaces';
+import { SerializedSceneState } from '../utils/SceneSerializer';
+export interface ScreenshotManagerDependencies {
+    renderer: IRenderer;
+    onRestore?: () => Promise<void>;
+}
+/**
+ * Manages screenshot capture and restoration functionality
+ */
+export declare class ScreenshotManager {
+    private screenshotElement;
+    private isShowingScreenshot;
+    private screenshotResizeHandler?;
+    private serializedSceneState?;
+    private readonly renderer;
+    private readonly onRestore?;
+    constructor(dependencies: ScreenshotManagerDependencies);
+    /**
+     * Check if currently showing a screenshot
+     */
+    isActive(): boolean;
+    /**
+     * Capture current frame and replace canvas with screenshot
+     */
+    captureAndReplace(camera: ICamera, controls: IControls, lastModelUrl?: string, onResourcesDisposed?: () => void): void;
+    /**
+     * Restore the 3D scene from screenshot
+     */
+    restore(): Promise<void>;
+    /**
+     * Get serialized scene state for restoration
+     */
+    getSerializedState(): SerializedSceneState | undefined;
+    /**
+     * Clean up resources
+     */
+    dispose(): void;
+}

package/dist/core/managers/StateManager.d.ts

@@ -0,0 +1,78 @@
+import { ViewerState } from '../entities/ViewerState';
+import { ThreeViewerError } from '../../errors';
+import { IObject3D } from '../interfaces';
+export interface StateChangeCallback {
+    (state: ViewerState): void;
+}
+/**
+ * Manages viewer state transitions and notifications
+ */
+export declare class StateManager {
+    private state;
+    private readonly stateChangeCallbacks;
+    constructor();
+    /**
+     * Get current state
+     */
+    getState(): ViewerState;
+    /**
+     * Set initialized state
+     */
+    setInitialized(): void;
+    /**
+     * Start loading state
+     */
+    startLoading(): void;
+    /**
+     * Set loaded state with model
+     */
+    setLoaded(model: IObject3D): void;
+    /**
+     * Set error state
+     */
+    setError(error: ThreeViewerError): void;
+    /**
+     * Start rendering state
+     */
+    startRendering(): void;
+    /**
+     * Update render info
+     */
+    updateRenderInfo(info: {
+        frameCount: number;
+        fps: number;
+        lastRenderTime: number;
+    }): void;
+    /**
+     * Set disposed state
+     */
+    setDisposed(): void;
+    /**
+     * Check if can load model in current state
+     */
+    canLoad(): boolean;
+    /**
+     * Check if viewer is initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Get current status
+     */
+    getStatus(): 'idle' | 'loading' | 'loaded' | 'rendering' | 'error' | 'disposed';
+    /**
+     * Get current model
+     */
+    getCurrentModel(): IObject3D | null;
+    /**
+     * Subscribe to state changes
+     */
+    onStateChange(callback: StateChangeCallback): () => void;
+    /**
+     * Clear all callbacks
+     */
+    clearCallbacks(): void;
+    /**
+     * Update state and notify listeners
+     */
+    private updateState;
+}

package/dist/core/managers/index.d.ts

@@ -0,0 +1,4 @@
+export { StateManager } from './StateManager';
+export { ScreenshotManager } from './ScreenshotManager';
+export { ModelManager } from './ModelManager';
+export { ResourceManager } from './ResourceManager';