plugin v1.0.1

assets/js/creations/state.js

@@ -1,7 +1,9 @@
 // js/state.js
 import { initializePatternState } from "./pattern/pattern_state.js";
-import { audioState, initializeAudioState } from "./audio/audio_state.js";
+import { audioState, initializeAudioState, getAudioSnapshot, applyAudioSnapshot } from "./audio/audio_state.js";
 import { DEFAULT_VOLUME, DEFAULT_PAN } from "./config.js";
+import { generateMmpFile } from "./file.js"; // Vamos usar uma adaptação disto ou criar um helper
+import { parseMmpContent } from "./file.js"; // Importante para restaurar o XML
 
 // Estado global da aplicação
 const globalState = {
@@ -25,21 +27,24 @@ const globalState = {
   clipboard: null,
   lastRulerClickTime: 0,
   justReset: false,
+  // Configs Globais que devem persistir
+  bpm: 140,
+  compassoA: 4,
+  compassoB: 4,
+  bars: 1,
+  syncMode: "global" // Adicionado para persistir a escolha
 };
 
-// --- ADICIONE ESTE BLOCO ---
-// Define o ESTADO INICIAL para o pattern module
 const patternState = {
   tracks: [],
   activeTrackId: null,
   activePatternIndex: 0,
 };
-// --- FIM DA ADIÇÃO ---
 
 // Combina todos os estados em um único objeto namespaced
 export let appState = {
   global: globalState,
-  pattern: patternState, // <-- AGORA 'patternState' está definido
+  pattern: patternState, 
   audio: audioState,
 };
 window.appState = appState;
@@ -47,7 +52,6 @@ window.appState = appState;
 export function resetProjectState() {
   console.log("Executando resetProjectState completo...");
 
-  // 1. Reseta o estado global para os padrões
   Object.assign(appState.global, {
     sliceToolActive: false,
     isPlaying: false,
@@ -71,61 +75,117 @@ export function resetProjectState() {
     justReset: false,
   });
 
-  // 2. Reseta o estado do pattern
   Object.assign(appState.pattern, {
     tracks: [],
     activeTrackId: null,
     activePatternIndex: 0,
   });
 
-  // 3. Reseta o estado de áudio (A PARTE QUE FALTAVA)
-  // Isso limpa appState.audio.clips e appState.audio.tracks
-  initializeAudioState(); //
+  initializeAudioState(); 
 }
 
+// --- NOVA IMPLEMENTAÇÃO DE PERSISTÊNCIA ---
+
+/**
+ * Helper: Gera a string XML do estado atual.
+ * Precisamos "emprestar" a lógica do file.js sem baixar o arquivo.
+ * A maneira mais limpa é importar generateXmlFromState de file.js,
+ * mas como ela não é exportada lá, vamos usar uma estratégia via DOM
+ * ou mover a lógica. Para simplificar sem quebrar o file.js,
+ * vamos salvar apenas o "essencial" do patternState se o XML falhar,
+ * mas o ideal é garantir que o XML seja gerado.
+ * * NOTA: Para que isso funcione perfeitamente, certifique-se de exportar 
+ * 'generateXmlFromState' no seu file.js ou usar a lógica abaixo.
+ */
+import { generateXmlFromStateExported } from "./file.js"; // Vamos assumir que você vai exportar isso no file.js
+
 export function saveStateToSession() {
+  // Só salva se estiver em uma sala (contexto colaborativo/online)
   if (!window.ROOM_NAME) return;
 
-  // 1. Crie uma versão "limpa" dos tracks, contendo APENAS dados
-  const cleanTracks = appState.pattern.tracks.map((track) => {
-    // Este novo objeto só contém dados que o JSON entende
-    return {
-      id: track.id,
-      name: track.name,
-      samplePath: track.samplePath,
-      patterns: track.patterns, // Isto é seguro (arrays de arrays/booleanos)
-      activePatternIndex: track.activePatternIndex,
-      volume: track.volume, // O número (0-1)
-      pan: track.pan, // O número (-1 to 1)
-      instrumentName: track.instrumentName,
-      instrumentXml: track.instrumentXml,
-      // *** OBJETOS TONE.JS EXCLUÍDOS ***:
-      // track.volumeNode, track.pannerNode, track.player
-    };
-  });
-
-  // 2. Construa o objeto de estado final para salvar
-  const stateToSave = {
-    pattern: {
-      ...appState.pattern, // Copia outras propriedades (ex: activeTrackId)
-      tracks: cleanTracks, // Usa a nossa versão limpa dos tracks
-    },
-    global: {
-      bpm: document.getElementById("bpm-input").value,
-      compassoA: document.getElementById("compasso-a-input").value,
-      compassoB: document.getElementById("compasso-b-input").value,
-      bars: document.getElementById("bars-input").value,
-    },
-  };
-
-  // 3. Agora o stringify vai funcionar
   try {
-    const roomName = window.ROOM_NAME || "default_room";
-    sessionStorage.setItem(
-      `temp_state_${roomName}`,
-      JSON.stringify(stateToSave)
-    );
+    // 1. Snapshot do Áudio (inclui blobs Base64 das gravações)
+    const audioSnap = getAudioSnapshot();
+
+    // 2. Snapshot do Pattern (XML)
+    // Se não conseguirmos o XML exato, salvamos os dados brutos do pattern
+    let xmlContent = null;
+    try {
+        // Tenta usar a função exportada (veja nota abaixo sobre file.js)
+        if(typeof generateXmlFromStateExported === 'function') {
+            xmlContent = generateXmlFromStateExported();
+        }
+    } catch(e) {
+        console.warn("Não foi possível gerar XML para backup:", e);
+    }
+
+    const stateToSave = {
+      timestamp: Date.now(),
+      xml: xmlContent, 
+      // Fallback: Salva o pattern bruto se o XML falhar
+      patternRaw: !xmlContent ? appState.pattern : null,
+      audio: audioSnap,
+      global: {
+        bpm: appState.global.bpm, // Pega do state, que deve estar syncado com o DOM
+        compassoA: appState.global.compassoA,
+        compassoB: appState.global.compassoB,
+        bars: appState.global.bars,
+        syncMode: appState.global.syncMode
+      }
+    };
+
+    const roomName = window.ROOM_NAME;
+    sessionStorage.setItem(`mmp_backup_${roomName}`, JSON.stringify(stateToSave));
+    // console.log("Estado salvo na sessão local (F5 safe).");
+
   } catch (e) {
-    console.error("Falha ao salvar estado na sessão:", e);
+    console.error("Falha crítica ao salvar sessão (Quota Excedida?):", e);
   }
 }
+
+export async function loadStateFromSession() {
+  const roomName = window.ROOM_NAME;
+  if (!roomName) return false;
+
+  try {
+    const raw = sessionStorage.getItem(`mmp_backup_${roomName}`);
+    if (!raw) return false;
+
+    const backup = JSON.parse(raw);
+    console.log(`[Session] Recuperando backup de ${new Date(backup.timestamp).toLocaleTimeString()}`);
+
+    // 1. Restaura Globais
+    if (backup.global) {
+        appState.global.bpm = backup.global.bpm;
+        appState.global.compassoA = backup.global.compassoA;
+        appState.global.compassoB = backup.global.compassoB;
+        appState.global.bars = backup.global.bars;
+        appState.global.syncMode = backup.global.syncMode || "global";
+        
+        // Atualiza DOM imediatamente para evitar desincronia visual
+        const bpmInput = document.getElementById("bpm-input");
+        if(bpmInput) bpmInput.value = backup.global.bpm;
+        // ... (outros inputs se necessário, mas o renderAll cuida da maioria)
+    }
+
+    // 2. Restaura Pattern (XML é preferível)
+    if (backup.xml) {
+       await parseMmpContent(backup.xml);
+    } else if (backup.patternRaw) {
+       // Fallback simples (menos robusto que XML)
+       console.warn("Restaurando de Pattern Raw (backup antigo/incompleto)");
+       Object.assign(appState.pattern, backup.patternRaw);
+    }
+
+    // 3. Restaura Áudio (Clipes + Gravações)
+    if (backup.audio) {
+       await applyAudioSnapshot(backup.audio);
+    }
+
+    return true; // Sucesso
+
+  } catch (e) {
+    console.error("Erro ao restaurar sessão:", e);
+    return false;
+  }
+}