mirror of
https://github.com/nimbold/Firelink.git
synced 2026-08-06 17:38:06 +00:00
NimBold
604 lines
25 KiB
TypeScript
604 lines
25 KiB
TypeScript
import { create } from 'zustand';
|
|
import { persist, createJSONStorage, StateStorage } from 'zustand/middleware';
|
|
import { invokeCommand as invoke } from '../ipc';
|
|
import { info } from '../utils/logger';
|
|
import type { ActiveView } from '../bindings/ActiveView';
|
|
import type { AppFontSize } from '../bindings/AppFontSize';
|
|
import type { ListRowDensity } from '../bindings/ListRowDensity';
|
|
import type { MediaCookieSource } from '../bindings/MediaCookieSource';
|
|
import type { PostQueueAction } from '../bindings/PostQueueAction';
|
|
import type { PersistedSettings } from '../bindings/PersistedSettings';
|
|
import type { ProxyMode } from '../bindings/ProxyMode';
|
|
import type { SchedulerSettings } from '../bindings/SchedulerSettings';
|
|
import type { SettingsTab } from '../bindings/SettingsTab';
|
|
import type { SiteLogin } from '../bindings/SiteLogin';
|
|
import type { Theme } from '../bindings/Theme';
|
|
import {
|
|
DEFAULT_CATEGORY_SUBFOLDERS,
|
|
normalizeDownloadLocationSettings
|
|
} from '../utils/downloadLocations';
|
|
import { normalizeSpeedLimitForBackend } from '../utils/downloads';
|
|
|
|
let settingsSave = Promise.resolve();
|
|
const DEFAULT_SCHEDULER_QUEUE_ID = '00000000-0000-0000-0000-000000000001';
|
|
export const DEFAULT_SPEED_LIMIT_PRESET_VALUES = [1, 5, 10];
|
|
|
|
const THEME_VALUES = ['system', 'light', 'dark', 'dracula', 'nord'] as const;
|
|
const APP_FONT_SIZE_VALUES = ['small', 'standard', 'large'] as const;
|
|
const LIST_ROW_DENSITY_VALUES = ['compact', 'standard', 'relaxed'] as const;
|
|
const PROXY_MODE_VALUES = ['none', 'system', 'custom'] as const;
|
|
const MEDIA_COOKIE_SOURCE_VALUES = [
|
|
'none', 'safari', 'chrome', 'chromium', 'firefox', 'edge', 'brave', 'opera', 'vivaldi', 'whale'
|
|
] as const;
|
|
const SETTINGS_TAB_VALUES = [
|
|
'downloads', 'lookandfeel', 'network', 'locations', 'sitelogins', 'power', 'engine', 'integrations', 'about'
|
|
] as const;
|
|
|
|
type PersistedSettingsSnapshot = PersistedSettings & {
|
|
keychainPromptDismissed: boolean;
|
|
keychainAccessVersion: string;
|
|
};
|
|
|
|
const clampSettingInteger = (
|
|
value: unknown,
|
|
minimum: number,
|
|
maximum: number,
|
|
fallback: number
|
|
) => {
|
|
const numeric = typeof value === 'number' ? value : Number(value);
|
|
if (!Number.isFinite(numeric)) return fallback;
|
|
return Math.min(maximum, Math.max(minimum, Math.trunc(numeric)));
|
|
};
|
|
|
|
const isAllowedSetting = <T extends string>(values: readonly T[], value: unknown): value is T =>
|
|
typeof value === 'string' && values.includes(value as T);
|
|
|
|
const isRecord = (value: unknown): value is Record<string, unknown> =>
|
|
value !== null && typeof value === 'object' && !Array.isArray(value);
|
|
|
|
const sanitizeSiteLogins = (value: unknown): SiteLogin[] => {
|
|
if (!Array.isArray(value)) return [];
|
|
return value.filter(isRecord).filter((login): login is SiteLogin =>
|
|
typeof login.id === 'string'
|
|
&& typeof login.urlPattern === 'string'
|
|
&& typeof login.username === 'string'
|
|
);
|
|
};
|
|
|
|
const persistedBoolean = (value: unknown, fallback: boolean) =>
|
|
typeof value === 'boolean' ? value : fallback;
|
|
|
|
const tauriStorage: StateStorage = {
|
|
getItem: async (name: string): Promise<string | null> => {
|
|
if (name === 'firelink-settings') {
|
|
try {
|
|
return await invoke('db_load_settings');
|
|
} catch (e) {
|
|
console.error("Failed to load settings from DB", e);
|
|
return null;
|
|
}
|
|
}
|
|
return null;
|
|
},
|
|
setItem: async (name: string, value: string): Promise<void> => {
|
|
if (name === 'firelink-settings') {
|
|
settingsSave = settingsSave
|
|
.then(() => invoke('db_save_settings', { data: value }))
|
|
.catch(e => {
|
|
console.error("Failed to save settings to DB", e);
|
|
});
|
|
await settingsSave;
|
|
}
|
|
},
|
|
removeItem: async (_name: string): Promise<void> => {
|
|
// no-op for now
|
|
},
|
|
};
|
|
|
|
/**
|
|
* Keychain identifier for the browser-extension pairing token. The token is an
|
|
* HMAC shared secret and is therefore persisted via the OS keychain rather
|
|
* than the user-data database. Legacy plaintext values are migrated into the
|
|
* Keychain before being removed from persisted settings. Portable mode is the
|
|
* explicit exception: its pairing token is persisted with the portable folder
|
|
* so extension pairing follows that folder.
|
|
*/
|
|
export type {
|
|
ActiveView,
|
|
AppFontSize,
|
|
ListRowDensity,
|
|
MediaCookieSource,
|
|
PostQueueAction,
|
|
ProxyMode,
|
|
SchedulerSettings,
|
|
SettingsTab,
|
|
SiteLogin,
|
|
Theme
|
|
};
|
|
|
|
export interface SettingsState {
|
|
theme: Theme;
|
|
baseDownloadFolder: string;
|
|
categorySubfoldersEnabled: boolean;
|
|
categorySubfolders: Record<string, string>;
|
|
categoryDirectoryOverrides: Record<string, string>;
|
|
approvedDownloadRoots: string[];
|
|
maxConcurrentDownloads: number;
|
|
globalSpeedLimit: string;
|
|
speedLimitPresetValues: number[];
|
|
logsEnabled: boolean;
|
|
isSidebarVisible: boolean;
|
|
activeView: ActiveView;
|
|
activeSettingsTab: SettingsTab;
|
|
scheduler: SchedulerSettings;
|
|
schedulerRunning: boolean;
|
|
schedulerActiveDownloadIds: string[];
|
|
schedulerLastStartKey: string;
|
|
schedulerLastStopKey: string;
|
|
lastCustomSpeedLimitKiB: number;
|
|
lastCustomSpeedLimitUnit: string;
|
|
|
|
// Replicated SwiftUI App Settings
|
|
perServerConnections: number;
|
|
maxAutomaticRetries: number;
|
|
showNotifications: boolean;
|
|
playCompletionSound: boolean;
|
|
autoAddClipboardLinks: boolean;
|
|
appFontSize: AppFontSize;
|
|
listRowDensity: ListRowDensity;
|
|
showDockBadge: boolean;
|
|
showMenuBarIcon: boolean;
|
|
proxyMode: ProxyMode;
|
|
proxyHost: string;
|
|
proxyPort: number;
|
|
customUserAgent: string;
|
|
askWhereToSaveEachFile: boolean;
|
|
preventsSleepWhileDownloading: boolean;
|
|
mediaCookieSource: MediaCookieSource;
|
|
siteLogins: SiteLogin[];
|
|
extensionPairingToken: string;
|
|
isPairingTokenPersistent: boolean;
|
|
keychainAccessGranted: boolean;
|
|
keychainAccessVersion: string;
|
|
keychainAccessReady: boolean;
|
|
keychainPromptDismissed: boolean;
|
|
autoCheckUpdates: boolean;
|
|
showKeychainModal: boolean;
|
|
|
|
setTheme: (theme: Theme) => void;
|
|
setBaseDownloadFolder: (path: string) => void;
|
|
approveDownloadRoot: (path: string) => Promise<string>;
|
|
setMaxConcurrentDownloads: (count: number) => void;
|
|
setGlobalSpeedLimit: (limit: string) => Promise<void>;
|
|
setSpeedLimitPresetValues: (values: number[]) => void;
|
|
setLogsEnabled: (enabled: boolean) => void;
|
|
setActiveView: (view: ActiveView) => void;
|
|
setActiveSettingsTab: (tab: SettingsTab) => void;
|
|
setScheduler: (settings: SchedulerSettings) => void;
|
|
setSchedulerRunning: (running: boolean) => void;
|
|
setSchedulerActiveDownloadIds: (ids: string[]) => void;
|
|
setSchedulerLastStartKey: (key: string) => void;
|
|
setSchedulerLastStopKey: (key: string) => void;
|
|
setLastCustomSpeedLimitKiB: (limit: number) => void;
|
|
setLastCustomSpeedLimitUnit: (unit: string) => void;
|
|
toggleSidebar: () => void;
|
|
|
|
setPerServerConnections: (count: number) => void;
|
|
setMaxAutomaticRetries: (count: number) => void;
|
|
setShowNotifications: (show: boolean) => void;
|
|
setPlayCompletionSound: (play: boolean) => void;
|
|
setAutoAddClipboardLinks: (enabled: boolean) => void;
|
|
setAppFontSize: (size: AppFontSize) => void;
|
|
setListRowDensity: (density: ListRowDensity) => void;
|
|
setShowDockBadge: (show: boolean) => void;
|
|
setShowMenuBarIcon: (show: boolean) => void;
|
|
setProxyMode: (mode: ProxyMode) => void;
|
|
setProxyHost: (host: string) => void;
|
|
setProxyPort: (port: number) => void;
|
|
setCustomUserAgent: (userAgent: string) => void;
|
|
setAskWhereToSaveEachFile: (ask: boolean) => void;
|
|
setPreventsSleepWhileDownloading: (prevent: boolean) => void;
|
|
setMediaCookieSource: (source: MediaCookieSource) => void;
|
|
setCategorySubfoldersEnabled: (enabled: boolean) => void;
|
|
setCategorySubfolder: (category: string, subfolder: string) => void;
|
|
setCategoryDirectoryOverride: (category: string, path?: string) => void;
|
|
resetCategoryLocations: () => void;
|
|
addSiteLogin: (login: SiteLogin) => void;
|
|
removeSiteLogin: (id: string) => void;
|
|
regeneratePairingToken: () => Promise<void>;
|
|
setAutoCheckUpdates: (autoCheckUpdates: boolean) => void;
|
|
hydratePairingToken: () => Promise<boolean>;
|
|
setShowKeychainModal: (show: boolean) => void;
|
|
setKeychainAccessReady: (ready: boolean) => void;
|
|
dismissKeychainPrompt: (version?: string) => void;
|
|
hydrateSessionPairingToken: () => Promise<void>;
|
|
}
|
|
|
|
export const useSettingsStore = create<SettingsState>()(
|
|
persist(
|
|
(set, get) => ({
|
|
theme: 'system',
|
|
baseDownloadFolder: '~/Downloads',
|
|
categorySubfoldersEnabled: true,
|
|
categorySubfolders: { ...DEFAULT_CATEGORY_SUBFOLDERS },
|
|
categoryDirectoryOverrides: {},
|
|
approvedDownloadRoots: [],
|
|
maxConcurrentDownloads: 3,
|
|
globalSpeedLimit: '',
|
|
speedLimitPresetValues: DEFAULT_SPEED_LIMIT_PRESET_VALUES,
|
|
logsEnabled: false,
|
|
activeView: 'downloads',
|
|
activeSettingsTab: 'downloads',
|
|
isSidebarVisible: true,
|
|
scheduler: {
|
|
enabled: false,
|
|
startTime: '00:00',
|
|
stopTimeEnabled: false,
|
|
stopTime: '08:00',
|
|
everyday: true,
|
|
selectedDays: [0, 1, 2, 3, 4, 5, 6],
|
|
selectedQueueIds: [DEFAULT_SCHEDULER_QUEUE_ID],
|
|
postQueueAction: 'none'
|
|
},
|
|
schedulerRunning: false,
|
|
schedulerActiveDownloadIds: [],
|
|
schedulerLastStartKey: '',
|
|
schedulerLastStopKey: '',
|
|
lastCustomSpeedLimitKiB: 1024,
|
|
lastCustomSpeedLimitUnit: 'MB/s',
|
|
|
|
// Replicated SwiftUI defaults
|
|
perServerConnections: 16,
|
|
maxAutomaticRetries: 3,
|
|
showNotifications: true,
|
|
playCompletionSound: false,
|
|
autoAddClipboardLinks: false,
|
|
appFontSize: 'standard',
|
|
listRowDensity: 'standard',
|
|
showDockBadge: true,
|
|
showMenuBarIcon: true,
|
|
proxyMode: 'none',
|
|
proxyHost: '',
|
|
proxyPort: 8080,
|
|
customUserAgent: '',
|
|
askWhereToSaveEachFile: false,
|
|
preventsSleepWhileDownloading: true,
|
|
mediaCookieSource: 'none',
|
|
siteLogins: [],
|
|
extensionPairingToken: '',
|
|
isPairingTokenPersistent: false,
|
|
keychainAccessGranted: false,
|
|
keychainAccessVersion: '',
|
|
keychainAccessReady: false,
|
|
keychainPromptDismissed: false,
|
|
autoCheckUpdates: true,
|
|
showKeychainModal: false,
|
|
|
|
setTheme: (theme) => { info('Settings updated: theme'); set({ theme }); },
|
|
setBaseDownloadFolder: (path) => {
|
|
info('Settings updated: baseDownloadFolder');
|
|
set({ baseDownloadFolder: path });
|
|
},
|
|
approveDownloadRoot: async (path) => {
|
|
const approvedPath = await invoke('approve_download_root', { path });
|
|
set(state => ({
|
|
approvedDownloadRoots: state.approvedDownloadRoots.includes(approvedPath)
|
|
? state.approvedDownloadRoots
|
|
: [...state.approvedDownloadRoots, approvedPath]
|
|
}));
|
|
return approvedPath;
|
|
},
|
|
setMaxConcurrentDownloads: (max) => {
|
|
info('Settings updated: maxConcurrentDownloads');
|
|
set({
|
|
maxConcurrentDownloads: clampSettingInteger(max, 1, 12, 3)
|
|
});
|
|
},
|
|
setGlobalSpeedLimit: async (limit) => {
|
|
await invoke('set_global_speed_limit', {
|
|
limit: normalizeSpeedLimitForBackend(limit)
|
|
});
|
|
info('Settings updated: globalSpeedLimit');
|
|
set({ globalSpeedLimit: limit });
|
|
},
|
|
setSpeedLimitPresetValues: (speedLimitPresetValues) => set({ speedLimitPresetValues }),
|
|
setLogsEnabled: (logsEnabled) => set({ logsEnabled }),
|
|
setActiveView: (view) => set({ activeView: view }),
|
|
setActiveSettingsTab: (activeSettingsTab) => set({ activeSettingsTab }),
|
|
setScheduler: (scheduler) => set({ scheduler }),
|
|
setSchedulerRunning: (schedulerRunning) => set({ schedulerRunning }),
|
|
setSchedulerActiveDownloadIds: (schedulerActiveDownloadIds) => set({ schedulerActiveDownloadIds }),
|
|
setSchedulerLastStartKey: (schedulerLastStartKey) => set({ schedulerLastStartKey }),
|
|
setSchedulerLastStopKey: (schedulerLastStopKey) => set({ schedulerLastStopKey }),
|
|
setLastCustomSpeedLimitKiB: (lastCustomSpeedLimitKiB) => set({ lastCustomSpeedLimitKiB }),
|
|
setLastCustomSpeedLimitUnit: (lastCustomSpeedLimitUnit) => set({ lastCustomSpeedLimitUnit }),
|
|
toggleSidebar: () => set((state) => ({ isSidebarVisible: !state.isSidebarVisible })),
|
|
|
|
setPerServerConnections: (perServerConnections) => set({
|
|
perServerConnections: clampSettingInteger(perServerConnections, 1, 16, 16)
|
|
}),
|
|
setMaxAutomaticRetries: (maxAutomaticRetries) => set({
|
|
maxAutomaticRetries: clampSettingInteger(maxAutomaticRetries, 0, 10, 3)
|
|
}),
|
|
setShowNotifications: (showNotifications) => set({ showNotifications }),
|
|
setPlayCompletionSound: (playCompletionSound) => set({ playCompletionSound }),
|
|
setAutoAddClipboardLinks: (autoAddClipboardLinks) => set({ autoAddClipboardLinks }),
|
|
setAppFontSize: (appFontSize) => set({ appFontSize }),
|
|
setListRowDensity: (listRowDensity) => set({ listRowDensity }),
|
|
setShowDockBadge: (showDockBadge) => {
|
|
set({ showDockBadge });
|
|
if (!showDockBadge) invoke('update_dock_badge', { count: 0 }).catch(console.error);
|
|
},
|
|
setShowMenuBarIcon: (showMenuBarIcon) => set({ showMenuBarIcon }),
|
|
setProxyMode: (proxyMode) => set({ proxyMode }),
|
|
setProxyHost: (proxyHost) => set({ proxyHost }),
|
|
setProxyPort: (proxyPort) => set({
|
|
proxyPort: Number.isFinite(proxyPort)
|
|
? Math.min(65535, Math.max(1, Math.trunc(proxyPort)))
|
|
: 8080
|
|
}),
|
|
setCustomUserAgent: (customUserAgent) => set({ customUserAgent }),
|
|
setAskWhereToSaveEachFile: (askWhereToSaveEachFile) => set({ askWhereToSaveEachFile }),
|
|
setPreventsSleepWhileDownloading: (preventsSleepWhileDownloading) => {
|
|
info('Settings updated: preventsSleepWhileDownloading');
|
|
set({ preventsSleepWhileDownloading });
|
|
},
|
|
setMediaCookieSource: (mediaCookieSource) => { info('Settings updated: mediaCookieSource'); set({ mediaCookieSource }); },
|
|
setCategorySubfoldersEnabled: (categorySubfoldersEnabled) => {
|
|
info('Settings updated: categorySubfoldersEnabled');
|
|
set({ categorySubfoldersEnabled });
|
|
},
|
|
setCategorySubfolder: (category, subfolder) => {
|
|
info(`Settings updated: category subfolder ${category}`);
|
|
set((state) => ({
|
|
categorySubfolders: { ...state.categorySubfolders, [category]: subfolder }
|
|
}));
|
|
},
|
|
setCategoryDirectoryOverride: (category, path) => {
|
|
info(`Settings updated: category directory override ${category}`);
|
|
set((state) => {
|
|
const next = { ...state.categoryDirectoryOverrides };
|
|
if (path?.trim()) next[category] = path.trim();
|
|
else delete next[category];
|
|
return { categoryDirectoryOverrides: next };
|
|
});
|
|
},
|
|
resetCategoryLocations: () => {
|
|
info('Settings updated: resetCategoryLocations');
|
|
set({
|
|
categorySubfolders: { ...DEFAULT_CATEGORY_SUBFOLDERS },
|
|
categoryDirectoryOverrides: {}
|
|
});
|
|
},
|
|
addSiteLogin: (login) => set((state) => ({
|
|
siteLogins: [...state.siteLogins, login]
|
|
})),
|
|
removeSiteLogin: (id) => set((state) => ({
|
|
siteLogins: state.siteLogins.filter((login) => login.id !== id)
|
|
})),
|
|
regeneratePairingToken: async () => {
|
|
const result = await invoke('regenerate_pairing_token');
|
|
if (!result.persistent) {
|
|
throw new Error(result.error || 'Credential store access is unavailable.');
|
|
}
|
|
set({
|
|
extensionPairingToken: result.token,
|
|
isPairingTokenPersistent: true,
|
|
showKeychainModal: false
|
|
});
|
|
},
|
|
hydratePairingToken: async () => {
|
|
// The backend migrates legacy settings copies and reads the token from
|
|
// the credential store after the app state is ready to receive it.
|
|
// Portable mode remains the explicit folder-contained exception.
|
|
const result = await invoke('hydrate_extension_pairing_token');
|
|
set({
|
|
extensionPairingToken: result.token,
|
|
isPairingTokenPersistent: result.persistent,
|
|
showKeychainModal: !result.persistent && !get().keychainPromptDismissed
|
|
});
|
|
return result.tokenChanged;
|
|
},
|
|
hydrateSessionPairingToken: async () => {
|
|
const result = await invoke('get_session_pairing_token');
|
|
set({
|
|
extensionPairingToken: result.token,
|
|
isPairingTokenPersistent: false,
|
|
keychainAccessReady: false
|
|
});
|
|
},
|
|
setAutoCheckUpdates: (autoCheckUpdates: boolean) => set({ autoCheckUpdates }),
|
|
setShowKeychainModal: (show: boolean) => set({ showKeychainModal: show }),
|
|
setKeychainAccessReady: (ready: boolean) => set({ keychainAccessReady: ready }),
|
|
dismissKeychainPrompt: (version?: string) => set(state => ({
|
|
keychainAccessGranted: false,
|
|
isPairingTokenPersistent: false,
|
|
keychainAccessReady: false,
|
|
keychainAccessVersion: version || state.keychainAccessVersion,
|
|
keychainPromptDismissed: true,
|
|
showKeychainModal: false
|
|
})),
|
|
}),
|
|
{
|
|
name: 'firelink-settings',
|
|
storage: createJSONStorage(() => tauriStorage),
|
|
version: 3,
|
|
migrate: (persistedState) => {
|
|
if (!persistedState || typeof persistedState !== 'object') {
|
|
return persistedState as SettingsState;
|
|
}
|
|
const persisted = persistedState as Partial<SettingsState>;
|
|
const locations = normalizeDownloadLocationSettings(
|
|
persisted as Partial<SettingsState> & {
|
|
defaultDownloadPath?: unknown;
|
|
downloadDirectories?: unknown;
|
|
}
|
|
);
|
|
return {
|
|
...persisted,
|
|
...locations,
|
|
scheduler: persisted.scheduler
|
|
? {
|
|
...persisted.scheduler,
|
|
selectedQueueIds: Array.isArray(persisted.scheduler.selectedQueueIds)
|
|
&& persisted.scheduler.selectedQueueIds.length > 0
|
|
? persisted.scheduler.selectedQueueIds
|
|
: [DEFAULT_SCHEDULER_QUEUE_ID]
|
|
}
|
|
: persisted.scheduler,
|
|
siteLogins: Array.isArray(persisted.siteLogins) ? persisted.siteLogins : [],
|
|
approvedDownloadRoots: Array.isArray(persisted.approvedDownloadRoots)
|
|
? persisted.approvedDownloadRoots
|
|
: [],
|
|
speedLimitPresetValues: Array.isArray(persisted.speedLimitPresetValues)
|
|
? persisted.speedLimitPresetValues
|
|
: DEFAULT_SPEED_LIMIT_PRESET_VALUES,
|
|
logsEnabled: persisted.logsEnabled === true
|
|
} as SettingsState;
|
|
},
|
|
partialize: (state): PersistedSettingsSnapshot => ({
|
|
theme: state.theme,
|
|
baseDownloadFolder: state.baseDownloadFolder,
|
|
categorySubfoldersEnabled: state.categorySubfoldersEnabled,
|
|
categorySubfolders: state.categorySubfolders,
|
|
categoryDirectoryOverrides: state.categoryDirectoryOverrides,
|
|
approvedDownloadRoots: state.approvedDownloadRoots,
|
|
maxConcurrentDownloads: state.maxConcurrentDownloads,
|
|
globalSpeedLimit: state.globalSpeedLimit,
|
|
speedLimitPresetValues: state.speedLimitPresetValues,
|
|
logsEnabled: state.logsEnabled,
|
|
isSidebarVisible: state.isSidebarVisible,
|
|
activeSettingsTab: state.activeSettingsTab,
|
|
scheduler: state.scheduler,
|
|
schedulerRunning: state.schedulerRunning,
|
|
schedulerActiveDownloadIds: state.schedulerActiveDownloadIds,
|
|
schedulerLastStartKey: state.schedulerLastStartKey,
|
|
schedulerLastStopKey: state.schedulerLastStopKey,
|
|
lastCustomSpeedLimitKiB: state.lastCustomSpeedLimitKiB,
|
|
lastCustomSpeedLimitUnit: state.lastCustomSpeedLimitUnit,
|
|
|
|
perServerConnections: state.perServerConnections,
|
|
maxAutomaticRetries: state.maxAutomaticRetries,
|
|
showNotifications: state.showNotifications,
|
|
playCompletionSound: state.playCompletionSound,
|
|
autoAddClipboardLinks: state.autoAddClipboardLinks,
|
|
appFontSize: state.appFontSize,
|
|
listRowDensity: state.listRowDensity,
|
|
showDockBadge: state.showDockBadge,
|
|
showMenuBarIcon: state.showMenuBarIcon,
|
|
proxyMode: state.proxyMode,
|
|
proxyHost: state.proxyHost,
|
|
proxyPort: state.proxyPort,
|
|
customUserAgent: state.customUserAgent,
|
|
askWhereToSaveEachFile: state.askWhereToSaveEachFile,
|
|
preventsSleepWhileDownloading: state.preventsSleepWhileDownloading,
|
|
mediaCookieSource: state.mediaCookieSource,
|
|
siteLogins: state.siteLogins,
|
|
keychainAccessGranted: state.keychainAccessGranted,
|
|
keychainAccessVersion: state.keychainAccessVersion,
|
|
keychainPromptDismissed: state.keychainPromptDismissed,
|
|
autoCheckUpdates: state.autoCheckUpdates
|
|
}),
|
|
merge: (persistedState: unknown, currentState) => {
|
|
const persisted = persistedState && typeof persistedState === 'object'
|
|
? persistedState as Partial<SettingsState>
|
|
: {};
|
|
const locations = normalizeDownloadLocationSettings(persisted);
|
|
return ({
|
|
...currentState,
|
|
...persisted,
|
|
...locations,
|
|
extensionPairingToken: currentState.extensionPairingToken,
|
|
keychainAccessReady: currentState.keychainAccessReady,
|
|
theme: isAllowedSetting(THEME_VALUES, persisted.theme)
|
|
? persisted.theme
|
|
: currentState.theme,
|
|
appFontSize: isAllowedSetting(APP_FONT_SIZE_VALUES, persisted.appFontSize)
|
|
? persisted.appFontSize
|
|
: currentState.appFontSize,
|
|
listRowDensity: isAllowedSetting(LIST_ROW_DENSITY_VALUES, persisted.listRowDensity)
|
|
? persisted.listRowDensity
|
|
: currentState.listRowDensity,
|
|
proxyMode: isAllowedSetting(PROXY_MODE_VALUES, persisted.proxyMode)
|
|
? persisted.proxyMode
|
|
: currentState.proxyMode,
|
|
mediaCookieSource: isAllowedSetting(MEDIA_COOKIE_SOURCE_VALUES, persisted.mediaCookieSource)
|
|
? persisted.mediaCookieSource
|
|
: 'none',
|
|
activeSettingsTab: isAllowedSetting(SETTINGS_TAB_VALUES, persisted.activeSettingsTab)
|
|
? persisted.activeSettingsTab
|
|
: currentState.activeSettingsTab,
|
|
showNotifications: persistedBoolean(persisted.showNotifications, currentState.showNotifications),
|
|
playCompletionSound: persistedBoolean(persisted.playCompletionSound, currentState.playCompletionSound),
|
|
autoAddClipboardLinks: persistedBoolean(
|
|
persisted.autoAddClipboardLinks,
|
|
currentState.autoAddClipboardLinks
|
|
),
|
|
showDockBadge: persistedBoolean(persisted.showDockBadge, currentState.showDockBadge),
|
|
showMenuBarIcon: persistedBoolean(persisted.showMenuBarIcon, currentState.showMenuBarIcon),
|
|
askWhereToSaveEachFile: persistedBoolean(
|
|
persisted.askWhereToSaveEachFile,
|
|
currentState.askWhereToSaveEachFile
|
|
),
|
|
preventsSleepWhileDownloading: persistedBoolean(
|
|
persisted.preventsSleepWhileDownloading,
|
|
currentState.preventsSleepWhileDownloading
|
|
),
|
|
keychainAccessGranted: persistedBoolean(
|
|
persisted.keychainAccessGranted,
|
|
currentState.keychainAccessGranted
|
|
),
|
|
keychainAccessVersion: typeof persisted.keychainAccessVersion === 'string'
|
|
? persisted.keychainAccessVersion
|
|
: currentState.keychainAccessVersion,
|
|
keychainPromptDismissed: persistedBoolean(
|
|
persisted.keychainPromptDismissed,
|
|
currentState.keychainPromptDismissed
|
|
),
|
|
autoCheckUpdates: persistedBoolean(persisted.autoCheckUpdates, currentState.autoCheckUpdates),
|
|
maxConcurrentDownloads: clampSettingInteger(
|
|
persisted.maxConcurrentDownloads,
|
|
1,
|
|
12,
|
|
currentState.maxConcurrentDownloads
|
|
),
|
|
perServerConnections: clampSettingInteger(
|
|
persisted.perServerConnections,
|
|
1,
|
|
16,
|
|
currentState.perServerConnections
|
|
),
|
|
maxAutomaticRetries: clampSettingInteger(
|
|
persisted.maxAutomaticRetries,
|
|
0,
|
|
10,
|
|
currentState.maxAutomaticRetries
|
|
),
|
|
speedLimitPresetValues: Array.isArray(persisted.speedLimitPresetValues)
|
|
? persisted.speedLimitPresetValues
|
|
: currentState.speedLimitPresetValues,
|
|
lastCustomSpeedLimitUnit: persisted.lastCustomSpeedLimitUnit === 'KB/s'
|
|
|| persisted.lastCustomSpeedLimitUnit === 'MB/s'
|
|
? persisted.lastCustomSpeedLimitUnit
|
|
: currentState.lastCustomSpeedLimitUnit,
|
|
logsEnabled: persisted.logsEnabled === true,
|
|
approvedDownloadRoots: Array.isArray(persisted.approvedDownloadRoots)
|
|
? persisted.approvedDownloadRoots
|
|
: currentState.approvedDownloadRoots,
|
|
scheduler: {
|
|
...currentState.scheduler,
|
|
...persisted.scheduler,
|
|
selectedQueueIds: Array.isArray(persisted.scheduler?.selectedQueueIds)
|
|
&& persisted.scheduler.selectedQueueIds.length > 0
|
|
? persisted.scheduler.selectedQueueIds
|
|
: currentState.scheduler.selectedQueueIds
|
|
},
|
|
siteLogins: Array.isArray(persisted.siteLogins)
|
|
? sanitizeSiteLogins(persisted.siteLogins)
|
|
: currentState.siteLogins
|
|
});
|
|
}
|
|
}
|
|
)
|
|
);
|