No OneTemporary
Actions

Authored By

Unknown

Size

55 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/modules/default_config_state.js b/src/modules/default_config_state.js
	index 8634752bd3..429bdd9310 100644
	--- a/src/modules/default_config_state.js
	+++ b/src/modules/default_config_state.js
	@@ -1,222 +1,223 @@
	const browserLocale = (navigator.language \|\| 'en').split('-')[0]

	/// Instance config entries provided by static config or pleroma api
	/// Put settings here only if it does not make sense for a normal user
	/// to override it.
	export const staticOrApiConfigDefault = {
	name: 'PleromaFE',
	- theme: 'pleroma-dark',
	+ theme: null,
	palette: null,
	- style: null,
	+ style: 'breezy',
	themeChecksum: undefined,
	defaultAvatar: '/images/avi.png',
	defaultBanner: '/images/banner.png',
	background: '/static/aurora_borealis.jpg',
	embeddedToS: true,
	logo: '/static/logo.svg',
	logoMargin: '.2em',
	logoMask: true,
	logoLeft: false,
	redirectRootLogin: '/main/friends',
	redirectRootNoLogin: '/main/all',
	hideSitename: false,
	nsfwCensorImage: null,
	showFeaturesPanel: true,
	showInstanceSpecificPanel: false,

	// Html stuff
	instanceSpecificPanelContent: '',
	tos: '',
	}

	/// This object contains setting entries that makes sense
	/// at the user level. The defaults can also be overriden by
	/// instance admins in the frontend_configuration endpoint or static config.
	export const instanceDefaultConfig = {
	expertLevel: 0, // used to track which settings to show and hide
	hideISP: false,
	hideInstanceWallpaper: false,
	hideShoutbox: false,
	// bad name: actually hides posts of muted USERS
	hideMutedPosts: false,
	hideMutedThreads: true,
	hideWordFilteredPosts: false,
	muteBotStatuses: false,
	muteSensitiveStatuses: false,
	collapseMessageWithSubject: false,
	padEmoji: true,
	hideAttachmentsInConv: false,
	hideScrobbles: false,
	hideScrobblesAfter: '2d',
	maxThumbnails: 16,
	loopVideo: true,
	loopVideoSilentOnly: true,
	/// This is not the streaming API configuration, but rather an option
	/// for automatically loading new posts into the timeline without
	/// the user clicking the Show New button.
	streaming: false,
	emojiReactionsOnTimeline: true,
	alwaysShowNewPostButton: false,
	autohideFloatingPostButton: false,
	pauseOnUnfocused: true,
	stopGifs: true,
	replyVisibility: 'all',
	thirdColumnMode: 'notifications',
	notificationVisibility: {
	follows: true,
	mentions: true,
	statuses: true,
	likes: true,
	repeats: true,
	moves: true,
	emojiReactions: true,
	followRequest: true,
	reports: true,
	chatMention: true,
	polls: true,
	},
	notificationNative: {
	follows: true,
	mentions: true,
	statuses: true,
	likes: false,
	repeats: false,
	moves: false,
	emojiReactions: false,
	followRequest: true,
	reports: true,
	chatMention: true,
	polls: true,
	},
	webPushNotifications: false,
	webPushAlwaysShowNotifications: false,
	interfaceLanguage: browserLocale,
	hideScopeNotice: false,
	scopeCopy: true,
	subjectLineBehavior: 'email',
	alwaysShowSubjectInput: true,
	minimalScopesMode: false,

	// This hides statuses filtered via a word filter
	hideFilteredStatuses: false,

	// Confirmations
	modalOnRepeat: false,
	modalOnUnfollow: false,
	modalOnBlock: true,
	modalOnMute: false,
	modalOnMuteConversation: false,
	modalOnMuteDomain: true,
	modalOnDelete: true,
	modalOnLogout: true,
	modalOnApproveFollow: false,
	modalOnDenyFollow: false,
	modalOnRemoveUserFromFollowers: false,

	// Expiry confirmations/default actions
	onMuteDefaultAction: 'ask',
	onBlockDefaultAction: 'ask',

	modalMobileCenter: false,
	playVideosInModal: false,
	useContainFit: true,
	disableStickyHeaders: false,
	showScrollbars: false,
	userPopoverAvatarAction: 'open',
	userPopoverOverlay: false,
	userCardLeftJustify: false,
	userCardHidePersonalMarks: false,
	forcedRoundness: -1,
	greentext: false,
	mentionLinkShowTooltip: true,
	mentionLinkShowAvatar: false,
	mentionLinkFadeDomain: true,
	mentionLinkShowYous: false,
	mentionLinkBoldenYou: true,
	hidePostStats: false,
	hideBotIndication: false,
	hideUserStats: false,
	virtualScrolling: true,
	sensitiveByDefault: false,
	conversationDisplay: 'linear',
	conversationTreeAdvanced: false,
	conversationOtherRepliesButton: 'below',
	conversationTreeFadeAncestors: false,
	showExtraNotifications: true,
	showExtraNotificationsTip: true,
	showChatsInExtraNotifications: true,
	showAnnouncementsInExtraNotifications: true,
	showFollowRequestsInExtraNotifications: true,
	maxDepthInThread: 6,
	autocompleteSelect: false,
	closingDrawerMarksAsSeen: true,
	unseenAtTop: false,
	ignoreInactionableSeen: false,
	unsavedPostAction: 'confirm',
	autoSaveDraft: false,
	useAbsoluteTimeFormat: false,
	absoluteTimeFormatMinAge: '0d',
	absoluteTime12h: '24h',
	}

	export const defaultConfigLocal = {
	hideAttachments: false,
	hideAttachmentsInConv: false,
	hideNsfw: true,
	useOneClickNsfw: false,
	preloadImage: true,
	postContentType: 'text/plain',
	sidebarRight: false,
	sidebarColumnWidth: '25rem',
	contentColumnWidth: '45rem',
	notifsColumnWidth: '25rem',
	themeEditorMinWidth: '0rem',
	emojiReactionsScale: 0.5,
	textSize: '1rem',
	emojiSize: '2.2rem',
	navbarSize: '3.5rem',
	panelHeaderSize: '3.2rem',
	navbarColumnStretch: false,
	mentionLinkDisplay: 'short',
	alwaysUseJpeg: false,
	imageCompression: true,
	useStreamingApi: false,
	underlay: 'none',
	fontInterface: undefined,
	fontInput: undefined,
	fontPosts: undefined,
	fontMonospace: undefined,
	themeDebug: false, // debug mode that uses computed backgrounds instead of real ones to debug contrast functions
	forceThemeRecompilation: false, // flag that forces recompilation on boot even if cache exists
	}
	+
	export const LOCAL_ONLY_KEYS = new Set(Object.keys(defaultConfigLocal))

	export const makeUndefined = (c) =>
	Object.fromEntries(Object.keys(c).map((key) => [key, undefined]))

	/// For properties with special processing or properties that does not
	/// make sense to be overriden on a instance-wide level.
	export const defaultState = {
	// Set these to undefined so it does not interfere with default settings check
	...makeUndefined(instanceDefaultConfig),
	...makeUndefined(defaultConfigLocal),
	// If there are any configurations that does not make sense to
	// have instance-wide default, put it here and explain why.

	// # Special processing
	// ## Theme stuff
	theme: undefined, // Very old theme store, stores preset name, still in use

	// V1
	colors: {}, // VERY old theme store, just colors of V1, probably not even used anymore

	// V2
	customTheme: undefined, // "snapshot", previously was used as actual theme store for V2 so it's still used in case of PleromaFE downgrade event.
	customThemeSource: undefined, // "source", stores original theme data

	// V3
	style: null,
	styleCustomData: null,
	palette: null,
	paletteCustomData: null,
	}
	diff --git a/src/stores/instance.js b/src/stores/instance.js
	index c893cab644..0838f7a516 100644
	--- a/src/stores/instance.js
	+++ b/src/stores/instance.js
	@@ -1,125 +1,125 @@
	import { get, set } from 'lodash'
	import { defineStore } from 'pinia'

	import { instanceDefaultProperties } from '../modules/config.js'
	import {
	- instanceDefaultConfig,
	defaultConfigLocal,
	+ instanceDefaultConfig,
	staticOrApiConfigDefault,
	} from '../modules/default_config_state.js'
	import apiService from '../services/api/api.service.js'

	import { useInterfaceStore } from 'src/stores/interface.js'

	import { ensureFinalFallback } from 'src/i18n/languages.js'

	const REMOTE_INTERACTION_URL = '/main/ostatus'

	const defaultState = {
	// Stuff from apiConfig
	name: 'Pleroma FE',
	registrationOpen: true,
	server: 'http://localhost:4040/',
	textlimit: 5000,
	privateMode: false,
	federating: true,
	federationPolicy: null,
	themesIndex: null,
	stylesIndex: null,
	palettesIndex: null,
	themeData: null, // used for theme editor v2
	vapidPublicKey: null,

	// Stuff from static/config.json
	loginMethod: 'password',
	disableUpdateNotification: false,

	// Instance-wide configurations that should not be changed by individual users
	instanceIdentity: {
	...staticOrApiConfigDefault,
	},

	limits: {
	bannerlimit: null,
	avatarlimit: null,
	backgroundlimit: null,
	uploadlimit: null,
	fieldsLimits: null,
	pollLimits: {
	max_options: 4,
	max_option_chars: 255,
	min_expiration: 60,
	max_expiration: 60 * 60 * 24,
	},
	},

	// Instance admins can override default settings for the whole instance
	prefsStorage: {
	...instanceDefaultConfig,
	...defaultConfigLocal,
	},

	// Known domains list for user's domain-muting
	knownDomains: [],

	// Moderation stuff
	staffAccounts: [],
	accountActivationRequired: null,
	accountApprovalRequired: null,
	birthdayRequired: false,
	birthdayMinAge: 0,
	restrictedNicknames: [],
	localBubbleInstances: [], // Akkoma

	// Version Information
	backendVersion: '',
	backendRepository: '',
	frontendVersion: '',
	}

	export const useInstanceStore = defineStore('instance', {
	state: () => ({ ...defaultState }),
	getters: {
	instanceDefaultConfig(state) {
	return instanceDefaultProperties
	.map((key) => [key, state[key]])
	.reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {})
	},
	instanceDomain(state) {
	return new URL(this.server).hostname
	},
	},
	actions: {
	set({ path, name, value }) {
	if (get(defaultState, path ?? name) === undefined)
	console.error(
	`Unknown instance option ${path ?? name}, value: ${value}`,
	)

	set(this, path ?? name, value)

	if ((path ?? name) === 'name') useInterfaceStore().setPageTitle()
	},
	async getKnownDomains() {
	try {
	this.knownDomains = await apiService.fetchKnownDomains({
	credentials: window.vuex.state.users.currentUser.credentials,
	})
	} catch (e) {
	console.warn("Can't load known domains\n", e)
	}
	},
	getRemoteInteractionLink({ statusId, nickname }) {
	const server = this.server.endsWith('/')
	? this.server.slice(0, -1)
	: this.server
	const link = server + REMOTE_INTERACTION_URL

	if (statusId) {
	return `${link}?status_id=${statusId}`
	} else {
	return `${link}?nickname=${nickname}`
	}
	},
	},
	})
	diff --git a/src/stores/sync_config.js b/src/stores/sync_config.js
	index 84011e2cf2..d4b5ad50a0 100644
	--- a/src/stores/sync_config.js
	+++ b/src/stores/sync_config.js
	@@ -1,789 +1,791 @@
	import sum from 'hash-sum'
	import {
	merge as _merge,
	clamp,
	cloneDeep,
	findLastIndex,
	flatten,
	get,
	groupBy,
	isEqual,
	set,
	take,
	takeRight,
	uniqWith,
	unset,
	} from 'lodash'
	import { defineStore } from 'pinia'
	import { toRaw } from 'vue'

	import { CURRENT_UPDATE_COUNTER } from 'src/components/update_notification/update_notification.js'

	import { useInstanceStore } from 'src/stores/instance.js'
	import { useLocalConfigStore } from 'src/stores/local_config.js'

	import { storage } from 'src/lib/storage.js'
	import {
	defaultState as configDefaultState,
	defaultConfigLocal,
	instanceDefaultConfig,
	LOCAL_ONLY_KEYS,
	} from 'src/modules/default_config_state.js'
	import { oldDefaultConfigSync } from 'src/modules/old_default_config_state.js'

	export const VERSION = 2
	export const NEW_USER_DATE = new Date('2026-03-16') // date of writing this, basically

	export const COMMAND_TRIM_FLAGS = 1000
	export const COMMAND_TRIM_FLAGS_AND_RESET = 1001
	export const COMMAND_WIPE_JOURNAL = 1010
	export const COMMAND_WIPE_JOURNAL_AND_STORAGE = 1011

	export const defaultState = {
	// do we need to update data on server?
	dirty: false,
	// storage of flags - stuff that can only be set and incremented
	flagStorage: {
	updateCounter: 0, // Counter for most recent update notification seen
	reset: 0, // special flag that can be used to force-reset all data, debug purposes only
	// special reset codes:
	// 1000: trim keys to those known by currently running FE
	// 1001: same as above + reset everything to 0
	},
	prefsStorage: {
	_journal: [],
	simple: {
	dontShowUpdateNotifs: false,
	collapseNav: false,
	muteFilters: {},

	...configDefaultState,
	},
	collections: {
	pinnedStatusActions: ['reply', 'retweet', 'favorite', 'emoji'],
	pinnedNavItems: ['home', 'dms', 'chats'],
	},
	},
	// raw data
	raw: null,
	// local cache
	cache: null,
	}

	export const newUserFlags = {
	...defaultState.flagStorage,
	updateCounter: CURRENT_UPDATE_COUNTER, // new users don't need to see update notification
	}

	export const _moveItemInArray = (array, value, movement) => {
	const oldIndex = array.indexOf(value)
	const newIndex = oldIndex + movement
	const newArray = [...array]
	// remove old
	newArray.splice(oldIndex, 1)
	// add new
	newArray.splice(clamp(newIndex, 0, newArray.length + 1), 0, value)
	return newArray
	}

	const _wrapData = (data, userName) => {
	return {
	...data,
	_user: userName,
	_timestamp: Date.now(),
	_version: VERSION,
	}
	}

	const _checkValidity = (data) => data._timestamp > 0 && data._version > 0

	const _verifyPrefs = (state) => {
	state.prefsStorage = state.prefsStorage \|\| {
	simple: {},
	collections: {},
	}

	// Simple
	Object.entries(defaultState.prefsStorage.simple).forEach(([k, v]) => {
	if (typeof v === 'undefined') return
	if (typeof v === 'number' \|\| typeof v === 'boolean') return
	if (typeof v === 'object') return
	console.warn(
	`Preference simple.${k} as invalid type ${typeof v}, reinitializing`,
	)
	set(state.prefsStorage.simple, k, defaultState.prefsStorage.simple[k])
	})

	// Collections
	Object.entries(defaultState.prefsStorage.collections).forEach(([k, v]) => {
	if (Array.isArray(v)) return
	console.warn(
	`Preference collections.${k} as invalid type ${typeof v}, reinitializing`,
	)
	set(
	state.prefsStorage.collections,
	k,
	defaultState.prefsStorage.collections[k],
	)
	})
	}

	export const _getRecentData = (cache, live, isTest) => {
	const result = { recent: null, stale: null, needUpload: false }
	const cacheValid = _checkValidity(cache \|\| {})
	const liveValid = _checkValidity(live \|\| {})
	if (!liveValid && cacheValid) {
	result.needUpload = true
	console.debug(
	'Nothing valid stored on server, assuming cache to be source of truth',
	)
	result.recent = cache
	result.stale = live
	} else if (!cacheValid && liveValid) {
	console.debug(
	'Valid storage on server found, no local cache found, using live as source of truth',
	)
	result.recent = live
	result.stale = cache
	} else if (cacheValid && liveValid) {
	console.debug('Both sources have valid data, figuring things out...')
	if (
	live._timestamp === cache._timestamp &&
	live._version === cache._version
	) {
	console.debug(
	'Same version/timestamp on both sources, source of truth irrelevant',
	)
	result.recent = cache
	result.stale = live
	} else {
	console.debug(
	'Different timestamp or version, figuring out which one is more recent',
	)
	if (live._timestamp < cache._timestamp) {
	result.recent = cache
	result.stale = live
	} else {
	result.recent = live
	result.stale = cache
	}
	}
	} else {
	console.debug('Both sources are invalid, start from scratch')
	result.needUpload = true
	}

	const merge = (a, b) => {
	return {
	_user: a._user ?? b._user,
	_version: a._version ?? b._version,
	_timestamp: a._timestamp ?? b._timestamp,
	needUpload: b.needUpload ?? a.needUpload,
	prefsStorage: _merge(cloneDeep(a.prefsStorage), b.prefsStorage),
	flagStorage: _merge(a.flagStorage, b.flagStorage),
	}
	}

	result.recent = isTest
	? result.recent
	: result.recent && merge(defaultState, result.recent)

	result.stale = isTest
	? result.stale
	: result.stale && merge(defaultState, result.stale)

	return result
	}

	export const _getAllFlags = (recent, stale) => {
	return Array.from(
	new Set([
	...Object.keys(toRaw((recent \|\| {}).flagStorage \|\| {})),
	...Object.keys(toRaw((stale \|\| {}).flagStorage \|\| {})),
	]),
	)
	}

	export const _mergeFlags = (recent, stale, allFlagKeys) => {
	if (!stale.flagStorage) return recent.flagStorage
	if (!recent.flagStorage) return stale.flagStorage
	return Object.fromEntries(
	allFlagKeys.map((flag) => {
	const recentFlag = recent.flagStorage[flag]
	const staleFlag = stale.flagStorage[flag]
	// use flag that is of higher value
	return [
	flag,
	Number((recentFlag > staleFlag ? recentFlag : staleFlag) \|\| 0),
	]
	}),
	)
	}

	export const _mergeJournal = (...journals) => {
	// Ignore invalid journal entries
	const allJournals = flatten(
	journals.map((j) => (Array.isArray(j) ? j : [])),
	).filter(
	(entry) =>
	Object.hasOwn(entry, 'path') &&
	Object.hasOwn(entry, 'operation') &&
	Object.hasOwn(entry, 'args') &&
	Object.hasOwn(entry, 'timestamp'),
	)
	const grouped = groupBy(allJournals, 'path')
	const trimmedGrouped = Object.entries(grouped).map(([path, journal]) => {
	// side effect
	journal.sort((a, b) => (a.timestamp > b.timestamp ? 1 : -1))

	if (path.startsWith('collections')) {
	const lastRemoveIndex = findLastIndex(
	journal,
	({ operation }) => operation === 'removeFromCollection',
	)
	// everything before last remove is unimportant
	let remainder
	if (lastRemoveIndex > 0) {
	remainder = journal.slice(lastRemoveIndex)
	} else {
	// everything else doesn't need trimming
	remainder = journal
	}
	return uniqWith(remainder, (a, b) => {
	if (a.path !== b.path) {
	return false
	}
	if (a.operation !== b.operation) {
	return false
	}
	if (a.operation === 'addToCollection') {
	return a.args[0] === b.args[0]
	}
	return false
	})
	} else if (path.startsWith('simple')) {
	// Only the last record is important
	return takeRight(journal)
	} else {
	return journal
	}
	})

	const flat = flatten(trimmedGrouped).sort((a, b) =>
	a.timestamp > b.timestamp ? 1 : -1,
	)
	return take(flat, 500)
	}

	export const _mergePrefs = (recent, stale) => {
	if (!stale) return recent
	if (!recent) return stale
	const { _journal: recentJournal, ...recentData } = recent
	const { _journal: staleJournal } = stale
	/** Journal entry format:
	* path: path to entry in prefsStorage
	* timestamp: timestamp of the change
	* operation: operation type
	* arguments: array of arguments, depends on operation type
	*
	* currently only supported operation type is "set" which just sets the value
	* to requested one. Intended only to be used with simple preferences (boolean, number)
	* shouldn't be used with collections!
	*/
	const resultOutput = { ...recentData }
	const totalJournal = _mergeJournal(staleJournal, recentJournal)
	totalJournal.forEach(({ path, operation, args }) => {
	if (path.startsWith('_')) {
	throw new Error(
	`journal contains entry to edit internal (starts with _) field '${path}', something is incorrect here, ignoring.`,
	)
	}
	switch (operation) {
	case 'set':
	if (path.startsWith('collections')) {
	return console.error('Illegal operation "set" on a collection')
	}
	if (path.split(/\./g).length <= 1) {
	return console.error(
	`Calling set on depth <= 1 (path: ${path}) is not allowed`,
	)
	}
	set(resultOutput, path, args[0])
	break
	case 'unset':
	if (path.startsWith('collections')) {
	return console.error('Illegal operation "unset" on a collection')
	}
	if (path.split(/\./g).length <= 2) {
	return console.error(
	`Calling unset on depth <= 2 (path: ${path}) is not allowed`,
	)
	}
	unset(resultOutput, path)
	break
	case 'addToCollection':
	if (!path.startsWith('collections')) {
	return console.error(
	'Illegal operation "addToCollection" on a non-collection',
	)
	}
	set(
	resultOutput,
	path,
	Array.from(new Set(get(resultOutput, path)).add(args[0])),
	)
	break
	case 'removeFromCollection': {
	if (!path.startsWith('collections')) {
	return console.error(
	'Illegal operation "removeFromCollection" on a non-collection',
	)
	}
	const newSet = new Set(get(resultOutput, path))
	newSet.delete(args[0])
	set(resultOutput, path, Array.from(newSet))
	break
	}
	case 'reorderCollection': {
	const [value, movement] = args
	set(
	resultOutput,
	path,
	_moveItemInArray(get(resultOutput, path), value, movement),
	)
	break
	}
	default:
	return console.error(
	`Unknown journal operation: '${operation}', did we forget to run reverse migrations beforehand?`,
	)
	}
	})
	return { ...resultOutput, _journal: totalJournal }
	}

	export const _resetFlags = (
	totalFlags,
	knownKeys = defaultState.flagStorage,
	) => {
	let result = { ...totalFlags }
	const allFlagKeys = Object.keys(totalFlags)
	// flag reset functionality
	if (
	totalFlags.reset >= COMMAND_TRIM_FLAGS &&
	totalFlags.reset <= COMMAND_TRIM_FLAGS_AND_RESET
	) {
	console.debug('Received command to trim the flags')
	const knownKeysSet = new Set(Object.keys(knownKeys))

	// Trim
	result = {}
	allFlagKeys.forEach((flag) => {
	if (knownKeysSet.has(flag)) {
	result[flag] = totalFlags[flag]
	}
	})

	// Reset
	if (totalFlags.reset === COMMAND_TRIM_FLAGS_AND_RESET) {
	// 1001 - and reset everything to 0
	console.debug('Received command to reset the flags')
	Object.keys(knownKeys).forEach((flag) => {
	result[flag] = 0
	})
	}
	}
	result.reset = 0
	return result
	}

	const _resetPrefs = (
	totalPrefs,
	totalFlags,
	knownKeys = defaultState.flagStorage,
	) => {
	// prefs reset functionality
	if (
	totalFlags.reset >= COMMAND_WIPE_JOURNAL &&
	totalFlags.reset <= COMMAND_WIPE_JOURNAL_AND_STORAGE
	) {
	console.debug('Received command to reset journals')
	this.flagStorage.reset = COMMAND_WIPE_JOURNAL
	this.prefsStorage._journal = []
	this.cache.prefsStorage._journal = []
	this.raw.prefsStorage._journal = []
	this.pushSyncConfig()
	if (totalFlags.reset === COMMAND_WIPE_JOURNAL_AND_STORAGE) {
	console.debug('Received command to reset storage')
	return cloneDeep(defaultState)
	}
	}
	return totalPrefs
	}

	const _doMigrations = async (data, setPreference) => {
	if (data._version < VERSION) {
	console.debug(
	'Data has older version, seeing if there any migrations that can be applied',
	)
	}

	if (data._version > VERSION) {
	console.debug(
	'Data has newer version, seeing if there any reverse migrations that can be applied',
	)

	// no reverse migrations right now but we leave a possibility of loading a hotpatch if need be
	if (window._PLEROMA_HOTPATCH) {
	if (window._PLEROMA_HOTPATCH.reverseMigrations) {
	console.debug('Found hotpatch migration, applying')
	return window._PLEROMA_HOTPATCH.reverseMigrations.call(
	{},
	'syncConfigStore',
	{ from: data._version, to: VERSION },
	data,
	)
	}
	}
	}

	return data
	}

	export const useSyncConfigStore = defineStore('sync_config', {
	state() {
	return cloneDeep(defaultState)
	},
	actions: {
	setFlag({ flag, value }) {
	this.flagStorage[flag] = value
	this.dirty = true
	},
	setSimplePrefAndSave({ path, value }) {
	this.setPreference({ path: `simple.${path}`, value })
	this.pushSyncConfig()
	},
	unsetSimplePrefAndSave({ path }) {
	this.unsetPreference({ path: `simple.${path}` })
	this.pushSyncConfig()
	},
	setPreference({ path, value }) {
	if (path.startsWith('_')) {
	throw new Error(
	`Tried to edit internal (starts with _) field '${path}', ignoring.`,
	)
	}
	if (path.startsWith('collections')) {
	throw new Error(
	`Invalid operation 'set' for collection field '${path}', ignoring.`,
	)
	}
	if (path.split(/\./g).length <= 1) {
	throw new Error(
	`Calling set on depth <= 1 (path: ${path}) is not allowed`,
	)
	}
	if (path.split(/\./g).length > 3) {
	throw new Error(
	`Calling set on depth > 3 (path: ${path}) is not allowed`,
	)
	}
	set(this.prefsStorage, path, value)
	this.prefsStorage._journal = [
	...this.prefsStorage._journal,
	{ operation: 'set', path, args: [value], timestamp: Date.now() },
	]
	this.dirty = true
	},
	unsetPreference({ path, value }) {
	if (path.startsWith('_')) {
	throw new Error(
	`Tried to edit internal (starts with _) field '${path}', ignoring.`,
	)
	}
	if (path.startsWith('collections')) {
	throw new Error(
	`Invalid operation 'unset' for collection field '${path}', ignoring.`,
	)
	}
	if (path.split(/\./g).length <= 2) {
	throw new Error(
	`Calling unset on depth <= 2 (path: ${path}) is not allowed`,
	)
	}
	if (path.split(/\./g).length > 3) {
	throw new Error(
	`Calling unset on depth > 3 (path: ${path}) is not allowed`,
	)
	}
	unset(this.prefsStorage, path)
	this.prefsStorage._journal = [
	...this.prefsStorage._journal,
	{ operation: 'unset', path, args: [], timestamp: Date.now() },
	]
	this.dirty = true
	},
	addCollectionPreference({ path, value }) {
	if (path.startsWith('_')) {
	throw new Error(
	`tried to edit internal (starts with _) field '${path}'`,
	)
	}
	if (path.startsWith('collections')) {
	const collection = new Set(get(this.prefsStorage, path))
	collection.add(value)
	set(this.prefsStorage, path, [...collection])
	}
	this.prefsStorage._journal = [
	...this.prefsStorage._journal,
	{
	operation: 'addToCollection',
	path,
	args: [value],
	timestamp: Date.now(),
	},
	]
	this.dirty = true
	},
	removeCollectionPreference({ path, value }) {
	if (path.startsWith('_')) {
	throw new Error(
	`tried to edit internal (starts with _) field '${path}', ignoring.`,
	)
	}

	const { _key } = value
	if (path.startsWith('collection')) {
	const collection = new Set(get(this.prefsStorage, path))
	collection.delete(value)
	set(this.prefsStorage, path, [...collection])

	this.prefsStorage._journal = [
	...this.prefsStorage._journal,
	{
	operation: 'removeFromCollection',
	path,
	args: [value],
	timestamp: Date.now(),
	},
	]
	this.dirty = true
	}
	},
	reorderCollectionPreference({ path, value, movement }) {
	if (path.startsWith('_')) {
	throw new Error(
	`tried to edit internal (starts with _) field '${path}', ignoring.`,
	)
	}
	const collection = get(this.prefsStorage, path)
	const newCollection = _moveItemInArray(collection, value, movement)
	set(this.prefsStorage, path, newCollection)
	this.prefsStorage._journal = [
	...this.prefsStorage._journal,
	{
	operation: 'arrangeCollection',
	path,
	args: [value],
	timestamp: Date.now(),
	},
	]
	this.dirty = true
	},
	updateCache({ username }) {
	this.prefsStorage._journal = _mergeJournal(this.prefsStorage._journal)
	this.cache = _wrapData(
	{
	flagStorage: toRaw(this.flagStorage),
	prefsStorage: toRaw(this.prefsStorage),
	},
	username,
	)
	},
	clearSyncConfig() {
	const blankState = { ...cloneDeep(defaultState) }
	Object.keys(this).forEach((k) => {
	this[k] = blankState[k]
	})
	this.flagStorage.reset = COMMAND_WIPE_JOURNAL_AND_STORAGE
	},
	async initSyncConfig(userData) {
	const live = userData.storage
	this.raw = live
	let cache = this.cache
	if (cache?._user !== userData.fqn) {
	console.warn(
	'Cache belongs to another user! reinitializing local cache!',
	)
	cache = null
	}

	let { recent, stale, needUpload } = _getRecentData(cache, live)

	const userNew = userData.created_at > NEW_USER_DATE
	const flagsTemplate = userNew ? newUserFlags : defaultState.flagStorage
	let dirty = false

	if (recent === null) {
	console.debug(
	`Data is empty, initializing for ${userNew ? 'new' : 'existing'} user`,
	)
	recent = _wrapData({
	flagStorage: { ...flagsTemplate },
	prefsStorage: { ...defaultState.prefsStorage },
	})
	}

	recent = recent && (await _doMigrations(recent, this.setPreference))
	stale = stale && (await _doMigrations(stale, this.setPreference))

	// Various migrations
	console.debug('Migrating from old config')
	const vuexState = (await storage.getItem('vuex-lz')) ?? {}
	vuexState.config = vuexState.config ?? {}

	const migratedEntries = new Set(vuexState.config._syncMigration ?? [])
	- console.debug(`Already migrated Values: ${[...migratedEntries].join() \|\| '[none]'}`)
	+ console.debug(
	+ `Already migrated Values: ${[...migratedEntries].join() \|\| '[none]'}`,
	+ )

	Object.entries(oldDefaultConfigSync).forEach(([key, value]) => {
	const oldValue = vuexState.config[key]
	const defaultValue = value

	const present = oldValue !== undefined
	const migrated = migratedEntries.has(key)
	const different = !isEqual(oldValue, defaultValue)

	if (present && !migrated && different) {
	console.debug(`Migrating config ${key}: ${oldValue}`)
	if (key === 'theme3hacks') {
	useLocalConfigStore().set({
	path: 'fontInterface',
	value: oldValue.fonts.interface,
	})
	useLocalConfigStore().set({
	path: 'fontInput',
	value: oldValue.fonts.input,
	})
	useLocalConfigStore().set({
	path: 'fontPost',
	value: oldValue.fonts.post,
	})
	useLocalConfigStore().set({
	path: 'fontMonospace',
	value: oldValue.fonts.monospace,
	})
	useLocalConfigStore().set({
	path: 'underlay',
	value: oldValue.underlay,
	})
	} else {
	this.setPreference({ path: `simple.${key}`, value: oldValue })
	}
	migratedEntries.add(key)
	needUpload = true
	}
	})

	vuexState.config._syncMigration = [...migratedEntries]
	storage.setItem('vuex-lz', vuexState)

	if (!needUpload && recent && stale) {
	console.debug('Checking if data needs merging...')
	// discarding timestamps and versions
	const { _timestamp: _0, _version: _1, ...recentData } = recent
	const { _timestamp: _2, _version: _3, ...staleData } = stale
	dirty = sum(recentData) !== sum(staleData)
	console.debug(`Data ${dirty ? 'needs' : "doesn't need"} merging`)
	}

	const allFlagKeys = _getAllFlags(recent, stale)
	let totalFlags
	let totalPrefs
	if (dirty) {
	// Merge the flags
	console.debug('Merging the data...')
	totalFlags = _mergeFlags(recent, stale, allFlagKeys)
	_verifyPrefs(recent)
	_verifyPrefs(stale)
	totalPrefs = _mergePrefs(recent.prefsStorage, stale.prefsStorage)
	} else {
	totalFlags = recent.flagStorage
	totalPrefs = recent.prefsStorage
	}

	totalPrefs = _resetPrefs(totalPrefs, totalFlags)
	totalFlags = _resetFlags(totalFlags)

	recent.flagStorage = { ...flagsTemplate, ...totalFlags }
	recent.prefsStorage = { ...defaultState.prefsStorage, ...totalPrefs }

	this.dirty = dirty \|\| needUpload
	this.cache = recent
	// set local timestamp to smaller one if we don't have any changes
	if (stale && recent && !this.dirty) {
	this.cache._timestamp = Math.min(stale._timestamp, recent._timestamp)
	}
	this.flagStorage = this.cache.flagStorage
	this.prefsStorage = this.cache.prefsStorage
	this.pushSyncConfig()
	console.log('C', this.cache)
	},
	pushSyncConfig({ force = false } = {}) {
	const needPush = this.dirty \|\| force
	if (!needPush) return
	this.updateCache({ username: window.vuex.state.users.currentUser.fqn })
	const params = { pleroma_settings_store: { 'pleroma-fe': this.cache } }
	window.vuex.state.api.backendInteractor.updateProfileJSON({ params })
	},
	},
	getters: {
	mergedConfig: (state) => {
	const instancePrefs = useInstanceStore().prefsStorage
	const localPrefs = useLocalConfigStore().prefsStorage
	const tempPrefs = useLocalConfigStore().tempStorage
	const result = Object.fromEntries(
	Object.entries(state.prefsStorage.simple).map(([k, value]) => [
	k,
	LOCAL_ONLY_KEYS.has(k)
	? (tempPrefs[k] ??
	localPrefs[k] ??
	instancePrefs[k] ??
	defaultConfigLocal[k])
	: (tempPrefs[k] ??
	localPrefs[k] ??
	value ??
	instancePrefs[k] ??
	instanceDefaultConfig[k]),
	]),
	)
	return result
	},
	mergedConfigDefault: (state) => {
	const instancePrefs = useInstanceStore().prefsStorage
	const result = Object.fromEntries(
	Object.entries(state.prefsStorage.simple).map(([k, value]) => [
	k,
	LOCAL_ONLY_KEYS.has(k)
	? (instancePrefs[k] ?? defaultConfigLocal[k])
	: (instancePrefs[k] ?? instanceDefaultConfig[k]),
	]),
	)
	return result
	},
	mergedConfigWithoutDefaults: (state) => {
	const localPrefs = useLocalConfigStore().prefsStorage
	const result = Object.fromEntries(
	Object.entries(state.prefsStorage.simple).map(([k, value]) => [
	k,
	LOCAL_ONLY_KEYS.has(k) ? localPrefs[k] : value,
	]),
	)
	return result
	},
	},
	persist: {
	afterLoad(state) {
	return state
	},
	},
	})
	diff --git a/test/unit/specs/stores/sync_config.spec.js b/test/unit/specs/stores/sync_config.spec.js
	index 8078b5949d..eef6e39ac2 100644
	--- a/test/unit/specs/stores/sync_config.spec.js
	+++ b/test/unit/specs/stores/sync_config.spec.js
	@@ -1,607 +1,608 @@
	import { cloneDeep } from 'lodash'
	import { createPinia, setActivePinia } from 'pinia'

	+import { CURRENT_UPDATE_COUNTER } from 'src/components/update_notification/update_notification.js'
	+
	import {
	_getAllFlags,
	_getRecentData,
	_mergeFlags,
	_mergePrefs,
	_moveItemInArray,
	_resetFlags,
	COMMAND_TRIM_FLAGS,
	COMMAND_TRIM_FLAGS_AND_RESET,
	defaultState,
	newUserFlags,
	useSyncConfigStore,
	VERSION,
	} from 'src/stores/sync_config.js'
	-import { CURRENT_UPDATE_COUNTER } from 'src/components/update_notification/update_notification.js'

	describe('The SyncConfig store', () => {
	beforeEach(() => {
	setActivePinia(createPinia())
	})

	describe('mutations', () => {
	describe('initSyncConfig', () => {
	const user = {
	created_at: new Date('1999-02-09'),
	storage: {},
	}

	it('should initialize storage if none present', async () => {
	const store = useSyncConfigStore()
	// PushSyncConfig is very simple but uses vuex to push data
	store.pushSyncConfig = () => {
	/* no-op */
	}
	await store.initSyncConfig({ ...user })
	expect(store.cache._version).to.eql(VERSION)
	expect(store.cache._timestamp).to.be.a('number')
	expect(store.cache.flagStorage).to.eql(defaultState.flagStorage)
	expect(store.cache.prefsStorage).to.eql(defaultState.prefsStorage)
	})

	it('should initialize storage with proper flags for new users if none present', async () => {
	const store = useSyncConfigStore()
	// PushSyncConfig is very simple but uses vuex to push data
	store.pushSyncConfig = () => {
	/* no-op */
	}
	await store.initSyncConfig({ ...user, created_at: new Date() })
	expect(store.cache._version).to.eql(VERSION)
	expect(store.cache._timestamp).to.be.a('number')
	expect(store.cache.flagStorage).to.eql(newUserFlags)
	expect(store.cache.prefsStorage).to.eql(defaultState.prefsStorage)
	})

	it('should merge flags even if remote timestamp is older', async () => {
	const store = useSyncConfigStore()
	// PushSyncConfig is very simple but uses vuex to push data
	store.pushSyncConfig = () => {
	/* no-op */
	}
	store.cache = {
	_timestamp: Date.now(),
	_version: VERSION,
	...cloneDeep(defaultState),
	}

	await store.initSyncConfig({
	...user,
	storage: {
	_timestamp: 123,
	_version: VERSION,
	flagStorage: {
	...defaultState.flagStorage,
	updateCounter: CURRENT_UPDATE_COUNTER,
	},
	prefsStorage: {
	...defaultState.prefsStorage,
	},
	},
	})

	expect(store.flagStorage).to.eql({
	...defaultState.flagStorage,
	updateCounter: CURRENT_UPDATE_COUNTER,
	})
	})

	it('should trim journal to 500 entries', async () => {
	const store = useSyncConfigStore()
	// PushSyncConfig is very simple but uses vuex to push data
	store.pushSyncConfig = () => {
	/* no-op */
	}
	store.cache = {
	_timestamp: Date.now(),
	_version: VERSION,
	...cloneDeep(defaultState),
	}
	const largeJournal = []
	for (let value = 0; value < 1000; value++) {
	largeJournal.push({
	path: 'simple.testing' + value,
	operation: 'set',
	args: [value],
	// should have A timestamp, we don't really care what it is
	timestamp: 123456,
	})
	}

	await store.initSyncConfig({
	...user,
	storage: {
	_timestamp: 123,
	_version: VERSION,
	flagStorage: {
	...defaultState.flagStorage,
	updateCounter: CURRENT_UPDATE_COUNTER,
	},
	prefsStorage: {
	...defaultState.prefsStorage,
	_journal: largeJournal,
	},
	},
	})

	expect(store.prefsStorage._journal.length).to.eql(500)
	})

	it('should reset local timestamp to remote if contents are the same', async () => {
	const store = useSyncConfigStore()
	store.cache = null
	// PushSyncConfig is very simple but uses vuex to push data
	store.pushSyncConfig = () => {
	/* no-op */
	}

	await store.initSyncConfig({
	...user,
	storage: {
	_timestamp: 123,
	_version: VERSION,
	flagStorage: {
	...defaultState.flagStorage,
	updateCounter: 999,
	},
	},
	})
	expect(store.cache._timestamp).to.eql(123)
	expect(store.flagStorage.updateCounter).to.eql(999)
	expect(store.cache.flagStorage.updateCounter).to.eql(999)
	})

	it('should use remote version if local missing', async () => {
	const store = useSyncConfigStore()
	// PushSyncConfig is very simple but uses vuex to push data
	store.pushSyncConfig = () => {
	/* no-op */
	}
	await store.initSyncConfig(store, user)
	expect(store.cache._version).to.eql(VERSION)
	expect(store.cache._timestamp).to.be.a('number')
	expect(store.cache.flagStorage).to.eql(defaultState.flagStorage)
	})
	})
	describe('setPreference', () => {
	it('should set preference and update journal log accordingly', () => {
	const store = useSyncConfigStore()
	// PushSyncConfig is very simple but uses vuex to push data
	store.pushSyncConfig = () => {
	/* no-op */
	}
	store.setPreference({ path: 'simple.testing', value: 1 })
	expect(store.prefsStorage.simple.testing).to.eql(1)
	expect(store.prefsStorage._journal.length).to.eql(1)
	expect(store.prefsStorage._journal[0]).to.eql({
	path: 'simple.testing',
	operation: 'set',
	args: [1],
	// should have A timestamp, we don't really care what it is
	timestamp: store.prefsStorage._journal[0].timestamp,
	})
	})

	it('should keep journal to a minimum', () => {
	const store = useSyncConfigStore()
	// PushSyncConfig is very simple but uses vuex to push data
	store.pushSyncConfig = () => {
	/* no-op */
	}
	store.setPreference({ path: 'simple.testing', value: 1 })
	store.setPreference({ path: 'simple.testing', value: 2 })
	store.addCollectionPreference({ path: 'collections.testing', value: 2 })
	store.removeCollectionPreference({
	path: 'collections.testing',
	value: 2,
	})
	store.updateCache({ username: 'test' })
	expect(store.prefsStorage.simple.testing).to.eql(2)
	expect(store.prefsStorage.collections.testing).to.eql([])
	expect(store.prefsStorage._journal.length).to.eql(2)
	expect(store.prefsStorage._journal[0]).to.eql({
	path: 'simple.testing',
	operation: 'set',
	args: [2],
	// should have A timestamp, we don't really care what it is
	timestamp: store.prefsStorage._journal[0].timestamp,
	})
	expect(store.prefsStorage._journal[1]).to.eql({
	path: 'collections.testing',
	operation: 'removeFromCollection',
	args: [2],
	// should have A timestamp, we don't really care what it is
	timestamp: store.prefsStorage._journal[1].timestamp,
	})
	})

	it('should remove duplicate entries from journal', () => {
	const store = useSyncConfigStore()
	// PushSyncConfig is very simple but uses vuex to push data
	store.pushSyncConfig = () => {
	/* no-op */
	}
	store.setPreference({ path: 'simple.testing', value: 1 })
	store.setPreference({ path: 'simple.testing', value: 1 })
	store.addCollectionPreference({ path: 'collections.testing', value: 2 })
	store.addCollectionPreference({ path: 'collections.testing', value: 2 })
	store.updateCache({ username: 'test' })
	expect(store.prefsStorage.simple.testing).to.eql(1)
	expect(store.prefsStorage.collections.testing).to.eql([2])
	expect(store.prefsStorage._journal.length).to.eql(2)
	})

	it('should remove depth = 3 set/unset entries from journal', () => {
	const store = useSyncConfigStore()
	// PushSyncConfig is very simple but uses vuex to push data
	store.pushSyncConfig = () => {
	/* no-op */
	}
	store.setPreference({ path: 'simple.object.foo', value: 1 })
	store.unsetPreference({ path: 'simple.object.foo' })
	store.updateCache(store, { username: 'test' })
	expect(store.prefsStorage.simple.object).to.not.have.property('foo')
	expect(store.prefsStorage._journal.length).to.eql(1)
	})

	it('should not allow unsetting depth <= 2', () => {
	const store = useSyncConfigStore()
	// PushSyncConfig is very simple but uses vuex to push data
	store.pushSyncConfig = () => {
	/* no-op */
	}
	store.setPreference({ path: 'simple.object.foo', value: 1 })
	expect(() => store.unsetPreference({ path: 'simple' })).to.throw()
	expect(() =>
	store.unsetPreference({ path: 'simple.object' }),
	).to.throw()
	})

	it('should not allow (un)setting depth > 3', () => {
	const store = useSyncConfigStore()
	// PushSyncConfig is very simple but uses vuex to push data
	store.pushSyncConfig = () => {
	/* no-op */
	}
	store.setPreference({ path: 'simple.object', value: {} })
	expect(() =>
	store.setPreference({ path: 'simple.object.lv3', value: 1 }),
	).to.not.throw()
	expect(() =>
	store.setPreference({ path: 'simple.object.lv3.lv4', value: 1 }),
	).to.throw()
	expect(() =>
	store.unsetPreference({ path: 'simple.object.lv3', value: 1 }),
	).to.not.throw()
	expect(() =>
	store.unsetPreference({ path: 'simple.object.lv3.lv4', value: 1 }),
	).to.throw()
	})
	})
	})

	describe('helper functions', () => {
	describe('_moveItemInArray', () => {
	it('should move item according to movement value', () => {
	expect(_moveItemInArray([1, 2, 3, 4], 4, -1)).to.eql([1, 2, 4, 3])
	expect(_moveItemInArray([1, 2, 3, 4], 1, 2)).to.eql([2, 3, 1, 4])
	})
	it('should clamp movement to within array', () => {
	expect(_moveItemInArray([1, 2, 3, 4], 4, -10)).to.eql([4, 1, 2, 3])
	expect(_moveItemInArray([1, 2, 3, 4], 3, 99)).to.eql([1, 2, 4, 3])
	})
	})
	describe('_getRecentData', () => {
	it('should handle nulls correctly', () => {
	expect(_getRecentData(null, null, true)).to.eql({
	recent: null,
	stale: null,
	needUpload: true,
	})
	})

	it("doesn't choke on invalid data", () => {
	expect(_getRecentData({ a: 1 }, { b: 2 }, true)).to.eql({
	recent: null,
	stale: null,
	needUpload: true,
	})
	})

	it('should prefer the valid non-null correctly, needUpload works properly', () => {
	const nonNull = { _version: VERSION, _timestamp: 1 }
	expect(_getRecentData(nonNull, null, true)).to.eql({
	recent: nonNull,
	stale: null,
	needUpload: true,
	})
	expect(_getRecentData(null, nonNull, true)).to.eql({
	recent: nonNull,
	stale: null,
	needUpload: false,
	})
	})

	it('should prefer the one with higher timestamp', () => {
	const a = { _version: VERSION, _timestamp: 1 }
	const b = { _version: VERSION, _timestamp: 2 }

	expect(_getRecentData(a, b, true)).to.eql({
	recent: b,
	stale: a,
	needUpload: false,
	})
	expect(_getRecentData(b, a, true)).to.eql({
	recent: b,
	stale: a,
	needUpload: false,
	})
	})

	it('case where both are same', () => {
	const a = { _version: VERSION, _timestamp: 3 }
	const b = { _version: VERSION, _timestamp: 3 }

	expect(_getRecentData(a, b, true)).to.eql({
	recent: b,
	stale: a,
	needUpload: false,
	})
	expect(_getRecentData(b, a, true)).to.eql({
	recent: b,
	stale: a,
	needUpload: false,
	})
	})
	})

	describe('_getAllFlags', () => {
	it('should handle nulls properly', () => {
	expect(_getAllFlags(null, null)).to.eql([])
	})
	it('should output list of keys if passed single object', () => {
	expect(
	_getAllFlags({ flagStorage: { a: 1, b: 1, c: 1 } }, null),
	).to.eql(['a', 'b', 'c'])
	})
	it('should union keys of both objects', () => {
	expect(
	_getAllFlags(
	{ flagStorage: { a: 1, b: 1, c: 1 } },
	{ flagStorage: { c: 1, d: 1 } },
	),
	).to.eql(['a', 'b', 'c', 'd'])
	})
	})

	describe('_mergeFlags', () => {
	it('should handle merge two flag sets correctly picking higher numbers', () => {
	expect(
	_mergeFlags(
	{ flagStorage: { a: 0, b: 3 } },
	{ flagStorage: { b: 1, c: 4, d: 9 } },
	['a', 'b', 'c', 'd'],
	),
	).to.eql({ a: 0, b: 3, c: 4, d: 9 })
	})
	})

	describe('_mergePrefs', () => {
	it('should prefer recent and apply journal to it', () => {
	expect(
	_mergePrefs(
	// RECENT
	{
	simple: { a: 1, b: 0, c: true },
	_journal: [
	{ path: 'simple.b', operation: 'set', args: [0], timestamp: 2 },
	{
	path: 'simple.c',
	operation: 'set',
	args: [true],
	timestamp: 4,
	},
	],
	},
	// STALE
	{
	simple: { a: 1, b: 1, c: false },
	_journal: [
	{ path: 'simple.a', operation: 'set', args: [1], timestamp: 1 },
	{ path: 'simple.b', operation: 'set', args: [1], timestamp: 3 },
	],
	},
	),
	).to.eql({
	simple: { a: 1, b: 1, c: true },
	_journal: [
	{ path: 'simple.a', operation: 'set', args: [1], timestamp: 1 },
	{ path: 'simple.b', operation: 'set', args: [1], timestamp: 3 },
	{ path: 'simple.c', operation: 'set', args: [true], timestamp: 4 },
	],
	})
	})

	it('should allow setting falsy values', () => {
	expect(
	_mergePrefs(
	// RECENT
	{
	simple: { a: 1, b: 0, c: false },
	_journal: [
	{ path: 'simple.b', operation: 'set', args: [0], timestamp: 2 },
	{
	path: 'simple.c',
	operation: 'set',
	args: [false],
	timestamp: 4,
	},
	],
	},
	// STALE
	{
	simple: { a: 0, b: 0, c: true },
	_journal: [
	{ path: 'simple.a', operation: 'set', args: [0], timestamp: 1 },
	{ path: 'simple.b', operation: 'set', args: [0], timestamp: 3 },
	],
	},
	),
	).to.eql({
	simple: { a: 0, b: 0, c: false },
	_journal: [
	{ path: 'simple.a', operation: 'set', args: [0], timestamp: 1 },
	{ path: 'simple.b', operation: 'set', args: [0], timestamp: 3 },
	{ path: 'simple.c', operation: 'set', args: [false], timestamp: 4 },
	],
	})
	})

	it('should work with strings', () => {
	expect(
	_mergePrefs(
	// RECENT
	{
	simple: { a: 'foo' },
	_journal: [
	{
	path: 'simple.a',
	operation: 'set',
	args: ['foo'],
	timestamp: 2,
	},
	],
	},
	// STALE
	{
	simple: { a: 'bar' },
	_journal: [
	{
	path: 'simple.a',
	operation: 'set',
	args: ['bar'],
	timestamp: 4,
	},
	],
	},
	),
	).to.eql({
	simple: { a: 'bar' },
	_journal: [
	{ path: 'simple.a', operation: 'set', args: ['bar'], timestamp: 4 },
	],
	})
	})

	it('should work with objects', () => {
	expect(
	_mergePrefs(
	// RECENT
	{
	simple: { lv2: { lv3: 'foo' } },
	_journal: [
	{
	path: 'simple.lv2.lv3',
	operation: 'set',
	args: ['foo'],
	timestamp: 2,
	},
	],
	},
	// STALE
	{
	simple: { lv2: { lv3: 'bar' } },
	_journal: [
	{
	path: 'simple.lv2.lv3',
	operation: 'set',
	args: ['bar'],
	timestamp: 4,
	},
	],
	},
	),
	).to.eql({
	simple: { lv2: { lv3: 'bar' } },
	_journal: [
	{
	path: 'simple.lv2.lv3',
	operation: 'set',
	args: ['bar'],
	timestamp: 4,
	},
	],
	})
	})

	it('should work with unset', () => {
	expect(
	_mergePrefs(
	// RECENT
	{
	simple: { lv2: { lv3: 'foo' } },
	_journal: [
	{
	path: 'simple.lv2.lv3',
	operation: 'set',
	args: ['foo'],
	timestamp: 2,
	},
	],
	},
	// STALE
	{
	simple: { lv2: {} },
	_journal: [
	{
	path: 'simple.lv2.lv3',
	operation: 'unset',
	args: [],
	timestamp: 4,
	},
	],
	},
	),
	).to.eql({
	simple: { lv2: {} },
	_journal: [
	{
	path: 'simple.lv2.lv3',
	operation: 'unset',
	args: [],
	timestamp: 4,
	},
	],
	})
	})
	})

	describe('_resetFlags', () => {
	it('should trim all flags to known when reset is set to 1000', () => {
	const totalFlags = { a: 0, b: 3, c: 33, reset: COMMAND_TRIM_FLAGS }

	expect(_resetFlags(totalFlags, { a: 0, b: 0, reset: 0 })).to.eql({
	a: 0,
	b: 3,
	reset: 0,
	})
	})
	it('should trim all flags to known and reset when reset is set to 1001', () => {
	const totalFlags = {
	a: 0,
	b: 3,
	c: 33,
	reset: COMMAND_TRIM_FLAGS_AND_RESET,
	}

	expect(_resetFlags(totalFlags, { a: 0, b: 0, reset: 0 })).to.eql({
	a: 0,
	b: 0,
	reset: 0,
	})
	})
	})
	})
	})

File Metadata

Mime Type: text/x-diff
Expires: Fri, Oct 30, 10:01 PM (16 h, 40 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1800605
Default Alt Text: (55 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions