@decky/ui 4.15.0 → 4.16.0

package/src/globals/stores/friendstore/friendgroupstore.ts

@@ -0,0 +1,187 @@
+import type { CPlayer } from './shared';
+import type { CFriendStore } from '.';
+
+export enum FriendGroupDisplayType {
+  eOnlineOnly,
+  eOnlineOnlyNotInGame,
+  eOfflineOnly,
+  eIncomingInvites,
+  eAll,
+}
+
+type FriendGroup_t = 'offline' | 'outgoing';
+
+interface CFriendGroupDisplayPrefs {
+  m_mapCollapsePrefs: Map<FriendGroup_t, boolean>;
+
+  /**
+   * @returns `true` if a provided group is collapsed.
+   */
+  GetUserGroupCollapsed(group: FriendGroup_t): boolean;
+
+  /**
+   * Sets a provided group's state to a provided value.
+   */
+  SetUserGroupCollapsed(group: FriendGroup_t, value: boolean): void;
+
+  /**
+   * Toggles a provided group's collapsed state.
+   */
+  ToggleUserGroupCollapsed(group: FriendGroup_t): void;
+
+  // maybe remove cuz this is done by the forementioned methods already
+  WritePrefs(): void;
+}
+
+// this extends CPlayerGroup but idc for now
+interface CFriendGroup {
+  // WHAT IS THIS
+  m_OnHeaderClick: any;
+  m_bAcceptsGroupRemovals: boolean;
+  m_bCollapsed: boolean;
+  m_bModifiable: boolean;
+  m_eDisplayType: FriendGroupDisplayType;
+  m_iGroupID: number;
+  m_rgAccountIDMembers: number[];
+  m_setMembers: Set<number>;
+  m_strName: string;
+
+  /**
+   * Adds a provided user to this group.
+   */
+  AddMember(steamid3: number): void;
+
+  /**
+   * Removes all users from this group.
+   */
+  Clear(): void;
+
+  /**
+   * @returns a set of this group's members' SteamID3s.
+   */
+  GetCurrentMemberSet(): Set<number>;
+
+  /**
+   * Filters users of this group by their nicknames from a provided string.
+   *
+   * @param s The string to filter by.
+   */
+  GetMembersMatchingSearch(s: string): CPlayer[];
+
+  /**
+   * @returns `true` if a provided user is in this group.
+   */
+  HasMember(steamid3: number): boolean;
+
+  /**
+   * Removes a provided user from this group.
+   */
+  RemoveMember(steamid3: number): void;
+
+  get GetRawMemberList(): CPlayer[];
+  get accepts_group_removals(): boolean;
+  get collapsed(): boolean;
+  get display_type(): FriendGroupDisplayType;
+  get icon_url(): string;
+  get id(): number;
+  get member_accountid_list(): number[];
+  get member_count(): number;
+  get member_counts(): { ingame: number; online: number };
+  get member_list(): CPlayer[];
+  get member_list_unsorted(): CPlayer[];
+  get modifiable(): boolean;
+  get name(): string;
+  get onheaderclick(): any;
+  get should_filter_categorized_friends(): boolean;
+  get unfiltered_count(): number;
+  get unique_id(): string;
+}
+
+interface CAllIncomingInvitesFriendsGroup extends CFriendGroup {
+  m_mapSteamIDToMutualFriends: Map<any, any>;
+  m_unMutualFriendsCacheHash: number;
+
+  GetMutualFriendsCacheHash(): number;
+  SetMutualFriends(e: Map<any, any>): void;
+  SetMutualFriendsCacheHash(e: number): void;
+}
+
+interface CFriendGameGroup extends CFriendGroup {
+  PlayerGroupSortComparator(e: CPlayer, t: CPlayer, r: Map<string, number>, n: any): any;
+}
+
+/**
+ * Represents functionality related to friend groups (not group chats).
+ */
+export declare class CFriendGroupStore {
+  m_FriendGroupDisplayPrefs: CFriendGroupDisplayPrefs;
+  m_FriendStore: CFriendStore;
+  m_groupAllFriends: CFriendGroup;
+  m_groupIncomingInvites: CAllIncomingInvitesFriendsGroup;
+  m_groupIngameFriends: CFriendGroup;
+  m_groupOfflineFriends: CFriendGroup;
+  m_groupOutgoingInvites: CFriendGroup;
+  m_mapGameGroups: Map<number, CFriendGameGroup>;
+  m_mapGroups: Map<number, CFriendGroup>;
+  m_nonSteamGameGroup: CFriendGameGroup;
+  m_singletonGameGroup: CFriendGameGroup;
+
+  /**
+   * Creates a friend group.
+   *
+   * @param name Name of the group to create.
+   * @param friends Array of SteamID64s to put into the group.
+   * @returns `true` on success.
+   */
+  CreateGroup(name: string, friends: string[]): Promise<boolean>;
+
+  EnsureMutualFriendsForIncomingInvites(): void;
+
+  /**
+   * @returns a number of friends currently playing the provided game.
+   */
+  GetCountFriendsInGame(appid: number): number;
+
+  /**
+   * @returns the friends group responsible for the provided app.
+   */
+  GetGameGroup(appid: number): CFriendGameGroup;
+
+  GetMaxCountFriendsInGame(): number;
+
+  /**
+   * Edits a group.
+   *
+   * @param group The group to edit.
+   * @param name The name to change the group to.
+   * @param addedFriends
+   * @param removedFriends
+   * @returns `true` on success.
+   *
+   * @todo no idea if this actually works, always fails for me :((( fuck you )))
+   */
+  ManageGroup(group: CFriendGroup, name: string, addedFriends?: string[], removedFriends?: string[]): Promise<boolean>;
+
+  /**
+   * Removes a group.
+   *
+   * @param group The group to delete.
+   */
+  RemoveGroup(group: CFriendGroup): void;
+
+  // TODO: this also fails but its name is self-explanatory
+  TransferFriendFromToGroup(player: CPlayer, groupA: CFriendGroup, groupB: CFriendGroup): Promise<boolean[]>;
+
+  get all_friends(): CFriendGroup;
+  get ingame_group(): CFriendGroup;
+  get incoming_invites_group(): CAllIncomingInvitesFriendsGroup;
+  get outgoing_invites_group(): CFriendGroup;
+  get friend_groups(): [...this['game_groups'], ...this['user_groups'], ...this['default_groups']];
+  get groupDisplayPrefs(): CFriendGroupDisplayPrefs;
+  get user_groups(): CFriendGroup[];
+  get game_groups(): CFriendGameGroup[];
+  get singleton_game_group(): this['m_singletonGameGroup'];
+  get categorized_friend_set(): Set<number>;
+  get default_groups(): CFriendGroup[];
+  get games_with_friends_playing(): number[];
+}

package/src/globals/stores/friendstore/friendingamenotificationstore.ts

@@ -0,0 +1 @@
+export declare class CFriendInGameNotificationStore {}

package/src/globals/stores/friendstore/friendslistfavoritesstore.ts

@@ -0,0 +1,37 @@
+import type { CClan, CClanStore } from './clanstore';
+import type { CChat } from './friendchat';
+import type { CPlayer } from './shared';
+import type { CFriendStore } from '.';
+
+type FavoriteEntry_t = { friend: CPlayer } | { chat: CChat } | { clan: CClan };
+
+export declare class CFriendsListFavoritesStore {
+  m_ChatStore: any;
+  m_ClanStore: CClanStore;
+  m_FriendStore: CFriendStore;
+  m_rgFavorites: FavoriteEntry_t[];
+
+  /**
+   * Adds a provided entry to the favorites list.
+   *
+   * @param entry The entry to add.
+   * @param index Array index to use, e.g. `1` will be second in the list.
+   * @returns `true` on success.
+   */
+  AddToFavorites(entry: FavoriteEntry_t, index?: number): Promise<boolean>;
+
+  /**
+   * @returns `true` if the provided entry is favorited.
+   */
+  BIsFavorited(entry: FavoriteEntry_t): boolean;
+
+  /**
+   * Removes the provided entry from favorites.
+   *
+   * @returns `true` on success.
+   */
+  RemoveFromFavorites(entry: FavoriteEntry_t): Promise<boolean>;
+
+  // maybe remove cuz done by the aforementioned methods already
+  SaveFavorites(): Promise<boolean>;
+}

