Files
simple-aircraft-manager-rails/app/javascript/controllers/offline_prep_controller.js
T
rickyandClaude Opus 5.5 d9de1be562 Connection status in the top bar, as SilverBullet does
- The top bar (and the phone's status bar) turns red when the server
  can't be reached: the device is offline, or a request failed (signal
  but no internet, or the proxy answering for the app). While red it
  checks /up every 15 seconds and turns back on its own.
- A ring fills while pages are saved for offline use or flights and
  squawks logged offline are sent, with the percentage in its middle,
  and hides when done. While some wait to send, it's amber with how many.

Checked on an Android 14 emulator: airplane mode on and off, saving for
offline, and a flight logged offline then sent.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 13:15:50 -05:00

81 lines
3.8 KiB
JavaScript

import { Controller } from "@hotwired/stimulus"
import { currentUser } from "controllers/offline_queue"
// Saves, ahead of time, what's needed to work without signal: the Fleet page
// and, for each of your aircraft, its Overview, W&B, Log Flight and Report
// Squawk pages (fetching them through the service worker keeps a copy, see
// service-worker.js) and its photo (kept in sam-images, shown when offline). Done in the background at most once an hour, or when
// your aircraft change. Signing out clears it.
const EVERY = 60 * 60 * 1000
// How far along it is, for the ring in the top bar (connection_controller.js).
const progress = (done, total) => document.dispatchEvent(new CustomEvent("sam:progress", { detail: { source: "prep", done, total } }))
export default class extends Controller {
static values = { aircraft: Array }
connect() {
if (!navigator.onLine || !("serviceWorker" in navigator)) return
navigator.serviceWorker.ready.then(() => this.prepare()).catch(() => {})
}
async prepare() {
const signature = `${currentUser()}:${JSON.stringify(this.aircraftValue)}`
let last = {}
try { last = JSON.parse(localStorage.getItem("sam-offline-prep") || "{}") } catch (_) { /* storage off */ }
if (last.signature === signature && Date.now() - last.at < EVERY) return
if (!navigator.serviceWorker.controller) return // first visit: the worker takes over on the next page
const forms = {}
const paths = [ "/" ]
for (const a of this.aircraftValue) {
paths.push(...a.pages, a.flight, a.squawk)
forms[a.flight] = { tail: a.tail, kind: "flight" }
forms[a.squawk] = { tail: a.tail, kind: "squawk" }
}
const pictures = this.aircraftValue.flatMap((a) => a.pictures || [])
const total = paths.length + 1
try {
for (const [ index, path ] of paths.entries()) {
progress(index, total)
if (!navigator.onLine) return
// One at a time, after the page has settled, so it never competes with what you're doing.
await new Promise((resolve) => (window.requestIdleCallback || setTimeout)(resolve, { timeout: 2000 }))
try { await fetch(path, { credentials: "same-origin", headers: { Accept: "text/html" } }) } catch (_) {
document.dispatchEvent(new CustomEvent("sam:unreachable"))
return
}
}
progress(paths.length, total)
await this.savePictures(pictures)
} finally { progress(total, total) }
try {
localStorage.setItem("sam-offline-forms", JSON.stringify({ ...JSON.parse(localStorage.getItem("sam-offline-forms") || "{}"), ...forms }))
localStorage.setItem("sam-offline-prep", JSON.stringify({ signature, at: Date.now() }))
} catch (_) { /* storage off */ }
}
// The aircraft photos: refreshed, and those of aircraft you no longer have dropped.
async savePictures(urls) {
try {
const cache = await caches.open("sam-images")
const wanted = urls.map((url) => [ url, imageKey(url) ]).filter(([ , key ]) => key)
for (const request of await cache.keys()) if (!wanted.some(([ , key ]) => key === request.url)) await cache.delete(request)
for (const [ url, key ] of wanted) {
const response = await fetch(url, { credentials: "same-origin" }).catch(() => null)
if (response?.ok) await cache.put(key, response)
}
} catch (_) { /* no Cache API */ }
}
}
// Photo links carry an expiry, so they change with every page; the saved copy
// is filed under the upload's id (and size) instead (same rule in service-worker.js).
function imageKey(url) {
try {
const [ , signed, size ] = new URL(url, location.origin).pathname.match(/\/(?:blobs|representations)\/redirect\/([^/]+?)--[^/]+\/(?:([^/]+)\/)?/)
const id = JSON.parse(atob(decodeURIComponent(signed)))._rails.data
return `${location.origin}/offline-image/${id}${size ? `/${size}` : ""}`
} catch (_) { return null }
}