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
+265
View File
@@ -0,0 +1,265 @@
import { defineStore } from 'pinia';
import Vue, { computed, reactive, watch } from 'vue';
import { avatarModerationRequest, playerModerationRequest } from '../api';
import { $app } from '../app';
import { watchState } from '../service/watchState';
import { useAvatarStore } from './avatar';
import { useUserStore } from './user';
import { useI18n } from 'vue-i18n-bridge';
export const useModerationStore = defineStore('Moderation', () => {
const avatarStore = useAvatarStore();
const userStore = useUserStore();
const { t } = useI18n();
const state = reactive({
cachedPlayerModerations: new Map(),
cachedPlayerModerationsUserIds: new Set(),
isPlayerModerationsLoading: false,
playerModerationTable: {
data: [],
pageSize: 15
}
});
const cachedPlayerModerations = computed({
get: () => state.cachedPlayerModerations,
set: (value) => {
state.cachedPlayerModerations = value;
}
});
const cachedPlayerModerationsUserIds = computed({
get: () => state.cachedPlayerModerationsUserIds,
set: (value) => {
state.cachedPlayerModerationsUserIds = value;
}
});
const isPlayerModerationsLoading = computed({
get: () => state.isPlayerModerationsLoading,
set: (value) => {
state.isPlayerModerationsLoading = value;
}
});
const playerModerationTable = computed({
get: () => state.playerModerationTable,
set: (value) => {
state.playerModerationTable = value;
}
});
watch(
() => watchState.isLoggedIn,
(isLoggedIn) => {
state.cachedPlayerModerations.clear();
state.cachedPlayerModerationsUserIds.clear();
state.isPlayerModerationsLoading = false;
state.playerModerationTable.data = [];
if (isLoggedIn) {
refreshPlayerModerations();
}
},
{ flush: 'sync' }
);
function handlePlayerModeration(args) {
args.ref = applyPlayerModeration(args.json);
const { ref } = args;
const array = state.playerModerationTable.data;
const { length } = array;
for (let i = 0; i < length; ++i) {
if (array[i].id === ref.id) {
Vue.set(array, i, ref);
return;
}
}
state.playerModerationTable.data.push(ref);
}
/**
*
* @param args
*/
function handlePlayerModerationAtSend(args) {
const { ref } = args;
const D = userStore.userDialog;
if (
D.visible === false ||
(ref.targetUserId !== D.id &&
ref.sourceUserId !== userStore.currentUser.id)
) {
return;
}
if (ref.type === 'block') {
D.isBlock = true;
} else if (ref.type === 'mute') {
D.isMute = true;
} else if (ref.type === 'hideAvatar') {
D.isHideAvatar = true;
} else if (ref.type === 'interactOff') {
D.isInteractOff = true;
} else if (ref.type === 'muteChat') {
D.isMuteChat = true;
}
$app.$message({
message: t('message.user.moderated'),
type: 'success'
});
}
function handlePlayerModerationAtDelete(args) {
const { ref } = args;
const D = userStore.userDialog;
if (
D.visible === false ||
ref.targetUserId !== D.id ||
ref.sourceUserId !== userStore.currentUser.id
) {
return;
}
if (ref.type === 'block') {
D.isBlock = false;
} else if (ref.type === 'mute') {
D.isMute = false;
} else if (ref.type === 'hideAvatar') {
D.isHideAvatar = false;
} else if (ref.type === 'interactOff') {
D.isInteractOff = false;
} else if (ref.type === 'muteChat') {
D.isMuteChat = false;
}
const array = state.playerModerationTable.data;
const { length } = array;
for (let i = 0; i < length; ++i) {
if (array[i].id === ref.id) {
array.splice(i, 1);
return;
}
}
}
function handlePlayerModerationDelete(args) {
let { type, moderated } = args.params;
const userId = userStore.currentUser.id;
for (let ref of state.cachedPlayerModerations.values()) {
if (
ref.type === type &&
ref.targetUserId === moderated &&
ref.sourceUserId === userId
) {
state.cachedPlayerModerations.delete(ref.id);
handlePlayerModerationAtDelete({
ref,
params: {
playerModerationId: ref.id
}
});
}
}
state.cachedPlayerModerationsUserIds.delete(moderated);
}
/**
*
* @param {object} json
* @returns {object}
*/
function applyPlayerModeration(json) {
let ref = state.cachedPlayerModerations.get(json.id);
if (typeof ref === 'undefined') {
ref = {
id: '',
type: '',
sourceUserId: '',
sourceDisplayName: '',
targetUserId: '',
targetDisplayName: '',
created: '',
// VRCX
$isExpired: false,
//
...json
};
state.cachedPlayerModerations.set(ref.id, ref);
} else {
Object.assign(ref, json);
ref.$isExpired = false;
}
if (json.targetUserId) {
state.cachedPlayerModerationsUserIds.add(json.targetUserId);
}
return ref;
}
function expirePlayerModerations() {
state.cachedPlayerModerationsUserIds.clear();
for (let ref of state.cachedPlayerModerations.values()) {
ref.$isExpired = true;
}
}
function deleteExpiredPlayerModerations() {
for (let ref of state.cachedPlayerModerations.values()) {
if (!ref.$isExpired) {
continue;
}
handlePlayerModerationAtDelete({
ref,
params: {
playerModerationId: ref.id
}
});
}
}
async function refreshPlayerModerations() {
if (state.isPlayerModerationsLoading) {
return;
}
state.isPlayerModerationsLoading = true;
expirePlayerModerations();
Promise.all([
playerModerationRequest.getPlayerModerations(),
avatarModerationRequest.getAvatarModerations()
])
.finally(() => {
state.isPlayerModerationsLoading = false;
})
.then((res) => {
// TODO: compare with cachedAvatarModerations
avatarStore.cachedAvatarModerations = new Map();
if (res[1]?.json) {
for (const json of res[1].json) {
avatarStore.applyAvatarModeration(json);
}
}
if (res[0]?.json) {
for (let json of res[0].json) {
handlePlayerModeration({
json,
params: {
playerModerationId: json.id
}
});
}
}
deleteExpiredPlayerModerations();
});
}
return {
state,
cachedPlayerModerations,
cachedPlayerModerationsUserIds,
isPlayerModerationsLoading,
playerModerationTable,
refreshPlayerModerations,
handlePlayerModerationAtSend,
handlePlayerModeration,
handlePlayerModerationDelete
};
});