No OneTemporary
Actions

Size

59 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/eslint.config.mjs b/eslint.config.mjs
	index 60c36d246b..cc66087a6a 100644
	--- a/eslint.config.mjs
	+++ b/eslint.config.mjs
	@@ -1,36 +1,36 @@
	import js from '@eslint/js'
	+import { defineConfig, globalIgnores } from "eslint/config";
	import vue from 'eslint-plugin-vue'
	import globals from 'globals'

	-export default [
	+export default defineConfig([
	...vue.configs['flat/recommended'],
	- js.configs.recommended,
	+ globalIgnores([
	+ '*/.js', 'build/', 'dist/', 'config/',
	+ ]),
	{
	- files: ['*/.js', '*/.mjs', '*/.vue'],
	- ignores: ['build/.js', 'config/.js'],
	-
	+ files: ['src/*/.vue'],
	+ plugins: { js },
	+ extends: ['js/recommended'],
	languageOptions: {
	ecmaVersion: 2024,
	sourceType: 'module',

	parserOptions: {
	parser: '@babel/eslint-parser',
	},
	globals: {
	...globals.browser,
	...globals.vitest,
	...globals.chai,
	...globals.commonjs,
	...globals.serviceworker,
	},
	},

	rules: {
	- 'arrow-parens': 0,
	- 'generator-star-spacing': 0,
	- 'no-debugger': 0,
	'vue/require-prop-types': 0,
	'vue/multi-word-component-names': 0,
	},
	- },
	-]
	+ }
	+])
	diff --git a/package.json b/package.json
	index b6f16bd60c..42a5283044 100644
	--- a/package.json
	+++ b/package.json
	@@ -1,123 +1,123 @@
	{
	"name": "pleroma_fe",
	- "version": "2.9.3",
	+ "version": "2.10.0",
	"description": "Pleroma frontend, the default frontend of Pleroma social network server",
	"author": "Pleroma contributors <https://git.pleroma.social/pleroma/pleroma-fe/-/blob/develop/CONTRIBUTORS.md>",
	"private": false,
	"scripts": {
	"dev": "node build/update-emoji.js && vite dev",
	"build": "node build/update-emoji.js && vite build",
	"unit": "node build/update-emoji.js && vitest --run",
	"unit-ci": "node build/update-emoji.js && vitest --run --browser.headless",
	"unit:watch": "node build/update-emoji.js && vitest",
	"e2e": "node test/e2e/runner.js",
	"test": "yarn run unit && yarn run e2e",
	"stylelint": "yarn exec stylelint '*/.scss' '*/.vue'",
	- "lint": "eslint src test/unit/specs test/e2e/specs",
	- "lint-fix": "eslint --fix src test/unit/specs test/e2e/specs"
	+ "lint": "yarn exec eslint src",
	+ "lint-fix": "yarn eslint --fix src test/unit/specs test/e2e/specs"
	},
	"dependencies": {
	"@babel/runtime": "7.28.4",
	"@chenfengyuan/vue-qrcode": "2.0.0",
	"@fortawesome/fontawesome-svg-core": "7.1.0",
	"@fortawesome/free-regular-svg-icons": "7.1.0",
	"@fortawesome/free-solid-svg-icons": "7.1.0",
	"@fortawesome/vue-fontawesome": "3.1.2",
	"@kazvmoe-infra/pinch-zoom-element": "1.3.0",
	"@kazvmoe-infra/unicode-emoji-json": "0.4.0",
	"@ruffle-rs/ruffle": "0.1.0-nightly.2025.6.22",
	"@vuelidate/core": "2.0.3",
	"@vuelidate/validators": "2.0.4",
	"@web3-storage/parse-link-header": "^3.1.0",
	"body-scroll-lock": "3.1.5",
	"chromatism": "3.0.0",
	"click-outside-vue3": "4.0.1",
	"cropperjs": "2.0.1",
	"escape-html": "1.0.3",
	"globals": "^16.0.0",
	"hash-sum": "^2.0.0",
	"js-cookie": "3.0.5",
	"localforage": "1.10.0",
	"parse-link-header": "2.0.0",
	"phoenix": "1.8.1",
	"pinia": "^3.0.0",
	"punycode.js": "2.3.1",
	"qrcode": "1.5.4",
	"querystring-es3": "0.2.1",
	"url": "0.11.4",
	"utf8": "3.0.0",
	"uuid": "11.1.0",
	"vue": "3.5.22",
	"vue-i18n": "11",
	"vue-router": "4.5.1",
	"vue-virtual-scroller": "^2.0.0-beta.7",
	"vuex": "4.1.0"
	},
	"devDependencies": {
	"@babel/core": "7.28.4",
	"@babel/eslint-parser": "7.28.4",
	"@babel/plugin-transform-runtime": "7.28.3",
	"@babel/preset-env": "7.28.3",
	"@babel/register": "7.28.3",
	"@biomejs/biome": "2.3.11",
	"@ungap/event-target": "0.2.4",
	"@vitejs/plugin-vue": "^5.2.1",
	"@vitejs/plugin-vue-jsx": "^4.1.1",
	"@vitest/browser": "^3.0.7",
	"@vitest/ui": "^3.0.7",
	"@vue/babel-helper-vue-jsx-merge-props": "1.4.0",
	"@vue/babel-plugin-jsx": "1.5.0",
	"@vue/compiler-sfc": "3.5.22",
	"@vue/test-utils": "2.4.6",
	"autoprefixer": "10.4.21",
	"babel-plugin-lodash": "3.3.4",
	"chai": "5.3.3",
	"chalk": "5.6.2",
	"chromedriver": "135.0.4",
	"connect-history-api-fallback": "2.0.0",
	"cross-spawn": "7.0.6",
	"custom-event-polyfill": "1.0.7",
	"eslint": "9.37.0",
	"eslint-config-standard": "17.1.0",
	"eslint-formatter-friendly": "7.0.0",
	"eslint-plugin-import": "2.32.0",
	"eslint-plugin-n": "17.23.1",
	"eslint-plugin-promise": "7.2.1",
	"eslint-plugin-vue": "10.5.0",
	"eventsource-polyfill": "0.9.6",
	"express": "5.1.0",
	"function-bind": "1.1.2",
	"http-proxy-middleware": "3.0.5",
	"iso-639-1": "3.1.5",
	"lodash": "4.17.21",
	"msw": "2.10.5",
	"nightwatch": "3.12.2",
	"playwright": "1.55.0",
	"postcss": "8.5.6",
	"postcss-html": "^1.5.0",
	"postcss-scss": "^4.0.6",
	"sass": "1.93.2",
	"selenium-server": "3.141.59",
	"semver": "7.7.3",
	"serve-static": "2.2.0",
	"shelljs": "0.10.0",
	"sinon": "20.0.0",
	"sinon-chai": "4.0.1",
	"stylelint": "16.25.0",
	"stylelint-config-html": "^1.1.0",
	"stylelint-config-recommended": "^16.0.0",
	"stylelint-config-recommended-scss": "^14.0.0",
	"stylelint-config-recommended-vue": "^1.6.0",
	"stylelint-config-standard": "38.0.0",
	"vite": "^6.1.0",
	"vite-plugin-eslint2": "^5.0.3",
	"vite-plugin-stylelint": "^6.0.0",
	"vitest": "^3.0.7",
	"vue-eslint-parser": "10.2.0"
	},
	"type": "module",
	"engines": {
	"node": ">= 16.0.0"
	},
	"packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
	}
	diff --git a/src/components/mention_link/mention_link.js b/src/components/mention_link/mention_link.js
	index ee35ce88b0..24820331e5 100644
	--- a/src/components/mention_link/mention_link.js
	+++ b/src/components/mention_link/mention_link.js
	@@ -1,165 +1,163 @@
	import { library } from '@fortawesome/fontawesome-svg-core'
	import { faAt } from '@fortawesome/free-solid-svg-icons'
	import generateProfileLink from 'src/services/user_profile_link_generator/user_profile_link_generator'
	import { defineAsyncComponent } from 'vue'
	import { mapGetters, mapState } from 'vuex'
	import {
	highlightClass,
	highlightStyle,
	} from '../../services/user_highlighter/user_highlighter.js'
	import UnicodeDomainIndicator from '../unicode_domain_indicator/unicode_domain_indicator.vue'
	import UserAvatar from '../user_avatar/user_avatar.vue'

	library.add(faAt)

	const MentionLink = {
	name: 'MentionLink',
	components: {
	UserAvatar,
	UnicodeDomainIndicator,
	UserPopover: defineAsyncComponent(
	() => import('../user_popover/user_popover.vue'),
	),
	},
	props: {
	url: {
	required: true,
	type: String,
	},
	content: {
	required: true,
	type: String,
	},
	userId: {
	required: false,
	type: String,
	},
	userScreenName: {
	required: false,
	type: String,
	},
	},
	data() {
	return {
	hasSelection: false,
	}
	},
	methods: {
	onClick() {
	if (this.shouldShowTooltip) return
	const link = generateProfileLink(
	this.userId \|\| this.user.id,
	this.userScreenName \|\| this.user.screen_name,
	)
	this.$router.push(link)
	},
	handleSelection() {
	if (this.$refs.full) {
	this.hasSelection = document
	.getSelection()
	.containsNode(this.$refs.full, true)
	}
	},
	},
	mounted() {
	document.addEventListener('selectionchange', this.handleSelection)
	},
	unmounted() {
	document.removeEventListener('selectionchange', this.handleSelection)
	},
	computed: {
	user() {
	return (
	this.url && this.$store && this.$store.getters.findUserByUrl(this.url)
	)
	},
	isYou() {
	// FIXME why user !== currentUser???
	return this.user && this.user.id === this.currentUser.id
	},
	userName() {
	return this.user && this.userNameFullUi.split('@')[0]
	},
	serverName() {
	// XXX assumed that domain does not contain @
	return (
	this.user &&
	(this.userNameFullUi.split('@')[1] \|\|
	this.$store.getters.instanceDomain)
	)
	},
	userNameFull() {
	return this.user && this.user.screen_name
	},
	userNameFullUi() {
	return this.user && this.user.screen_name_ui
	},
	highlight() {
	return this.user && this.mergedConfig.highlight[this.user.screen_name]
	},
	highlightType() {
	return this.highlight && '-' + this.highlight.type
	},
	highlightClass() {
	if (this.highlight) return highlightClass(this.user)
	},
	style() {
	if (this.highlight) {
	- /* eslint-disable no-unused-vars */
	const {
	backgroundColor,
	backgroundPosition,
	backgroundImage,
	...rest
	} = highlightStyle(this.highlight)
	- /* eslint-enable no-unused-vars */
	return rest
	}
	},
	classnames() {
	return [
	{
	'-you': this.isYou && this.shouldBoldenYou,
	'-highlighted': this.highlight,
	'-has-selection': this.hasSelection,
	},
	this.highlightType,
	]
	},
	isRemote() {
	return this.userName !== this.userNameFull
	},
	shouldShowFullUserName() {
	const conf = this.mergedConfig.mentionLinkDisplay
	if (conf === 'short') {
	return false
	} else if (conf === 'full') {
	return true
	} else {
	// full_for_remote
	return this.isRemote
	}
	},
	shouldShowTooltip() {
	return this.mergedConfig.mentionLinkShowTooltip
	},
	shouldShowAvatar() {
	return this.mergedConfig.mentionLinkShowAvatar
	},
	shouldShowYous() {
	return this.mergedConfig.mentionLinkShowYous
	},
	shouldBoldenYou() {
	return this.mergedConfig.mentionLinkBoldenYou
	},
	shouldFadeDomain() {
	return this.mergedConfig.mentionLinkFadeDomain
	},
	...mapGetters(['mergedConfig']),
	...mapState({
	currentUser: (state) => state.users.currentUser,
	}),
	},
	}

	export default MentionLink
	diff --git a/src/components/status/status.js b/src/components/status/status.js
	index 206d25aae8..aa7a0efb40 100644
	--- a/src/components/status/status.js
	+++ b/src/components/status/status.js
	@@ -1,672 +1,671 @@
	import { library } from '@fortawesome/fontawesome-svg-core'
	import {
	faAngleDoubleRight,
	faChevronDown,
	faChevronUp,
	faEllipsisH,
	faEnvelope,
	faEye,
	faEyeSlash,
	faGlobe,
	faIgloo,
	faLock,
	faLockOpen,
	faPlay,
	faPlusSquare,
	faReply,
	faRetweet,
	faSmileBeam,
	faStar,
	faThumbtack,
	faTimes,
	} from '@fortawesome/free-solid-svg-icons'
	import { unescape as ldUnescape, uniqBy } from 'lodash'
	import MentionLink from 'src/components/mention_link/mention_link.vue'
	import MentionsLine from 'src/components/mentions_line/mentions_line.vue'
	import RichContent from 'src/components/rich_content/rich_content.jsx'
	import StatusActionButtons from 'src/components/status_action_buttons/status_action_buttons.vue'
	import generateProfileLink from 'src/services/user_profile_link_generator/user_profile_link_generator'
	import { useServerSideStorageStore } from 'src/stores/serverSideStorage'
	import { muteFilterHits } from '../../services/status_parser/status_parser.js'
	import {
	highlightClass,
	highlightStyle,
	} from '../../services/user_highlighter/user_highlighter.js'
	import AvatarList from '../avatar_list/avatar_list.vue'
	import EmojiReactions from '../emoji_reactions/emoji_reactions.vue'
	import PostStatusForm from '../post_status_form/post_status_form.vue'
	import StatusContent from '../status_content/status_content.vue'
	import StatusPopover from '../status_popover/status_popover.vue'
	import Timeago from '../timeago/timeago.vue'
	import UserAvatar from '../user_avatar/user_avatar.vue'
	import UserLink from '../user_link/user_link.vue'
	import UserListPopover from '../user_list_popover/user_list_popover.vue'
	import UserPopover from '../user_popover/user_popover.vue'

	library.add(
	faEnvelope,
	faGlobe,
	faIgloo,
	faLock,
	faLockOpen,
	faTimes,
	faRetweet,
	faReply,
	faPlusSquare,
	faStar,
	faSmileBeam,
	faEllipsisH,
	faEyeSlash,
	faEye,
	faThumbtack,
	faChevronUp,
	faChevronDown,
	faAngleDoubleRight,
	faPlay,
	)

	const camelCase = (name) => name.charAt(0).toUpperCase() + name.slice(1)

	const controlledOrUncontrolledGetters = (list) =>
	list.reduce((res, name) => {
	const camelized = camelCase(name)
	const toggle = `controlledToggle${camelized}`
	const controlledName = `controlled${camelized}`
	const uncontrolledName = `uncontrolled${camelized}`
	res[name] = function () {
	return (this.$data[toggle] !== undefined \|\|
	this.$props[toggle] !== undefined) &&
	this[toggle]
	? this[controlledName]
	: this[uncontrolledName]
	}
	return res
	}, {})

	const controlledOrUncontrolledToggle = (obj, name) => {
	const camelized = camelCase(name)
	const toggle = `controlledToggle${camelized}`
	const uncontrolledName = `uncontrolled${camelized}`
	if (obj[toggle]) {
	obj[toggle]()
	} else {
	obj[uncontrolledName] = !obj[uncontrolledName]
	}
	}

	const controlledOrUncontrolledSet = (obj, name, val) => {
	const camelized = camelCase(name)
	const set = `controlledSet${camelized}`
	const uncontrolledName = `uncontrolled${camelized}`
	if (obj[set]) {
	obj[set](val)
	} else {
	obj[uncontrolledName] = val
	}
	}

	const Status = {
	name: 'Status',
	components: {
	PostStatusForm,
	UserAvatar,
	AvatarList,
	Timeago,
	StatusPopover,
	UserListPopover,
	EmojiReactions,
	StatusContent,
	RichContent,
	MentionLink,
	MentionsLine,
	UserPopover,
	UserLink,
	StatusActionButtons,
	},
	props: [
	'statusoid',
	'expandable',
	'inConversation',
	'focused',
	'highlight',
	'compact',
	'replies',
	'isPreview',
	'noHeading',
	'inlineExpanded',
	'showPinned',
	'inProfile',
	'profileUserId',
	'inQuote',

	'simpleTree',
	'controlledThreadDisplayStatus',
	'controlledToggleThreadDisplay',
	'showOtherRepliesAsButton',

	'controlledShowingTall',
	'controlledToggleShowingTall',
	'controlledExpandingSubject',
	'controlledToggleExpandingSubject',
	'controlledShowingLongSubject',
	'controlledToggleShowingLongSubject',
	'controlledReplying',
	'controlledToggleReplying',
	'controlledMediaPlaying',
	'controlledSetMediaPlaying',
	'dive',
	],
	emits: ['interacted'],
	data() {
	return {
	uncontrolledReplying: false,
	unmuted: false,
	userExpanded: false,
	uncontrolledMediaPlaying: [],
	suspendable: true,
	error: null,
	headTailLinks: null,
	displayQuote: !this.inQuote,
	}
	},
	computed: {
	...controlledOrUncontrolledGetters(['replying', 'mediaPlaying']),
	showReasonMutedThread() {
	return (
	(this.status.thread_muted \|\|
	(this.status.reblog && this.status.reblog.thread_muted)) &&
	!this.inConversation
	)
	},
	repeaterClass() {
	const user = this.statusoid.user
	return highlightClass(user)
	},
	userClass() {
	const user = this.retweet
	? this.statusoid.retweeted_status.user
	: this.statusoid.user
	return highlightClass(user)
	},
	deleted() {
	return this.statusoid.deleted
	},
	repeaterStyle() {
	const user = this.statusoid.user
	const highlight = this.mergedConfig.highlight
	return highlightStyle(highlight[user.screen_name])
	},
	userStyle() {
	if (this.noHeading) return
	const user = this.retweet
	? this.statusoid.retweeted_status.user
	: this.statusoid.user
	const highlight = this.mergedConfig.highlight
	return highlightStyle(highlight[user.screen_name])
	},
	userProfileLink() {
	return this.generateUserProfileLink(
	this.status.user.id,
	this.status.user.screen_name,
	)
	},
	replyProfileLink() {
	if (this.isReply) {
	const user = this.$store.getters.findUser(
	this.status.in_reply_to_user_id,
	)
	// FIXME Why user not found sometimes???
	return user ? user.statusnet_profile_url : 'NOT_FOUND'
	}
	},
	retweet() {
	return !!this.statusoid.retweeted_status
	},
	retweeterUser() {
	return this.statusoid.user
	},
	retweeter() {
	return this.statusoid.user.name \|\| this.statusoid.user.screen_name_ui
	},
	retweeterHtml() {
	return this.statusoid.user.name
	},
	retweeterProfileLink() {
	return this.generateUserProfileLink(
	this.statusoid.user.id,
	this.statusoid.user.screen_name,
	)
	},
	status() {
	if (this.retweet) {
	return this.statusoid.retweeted_status
	} else {
	return this.statusoid
	}
	},
	statusFromGlobalRepository() {
	// NOTE: Consider to replace status with statusFromGlobalRepository
	return this.$store.state.statuses.allStatusesObject[this.status.id]
	},
	loggedIn() {
	return !!this.currentUser
	},
	muteFilterHits() {
	return muteFilterHits(
	Object.values(
	useServerSideStorageStore().prefsStorage.simple.muteFilters,
	),
	this.status,
	)
	},
	botStatus() {
	return this.status.user.actor_type === 'Service'
	},
	showActorTypeIndicator() {
	return !this.hideBotIndication
	},
	sensitiveStatus() {
	return this.status.nsfw
	},
	mentionsLine() {
	if (!this.headTailLinks) return []
	const writtenSet = new Set(
	this.headTailLinks.writtenMentions.map((_) => _.url),
	)
	return this.status.attentions
	.filter((attn) => {
	// no reply user
	return (
	attn.id !== this.status.in_reply_to_user_id &&
	// no self-replies
	attn.statusnet_profile_url !==
	this.status.user.statusnet_profile_url &&
	// don't include if mentions is written
	!writtenSet.has(attn.statusnet_profile_url)
	)
	})
	.map((attn) => ({
	url: attn.statusnet_profile_url,
	content: attn.screen_name,
	userId: attn.id,
	}))
	},
	hasMentionsLine() {
	return this.mentionsLine.length > 0
	},
	muteReasons() {
	return [
	this.userIsMuted ? 'user' : null,
	this.status.thread_muted ? 'thread' : null,
	this.muteFilterHits.length > 0 ? 'filtered' : null,
	this.muteBotStatuses && this.botStatus ? 'bot' : null,
	this.muteSensitiveStatuses && this.sensitiveStatus ? 'nsfw' : null,
	].filter((_) => _)
	},
	muteLocalized() {
	if (this.muteReasons.length === 0) return null
	const mainReason = () => {
	switch (this.muteReasons[0]) {
	case 'user':
	return this.$t('status.muted_user')
	case 'thread':
	return this.$t('status.thread_muted')
	case 'filtered':
	return this.$t(
	'status.muted_filters',
	{
	name: this.muteFilterHits[0].name,
	filterMore: this.muteFilterHits.length - 1,
	},
	this.muteFilterHits.length,
	)
	case 'bot':
	return this.$t('status.bot_muted')
	case 'nsfw':
	return this.$t('status.sensitive_muted')
	}
	}
	if (this.muteReasons.length > 1) {
	return this.$t(
	'status.multi_reason_mute',
	{
	main: mainReason(),
	numReasonsMore: this.muteReasons.length - 1,
	},
	this.muteReasons.length - 1,
	)
	} else {
	return mainReason()
	}
	},
	muted() {
	if (this.statusoid.user.id === this.currentUser.id) return false
	return !this.unmuted && !this.shouldNotMute && this.muteReasons.length > 0
	},
	userIsMuted() {
	if (this.statusoid.user.id === this.currentUser.id) return false
	const { status } = this
	const { reblog } = status
	const relationship = this.$store.getters.relationship(status.user.id)
	const relationshipReblog =
	reblog && this.$store.getters.relationship(reblog.user.id)
	return (
	(status.muted && !status.thread_muted) \|\|
	// Reprööt of a muted post according to BE
	(reblog && reblog.muted && !reblog.thread_muted) \|\|
	// Muted user
	relationship.muting \|\|
	// Muted user of a reprööt
	(relationshipReblog && relationshipReblog.muting)
	)
	},
	shouldNotMute() {
	if (this.isFocused) return true
	const { status } = this
	const { reblog } = status
	return (
	((this.inProfile &&
	// Don't mute user's posts on user timeline (except reblogs)
	((!reblog && status.user.id === this.profileUserId) \|\|
	// Same as above but also allow self-reblogs
	(reblog && reblog.user.id === this.profileUserId))) \|\|
	// Don't mute statuses in muted conversation when said conversation is opened
	(this.inConversation && status.thread_muted)) &&
	// No excuses if post has muted words
	!this.muteFilterHits.length > 0
	)
	},
	hideMutedUsers() {
	return this.mergedConfig.hideMutedPosts
	},
	hideMutedThreads() {
	return this.mergedConfig.hideMutedThreads
	},
	hideFilteredStatuses() {
	return this.mergedConfig.hideFilteredStatuses
	},
	hideWordFilteredPosts() {
	return this.mergedConfig.hideWordFilteredPosts
	},
	hideStatus() {
	return (
	!this.shouldNotMute &&
	((this.muted && this.hideFilteredStatuses) \|\|
	(this.userIsMuted && this.hideMutedUsers) \|\|
	(this.status.thread_muted && this.hideMutedThreads) \|\|
	(this.muteFilterHits.length > 0 && this.hideWordFilteredPosts) \|\|
	this.muteFilterHits.some((x) => x.hide))
	)
	},
	isFocused() {
	// retweet or root of an expanded conversation
	if (this.focused) {
	return true
	} else if (!this.inConversation) {
	return false
	}
	// use conversation highlight only when in conversation
	return this.status.id === this.highlight
	},
	isReply() {
	return !!(
	this.status.in_reply_to_status_id && this.status.in_reply_to_user_id
	)
	},
	replyToName() {
	if (this.status.in_reply_to_screen_name) {
	return this.status.in_reply_to_screen_name
	} else {
	const user = this.$store.getters.findUser(
	this.status.in_reply_to_user_id,
	)
	return user && user.screen_name_ui
	}
	},
	replySubject() {
	if (!this.status.summary) return ''
	const decodedSummary = ldUnescape(this.status.summary)
	const behavior = this.mergedConfig.subjectLineBehavior
	const startsWithRe = decodedSummary.match(/^re[: ]/i)
	if ((behavior !== 'noop' && startsWithRe) \|\| behavior === 'masto') {
	return decodedSummary
	} else if (behavior === 'email') {
	return 're: '.concat(decodedSummary)
	} else if (behavior === 'noop') {
	return ''
	}
	},
	combinedFavsAndRepeatsUsers() {
	// Use the status from the global status repository since favs and repeats are saved in it
	const combinedUsers = [].concat(
	this.statusFromGlobalRepository.favoritedBy,
	this.statusFromGlobalRepository.rebloggedBy,
	)
	return uniqBy(combinedUsers, 'id')
	},
	tags() {
	- // eslint-disable-next-line no-prototype-builtins
	return this.status.tags
	.filter((tagObj) => Object.hasOwn(tagObj, 'name'))
	.map((tagObj) => tagObj.name)
	.join(' ')
	},
	hidePostStats() {
	return this.mergedConfig.hidePostStats
	},
	shouldDisplayFavsAndRepeats() {
	return (
	!this.hidePostStats &&
	this.isFocused &&
	(this.combinedFavsAndRepeatsUsers.length > 0 \|\|
	this.statusFromGlobalRepository.quotes_count)
	)
	},
	muteBotStatuses() {
	return this.mergedConfig.muteBotStatuses
	},
	muteSensitiveStatuses() {
	return this.mergedConfig.muteSensitiveStatuses
	},
	hideBotIndication() {
	return this.mergedConfig.hideBotIndication
	},
	currentUser() {
	return this.$store.state.users.currentUser
	},
	mergedConfig() {
	return this.$store.getters.mergedConfig
	},
	isSuspendable() {
	return !this.replying && this.mediaPlaying.length === 0
	},
	inThreadForest() {
	return !!this.controlledThreadDisplayStatus
	},
	threadShowing() {
	return this.controlledThreadDisplayStatus === 'showing'
	},
	visibilityLocalized() {
	return this.$i18n.t('general.scope_in_timeline.' + this.status.visibility)
	},
	isEdited() {
	return this.status.edited_at !== null
	},
	editingAvailable() {
	return this.$store.state.instance.editingAvailable
	},
	hasVisibleQuote() {
	return this.status.quote_url && this.status.quote_visible
	},
	hasInvisibleQuote() {
	return this.status.quote_url && !this.status.quote_visible
	},
	quotedStatus() {
	return this.status.quote_id
	? this.$store.state.statuses.allStatusesObject[this.status.quote_id]
	: undefined
	},
	shouldDisplayQuote() {
	return this.quotedStatus && this.displayQuote
	},
	scrobblePresent() {
	if (this.mergedConfig.hideScrobbles) return false
	if (!this.status.user?.latestScrobble) return false
	const value = this.mergedConfig.hideScrobblesAfter.match(/\d+/gs)[0]
	const unit = this.mergedConfig.hideScrobblesAfter.match(/\D+/gs)[0]
	let multiplier = 60 * 1000 // minutes is smallest unit
	switch (unit) {
	case 'm':
	break
	case 'h':
	multiplier *= 60 // hour
	break
	case 'd':
	multiplier *= 60 // hour
	multiplier *= 24 // day
	break
	}
	const maxAge = Number(value) * multiplier
	const createdAt = Date.parse(this.status.user.latestScrobble.created_at)
	const age = Date.now() - createdAt
	if (age > maxAge) return false
	return this.status.user.latestScrobble.artist
	},
	scrobble() {
	return this.status.user?.latestScrobble
	},
	},
	methods: {
	visibilityIcon(visibility) {
	switch (visibility) {
	case 'private':
	return 'lock'
	case 'unlisted':
	return 'lock-open'
	case 'direct':
	return 'envelope'
	case 'local':
	return 'igloo'
	default:
	return 'globe'
	}
	},
	showError(error) {
	this.error = error
	},
	clearError() {
	this.$emit('interacted')
	this.error = undefined
	},
	toggleReplying() {
	this.$emit('interacted')
	if (this.replying) {
	this.$refs.postStatusForm.requestClose()
	} else {
	this.doToggleReplying()
	}
	},
	doToggleReplying() {
	controlledOrUncontrolledToggle(this, 'replying')
	},
	gotoOriginal(id) {
	if (this.inConversation) {
	this.$emit('goto', id)
	}
	},
	toggleExpanded() {
	this.$emit('toggleExpanded')
	},
	toggleMute() {
	this.unmuted = !this.unmuted
	},
	toggleUserExpanded() {
	this.userExpanded = !this.userExpanded
	},
	generateUserProfileLink(id, name) {
	return generateProfileLink(
	id,
	name,
	this.$store.state.instance.restrictedNicknames,
	)
	},
	addMediaPlaying(id) {
	controlledOrUncontrolledSet(
	this,
	'mediaPlaying',
	this.mediaPlaying.concat(id),
	)
	},
	removeMediaPlaying(id) {
	controlledOrUncontrolledSet(
	this,
	'mediaPlaying',
	this.mediaPlaying.filter((mediaId) => mediaId !== id),
	)
	},
	setHeadTailLinks(headTailLinks) {
	this.headTailLinks = headTailLinks
	},
	toggleThreadDisplay() {
	this.controlledToggleThreadDisplay()
	},
	scrollIfHighlighted(highlightId) {
	if (this.$el.getBoundingClientRect == null) return
	const id = highlightId
	if (this.status.id === id) {
	const rect = this.$el.getBoundingClientRect()
	if (rect.top < 100) {
	// Post is above screen, match its top to screen top
	window.scrollBy(0, rect.top - 100)
	} else if (rect.height >= window.innerHeight - 50) {
	// Post we want to see is taller than screen so match its top to screen top
	window.scrollBy(0, rect.top - 100)
	} else if (rect.bottom > window.innerHeight - 50) {
	// Post is below screen, match its bottom to screen bottom
	window.scrollBy(0, rect.bottom - window.innerHeight + 50)
	}
	}
	},
	toggleDisplayQuote() {
	if (this.shouldDisplayQuote) {
	this.displayQuote = false
	} else if (!this.quotedStatus) {
	this.$store.dispatch('fetchStatus', this.status.quote_id).then(() => {
	this.displayQuote = true
	})
	} else {
	this.displayQuote = true
	}
	},
	},
	watch: {
	highlight: function (id) {
	this.scrollIfHighlighted(id)
	},
	'status.repeat_num': function (num) {
	// refetch repeats when repeat_num is changed in any way
	if (
	this.isFocused &&
	this.statusFromGlobalRepository.rebloggedBy &&
	this.statusFromGlobalRepository.rebloggedBy.length !== num
	) {
	this.$store.dispatch('fetchRepeats', this.status.id)
	}
	},
	'status.fave_num': function (num) {
	// refetch favs when fave_num is changed in any way
	if (
	this.isFocused &&
	this.statusFromGlobalRepository.favoritedBy &&
	this.statusFromGlobalRepository.favoritedBy.length !== num
	) {
	this.$store.dispatch('fetchFavs', this.status.id)
	}
	},
	isSuspendable: function (val) {
	this.suspendable = val
	},
	},
	}

	export default Status
	diff --git a/src/modules/notifications.js b/src/modules/notifications.js
	index 6c1cb33c35..eec335419a 100644
	--- a/src/modules/notifications.js
	+++ b/src/modules/notifications.js
	@@ -1,190 +1,189 @@
	import { useReportsStore } from 'src/stores/reports.js'
	import { useServerSideStorageStore } from 'src/stores/serverSideStorage'
	import apiService from '../services/api/api.service.js'

	import {
	closeAllDesktopNotifications,
	closeDesktopNotification,
	} from '../services/desktop_notification_utils/desktop_notification_utils.js'
	import {
	isStatusNotification,
	isValidNotification,
	maybeShowNotification,
	} from '../services/notification_utils/notification_utils.js'

	const emptyNotifications = () => ({
	desktopNotificationSilence: true,
	maxId: 0,
	minId: Number.POSITIVE_INFINITY,
	data: [],
	idStore: {},
	loading: false,
	})

	export const defaultState = () => ({
	...emptyNotifications(),
	})

	export const notifications = {
	state: defaultState(),
	mutations: {
	addNewNotifications(state, { notifications }) {
	notifications.forEach((notification) => {
	state.data.push(notification)
	state.idStore[notification.id] = notification
	})
	},
	clearNotifications(state) {
	const blankState = defaultState()
	Object.keys(state).forEach((k) => {
	state[k] = blankState[k]
	})
	},
	updateNotificationsMinMaxId(state, id) {
	state.maxId = id > state.maxId ? id : state.maxId
	state.minId = id < state.minId ? id : state.minId
	},
	setNotificationsLoading(state, { value }) {
	state.loading = value
	},
	setNotificationsSilence(state, { value }) {
	state.desktopNotificationSilence = value
	},
	markNotificationsAsSeen(state) {
	state.data.forEach((notification) => {
	notification.seen = true
	})
	},
	markSingleNotificationAsSeen(state, { id }) {
	const notification = state.idStore[id]
	if (notification) notification.seen = true
	},
	dismissNotification(state, { id }) {
	state.data = state.data.filter((n) => n.id !== id)
	delete state.idStore[id]
	},
	updateNotification(state, { id, updater }) {
	const notification = state.idStore[id]
	notification && updater(notification)
	},
	},
	actions: {
	addNewNotifications(store, { notifications }) {
	const { commit, dispatch, state, rootState } = store
	const validNotifications = notifications.filter((notification) => {
	// If invalid notification, update ids but don't add it to store
	if (!isValidNotification(notification)) {
	console.error('Invalid notification:', notification)
	commit('updateNotificationsMinMaxId', notification.id)
	return false
	}
	return true
	})

	const statusNotifications = validNotifications.filter(
	(notification) =>
	isStatusNotification(notification.type) && notification.status,
	)

	// Synchronous commit to add all the statuses
	commit('addNewStatuses', {
	statuses: statusNotifications.map(
	(notification) => notification.status,
	),
	})

	// Update references to statuses in notifications to ones in the store
	statusNotifications.forEach((notification) => {
	const id = notification.status.id
	const referenceStatus = rootState.statuses.allStatusesObject[id]

	if (referenceStatus) {
	notification.status = referenceStatus
	}
	})

	validNotifications.forEach((notification) => {
	if (notification.type === 'pleroma:report') {
	useReportsStore().addReport(notification.report)
	}

	if (notification.type === 'pleroma:emoji_reaction') {
	dispatch('fetchEmojiReactionsBy', notification.status.id)
	}

	// Only add a new notification if we don't have one for the same action
	- // eslint-disable-next-line no-prototype-builtins
	if (!Object.hasOwn(state.idStore, notification.id)) {
	commit('updateNotificationsMinMaxId', notification.id)
	commit('addNewNotifications', { notifications: [notification] })

	maybeShowNotification(
	store,
	Object.values(
	useServerSideStorageStore().prefsStorage.simple.muteFilters,
	),
	notification,
	)
	} else if (notification.seen) {
	state.idStore[notification.id].seen = true
	}
	})
	},
	notificationClicked({ state, dispatch }, { id }) {
	const notification = state.idStore[id]
	const { type, seen } = notification

	if (!seen) {
	switch (type) {
	case 'mention':
	case 'pleroma:report':
	case 'follow_request':
	break
	default:
	dispatch('markSingleNotificationAsSeen', { id })
	}
	}
	},
	setNotificationsLoading({ commit }, { value }) {
	commit('setNotificationsLoading', { value })
	},
	setNotificationsSilence({ commit }, { value }) {
	commit('setNotificationsSilence', { value })
	},
	markNotificationsAsSeen({ rootState, state, commit }) {
	commit('markNotificationsAsSeen')
	apiService
	.markNotificationsAsSeen({
	id: state.maxId,
	credentials: rootState.users.currentUser.credentials,
	})
	.then(() => {
	closeAllDesktopNotifications(rootState)
	})
	},
	markSingleNotificationAsSeen({ rootState, commit }, { id }) {
	commit('markSingleNotificationAsSeen', { id })
	apiService
	.markNotificationsAsSeen({
	single: true,
	id,
	credentials: rootState.users.currentUser.credentials,
	})
	.then(() => {
	closeDesktopNotification(rootState, { id })
	})
	},
	dismissNotificationLocal({ commit }, { id }) {
	commit('dismissNotification', { id })
	},
	dismissNotification({ rootState, commit }, { id }) {
	commit('dismissNotification', { id })
	rootState.api.backendInteractor.dismissNotification({ id })
	},
	updateNotification({ commit }, { id, updater }) {
	commit('updateNotification', { id, updater })
	},
	},
	}

	export default notifications
	diff --git a/src/stores/serverSideStorage.js b/src/stores/serverSideStorage.js
	index 5e269cd75c..18d3fa4ee2 100644
	--- a/src/stores/serverSideStorage.js
	+++ b/src/stores/serverSideStorage.js
	@@ -1,644 +1,642 @@
	import {
	merge as _merge,
	clamp,
	cloneDeep,
	findLastIndex,
	flatten,
	get,
	groupBy,
	isEqual,
	set,
	takeRight,
	uniqWith,
	unset,
	} from 'lodash'
	import { defineStore } from 'pinia'
	import { CURRENT_UPDATE_COUNTER } from 'src/components/update_notification/update_notification.js'
	import { toRaw } from 'vue'

	export const VERSION = 1
	export const NEW_USER_DATE = new Date('2022-08-04') // date of writing this, basically

	export const COMMAND_TRIM_FLAGS = 1000
	export const COMMAND_TRIM_FLAGS_AND_RESET = 1001

	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
	configMigration: 0, // Counter for config -> server-side migrations
	reset: 0, // special flag that can be used to force-reset all flags, 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: {},
	},
	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) => ({
	...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 === 'number' \|\| typeof v === 'boolean') return
	if (typeof v === 'object' && v != null) return
	console.warn(`Preference simple.${k} as invalid type, 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, 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 source, source of truth irrelevant',
	)
	result.recent = cache
	result.stale = live
	} else {
	console.debug(
	'Different timestamp, 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) => ({
	_user: a._user ?? b._user,
	_version: a._version ?? b._version,
	_timestamp: a._timestamp ?? b._timestamp,
	needUpload: b.needUpload ?? a.needUpload,
	prefsStorage: _merge(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),
	]
	}),
	)
	}

	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
	}
	})
	return flatten(trimmedGrouped).sort((a, b) =>
	a.timestamp > b.timestamp ? 1 : -1,
	)
	}

	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') \|\|
	path.startsWith('objectCollections')
	) {
	throw new Error('Illegal operation "set" on a collection')
	}
	if (path.split(/\./g).length <= 1) {
	throw new Error(
	`Calling set on depth <= 1 (path: ${path}) is not allowed`,
	)
	}
	set(resultOutput, path, args[0])
	break
	case 'unset':
	if (
	path.startsWith('collections') \|\|
	path.startsWith('objectCollections')
	) {
	throw new Error('Illegal operation "unset" on a collection')
	}
	if (path.split(/\./g).length <= 2) {
	throw new Error(
	`Calling unset on depth <= 2 (path: ${path}) is not allowed`,
	)
	}
	unset(resultOutput, path)
	break
	case 'addToCollection':
	set(
	resultOutput,
	path,
	Array.from(new Set(get(resultOutput, path)).add(args[0])),
	)
	break
	case 'removeFromCollection': {
	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:
	throw new 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
	})
	}
	} else if (totalFlags.reset > 0 && totalFlags.reset < 9000) {
	console.debug('Received command to reset the flags')
	allFlagKeys.forEach((flag) => {
	result[flag] = 0
	})
	}
	result.reset = 0
	return result
	}

	export const _doMigrations = (cache) => {
	if (!cache) return cache

	if (cache._version < VERSION) {
	console.debug(
	'Local cached data has older version, seeing if there any migrations that can be applied',
	)

	// no migrations right now since we only have one version
	console.debug('No migrations found')
	}

	if (cache._version > VERSION) {
	console.debug(
	'Local cached 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(
	{},
	'serverSideStorage',
	{ from: cache._version, to: VERSION },
	cache,
	)
	}
	}
	}

	return cache
	}

	export const useServerSideStorageStore = defineStore('serverSideStorage', {
	state() {
	return cloneDeep(defaultState)
	},
	actions: {
	setFlag({ flag, value }) {
	this.flagStorage[flag] = value
	this.dirty = true
	},
	setPreference({ path, value }) {
	if (path.startsWith('_')) {
	throw new Error(
	`Tried to edit internal (starts with _) field '${path}', ignoring.`,
	)
	}
	if (
	path.startsWith('collections') \|\|
	path.startsWith('objectCollections')
	) {
	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') \|\|
	path.startsWith('objectCollections')
	) {
	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, value)
	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])
	} else if (path.startsWith('objectCollections')) {
	const { _key } = value
	if (!_key && typeof _key !== 'string') {
	throw new Error('Object for storage is missing _key field!')
	}
	const collection = new Set(get(this.prefsStorage, path + '.index'))
	collection.add(_key)
	set(this.prefsStorage, path + '.index', [...collection])
	set(this.prefsStorage, path + '.data.' + _key, value)
	}
	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 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,
	)
	},
	clearServerSideStorage() {
	const blankState = { ...cloneDeep(defaultState) }
	Object.keys(this).forEach((k) => {
	this[k] = blankState[k]
	})
	},
	setServerSideStorage(userData) {
	const live = userData.storage
	this.raw = live
	let cache = this.cache
	if (cache && cache._user !== userData.fqn) {
	console.warn(
	'Cache belongs to another user! reinitializing local cache!',
	)
	cache = null
	}

	cache = _doMigrations(cache)

	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 },
	})
	}

	if (!needUpload && recent && stale) {
	console.debug('Checking if data needs merging...')
	// discarding timestamps and versions
	- /* eslint-disable no-unused-vars */
	const { _timestamp: _0, _version: _1, ...recentData } = recent
	const { _timestamp: _2, _version: _3, ...staleData } = stale
	- /* eslint-enable no-unused-vars */
	dirty = !isEqual(recentData, 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
	}

	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
	},
	pushServerSideStorage({ 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 })
	.then((user) => {
	this.setServerSideStorage(user)
	this.dirty = false
	})
	},
	},
	})
	diff --git a/test/unit/specs/boot/routes.spec.js b/test/unit/specs/boot/routes.spec.js
	index 0cc9121a43..83cc37e7de 100644
	--- a/test/unit/specs/boot/routes.spec.js
	+++ b/test/unit/specs/boot/routes.spec.js
	@@ -1,97 +1,94 @@
	import routes from 'src/boot/routes'
	import { createMemoryHistory, createRouter } from 'vue-router'
	import { createStore } from 'vuex'

	const store = createStore({
	state: {
	instance: {},
	},
	})

	describe('routes', () => {
	const router = createRouter({
	history: createMemoryHistory(),
	routes: routes(store),
	})

	it('root path', async () => {
	await router.push('/main/all')

	const matchedComponents = router.currentRoute.value.matched

	- // eslint-disable-next-line no-prototype-builtins
	expect(
	Object.hasOwn(
	matchedComponents[0].components.default.components,
	'Timeline',
	),
	).to.eql(true)
	})

	it("user's profile", async () => {
	await router.push('/fake-user-name')

	const matchedComponents = router.currentRoute.value.matched

	- // eslint-disable-next-line no-prototype-builtins
	expect(
	Object.hasOwn(
	matchedComponents[0].components.default.components,
	'UserCard',
	),
	).to.eql(true)
	})

	it("user's profile at /users", async () => {
	await router.push('/users/fake-user-name')

	const matchedComponents = router.currentRoute.value.matched

	- // eslint-disable-next-line no-prototype-builtins
	expect(
	Object.hasOwn(
	matchedComponents[0].components.default.components,
	'UserCard',
	),
	).to.eql(true)
	})

	it('list view', async () => {
	await router.push('/lists')

	const matchedComponents = router.currentRoute.value.matched

	expect(
	Object.hasOwn(
	matchedComponents[0].components.default.components,
	'ListsCard',
	),
	).to.eql(true)
	})

	it('list timeline', async () => {
	await router.push('/lists/1')

	const matchedComponents = router.currentRoute.value.matched

	expect(
	Object.hasOwn(
	matchedComponents[0].components.default.components,
	'Timeline',
	),
	).to.eql(true)
	})

	it('list edit', async () => {
	await router.push('/lists/1/edit')

	const matchedComponents = router.currentRoute.value.matched

	expect(
	Object.hasOwn(
	matchedComponents[0].components.default.components,
	'BasicUserCard',
	),
	).to.eql(true)
	})
	})

File Metadata

Mime Type: text/x-diff
Expires: Sun, Aug 30, 7:03 AM (1 d, 18 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1737848
Default Alt Text: (59 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions