kingkont 0.8.7 → 0.9.0

package/renderer/cloudFs.js

@@ -0,0 +1,271 @@
+// renderer/cloudFs.js — FileSystemDirectoryHandle shim для облачных проектов.
+//
+// Зачем: state.filmHandle во всём существующем коде типизирован как FSAH.
+// Чтобы не переписывать весь board.js / state.js / generate.js под условия
+// «if (cloudProject) ... else ...», мы оборачиваем IPC к main-процессу
+// (см. preload.js → window.cloudFs) в объект, который имеет тот же интерфейс
+// что FileSystemDirectoryHandle:
+//
+//   - .name                     — последний сегмент path
+//   - .kind === 'directory'
+//   - .queryPermission()        — всегда 'granted' (это наша же папка)
+//   - .requestPermission()      — то же
+//   - .entries() / .keys()      — async-iterator
+//   - .getDirectoryHandle(name, { create })
+//   - .getFileHandle(name, { create })
+//   - .removeEntry(name, { recursive })
+//
+// FileHandle также мимикрирует:
+//   - .name
+//   - .kind === 'file'
+//   - .getFile() → File-like объект (.size, .type, .name, .arrayBuffer())
+//   - .createWritable() → { write(data), close() }
+//
+// На web-версии (без preload) — window.cloudFs undefined. Тогда возвращаем
+// in-memory shim (карта { path → Uint8Array }). При save-to-server он
+// сериализуется и уходит в /api/projects~update.
+//
+// Идентификатор проекта: projectId (string). Для in-memory — любой стабильный
+// ключ, мы используем 'web:<serverId>' если открыт серверный, или 'web:<uuid>'
+// для нового unsaved.
+
+(function () {
+  // === In-memory FS (web fallback). ============================================
+  // Структура: Map<projectId, Map<path, {kind:'file'|'dir', data?: Uint8Array, mtimeMs?: number}>>.
+  // Path хранится в normalised форме без leading slash (например 'characters/Anna/scene.json').
+  const _mem = new Map();
+  function _memProject(id) {
+    if (!_mem.has(id)) _mem.set(id, new Map());
+    return _mem.get(id);
+  }
+  // Нормализация и помощник для родительских папок: 'a/b/c' → ['a', 'a/b', 'a/b/c'].
+  function _normalize(p) { return String(p || '').replace(/^\/+|\/+$/g, ''); }
+  function _ensureDirs(map, p) {
+    const parts = _normalize(p).split('/');
+    let acc = '';
+    for (let i = 0; i < parts.length; i++) {
+      acc = acc ? acc + '/' + parts[i] : parts[i];
+      if (!map.has(acc)) map.set(acc, { kind: 'dir' });
+    }
+  }
+  function _split(p) {
+    const n = _normalize(p);
+    const i = n.lastIndexOf('/');
+    return i < 0 ? { dir: '', name: n } : { dir: n.slice(0, i), name: n.slice(i + 1) };
+  }
+
+  // === Backend factories. =====================================================
+  // Возвращает объект с минимальным API над хранилищем (диск или память).
+  function makeBackend(projectId) {
+    if (window.cloudFs) {
+      const fs = window.cloudFs;
+      return {
+        async ensure() { await fs.ensureProject(projectId); },
+        list(rel)        { return fs.list(projectId, rel || ''); },
+        exists(rel)      { return fs.exists(projectId, rel || ''); },
+        stat(rel)        { return fs.stat(projectId, rel || ''); },
+        read(rel)        { return fs.read(projectId, rel || ''); },         // Uint8Array
+        readText(rel)    { return fs.readText(projectId, rel || ''); },
+        write(rel, data) { return fs.write(projectId, rel || '', data); },
+        mkdir(rel)       { return fs.mkdir(projectId, rel || ''); },
+        remove(rel)      { return fs.remove(projectId, rel || ''); },
+      };
+    }
+    // ---- web in-memory fallback ----
+    const map = _memProject(projectId);
+    return {
+      async ensure() { _ensureDirs(map, ''); },
+      async list(rel) {
+        const prefix = _normalize(rel);
+        const out = [];
+        for (const [k, v] of map.entries()) {
+          if (k === prefix) continue;
+          if (prefix && !k.startsWith(prefix + '/')) continue;
+          if (!prefix && k.includes('/')) continue;
+          if (prefix && k.slice(prefix.length + 1).includes('/')) continue;
+          out.push({ name: k.split('/').pop(), kind: v.kind });
+        }
+        return out;
+      },
+      async exists(rel) { return map.has(_normalize(rel)); },
+      async stat(rel) {
+        const v = map.get(_normalize(rel));
+        if (!v) return null;
+        return {
+          size: v.data?.byteLength ?? 0,
+          mtimeMs: v.mtimeMs ?? 0,
+          isFile: v.kind === 'file',
+          isDirectory: v.kind === 'dir',
+        };
+      },
+      async read(rel) {
+        const v = map.get(_normalize(rel));
+        if (!v || v.kind !== 'file') throw new Error('ENOENT: ' + rel);
+        return v.data || new Uint8Array(0);
+      },
+      async readText(rel) {
+        const v = map.get(_normalize(rel));
+        if (!v || v.kind !== 'file') return null;
+        return new TextDecoder('utf-8').decode(v.data || new Uint8Array(0));
+      },
+      async write(rel, data) {
+        const p = _normalize(rel);
+        const { dir } = _split(p);
+        if (dir) _ensureDirs(map, dir);
+        const buf = typeof data === 'string'
+          ? new TextEncoder().encode(data)
+          : (data instanceof Uint8Array ? data : new Uint8Array(data));
+        map.set(p, { kind: 'file', data: buf, mtimeMs: Date.now() });
+        return true;
+      },
+      async mkdir(rel) { _ensureDirs(map, rel); return true; },
+      async remove(rel) {
+        const p = _normalize(rel);
+        // Удаляем запись и все потомки.
+        for (const k of Array.from(map.keys())) {
+          if (k === p || k.startsWith(p + '/')) map.delete(k);
+        }
+        return true;
+      },
+    };
+  }
+
+  // === FSAH-shim — directory + file. ==========================================
+  function _join(a, b) { return a ? a + '/' + b : b; }
+
+  function makeDirHandle(backend, dirPath, projectId, displayName) {
+    const _name = displayName ?? (dirPath ? dirPath.split('/').pop() : projectId);
+    return {
+      kind: 'directory',
+      name: _name,
+      // FSAH-специфичные методы пермишенов — у нас всегда granted.
+      async queryPermission() { return 'granted'; },
+      async requestPermission() { return 'granted'; },
+
+      async getFileHandle(name, opts) {
+        const rel = _join(dirPath, name);
+        const exists = await backend.exists(rel);
+        if (!exists) {
+          if (opts?.create) {
+            await backend.write(rel, new Uint8Array(0));
+          } else {
+            const e = new Error(`A requested file or directory could not be found at the time an operation was processed. (file: ${rel})`);
+            e.name = 'NotFoundError';
+            throw e;
+          }
+        }
+        return makeFileHandle(backend, rel, name);
+      },
+      async getDirectoryHandle(name, opts) {
+        const rel = _join(dirPath, name);
+        const exists = await backend.exists(rel);
+        if (!exists) {
+          if (opts?.create) {
+            await backend.mkdir(rel);
+          } else {
+            const e = new Error(`A requested directory could not be found at the time an operation was processed. (dir: ${rel})`);
+            e.name = 'NotFoundError';
+            throw e;
+          }
+        }
+        return makeDirHandle(backend, rel, projectId, name);
+      },
+      async removeEntry(name, opts) {
+        await backend.remove(_join(dirPath, name));
+      },
+      // async-iterable — повторяет .entries() FSAH ([name, handle]).
+      async *entries() {
+        const items = await backend.list(dirPath);
+        for (const it of items) {
+          const sub = _join(dirPath, it.name);
+          if (it.kind === 'dir') yield [it.name, makeDirHandle(backend, sub, projectId, it.name)];
+          else yield [it.name, makeFileHandle(backend, sub, it.name)];
+        }
+      },
+      async *keys() {
+        const items = await backend.list(dirPath);
+        for (const it of items) yield it.name;
+      },
+      async *values() {
+        for (const [, h] of this.entries()) yield h;
+      },
+      [Symbol.asyncIterator]() { return this.entries(); },
+
+      // --- KingKont-специфичные расширения (не часть стандарта FSAH). -----
+      __cloudProjectId: projectId,            // используется board.js для ветвления
+      __cloudPath: dirPath,
+      __backend: backend,
+    };
+  }
+
+  function makeFileHandle(backend, relPath, displayName) {
+    const _name = displayName ?? relPath.split('/').pop();
+    return {
+      kind: 'file',
+      name: _name,
+      async queryPermission() { return 'granted'; },
+      async requestPermission() { return 'granted'; },
+      async getFile() {
+        const buf = await backend.read(relPath);
+        const u8 = buf instanceof Uint8Array ? buf : new Uint8Array(buf);
+        const stat = await backend.stat(relPath);
+        // Имитация Web File: (.name, .size, .type, .arrayBuffer(), .text(), .stream()).
+        const blob = new Blob([u8]);
+        return Object.assign(blob, {
+          name: _name,
+          lastModified: stat?.mtimeMs ?? Date.now(),
+          arrayBuffer: () => Promise.resolve(u8.buffer.slice(u8.byteOffset, u8.byteOffset + u8.byteLength)),
+        });
+      },
+      async createWritable() {
+        let chunks = [];
+        return {
+          async write(data) {
+            if (typeof data === 'string') chunks.push(new TextEncoder().encode(data));
+            else if (data instanceof Blob) chunks.push(new Uint8Array(await data.arrayBuffer()));
+            else if (data instanceof Uint8Array) chunks.push(data);
+            else if (data instanceof ArrayBuffer) chunks.push(new Uint8Array(data));
+            else throw new Error('createWritable: unsupported data type');
+          },
+          async close() {
+            const total = chunks.reduce((s, c) => s + c.byteLength, 0);
+            const merged = new Uint8Array(total);
+            let off = 0;
+            for (const c of chunks) { merged.set(c, off); off += c.byteLength; }
+            await backend.write(relPath, merged);
+            chunks = null;
+          },
+          async abort() { chunks = null; },
+        };
+      },
+      __cloudProjectId: backend.__projectId,
+      __cloudPath: relPath,
+    };
+  }
+
+  // === Public API. ============================================================
+  // Создать FSAH-shim для облачного проекта. projectName показывается как
+  // .name root-handle'а (вместо projectId).
+  async function makeCloudHandle(projectId, projectName) {
+    const backend = makeBackend(projectId);
+    backend.__projectId = projectId;
+    await backend.ensure();
+    return makeDirHandle(backend, '', projectId, projectName || projectId);
+  }
+
+  // Проверить — это cloud-handle (наш shim) или native FSAH?
+  function isCloudHandle(handle) {
+    return !!(handle && handle.__cloudProjectId);
+  }
+
+  // Получить projectId / backend из любого вложенного cloud-handle.
+  function getCloudProjectId(handle) { return handle?.__cloudProjectId || null; }
+
+  window.cloudFsShim = {
+    makeCloudHandle,
+    isCloudHandle,
+    getCloudProjectId,
+    // exposed для save-to-server: пройтись по всем файлам in-memory map'а.
+    _memProject,
+  };
+})();