package/src/globals/stores/friendstore/friendsuifriendstore.ts

@@ -0,0 +1,274 @@
+import type { CCallbackList, CSteamID, Unsubscribable } from '../../shared';
+import type { EResult } from '../../steam-client/shared';
+import type { CClanStore } from './clanstore';
+import type { CFriendGroupStore } from './friendgroupstore';
+import type { CFriendInGameNotificationStore } from './friendingamenotificationstore';
+import type { CFriendsListFavoritesStore } from './friendslistfavoritesstore';
+import type { CPlayer, EFriendRelationship, EPersonaState, PerFriendNotificationSettings } from './shared';
+
+interface FriendStorePrefs {
+  ePersonaState: EPersonaState;
+  strNonFriendsAllowedToMsg: string;
+}
+
+interface SendFriendInviteResult {
+  eResult: EResult;
+  eFriendRelationship: EFriendRelationship;
+}
+
+interface TokenBucketChangeStatus {
+  m_numStartingTokens: number;
+  m_numTokensPerMillisecond: number;
+  m_numIntervalsPerMillisecond: number;
+  m_TimeLastChecked: number;
+  m_flTokens: number;
+  AddTokens(): void;
+  BRemoveToken(): void;
+  Reset(): void;
+}
+
+// TODO(protobufs): generate
+declare class CMsgClientFriendsList {}
+
+// TODO(protobufs): generate
+declare class PerFriendPreferences {}
+
+export interface CFriendsUIFriendStore {
+  m_ClanStore: CClanStore;
+  m_FavoritesStore: CFriendsListFavoritesStore;
+  m_FriendGroupStore: CFriendGroupStore;
+  m_FriendInGameNotificationStore: CFriendInGameNotificationStore;
+  m_FriendStorePrefs: FriendStorePrefs;
+  m_InitialAppInfoPromises: Promise<void>[];
+  m_TokenBucketChangeStatus: TokenBucketChangeStatus;
+  m_TokenFailureAssertCount: number;
+  m_bAwayCallbackFired: boolean;
+  m_bInitialAppInfoLoaded: boolean;
+  m_bInitialPersonaStatesLoaded: boolean;
+  m_bIsClientIdle: boolean;
+  m_bMadeGetFriendsListRequest: boolean;
+  m_bNextActivityCallbackRegistered: boolean;
+  m_bParentalLocked: boolean;
+  m_bPerFriendPreferencesLoaded: boolean;
+  m_bReadyToRender: boolean;
+  m_bReceivedFriendsList: boolean;
+  m_bReconnectedSinceLastIdleUpdate: boolean;
+  m_bSnoozeCallbackFired: boolean;
+  m_bUserSetPersonaState: boolean;
+  m_cFriendPersonaStatesInitialized: number;
+  m_cLastUnreadPriorityMessageCountPosted: number;
+  m_eUserPersonaState: EPersonaState;
+  m_eUserPersonaStateParental: EPersonaState;
+  m_iIntervalDelayLoadFriendsList: number;
+  m_iIntervalSubscribeToPersonaStateUpdates: number;
+  m_mapApprovedNonFriendMessages: Map<number, number>;
+  m_mapPlayerCache: Map<number, CPlayer>;
+  m_nMissingPersonaStateMaxRetries: number;
+  m_nMissingPersonaStateRetryCount: number;
+  m_rgPersonaStateChangeCallbacks: CCallbackList<[CPlayer]>;
+  m_rgPlayerGameChangedCallbacks: CCallbackList<[number, number, number]>;
+  m_self: CPlayer;
+  m_setFriendAccountIDs: Set<number>;
+  m_setFriendsNeedingPersonaStateLoad: Set<number>;
+  m_setIncomingInviteAccountIDs: Set<number>;
+  m_tsLastConnect: number;
+  m_vecLastTenChangeStatusReasons: string[];
+
+  // does not actually add a friend, im pretty sure
+  AddFriend(steamid64: string, relationship: EFriendRelationship, dontInitPlayer: boolean): void;
+
+  /**
+   * Adds a callback to dispatch on persona state change.
+   */
+  AddPersonaStateChangedCallback(callback: (player: CPlayer) => void): Unsubscribable;
+
+  /**
+   * Adds a callback to dispatch on player's game change.
+   */
+  AddPlayerGameChangedCallback(callback: (steamid3: number, param1: number, appid: number) => void): Unsubscribable;
+
+  /**
+   * Adds a provided player to cache.
+   *
+   * @param steamid3 The SteamID3 of the player to add to the cache.
+   * @returns the persona state of the player's SteamID3.
+   */
+  AddPlayerToCache(steamid3: number, unused0?: number, unused1?: boolean): CPlayer;
+
+  AdjustPersonaStateForIdleTime(state: EPersonaState): number;
+
+  BApprovedNonFriendMessages(steamid3: number): boolean;
+
+  /**
+   * @returns `true` if user is currently in invisible mode.
+   */
+  BIsInvisibleMode(): boolean;
+
+  /**
+   * @returns `true` if user is currently in offline mode (community, not
+   * client).
+   */
+  BIsOfflineMode(): boolean;
+
+  /**
+   * Blocks a provided user.
+   *
+   * @param player The user to (un)block.
+   * @param unblock `true` to unblock, `false` otherwise.
+   */
+  BlockPlayer(player: CPlayer, unblock?: boolean): Promise<EFriendRelationship>;
+
+  EnsureApprovedNonFriendMapReady(): void;
+
+  EnsureFriendsListLoaded(param0: boolean): void;
+
+  ForceReadyToRender(): void;
+
+  /**
+   * @returns the incoming group invite count.
+   */
+  GetClanInviteCount(): number;
+
+  /**
+   * @returns a cached player from a provided SteamID3, or `null` if not a
+   * friend.
+   */
+  GetFriend(steamid3: number): CPlayer | null;
+
+  /**
+   * Like {@link GetFriend}, but will return `undefined` if not cached yet.
+   */
+  GetFriendIfCached(steamid3: number): CPlayer | undefined;
+
+  /**
+   * @returns the incoming friend request count.
+   */
+  GetFriendInviteCount(): number;
+
+  GetFriendsList(): Promise<void>;
+
+  /**
+   * @returns the online friends count.
+   */
+  GetOnlineFriendCount(): number;
+
+  /**
+   * @returns the outgoing friend request count.
+   */
+  GetOutgoingFriendRequestCount(): number;
+
+  /**
+   * @returns the incoming friend request count + incoming group invite count.
+   */
+  GetPendingInviteCount(): number;
+
+  GetPersonaStatePreference(): EPersonaState;
+
+  /**
+   * Gets a player from a provided SteamID3 and caches it.
+   */
+  GetPlayer(steamid3: number): CPlayer;
+
+  /**
+   * Like {@link GetPlayer}, but returns `undefined` if not cached yet.
+   */
+  GetPlayerIfCached(steamid3: number): CPlayer | undefined;
+
+  /**
+   * @returns `true` if user has DND enabled.
+   */
+  GetUserDoNotDisturb(): boolean;
+
+  // TODO: later
+  InviteToGame(player: CPlayer, appid: number, connectString: string): void;
+
+  // TODO: steamIdLobby is steam_id_lobby from CMsgClientMMSInviteToLobby but no
+  // idea what that is yet
+  InviteToLobby(player: CPlayer, appid: number, steamIdLobby: string): void;
+
+  InviteToWatch(player: CPlayer): void;
+
+  PlayFriendOnlineSound(): void;
+
+  PlayJoinGameSound(): void;
+
+  /**
+   * Removes a provided user from friends.
+   */
+  RemoveFriend(player: CPlayer): Promise<EFriendRelationship>;
+
+  /**
+   * Like {@link RemoveFriend}, but using a SteamID.
+   *
+   * @param steamid Instance of CSteamID or a SteamID64.
+   */
+  RemoveFriendBySteamID(steamid: string | CSteamID): Promise<EFriendRelationship>;
+
+  /**
+   * Sends a friend invite to a provided user.
+   */
+  SendFriendInvite(player: CPlayer): Promise<SendFriendInviteResult>;
+
+  /**
+   * Like {@link SendFriendInvite}, but using a SteamID.
+   *
+   * @param steamid Instance of CSteamID or a SteamID64.
+   */
+  SendFriendInviteBySteamID(steamid: string | CSteamID): Promise<SendFriendInviteResult>;
+
+  SendPersonaStateToServer(needPersonaResponse: boolean, changeStatusReason: string): boolean;
+
+  SetApprovedNonFriendMessages(param0: number): void;
+
+  SetFriendsList(msg: CMsgClientFriendsList): Promise<void>;
+
+  // sets everyone to be offline lol why
+  SetPersonasOffline(value: boolean): void;
+
+  SetPlayerNickname(prefs: PerFriendPreferences, nicknane: string): Promise<EResult>;
+
+  SetPlayerNotificationSettings(
+    prefs: PerFriendPreferences,
+    notificationSettings: PerFriendNotificationSettings,
+  ): Promise<EResult>;
+
+  SetPlayerPerFriendPreferences(
+    prefs: PerFriendPreferences,
+    nickname: string,
+    notificationSettings: PerFriendNotificationSettings,
+  ): Promise<EResult>;
+
+  SetReconnectedSinceLastIdleUpdate(): void;
+
+  /**
+   * Sets the user's DND state.
+   */
+  SetUserDoNotDisturb(value: boolean): void;
+
+  /**
+   * Sets the user's status.
+   * @param state The state to set.
+   * @param isUserSet
+   */
+  SetUserPersonaState(state: EPersonaState, isUserSet: boolean): void;
+
+  UpdateUnreadMessagesGlobal(): void;
+
+  UpdateUserPersonaStateInternal(
+    state: EPersonaState,
+    isUserSet: boolean,
+    isClientIdle: boolean,
+    param3: boolean,
+    changeStatusReason: string,
+  ): void;
+
+  get all_friends(): CPlayer[];
+  get all_friends_accountids(): Set<number>;
+  get friends_list_ready(): boolean;
+  get not_ready_to_render_reason(): string;
+  get online_friends(): CPlayer[];
+  get self(): CPlayer;
+  get ClanStore(): CClanStore;
+  get FavoritesStore(): CFriendsListFavoritesStore;
+  get FriendGroupStore(): CFriendGroupStore;
+}

