Sync live quote handling, SSE product images, store hours, file URL normalization, PWA icon cache, TV monitor, about software, SuperAdmin menu gates, price alerts, and related UX from modular while preserving boursecu branding and config constraints. Co-authored-by: Cursor <cursoragent@cursor.com>
343 lines
9.0 KiB
TypeScript
343 lines
9.0 KiB
TypeScript
import type { AppConfig } from '@/config/types'
|
|
import { resetVersionCheckCache } from '@/config/load-version'
|
|
import { clearCachedPwaManifest } from '@/modules/pwa/manifest-cache'
|
|
import { resolveTenantDomain } from '@/config/superadmin'
|
|
import { collectAuthTokensForPreserve } from '@/utils/authToken'
|
|
|
|
const CONFIG_COOKIE_NAME = 'APP_CONFIG_CACHE'
|
|
const APP_CONFIG_LS_KEY = 'APP_CONFIG_LS_CACHE'
|
|
const CONFIG_SUCCESS_URL_KEY = 'CONFIG_Success_URL'
|
|
const VERSION_SUCCESS_URL_KEY = 'VERSION_Success_URL'
|
|
const CONFIG_COOKIE_MAX_AGE_SECONDS = 60 * 60 * 24 * 7
|
|
const MAX_COOKIE_VALUE_LENGTH = 3500
|
|
|
|
const VERSION_STORAGE_KEY = 'version'
|
|
const VERSION_UPDATE_LOCK_KEY = 'version_update_lock'
|
|
const VERSION_LAST_RELOAD_KEY = 'version_last_reload'
|
|
|
|
type CachedConfigPayload = {
|
|
cached_at: number
|
|
config: AppConfig
|
|
}
|
|
|
|
export type VersionedAppConfigCache = {
|
|
version: string
|
|
domain: string
|
|
cached_at: number
|
|
config: AppConfig
|
|
}
|
|
|
|
type VersionUpdateLock = {
|
|
version: string
|
|
started_at: number
|
|
}
|
|
|
|
function getCookie(name: string) {
|
|
const cookie = document.cookie.split('; ').find((row) => row.startsWith(`${name}=`))
|
|
|
|
if (!cookie) return null
|
|
|
|
return cookie.substring(name.length + 1)
|
|
}
|
|
|
|
function setCookie(name: string, value: string, maxAgeSeconds: number) {
|
|
const secure = window.location.protocol === 'https:' ? '; Secure' : ''
|
|
|
|
document.cookie = [
|
|
`${name}=${value}`,
|
|
'Path=/',
|
|
`Max-Age=${maxAgeSeconds}`,
|
|
'SameSite=Lax',
|
|
secure
|
|
].join('; ')
|
|
}
|
|
|
|
export function readCachedAppConfig(): AppConfig | null {
|
|
try {
|
|
const rawCookie = getCookie(CONFIG_COOKIE_NAME)
|
|
|
|
if (!rawCookie) return null
|
|
|
|
const decoded = decodeURIComponent(rawCookie)
|
|
const payload = JSON.parse(decoded) as CachedConfigPayload
|
|
|
|
if (!payload?.config) return null
|
|
|
|
return payload.config
|
|
} catch (error) {
|
|
console.warn('Failed to read cached app config:', error)
|
|
clearCachedAppConfig()
|
|
return null
|
|
}
|
|
}
|
|
|
|
/** کش بزرگ get_user در localStorage — با version باطل میشود */
|
|
export function readVersionedAppConfigCache(domain?: string): VersionedAppConfigCache | null {
|
|
try {
|
|
const raw = localStorage.getItem(APP_CONFIG_LS_KEY)
|
|
if (!raw) return null
|
|
|
|
const payload = JSON.parse(raw) as VersionedAppConfigCache
|
|
if (!payload?.config || !payload.version) return null
|
|
|
|
if (domain && payload.domain && payload.domain !== domain) {
|
|
return null
|
|
}
|
|
|
|
return payload
|
|
} catch (error) {
|
|
console.warn('Failed to read versioned app config cache:', error)
|
|
clearVersionedAppConfigCache()
|
|
return null
|
|
}
|
|
}
|
|
|
|
export function writeVersionedAppConfigCache(
|
|
config: AppConfig,
|
|
version: string,
|
|
domain: string,
|
|
) {
|
|
const normalizedVersion = String(version || '').trim()
|
|
if (!normalizedVersion) return
|
|
|
|
try {
|
|
const payload: VersionedAppConfigCache = {
|
|
version: normalizedVersion,
|
|
domain: String(domain || '').trim(),
|
|
cached_at: Date.now(),
|
|
config,
|
|
}
|
|
localStorage.setItem(APP_CONFIG_LS_KEY, JSON.stringify(payload))
|
|
} catch (error) {
|
|
console.warn('Failed to write versioned app config cache:', error)
|
|
}
|
|
|
|
writeCachedAppConfig(config)
|
|
}
|
|
|
|
export function clearVersionedAppConfigCache() {
|
|
localStorage.removeItem(APP_CONFIG_LS_KEY)
|
|
}
|
|
|
|
export function writeCachedAppConfig(config: AppConfig) {
|
|
try {
|
|
const payload: CachedConfigPayload = {
|
|
cached_at: Date.now(),
|
|
config
|
|
}
|
|
|
|
const encoded = encodeURIComponent(JSON.stringify(payload))
|
|
|
|
if (encoded.length > MAX_COOKIE_VALUE_LENGTH) {
|
|
console.warn(`App config is too large for cookie cache. Size: ${encoded.length}`)
|
|
return
|
|
}
|
|
|
|
setCookie(CONFIG_COOKIE_NAME, encoded, CONFIG_COOKIE_MAX_AGE_SECONDS)
|
|
} catch (error) {
|
|
console.warn('Failed to write app config cache:', error)
|
|
}
|
|
}
|
|
|
|
export function clearCachedAppConfig() {
|
|
document.cookie = `${CONFIG_COOKIE_NAME}=; Path=/; Max-Age=0; SameSite=Lax`
|
|
clearVersionedAppConfigCache()
|
|
clearCachedPwaManifest()
|
|
}
|
|
|
|
export function getStoredAppVersion() {
|
|
return localStorage.getItem(VERSION_STORAGE_KEY)
|
|
}
|
|
|
|
export function getDisplayAppVersion(fallbackVersion: string) {
|
|
return getStoredAppVersion() || fallbackVersion
|
|
}
|
|
|
|
export function writeStoredAppVersion(version: string) {
|
|
localStorage.setItem(VERSION_STORAGE_KEY, String(version).trim())
|
|
}
|
|
|
|
export function getNormalizedVersion(version: unknown) {
|
|
if (version === null || version === undefined) return ''
|
|
return String(version).trim()
|
|
}
|
|
|
|
export function shouldUpdateForVersion(serverVersion: unknown) {
|
|
const normalizedServerVersion = getNormalizedVersion(serverVersion)
|
|
|
|
if (!normalizedServerVersion) return false
|
|
|
|
const storedVersion = getStoredAppVersion()
|
|
|
|
if (!storedVersion) {
|
|
writeStoredAppVersion(normalizedServerVersion)
|
|
return false
|
|
}
|
|
|
|
return storedVersion !== normalizedServerVersion
|
|
}
|
|
|
|
export function canStartVersionUpdate(serverVersion: string) {
|
|
const version = getNormalizedVersion(serverVersion)
|
|
|
|
if (!version) return false
|
|
|
|
const lastReloadVersion = sessionStorage.getItem(VERSION_LAST_RELOAD_KEY)
|
|
|
|
if (lastReloadVersion === version) {
|
|
return false
|
|
}
|
|
|
|
const rawLock = sessionStorage.getItem(VERSION_UPDATE_LOCK_KEY)
|
|
|
|
if (rawLock) {
|
|
try {
|
|
const lock = JSON.parse(rawLock) as VersionUpdateLock
|
|
const isSameVersion = lock.version === version
|
|
const isFreshLock = Date.now() - lock.started_at < 60_000
|
|
|
|
if (isSameVersion && isFreshLock) {
|
|
return false
|
|
}
|
|
} catch {
|
|
sessionStorage.removeItem(VERSION_UPDATE_LOCK_KEY)
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
export function startVersionUpdateLock(serverVersion: string) {
|
|
const version = getNormalizedVersion(serverVersion)
|
|
|
|
const lock: VersionUpdateLock = {
|
|
version,
|
|
started_at: Date.now()
|
|
}
|
|
|
|
sessionStorage.setItem(VERSION_UPDATE_LOCK_KEY, JSON.stringify(lock))
|
|
}
|
|
|
|
export function finishVersionUpdateBeforeReload(serverVersion: string) {
|
|
const version = getNormalizedVersion(serverVersion)
|
|
|
|
writeStoredAppVersion(version)
|
|
|
|
sessionStorage.setItem(VERSION_LAST_RELOAD_KEY, version)
|
|
sessionStorage.removeItem(VERSION_UPDATE_LOCK_KEY)
|
|
}
|
|
|
|
export function cancelVersionUpdateLock() {
|
|
sessionStorage.removeItem(VERSION_UPDATE_LOCK_KEY)
|
|
}
|
|
|
|
function clearReadableCookiesExceptConfigAlreadyHandled() {
|
|
document.cookie.split(';').forEach((cookie) => {
|
|
const name = cookie.split('=')[0]?.trim()
|
|
|
|
if (!name) return
|
|
|
|
document.cookie = `${name}=; Path=/; Max-Age=0; SameSite=Lax`
|
|
})
|
|
}
|
|
|
|
export async function clearBrowserRuntimeCaches() {
|
|
try {
|
|
if ('serviceWorker' in navigator) {
|
|
const registrations = await navigator.serviceWorker.getRegistrations()
|
|
|
|
await Promise.all(registrations.map((registration) => registration.unregister()))
|
|
}
|
|
} catch (error) {
|
|
console.warn('Could not unregister service workers:', error)
|
|
}
|
|
|
|
try {
|
|
if (!('caches' in window)) return
|
|
|
|
const cacheKeys = await caches.keys()
|
|
await Promise.all(cacheKeys.map((key) => caches.delete(key)))
|
|
} catch (error) {
|
|
console.warn('Could not clear browser caches:', error)
|
|
}
|
|
}
|
|
|
|
function clearLocalStorageExceptToken() {
|
|
const preserved = collectAuthTokensForPreserve()
|
|
|
|
localStorage.clear()
|
|
|
|
for (const [key, value] of Object.entries(preserved)) {
|
|
localStorage.setItem(key, value)
|
|
}
|
|
}
|
|
|
|
export function clearAppStorageExceptToken() {
|
|
clearReadableCookiesExceptConfigAlreadyHandled()
|
|
clearLocalStorageExceptToken()
|
|
sessionStorage.clear()
|
|
}
|
|
|
|
export function clearAllBootstrapFetchCaches() {
|
|
localStorage.removeItem(CONFIG_SUCCESS_URL_KEY)
|
|
localStorage.removeItem(VERSION_SUCCESS_URL_KEY)
|
|
clearVersionedAppConfigCache()
|
|
clearCachedPwaManifest()
|
|
resetVersionCheckCache()
|
|
window.__APP_CONFIG__ = undefined
|
|
}
|
|
|
|
export function hardReloadApp() {
|
|
const refreshUrl = `${window.location.origin}${window.location.pathname}?__app_refresh=${Date.now()}`
|
|
window.location.href = refreshUrl
|
|
}
|
|
|
|
export async function refreshConfigCacheForVersion(
|
|
newVersion: string,
|
|
fetchConfig: () => Promise<AppConfig>
|
|
) {
|
|
const normalizedVersion = getNormalizedVersion(newVersion)
|
|
|
|
if (!normalizedVersion) {
|
|
throw new Error('Version is empty')
|
|
}
|
|
|
|
startVersionUpdateLock(normalizedVersion)
|
|
|
|
const freshConfig = await fetchConfig()
|
|
|
|
clearCachedAppConfig()
|
|
clearAppStorageExceptToken()
|
|
clearAllBootstrapFetchCaches()
|
|
await clearBrowserRuntimeCaches()
|
|
|
|
writeCachedAppConfig(freshConfig)
|
|
writeVersionedAppConfigCache(freshConfig, normalizedVersion, resolveTenantDomain())
|
|
finishVersionUpdateBeforeReload(normalizedVersion)
|
|
|
|
return freshConfig
|
|
}
|
|
|
|
export async function resetAppAndRefreshConfig(
|
|
fetchConfig: () => Promise<AppConfig>,
|
|
version?: string | null
|
|
) {
|
|
const normalizedVersion = getNormalizedVersion(version)
|
|
|
|
const freshConfig = await fetchConfig()
|
|
|
|
clearCachedAppConfig()
|
|
clearAppStorageExceptToken()
|
|
clearAllBootstrapFetchCaches()
|
|
await clearBrowserRuntimeCaches()
|
|
|
|
writeCachedAppConfig(freshConfig)
|
|
|
|
if (normalizedVersion) {
|
|
writeStoredAppVersion(normalizedVersion)
|
|
writeVersionedAppConfigCache(freshConfig, normalizedVersion, resolveTenantDomain())
|
|
}
|
|
|
|
return freshConfig
|
|
}
|