gps-plus-slam-app-framework 1.3.0 → 1.4.0

package/dist/storage/file-system.js

@@ -1,289 +0,0 @@
-import { createLogger } from "../utils/logger.js";
-import { setFileSystemState } from "../sensors/permission-checker.js";
-import { SESSION_IMAGES_DIR, formatTimestamp } from "./file-system-utils.js";
-import { createSession, getAppRootHandle, initOpfsStorage, listSessions as listSessions$1, resetOpfsStorage, resetSessionHandles, setSessionHandles, writeAction as writeAction$1, writeFrame as writeFrame$1, writeSessionMetadata as writeSessionMetadata$1 } from "./opfs-storage.js";
-//#region ../src/storage/file-system.ts
-/**
-* File System Storage Module
-*
-* Facade over the OPFS storage module. Provides session lifecycle, write
-* operations, and backwards-compatible scenario management for the recorder.
-*
-* The core OPFS module (opfs-storage.ts) is scenario-free — it manages
-* flat sessions/{timestamp}/ directories. This module bridges the gap by
-* managing scenario directory handles for consumers that still need them
-* (recorder, ref-point loader, etc.) until those are migrated to
-* ScenarioWrappingStorageBackend in later iterations.
-*/
-const log = createLogger("Storage");
-let _currentScenarioName = null;
-let storageInitialized = false;
-let scenariosDir = null;
-let currentScenarioHandle = null;
-/**
-* Reset module state - exported for testing only
-* @internal
-*/
-function resetStorageState() {
-	_currentScenarioName = null;
-	storageInitialized = false;
-	scenariosDir = null;
-	currentScenarioHandle = null;
-	resetOpfsStorage();
-}
-/**
-* Reset session-level state for a new recording.
-*
-* Clears scenario/session names and OPFS session handles, but preserves
-* `storageInitialized` and the OPFS root so `initStorage()` doesn't need
-* to be called again.
-*/
-function resetForNewSession() {
-	_currentScenarioName = null;
-	currentScenarioHandle = null;
-	resetSessionHandles();
-}
-/**
-* Verify that we have actual write access to a directory.
-*/
-async function verifyWriteAccess(dirHandle) {
-	const testFilename = `.write-test-${Date.now()}`;
-	try {
-		const writable = await (await dirHandle.getFileHandle(testFilename, { create: true })).createWritable();
-		await writable.write("write-test");
-		await writable.close();
-		try {
-			await dirHandle.removeEntry(testFilename);
-		} catch (cleanupErr) {
-			log.warn("Write test cleanup failed (non-critical):", cleanupErr);
-		}
-		log.info("Write access verified for:", dirHandle.name);
-		return { success: true };
-	} catch (err) {
-		const error = err instanceof Error ? err : new Error(String(err));
-		log.error("Write verification failed:", error);
-		if (error.name === "NoModificationAllowedError") return {
-			success: false,
-			error: "Folder is read-only. Please select a different folder with write access."
-		};
-		return {
-			success: false,
-			error: `Cannot write to folder: ${error.message}`
-		};
-	}
-}
-async function ensureScenariosDir() {
-	if (scenariosDir) return scenariosDir;
-	const appRoot = getAppRootHandle();
-	if (!appRoot) return null;
-	scenariosDir = await appRoot.getDirectoryHandle("scenarios", { create: true });
-	return scenariosDir;
-}
-/**
-* List all scenario names in OPFS storage.
-* Legacy: scenarios are managed by the recorder, not the framework.
-*/
-async function listScenarios() {
-	const dir = await ensureScenariosDir();
-	if (!dir) return [];
-	const scenarios = [];
-	for await (const entry of dir.values()) if (entry.kind === "directory") scenarios.push(entry.name);
-	return scenarios;
-}
-/**
-* Initialize storage using OPFS.
-*
-* @returns List of existing scenario folder names
-* @throws Error if OPFS is not supported
-*/
-async function initStorage() {
-	try {
-		await initOpfsStorage();
-		storageInitialized = true;
-		setFileSystemState({
-			folderSelected: true,
-			writeVerified: true
-		});
-		await ensureScenariosDir();
-		const scenarios = await listScenarios();
-		log.info("OPFS storage initialized, found scenarios:", scenarios);
-		return scenarios;
-	} catch (err) {
-		const error = err instanceof Error ? err : new Error(String(err));
-		log.error("OPFS initialization failed:", error);
-		setFileSystemState({
-			folderSelected: false,
-			writeVerified: false,
-			writeError: error.message
-		});
-		throw error;
-	}
-}
-/**
-* Create a new session folder.
-*
-* When scenarioName is provided, creates under the scenario directory
-* (legacy scenario layout for the recorder). When omitted, creates under
-* the flat sessions/ directory.
-*
-* @param scenarioName - Optional name of the scenario (omit for flat layout)
-*/
-async function startSession(scenarioName) {
-	if (!storageInitialized) throw new Error("Storage not initialized. Call initStorage first.");
-	if (scenarioName) {
-		const dir = await ensureScenariosDir();
-		if (!dir) throw new Error("Failed to access scenarios directory.");
-		const scenarioHandle = await dir.getDirectoryHandle(scenarioName, { create: true });
-		currentScenarioHandle = scenarioHandle;
-		const sessionName = `recording-${formatTimestamp(/* @__PURE__ */ new Date())}`;
-		const sessionHandle = await scenarioHandle.getDirectoryHandle(sessionName, { create: true });
-		setSessionHandles(sessionHandle, await sessionHandle.getDirectoryHandle("actions", { create: true }), await sessionHandle.getDirectoryHandle(SESSION_IMAGES_DIR, { create: true }));
-		_currentScenarioName = scenarioName;
-		log.info("Session started:", `${scenarioName}/${sessionName}`);
-		return {
-			scenarioPath: scenarioName,
-			sessionPath: sessionName
-		};
-	}
-	const result = await createSession(/* @__PURE__ */ new Date());
-	_currentScenarioName = "";
-	result.sessionName;
-	log.info("Session started:", result.sessionName);
-	return {
-		scenarioPath: "",
-		sessionPath: result.sessionName
-	};
-}
-/**
-* List all session names.
-* When scenarioName is provided, lists sessions under that scenario.
-* Otherwise lists flat sessions.
-*/
-async function listSessions(scenarioName) {
-	if (scenarioName) {
-		const dir = await ensureScenariosDir();
-		if (!dir) return [];
-		try {
-			const scenarioHandle = await dir.getDirectoryHandle(scenarioName);
-			const sessions = [];
-			for await (const entry of scenarioHandle.values()) if (entry.kind === "directory") sessions.push(entry.name);
-			return sessions;
-		} catch {
-			return [];
-		}
-	}
-	return listSessions$1();
-}
-/**
-* Write a Redux action to OPFS as a JSON file.
-*/
-async function writeAction(action, index) {
-	await writeAction$1(action, index);
-}
-/**
-* Write a captured frame image to OPFS.
-*/
-async function writeFrame(blob, index) {
-	await writeFrame$1(blob, index);
-}
-/**
-* Write session metadata (session.json) to OPFS.
-*/
-async function writeSessionMetadata(metadata) {
-	await writeSessionMetadata$1(metadata);
-}
-/**
-* Get the current scenario handle (for loading prior sessions).
-* Legacy: uses scenario directory layout.
-*/
-function getCurrentScenarioHandle() {
-	if (!_currentScenarioName) return null;
-	return currentScenarioHandle;
-}
-/**
-* Set the current scenario handle (when user selects a scenario).
-* Legacy: uses scenario directory layout.
-*/
-async function setCurrentScenario(scenarioName) {
-	const scenRoot = await ensureScenariosDir();
-	if (!scenRoot) return null;
-	try {
-		const handle = await scenRoot.getDirectoryHandle(scenarioName);
-		_currentScenarioName = scenarioName;
-		currentScenarioHandle = handle;
-		return handle;
-	} catch {
-		log.warn("Scenario not found:", scenarioName);
-		return null;
-	}
-}
-/**
-* Ensure a scenario directory exists in OPFS, creating it if necessary.
-* Legacy: used during OPFS recovery.
-*/
-async function ensureScenarioDirectory(scenarioName) {
-	const scenRoot = await ensureScenariosDir();
-	if (!scenRoot) return null;
-	try {
-		const handle = await scenRoot.getDirectoryHandle(scenarioName, { create: true });
-		_currentScenarioName = scenarioName;
-		currentScenarioHandle = handle;
-		return handle;
-	} catch (err) {
-		log.error("Failed to create scenario directory:", err);
-		return null;
-	}
-}
-/**
-* Clear the cached `refPoints/` directory for every scenario in OPFS.
-*
-* Used by the "Clear Reference Point Cache" maintenance action so that the
-* next scenario load re-imports ref points from the read folder's `*.zip`
-* recordings (see ref-point-recovery in the recorder app).
-*
-* Failures for individual scenarios are collected in `errors` rather than
-* aborting the whole operation — partial progress is still useful.
-*
-* @throws Error if OPFS storage is unavailable (e.g. `initStorage()` not yet
-*   called, or browser does not support OPFS). Surfacing this loudly avoids
-*   reporting a silent "0 scenarios cleared" success that would mask the
-*   real failure to the user.
-*/
-async function clearRefPointsCacheForAllScenarios() {
-	const dir = await ensureScenariosDir();
-	if (!dir) throw new Error("clearRefPointsCacheForAllScenarios: OPFS scenarios directory is unavailable — call initStorage() first or check OPFS support");
-	const errors = [];
-	let scenariosCleared = 0;
-	let scenariosScanned = 0;
-	const scenarios = await listScenarios();
-	for (const scenarioName of scenarios) {
-		scenariosScanned++;
-		try {
-			const handle = await dir.getDirectoryHandle(scenarioName);
-			if (!handle) continue;
-			try {
-				await handle.removeEntry("refPoints", { recursive: true });
-				scenariosCleared++;
-			} catch (err) {
-				if ((err instanceof Error ? err.name : String(err?.name)) === "NotFoundError") continue;
-				errors.push({
-					scenarioName,
-					reason: err instanceof Error ? err.message : String(err)
-				});
-			}
-		} catch (err) {
-			errors.push({
-				scenarioName,
-				reason: err instanceof Error ? err.message : String(err)
-			});
-		}
-	}
-	log.info(`Cleared ref-point cache for ${scenariosCleared}/${scenariosScanned} scenarios (${errors.length} errors)`);
-	return {
-		scenariosCleared,
-		scenariosScanned,
-		errors
-	};
-}
-//#endregion
-export { clearRefPointsCacheForAllScenarios, ensureScenarioDirectory, getCurrentScenarioHandle, initStorage, listSessions, resetForNewSession, resetStorageState, setCurrentScenario, startSession, verifyWriteAccess, writeAction, writeFrame, writeSessionMetadata };