You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1067 lines
39 KiB
1067 lines
39 KiB
import { |
|
DEFAULT_NIP_96_SERVICE, |
|
ExtendedKind, |
|
MEDIA_AUTO_LOAD_POLICY, |
|
NOTIFICATION_LIST_STYLE, |
|
DEFAULT_FEED_SHOW_KINDS, |
|
StorageKey |
|
} from '@/constants' |
|
import { kinds } from 'nostr-tools' |
|
import { isSameAccount } from '@/lib/account' |
|
import { randomString } from '@/lib/random' |
|
import { |
|
TAccount, |
|
TAccountPointer, |
|
TFeedInfo, |
|
TFontSize, |
|
TMediaAutoLoadPolicy, |
|
TMediaUploadServiceConfig, |
|
TNoteListMode, |
|
TNotificationStyle, |
|
TRelaySet, |
|
TTheme, |
|
TThemeSetting, |
|
} from '@/types' |
|
import indexedDb from './indexed-db.service' |
|
|
|
/** Keys we persist to IndexedDB (and migrate from localStorage when IDB is empty). */ |
|
const SETTINGS_KEYS = [ |
|
StorageKey.RELAY_SETS, |
|
StorageKey.THEME_SETTING, |
|
StorageKey.THEME, |
|
StorageKey.ADD_CLIENT_TAG, |
|
StorageKey.FONT_SIZE, |
|
StorageKey.NOTE_LIST_MODE, |
|
StorageKey.ACCOUNTS, |
|
StorageKey.CURRENT_ACCOUNT, |
|
StorageKey.DEFAULT_ZAP_SATS, |
|
StorageKey.DEFAULT_ZAP_COMMENT, |
|
StorageKey.QUICK_ZAP, |
|
StorageKey.ZAP_REPLY_THRESHOLD, |
|
StorageKey.ACCOUNT_FEED_INFO_MAP, |
|
StorageKey.AUTOPLAY, |
|
StorageKey.HIDE_UNTRUSTED_INTERACTIONS, |
|
StorageKey.HIDE_UNTRUSTED_NOTIFICATIONS, |
|
StorageKey.HIDE_UNTRUSTED_NOTES, |
|
StorageKey.MEDIA_UPLOAD_SERVICE_CONFIG_MAP, |
|
StorageKey.DEFAULT_SHOW_NSFW, |
|
StorageKey.DISMISSED_TOO_MANY_RELAYS_ALERT, |
|
StorageKey.SHOW_KINDS, |
|
StorageKey.SHOW_KINDS_VERSION, |
|
StorageKey.SHOW_KIND_1_OPs, |
|
StorageKey.SHOW_KIND_1_REPLIES, |
|
StorageKey.SHOW_KIND_1111, |
|
StorageKey.FEED_KIND_FILTER_BYPASS, |
|
StorageKey.HIDE_CONTENT_MENTIONING_MUTED_USERS, |
|
StorageKey.NOTIFICATION_LIST_STYLE, |
|
StorageKey.MEDIA_AUTO_LOAD_POLICY, |
|
StorageKey.SHOWN_CREATE_WALLET_GUIDE_TOAST_PUBKEYS, |
|
StorageKey.SHOW_RECOMMENDED_RELAYS_PANEL, |
|
StorageKey.ADD_RANDOM_RELAYS_TO_PUBLISH, |
|
StorageKey.SHOW_PUBLISH_SUCCESS_TOASTS, |
|
StorageKey.SHOW_LIVE_ACTIVITIES_BANNER, |
|
StorageKey.DEFAULT_EXPIRATION_ENABLED, |
|
StorageKey.DEFAULT_EXPIRATION_MONTHS, |
|
StorageKey.DEFAULT_QUIET_ENABLED, |
|
StorageKey.DEFAULT_QUIET_DAYS, |
|
StorageKey.RESPECT_QUIET_TAGS, |
|
StorageKey.GLOBAL_QUIET_MODE, |
|
StorageKey.SHOW_RSS_FEED, |
|
StorageKey.PANE_MODE |
|
] as const |
|
|
|
class LocalStorageService { |
|
static instance: LocalStorageService |
|
|
|
private relaySets: TRelaySet[] = [] |
|
private themeSetting: TThemeSetting = 'system' |
|
private theme: TTheme = 'light' |
|
private addClientTag: boolean = true |
|
private fontSize: TFontSize = 'medium' |
|
private accounts: TAccount[] = [] |
|
private currentAccount: TAccount | null = null |
|
private noteListMode: TNoteListMode = 'posts' |
|
private defaultZapSats: number = 21 |
|
private defaultZapComment: string = 'Zap!' |
|
private quickZap: boolean = false |
|
private zapReplyThreshold: number = 1 |
|
private accountFeedInfoMap: Record<string, TFeedInfo | undefined> = {} |
|
private mediaUploadService: string = DEFAULT_NIP_96_SERVICE |
|
private autoplay: boolean = true |
|
private hideUntrustedInteractions: boolean = false |
|
private hideUntrustedNotifications: boolean = false |
|
private hideUntrustedNotes: boolean = false |
|
private mediaUploadServiceConfigMap: Record<string, TMediaUploadServiceConfig> = {} |
|
private defaultShowNsfw: boolean = false |
|
private dismissedTooManyRelaysAlert: boolean = false |
|
private showKinds: number[] = [] |
|
private showKind1OPs: boolean = true |
|
private showKind1Replies: boolean = true |
|
private showKind1111: boolean = true |
|
/** Omit kinds in feed REQ + skip client kind filtering (testing). */ |
|
private feedKindFilterBypass: boolean = false |
|
private hideContentMentioningMutedUsers: boolean = false |
|
private notificationListStyle: TNotificationStyle = NOTIFICATION_LIST_STYLE.DETAILED |
|
private mediaAutoLoadPolicy: TMediaAutoLoadPolicy = MEDIA_AUTO_LOAD_POLICY.ALWAYS |
|
private showRecommendedRelaysPanel: boolean = false |
|
private shownCreateWalletGuideToastPubkeys: Set<string> = new Set() |
|
private defaultExpirationEnabled: boolean = false |
|
private defaultExpirationMonths: number = 6 |
|
private defaultQuietEnabled: boolean = false |
|
private defaultQuietDays: number = 7 |
|
private respectQuietTags: boolean = true |
|
private globalQuietMode: boolean = false |
|
private showRssFeed: boolean = true |
|
private panelMode: 'single' | 'double' = 'single' |
|
private addRandomRelaysToPublish: boolean = false |
|
private showPublishSuccessToasts: boolean = true |
|
private showLiveActivitiesBanner: boolean = true |
|
|
|
constructor() { |
|
if (!LocalStorageService.instance) { |
|
this.init() |
|
LocalStorageService.instance = this |
|
} |
|
return LocalStorageService.instance |
|
} |
|
|
|
init() { |
|
this.themeSetting = |
|
(window.localStorage.getItem(StorageKey.THEME_SETTING) as TThemeSetting) ?? 'system' |
|
const themeStr = window.localStorage.getItem(StorageKey.THEME) as TTheme | null |
|
this.theme = themeStr === 'dark' || themeStr === 'light' ? themeStr : 'light' |
|
const addClientTagStr = window.localStorage.getItem(StorageKey.ADD_CLIENT_TAG) |
|
this.addClientTag = addClientTagStr === null ? true : addClientTagStr === 'true' |
|
this.fontSize = |
|
(window.localStorage.getItem(StorageKey.FONT_SIZE) as TFontSize) ?? 'medium' |
|
const accountsStr = window.localStorage.getItem(StorageKey.ACCOUNTS) |
|
this.accounts = accountsStr ? JSON.parse(accountsStr) : [] |
|
const currentAccountStr = window.localStorage.getItem(StorageKey.CURRENT_ACCOUNT) |
|
this.currentAccount = currentAccountStr ? JSON.parse(currentAccountStr) : null |
|
if ( |
|
this.currentAccount != null && |
|
!this.accounts.some((a) => isSameAccount(a, this.currentAccount)) |
|
) { |
|
this.currentAccount = null |
|
window.localStorage.setItem(StorageKey.CURRENT_ACCOUNT, JSON.stringify(null)) |
|
} |
|
const noteListModeStr = window.localStorage.getItem(StorageKey.NOTE_LIST_MODE) |
|
this.noteListMode = |
|
noteListModeStr && ['posts', 'postsAndReplies', 'media'].includes(noteListModeStr) |
|
? (noteListModeStr as TNoteListMode) |
|
: 'posts' |
|
const relaySetsStr = window.localStorage.getItem(StorageKey.RELAY_SETS) |
|
if (!relaySetsStr) { |
|
let relaySets: TRelaySet[] = [] |
|
const legacyRelayGroupsStr = window.localStorage.getItem('relayGroups') |
|
if (legacyRelayGroupsStr) { |
|
const legacyRelayGroups = JSON.parse(legacyRelayGroupsStr) |
|
relaySets = legacyRelayGroups.map((group: any) => { |
|
return { |
|
id: randomString(), |
|
name: group.groupName, |
|
relayUrls: group.relayUrls |
|
} |
|
}) |
|
} |
|
if (!relaySets.length) { |
|
relaySets = [] |
|
} |
|
this.persistSetting(StorageKey.RELAY_SETS, JSON.stringify(relaySets)) |
|
this.relaySets = relaySets |
|
} else { |
|
this.relaySets = JSON.parse(relaySetsStr) |
|
} |
|
|
|
const defaultZapSatsStr = window.localStorage.getItem(StorageKey.DEFAULT_ZAP_SATS) |
|
if (defaultZapSatsStr) { |
|
const num = parseInt(defaultZapSatsStr) |
|
if (!isNaN(num)) { |
|
this.defaultZapSats = num |
|
} |
|
} |
|
this.defaultZapComment = window.localStorage.getItem(StorageKey.DEFAULT_ZAP_COMMENT) ?? 'Zap!' |
|
this.quickZap = window.localStorage.getItem(StorageKey.QUICK_ZAP) === 'true' |
|
|
|
const zapReplyThresholdStr = window.localStorage.getItem(StorageKey.ZAP_REPLY_THRESHOLD) |
|
if (zapReplyThresholdStr) { |
|
const num = parseInt(zapReplyThresholdStr) |
|
if (!isNaN(num)) { |
|
this.zapReplyThreshold = num |
|
} |
|
} |
|
|
|
const accountFeedInfoMapStr = |
|
window.localStorage.getItem(StorageKey.ACCOUNT_FEED_INFO_MAP) ?? '{}' |
|
this.accountFeedInfoMap = JSON.parse(accountFeedInfoMapStr) |
|
|
|
// deprecated |
|
this.mediaUploadService = |
|
window.localStorage.getItem(StorageKey.MEDIA_UPLOAD_SERVICE) ?? DEFAULT_NIP_96_SERVICE |
|
|
|
this.autoplay = window.localStorage.getItem(StorageKey.AUTOPLAY) !== 'false' |
|
|
|
const hideUntrustedEvents = |
|
window.localStorage.getItem(StorageKey.HIDE_UNTRUSTED_EVENTS) === 'true' |
|
const storedHideUntrustedInteractions = window.localStorage.getItem( |
|
StorageKey.HIDE_UNTRUSTED_INTERACTIONS |
|
) |
|
const storedHideUntrustedNotifications = window.localStorage.getItem( |
|
StorageKey.HIDE_UNTRUSTED_NOTIFICATIONS |
|
) |
|
const storedHideUntrustedNotes = window.localStorage.getItem(StorageKey.HIDE_UNTRUSTED_NOTES) |
|
this.hideUntrustedInteractions = storedHideUntrustedInteractions |
|
? storedHideUntrustedInteractions === 'true' |
|
: hideUntrustedEvents |
|
this.hideUntrustedNotifications = storedHideUntrustedNotifications |
|
? storedHideUntrustedNotifications === 'true' |
|
: hideUntrustedEvents |
|
this.hideUntrustedNotes = storedHideUntrustedNotes |
|
? storedHideUntrustedNotes === 'true' |
|
: hideUntrustedEvents |
|
|
|
const mediaUploadServiceConfigMapStr = window.localStorage.getItem( |
|
StorageKey.MEDIA_UPLOAD_SERVICE_CONFIG_MAP |
|
) |
|
if (mediaUploadServiceConfigMapStr) { |
|
this.mediaUploadServiceConfigMap = JSON.parse(mediaUploadServiceConfigMapStr) |
|
} |
|
|
|
this.defaultShowNsfw = window.localStorage.getItem(StorageKey.DEFAULT_SHOW_NSFW) === 'true' |
|
|
|
this.dismissedTooManyRelaysAlert = |
|
window.localStorage.getItem(StorageKey.DISMISSED_TOO_MANY_RELAYS_ALERT) === 'true' |
|
|
|
const storedValue = window.localStorage.getItem(StorageKey.SHOW_RECOMMENDED_RELAYS_PANEL) |
|
this.showRecommendedRelaysPanel = storedValue === 'true' // Default to false if not explicitly set to true |
|
|
|
const showKindsStr = window.localStorage.getItem(StorageKey.SHOW_KINDS) |
|
if (!showKindsStr) { |
|
this.showKinds = [...DEFAULT_FEED_SHOW_KINDS] |
|
} else { |
|
const showKindsVersionStr = window.localStorage.getItem(StorageKey.SHOW_KINDS_VERSION) |
|
const showKindsVersion = showKindsVersionStr ? parseInt(showKindsVersionStr) : 0 |
|
const showKinds = JSON.parse(showKindsStr) as number[] |
|
if (showKindsVersion < 1) { |
|
showKinds.push(ExtendedKind.VIDEO, ExtendedKind.SHORT_VIDEO) |
|
} |
|
if (showKindsVersion < 2) { |
|
showKinds.push(ExtendedKind.ZAP_RECEIPT) |
|
} |
|
if (showKindsVersion < 3) { |
|
// Remove boosts (kind 6) from existing users' filters |
|
const repostIndex = showKinds.indexOf(kinds.Repost) |
|
if (repostIndex !== -1) { |
|
showKinds.splice(repostIndex, 1) |
|
} |
|
} |
|
if (showKindsVersion < 4) { |
|
// Add publications and wiki articles to existing users' filters |
|
if (!showKinds.includes(ExtendedKind.PUBLICATION)) { |
|
showKinds.push(ExtendedKind.PUBLICATION) |
|
} |
|
if (!showKinds.includes(ExtendedKind.PUBLICATION_CONTENT)) { |
|
showKinds.push(ExtendedKind.PUBLICATION_CONTENT) |
|
} |
|
if (!showKinds.includes(ExtendedKind.WIKI_ARTICLE)) { |
|
showKinds.push(ExtendedKind.WIKI_ARTICLE) |
|
} |
|
} |
|
if (showKindsVersion < 5) { |
|
// Remove publication content from existing users' filters (should only be embedded) |
|
const pubContentIndex = showKinds.indexOf(ExtendedKind.PUBLICATION_CONTENT) |
|
if (pubContentIndex !== -1) { |
|
showKinds.splice(pubContentIndex, 1) |
|
} |
|
} |
|
if (showKindsVersion < 6) { |
|
// Remove publications and publication content from existing users' filters (should only be embedded, not in feeds) |
|
const pubIndex = showKinds.indexOf(ExtendedKind.PUBLICATION) |
|
if (pubIndex !== -1) { |
|
showKinds.splice(pubIndex, 1) |
|
} |
|
const pubContentIndex = showKinds.indexOf(ExtendedKind.PUBLICATION_CONTENT) |
|
if (pubContentIndex !== -1) { |
|
showKinds.splice(pubContentIndex, 1) |
|
} |
|
} |
|
if (showKindsVersion < 7) { |
|
// Remove NIP-89 handler kinds from feed (not in filter UI; avoid showing in main feed) |
|
const nip89RecIndex = showKinds.indexOf(ExtendedKind.APPLICATION_HANDLER_RECOMMENDATION) |
|
if (nip89RecIndex !== -1) { |
|
showKinds.splice(nip89RecIndex, 1) |
|
} |
|
const nip89InfoIndex = showKinds.indexOf(ExtendedKind.APPLICATION_HANDLER_INFO) |
|
if (nip89InfoIndex !== -1) { |
|
showKinds.splice(nip89InfoIndex, 1) |
|
} |
|
} |
|
if (showKindsVersion < 8) { |
|
// Boosts (kind 6) and publications removed from feed filter UI — strip from saved preferences |
|
for (let i = showKinds.length - 1; i >= 0; i--) { |
|
const k = showKinds[i] |
|
if (k === kinds.Repost || k === ExtendedKind.PUBLICATION) { |
|
showKinds.splice(i, 1) |
|
} |
|
} |
|
} |
|
if (showKindsVersion < 10) { |
|
if (showKinds.includes(ExtendedKind.POLL) && !showKinds.includes(ExtendedKind.ZAP_POLL)) { |
|
showKinds.push(ExtendedKind.ZAP_POLL) |
|
} |
|
} |
|
if (showKindsVersion < 11) { |
|
if (!showKinds.includes(ExtendedKind.GIT_RELEASE)) { |
|
showKinds.push(ExtendedKind.GIT_RELEASE) |
|
} |
|
} |
|
if (showKindsVersion < 12) { |
|
// Add WIKI_ARTICLE_MARKDOWN (30817) for users who already have long-form articles (30023) or |
|
// wiki articles (30818) enabled — it was omitted from the earlier v4 migration. |
|
if ( |
|
(showKinds.includes(kinds.LongFormArticle) || showKinds.includes(ExtendedKind.WIKI_ARTICLE)) && |
|
!showKinds.includes(ExtendedKind.WIKI_ARTICLE_MARKDOWN) |
|
) { |
|
showKinds.push(ExtendedKind.WIKI_ARTICLE_MARKDOWN) |
|
} |
|
} |
|
// v9: boosts are optional in the same filter list as other kinds; do not auto-enable (leave absent). |
|
this.showKinds = showKinds |
|
// Only persist when we read from localStorage. If SHOW_KINDS is missing here (migrated to IDB and |
|
// keys cleared), persisting would write DEFAULT_FEED_SHOW_KINDS to IndexedDB and wipe the user's |
|
// saved filter before initAsync/applySettings runs. |
|
this.persistSetting(StorageKey.SHOW_KINDS, JSON.stringify(this.showKinds)) |
|
this.persistSetting(StorageKey.SHOW_KINDS_VERSION, '12') |
|
} |
|
|
|
// Feed filter: kind 1 OPs, kind 1 replies, kind 1111 (migrate from legacy showRepliesAndComments if set) |
|
const showKind1OPsStr = window.localStorage.getItem(StorageKey.SHOW_KIND_1_OPs) |
|
const showRepliesStr = window.localStorage.getItem(StorageKey.SHOW_REPLIES_AND_COMMENTS) |
|
const showKind1RepliesStr = window.localStorage.getItem(StorageKey.SHOW_KIND_1_REPLIES) |
|
const showKind1111Str = window.localStorage.getItem(StorageKey.SHOW_KIND_1111) |
|
if (showKind1OPsStr !== null) { |
|
this.showKind1OPs = showKind1OPsStr === 'true' |
|
} else { |
|
this.showKind1OPs = this.showKinds.includes(kinds.ShortTextNote) |
|
} |
|
if (showKind1RepliesStr !== null) { |
|
this.showKind1Replies = showKind1RepliesStr === 'true' |
|
} else if (showRepliesStr !== null) { |
|
this.showKind1Replies = showRepliesStr === 'true' |
|
} else { |
|
this.showKind1Replies = this.showKinds.includes(kinds.ShortTextNote) |
|
} |
|
if (showKind1111Str !== null) { |
|
this.showKind1111 = showKind1111Str === 'true' |
|
} else if (showRepliesStr !== null) { |
|
this.showKind1111 = showRepliesStr === 'true' |
|
} else { |
|
this.showKind1111 = this.showKinds.includes(ExtendedKind.COMMENT) |
|
} |
|
|
|
const feedKindFilterBypassStr = window.localStorage.getItem(StorageKey.FEED_KIND_FILTER_BYPASS) |
|
this.feedKindFilterBypass = feedKindFilterBypassStr === 'true' |
|
|
|
this.hideContentMentioningMutedUsers = |
|
window.localStorage.getItem(StorageKey.HIDE_CONTENT_MENTIONING_MUTED_USERS) === 'true' |
|
|
|
this.notificationListStyle = |
|
window.localStorage.getItem(StorageKey.NOTIFICATION_LIST_STYLE) === |
|
NOTIFICATION_LIST_STYLE.COMPACT |
|
? NOTIFICATION_LIST_STYLE.COMPACT |
|
: NOTIFICATION_LIST_STYLE.DETAILED |
|
|
|
const mediaAutoLoadPolicy = window.localStorage.getItem(StorageKey.MEDIA_AUTO_LOAD_POLICY) |
|
if ( |
|
mediaAutoLoadPolicy && |
|
Object.values(MEDIA_AUTO_LOAD_POLICY).includes(mediaAutoLoadPolicy as TMediaAutoLoadPolicy) |
|
) { |
|
this.mediaAutoLoadPolicy = mediaAutoLoadPolicy as TMediaAutoLoadPolicy |
|
} |
|
|
|
const shownCreateWalletGuideToastPubkeysStr = window.localStorage.getItem( |
|
StorageKey.SHOWN_CREATE_WALLET_GUIDE_TOAST_PUBKEYS |
|
) |
|
this.shownCreateWalletGuideToastPubkeys = shownCreateWalletGuideToastPubkeysStr |
|
? new Set(JSON.parse(shownCreateWalletGuideToastPubkeysStr)) |
|
: new Set() |
|
|
|
// Initialize expiration and quiet settings |
|
const defaultExpirationEnabledStr = window.localStorage.getItem(StorageKey.DEFAULT_EXPIRATION_ENABLED) |
|
this.defaultExpirationEnabled = defaultExpirationEnabledStr === 'true' |
|
|
|
const defaultExpirationMonthsStr = window.localStorage.getItem(StorageKey.DEFAULT_EXPIRATION_MONTHS) |
|
if (defaultExpirationMonthsStr) { |
|
const num = parseInt(defaultExpirationMonthsStr) |
|
if (!isNaN(num) && num >= 0 && Number.isInteger(num)) { |
|
this.defaultExpirationMonths = num |
|
} |
|
} |
|
|
|
const defaultQuietEnabledStr = window.localStorage.getItem(StorageKey.DEFAULT_QUIET_ENABLED) |
|
this.defaultQuietEnabled = defaultQuietEnabledStr === 'true' |
|
|
|
const defaultQuietDaysStr = window.localStorage.getItem(StorageKey.DEFAULT_QUIET_DAYS) |
|
if (defaultQuietDaysStr) { |
|
const num = parseInt(defaultQuietDaysStr) |
|
if (!isNaN(num) && num >= 0 && Number.isInteger(num)) { |
|
this.defaultQuietDays = num |
|
} |
|
} |
|
|
|
const respectQuietTagsStr = window.localStorage.getItem(StorageKey.RESPECT_QUIET_TAGS) |
|
this.respectQuietTags = respectQuietTagsStr === null ? true : respectQuietTagsStr === 'true' |
|
|
|
const globalQuietModeStr = window.localStorage.getItem(StorageKey.GLOBAL_QUIET_MODE) |
|
this.globalQuietMode = globalQuietModeStr === 'true' |
|
|
|
const showRssFeedStr = window.localStorage.getItem(StorageKey.SHOW_RSS_FEED) |
|
this.showRssFeed = showRssFeedStr === null ? true : showRssFeedStr === 'true' // Default to true |
|
|
|
const panelModeStr = window.localStorage.getItem(StorageKey.PANE_MODE) |
|
this.panelMode = panelModeStr === 'double' ? 'double' : 'single' // Default to 'single' |
|
|
|
const addRandomRelaysStr = window.localStorage.getItem(StorageKey.ADD_RANDOM_RELAYS_TO_PUBLISH) |
|
this.addRandomRelaysToPublish = addRandomRelaysStr === null ? false : addRandomRelaysStr === 'true' |
|
|
|
const showPublishSuccessStr = window.localStorage.getItem(StorageKey.SHOW_PUBLISH_SUCCESS_TOASTS) |
|
this.showPublishSuccessToasts = showPublishSuccessStr !== 'false' |
|
|
|
const showLiveActivitiesStr = window.localStorage.getItem(StorageKey.SHOW_LIVE_ACTIVITIES_BANNER) |
|
this.showLiveActivitiesBanner = showLiveActivitiesStr !== 'false' |
|
|
|
// Clean up deprecated data |
|
window.localStorage.removeItem(StorageKey.ACCOUNT_PROFILE_EVENT_MAP) |
|
window.localStorage.removeItem(StorageKey.ACCOUNT_FOLLOW_LIST_EVENT_MAP) |
|
window.localStorage.removeItem(StorageKey.ACCOUNT_RELAY_LIST_EVENT_MAP) |
|
window.localStorage.removeItem(StorageKey.ACCOUNT_MUTE_LIST_EVENT_MAP) |
|
window.localStorage.removeItem(StorageKey.ACCOUNT_MUTE_DECRYPTED_TAGS_MAP) |
|
window.localStorage.removeItem(StorageKey.ACTIVE_RELAY_SET_ID) |
|
window.localStorage.removeItem(StorageKey.FEED_TYPE) |
|
} |
|
|
|
/** Persist a setting. Keys in SETTINGS_KEYS go only to IndexedDB; others use localStorage. */ |
|
private persistSetting(key: string, value: string): void { |
|
if ((SETTINGS_KEYS as readonly string[]).includes(key)) { |
|
indexedDb.setSetting(key, value).catch(() => {}) |
|
return |
|
} |
|
window.localStorage.setItem(key, value) |
|
} |
|
|
|
private initPromise: Promise<void> | null = null |
|
|
|
/** |
|
* Async init: hydrate from IndexedDB when available, otherwise migrate localStorage into IndexedDB. |
|
* Call this before app render so settings are read from IndexedDB. |
|
*/ |
|
async initAsync(): Promise<void> { |
|
if (this.initPromise) return this.initPromise |
|
this.initPromise = (async () => { |
|
await indexedDb.init() |
|
const all = await indexedDb.getAllSettings() |
|
if (Object.keys(all).length > 0) { |
|
this.applySettings(all) |
|
} else { |
|
await this.migrateToIdb() |
|
} |
|
this.clearSettingsFromLocalStorage() |
|
})() |
|
return this.initPromise |
|
} |
|
|
|
/** Remove SETTINGS_KEYS from localStorage so we don't duplicate; source of truth is IndexedDB. */ |
|
private clearSettingsFromLocalStorage(): void { |
|
for (const key of SETTINGS_KEYS) { |
|
window.localStorage.removeItem(key) |
|
} |
|
} |
|
|
|
private async migrateToIdb(): Promise<void> { |
|
for (const key of SETTINGS_KEYS) { |
|
const value = window.localStorage.getItem(key) |
|
if (value != null) await indexedDb.setSetting(key, value) |
|
} |
|
} |
|
|
|
private applySettings(record: Record<string, string>): void { |
|
const get = (k: string) => record[k] ?? window.localStorage.getItem(k) |
|
if (get(StorageKey.THEME_SETTING) != null) { |
|
this.themeSetting = (get(StorageKey.THEME_SETTING) as TThemeSetting) ?? this.themeSetting |
|
} |
|
const themeStr = get(StorageKey.THEME) |
|
if (themeStr === 'dark' || themeStr === 'light') this.theme = themeStr |
|
const addClientTagStr = get(StorageKey.ADD_CLIENT_TAG) |
|
if (addClientTagStr != null) this.addClientTag = addClientTagStr === 'true' |
|
if (get(StorageKey.FONT_SIZE) != null) { |
|
this.fontSize = (get(StorageKey.FONT_SIZE) as TFontSize) ?? this.fontSize |
|
} |
|
const noteListModeStr = get(StorageKey.NOTE_LIST_MODE) |
|
if (noteListModeStr != null && ['posts', 'postsAndReplies', 'media'].includes(noteListModeStr)) { |
|
this.noteListMode = noteListModeStr as TNoteListMode |
|
} |
|
const accountsStr = get(StorageKey.ACCOUNTS) |
|
if (accountsStr != null) this.accounts = JSON.parse(accountsStr) as TAccount[] |
|
const currentAccountStr = get(StorageKey.CURRENT_ACCOUNT) |
|
if (currentAccountStr != null) this.currentAccount = JSON.parse(currentAccountStr) as TAccount | null |
|
if ( |
|
this.currentAccount != null && |
|
!this.accounts.some((a) => isSameAccount(a, this.currentAccount)) |
|
) { |
|
this.currentAccount = null |
|
this.persistSetting(StorageKey.CURRENT_ACCOUNT, JSON.stringify(null)) |
|
} |
|
const relaySetsStr = get(StorageKey.RELAY_SETS) |
|
if (relaySetsStr != null) this.relaySets = JSON.parse(relaySetsStr) as TRelaySet[] |
|
const defaultZapSatsStr = get(StorageKey.DEFAULT_ZAP_SATS) |
|
if (defaultZapSatsStr != null) { |
|
const num = parseInt(defaultZapSatsStr) |
|
if (!isNaN(num)) this.defaultZapSats = num |
|
} |
|
const defaultZapCommentStr = get(StorageKey.DEFAULT_ZAP_COMMENT) |
|
if (defaultZapCommentStr != null) this.defaultZapComment = defaultZapCommentStr |
|
const quickZapStr = get(StorageKey.QUICK_ZAP) |
|
if (quickZapStr != null) this.quickZap = quickZapStr === 'true' |
|
const zapReplyStr = get(StorageKey.ZAP_REPLY_THRESHOLD) |
|
if (zapReplyStr != null) { |
|
const num = parseInt(zapReplyStr) |
|
if (!isNaN(num)) this.zapReplyThreshold = num |
|
} |
|
const accountFeedInfoStr = get(StorageKey.ACCOUNT_FEED_INFO_MAP) |
|
if (accountFeedInfoStr != null) this.accountFeedInfoMap = JSON.parse(accountFeedInfoStr) as Record<string, TFeedInfo | undefined> |
|
this.autoplay = get(StorageKey.AUTOPLAY) !== 'false' |
|
const hideInteractions = get(StorageKey.HIDE_UNTRUSTED_INTERACTIONS) |
|
if (hideInteractions != null) this.hideUntrustedInteractions = hideInteractions === 'true' |
|
const hideNotifications = get(StorageKey.HIDE_UNTRUSTED_NOTIFICATIONS) |
|
if (hideNotifications != null) this.hideUntrustedNotifications = hideNotifications === 'true' |
|
const hideNotes = get(StorageKey.HIDE_UNTRUSTED_NOTES) |
|
if (hideNotes != null) this.hideUntrustedNotes = hideNotes === 'true' |
|
const mediaConfigStr = get(StorageKey.MEDIA_UPLOAD_SERVICE_CONFIG_MAP) |
|
if (mediaConfigStr != null) this.mediaUploadServiceConfigMap = JSON.parse(mediaConfigStr) as Record<string, TMediaUploadServiceConfig> |
|
this.defaultShowNsfw = get(StorageKey.DEFAULT_SHOW_NSFW) === 'true' |
|
this.dismissedTooManyRelaysAlert = get(StorageKey.DISMISSED_TOO_MANY_RELAYS_ALERT) === 'true' |
|
this.showRecommendedRelaysPanel = get(StorageKey.SHOW_RECOMMENDED_RELAYS_PANEL) === 'true' |
|
this.addRandomRelaysToPublish = get(StorageKey.ADD_RANDOM_RELAYS_TO_PUBLISH) === 'true' |
|
const showPublishSuccessStr = get(StorageKey.SHOW_PUBLISH_SUCCESS_TOASTS) |
|
if (showPublishSuccessStr != null) this.showPublishSuccessToasts = showPublishSuccessStr !== 'false' |
|
const showLiveActivitiesStr = get(StorageKey.SHOW_LIVE_ACTIVITIES_BANNER) |
|
if (showLiveActivitiesStr != null) this.showLiveActivitiesBanner = showLiveActivitiesStr !== 'false' |
|
const showKindsStr = get(StorageKey.SHOW_KINDS) |
|
if (showKindsStr != null) this.showKinds = JSON.parse(showKindsStr) as number[] |
|
const showKind1OPsStr = get(StorageKey.SHOW_KIND_1_OPs) |
|
if (showKind1OPsStr != null) this.showKind1OPs = showKind1OPsStr === 'true' |
|
const showKind1RepliesStr = get(StorageKey.SHOW_KIND_1_REPLIES) |
|
if (showKind1RepliesStr != null) this.showKind1Replies = showKind1RepliesStr === 'true' |
|
const showKind1111Str = get(StorageKey.SHOW_KIND_1111) |
|
if (showKind1111Str != null) this.showKind1111 = showKind1111Str === 'true' |
|
const feedKindFilterBypassStr = get(StorageKey.FEED_KIND_FILTER_BYPASS) |
|
if (feedKindFilterBypassStr != null) this.feedKindFilterBypass = feedKindFilterBypassStr === 'true' |
|
this.hideContentMentioningMutedUsers = get(StorageKey.HIDE_CONTENT_MENTIONING_MUTED_USERS) === 'true' |
|
const notifStyle = get(StorageKey.NOTIFICATION_LIST_STYLE) |
|
if (notifStyle != null) this.notificationListStyle = notifStyle === NOTIFICATION_LIST_STYLE.COMPACT ? NOTIFICATION_LIST_STYLE.COMPACT : NOTIFICATION_LIST_STYLE.DETAILED |
|
const mediaPolicy = get(StorageKey.MEDIA_AUTO_LOAD_POLICY) |
|
if (mediaPolicy != null && Object.values(MEDIA_AUTO_LOAD_POLICY).includes(mediaPolicy as TMediaAutoLoadPolicy)) { |
|
this.mediaAutoLoadPolicy = mediaPolicy as TMediaAutoLoadPolicy |
|
} |
|
const shownWalletStr = get(StorageKey.SHOWN_CREATE_WALLET_GUIDE_TOAST_PUBKEYS) |
|
if (shownWalletStr != null) this.shownCreateWalletGuideToastPubkeys = new Set(JSON.parse(shownWalletStr) as string[]) |
|
this.defaultExpirationEnabled = get(StorageKey.DEFAULT_EXPIRATION_ENABLED) === 'true' |
|
const defaultExpirationMonthsStr = get(StorageKey.DEFAULT_EXPIRATION_MONTHS) |
|
if (defaultExpirationMonthsStr != null) { |
|
const num = parseInt(defaultExpirationMonthsStr) |
|
if (!isNaN(num) && num >= 0) this.defaultExpirationMonths = num |
|
} |
|
this.defaultQuietEnabled = get(StorageKey.DEFAULT_QUIET_ENABLED) === 'true' |
|
const defaultQuietDaysStr = get(StorageKey.DEFAULT_QUIET_DAYS) |
|
if (defaultQuietDaysStr != null) { |
|
const num = parseInt(defaultQuietDaysStr) |
|
if (!isNaN(num) && num >= 0) this.defaultQuietDays = num |
|
} |
|
const respectQuietStr = get(StorageKey.RESPECT_QUIET_TAGS) |
|
if (respectQuietStr != null) this.respectQuietTags = respectQuietStr === 'true' |
|
this.globalQuietMode = get(StorageKey.GLOBAL_QUIET_MODE) === 'true' |
|
const showRssStr = get(StorageKey.SHOW_RSS_FEED) |
|
if (showRssStr != null) this.showRssFeed = showRssStr === 'true' |
|
const paneStr = get(StorageKey.PANE_MODE) |
|
if (paneStr != null && (paneStr === 'single' || paneStr === 'double')) this.panelMode = paneStr |
|
} |
|
|
|
getRelaySets() { |
|
return this.relaySets |
|
} |
|
|
|
setRelaySets(relaySets: TRelaySet[]) { |
|
this.relaySets = relaySets |
|
this.persistSetting(StorageKey.RELAY_SETS, JSON.stringify(this.relaySets)) |
|
} |
|
|
|
getThemeSetting() { |
|
return this.themeSetting |
|
} |
|
|
|
setThemeSetting(themeSetting: TThemeSetting) { |
|
this.persistSetting(StorageKey.THEME_SETTING, themeSetting) |
|
this.themeSetting = themeSetting |
|
} |
|
|
|
getTheme(): TTheme { |
|
return this.theme |
|
} |
|
|
|
setTheme(theme: TTheme) { |
|
this.theme = theme |
|
this.persistSetting(StorageKey.THEME, theme) |
|
} |
|
|
|
getAddClientTag(): boolean { |
|
return this.addClientTag |
|
} |
|
|
|
setAddClientTag(value: boolean) { |
|
this.addClientTag = value |
|
this.persistSetting(StorageKey.ADD_CLIENT_TAG, value.toString()) |
|
} |
|
|
|
getFontSize() { |
|
return this.fontSize |
|
} |
|
|
|
setFontSize(fontSize: TFontSize) { |
|
this.persistSetting(StorageKey.FONT_SIZE, fontSize) |
|
this.fontSize = fontSize |
|
} |
|
|
|
getNoteListMode() { |
|
return this.noteListMode |
|
} |
|
|
|
setNoteListMode(mode: TNoteListMode) { |
|
this.persistSetting(StorageKey.NOTE_LIST_MODE, mode) |
|
this.noteListMode = mode |
|
} |
|
|
|
getAccounts() { |
|
return this.accounts |
|
} |
|
|
|
findAccount(account: TAccountPointer) { |
|
return this.accounts.find((act) => isSameAccount(act, account)) |
|
} |
|
|
|
getCurrentAccount() { |
|
return this.currentAccount |
|
} |
|
|
|
getAccountNsec(pubkey: string) { |
|
const account = this.accounts.find((act) => act.pubkey === pubkey && act.signerType === 'nsec') |
|
return account?.nsec |
|
} |
|
|
|
getAccountNcryptsec(pubkey: string) { |
|
const account = this.accounts.find( |
|
(act) => act.pubkey === pubkey && act.signerType === 'ncryptsec' |
|
) |
|
return account?.ncryptsec |
|
} |
|
|
|
addAccount(account: TAccount) { |
|
const index = this.accounts.findIndex((act) => isSameAccount(act, account)) |
|
if (index !== -1) { |
|
this.accounts[index] = account |
|
} else { |
|
this.accounts.push(account) |
|
} |
|
this.persistSetting(StorageKey.ACCOUNTS, JSON.stringify(this.accounts)) |
|
return this.accounts |
|
} |
|
|
|
removeAccount(account: TAccount) { |
|
this.accounts = this.accounts.filter((act) => !isSameAccount(act, account)) |
|
this.persistSetting(StorageKey.ACCOUNTS, JSON.stringify(this.accounts)) |
|
if (isSameAccount(this.currentAccount, account)) { |
|
this.currentAccount = null |
|
this.persistSetting(StorageKey.CURRENT_ACCOUNT, JSON.stringify(null)) |
|
} else if ( |
|
this.currentAccount != null && |
|
!this.accounts.some((a) => isSameAccount(a, this.currentAccount)) |
|
) { |
|
this.currentAccount = null |
|
this.persistSetting(StorageKey.CURRENT_ACCOUNT, JSON.stringify(null)) |
|
} |
|
return this.accounts |
|
} |
|
|
|
switchAccount(account: TAccount | null) { |
|
if (account === null) { |
|
if (this.currentAccount === null) return |
|
this.currentAccount = null |
|
this.persistSetting(StorageKey.CURRENT_ACCOUNT, JSON.stringify(null)) |
|
return |
|
} |
|
if (isSameAccount(this.currentAccount, account)) { |
|
return |
|
} |
|
const act = this.accounts.find((act) => isSameAccount(act, account)) |
|
if (!act) { |
|
return |
|
} |
|
this.currentAccount = act |
|
this.persistSetting(StorageKey.CURRENT_ACCOUNT, JSON.stringify(act)) |
|
} |
|
|
|
getDefaultZapSats() { |
|
return this.defaultZapSats |
|
} |
|
|
|
setDefaultZapSats(sats: number) { |
|
this.defaultZapSats = sats |
|
this.persistSetting(StorageKey.DEFAULT_ZAP_SATS, sats.toString()) |
|
} |
|
|
|
getDefaultZapComment() { |
|
return this.defaultZapComment |
|
} |
|
|
|
setDefaultZapComment(comment: string) { |
|
this.defaultZapComment = comment |
|
this.persistSetting(StorageKey.DEFAULT_ZAP_COMMENT, comment) |
|
} |
|
|
|
getQuickZap() { |
|
return this.quickZap |
|
} |
|
|
|
setQuickZap(quickZap: boolean) { |
|
this.quickZap = quickZap |
|
this.persistSetting(StorageKey.QUICK_ZAP, quickZap.toString()) |
|
} |
|
|
|
getZapReplyThreshold() { |
|
return this.zapReplyThreshold |
|
} |
|
|
|
setZapReplyThreshold(sats: number) { |
|
this.zapReplyThreshold = sats |
|
this.persistSetting(StorageKey.ZAP_REPLY_THRESHOLD, sats.toString()) |
|
} |
|
|
|
getFeedInfo(pubkey: string) { |
|
return this.accountFeedInfoMap[pubkey] |
|
} |
|
|
|
setFeedInfo(info: TFeedInfo, pubkey?: string | null) { |
|
this.accountFeedInfoMap[pubkey ?? 'default'] = info |
|
this.persistSetting( |
|
StorageKey.ACCOUNT_FEED_INFO_MAP, |
|
JSON.stringify(this.accountFeedInfoMap) |
|
) |
|
} |
|
|
|
getAutoplay() { |
|
return this.autoplay |
|
} |
|
|
|
setAutoplay(autoplay: boolean) { |
|
this.autoplay = autoplay |
|
this.persistSetting(StorageKey.AUTOPLAY, autoplay.toString()) |
|
} |
|
|
|
getHideUntrustedInteractions() { |
|
return this.hideUntrustedInteractions |
|
} |
|
|
|
setHideUntrustedInteractions(hideUntrustedInteractions: boolean) { |
|
this.hideUntrustedInteractions = hideUntrustedInteractions |
|
this.persistSetting( |
|
StorageKey.HIDE_UNTRUSTED_INTERACTIONS, |
|
hideUntrustedInteractions.toString() |
|
) |
|
} |
|
|
|
getHideUntrustedNotifications() { |
|
return this.hideUntrustedNotifications |
|
} |
|
|
|
setHideUntrustedNotifications(hideUntrustedNotifications: boolean) { |
|
this.hideUntrustedNotifications = hideUntrustedNotifications |
|
this.persistSetting( |
|
StorageKey.HIDE_UNTRUSTED_NOTIFICATIONS, |
|
hideUntrustedNotifications.toString() |
|
) |
|
} |
|
|
|
getHideUntrustedNotes() { |
|
return this.hideUntrustedNotes |
|
} |
|
|
|
setHideUntrustedNotes(hideUntrustedNotes: boolean) { |
|
this.hideUntrustedNotes = hideUntrustedNotes |
|
this.persistSetting(StorageKey.HIDE_UNTRUSTED_NOTES, hideUntrustedNotes.toString()) |
|
} |
|
|
|
getMediaUploadServiceConfig(pubkey?: string | null): TMediaUploadServiceConfig { |
|
const defaultConfig = { type: 'nip96', service: this.mediaUploadService } as const |
|
if (!pubkey) { |
|
return defaultConfig |
|
} |
|
return this.mediaUploadServiceConfigMap[pubkey] ?? defaultConfig |
|
} |
|
|
|
setMediaUploadServiceConfig( |
|
pubkey: string, |
|
config: TMediaUploadServiceConfig |
|
): TMediaUploadServiceConfig { |
|
this.mediaUploadServiceConfigMap[pubkey] = config |
|
this.persistSetting( |
|
StorageKey.MEDIA_UPLOAD_SERVICE_CONFIG_MAP, |
|
JSON.stringify(this.mediaUploadServiceConfigMap) |
|
) |
|
return config |
|
} |
|
|
|
getDefaultShowNsfw() { |
|
return this.defaultShowNsfw |
|
} |
|
|
|
setDefaultShowNsfw(defaultShowNsfw: boolean) { |
|
this.defaultShowNsfw = defaultShowNsfw |
|
this.persistSetting(StorageKey.DEFAULT_SHOW_NSFW, defaultShowNsfw.toString()) |
|
} |
|
|
|
getDismissedTooManyRelaysAlert() { |
|
return this.dismissedTooManyRelaysAlert |
|
} |
|
|
|
setDismissedTooManyRelaysAlert(dismissed: boolean) { |
|
this.dismissedTooManyRelaysAlert = dismissed |
|
this.persistSetting(StorageKey.DISMISSED_TOO_MANY_RELAYS_ALERT, dismissed.toString()) |
|
} |
|
|
|
getShowRecommendedRelaysPanel() { |
|
return this.showRecommendedRelaysPanel |
|
} |
|
|
|
setShowRecommendedRelaysPanel(show: boolean) { |
|
this.showRecommendedRelaysPanel = show |
|
this.persistSetting(StorageKey.SHOW_RECOMMENDED_RELAYS_PANEL, show.toString()) |
|
} |
|
|
|
getAddRandomRelaysToPublish(): boolean { |
|
return this.addRandomRelaysToPublish |
|
} |
|
|
|
setAddRandomRelaysToPublish(value: boolean) { |
|
this.addRandomRelaysToPublish = value |
|
this.persistSetting(StorageKey.ADD_RANDOM_RELAYS_TO_PUBLISH, value.toString()) |
|
} |
|
|
|
getShowLiveActivitiesBanner(): boolean { |
|
return this.showLiveActivitiesBanner |
|
} |
|
|
|
setShowLiveActivitiesBanner(value: boolean) { |
|
this.showLiveActivitiesBanner = value |
|
this.persistSetting(StorageKey.SHOW_LIVE_ACTIVITIES_BANNER, value ? 'true' : 'false') |
|
} |
|
|
|
getShowKinds() { |
|
return this.showKinds |
|
} |
|
|
|
setShowKinds(newKinds: number[]) { |
|
this.showKinds = newKinds |
|
this.persistSetting(StorageKey.SHOW_KINDS, JSON.stringify(newKinds)) |
|
} |
|
|
|
getShowKind1OPs(): boolean { |
|
return this.showKind1OPs |
|
} |
|
|
|
setShowKind1OPs(value: boolean) { |
|
this.showKind1OPs = value |
|
this.persistSetting(StorageKey.SHOW_KIND_1_OPs, value.toString()) |
|
} |
|
|
|
getShowKind1Replies(): boolean { |
|
return this.showKind1Replies |
|
} |
|
|
|
setShowKind1Replies(value: boolean) { |
|
this.showKind1Replies = value |
|
this.persistSetting(StorageKey.SHOW_KIND_1_REPLIES, value.toString()) |
|
} |
|
|
|
getShowKind1111(): boolean { |
|
return this.showKind1111 |
|
} |
|
|
|
setShowKind1111(value: boolean) { |
|
this.showKind1111 = value |
|
this.persistSetting(StorageKey.SHOW_KIND_1111, value.toString()) |
|
} |
|
|
|
getFeedKindFilterBypass(): boolean { |
|
return this.feedKindFilterBypass |
|
} |
|
|
|
setFeedKindFilterBypass(value: boolean) { |
|
this.feedKindFilterBypass = value |
|
this.persistSetting(StorageKey.FEED_KIND_FILTER_BYPASS, value.toString()) |
|
} |
|
|
|
getHideContentMentioningMutedUsers() { |
|
return this.hideContentMentioningMutedUsers |
|
} |
|
|
|
setHideContentMentioningMutedUsers(hide: boolean) { |
|
this.hideContentMentioningMutedUsers = hide |
|
this.persistSetting(StorageKey.HIDE_CONTENT_MENTIONING_MUTED_USERS, hide.toString()) |
|
} |
|
|
|
getNotificationListStyle() { |
|
return this.notificationListStyle |
|
} |
|
|
|
setNotificationListStyle(style: TNotificationStyle) { |
|
this.notificationListStyle = style |
|
this.persistSetting(StorageKey.NOTIFICATION_LIST_STYLE, style) |
|
} |
|
|
|
getMediaAutoLoadPolicy() { |
|
return this.mediaAutoLoadPolicy |
|
} |
|
|
|
setMediaAutoLoadPolicy(policy: TMediaAutoLoadPolicy) { |
|
this.mediaAutoLoadPolicy = policy |
|
this.persistSetting(StorageKey.MEDIA_AUTO_LOAD_POLICY, policy) |
|
} |
|
|
|
hasShownCreateWalletGuideToast(pubkey: string) { |
|
return this.shownCreateWalletGuideToastPubkeys.has(pubkey) |
|
} |
|
|
|
markCreateWalletGuideToastAsShown(pubkey: string) { |
|
if (this.shownCreateWalletGuideToastPubkeys.has(pubkey)) { |
|
return |
|
} |
|
this.shownCreateWalletGuideToastPubkeys.add(pubkey) |
|
this.persistSetting( |
|
StorageKey.SHOWN_CREATE_WALLET_GUIDE_TOAST_PUBKEYS, |
|
JSON.stringify(Array.from(this.shownCreateWalletGuideToastPubkeys)) |
|
) |
|
} |
|
|
|
// Expiration settings |
|
getDefaultExpirationEnabled() { |
|
return this.defaultExpirationEnabled |
|
} |
|
|
|
setDefaultExpirationEnabled(enabled: boolean) { |
|
this.defaultExpirationEnabled = enabled |
|
this.persistSetting(StorageKey.DEFAULT_EXPIRATION_ENABLED, enabled.toString()) |
|
} |
|
|
|
getDefaultExpirationMonths() { |
|
return this.defaultExpirationMonths |
|
} |
|
|
|
setDefaultExpirationMonths(months: number) { |
|
if (Number.isInteger(months) && months >= 0) { |
|
this.defaultExpirationMonths = months |
|
this.persistSetting(StorageKey.DEFAULT_EXPIRATION_MONTHS, months.toString()) |
|
} |
|
} |
|
|
|
// Quiet settings |
|
getDefaultQuietEnabled() { |
|
return this.defaultQuietEnabled |
|
} |
|
|
|
setDefaultQuietEnabled(enabled: boolean) { |
|
this.defaultQuietEnabled = enabled |
|
this.persistSetting(StorageKey.DEFAULT_QUIET_ENABLED, enabled.toString()) |
|
} |
|
|
|
getDefaultQuietDays() { |
|
return this.defaultQuietDays |
|
} |
|
|
|
setDefaultQuietDays(days: number) { |
|
if (Number.isInteger(days) && days >= 0) { |
|
this.defaultQuietDays = days |
|
this.persistSetting(StorageKey.DEFAULT_QUIET_DAYS, days.toString()) |
|
} |
|
} |
|
|
|
getRespectQuietTags() { |
|
return this.respectQuietTags |
|
} |
|
|
|
setRespectQuietTags(respect: boolean) { |
|
this.respectQuietTags = respect |
|
this.persistSetting(StorageKey.RESPECT_QUIET_TAGS, respect.toString()) |
|
} |
|
|
|
getGlobalQuietMode() { |
|
return this.globalQuietMode |
|
} |
|
|
|
setGlobalQuietMode(enabled: boolean) { |
|
this.globalQuietMode = enabled |
|
this.persistSetting(StorageKey.GLOBAL_QUIET_MODE, enabled.toString()) |
|
} |
|
|
|
getShowRssFeed() { |
|
return this.showRssFeed |
|
} |
|
|
|
setShowRssFeed(show: boolean) { |
|
this.showRssFeed = show |
|
this.persistSetting(StorageKey.SHOW_RSS_FEED, show.toString()) |
|
} |
|
|
|
getShowPublishSuccessToasts(): boolean { |
|
return this.showPublishSuccessToasts |
|
} |
|
|
|
setShowPublishSuccessToasts(show: boolean) { |
|
this.showPublishSuccessToasts = show |
|
this.persistSetting(StorageKey.SHOW_PUBLISH_SUCCESS_TOASTS, show.toString()) |
|
} |
|
|
|
getPanelMode(): 'single' | 'double' { |
|
return this.panelMode |
|
} |
|
|
|
setPanelMode(mode: 'single' | 'double') { |
|
this.panelMode = mode |
|
this.persistSetting(StorageKey.PANE_MODE, mode) |
|
} |
|
|
|
getAccountNetworkHydrateAt(pubkey: string): number | undefined { |
|
try { |
|
const raw = window.localStorage.getItem(StorageKey.ACCOUNT_NETWORK_HYDRATE_AT_MAP) |
|
if (!raw) return undefined |
|
const map = JSON.parse(raw) as Record<string, unknown> |
|
const pk = pubkey.trim().toLowerCase() |
|
const v = map[pk] |
|
return typeof v === 'number' && Number.isFinite(v) ? v : undefined |
|
} catch { |
|
return undefined |
|
} |
|
} |
|
|
|
setAccountNetworkHydrateAt(pubkey: string, atMs: number): void { |
|
try { |
|
const raw = window.localStorage.getItem(StorageKey.ACCOUNT_NETWORK_HYDRATE_AT_MAP) |
|
const map: Record<string, number> = raw ? (JSON.parse(raw) as Record<string, number>) : {} |
|
map[pubkey.trim().toLowerCase()] = atMs |
|
window.localStorage.setItem(StorageKey.ACCOUNT_NETWORK_HYDRATE_AT_MAP, JSON.stringify(map)) |
|
} catch { |
|
/* ignore quota / privacy mode */ |
|
} |
|
} |
|
} |
|
|
|
const instance = new LocalStorageService() |
|
export default instance
|
|
|