No OneTemporary
Actions

Size

33 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/components/desktop_nav/desktop_nav.js b/src/components/desktop_nav/desktop_nav.js
	index f651869914..32d0b37a94 100644
	--- a/src/components/desktop_nav/desktop_nav.js
	+++ b/src/components/desktop_nav/desktop_nav.js
	@@ -1,150 +1,148 @@
	import SearchBar from 'components/search_bar/search_bar.vue'
	import { mapActions, mapState } from 'pinia'
	import { defineAsyncComponent } from 'vue'

	import { useInstanceStore } from 'src/stores/instance.js'
	import { useInterfaceStore } from 'src/stores/interface'
	import { useMergedConfigStore } from 'src/stores/merged_config.js'
	-import { useUsersStore } from 'src/stores/users.js'
	import { useStreamingStore } from 'src/stores/streaming.js'
	+import { useUsersStore } from 'src/stores/users.js'

	-import {
	- WSConnectionStatus,
	-} from 'src/api/websocket.js'
	+import { WSConnectionStatus } from 'src/api/websocket.js'

	import { library } from '@fortawesome/fontawesome-svg-core'
	import {
	faBell,
	faBullhorn,
	faCog,
	faComments,
	faHome,
	faInfoCircle,
	+ faPlug,
	+ faPlugCircleXmark,
	faSearch,
	faSignInAlt,
	faSignOutAlt,
	faTachometerAlt,
	faUserPlus,
	- faPlug,
	- faPlugCircleXmark
	} from '@fortawesome/free-solid-svg-icons'

	library.add(
	faSignInAlt,
	faSignOutAlt,
	faHome,
	faComments,
	faBell,
	faUserPlus,
	faBullhorn,
	faSearch,
	faTachometerAlt,
	faCog,
	faInfoCircle,
	faPlug,
	- faPlugCircleXmark
	+ faPlugCircleXmark,
	)

	export default {
	components: {
	SearchBar,
	ConfirmModal: defineAsyncComponent(
	() => import('src/components/confirm_modal/confirm_modal.vue'),
	),
	},
	data: () => ({
	searchBarHidden: true,
	supportsMask:
	window.CSS?.supports &&
	(window.CSS.supports('mask-size', 'contain') \|\|
	window.CSS.supports('-webkit-mask-size', 'contain') \|\|
	window.CSS.supports('-moz-mask-size', 'contain') \|\|
	window.CSS.supports('-ms-mask-size', 'contain') \|\|
	window.CSS.supports('-o-mask-size', 'contain')),
	showingConfirmLogout: false,
	}),
	computed: {
	enableMask() {
	return this.supportsMask && this.logoMask
	},
	logoStyle() {
	return {
	visibility: this.enableMask ? 'hidden' : 'visible',
	}
	},
	logoMaskStyle() {
	return this.enableMask
	? {
	'mask-image': `url(${this.logo})`,
	}
	: {
	'background-color': this.enableMask ? '' : 'transparent',
	}
	},
	logoBgStyle() {
	const mask = this.enableMask
	? {}
	: { 'background-color': this.enableMask ? '' : 'transparent' }

	return {
	margin: `${this.logoMargin} 0`,
	opacity: this.searchBarHidden ? 1 : 0,
	...mask,
	}
	},
	...mapState(useInstanceStore, ['privateMode']),
	...mapState(useInstanceStore, {
	logoMask: (store) => store.instanceIdentity.logoMask,
	logo: (store) => store.instanceIdentity.logo,
	logoLeft: (store) => store.instanceIdentity.logoLeft,
	logoMargin: (store) => store.instanceIdentity.logoMargin,
	sitename: (store) => store.instanceIdentity.name,
	hideSitename: (store) => store.instanceIdentity.hideSitename,
	}),
	...mapState(useUsersStore, ['currentUser']),
	...mapState(useStreamingStore, {
	- streamingConnected: (store) => store.state === WSConnectionStatus.JOINED
	+ streamingConnected: (store) => store.state === WSConnectionStatus.JOINED,
	}),
	...mapState(useMergedConfigStore, ['mergedConfig']),
	shouldConfirmLogout() {
	return this.mergedConfig.modalOnLogout
	},
	streamingEnabled() {
	return this.mergedConfig.useStreamingApi
	},
	streamingTooltip() {
	if (this.streamingConnected) {
	return this.$t('timeline.socket_reconnected')
	} else {
	return this.$t('timeline.socket_disconnected')
	}
	- }
	+ },
	},
	methods: {
	scrollToTop() {
	window.scrollTo(0, 0)
	},
	showConfirmLogout() {
	this.showingConfirmLogout = true
	},
	hideConfirmLogout() {
	this.showingConfirmLogout = false
	},
	logout() {
	if (!this.shouldConfirmLogout) {
	this.doLogout()
	} else {
	this.showConfirmLogout()
	}
	},
	doLogout() {
	this.$router.replace('/main/public')
	useUsersStore().logout()
	this.hideConfirmLogout()
	},
	onSearchBarToggled(hidden) {
	this.searchBarHidden = hidden
	},
	...mapActions(useInterfaceStore, ['openSettingsModal']),
	},
	}
	diff --git a/src/components/desktop_nav/desktop_nav.vue b/src/components/desktop_nav/desktop_nav.vue
	index 9a93b395cc..52370a57f4 100644
	--- a/src/components/desktop_nav/desktop_nav.vue
	+++ b/src/components/desktop_nav/desktop_nav.vue
	@@ -1,117 +1,116 @@
	<template>
	<nav
	id="nav"
	class="DesktopNav"
	:class="{ '-logoLeft': logoLeft }"
	@click="scrollToTop()"
	>
	<div class="inner-nav">
	<div class="item sitename">
	<router-link
	v-if="!hideSitename"
	class="site-name"
	:to="{ name: 'root' }"
	active-class="home"
	>
	{{ sitename }}
	</router-link>
	<div
	class="nav-icon"
	v-if="streamingEnabled"
	:title="streamingTooltip"
	>
	<FAIcon
	v-if="streamingConnected"
	fixed-width
	class="fa-scale-110 fa-old-padding"
	icon="plug"
	/>
	-
	<FAIcon
	v-else
	fixed-width
	class="fa-scale-110 fa-old-padding"
	icon="plug-circle-xmark"
	/>
	</div>
	</div>
	<router-link
	class="logo"
	:to="{ name: 'root' }"
	:style="logoBgStyle"
	:title="sitename"
	>
	<div
	class="mask"
	:style="logoMaskStyle"
	/>
	<img
	:src="logo"
	:style="logoStyle"
	>
	</router-link>
	<div class="item right actions">
	<SearchBar
	v-if="currentUser \|\| !privateMode"
	@toggled="onSearchBarToggled"
	@click.stop
	/>
	<template v-if="searchBarHidden">
	<button
	class="button-unstyled nav-icon"
	:title="$t('nav.preferences')"
	@click.stop="openSettingsModal('user')"
	>
	<FAIcon
	fixed-width
	class="fa-scale-110 fa-old-padding"
	icon="cog"
	/>
	</button>
	<button
	v-if="currentUser?.role === 'admin'"
	class="button-unstyled nav-icon"
	target="_blank"
	:title="$t('nav.administration')"
	@click.stop="openSettingsModal('admin')"
	>
	<FAIcon
	fixed-width
	class="fa-scale-110 fa-old-padding"
	icon="tachometer-alt"
	/>
	</button>
	<span class="spacer" />
	<button
	v-if="currentUser"
	class="button-unstyled nav-icon"
	:title="$t('login.logout')"
	@click.stop.prevent="logout"
	>
	<FAIcon
	fixed-width
	class="fa-scale-110 fa-old-padding"
	icon="sign-out-alt"
	/>
	</button>
	</template>
	</div>
	</div>
	<teleport to="#modal">
	<ConfirmModal
	v-if="showingConfirmLogout"
	:title="$t('login.logout_confirm_title')"
	:confirm-danger="true"
	:confirm-text="$t('login.logout_confirm_accept_button')"
	:cancel-text="$t('login.logout_confirm_cancel_button')"
	@accepted="doLogout"
	@cancelled="hideConfirmLogout"
	>
	{{ $t('login.logout_confirm') }}
	</ConfirmModal>
	</teleport>
	</nav>
	</template>
	<script src="./desktop_nav.js"></script>

	<style src="./desktop_nav.scss" lang="scss"></style>
	diff --git a/src/components/settings_modal/tabs/general_tab.js b/src/components/settings_modal/tabs/general_tab.js
	index ebe33a9277..c090557cfc 100644
	--- a/src/components/settings_modal/tabs/general_tab.js
	+++ b/src/components/settings_modal/tabs/general_tab.js
	@@ -1,84 +1,84 @@
	import { mapState } from 'pinia'

	import FontControl from 'src/components/font_control/font_control.vue'
	import InterfaceLanguageSwitcher from 'src/components/interface_language_switcher/interface_language_switcher.vue'
	import BooleanSetting from '../helpers/boolean_setting.vue'
	import ChoiceSetting from '../helpers/choice_setting.vue'
	import FloatSetting from '../helpers/float_setting.vue'
	import SharedComputedObject from '../helpers/shared_computed_object.js'
	import UnitSetting from '../helpers/unit_setting.vue'

	import { useInstanceCapabilitiesStore } from 'src/stores/instance_capabilities.js'
	import { useLocalConfigStore } from 'src/stores/local_config.js'
	import { useMergedConfigStore } from 'src/stores/merged_config.js'
	import { useOAuthStore } from 'src/stores/oauth.js'
	+import { useStreamingStore } from 'src/stores/streaming.js'
	import { useSyncConfigStore } from 'src/stores/sync_config.js'
	import { useUsersStore } from 'src/stores/users.js'
	-import { useStreamingStore } from 'src/stores/streaming.js'

	import { updateProfile } from 'src/api/user.js'
	import localeService from 'src/services/locale/locale.service.js'

	const GeneralTab = {
	data() {
	return {
	absoluteTime12hOptions: ['24h', '12h'].map((mode) => ({
	key: mode,
	value: mode,
	label: this.$t(`settings.absolute_time_format_12h_${mode}`),
	})),
	emailLanguage: useUsersStore().currentUser.language \|\| [''],
	}
	},
	components: {
	BooleanSetting,
	ChoiceSetting,
	UnitSetting,
	FloatSetting,
	FontControl,
	InterfaceLanguageSwitcher,
	},
	computed: {
	language: {
	get: function () {
	return useMergedConfigStore().mergedConfig.interfaceLanguage
	},
	set: function (val) {
	useSyncConfigStore().setSimplePrefAndSave({
	path: 'interfaceLanguage',
	value: val,
	})
	},
	},
	...SharedComputedObject(),
	...mapState(useInstanceCapabilitiesStore, ['blockExpiration']),
	},
	methods: {
	updateProfile() {
	const params = {
	language: localeService.internalToBackendLocaleMulti(
	this.emailLanguage,
	),
	}

	updateProfile({
	params,
	credentials: useOAuthStore().token,
	}).then((result) => {
	useUsersStore().addNewUsers(result)
	})
	},
	updateFont(path, value) {
	useLocalConfigStore().set({ path, value })
	},
	toggleStreaming(value) {
	if (value) {
	useStreamingStore().initSocket()
	} else {
	useStreamingStore().stopSocket()
	}
	},
	},
	}

	export default GeneralTab
	diff --git a/src/components/status_action_buttons/action_button.js b/src/components/status_action_buttons/action_button.js
	index ba4c1c9e5d..97c9ac6920 100644
	--- a/src/components/status_action_buttons/action_button.js
	+++ b/src/components/status_action_buttons/action_button.js
	@@ -1,177 +1,177 @@
	import Popover from 'src/components/popover/popover.vue'
	import StatusBookmarkFolderMenu from 'src/components/status_bookmark_folder_menu/status_bookmark_folder_menu.vue'
	import EmojiPicker from '../emoji_picker/emoji_picker.vue'

	import { useInstanceStore } from 'src/stores/instance.js'
	import { useInstanceCapabilitiesStore } from 'src/stores/instance_capabilities.js'
	import { useMergedConfigStore } from 'src/stores/merged_config.js'
	-import { useUsersStore } from 'src/stores/users.js'
	import { useStatusesStore } from 'src/stores/statuses.js'
	+import { useUsersStore } from 'src/stores/users.js'

	import { library } from '@fortawesome/fontawesome-svg-core'
	import {
	faBookmark as faBookmarkRegular,
	faFaceSmileBeam,
	faStar as faStarRegular,
	} from '@fortawesome/free-regular-svg-icons'
	import {
	faBookmark,
	faCheck,
	faChevronDown,
	faChevronRight,
	faComments,
	faExternalLinkAlt,
	faEye,
	faEyeSlash,
	faHistory,
	faList,
	faMinus,
	faPencil,
	faPlus,
	faReply,
	faRetweet,
	faShareAlt,
	faStar,
	faThumbtack,
	faTimes,
	faWrench,
	} from '@fortawesome/free-solid-svg-icons'

	library.add(
	faPlus,
	faMinus,
	faCheck,
	faTimes,
	faWrench,

	faChevronRight,
	faChevronDown,

	faReply,
	faRetweet,
	faStar,
	faStarRegular,
	faFaceSmileBeam,

	faBookmark,
	faBookmarkRegular,
	faEyeSlash,
	faEye,
	faThumbtack,
	faPencil,
	faShareAlt,
	faComments,
	faList,
	faExternalLinkAlt,
	faHistory,
	)

	export default {
	props: [
	'button',
	'status',
	'extra',
	'status',
	'funcArg',
	'getClass',
	'getComponent',
	'doAction',
	'outerClose',
	'defaultButtonStyle',
	'hideLabel',
	],
	components: {
	StatusBookmarkFolderMenu,
	EmojiPicker,
	Popover,
	},
	data: () => ({
	animationState: false,
	}),
	computed: {
	buttonClass() {
	return [
	this.button.name + '-button',
	{
	'-with-extra': this.button.name === 'bookmark',
	'-extra': this.extra,
	'-quick': !this.extra,
	},
	]
	},
	userIsMuted() {
	return useUsersStore().relationship(this.status.user.id).muting
	},
	threadIsMuted() {
	return this.status.thread_muted
	},
	hideCustomEmoji() {
	return !useInstanceCapabilitiesStore()
	.pleromaCustomEmojiReactionsAvailable
	},
	hidePostStats() {
	return useMergedConfigStore().mergedConfig.hidePostStats
	},
	buttonInnerClass() {
	const buttonStyleClass = this.defaultButtonStyle
	? 'button-default'
	: 'button-unstyled'
	return [
	this.button.name + '-button',
	{
	'main-button': this.extra,
	[buttonStyleClass]: !this.extra,
	'-active': this.button.active?.(this.funcArg),
	disabled: this.button.interactive
	? !this.button.interactive(this.funcArg)
	: false,
	},
	]
	},
	remoteInteractionLink() {
	return useInstanceStore().getRemoteInteractionLink({
	statusId: this.status.id,
	})
	},
	},
	methods: {
	addReaction(event) {
	const emoji = event.insertion
	const existingReaction = this.status.emoji_reactions.find(
	(r) => r.name === emoji,
	)
	if (existingReaction?.me) {
	useStatusesStore().unreactWithEmoji(this.status.id, emoji)
	} else {
	useStatusesStore().reactWithEmoji(this.status.id, emoji)
	}
	},
	onShowEmojiPicker() {
	this.$emit('emojiPickerShown', true)
	},
	onHideEmojiPicker() {
	this.$emit('emojiPickerShown', false)
	},
	doActionWrap(
	button,
	close = () => {
	/* no-op */
	},
	) {
	if (
	this.button.interactive ? !this.button.interactive(this.funcArg) : false
	)
	return
	if (button.name === 'emoji') {
	this.$refs.picker.togglePicker()
	} else {
	this.animationState = true
	this.getComponent(button) === 'button' && this.doAction(button)
	setTimeout(() => {
	this.animationState = false
	}, 500)
	if (!this.button.dropdown) close()
	}
	},
	},
	}
	diff --git a/src/components/user_avatar/user_avatar.js b/src/components/user_avatar/user_avatar.js
	index 585cf52ee5..b80aa8fb8b 100644
	--- a/src/components/user_avatar/user_avatar.js
	+++ b/src/components/user_avatar/user_avatar.js
	@@ -1,56 +1,56 @@
	import { useInstanceStore } from 'src/stores/instance.js'
	import { useInterfaceStore } from 'src/stores/interface.js'
	-import { useUsersStore } from 'src/stores/users.js'
	import { useMergedConfigStore } from 'src/stores/merged_config.js'
	+import { useUsersStore } from 'src/stores/users.js'

	import { library } from '@fortawesome/fontawesome-svg-core'
	import { faPeopleGroup, faRobot } from '@fortawesome/free-solid-svg-icons'

	library.add(faRobot, faPeopleGroup)

	const UserAvatar = {
	props: {
	// UserID of a user to show avatar of
	userId: {
	required: true,
	type: String,
	},
	// Use less space and use alternative roundness
	compact: {
	required: false,
	type: Boolean,
	default: false,
	},
	// Override avatar image URL, useful for profile editing
	url: {
	required: false,
	type: String,
	default: null,
	},
	},
	data() {
	return {
	showPlaceholder: false,
	defaultAvatar: `${useInstanceStore().server + useInstanceStore().instanceIdentity.defaultAvatar}`,
	betterShadow: useInterfaceStore().browserSupport.cssFilter,
	}
	},
	computed: {
	user() {
	return useUsersStore().findUser(this.userId)
	},
	showActorTypeIndicator() {
	return useMergedConfigStore().mergedConfig.hideBotIndication
	},
	},
	methods: {
	imgSrc(src) {
	return !src \|\| this.showPlaceholder ? this.defaultAvatar : src
	},
	imageLoadError() {
	this.showPlaceholder = true
	},
	},
	}

	export default UserAvatar
	diff --git a/src/stores/streaming.js b/src/stores/streaming.js
	index 306501ac85..cce3c175b4 100644
	--- a/src/stores/streaming.js
	+++ b/src/stores/streaming.js
	@@ -1,247 +1,247 @@
	import { defineStore } from 'pinia'

	import { useOAuthStore } from 'src/stores/oauth.js'

	import {
	getMastodonSocketURI,
	ProcessedWS,
	WSConnectionStatus,
	} from 'src/api/websocket.js'

	const ARGUMENT_MAP = {
	tag: 'tag',
	list: 'list',
	}

	export const TIMELINE_STREAM_MAP = {
	friends: 'user',
	public: 'public',
	tag: 'hashtag',
	list: 'list',
	dms: 'direct',
	}

	const retryTimeout = (multiplier) => 1000 * multiplier

	export class StreamStateEvent extends Event {
	original

	constructor(name, original) {
	super(name)
	this.original = original
	}
	}

	export class StreamErrorEvent extends Event {
	error

	constructor(error) {
	super('error', error)
	this.error = error
	}
	}

	export class StreamMessageEvent extends Event {
	data
	stream
	timestamp

	constructor(name, stream, data) {
	super(name)
	this.data = data
	this.stream = stream
	this.timestamp = Date.now()
	}
	}

	export const useStreamingStore = defineStore('streaming', {
	state: () => ({
	socket: null,
	error: null,
	state: null,
	retryMultiplier: 1,
	retrying: false,
	subscribers: new Set(),
	subscriptions: new Map(),
	globalSubscriptions: new Set(),
	}),
	actions: {
	addSubscriber(subscriber) {
	const { stream, et } = subscriber

	if (stream) {
	if (!this.subscriptions.has(stream.name)) {
	this.subscriptions.set(stream.name, new Map())
	}

	const streamSubs = this.subscriptions.get(stream.name)

	if (streamSubs.has(stream.argument)) {
	throw new Error('Subscription already exists!')
	}

	streamSubs.set(stream.argument, subscriber)
	} else {
	this.globalSubscriptions.add(subscriber)
	}

	this.subscribers.add(subscriber)
	if (this.state === WSConnectionStatus.JOINED) {
	if (stream) {
	this.socket.subscribe(...this.getSubArgs(stream))
	}
	et.dispatchEvent(new StreamStateEvent('open'))
	}
	},
	removeSubscriber(subscriber) {
	const { stream } = subscriber

	this.subscribers.delete(subscriber)
	if (stream) {
	this.subscriptions.get(stream.name).delete(stream.argument)
	}

	if (this.state === WSConnectionStatus.JOINED) {
	this.socket.unsubscribe(...this.getSubArgs(stream))
	}
	},
	initSocket(initial) {
	this.state = initial
	? WSConnectionStatus.STARTING_INITIAL
	: WSConnectionStatus.STARTING

	const credentials = useOAuthStore().token
	const url = getMastodonSocketURI({ credentials })

	this.socket = ProcessedWS({
	url,
	id: 'Unified',
	credentials,
	})

	this.socket.addEventListener('pleroma:authenticated', this.onAuth)
	this.socket.addEventListener('open', this.onOpen)
	this.socket.addEventListener('close', this.onClose)
	this.socket.addEventListener('message', this.onMessage)
	this.socket.addEventListener('error', this.onError)
	},
	stopSocket() {
	this.socket.close()
	this.state = WSConnectionStatus.CLOSED
	},

	getSubArgs(stream) {
	const argumentKey = ARGUMENT_MAP[stream.name]
	const args = argumentKey
	? {
	[argumentKey]: stream.argument,
	}
	: null

	return [stream.name, args]
	},
	onAuth() {
	this.subscribers.forEach(({ stream, et }) => {
	et.dispatchEvent(new StreamStateEvent('authenticated'))

	if (stream) {
	this.socket.subscribe(...this.getSubArgs(stream))
	}
	})
	this.state = WSConnectionStatus.JOINED
	},
	onOpen() {
	this.retryMultiplier = 1
	- this.retrying = false,
	+ this.retrying = false
	this.error = null
	this.subscribers.forEach(({ stream, et }) => {
	et.dispatchEvent(new StreamStateEvent('open'))
	})
	},
	onMessage({ data: message }) {
	if (!message) return // pings
	const { event: eventName, stream: eventStream, ...data } = message
	const [streamName, streamArgument] = eventStream ?? []

	const subscriber = this.subscriptions.get(streamName)?.get(streamArgument)

	const totalSubs = [
	...this.globalSubscriptions.values(),
	subscriber,
	].filter(Boolean)

	const eventData = (() => {
	switch (eventName) {
	case 'status.update':
	case 'update':
	return [data.status]
	case 'notification':
	return [data.notification]
	case 'delete':
	return [data.id]
	default:
	console.log('UNKNOWN', eventName, eventStream, data)
	return data
	}
	})()

	const event = new StreamMessageEvent(
	eventName,
	{ name: streamName, argument: streamArgument },
	eventData,
	)

	totalSubs.forEach(({ stream, et }) => {
	et.dispatchEvent(event)
	})
	},
	onError({ data: error }) {
	this.subscribers.forEach(({ stream, et }) => {
	et.dispatchEvent(new StreamErrorEvent(error))
	})
	this.error = error
	console.error('Error in MastoAPI websocket:', error)
	},
	onClose({ data: closeEvent }) {
	const ignoreCodes = new Set([
	1000, // Normal (intended) closure
	1001, // Going away
	])
	const { code } = closeEvent

	if (ignoreCodes.has(code)) {
	console.debug(
	`Not restarting socket becasue of closure code ${code} is in ignore list`,
	)

	this.state = WSConnectionStatus.CLOSED
	this.retrying = false
	this.error = null
	this.retryMultiplier = 1

	this.subscribers.forEach(({ et }) => {
	et.dispatchEvent(new StreamStateEvent('close', closeEvent))
	})
	} else {
	console.warn(
	`MastoAPI websocket disconnected, restarting. CloseEvent code: ${code}`,
	)

	setTimeout(() => {
	this.initSocket()
	}, retryTimeout(this.retryMultiplier))

	this.retryMultiplier += 1

	if (!this.retrying) {
	this.subscribers.forEach(({ et }) => {
	et.dispatchEvent(new StreamStateEvent('close', closeEvent))
	})
	}

	this.retrying = true
	this.state = WSConnectionStatus.ERROR
	}
	},
	},
	})
	diff --git a/src/stores/timelines.js b/src/stores/timelines.js
	index 67b0c20f51..ce67bf5b50 100644
	--- a/src/stores/timelines.js
	+++ b/src/stores/timelines.js
	@@ -1,335 +1,338 @@
	import { first, last, max, min } from 'lodash'
	import { defineStore } from 'pinia'

	import { useInstanceCapabilitiesStore } from 'src/stores/instance_capabilities.js'
	import { useOAuthStore } from 'src/stores/oauth.js'
	import { useStatusesStore } from 'src/stores/statuses.js'
	import { TIMELINE_STREAM_MAP, useStreamingStore } from 'src/stores/streaming.js'
	import { useUsersStore } from 'src/stores/users.js'

	import timelineFetcher from 'src/services/timeline_fetcher/timeline_fetcher.service.js'

	const emptyTl = (name, argument = null) => {
	const result = {
	name,
	statuses: new Map(),
	visibleStatusesIds: new Set(),
	newStatusCount: 0,
	maxId: '',
	minId: '',
	minVisibleId: '',
	loading: false,
	streaming: false,
	flushMarker: 0,
	fetcher: null,
	}

	const property = ARGUMENT_MAP[name]

	if (property) {
	result[property] = argument
	}

	if (name === 'dms' \|\| name === 'friends') {
	result.persistent = true
	}

	return result
	}

	export const ARGUMENT_MAP = {
	tag: 'tag',
	list: 'listId',
	bookmarks: 'bookmarkFolderId',
	quotes: 'statusId',
	search: 'query',
	user: 'userId',
	userPinned: 'userId',
	media: 'userId',
	}

	const TIMELINES = new Set([
	'mentions',
	'public',
	'user',
	'userPinned',
	'media',
	'favorites',
	'publicAndExternal',
	'friends',
	'tag',
	'dms',
	'bookmarks',
	'list',
	'bubble',
	'quotes',
	'search',
	])

	export const defaultState = () => {
	return Object.fromEntries([...TIMELINES].map((name) => [name, emptyTl(name)]))
	}

	//const CUSTOM_SORT = new Set(['bookmarks', 'favorites'])

	export const useTimelinesStore = defineStore('timelines', {
	state: defaultState,
	actions: {
	// (De)Initialization stuff
	activate(timelineName, argument, persistent) {
	const timeline = this[timelineName]
	if (timeline.persistent && !persistent) return

	if (
	timelineName === 'favourites' &&
	!useInstanceCapabilitiesStore().pleromaPublicFavouritesAvailable
	) {
	- console.warn('Instance doesn\'t support public favorites timeline')
	+ console.warn("Instance doesn't support public favorites timeline")
	return
	}

	timeline.fetcher = timelineFetcher(
	timeline,
	argument,
	useOAuthStore().token,
	)

	this.startFetchingTimeline(timelineName, argument, 'Timeline activated')

	const streamName = TIMELINE_STREAM_MAP[timelineName]

	if (streamName) {
	const et = new EventTarget()
	const openHandler = () => this.onStreamConnect(timelineName, argument)
	const closeHandler = () =>
	this.onStreamDisconnect(timelineName, argument)
	const messageHandler =
	() =>
	({ detail: message }) =>
	this.onStreamMessage(timelineName, argument, message)

	et.addEventListener('open', openHandler)
	et.addEventListener('close', closeHandler)
	et.addEventListener('update', messageHandler)

	timeline.socket = {
	stream: {
	name: streamName,
	argument,
	},
	et,
	handlers: {
	openHandler,
	closeHandler,
	messageHandler,
	},
	}

	useStreamingStore().addSubscriber(timeline.socket)
	}
	},
	deactivate(timelineName, persistent) {
	const timeline = this[timelineName]
	if (timeline.persistent && !persistent) return
	if (!timeline.streaming) {
	this.stopFetchingTimeline(timelineName, 'Timeline deactivation')
	}

	if (timeline.socket) {
	useStreamingStore().removeSubscriber(timeline.socket)

	const { openHandler, closeHandler, messageHandler } =
	timeline.socket.handlers
	timeline.socket.et.removeEventListener('open', openHandler)
	timeline.socket.et.removeEventListener('close', closeHandler)
	timeline.socket.et.removeEventListener('message', messageHandler)
	}

	this[timelineName] = emptyTl(timelineName)
	},
	activatePersistents() {
	TIMELINES.forEach((name) => {
	if (this[name].persistent) {
	this.activate(name, undefined, true)
	}
	})
	},
	deactivateAll() {
	TIMELINES.forEach((name) => {
	this.deactivate(name, true)
	})
	},

	// Update stuff
	addStatusesToTimeline(
	timelineName,
	argument,
	{
	statuses,
	showImmediately = false,
	noIdUpdate = false,
	pagination = {},
	nested = false,
	},
	) {
	if (statuses.length === 0) return
	const timeline = this[timelineName]

	// This makes sure that user timeline won't get data meant for other
	// user. I.e. opening different user profiles makes request which could
	// return data late after user already viewing different user profile
	// Same can happen with tags etc.
	const property = ARGUMENT_MAP[name]

	if (property && timeline[property] !== argument) {
	return
	}

	if (!noIdUpdate) {
	this.updateTimelineExtremes(
	timeline,
	statuses.map((x) => x.id),
	pagination,
	)
	}

	statuses.forEach((status) => {
	const isNew = !timeline.statuses.has(status.id)
	timeline.statuses.set(status.id, status)

	if (isNew) {
	if (showImmediately) {
	// Add it directly to the visibleStatuses, don't change
	// newStatusCount
	timeline.visibleStatusesIds.add(status.id)
	} else {
	// Just change newStatuscount
	timeline.newStatusCount += 1
	}
	}

	if (nested) return
	// We are mentioned in a post
	if (
	status.type === 'status' &&
	status.attentions.some(
	({ id }) => id === useUsersStore().currentUser?.id,
	)
	) {
	// Add the mention to the mentions timeline
	if (timeline !== this.mentions) {
	this.addStatusesToTimeline('mentions', null, {
	statuses: [status],
	nested: true,
	})
	}
	}

	if (status.visibility === 'direct') {
	if (timeline !== this.dms) {
	- this.addStatusesToTimeline('dms', null, { statuses: [status], nested: true })
	+ this.addStatusesToTimeline('dms', null, {
	+ statuses: [status],
	+ nested: true,
	+ })
	}
	}
	})
	},
	onStreamMessage(timeline, argument, event) {
	// This relies on statuses store to process this event first
	const status = useStatusesStore().allStatuses.get(event.data.status.id)

	this.addStatusesToTimeline(timeline, argument, {
	statuses: [status],
	})
	},

	// Poll & Push
	onStreamConnect(timeline) {
	console.debug('[Timelines] Stream connected', timeline)
	this[timeline].streaming = true
	this.stopFetchingTimeline(timeline, 'Socket connected')
	},
	onStreamDisconnect(timeline, argument) {
	console.debug('[Timelines] Stream disconnected', timeline, argument)
	this[timeline].streaming = false
	this.startFetchingTimeline(timeline, argument, 'Socket disconnected')
	},
	startFetchingTimeline(timelineName, argument, reason) {
	console.debug(
	'[Timelines] Starting fetching timeline',
	timelineName,
	argument,
	'Reason:',
	reason,
	)
	const timeline = this[timelineName]
	timeline.fetcher.startFetching()
	},
	stopFetchingTimeline(timelineName, reason) {
	console.debug(
	'[Timelines] Stopped fetching timeline',
	timelineName,
	'Reason:',
	reason,
	)
	const timeline = this[timelineName]
	timeline.fetcher.stopFetching()
	},

	// Queues & Timeline manip
	updateTimelineExtremes(timeline, statuses, pagination = {}) {
	// Can't use Math.min/max because it doesn't work with string (duh)
	const minNew = pagination.maxId ?? min(...statuses) ?? ''
	const maxNew = pagination.minId ?? max(...statuses) ?? ''

	const newer = maxNew > timeline.maxId
	const older = minNew < timeline.minId

	if (newer \|\| timeline.maxId === '') {
	timeline.maxId = maxNew
	}
	if (older \|\| timeline.minId === '') {
	timeline.minId = minNew
	}
	},
	showNewStatuses(timelineName) {
	const timeline = this[timelineName]

	timeline.newStatusCount = 0

	timeline.visibleStatusesIds = new Set(
	[...timeline.statuses.keys()].slice(0, 50),
	)
	timeline.minVisibleId = last(timeline.visibleStatusesIds.keys())
	timeline.minId = ''
	timeline.maxId = ''

	this.updateTimelineExtremes(timeline, [...timeline.statuses.keys()])
	},
	queueFlush(timeline, id) {
	this[timeline].flushMarker = id
	},
	queueFlushAll() {
	Object.keys(this).forEach((timeline) => {
	this[timeline].flushMarker = this[timeline].maxId
	})
	},

	// Misc
	removeUserStatuses({ timelineName, userId }) {
	const timeline = this.timelines[timelineName]

	timeline.statuses
	.values()
	.filter(({ user }) => user.id === userId)
	.forEach(({ id }) => {
	timeline.statuses.delete(id)
	timeline.visibleStatusesIds.delete(id)
	})
	timeline.minVisibleId =
	timeline.visibleStatusesIds.size > 0
	? last(timeline.visibleStatusesIds).id
	: 0
	timeline.maxId =
	timeline.statuses.length > 0 ? first(timeline.statuses).id : 0
	},
	},
	})

File Metadata

Mime Type: text/x-diff
Expires: Tue, Oct 13, 9:47 PM (1 d, 22 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1786913
Default Alt Text: (33 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions