@mindexec/cli 0.2.0

package/wwwroot/_content/MindExecution.Shared/js/file-system-helper.js

@@ -0,0 +1,639 @@
+window.fileSystemHelper = {
+    cachedFileHandle: null,
+
+    // ▼▼▼ OPFS Helpers ▼▼▼
+    _getOpfsRoot: async () => {
+        return await navigator.storage.getDirectory();
+    },
+
+    isOpfsAvailable: async () => {
+        try {
+            return !!(navigator.storage && navigator.storage.getDirectory && await navigator.storage.getDirectory());
+        } catch {
+            return false;
+        }
+    },
+
+    saveToOpfs: async (filePath, dataContent) => {
+        try {
+            const root = await window.fileSystemHelper._getOpfsRoot();
+            const parts = filePath.split('/');
+            const fileName = parts.pop();
+            let currentDir = root;
+
+            for (const part of parts) {
+                currentDir = await currentDir.getDirectoryHandle(part, { create: true });
+            }
+
+            const fileHandle = await currentDir.getFileHandle(fileName, { create: true });
+            const writable = await fileHandle.createWritable();
+            await writable.write(dataContent);
+            await writable.close();
+            return true;
+        } catch (err) {
+            console.error(`[OPFS] Text Save Failed (${filePath}):`, err);
+            return false;
+        }
+    },
+
+    loadFromOpfs: async (filePath) => {
+        try {
+            const root = await window.fileSystemHelper._getOpfsRoot();
+            const parts = filePath.split('/');
+            const fileName = parts.pop();
+            let currentDir = root;
+
+            for (const part of parts) {
+                currentDir = await currentDir.getDirectoryHandle(part);
+            }
+
+            const fileHandle = await currentDir.getFileHandle(fileName);
+            const file = await fileHandle.getFile();
+            const buffer = await file.arrayBuffer();
+            return new Uint8Array(buffer);
+        } catch (err) {
+            return null;
+        }
+    },
+
+    loadAssetAsBlobUrl: async (filePath) => {
+        try {
+            const root = await window.fileSystemHelper._getOpfsRoot();
+            const parts = filePath.split('/');
+            const fileName = parts.pop();
+            let currentDir = root;
+
+            for (const part of parts) {
+                currentDir = await currentDir.getDirectoryHandle(part);
+            }
+
+            const fileHandle = await currentDir.getFileHandle(fileName);
+            const file = await fileHandle.getFile();
+            return URL.createObjectURL(file);
+        } catch (err) {
+            console.warn(`[OPFS] Asset not found: ${filePath}`);
+            return null;
+        }
+    },
+
+    existsInOpfs: async (filePath) => {
+        try {
+            const root = await window.fileSystemHelper._getOpfsRoot();
+            const parts = filePath.split('/');
+            const fileName = parts.pop();
+            let currentDir = root;
+
+            for (const part of parts) {
+                currentDir = await currentDir.getDirectoryHandle(part);
+            }
+
+            await currentDir.getFileHandle(fileName);
+            return true;
+        } catch {
+            return false;
+        }
+    },
+
+    listOpfsDirectory: async (dirPath) => {
+        try {
+            const root = await window.fileSystemHelper._getOpfsRoot();
+            const parts = (dirPath || '').split('/').filter(Boolean);
+            let currentDir = root;
+
+            for (const part of parts) {
+                currentDir = await currentDir.getDirectoryHandle(part);
+            }
+
+            const entries = [];
+            for await (const [name, handle] of currentDir.entries()) {
+                let modified = null;
+                if (handle.kind === 'file') {
+                    try {
+                        const file = await handle.getFile();
+                        modified = new Date(file.lastModified).toISOString();
+                    } catch {
+                        modified = null;
+                    }
+                }
+
+                entries.push({ name, kind: handle.kind, modified });
+            }
+
+            return entries;
+        } catch {
+            return [];
+        }
+    },
+
+    deleteFromOpfs: async (filePath) => {
+        try {
+            const root = await window.fileSystemHelper._getOpfsRoot();
+            const parts = filePath.split('/');
+            const fileName = parts.pop();
+            let currentDir = root;
+
+            for (const part of parts) {
+                currentDir = await currentDir.getDirectoryHandle(part);
+            }
+
+            await currentDir.removeEntry(fileName);
+            return true;
+        } catch {
+            return false;
+        }
+    },
+
+    saveAssetFromUrlToOpfs: async (blobUrl, filePath) => {
+        try {
+            const response = await fetch(blobUrl);
+            const blob = await response.blob();
+
+            const root = await window.fileSystemHelper._getOpfsRoot();
+            const parts = filePath.split('/');
+            const fileName = parts.pop();
+            let currentDir = root;
+
+            for (const part of parts) {
+                currentDir = await currentDir.getDirectoryHandle(part, { create: true });
+            }
+
+            const fileHandle = await currentDir.getFileHandle(fileName, { create: true });
+            const writable = await fileHandle.createWritable();
+            await writable.write(blob);
+            await writable.close();
+            return true;
+        } catch (err) {
+            console.error('[OPFS] Asset Save Failed:', err);
+            return false;
+        }
+    },
+
+    resetOpfs: async () => {
+        try {
+            const root = await navigator.storage.getDirectory();
+            for await (const name of root.keys()) {
+                await root.removeEntry(name, { recursive: true });
+            }
+            console.log('[OPFS] All data wiped.');
+        } catch (err) {
+            console.error('[OPFS] Reset failed:', err);
+        }
+    },
+    // ▲▲▲ OPFS Helpers ▲▲▲
+
+    // ▼▼▼ [NEW] VFS <-> IndexedDB sync utilities ▼▼▼
+    _dbPromise: null,
+    _getDb: function () {
+        if (!this._dbPromise) {
+            this._dbPromise = new Promise((resolve, reject) => {
+                const request = indexedDB.open('MindMapVFS', 1);
+                request.onupgradeneeded = (e) => {
+                    const db = e.target.result;
+                    if (!db.objectStoreNames.contains('files')) {
+                        db.createObjectStore('files');
+                    }
+                };
+                request.onsuccess = (e) => resolve(e.target.result);
+                request.onerror = (e) => reject(e.target.error);
+            });
+        }
+        return this._dbPromise;
+    },
+
+    saveToIndexedDB: async (filePath, dataBytes) => {
+        try {
+            const db = await window.fileSystemHelper._getDb();
+
+            return new Promise((resolve, reject) => {
+                const tx = db.transaction('files', 'readwrite');
+                tx.objectStore('files').put(dataBytes, filePath);
+                tx.oncomplete = () => resolve(true);
+                tx.onerror = () => reject(tx.error);
+            });
+        } catch (err) {
+            console.error('[VFS] Save to IndexedDB failed:', err);
+            return false;
+        }
+    },
+
+    loadFromIndexedDB: async (filePath) => {
+        try {
+            const db = await window.fileSystemHelper._getDb();
+            return new Promise((resolve, reject) => {
+                const tx = db.transaction('files', 'readonly');
+                const store = tx.objectStore('files');
+                const request = store.get(filePath);
+                request.onsuccess = () => resolve(request.result || null);
+                request.onerror = () => reject(request.error);
+            });
+        } catch (err) {
+            console.error('[VFS] Load from IndexedDB failed:', err);
+            return null;
+        }
+    },
+
+    existsInIndexedDB: async (filePath) => {
+        try {
+            const db = await window.fileSystemHelper._getDb();
+            return new Promise((resolve) => {
+                const tx = db.transaction('files', 'readonly');
+                const store = tx.objectStore('files');
+                const request = store.count(filePath);
+                request.onsuccess = () => resolve(request.result > 0);
+                request.onerror = () => resolve(false);
+            });
+        } catch {
+            return false;
+        }
+    },
+    // ▲▲▲ [NEW] ▲▲▲
+
+    // ▼▼▼ [NEW] Save binary data to local disk ▼▼▼
+    saveDataToLocalDisk: async (dataBytes, fileName) => {
+        try {
+            // Without a cachedFileHandle (i.e., not from an explicit user gesture), we cannot prompt.
+            // For auto-save scenarios, it's correct to just skip disk writes.
+            if (!window.fileSystemHelper.cachedFileHandle) {
+                 console.log("[FileSystemHelper] No cached handle for auto-export. Skipping disk write.");
+                 return;
+            }
+            
+            // 1. Convert to Uint8Array (Blazor may marshal byte[] as base64 or an array; verify if needed)
+            // Usually, Blazor JS interop marshals byte[] into a Uint8Array.
+            
+            const writable = await window.fileSystemHelper.cachedFileHandle.createWritable();
+            await writable.write(dataBytes);
+            await writable.close();
+            
+            console.log("[FileSystemHelper] Database saved to local disk.");
+        } catch (err) {
+             console.warn("[FileSystemHelper] Disk export failed:", err);
+        }
+    },
+    // ▲▲▲ [NEW] ▲▲▲
+
+    // 1. Save the DB from OPFS to local disk (no longer used; kept for compatibility)
+    exportOpfsDatabase: async (dbName) => {
+        try {
+            // A. Read DB file from OPFS
+            const opfsRoot = await navigator.storage.getDirectory();
+            const fileHandle = await opfsRoot.getFileHandle(dbName);
+            const file = await fileHandle.getFile();
+
+            // B. Choose save location (File System Access API)
+            // If there is no cached handle, prompt the user.
+            if (!window.fileSystemHelper.cachedFileHandle) {
+                window.fileSystemHelper.cachedFileHandle = await window.showSaveFilePicker({
+                    suggestedName: dbName,
+                    types: [{
+                        description: 'SQLite Database',
+                        accept: { 'application/vnd.sqlite3': ['.db'] },
+                    }],
+                });
+            }
+
+            // C. Write
+            const writable = await window.fileSystemHelper.cachedFileHandle.createWritable();
+            await writable.write(file);
+            await writable.close();
+
+            console.log("DB Saved to local disk successfully.");
+        } catch (err) {
+            console.error("Export failed:", err);
+            // On failure (e.g., permission denied), reset the cached handle
+            window.fileSystemHelper.cachedFileHandle = null;
+        }
+    },
+
+    // 2. Copy a local DB into OPFS (import)
+    importDatabaseToOpfs: async (dbName) => {
+        try {
+            // A. Open file
+            const [handle] = await window.showOpenFilePicker({
+                types: [{
+                    description: 'SQLite Database',
+                    accept: { 'application/vnd.sqlite3': ['.db'] },
+                }],
+                multiple: false
+            });
+            const file = await handle.getFile();
+
+            // B. Write into OPFS
+            const opfsRoot = await navigator.storage.getDirectory();
+            const fileHandle = await opfsRoot.getFileHandle(dbName, { create: true });
+            const writable = await fileHandle.createWritable();
+            await writable.write(file);
+            await writable.close();
+
+            console.log("DB Imported to OPFS.");
+            return true;
+        } catch (err) {
+            console.error("Import failed:", err);
+            return false;
+        }
+    },
+
+    // ▼▼▼ [UPDATED] Optimized large-file handling (use Response streams) ▼▼▼
+    createBlobUrlFromStream: async (streamRef, mimeType) => {
+        const debugTracing = Boolean(window.MindMapDebugEnabled);
+        if (debugTracing) {
+            console.debug('[FileSystemHelper] createBlobUrlFromStream start', { mimeType });
+        }
+
+        try {
+            // 1. Convert DotNetStreamReference into a Response object (memory-efficient)
+            const response = await streamRef.stream();
+
+            // 2. Create a Blob from the stream
+            const blob = await new Response(response).blob();
+            if (debugTracing) {
+                console.debug('[FileSystemHelper] stream converted to blob', { size: blob.size, type: blob.type });
+            }
+
+            // 3. Set MIME type: new Blob([blob]) may copy data; using slice only changes type and
+            //    reduces memory pressure / failure risk.
+            const targetType = mimeType || blob.type || 'application/octet-stream';
+            const typedBlob = (blob.type === targetType) ? blob : blob.slice(0, blob.size, targetType);
+            const blobUrl = URL.createObjectURL(typedBlob);
+
+            if (debugTracing) {
+                console.debug('[FileSystemHelper] Blob URL created', { mimeType: targetType, blobSize: typedBlob.size });
+            }
+
+            return blobUrl;
+        } catch (err) {
+            console.error('[FileSystemHelper] Failed to create blob from stream:', err);
+            if (debugTracing) {
+                console.error('[FileSystemHelper] createBlobUrlFromStream error context', { mimeType });
+            }
+            return null;
+        }
+    }
+    ,
+
+    // Fallback: C# byte[] -> Blob URL
+    createBlobUrlFromBytes: (dataBytes, mimeType) => {
+        const debugTracing = Boolean(window.MindMapDebugEnabled);
+        try {
+            const targetType = mimeType || 'application/octet-stream';
+            const bytes = (dataBytes instanceof Uint8Array) ? dataBytes : new Uint8Array(dataBytes);
+            if (debugTracing) {
+                console.debug('[FileSystemHelper] createBlobUrlFromBytes', { mimeType: targetType, size: bytes.byteLength });
+            }
+            const blob = new Blob([bytes], { type: targetType });
+            return URL.createObjectURL(blob);
+        } catch (err) {
+            console.error('[FileSystemHelper] Failed to create blob from bytes:', err);
+            return null;
+        }
+    }
+    // ▲▲▲ [UPDATED] ▲▲▲
+};
+
+(function () {
+    const DB_NAME = 'MindMapDB';
+    const STORE_NAME = 'handles';
+    const LOCAL_FILE_KEY_PREFIX = 'local-file:';
+    const LOCAL_FILE_URI_PREFIX = 'mindexec-local-file://';
+    const sessionEntries = new Map();
+    const objectUrls = new Map();
+    let dbPromise = null;
+
+    function getDb() {
+        if (!dbPromise) {
+            dbPromise = new Promise((resolve, reject) => {
+                const request = indexedDB.open(DB_NAME, 1);
+                request.onupgradeneeded = (event) => {
+                    const db = event.target.result;
+                    if (!db.objectStoreNames.contains(STORE_NAME)) {
+                        db.createObjectStore(STORE_NAME);
+                    }
+                };
+                request.onsuccess = () => resolve(request.result);
+                request.onerror = () => reject(request.error);
+            });
+        }
+
+        return dbPromise;
+    }
+
+    async function idbSet(key, value) {
+        const db = await getDb();
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(STORE_NAME, 'readwrite');
+            tx.objectStore(STORE_NAME).put(value, key);
+            tx.oncomplete = () => resolve(true);
+            tx.onerror = () => reject(tx.error);
+        });
+    }
+
+    async function idbGet(key) {
+        const db = await getDb();
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(STORE_NAME, 'readonly');
+            const request = tx.objectStore(STORE_NAME).get(key);
+            request.onsuccess = () => resolve(request.result || null);
+            request.onerror = () => reject(request.error);
+        });
+    }
+
+    function createId() {
+        if (window.crypto?.randomUUID) {
+            return window.crypto.randomUUID();
+        }
+
+        return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 12)}`;
+    }
+
+    function createReference(id) {
+        const normalizedId = String(id || '').trim();
+        return normalizedId ? `${LOCAL_FILE_URI_PREFIX}${encodeURIComponent(normalizedId)}` : '';
+    }
+
+    function extractId(value) {
+        const text = String(value || '').trim();
+        if (!text) {
+            return '';
+        }
+
+        if (text.toLowerCase().startsWith(LOCAL_FILE_URI_PREFIX)) {
+            return decodeURIComponent(text.slice(LOCAL_FILE_URI_PREFIX.length));
+        }
+
+        if (text.toLowerCase().startsWith('local-file:')) {
+            return text.slice('local-file:'.length);
+        }
+
+        return text;
+    }
+
+    function isReference(value) {
+        const text = String(value || '').trim().toLowerCase();
+        return text.startsWith(LOCAL_FILE_URI_PREFIX) || text.startsWith('local-file:');
+    }
+
+    function rememberObjectUrl(id, objectUrl) {
+        const normalizedId = String(id || '').trim();
+        if (!normalizedId || !objectUrl) {
+            return '';
+        }
+
+        const previous = objectUrls.get(normalizedId);
+        if (previous && previous !== objectUrl) {
+            try { URL.revokeObjectURL(previous); } catch { }
+        }
+
+        objectUrls.set(normalizedId, objectUrl);
+        return objectUrl;
+    }
+
+    async function getDroppedFileHandle(item) {
+        if (!item || item.kind !== 'file' || typeof item.getAsFileSystemHandle !== 'function') {
+            return null;
+        }
+
+        try {
+            const handle = await item.getAsFileSystemHandle();
+            return handle?.kind === 'file' ? handle : null;
+        } catch (error) {
+            console.warn('[MindMapLocalFiles] Could not capture dropped file handle:', error);
+            return null;
+        }
+    }
+
+    async function canReadHandle(handle, requestIfNeeded = false) {
+        if (!handle) {
+            return false;
+        }
+
+        try {
+            if (typeof handle.queryPermission !== 'function') {
+                return true;
+            }
+
+            const queried = await handle.queryPermission({ mode: 'read' });
+            if (queried === 'granted') {
+                return true;
+            }
+
+            if (!requestIfNeeded || typeof handle.requestPermission !== 'function') {
+                return false;
+            }
+
+            return await handle.requestPermission({ mode: 'read' }) === 'granted';
+        } catch {
+            return false;
+        }
+    }
+
+    async function registerDroppedFile(file, item = null, options = {}) {
+        if (!(file instanceof File)) {
+            return null;
+        }
+
+        const id = String(options.id || createId()).trim();
+        const reference = createReference(id);
+        const objectUrl = rememberObjectUrl(id, URL.createObjectURL(file));
+        const handle = await getDroppedFileHandle(item);
+        let durableHandle = false;
+
+        if (handle) {
+            try {
+                await idbSet(`${LOCAL_FILE_KEY_PREFIX}${id}`, handle);
+                durableHandle = true;
+            } catch (error) {
+                console.warn('[MindMapLocalFiles] Failed to persist local file handle:', error);
+            }
+        }
+
+        const entry = {
+            id,
+            reference,
+            objectUrl,
+            file,
+            fileName: file.name || '',
+            size: Number(file.size || 0),
+            mime: file.type || '',
+            lastModified: Number(file.lastModified || 0),
+            durableHandle,
+            sourceKind: durableHandle ? 'local-file' : 'session-file'
+        };
+
+        sessionEntries.set(id, entry);
+        return entry;
+    }
+
+    async function getStoredHandle(id) {
+        const normalizedId = extractId(id);
+        if (!normalizedId) {
+            return null;
+        }
+
+        return await idbGet(`${LOCAL_FILE_KEY_PREFIX}${normalizedId}`);
+    }
+
+    async function getObjectUrl(referenceOrId, options = {}) {
+        const id = extractId(referenceOrId);
+        if (!id) {
+            return '';
+        }
+
+        const existingObjectUrl = objectUrls.get(id);
+        if (existingObjectUrl) {
+            return existingObjectUrl;
+        }
+
+        const sessionEntry = sessionEntries.get(id);
+        if (sessionEntry?.file instanceof File) {
+            return rememberObjectUrl(id, URL.createObjectURL(sessionEntry.file));
+        }
+
+        const handle = await getStoredHandle(id);
+        if (!handle) {
+            return '';
+        }
+
+        if (!(await canReadHandle(handle, options.requestPermission === true))) {
+            return '';
+        }
+
+        const file = await handle.getFile();
+        const objectUrl = rememberObjectUrl(id, URL.createObjectURL(file));
+        sessionEntries.set(id, {
+            id,
+            reference: createReference(id),
+            objectUrl,
+            file,
+            fileName: file.name || '',
+            size: Number(file.size || 0),
+            mime: file.type || '',
+            lastModified: Number(file.lastModified || 0),
+            durableHandle: true,
+            sourceKind: 'local-file'
+        });
+
+        return objectUrl;
+    }
+
+    window.MindMapLocalFiles = {
+        uriPrefix: LOCAL_FILE_URI_PREFIX,
+        isSupported: () => typeof indexedDB !== 'undefined'
+            && typeof URL !== 'undefined'
+            && typeof URL.createObjectURL === 'function',
+        isReference,
+        extractId,
+        createReference,
+        registerDroppedFile,
+        getObjectUrl,
+        getStoredHandle,
+        getSessionEntry: (referenceOrId) => sessionEntries.get(extractId(referenceOrId)) || null,
+        revokeObjectUrl(referenceOrId) {
+            const id = extractId(referenceOrId);
+            const objectUrl = objectUrls.get(id);
+            if (objectUrl) {
+                try { URL.revokeObjectURL(objectUrl); } catch { }
+                objectUrls.delete(id);
+            }
+        }
+    };
+})();