package/src/globals/stores/friendstore/index.ts

@@ -0,0 +1,58 @@
+import type { CSteamID } from '../../shared';
+import type { EResult } from '../../steam-client/shared';
+import type { CFriendsUIFriendStore } from './friendsuifriendstore';
+import type { CPlayer } from './shared';
+
+export declare class CFriendStore {
+  m_FriendsUIFriendStore: CFriendsUIFriendStore;
+  m_mapOwnedGamesCacheErrors: Map<number, EResult>;
+  m_mapPlayerCache: Map<number, CPlayer>;
+
+  BShouldCachePlayer(persona: CPlayer): boolean;
+
+  /**
+   * @returns a set of owned games' IDs.
+   */
+  FetchOwnedGames(steamid3: number): Promise<{ setApps: Set<number> }>;
+
+  /**
+   * @returns the number of friends currently playing the provided game.
+   */
+  GetCountFriendsInGame(appid: number): number;
+
+  /**
+   * @returns the number of currently playing friends.
+   */
+  GetCountFriendsPlayingGames(): number;
+
+  GetFriendState(friend: number | CSteamID): CPlayer;
+
+  /**
+   * @returns an array of friends currently playing the provided game.
+   */
+  GetFriendsInGame(appid: number): CPlayer[];
+
+  GetMaxCountFriendsInGame(): number;
+
+  /**
+   * @returns a set of owned games' IDs of a provided friend.
+   */
+  GetOwnedGames(steamid3: number): Set<number>;
+
+  IsLibraryAccessDenied(steamid3: number): boolean;
+
+  /**
+   * Loads the persona for a provided friend.
+   *
+   * @param friend SteamID3 or CSteamID instance of a friend to load the persona
+   * for.
+   * @returns the loaded persona.
+   */
+  LoadPersonaState(friend: number | CSteamID): Promise<CPlayer>;
+
+  RefreshOwnedGames(steamid3: number): void;
+
+  get allFriends(): CPlayer[];
+  get currentUserSteamID(): CSteamID;
+  get favoriteFriends(): CPlayer[];
+}