@viji-dev/sdk 1.0.0 → 1.0.2

package/src/stores/scene-player/scene-session.store.ts

@@ -1,659 +0,0 @@
-import { create } from 'zustand';
-import { persist, createJSONStorage } from 'zustand/middleware';
-import { VijiCore } from '@viji-dev/core';
-import { useInputManagerStore } from './input-manager.store';
-
-// Core Instance Configuration  
-export interface CoreInstanceConfig {
-  resolution: number;
-  frameRateMode: 'full' | 'half';
-  allowUserInteraction: boolean;
-  audioStream?: MediaStream | null;
-  videoStream?: MediaStream | null;
-}
-
-// Scene Player Session
-export interface ScenePlayerSession {
-  // Core Identification
-  sceneId: string;
-  sceneTitle: string;
-  sceneThumbnail?: string;
-  sceneCode: string;
-  
-  // Author Information (for SDK, this might be local project info)
-  authorId: string;
-  authorUsername: string;
-  
-  // Core Configuration
-  coreConfig: CoreInstanceConfig;
-  coreInstance?: VijiCore;
-  
-  // Preview Instances (for parameter previews)
-  previewInstances: Map<string, VijiCore>;
-  
-  // Parameters
-  parameters: Record<string, any>;
-  parameterGroups: any[];
-  
-  // Presets (simplified for SDK - local only)
-  availablePresets: any[];
-  activePresetId?: string;
-  
-  // Session State
-  hasUnsavedChanges: boolean;
-  isActive: boolean;
-  createdAt: Date;
-  lastActiveAt: Date;
-}
-
-// Application Context Types
-export type AppContext = 'sdk';
-
-// Scene Session Store State
-interface SceneSessionState {
-  // SDK Session (single context for SDK)
-  session: ScenePlayerSession | null;
-  activeContext: AppContext | null;
-  
-  // UI Preferences
-  uiPreferences: {
-    showFPSCounter: boolean;
-  };
-  
-  // Persistent Parameters (survives session clearing)
-  persistentParameters: Record<string, Record<string, any>>; // sceneId -> parameters
-  
-  // Session Management
-  isSessionActive: boolean;
-  
-  // Core initialization control
-  initializationAbortController: AbortController | null;
-  
-  // Scene Management (for SDK, these are local projects)
-  availableScenes: any[]; // Local projects
-  isLoadingScenes: boolean;
-  isLoadingScene: boolean;
-  
-  // Core Management
-  isInitializingCore: boolean;
-  coreReady: boolean;
-  
-  // Preset Management (local only)
-  isLoadingPresets: boolean;
-  isSavingPreset: boolean;
-  
-  // Error Handling
-  lastError: string | null;
-  sceneError: string | null;
-  presetError: string | null;
-  
-  // Persistence state tracking
-  _hasHydrated: boolean;
-}
-
-// Scene Session Store Actions
-interface SceneSessionActions {
-  // Session Management
-  createSession: (sceneId: string, sceneCode?: string, sceneTitle?: string) => Promise<void>;
-  updateSession: (updates: Partial<ScenePlayerSession>) => void;
-  clearSession: () => Promise<void>;
-  switchToContext: () => void;
-  getSession: () => ScenePlayerSession | null;
-  
-  // Core Management
-  initializeCore: (container: HTMLElement) => Promise<void>;
-  destroyCore: () => Promise<void>;
-  cancelInitialization: () => void;
-  updateCoreConfig: (config: Partial<CoreInstanceConfig>) => Promise<void>;
-  
-  // Parameter Management
-  updateParameters: (parameters: Record<string, any>, persist?: boolean) => void;
-  resetParameters: () => void;
-  setParameterGroups: (groups: any[]) => void;
-  
-  // Preset Management (simplified for SDK)
-  loadPresets: (sceneId: string) => Promise<void>;
-  applyPreset: (presetId: string) => Promise<void>;
-  saveCurrentAsPreset: (name: string) => Promise<void>;
-  deletePreset: (presetId: string) => Promise<void>;
-  renamePreset: (presetId: string, newName: string) => Promise<void>;
-  
-  // Scene Management (local projects)
-  loadAvailableScenes: () => Promise<void>;
-  
-  // UI Preferences
-  setShowFPSCounter: (show: boolean) => void;
-  
-  // Error Handling
-  setLastError: (error: string | null) => void;
-  setSceneError: (error: string | null) => void;
-  setPresetError: (error: string | null) => void;
-  clearErrors: () => void;
-  
-  // Core Ready State
-  setCoreReady: (ready: boolean) => void;
-}
-
-// Combined Store Type
-type SceneSessionStore = SceneSessionState & SceneSessionActions;
-
-// Helper function to create default core config
-const createDefaultCoreConfig = (): CoreInstanceConfig => ({
-  resolution: 1.0,
-  frameRateMode: 'full',
-  allowUserInteraction: true,
-});
-
-// Initial State
-const initialState: SceneSessionState = {
-  session: null,
-  activeContext: null,
-  uiPreferences: {
-    showFPSCounter: false,
-  },
-  persistentParameters: {},
-  isSessionActive: false,
-  initializationAbortController: null,
-  availableScenes: [],
-  isLoadingScenes: false,
-  isLoadingScene: false,
-  isInitializingCore: false,
-  coreReady: false,
-  isLoadingPresets: false,
-  isSavingPreset: false,
-  lastError: null,
-  sceneError: null,
-  presetError: null,
-  _hasHydrated: false,
-};
-
-// Create Zustand Store with Persistence
-export const useSceneSessionStore = create<SceneSessionStore>()(
-  persist(
-    (set, get) => ({
-      // Initial State
-      ...initialState,
-      
-      // Session Management Actions
-      createSession: async (sceneId: string, sceneCode?: string, sceneTitle?: string) => {
-        try {
-          console.log(`🎬 [SDK STORE] Creating session for scene: ${sceneId}`);
-          set({ isLoadingScene: true, lastError: null, activeContext: 'sdk' });
-          
-          // For SDK, we create a session with provided or default values
-          const session: ScenePlayerSession = {
-            sceneId,
-            sceneTitle: sceneTitle || 'Untitled Scene',
-            sceneCode: sceneCode || '// SDK Scene Code\nconsole.log("Hello from Viji SDK");',
-            authorId: 'local',
-            authorUsername: 'SDK User',
-            coreConfig: createDefaultCoreConfig(),
-            previewInstances: new Map(),
-            parameters: get().persistentParameters[sceneId] || {},
-            parameterGroups: [],
-            availablePresets: [],
-            hasUnsavedChanges: false,
-            isActive: true,
-            createdAt: new Date(),
-            lastActiveAt: new Date(),
-          };
-          
-          set({
-            session,
-            isSessionActive: true,
-            isLoadingScene: false,
-          });
-          
-          console.log(`🎬 [SDK STORE] Session created successfully`);
-        } catch (error) {
-          console.error(`🎬 [SDK STORE] Failed to create session:`, error);
-          set({ 
-            lastError: error instanceof Error ? error.message : 'Failed to create session',
-            isLoadingScene: false 
-          });
-          throw error;
-        }
-      },
-      
-      updateSession: (updates: Partial<ScenePlayerSession>) => {
-        const currentSession = get().session;
-        if (!currentSession) return;
-        
-        const updatedSession = { ...currentSession, ...updates };
-        set({ session: updatedSession });
-      },
-      
-      clearSession: async () => {
-        const currentSession = get().session;
-        if (currentSession?.coreInstance) {
-          try {
-            console.log('🧹 Destroying VijiCore worker...');
-            await currentSession.coreInstance.destroy();
-            console.log('✅ VijiCore worker destroyed successfully');
-          } catch (error) {
-            console.error('❌ Error destroying VijiCore worker:', error);
-          }
-        }
-        
-        set({
-          session: null,
-          isSessionActive: false,
-          coreReady: false,
-        });
-      },
-      
-      switchToContext: () => {
-        set({ activeContext: 'sdk' });
-      },
-      
-      getSession: () => get().session,
-      
-      // Core Management Actions
-      initializeCore: async (container: HTMLElement) => {
-        const session = get().session;
-        if (!session) throw new Error('No active session');
-        
-        // Prevent multiple simultaneous initializations
-        if (get().isInitializingCore) {
-          console.log('⚠️ [SDK STORE] Core initialization already in progress, skipping...');
-          return;
-        }
-        
-        try {
-          set({ isInitializingCore: true, sceneError: null });
-          
-          // Cancel any existing initialization
-          if (get().initializationAbortController) {
-            get().initializationAbortController!.abort();
-          }
-          
-          const abortController = new AbortController();
-          set({ initializationAbortController: abortController });
-          
-          console.log('🚀 [SDK STORE] Initializing Viji Core...');
-          
-          // Create Core instance
-          const coreInstance = new VijiCore({
-            hostContainer: container,
-            sceneCode: session.sceneCode, // Scene code is at session level
-            frameRateMode: session.coreConfig.frameRateMode,
-            allowUserInteraction: session.coreConfig.allowUserInteraction,
-            audioStream: undefined, // Will be set by input manager
-            videoStream: undefined, // Will be set by input manager
-          });
-          
-          // Set up parameter detection
-          coreInstance.onParametersDefined((groups: any[]) => {
-            console.log('📊 [SDK STORE] Parameters detected:', groups);
-            get().setParameterGroups(groups);
-          });
-          
-          // Set up capabilities change listener
-          if (coreInstance.onCapabilitiesChange) {
-            coreInstance.onCapabilitiesChange((capabilities: any) => {
-              console.log('🔧 [SDK STORE] Capabilities changed:', capabilities);
-              if (coreInstance && coreInstance.parametersReady) {
-                get().setParameterGroups(coreInstance.getParameterGroups?.() || []);
-              }
-            });
-          }
-          
-          // Check for cancellation before initialization
-          if (abortController.signal.aborted) {
-            await coreInstance.destroy();
-            return;
-          }
-          
-          // Initialize core
-          await coreInstance.initialize();
-          
-          // Update session with core instance
-          get().updateSession({ coreInstance });
-          
-          // Re-apply current input streams and interaction state from InputManager to preserve across scenes
-          try {
-            const ims = useInputManagerStore.getState();
-            const streams = await ims.updateStreamsForCore();
-            await get().updateCoreConfig({
-              audioStream: streams.audioStream,
-              videoStream: streams.videoStream,
-              allowUserInteraction: ims.inputConfiguration.interactionEnabled,
-            });
-          } catch (e) {
-            console.warn('⚠️ [SDK STORE] Failed to re-apply input streams to new core:', e);
-          }
-
-          set({ 
-            coreReady: true,
-            isInitializingCore: false,
-            initializationAbortController: null 
-          });
-          
-          console.log('✅ [SDK STORE] Viji Core initialized successfully');
-          
-        } catch (error) {
-          console.error('❌ [SDK STORE] Failed to initialize core:', error);
-          const errorMessage = error instanceof Error ? error.message : 'Failed to initialize core';
-          set({ 
-            sceneError: errorMessage,
-            isInitializingCore: false,
-            initializationAbortController: null 
-          });
-          throw error;
-        }
-      },
-      
-      destroyCore: async () => {
-        const session = get().session;
-        if (session?.coreInstance) {
-          try {
-            await session.coreInstance.destroy();
-            get().updateSession({ coreInstance: undefined });
-            set({ coreReady: false });
-            console.log('🧹 [SDK STORE] Core destroyed');
-          } catch (error) {
-            console.error('Error destroying core:', error);
-          }
-        }
-      },
-      
-      cancelInitialization: () => {
-        const abortController = get().initializationAbortController;
-        if (abortController) {
-          abortController.abort();
-          set({ initializationAbortController: null, isInitializingCore: false });
-        }
-      },
-      
-      updateCoreConfig: async (config: Partial<CoreInstanceConfig>) => {
-        console.log(`🎯 [SDK STORE] updateCoreConfig called:`, {
-          configKeys: Object.keys(config),
-          hasAudioStream: 'audioStream' in config,
-          hasVideoStream: 'videoStream' in config,
-          timestamp: new Date().toISOString()
-        });
-        
-        const session = get().session;
-        if (!session) {
-          console.log(`❌ [SDK STORE] No session available, skipping updateCoreConfig`);
-          return;
-        }
-        
-        const updatedConfig = { ...session.coreConfig, ...config };
-        get().updateSession({ coreConfig: updatedConfig });
-        
-        // Apply config to core instance if available
-        if (session.coreInstance) {
-          console.log(`🎯 [SDK STORE] Applying config to core instance...`);
-          
-          if (config.frameRateMode) {
-            if (config.frameRateMode === 'full') {
-              await session.coreInstance.setFullFrameRate();
-            } else {
-              await session.coreInstance.setHalfFrameRate();
-            }
-          }
-          
-          if (config.resolution !== undefined) {
-            await session.coreInstance.setResolution(config.resolution);
-          }
-          
-          if (config.allowUserInteraction !== undefined) {
-            await session.coreInstance.setInteractionEnabled(config.allowUserInteraction);
-          }
-          
-          if ('audioStream' in config) {
-            console.log(`🎵 [SDK STORE] Setting audio stream on core:`, {
-              streamExists: !!config.audioStream,
-              streamId: config.audioStream?.id
-            });
-            await session.coreInstance.setAudioStream(config.audioStream ?? null);
-          }
-          
-          if ('videoStream' in config) {
-            console.log(`📹 [SDK STORE] Setting video stream on core:`, {
-              streamExists: !!config.videoStream,
-              streamId: config.videoStream?.id
-            });
-            
-            try {
-              await session.coreInstance.setVideoStream(config.videoStream ?? null);
-            } catch (error) {
-              console.error(`❌ [SDK STORE] Failed to set video stream:`, error);
-              // Don't throw to prevent breaking the entire config update
-            }
-          }
-          
-          console.log(`✅ [SDK STORE] All core config updates completed`);
-        } else {
-          console.log(`⚠️ [SDK STORE] No core instance available, config stored but not applied`);
-        }
-      },
-      
-      // Parameter Management Actions
-      updateParameters: (parameters: Record<string, any>, persist = false) => {
-        const session = get().session;
-        if (!session) return;
-        
-        const updatedParameters = { ...session.parameters, ...parameters };
-        get().updateSession({ parameters: updatedParameters });
-        
-        // Apply parameters to core instance
-        if (session.coreInstance) {
-          Object.entries(parameters).forEach(([name, value]) => {
-            try {
-              session.coreInstance!.setParameter(name, value);
-            } catch (error) {
-              console.warn(`Failed to set parameter ${name}:`, error);
-            }
-          });
-        }
-        
-        // Persist parameters if requested
-        if (persist && session.sceneId) {
-          const { persistentParameters } = get();
-          set({
-            persistentParameters: {
-              ...persistentParameters,
-              [session.sceneId]: updatedParameters,
-            },
-          });
-        }
-      },
-      
-      resetParameters: () => {
-        const session = get().session;
-        if (!session) return;
-        
-        get().updateSession({ parameters: {} });
-        
-        // Clear persistent parameters for this scene
-        if (session.sceneId) {
-          const { persistentParameters } = get();
-          const { [session.sceneId]: _, ...remaining } = persistentParameters;
-          set({ persistentParameters: remaining });
-        }
-      },
-      
-      setParameterGroups: (parameterGroups: any[]) => {
-        get().updateSession({ parameterGroups });
-      },
-      
-      // Preset Management (simplified for SDK - local storage only)
-      loadPresets: async (sceneId: string) => {
-        set({ isLoadingPresets: true, presetError: null });
-        
-        try {
-          // For SDK, presets are stored locally
-          const localPresets = localStorage.getItem(`viji-sdk-presets-${sceneId}`);
-          const presets = localPresets ? JSON.parse(localPresets) : [];
-          
-          get().updateSession({ availablePresets: presets });
-          
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : 'Failed to load presets';
-          set({ presetError: errorMessage });
-        } finally {
-          set({ isLoadingPresets: false });
-        }
-      },
-      
-      applyPreset: async (presetId: string) => {
-        const session = get().session;
-        if (!session) return;
-        
-        const preset = session.availablePresets.find(p => p.id === presetId);
-        if (!preset) {
-          set({ presetError: 'Preset not found' });
-          return;
-        }
-        
-        // Apply preset parameters
-        get().updateParameters(preset.parameters, true);
-        get().updateSession({ activePresetId: presetId });
-      },
-      
-      saveCurrentAsPreset: async (name: string) => {
-        const session = get().session;
-        if (!session) return;
-        
-        set({ isSavingPreset: true, presetError: null });
-        
-        try {
-          const preset = {
-            id: crypto.randomUUID(),
-            name,
-            parameters: session.parameters,
-            createdAt: new Date().toISOString(),
-          };
-          
-          const updatedPresets = [...session.availablePresets, preset];
-          
-          // Save to local storage
-          localStorage.setItem(`viji-sdk-presets-${session.sceneId}`, JSON.stringify(updatedPresets));
-          
-          get().updateSession({ availablePresets: updatedPresets });
-          
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : 'Failed to save preset';
-          set({ presetError: errorMessage });
-        } finally {
-          set({ isSavingPreset: false });
-        }
-      },
-      
-      deletePreset: async (presetId: string) => {
-        const session = get().session;
-        if (!session) return;
-        
-        try {
-          const updatedPresets = session.availablePresets.filter(p => p.id !== presetId);
-          
-          // Save to local storage
-          localStorage.setItem(`viji-sdk-presets-${session.sceneId}`, JSON.stringify(updatedPresets));
-          
-          get().updateSession({ availablePresets: updatedPresets });
-          
-          // Clear active preset if it was deleted
-          if (session.activePresetId === presetId) {
-            get().updateSession({ activePresetId: undefined });
-          }
-          
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : 'Failed to delete preset';
-          set({ presetError: errorMessage });
-        }
-      },
-      
-      renamePreset: async (presetId: string, newName: string) => {
-        const session = get().session;
-        if (!session) return;
-        
-        try {
-          const updatedPresets = session.availablePresets.map(p => 
-            p.id === presetId ? { ...p, name: newName } : p
-          );
-          
-          // Save to local storage
-          localStorage.setItem(`viji-sdk-presets-${session.sceneId}`, JSON.stringify(updatedPresets));
-          
-          get().updateSession({ availablePresets: updatedPresets });
-          
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : 'Failed to rename preset';
-          set({ presetError: errorMessage });
-        }
-      },
-      
-      // Scene Management (local projects for SDK)
-      loadAvailableScenes: async () => {
-        set({ isLoadingScenes: true });
-        
-        try {
-          // For SDK, scenes are local projects
-          // This would be implemented by the CLI/project management system
-          const localProjects = []; // TODO: Implement project discovery
-          
-          set({ availableScenes: localProjects });
-          
-        } catch (error) {
-          console.error('Failed to load available scenes:', error);
-        } finally {
-          set({ isLoadingScenes: false });
-        }
-      },
-      
-      // UI Preferences
-      setShowFPSCounter: (showFPSCounter: boolean) => {
-        const { uiPreferences } = get();
-        set({
-          uiPreferences: {
-            ...uiPreferences,
-            showFPSCounter,
-          },
-        });
-      },
-      
-      // Error Handling
-      setLastError: (lastError: string | null) => {
-        set({ lastError });
-      },
-      
-      setSceneError: (sceneError: string | null) => {
-        set({ sceneError });
-      },
-      
-      setPresetError: (presetError: string | null) => {
-        set({ presetError });
-      },
-      
-      clearErrors: () => {
-        set({
-          lastError: null,
-          sceneError: null,
-          presetError: null,
-        });
-      },
-      
-      // Core Ready State
-      setCoreReady: (coreReady: boolean) => {
-        set({ coreReady });
-      },
-    }),
-    {
-      name: 'viji-sdk-scene-session',
-      storage: createJSONStorage(() => localStorage),
-      // Don't persist core instances, abort controllers, or temporary state
-      partialize: (state) => ({
-        uiPreferences: state.uiPreferences,
-        persistentParameters: state.persistentParameters,
-        _hasHydrated: true, // Mark as hydrated
-      }),
-      onRehydrateStorage: () => (state) => {
-        if (state) {
-          state._hasHydrated = true;
-        }
-      },
-    }
-  )
-);