// The browser's project library: several projects in localStorage, each // with its own entry, plus an index with names and share links. import { parseProject } from './project' import type { Project } from './types' export interface ShareLink { id: string /** Edit key; only the person who created the link has it. */ key?: string } export interface ProjectMeta { id: string name: string updated: number link?: ShareLink /** Set once the project is stored in an account: whose, and which revision this browser has. */ cloud?: { owner: string; rev: number } /** Changed here since the last upload to the account. */ dirty?: boolean /** The example project a new browser starts with, never touched yet. */ starter?: boolean } export interface AccountUser { id: string email: string } const INDEX = 'logigate:projects' const CURRENT = 'logigate:current' const LEGACY = 'logigate:project:v1' const ACCOUNT = 'logigate:account' const PENDING_DELETES = 'logigate:pending-deletes' const entry = (id: string) => `logigate:p:${id}` function read(key: string): string | null { try { return localStorage.getItem(key) } catch { return null } } function write(key: string, value: string): boolean { try { localStorage.setItem(key, value) return true } catch { return false } } export function newLocalId(): string { return Math.random().toString(36).slice(2, 10) } export function listProjects(): ProjectMeta[] { try { const list = JSON.parse(read(INDEX) ?? '[]') as ProjectMeta[] return Array.isArray(list) ? list.filter(m => m && typeof m.id === 'string') : [] } catch { return [] } } function writeIndex(list: ProjectMeta[]) { write(INDEX, JSON.stringify(list)) } export function loadProject(id: string): Project | null { const raw = read(entry(id)) if (!raw) return null try { return parseProject(raw) } catch { return null } } /** Saves a project and its index entry. Returns false when storage is full or blocked. */ export function saveProject(meta: ProjectMeta, project: Project): boolean { const ok = write(entry(meta.id), JSON.stringify(project)) const list = listProjects().filter(m => m.id !== meta.id) list.unshift(meta) writeIndex(list) return ok } export function saveMeta(meta: ProjectMeta) { writeIndex(listProjects().map(m => (m.id === meta.id ? meta : m))) } export function removeProject(id: string) { try { localStorage.removeItem(entry(id)) } catch {} writeIndex(listProjects().filter(m => m.id !== id)) } export function currentId(): string | null { return read(CURRENT) } export function setCurrentId(id: string) { write(CURRENT, id) } /** Moves the single project of the first version into the library. */ export function migrateLegacy(): void { const raw = read(LEGACY) if (!raw || listProjects().length) return try { const project = parseProject(raw) if (project.name === 'Untitled') project.name = 'My first project' const meta: ProjectMeta = { id: newLocalId(), name: project.name, updated: Date.now() } if (saveProject(meta, project)) { setCurrentId(meta.id) localStorage.removeItem(LEGACY) } } catch {} } /** The account this browser was last signed in to, so the UI knows before the server answers. */ export function cachedAccount(): AccountUser | null { try { const a = JSON.parse(read(ACCOUNT) ?? 'null') as AccountUser | null return a && typeof a.id === 'string' ? a : null } catch { return null } } export function setCachedAccount(user: AccountUser | null) { if (user) write(ACCOUNT, JSON.stringify(user)) else try { localStorage.removeItem(ACCOUNT) } catch {} } /** Account projects deleted while offline, to delete on the server at the next sync. */ export function pendingDeletes(): { owner: string; id: string }[] { try { const list = JSON.parse(read(PENDING_DELETES) ?? '[]') return Array.isArray(list) ? list : [] } catch { return [] } } export function setPendingDeletes(list: { owner: string; id: string }[]) { write(PENDING_DELETES, JSON.stringify(list)) }