refactor: app.js (#1291)

* refactor: frontend

* Fix avatar gallery sort

* Update .NET dependencies

* Update npm dependencies

electron v37.1.0

* bulkRefreshFriends

* fix dark theme

* Remove crowdin

* Fix config.json dialog not updating

* VRCX log file fixes & add Cef log

* Remove SharedVariable, fix startup

* Revert init theme change

* Logging date not working? Fix WinformThemer designer error

* Add Cef request hander, no more escaping main page

* clean

* fix

* fix

* clean

* uh

* Apply thememode at startup, fixes random user colours

* Split database into files

* Instance info remove empty lines

* Open external VRC links with VRCX

* Electron fixes

* fix userdialog style

* ohhhh

* fix store

* fix store

* fix: load all group members after kicking a user

* fix: world dialog favorite button style

* fix: Clear VRCX Cache Timer input value

* clean

* Fix VR overlay

* Fix VR overlay 2

* Fix Discord discord rich presence for RPC worlds

* Clean up age verified user tags

* Fix playerList being occupied after program reload

* no `this`

* Fix login stuck loading

* writable: false

* Hide dialogs on logout

* add flush sync option

* rm LOGIN event

* rm LOGOUT event

* remove duplicate event listeners

* remove duplicate event listeners

* clean

* remove duplicate event listeners

* clean

* fix theme style

* fix t

* clearable

* clean

* fix ipcEvent

* Small changes

* Popcorn Palace support

* Remove checkActiveFriends

* Clean up

* Fix dragEnterCef

* Block API requests when not logged in

* Clear state on login & logout

* Fix worldDialog instances not updating

* use <script setup>

* Fix avatar change event, CheckGameRunning at startup

* Fix image dragging

* fix

* Remove PWI

* fix updateLoop

* add webpack-dev-server to dev environment

* rm unnecessary chunks

* use <script setup>

* webpack-dev-server changes

* use <script setup>

* use <script setup>

* Fix UGC text size

* Split login event

* t

* use <script setup>

* fix

* Update .gitignore and enable checkJs in jsconfig

* fix i18n t

* use <script setup>

* use <script setup>

* clean

* global types

* fix

* use checkJs for debugging

* Add watchState for login watchers

* fix .vue template

* type fixes

* rm Vue.filter

* Cef v138.0.170, VC++ 2022

* Settings fixes

* Remove 'USER:CURRENT'

* clean up 2FA callbacks

* remove userApply

* rm i18n import

* notification handling to use notification store methods

* refactor favorite handling to use favorite store methods and clean up event emissions

* refactor moderation handling to use dedicated functions for player moderation events

* refactor friend handling to use dedicated functions for friend events

* Fix program startup, move lang init

* Fix friend state

* Fix status change error

* Fix user notes diff

* fix

* rm group event

* rm auth event

* rm avatar event

* clean

* clean

* getUser

* getFriends

* getFavoriteWorlds, getFavoriteAvatars

* AvatarGalleryUpload btn style & package.json update

* Fix friend requests

* Apply user

* Apply world

* Fix note diff

* Fix VR overlay

* Fixes

* Update build scripts

* Apply avatar

* Apply instance

* Apply group

* update hidden VRC+ badge

* Fix sameInstance "private"

* fix 502/504 API errors

* fix 502/504 API errors

* clean

* Fix friend in same instance on orange showing twice in friends list

* Add back in broken friend state repair methods

* add types

---------

Co-authored-by: Natsumi <cmcooper123@hotmail.com>
This commit is contained in:
pa
2025-07-14 12:00:08 +09:00
committed by GitHub
parent 952fd77ed5
commit f4f78bb5ec
323 changed files with 47745 additions and 43326 deletions
+238
View File
@@ -0,0 +1,238 @@
import { defineStore } from 'pinia';
import { computed, reactive, watch } from 'vue';
import configRepository from '../service/config';
import { database } from '../service/database';
import { watchState } from '../service/watchState';
import { useFriendStore } from './friend';
import { useNotificationStore } from './notification';
import { useSharedFeedStore } from './sharedFeed';
import { useUiStore } from './ui';
import { useVrcxStore } from './vrcx';
export const useFeedStore = defineStore('Feed', () => {
const friendStore = useFriendStore();
const notificationStore = useNotificationStore();
const UiStore = useUiStore();
const vrcxStore = useVrcxStore();
const sharedFeedStore = useSharedFeedStore();
const state = reactive({
feedTable: {
data: [],
search: '',
vip: false,
loading: false,
filter: [],
tableProps: {
stripe: true,
size: 'mini',
defaultSort: {
prop: 'created_at',
order: 'descending'
}
},
pageSize: 15,
paginationProps: {
small: true,
layout: 'sizes,prev,pager,next,total',
pageSizes: [10, 15, 20, 25, 50, 100]
}
},
feedSessionTable: []
});
async function init() {
state.feedTable.filter = JSON.parse(
await configRepository.getString('VRCX_feedTableFilters', '[]')
);
state.feedTable.vip = await configRepository.getBool(
'VRCX_feedTableVIPFilter',
false
);
}
init();
const feedTable = computed({
get: () => state.feedTable,
set: (value) => {
state.feedTable = value;
}
});
const feedSessionTable = computed({
get: () => state.feedSessionTable,
set: (value) => {
state.feedSessionTable = value;
}
});
watch(
() => watchState.isLoggedIn,
(isLoggedIn) => {
state.feedTable.data = [];
state.feedSessionTable = [];
if (isLoggedIn) {
initFeedTable();
}
},
{ flush: 'sync' }
);
function feedSearch(row) {
const value = state.feedTable.search.toUpperCase();
if (!value) {
return true;
}
if (
(value.startsWith('wrld_') || value.startsWith('grp_')) &&
String(row.location).toUpperCase().includes(value)
) {
return true;
}
switch (row.type) {
case 'GPS':
if (String(row.displayName).toUpperCase().includes(value)) {
return true;
}
if (String(row.worldName).toUpperCase().includes(value)) {
return true;
}
return false;
case 'Online':
if (String(row.displayName).toUpperCase().includes(value)) {
return true;
}
if (String(row.worldName).toUpperCase().includes(value)) {
return true;
}
return false;
case 'Offline':
if (String(row.displayName).toUpperCase().includes(value)) {
return true;
}
if (String(row.worldName).toUpperCase().includes(value)) {
return true;
}
return false;
case 'Status':
if (String(row.displayName).toUpperCase().includes(value)) {
return true;
}
if (String(row.status).toUpperCase().includes(value)) {
return true;
}
if (
String(row.statusDescription).toUpperCase().includes(value)
) {
return true;
}
return false;
case 'Avatar':
if (String(row.displayName).toUpperCase().includes(value)) {
return true;
}
if (String(row.avatarName).toUpperCase().includes(value)) {
return true;
}
return false;
case 'Bio':
if (String(row.displayName).toUpperCase().includes(value)) {
return true;
}
if (String(row.bio).toUpperCase().includes(value)) {
return true;
}
if (String(row.previousBio).toUpperCase().includes(value)) {
return true;
}
return false;
}
return true;
}
async function feedTableLookup() {
await configRepository.setString(
'VRCX_feedTableFilters',
JSON.stringify(state.feedTable.filter)
);
await configRepository.setBool(
'VRCX_feedTableVIPFilter',
state.feedTable.vip
);
state.feedTable.loading = true;
let vipList = [];
if (state.feedTable.vip) {
vipList = Array.from(friendStore.localFavoriteFriends.values());
}
state.feedTable.data = await database.lookupFeedDatabase(
state.feedTable.search,
state.feedTable.filter,
vipList
);
state.feedTable.loading = false;
}
function addFeed(feed) {
notificationStore.queueFeedNoty(feed);
state.feedSessionTable.push(feed);
sharedFeedStore.updateSharedFeed(false);
if (
state.feedTable.filter.length > 0 &&
!state.feedTable.filter.includes(feed.type)
) {
return;
}
if (
state.feedTable.vip &&
!friendStore.localFavoriteFriends.has(feed.userId)
) {
return;
}
if (!feedSearch(feed)) {
return;
}
state.feedTable.data.push(feed);
sweepFeed();
UiStore.notifyMenu('feed');
}
function sweepFeed() {
let limit;
const { data } = state.feedTable;
const j = data.length;
if (j > vrcxStore.maxTableSize) {
data.splice(0, j - vrcxStore.maxTableSize);
}
const date = new Date();
date.setDate(date.getDate() - 1); // 24 hour limit
limit = date.toJSON();
let i = 0;
const k = state.feedSessionTable.length;
while (i < k && state.feedSessionTable[i].created_at < limit) {
++i;
}
if (i === k) {
state.feedSessionTable = [];
} else if (i) {
state.feedSessionTable.splice(0, i);
}
}
async function initFeedTable() {
state.feedTable.loading = true;
feedTableLookup();
state.feedSessionTable = await database.getFeedDatabase();
}
return {
state,
feedTable,
feedSessionTable,
initFeedTable,
feedTableLookup,
addFeed
};
});