brief-rags-bench/static/js/data/storage.js

/**
 * Storage Service
 *
 * Обертка над localStorage для работы с данными приложения.
 */

import { STORAGE_KEYS } from '../config.js'

/**
 * Save environment data to localStorage
 * @param {string} env - Environment name ('ift', 'psi', 'prod')
 * @param {object} data - Environment data to save
 */
export function saveEnvironmentData(env, data) {
  try {
    const key = STORAGE_KEYS.envData(env)
    localStorage.setItem(key, JSON.stringify(data))
  } catch (e) {
    console.error(`Failed to save data for environment ${env}:`, e)
  }
}

/**
 * Load environment data from localStorage
 * @param {string} env - Environment name ('ift', 'psi', 'prod')
 * @returns {object|null} Environment data or null if not found
 */
export function loadEnvironmentData(env) {
  try {
    const key = STORAGE_KEYS.envData(env)
    const savedData = localStorage.getItem(key)

    if (!savedData) {
      return null
    }

    return JSON.parse(savedData)
  } catch (e) {
    console.error(`Failed to load data for environment ${env}:`, e)
    return null
  }
}

/**
 * Clear environment data from localStorage
 * @param {string} env - Environment name ('ift', 'psi', 'prod')
 */
export function clearEnvironmentData(env) {
  try {
    const key = STORAGE_KEYS.envData(env)
    localStorage.removeItem(key)
  } catch (e) {
    console.error(`Failed to clear data for environment ${env}:`, e)
  }
}

/**
 * Clear all environment data
 */
export function clearAllEnvironmentData() {
  const environments = ['ift', 'psi', 'prod']
  environments.forEach(env => clearEnvironmentData(env))
}

/**
 * Save token to localStorage
 * @param {string} token - JWT token
 */
export function saveToken(token) {
  try {
    localStorage.setItem(STORAGE_KEYS.token, token)
  } catch (e) {
    console.error('Failed to save token:', e)
  }
}

/**
 * Load token from localStorage
 * @returns {string|null} JWT token or null if not found
 */
export function loadToken() {
  try {
    return localStorage.getItem(STORAGE_KEYS.token)
  } catch (e) {
    console.error('Failed to load token:', e)
    return null
  }
}

/**
 * Clear token from localStorage
 */
export function clearToken() {
  try {
    localStorage.removeItem(STORAGE_KEYS.token)
  } catch (e) {
    console.error('Failed to clear token:', e)
  }
}

/**
 * Save user info to localStorage
 * @param {object} user - User object
 */
export function saveUser(user) {
  try {
    localStorage.setItem(STORAGE_KEYS.user, JSON.stringify(user))
  } catch (e) {
    console.error('Failed to save user:', e)
  }
}

/**
 * Load user info from localStorage
 * @returns {object|null} User object or null if not found
 */
export function loadUser() {
  try {
    const userData = localStorage.getItem(STORAGE_KEYS.user)
    return userData ? JSON.parse(userData) : null
  } catch (e) {
    console.error('Failed to load user:', e)
    return null
  }
}

/**
 * Clear user info from localStorage
 */
export function clearUser() {
  try {
    localStorage.removeItem(STORAGE_KEYS.user)
  } catch (e) {
    console.error('Failed to clear user:', e)
  }
}

/**
 * Save settings to localStorage
 * @param {object} settings - Settings object
 */
export function saveSettings(settings) {
  try {
    localStorage.setItem(STORAGE_KEYS.settings, JSON.stringify(settings))
  } catch (e) {
    console.error('Failed to save settings:', e)
  }
}

/**
 * Load settings from localStorage
 * @returns {object|null} Settings object or null if not found
 */
export function loadSettings() {
  try {
    const settingsData = localStorage.getItem(STORAGE_KEYS.settings)
    return settingsData ? JSON.parse(settingsData) : null
  } catch (e) {
    console.error('Failed to load settings:', e)
    return null
  }
}

/**
 * Clear settings from localStorage
 */
export function clearSettings() {
  try {
    localStorage.removeItem(STORAGE_KEYS.settings)
  } catch (e) {
    console.error('Failed to clear settings:', e)
  }
}

/**
 * Save annotation draft to localStorage
 * @param {object} draft - Annotation draft object
 */
export function saveAnnotationDraft(draft) {
  try {
    localStorage.setItem(STORAGE_KEYS.annotations, JSON.stringify(draft))
  } catch (e) {
    console.error('Failed to save annotation draft:', e)
  }
}

/**
 * Load annotation draft from localStorage
 * @returns {object|null} Annotation draft or null if not found
 */
export function loadAnnotationDraft() {
  try {
    const draftData = localStorage.getItem(STORAGE_KEYS.annotations)
    return draftData ? JSON.parse(draftData) : null
  } catch (e) {
    console.error('Failed to load annotation draft:', e)
    return null
  }
}

/**
 * Clear annotation draft from localStorage
 */
export function clearAnnotationDraft() {
  try {
    localStorage.removeItem(STORAGE_KEYS.annotations)
  } catch (e) {
    console.error('Failed to clear annotation draft:', e)
  }
}

/**
 * Clear all data from localStorage
 */
export function clearAllData() {
  try {
    clearToken()
    clearUser()
    clearSettings()
    clearAllEnvironmentData()
    clearAnnotationDraft()
  } catch (e) {
    console.error('Failed to clear all data:', e)
  }
}