kingkont 0.7.39 → 0.7.41

package/renderer/state.js

@@ -0,0 +1,566 @@
+// renderer/state.js — IndexedDB + File System Access helpers, scene.json IO, app state, history (undo/redo)
+//
+// Этот модуль был выделен из index.html (раньше всё было в одном <script>
+// блоке на 9123 строки). Все модули загружаются как plain <script>
+// в одном глобальном scope — поэтому функции/переменные между файлами
+// видят друг друга по именам, без import/export. Порядок загрузки
+// важен: см. <script> теги внизу index.html.
+
+// =================== IndexedDB (хэндл папки фильма) ===================
+const DB_NAME = 'video-editor';
+const STORE = 'handles';
+
+function openDB() {
+  return new Promise((resolve, reject) => {
+    const req = indexedDB.open(DB_NAME, 1);
+    req.onupgradeneeded = () => req.result.createObjectStore(STORE);
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+async function idbGet(key) {
+  const db = await openDB();
+  return new Promise((resolve, reject) => {
+    const r = db.transaction(STORE, 'readonly').objectStore(STORE).get(key);
+    r.onsuccess = () => resolve(r.result);
+    r.onerror = () => reject(r.error);
+  });
+}
+async function idbSet(key, value) {
+  const db = await openDB();
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(STORE, 'readwrite');
+    tx.objectStore(STORE).put(value, key);
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+  });
+}
+
+// =================== File system helpers ===================
+async function verifyPermission(handle, mode = 'readwrite') {
+  const opts = { mode };
+  if ((await handle.queryPermission(opts)) === 'granted') return true;
+  if ((await handle.requestPermission(opts)) === 'granted') return true;
+  return false;
+}
+
+const CHAR_DIR = '_characters';
+const LOC_DIR = '_locations';
+
+async function listEpisodes(filmHandle) {
+  const folders = [];
+  for await (const [name, h] of filmHandle.entries()) {
+    if (h.kind === 'directory' && !name.startsWith('_') && !name.startsWith('.')) {
+      folders.push({ name, handle: h });
+    }
+  }
+  folders.sort((a, b) => a.name.localeCompare(b.name, 'ru'));
+  return folders;
+}
+
+async function listCharacters(filmHandle) {
+  try {
+    const root = await filmHandle.getDirectoryHandle(CHAR_DIR);
+    const folders = [];
+    for await (const [name, h] of root.entries()) {
+      if (h.kind === 'directory') folders.push({ name, handle: h });
+    }
+    folders.sort((a, b) => a.name.localeCompare(b.name, 'ru'));
+    return folders;
+  } catch { return []; }
+}
+
+async function listLocations(filmHandle) {
+  try {
+    const root = await filmHandle.getDirectoryHandle(LOC_DIR);
+    const folders = [];
+    for await (const [name, h] of root.entries()) {
+      if (h.kind === 'directory') folders.push({ name, handle: h });
+    }
+    folders.sort((a, b) => a.name.localeCompare(b.name, 'ru'));
+    return folders;
+  } catch { return []; }
+}
+
+async function fileExists(handle, name) {
+  try { await handle.getFileHandle(name); return true; } catch { return false; }
+}
+
+async function uniqueName(handle, name) {
+  if (!(await fileExists(handle, name))) return name;
+  const dot = name.lastIndexOf('.');
+  const base = dot > 0 ? name.slice(0, dot) : name;
+  const ext  = dot > 0 ? name.slice(dot) : '';
+  let i = 1;
+  while (await fileExists(handle, `${base}_${i}${ext}`)) i++;
+  return `${base}_${i}${ext}`;
+}
+
+async function writeFile(dirHandle, name, data) {
+  const fh = await dirHandle.getFileHandle(name, { create: true });
+  const w = await fh.createWritable();
+  await w.write(data);
+  await w.close();
+}
+
+async function importFile(dirHandle, file) {
+  const name = await uniqueName(dirHandle, file.name);
+  await writeFile(dirHandle, name, file);
+  return name;
+}
+
+// =================== Раскладка по подпапкам внутри доски ===================
+// clips/ — видео, frames/ — картинки, audio/ — звуки, texts/ — .md
+function boardSubdirForType(type) {
+  if (type === 'video') return 'clips';
+  if (type === 'image') return 'frames';
+  if (type === 'audio') return 'audio';
+  if (type === 'text')  return 'texts';
+  return null;
+}
+
+const BOARD_SUBDIRS = ['clips', 'frames', 'audio', 'texts'];
+
+async function getOrCreateBoardSubdir(boardHandle, name) {
+  return await boardHandle.getDirectoryHandle(name, { create: true });
+}
+
+// Получить FileHandle по relPath (поддерживает 'clips/x.mp4', легаси 'x.mp4' и устаревшие пути)
+async function resolveBoardFile(boardHandle, relPath) {
+  if (!relPath) throw new Error('empty path');
+  const tryDirect = async (h, p) => {
+    const parts = p.split('/');
+    let cur = h;
+    for (let i = 0; i < parts.length - 1; i++) {
+      cur = await cur.getDirectoryHandle(parts[i]);
+    }
+    return cur.getFileHandle(parts[parts.length - 1]);
+  };
+  if (relPath.includes('/')) {
+    try { return await tryDirect(boardHandle, relPath); } catch {}
+  }
+  // Фоллбэк по basename: пробуем рут, затем известные подпапки
+  const bare = relPath.split('/').pop();
+  try { return await boardHandle.getFileHandle(bare); } catch {}
+  for (const sub of BOARD_SUBDIRS) {
+    try {
+      const h = await boardHandle.getDirectoryHandle(sub);
+      return await h.getFileHandle(bare);
+    } catch {}
+  }
+  throw new Error(`Файл не найден: ${relPath}`);
+}
+
+// Записать файл по relPath (создаёт папки)
+async function writeBoardFile(boardHandle, relPath, data) {
+  const parts = relPath.split('/');
+  let h = boardHandle;
+  for (let i = 0; i < parts.length - 1; i++) {
+    h = await h.getDirectoryHandle(parts[i], { create: true });
+  }
+  const fh = await h.getFileHandle(parts[parts.length - 1], { create: true });
+  const w = await fh.createWritable();
+  await w.write(data);
+  await w.close();
+}
+
+// Уникальное имя в подпапке (или в руте если subdir==null)
+async function uniqueBoardFilename(boardHandle, subdir, name) {
+  const dir = subdir ? await getOrCreateBoardSubdir(boardHandle, subdir) : boardHandle;
+  return await uniqueName(dir, name);
+}
+
+// Импорт File-объекта в типовую подпапку, возвращает relPath
+async function importToBoard(boardHandle, file, type) {
+  const sub = boardSubdirForType(type);
+  if (!sub) {
+    const n = await uniqueName(boardHandle, file.name);
+    await writeFile(boardHandle, n, file);
+    return n;
+  }
+  const dir = await getOrCreateBoardSubdir(boardHandle, sub);
+  const n = await uniqueName(dir, file.name);
+  await writeFile(dir, n, file);
+  return `${sub}/${n}`;
+}
+
+// Удалить файл по relPath (используется в deleteNode)
+async function removeBoardFile(boardHandle, relPath) {
+  if (relPath.includes('/')) {
+    const parts = relPath.split('/');
+    let h = boardHandle;
+    for (let i = 0; i < parts.length - 1; i++) {
+      h = await h.getDirectoryHandle(parts[i]);
+    }
+    await h.removeEntry(parts[parts.length - 1]);
+  } else {
+    // легаси: пробуем рут, затем подпапки
+    try { await boardHandle.removeEntry(relPath); return; } catch {}
+    for (const sub of BOARD_SUBDIRS) {
+      try {
+        const h = await boardHandle.getDirectoryHandle(sub);
+        await h.removeEntry(relPath);
+        return;
+      } catch {}
+    }
+    throw new Error(`Файл не найден для удаления: ${relPath}`);
+  }
+}
+
+// Чтение бинаря/текста файла по relPath
+async function readBoardFile(boardHandle, relPath) {
+  const fh = await resolveBoardFile(boardHandle, relPath);
+  return await fh.getFile();
+}
+
+function defaultNameForFile(filename) {
+  const dot = filename.lastIndexOf('.');
+  return dot > 0 ? filename.slice(0, dot) : filename;
+}
+
+function uniqueNodeName(nodes, base) {
+  if (!nodes.some(n => n.name === base)) return base;
+  let i = 2;
+  while (nodes.some(n => n.name === `${base}-${i}`)) i++;
+  return `${base}-${i}`;
+}
+
+function slugifyPrompt(prompt, maxWords = 4) {
+  if (!prompt) return '';
+  return prompt
+    .toLowerCase()
+    .replace(/[.,!?;:'"«»()\[\]{}<>\/\\@#%^&*=+|`~]/g, '')
+    .split(/\s+/)
+    .filter(Boolean)
+    .slice(0, maxWords)
+    .join('-')
+    .slice(0, 48);
+}
+
+async function loadBoardMetadata(boardHandle) {
+  let migrated = false;
+  let nodes = [];
+  let connections = [];
+  let legacyEditor = false;
+
+  let view = null;
+  let character = null;
+  let location = null;
+  let timeline = null;
+  let history = null;
+  // 1) Пробуем scene.json
+  try {
+    const fh = await boardHandle.getFileHandle('scene.json');
+    const data = JSON.parse(await (await fh.getFile()).text());
+    nodes = Array.isArray(data.nodes) ? data.nodes : [];
+    connections = Array.isArray(data.connections) ? data.connections : [];
+    view = data.view || null;
+    character = data.character || null;
+    location = data.location || null;
+    timeline = data.timeline || null;
+    history = data.history || null;
+  } catch {
+    // 2) Легаси: .editor.json
+    try {
+      const fh = await boardHandle.getFileHandle('.editor.json');
+      const data = JSON.parse(await (await fh.getFile()).text());
+      nodes = Array.isArray(data.nodes) ? data.nodes : [];
+      connections = Array.isArray(data.connections) ? data.connections : [];
+      view = data.view || null;
+      character = data.character || null;
+      location = data.location || null;
+      timeline = data.timeline || null;
+      legacyEditor = true;
+      migrated = true;
+    } catch {}
+  }
+
+  // Миграция/загрузка текстовых нод из .md
+  for (const n of nodes) {
+    if (n.type !== 'text') continue;
+    if (n.file) {
+      try {
+        const fh = await resolveBoardFile(boardHandle, n.file);
+        n.text = await (await fh.getFile()).text();
+      } catch { n.text = ''; }
+    } else {
+      // Легаси: текст инлайном — переезжает в .md в texts/
+      const dir = await getOrCreateBoardSubdir(boardHandle, 'texts');
+      const baseName = await uniqueName(dir, (n.name || 'text') + '.md');
+      await writeFile(dir, baseName, n.text || '');
+      n.file = `texts/${baseName}`;
+      migrated = true;
+    }
+  }
+
+  // Удалить старый .editor.json после успешной миграции в scene.json
+  if (legacyEditor) {
+    try { await boardHandle.removeEntry('.editor.json'); } catch {}
+  }
+
+  return { nodes, connections, view, character, location, timeline, history, _migrated: migrated };
+}
+
+async function saveBoardMetadata(boardHandle, meta) {
+  for (const n of meta.nodes) {
+    if (n.type === 'text' && n.file) {
+      try { await writeBoardFile(boardHandle, n.file, n.text || ''); }
+      catch (e) { console.error('save .md failed', n.file, e); }
+    }
+  }
+  const nodesForJson = meta.nodes.map(n => {
+    const out = { ...n };
+    delete out.text;
+    return out;
+  });
+  const payload = {
+    nodes: nodesForJson,
+    connections: meta.connections || [],
+    view: meta.view || null,
+    character: meta.character || null,
+    location: meta.location || null,
+    timeline: meta.timeline || null,
+    history: meta.history && (meta.history.past?.length || meta.history.future?.length)
+      ? meta.history : null,
+  };
+  await writeFile(boardHandle, 'scene.json', JSON.stringify(payload, null, 2));
+}
+
+function getFileType(file) {
+  const ext = (file.name.split('.').pop() || '').toLowerCase();
+  if (['md','markdown'].includes(ext)) return 'text';
+  if (file.type.startsWith('video/')) return 'video';
+  if (file.type.startsWith('audio/')) return 'audio';
+  if (file.type.startsWith('image/')) return 'image';
+  if (['mp4','mov','webm','mkv','avi','m4v'].includes(ext)) return 'video';
+  if (['mp3','wav','ogg','oga','m4a','flac','aac'].includes(ext)) return 'audio';
+  if (['png','jpg','jpeg','gif','webp','bmp','svg','heic','avif'].includes(ext)) return 'image';
+  return null;
+}
+
+// =================== State ===================
+const state = {
+  filmHandle: null,
+  currentBoard: null,   // { kind, name, key, handle, metadata, urls }
+  genKind: 'image',
+  imageModel: 'nano-banana-2',  // 'nano-banana-2' | 'grok' | ...
+  imageAspect: localStorage.getItem('imageAspect') || '1:1',  // 1:1 / 16:9 / 9:16 / 3:2 / 2:3 / 4:3 / 3:4
+  videoModel: localStorage.getItem('videoModel') || 'seedance-2',  // 'seedance-2' | 'kling-o1' | 'kling-3.0' | ...
+  ttsModel: localStorage.getItem('ttsModel') || 'qwen/qwen3-tts',  // qwen/elevenlabs/v3/minimax/speech-02-hd/gemini
+  videoDuration: +(localStorage.getItem('videoDuration') || 5),
+  videoResolution: localStorage.getItem('videoResolution') || '720p',
+  videoAspect: localStorage.getItem('videoAspect') || '9:16',
+  jobs: new Map(),      // nodeId -> { boardKey, boardHandle, kind, taskId }
+  undoStack: [],        // {type, ...payload}
+  zoom: 1,
+  pendingConnectionFrom: null,  // id ноды-источника при drag-line → modal
+  addMenuPos: null,             // {clientX, clientY} клика
+  charactersInfo: [],           // [{name, handle, voice, voiceName, tone, commonTones}]
+  locationsInfo: [],            // [{name, handle, sheet}]
+  pickedCharNames: new Set(),   // выбранные персонажи в gen-модалке (имена)
+  pickedLocName: null,          // выбранная локация в gen-модалке
+  selectedTrackIds: new Set(),  // выделение дорожек таймлайна
+  selectedClipIds: new Set(),   // выделение клипов таймлайна
+  timelineGenTarget: null,      // {trackId, time, charName} — куда положить будущий audio-клип
+  selectedNodeIds: new Set(),   // мультивыделение
+  clipboard: [],                // [{node, blob?, textContent?}] для Cmd+C/V между досками
+  regenerateTarget: null,       // нода для перегенерации (при открытии modal)
+  activeTones: [],              // активные тоны для текущей голосовой генерации
+  toneSuggestions: [],          // подсказки для tone-input (commonTones из персонажа + дефолты)
+  jobLogs: new Map(),           // nodeId -> [{ts, msg}]
+  timelineZoom: parseFloat(localStorage.getItem('timelineZoom') || '50'),  // px на секунду
+  playheadTime: 0,              // текущая позиция playhead в секундах
+  playheadStart: null,          // {time, ts} для tracking при play
+};
+
+function logJob(nodeId, msg) {
+  if (!state.jobLogs.has(nodeId)) state.jobLogs.set(nodeId, []);
+  const arr = state.jobLogs.get(nodeId);
+  arr.push({ ts: Date.now(), msg });
+  if (arr.length > 1000) arr.splice(0, arr.length - 1000);
+  console.log(`[${nodeId.slice(0,8)}] ${msg}`);
+}
+
+// Зеркалит логику маршрутизации в server.js — для timeline-лога ноды,
+// чтобы юзер ВИДЕЛ ДО запроса, на какой провайдер уйдут данные. Если
+// настройки не позволяют ни один путь — возвращает 'none' (запрос либо
+// упадёт 503, либо отработает дефолтом — UI всё равно покажет факт).
+async function plannedProvider(kind) {
+  let s;
+  try { s = await window.appSettings.get(); } catch { s = {}; }
+  const hasChatium = !!(s.useChatium && s.chatium?.token && s.chatium?.base);
+  switch (kind) {
+    case 'text':
+      if (hasChatium) return 'kingkont';
+      if (s.useOpenrouter === true) return 'openrouter';
+      return 'none';
+    case 'audio': case 'tts': case 'sfx': case 'music':
+      // Если ElevenLabs включён С ключом — приоритет прямого ElevenLabs
+      // (юзеру нужны его кастомные/cloned voices). Иначе KingKont.
+      if (s.useElevenlabs === true && s.elevenKey) return 'elevenlabs';
+      if (hasChatium) return 'kingkont';
+      if (s.useElevenlabs === true) return 'elevenlabs';
+      return 'none';
+    case 'video':
+      if (hasChatium) return 'kingkont';
+      if (s.useKie === true) return 'kie';
+      return 'none';
+    case 'image':
+      if (hasChatium) return 'kingkont';
+      if (s.useKie === true) return 'kie';
+      return 'none';
+    default:
+      return '?';
+  }
+}
+// Безопасная сериализация для логов: обрезает длинные строки и убирает blob/handle
+function logSafe(obj) {
+  try {
+    return JSON.stringify(obj, (k, v) => {
+      if (k === 'boardHandle') return v ? `<DirectoryHandle ${v.name || ''}>` : null;
+      if (typeof v === 'string' && v.length > 200) return v.slice(0, 200) + `…(+${v.length - 200} chars)`;
+      return v;
+    });
+  } catch (e) { return String(obj); }
+}
+const DEFAULT_TONES = ['шепот', 'крик', 'смех', 'плач', 'вздох', 'нежно', 'сурово', 'удивлённо', 'грустно', 'возбуждённо'];
+
+function clearSelection() { state.selectedNodeIds.clear(); }
+function toggleSelection(id) {
+  if (state.selectedNodeIds.has(id)) state.selectedNodeIds.delete(id);
+  else state.selectedNodeIds.add(id);
+}
+function renderSelection() {
+  canvas.querySelectorAll('.node.picked').forEach(el => el.classList.remove('picked'));
+  for (const id of state.selectedNodeIds) {
+    const el = canvas.querySelector(`.node[data-id="${id}"]`);
+    if (el) el.classList.add('picked');
+  }
+}
+const ZOOM_MIN = 0.1, ZOOM_MAX = 4;
+const MAX_HISTORY = 30;
+
+// =================== История изменений (undo/redo, persist в scene.json) ===================
+// Хранится в state.currentBoard.metadata.history = { past: [], future: [] },
+// каждый элемент — { ts, label, snap } где snap — сериализованная сцена.
+// snap охватывает: nodes (включая n.text для текстовых), connections, timeline,
+// character, location. Файлы НЕ копируются, но при удалении они уезжают в _deleted
+// и movedFiles в past-элементе помогает их вернуть.
+
+function _getHistory() {
+  if (!state.currentBoard) return null;
+  const meta = state.currentBoard.metadata;
+  if (!meta.history) meta.history = { past: [], future: [] };
+  if (!Array.isArray(meta.history.past))   meta.history.past = [];
+  if (!Array.isArray(meta.history.future)) meta.history.future = [];
+  return meta.history;
+}
+
+function captureScene() {
+  if (!state.currentBoard) return null;
+  const meta = state.currentBoard.metadata;
+  // Копируем ноды с n.text (для text-node содержимое .md-файла) — иначе откат текста невозможен.
+  const nodes = meta.nodes.map(n => ({ ...n }));
+  return JSON.stringify({
+    nodes,
+    connections: meta.connections || [],
+    timeline:    meta.timeline    || null,
+    character:   meta.character   || null,
+    location:    meta.location    || null,
+  });
+}
+
+// Записывает текущее состояние в past и очищает future.
+// Вызывать ДО мутации. opts.movedFiles — для случаев когда удаление файлов уже произошло
+// и при undo нужно их вернуть (см. вызовы в deleteSelectedNodes / deleteNode).
+function pushHistory(label = '', opts = {}) {
+  const h = _getHistory();
+  if (!h) return;
+  const snap = captureScene();
+  h.past.push({ ts: Date.now(), label, snap, movedFiles: opts.movedFiles || null });
+  if (h.past.length > MAX_HISTORY) h.past.shift();
+  h.future.length = 0;
+  scheduleSave();
+}
+
+async function _restoreMovedFiles(boardHandle, movedFiles) {
+  if (!movedFiles?.length) return;
+  for (const mv of movedFiles) {
+    try {
+      const delDir = await boardHandle.getDirectoryHandle('_deleted');
+      const srcFh = await delDir.getFileHandle(mv.movedFilename);
+      const file = await srcFh.getFile();
+      await writeBoardFile(boardHandle, mv.originalPath, file);
+      await delDir.removeEntry(mv.movedFilename);
+    } catch (e) { console.warn('restoreMovedFiles', mv, e); }
+  }
+}
+
+async function applyScene(snap) {
+  if (!state.currentBoard) return;
+  const data = JSON.parse(snap);
+  const meta = state.currentBoard.metadata;
+  // Текстовые ноды: их содержимое — это .md файл, метаданные не хранят текст.
+  // При откате нам нужно перезаписать .md актуальным n.text из snapshot.
+  for (const n of (data.nodes || [])) {
+    if (n.type === 'text' && n.file) {
+      try { await writeBoardFile(state.currentBoard.handle, n.file, n.text || ''); }
+      catch (e) { console.warn('applyScene: text write failed', n.file, e); }
+    }
+  }
+  meta.nodes       = data.nodes || [];
+  meta.connections = data.connections || [];
+  meta.timeline    = data.timeline || null;
+  meta.character   = data.character || null;
+  meta.location    = data.location || null;
+  // blob-URL'ы пересоздадим при следующем рендере — они могли указывать на исчезнувшие файлы
+  for (const u of Object.values(state.currentBoard.urls || {})) URL.revokeObjectURL(u);
+  state.currentBoard.urls = {};
+  state.selectedNodeIds.clear();
+  state.selectedClipIds.clear();
+  state.selectedTrackIds.clear();
+  await renderCanvas();
+  if (!$('timelinePanel').classList.contains('hidden')) await renderTimeline();
+  scheduleSave();
+}
+
+async function undo() {
+  const h = _getHistory();
+  if (h && h.past.length) {
+    const cur = captureScene();
+    const prev = h.past.pop();
+    h.future.push({ ts: Date.now(), label: prev.label, snap: cur });
+    if (h.future.length > MAX_HISTORY) h.future.shift();
+    if (prev.movedFiles) await _restoreMovedFiles(state.currentBoard.handle, prev.movedFiles);
+    await applyScene(prev.snap);
+    return true;
+  }
+  // Фоллбэк: восстанавливаем последнее удалённое board из _deleted.
+  return await undoBoardDelete();
+}
+
+async function redo() {
+  const h = _getHistory();
+  if (!h || !h.future.length) return false;
+  const cur = captureScene();
+  const next = h.future.pop();
+  h.past.push({ ts: Date.now(), label: next.label, snap: cur, movedFiles: null });
+  if (h.past.length > MAX_HISTORY) h.past.shift();
+  await applyScene(next.snap);
+  return true;
+}
+
+// Совместимость со старыми вызовами pushUndo({type:'sceneSnapshot'|'timelineSnapshot'|'delete', ...}).
+// Мы превращаем их в pushHistory: всё равно snapshot уже содержит всю сцену.
+function pushUndo(action) {
+  if (!state.currentBoard) return;
+  const movedFiles = action?.movedFiles || (action?.type === 'delete' && action.movedFilename
+    ? [{ originalPath: action.node?.file, movedFilename: action.movedFilename }]
+    : null);
+  pushHistory(action?.label || action?.type || 'edit', { movedFiles });
+}
+
+async function performUndo() { return undo(); }
+
+const boardKey = (kind, name) => `${kind}/${name}`;
+