emoemu 0.1.0

package/src/frontend/saveServices/consts.ts

@@ -0,0 +1,2 @@
+/** ASCII code for '{' - indicates start of JSON */
+export const JSON_OPEN_BRACE = 0x7b;

package/src/frontend/saveServices/index.ts

@@ -0,0 +1,313 @@
+/**
+ * Save Services
+ *
+ * Service classes for save state and battery save operations.
+ * These hold config internally so callers don't need to pass it to every method.
+ * Services manage their own directory cache for efficient batch operations.
+ */
+
+import { readFileSync, writeFileSync, existsSync, readdirSync, unlinkSync } from 'fs';
+import { basename, dirname, extname, join } from 'path';
+import { decompress, detectCompressionFormat } from '../../utils/compression';
+import type { Config } from '../config';
+import { resolveSaveStateDir, resolveSaveFileDir } from '../config';
+import { type DirectoryCache, createDirectoryCache, getCachedDirectoryListing } from '../directoryCache';
+import { logger } from '../../utils/logger';
+import { getErrorMessage } from '../../utils/getErrorMessage';
+
+export * from './consts';
+
+import { JSON_OPEN_BRACE } from './consts';
+
+/**
+ * Escape special regex characters in a string
+ */
+const escapeRegExp = (str: string): string => {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+};
+
+/**
+ * Details loaded from a save state file
+ */
+export interface SaveStateDetails {
+  /** Timestamp when the save state was last modified (from file system) */
+  savedAt?: Date;
+}
+
+/**
+ * Result of checking for a save state
+ */
+export interface SaveStateCheckResult {
+  exists: boolean;
+  date?: Date;
+  path?: string;
+}
+
+/**
+ * Result of checking for a battery save
+ */
+export interface BatterySaveCheckResult {
+  exists: boolean;
+  date?: Date;
+  path?: string;
+}
+
+/**
+ * Service for save state operations.
+ * Holds config internally so callers don't need to pass it to every method.
+ * Manages its own directory cache for efficient batch operations.
+ */
+export class SaveStateService {
+  private cache: DirectoryCache = createDirectoryCache();
+
+  constructor(private config: Config) {}
+
+  /**
+   * Clear the internal directory cache.
+   * Call this after batch operations or when files may have changed.
+   */
+  clearCache(): void {
+    this.cache.clear();
+  }
+
+  /**
+   * Get the directory where save states should be stored for a ROM.
+   * Uses savestates_in_content_dir setting to determine location.
+   */
+  getSaveDir(romPath: string): string {
+    return resolveSaveStateDir(dirname(romPath), this.config);
+  }
+
+  /**
+   * Get the path for writing a new save state file.
+   * Format: [rom basename without extension].state.auto
+   */
+  getStatePath(romPath: string): string {
+    const dir = this.getSaveDir(romPath);
+    const name = basename(romPath, extname(romPath));
+    return join(dir, `${name}.state.auto`);
+  }
+
+  /**
+   * Find an existing save state file for a ROM.
+   * Searches only in the directory specified by config settings.
+   *
+   * Priority:
+   * 1. [romname].state.auto (highest priority)
+   * 2. [romname].[anything].state (legacy format with coreId or other suffix)
+   * 3. [romname].state (legacy format without suffix)
+   *
+   * Returns the path to the save state file, or null if none found.
+   */
+  findExistingStatePath(romPath: string): string | null {
+    const dir = this.getSaveDir(romPath);
+    const name = basename(romPath, extname(romPath));
+
+    // Priority 1: Check for .state.auto (preferred format)
+    const autoPath = join(dir, `${name}.state.auto`);
+    if (existsSync(autoPath)) {
+      return autoPath;
+    }
+
+    // Priority 2 & 3: Look for legacy formats
+    try {
+      const files = readdirSync(dir);
+      const statePattern = new RegExp(`^${escapeRegExp(name)}(\\.[^.]+)?\\.state$`);
+
+      for (const file of files) {
+        if (statePattern.test(file)) {
+          return join(dir, file);
+        }
+      }
+    } catch {
+      // Directory read failed
+    }
+
+    return null;
+  }
+
+  /**
+   * Check if a save state exists for a ROM.
+   * Uses internal directory cache for efficient batch lookups.
+   */
+  checkExists(romPath: string): SaveStateCheckResult {
+    const dir = this.getSaveDir(romPath);
+    const romName = basename(romPath, extname(romPath));
+
+    // Use cached directory listing for O(1) lookup
+    const listing = getCachedDirectoryListing(dir, this.cache);
+
+    // Priority 1: Check for .state.auto
+    const autoFilename = `${romName}.state.auto`;
+    const autoMtime = listing.get(autoFilename);
+    if (autoMtime) {
+      return { exists: true, date: autoMtime, path: join(dir, autoFilename) };
+    }
+
+    // Priority 2 & 3: Check legacy formats
+    const statePattern = new RegExp(`^${escapeRegExp(romName)}(\\.[^.]+)?\\.state$`);
+    for (const [filename, mtime] of listing.entries()) {
+      if (statePattern.test(filename)) {
+        return { exists: true, date: mtime, path: join(dir, filename) };
+      }
+    }
+
+    return { exists: false };
+  }
+
+  /**
+   * Load detailed information from a save state file.
+   * Uses file modification time since save states no longer contain metadata.
+   */
+  loadDetails(romPath: string): SaveStateDetails {
+    const result = this.checkExists(romPath);
+    if (result.exists && result.date) {
+      return { savedAt: result.date };
+    }
+    return {};
+  }
+
+  /**
+   * Load raw binary state directly from file.
+   * Automatically decompresses if the file is compressed (zstd, zlib, or gzip).
+   */
+  loadRawState(romPath: string): Buffer | null {
+    const statePath = this.findExistingStatePath(romPath);
+
+    if (!statePath) {
+      return null;
+    }
+
+    try {
+      const data = readFileSync(statePath);
+      return decompress(data);
+    } catch (err) {
+      logger.error(`Failed to load raw state: ${statePath} - ${getErrorMessage(err)}`, 'SaveState');
+      return null;
+    }
+  }
+
+  /**
+   * Save raw binary state directly to file (RetroArch-compatible format).
+   * Always writes to .state.auto format.
+   */
+  saveRawState(romPath: string, buffer: Buffer): void {
+    const statePath = this.getStatePath(romPath);
+
+    try {
+      writeFileSync(statePath, buffer);
+    } catch (err) {
+      logger.error(`Failed to save raw state: ${statePath} - ${getErrorMessage(err)}`, 'SaveState');
+    }
+  }
+
+  /**
+   * Check if the saved state appears to be a raw binary file (not JSON).
+   * Handles compressed files by checking the decompressed content.
+   */
+  isRawStateFile(romPath: string): boolean {
+    const statePath = this.findExistingStatePath(romPath);
+
+    if (!statePath) {
+      return false;
+    }
+
+    try {
+      const data = readFileSync(statePath);
+      const format = detectCompressionFormat(data);
+      const decompressed = format !== 'none' ? decompress(data) : data;
+
+      if (decompressed.length > 0 && decompressed[0] === JSON_OPEN_BRACE) {
+        return false;
+      }
+
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Delete the save state file for a ROM.
+   */
+  deleteState(romPath: string): void {
+    const statePath = this.findExistingStatePath(romPath);
+    if (statePath) {
+      try {
+        unlinkSync(statePath);
+      } catch {
+        // Ignore errors when deleting
+      }
+    }
+  }
+
+  /**
+   * Check if a save state exists for this ROM
+   */
+  hasSavedState(romPath: string): boolean {
+    return this.findExistingStatePath(romPath) !== null;
+  }
+
+  /**
+   * Get the game ID (ROM filename without path)
+   */
+  getGameId(romPath: string): string {
+    return basename(romPath);
+  }
+}
+
+/**
+ * Service for battery save (.srm) operations.
+ * Holds config internally so callers don't need to pass it to every method.
+ * Manages its own directory cache for efficient batch operations.
+ */
+export class BatterySaveService {
+  private cache: DirectoryCache = createDirectoryCache();
+
+  constructor(private config: Config) {}
+
+  /**
+   * Clear the internal directory cache.
+   * Call this after batch operations or when files may have changed.
+   */
+  clearCache(): void {
+    this.cache.clear();
+  }
+
+  /**
+   * Get the directory where battery saves should be stored for a ROM.
+   * Uses savefiles_in_content_dir setting to determine location.
+   */
+  getSaveDir(romPath: string): string {
+    return resolveSaveFileDir(dirname(romPath), this.config);
+  }
+
+  /**
+   * Get the path for a battery save file.
+   * Format: [rom basename without extension].srm
+   */
+  getSavePath(romPath: string): string {
+    const dir = this.getSaveDir(romPath);
+    const name = basename(romPath, extname(romPath));
+    return join(dir, `${name}.srm`);
+  }
+
+  /**
+   * Check if a battery save exists for a ROM.
+   * Uses internal directory cache for efficient batch lookups.
+   */
+  checkExists(romPath: string): BatterySaveCheckResult {
+    const dir = this.getSaveDir(romPath);
+    const romName = basename(romPath, extname(romPath));
+    const srmFilename = `${romName}.srm`;
+
+    // Use cached directory listing for O(1) lookup
+    const listing = getCachedDirectoryListing(dir, this.cache);
+    const mtime = listing.get(srmFilename);
+    if (mtime) {
+      return { exists: true, date: mtime, path: join(dir, srmFilename) };
+    }
+
+    return { exists: false };
+  }
+}

package/src/frontend/serviceProvider/index.ts

@@ -0,0 +1,108 @@
+/**
+ * Service Provider
+ *
+ * Centralized service management for both React and non-React code.
+ * Services are initialized once with config and can be accessed anywhere.
+ *
+ * Usage:
+ *   // At app startup (CLI or React app mount)
+ *   initializeServices(config);
+ *
+ *   // Anywhere in the codebase
+ *   const saveStateService = getSaveStateService();
+ *   const path = saveStateService.findExistingStatePath(romPath);
+ */
+
+import type { Config } from '../config';
+import { getPlaylistsDirectory } from '../config';
+import { SaveStateService, BatterySaveService } from '../saveServices';
+import { buildCrcCacheFromDirectory, type CrcCache } from '../playlist';
+import { ServiceError } from './types';
+
+/** Current config (set at initialization) */
+let currentConfig: Config | null = null;
+
+/** Singleton service instances */
+let saveStateService: SaveStateService | null = null;
+let batterySaveService: BatterySaveService | null = null;
+
+/**
+ * Initialize services with config.
+ * Call this once at app startup before using any services.
+ */
+export const initializeServices = (config: Config): void => {
+  currentConfig = config;
+  saveStateService = new SaveStateService(config);
+  batterySaveService = new BatterySaveService(config);
+};
+
+/**
+ * Update services with new config.
+ * Call this when config changes (e.g., settings update).
+ */
+export const updateServices = (config: Config): void => {
+  currentConfig = config;
+  saveStateService = new SaveStateService(config);
+  batterySaveService = new BatterySaveService(config);
+};
+
+/**
+ * Get the current config.
+ * Returns null if services haven't been initialized.
+ */
+export const getConfig = (): Config | null => currentConfig;
+
+/**
+ * Get the SaveStateService instance.
+ * Throws if services haven't been initialized.
+ */
+export const getSaveStateService = (): SaveStateService => {
+  if (!saveStateService) {
+    throw new ServiceError('NOT_INITIALIZED');
+  }
+  return saveStateService;
+};
+
+/**
+ * Get the BatterySaveService instance.
+ * Throws if services haven't been initialized.
+ */
+export const getBatterySaveService = (): BatterySaveService => {
+  if (!batterySaveService) {
+    throw new ServiceError('NOT_INITIALIZED');
+  }
+  return batterySaveService;
+};
+
+/**
+ * Check if services have been initialized.
+ */
+export const areServicesInitialized = (): boolean => {
+  return currentConfig !== null && saveStateService !== null && batterySaveService !== null;
+};
+
+/**
+ * Get the playlist directory from config.
+ * Throws if services haven't been initialized.
+ */
+export const getPlaylistDirectory = (): string => {
+  if (!currentConfig) {
+    throw new ServiceError('NOT_INITIALIZED');
+  }
+  return getPlaylistsDirectory(currentConfig);
+};
+
+/**
+ * Build a CRC cache from all playlists in the configured playlist directory.
+ * This avoids recalculating CRC32s for ROMs that are already in playlists.
+ * Returns an empty map if services haven't been initialized.
+ */
+export const buildCrcCache = (): CrcCache => {
+  if (!currentConfig) {
+    return new Map();
+  }
+  const playlistDir = getPlaylistsDirectory(currentConfig);
+  return buildCrcCacheFromDirectory(playlistDir);
+};
+
+export * from "./types";

package/src/frontend/serviceProvider/types.ts

@@ -0,0 +1,13 @@
+/**
+ * Service provider error types
+ */
+
+import { createTypedError } from '../../utils/typedError';
+
+export type ServiceErrorCode =
+  | 'NOT_INITIALIZED';
+
+const { TypedError, isTypedError } = createTypedError<ServiceErrorCode>('ServiceError');
+export const ServiceError = TypedError;
+export type ServiceError = InstanceType<typeof TypedError>;
+export const isServiceError = isTypedError;