同步 sgs-frontend-mobile 源码
Some checks failed
CI / verify (push) Has been cancelled

This commit is contained in:
lyf
2026-07-27 11:26:01 +08:00
parent 575dca430f
commit 9ea1bfab71
181 changed files with 24395 additions and 5212 deletions

View File

@@ -0,0 +1,147 @@
const CACHE_NAME = 'sgs-guide-model-v1'
const INDEX_STORAGE_KEY = 'sgs.guide.model-cache-index.v1'
const MAX_ENTRIES = 6
interface CacheIndexEntry {
key: string
touchedAt: number
}
export interface PersistentModelAsset {
url: string
release: () => void
}
const getCacheStorage = () => (
typeof globalThis !== 'undefined' && 'caches' in globalThis
? globalThis.caches
: null
)
const getStorage = () => (
typeof localStorage !== 'undefined' ? localStorage : null
)
const buildCacheKey = (url: string, version?: string) => {
const normalizedUrl = url.trim()
const normalizedVersion = version?.trim() || normalizedUrl
const separator = normalizedUrl.includes('?') ? '&' : '?'
return `${normalizedUrl}${separator}__sgs_model_version=${encodeURIComponent(normalizedVersion)}`
}
const readIndex = (): CacheIndexEntry[] => {
try {
const raw = getStorage()?.getItem(INDEX_STORAGE_KEY)
const parsed = raw ? JSON.parse(raw) : []
return Array.isArray(parsed)
? parsed.filter((entry): entry is CacheIndexEntry => (
Boolean(entry)
&& typeof entry.key === 'string'
&& typeof entry.touchedAt === 'number'
))
: []
} catch {
return []
}
}
const writeIndex = (entries: CacheIndexEntry[]) => {
try {
getStorage()?.setItem(INDEX_STORAGE_KEY, JSON.stringify(entries))
} catch {
// Persistent cache is an optimization. Storage quota failures must not block map loading.
}
}
const touchIndex = (key: string) => {
const now = Date.now()
const next = readIndex()
.filter((entry) => entry.key !== key)
next.push({ key, touchedAt: now })
writeIndex(next)
return next
}
const removeFromIndex = (key: string) => {
writeIndex(readIndex().filter((entry) => entry.key !== key))
}
export class GuideModelPersistentCache {
async get(url: string, version?: string): Promise<PersistentModelAsset | null> {
const cacheStorage = getCacheStorage()
if (!cacheStorage || typeof URL === 'undefined' || typeof URL.createObjectURL !== 'function') return null
const key = buildCacheKey(url, version)
try {
const cache = await cacheStorage.open(CACHE_NAME)
const response = await cache.match(key)
if (!response) return null
const blob = await response.blob()
if (!blob.size) {
await cache.delete(key)
removeFromIndex(key)
return null
}
touchIndex(key)
const objectUrl = URL.createObjectURL(blob)
return {
url: objectUrl,
release: () => URL.revokeObjectURL(objectUrl)
}
} catch {
return null
}
}
async store(url: string, version?: string): Promise<void> {
const cacheStorage = getCacheStorage()
if (!cacheStorage || typeof fetch !== 'function') return
const key = buildCacheKey(url, version)
try {
const cache = await cacheStorage.open(CACHE_NAME)
if (await cache.match(key)) {
await this.prune(cache, touchIndex(key))
return
}
// The preceding GLTF request is normally still in the browser HTTP cache, so this does
// not redownload a successful asset on standard H5 browsers.
const response = await fetch(url, { cache: 'force-cache' })
if (!response.ok || !response.body) return
await cache.put(key, response)
await this.prune(cache, touchIndex(key))
} catch {
// Cache writes are deliberately best-effort.
}
}
async remove(url: string, version?: string): Promise<void> {
const cacheStorage = getCacheStorage()
if (!cacheStorage) return
const key = buildCacheKey(url, version)
try {
const cache = await cacheStorage.open(CACHE_NAME)
await cache.delete(key)
} catch {
// Ignore cache cleanup failures and continue with a normal network request.
}
removeFromIndex(key)
}
private async prune(cache: Cache, entries: CacheIndexEntry[]) {
const staleEntries = [...entries]
.sort((left, right) => left.touchedAt - right.touchedAt)
.slice(0, Math.max(0, entries.length - MAX_ENTRIES))
if (!staleEntries.length) return
await Promise.all(staleEntries.map((entry) => cache.delete(entry.key)))
const staleKeys = new Set(staleEntries.map((entry) => entry.key))
writeIndex(entries.filter((entry) => !staleKeys.has(entry.key)))
}
}
export const guideModelPersistentCache = new GuideModelPersistentCache()