@decky/ui 4.15.0 → 4.16.0

package/dist/globals/stores/focusnavcontroller.d.ts

@@ -0,0 +1,383 @@
+import type ReactDOM from 'react-dom';
+import type { ActionDescriptionMap, EFocusSource, FooterLegendProps, GamepadButton, GamepadEvent, GamepadEventDetail } from '../../components/FooterLegend';
+import type { CCallbackList, CScheduledFunc, MappedSubscribableValue, SubscribableValue, Unsubscribable } from '../shared';
+import type { ENavigationSourceType, NavigationSource } from '../shared/navigation';
+import type { CGamepadBrowserView } from './steamuistore/gamepadbrowserview';
+export type FlowChildrenLayout_t = 'column' | 'column-reverse' | 'geometric' | 'grid' | 'row' | 'row-reverse';
+type FocusRing_t = any;
+declare enum EFlowChildrenLayout {
+    NONE = 0,
+    COLUMN = 1,
+    ROW = 2,
+    COLUMN_REVERSE = 3,
+    ROW_REVERSE = 4,
+    GRID = 5,
+    GEOMETRIC = 6
+}
+declare enum EFocusDirection {
+    INVALID = 0,
+    FORWARD = 1,
+    BACKWARD = 2
+}
+declare enum EGamepadInputRepeatOnAxis {
+    None = 0,
+    Horizontal = 1,
+    Vertical = 2
+}
+declare enum EScrollIntoViewType {
+    Standard = 0,
+    NoTransform = 1,
+    NoTransformSparseContent = 2
+}
+interface GamepadInputRepeatConfig_t {
+    inputsThatRepeat: Set<GamepadButton>;
+    firstRepeatInterval_ms: number;
+    repeatInterval_ms: number;
+}
+declare class CGamepadInputRepeatGenerator {
+    m_ActiveInputId: GamepadButton | undefined;
+    m_ActiveInputTimeout: number | undefined;
+    m_config: GamepadInputRepeatConfig_t;
+    Reset(): void;
+    HandleInputButtonDown(button: GamepadButton, param1: () => void): void;
+}
+declare class CGamepadInputRepeatHandler {
+    m_config: GamepadInputRepeatConfig_t;
+    m_fnRepeatAllowed: () => boolean;
+    m_inputRepeatGenerator: CGamepadInputRepeatGenerator;
+    m_repeatOnAxis: EGamepadInputRepeatOnAxis;
+    Reset(): void;
+    SetRepeatAllowed(value: boolean): void;
+    HandleInputButtonDown(button: GamepadButton, param1: () => void, param2: () => void): void;
+    HandleInputButtonUp(button: GamepadButton): void;
+}
+declare class CGamepadInputSource {
+    m_OnGamepadDetectedCallbacks: CCallbackList;
+    m_ButtonDownCallbacks: CCallbackList<[GamepadButton, ENavigationSourceType, number, boolean]>;
+    m_ButtonRepeatHandler: CGamepadInputRepeatHandler;
+    m_ButtonUpCallbacks: CCallbackList<[GamepadButton, ENavigationSourceType, number]>;
+    m_AnalogCallbacks: CCallbackList<[button: GamepadButton, param1: number, param2: number, index: number | undefined]>;
+    m_NavigationTypeChangeCallbacks: CCallbackList<[ENavigationSourceType]>;
+    m_eNavigationSourceType: ENavigationSourceType;
+    m_fLastActiveTime: number;
+    m_nLastActiveControllerIndex: number;
+    DispatchButtonDown(button: GamepadButton, param1: boolean): void;
+    GetActiveControllerIndex(): number;
+    GetActiveControllerTime(): number;
+    GetSourceType(): ENavigationSourceType;
+    OnAnalogPad(button: GamepadButton, param1: number, param2: number, index: number): void;
+    OnButtonDown(button: GamepadButton, param1: number | undefined): void;
+    OnButtonUp(button: GamepadButton, param1: number | undefined): void;
+    OnGamepadDetected(): void;
+    OnNavigationTypeChanged(navType: ENavigationSourceType): void;
+    RegisterForGamepadDetected(callback: () => void): void;
+    RegisterForGamepadButtonDown(callback: (button: GamepadButton, navType: ENavigationSourceType, param2: number, param3: boolean) => void): void;
+    RegisterForGamepadButtonUp(callback: (button: GamepadButton, navType: ENavigationSourceType, index: number) => void): void;
+    RegisterForAnalog(callback: (button: GamepadButton, param1: number, param2: number, index: number | undefined) => void): void;
+    RegisterForNavigationTypeChange(callback: (navType: ENavigationSourceType) => void): void;
+    SetControllerActive(nLastActiveControllerIndex: number): void;
+    SetRepeatAllowed(value: boolean): void;
+    SetSourceType(value: ENavigationSourceType): void;
+}
+interface DeferredFocusTarget {
+    bFocusDescendant: boolean;
+    node: CNavigationTreeNode;
+}
+declare class CNavigationTreeDeferredFocus {
+    m_bSuppressed: boolean;
+    m_interval: any | undefined;
+    m_schExecuteQueuedFocus: CScheduledFunc;
+    m_target: DeferredFocusTarget | undefined;
+    m_tree: CNavigationTree;
+    BHasQueuedFocusNode(): boolean;
+    BIsQueuedFocusNode(node: CNavigationTreeNode): boolean;
+    ClearInterval(): void;
+    ExecuteQueuedFocus(): void;
+    RequestFocus(node: CNavigationTreeNode, target: DeferredFocusTarget): void;
+    Reset(): void;
+    SuppressFocus(): void;
+}
+declare class CTreeNodeMovementRect {
+    m_element: Element | undefined;
+    m_rect: DOMRect | undefined;
+    GetRect(): DOMRect;
+    Reset(): void;
+    SetNode(value: Element | undefined): void;
+}
+interface TreeNodeNavigationProps extends FooterLegendProps {
+    autoFocus: boolean;
+    childFocusDisabled: boolean;
+    disableNavSounds: boolean;
+    fnCanTakeFocus(node: CNavigationTreeNode): boolean;
+    fnScrollIntoViewHandler: () => boolean;
+    focusable: boolean;
+    focusableIfEmpty: boolean;
+    layout: EFlowChildrenLayout;
+    navKey: string;
+    navRef: any;
+    noFocusRing: boolean;
+    onFocusWithin(param0: boolean): void;
+    onMoveDown(eventDetails: GamepadEventDetail, node: CNavigationTreeNode): boolean;
+    onMoveLeft(eventDetails: GamepadEventDetail, node: CNavigationTreeNode): boolean;
+    onMoveRight(eventDetails: GamepadEventDetail, node: CNavigationTreeNode): boolean;
+    onMoveUp(eventDetails: GamepadEventDetail, node: CNavigationTreeNode): boolean;
+    resetNavOnEntry: boolean;
+    scrollIntoViewType: EScrollIntoViewType;
+    scrollIntoViewWhenChildFocused: boolean;
+}
+declare class CNavigationTreeNode {
+    m_Tree: CNavigationTree;
+    m_Parent: CNavigationTreeNode;
+    m_ActiveChild: CNavigationTreeNode | undefined;
+    m_iLastActiveChildIndex: boolean;
+    m_Properties: Partial<TreeNodeNavigationProps>;
+    m_element: Element | undefined;
+    m_FocusRing: FocusRing_t;
+    m_bChildrenSorted: boolean;
+    m_bAutoFocusChild: boolean;
+    m_bMounted: boolean;
+    m_nDepth: number;
+    m_Focused: SubscribableValue<boolean>;
+    m_FocusWithin: SubscribableValue<boolean>;
+    m_ActionDescriptionsChangedCallbackList: CCallbackList;
+    m_FocusableIfEmptyAncestor: CNavigationTreeNode | null;
+    m_rgChildren: CNavigationTreeNode[];
+    m_rgNavigationHandlers: (() => void)[];
+    m_rgFocusHandlers: (() => void)[];
+    AdvanceIndex(idx: number, dir: EFocusDirection): number;
+    AddChild(node: CNavigationTreeNode): void;
+    AdjustRectForLastMovementOnTangentAxis(rect: DOMRect, axis: 'x' | 'y'): DOMRect;
+    BChildTakeFocus(focusSource: EFocusSource, button: GamepadButton): boolean;
+    BHasFocus(): boolean;
+    BFocusWithin(): boolean;
+    BFocusFirstChild(focusSource: EFocusSource): boolean;
+    BFocusLastChild(focusSource: EFocusSource): boolean;
+    BTakeFocus(focusSource: EFocusSource, button: GamepadButton): void;
+    BTryInternalNavigation(button: GamepadButton, t: boolean): boolean;
+    BuildConsolidatedActionDescriptionMap(value: ActionDescriptionMap): ActionDescriptionMap;
+    BVisibleChildTakeFocus(focusSource: EFocusSource): boolean;
+    BWantsAutoFocus(): boolean;
+    BWantsPreferredFocus(): boolean;
+    BWantsFocusRing(): boolean;
+    ComputeRelativeDirection(button: GamepadButton, layout: EFlowChildrenLayout): EFocusDirection;
+    CreateHandle(): FocusRing_t;
+    EnsureChildrenSorted(e?: boolean): void;
+    FindClosetChildInDirection(axis: 'x' | 'y', rect: DOMRect, dir: EFocusDirection, button: GamepadButton): CNavigationTreeNode | null;
+    FindClosestChildInNextAxiallyAlignedSet(axis: 'x' | 'y', dir: EFocusDirection, button: GamepadButton, rect: DOMRect, i?: number, rect2?: DOMRect): CNavigationTreeNode | null;
+    FindClosestFocusableNodeToRect(button: GamepadButton, rect: DOMRect): CNavigationTreeNode;
+    FindFocusableDescendant(button: GamepadButton, param1: boolean): CNavigationTreeNode | null;
+    FindFocusableNode(button: GamepadButton, rect?: DOMRect): CNavigationTreeNode | null;
+    FindNextFocusableChildGeometric(dir: EFocusDirection, button: GamepadButton): CNavigationTreeNode | null;
+    FindNextFocusableChildInDirection(idx: number, dir: EFocusDirection, button: GamepadButton): CNavigationTreeNode | null;
+    FindNextFocusableChildInGrid(idx: number, dir: EFocusDirection, button: GamepadButton): CNavigationTreeNode | null;
+    ForceMeasureFocusRing(): void;
+    GetActiveActionDescriptions(): ActionDescriptionMap;
+    GetActiveChild(): CNavigationTreeNode | null;
+    GetActiveChildIndex(): number;
+    GetActiveDescendant(): CNavigationTreeNode;
+    GetBoundingRect(): DOMRect | undefined;
+    GetChildren(): [CNavigationTreeNode[], number];
+    GetDepth(): number;
+    GetFocusable(): 'children' | 'none' | 'self';
+    GetLastFocusElement(): Element;
+    GetLayout(): EFlowChildrenLayout;
+    GetRelativeDirection(button: GamepadButton): EFocusDirection;
+    GetScrollIntoViewType(): EScrollIntoViewType;
+    InternalFocusDescendant(node: CNavigationTreeNode | null, focusSource: EFocusSource, button: GamepadButton): void;
+    IsValidChildIndex(idx: number): CNavigationTreeNode;
+    OnDOMBlur(e: any): void;
+    OnDOMFocus(e: any): void;
+    OnFocusedDecendantRemoved(e: any): void;
+    OnMount(el: Element): void;
+    OnNavigationEvent(ev: GamepadEvent): void;
+    OnUnmount(): void;
+    PropagateFocusableIfEmptyAncestorToDescendants(node: CNavigationTreeNode): void;
+    RegisterDOMEvents(): void;
+    RemoveChild(node: CNavigationTreeNode): void;
+    ScanChildren(e: number, dir: EFocusDirection, callback: (child: CNavigationTreeNode) => void): void;
+    SetActiveChild(nodeOrIndex: CNavigationTreeNode | number): void;
+    SetDOMFocusAndScroll(focusSource: EFocusSource, param1: any): void;
+    SetFocusableIfEmptyAncestor(node: CNavigationTreeNode): void;
+    SetFocusWithin(value: boolean): void;
+    SetHasFocus(value: boolean): void;
+    SetProperties(props: TreeNodeNavigationProps): void;
+    UnregisterDOMEvents(): void;
+    UpdateParentActiveChild(): void;
+    get ActionDescriptionChangedCallbackList(): CCallbackList;
+    get Tree(): CNavigationTree;
+    get NavKey(): string | undefined;
+    get Element(): Element | undefined;
+    get Parent(): CNavigationTreeNode;
+    get SubscribableFocusWithin(): SubscribableValue<boolean>;
+    get SubscribableHasFocus(): SubscribableValue<boolean>;
+}
+declare class CNavigationTree {
+    m_Controller: CFocusNavController;
+    m_DeferredFocus: CNavigationTreeDeferredFocus;
+    m_ID: string;
+    m_ParentNavTree: CNavigationTree | undefined;
+    m_Root: CNavigationTreeNode;
+    m_bIsEmbeddedInLegacyTree: boolean;
+    m_bIsEnabled: boolean;
+    m_bIsMounted: boolean;
+    m_bModal: boolean;
+    m_bVirtualFocus: boolean;
+    m_bWasActiveForLastFocusChange: boolean;
+    m_context: CFocusNavigationContext;
+    m_lastFocusNode: CNavigationTreeNode;
+    m_lastFocusNodeXMovement: CTreeNodeMovementRect;
+    m_lastFocusNodeYMovement: CTreeNodeMovementRect;
+    m_onActivateCallbacks: CCallbackList<[CNavigationTree]>;
+    m_onActiveFocusStateChangedCallbacks: CCallbackList<[boolean, CNavigationTree]>;
+    m_onChildTreesChanged: CCallbackList<['add' | 'remove', CNavigationTree]>;
+    m_onDeactivateCallbacks: CCallbackList<[CNavigationTree, CNavigationTree]>;
+    m_onGlobalButtonDown: ((ev: GamepadEvent) => void) | undefined;
+    m_onUnhandledButton: ((ev: GamepadEvent) => void) | undefined;
+    m_rgChildNavTrees: CNavigationTree[];
+    m_tsLastActivated: number;
+    m_window: Window;
+    Activate(param0?: boolean): void;
+    AddChildNavTree(tree: CNavigationTree): () => void;
+    BIsActive(): boolean;
+    BIsActiveFocus(): boolean;
+    BIsActiveWithinContext(): boolean;
+    BIsContextActive(): boolean;
+    BIsEnabled(): boolean;
+    BIsModal(): boolean;
+    BUseVirtualFocus(): boolean;
+    CreateNode(parent: CNavigationTreeNode, focusRing: FocusRing_t): CNavigationTreeNode;
+    Deactivate(): void;
+    FindModalDescendant(): CNavigationTree;
+    GetParentEmbeddedNavTree(): CNavigationTree | undefined;
+    GetTimeLastActivated(): number;
+    GetLastFocusedNode(): CNavigationTreeNode;
+    GetLastFocusedMovementRect(e: string): DOMRect | undefined;
+    HandleButtonDownEventAsLogicalEvent(ev: Event): boolean;
+    IsActiveFocusNavTree(): boolean;
+    OnActivate(tree: CNavigationTree): void;
+    OnChildActivated(source: EFocusSource): void;
+    OnContextActiveStateChanged(e: boolean): void;
+    OnDeactivate(tree: CNavigationTree): void;
+    OnRootButtonDown(ev: Event): boolean;
+    MountNavTree(wnd: Window): () => void;
+    RegisterNavigationItem(ctx: CFocusNavigationContext, wnd: Window): () => void;
+    SetIsEnabled(value: boolean): void;
+    SetIsEmbeddedInLegacyTree(value: boolean): void;
+    SetModal(value: boolean): void;
+    SetOnUnhandledButtonCallback(value: (ev: GamepadEvent) => void): void;
+    SetOnGlobalButtonDown(value: (ev: GamepadEvent) => void): void;
+    SetUseVirtualFocus(value: boolean): void;
+    TakeFocus(focusSource: EFocusSource, t?: boolean): void;
+    TransferFocus(focusSource: EFocusSource, focusedNode: CNavigationTreeNode | null, blurredNode: CNavigationTreeNode): void;
+    TransferFocusInternal(focusSource: EFocusSource, focusedNode: CNavigationTreeNode | null, blurredNode: CNavigationTreeNode): void;
+    get ChildTrees(): CNavigationTree[];
+    get Controller(): CFocusNavController;
+    get DeferredFocus(): CNavigationTreeDeferredFocus;
+    get OnActivateCallbacks(): CCallbackList;
+    get OnActiveStateChangedCallbacks(): CCallbackList;
+    get OnChildTreesChangedCallbacks(): CCallbackList;
+    get OnDeactivateCallbacks(): CCallbackList;
+    get Parent(): CNavigationTree | undefined;
+    get Root(): CNavigationTreeNode;
+    get Window(): Window;
+    get WindowContext(): CFocusNavigationContext;
+    get id(): string;
+}
+interface ActiveFocusChange {
+    source: EFocusSource;
+    from: CNavigationTreeNode | undefined;
+    to: CNavigationTree;
+}
+export declare class CFocusNavigationContext {
+    m_ActiveFocusChange: ActiveFocusChange | undefined;
+    m_FocusChangedCallbacks: CCallbackList<[EFocusSource, CNavigationTreeNode | undefined, CNavigationTree]>;
+    m_LastActiveFocusNavTree: CNavigationTree | undefined;
+    m_LastActiveNavTree: CNavigationTree | undefined;
+    m_activeBrowserView: CGamepadBrowserView | undefined;
+    m_activeWindow: Window;
+    m_bIsGamepadInputSuppressed: false;
+    m_bMounted: boolean;
+    m_controller: CFocusNavController;
+    m_iFocusChangeStack: number;
+    m_rgGamepadNavigationTrees: CNavigationTree[];
+    m_rootWindow: Window;
+    m_schDeferredActivate: CScheduledFunc;
+    m_valueIsActive: SubscribableValue<boolean>;
+    AddNavTree(tree: CNavigationTree): void;
+    BIsActive(): boolean;
+    BIsGamepadInputSuppressed(): boolean;
+    BlurNavTree(tree: CNavigationTree): void;
+    Destroy(wnd: Window): void;
+    FindNavTreeInFocusedWindow(): CNavigationTree | undefined;
+    FindNavTreeToActivate(): CNavigationTree | undefined;
+    LogName(info?: {
+        name: string;
+    }): string;
+    OnActivate(activeWindow: Window): void;
+    OnActivateBrowserView(activeWindow: Window, activeBrowserView?: CGamepadBrowserView): void;
+    OnDeactivate(activeWindow: Window): void;
+    OnDeactivateBrowserView(activeWindow: Window, activeBrowserView?: CGamepadBrowserView): void;
+    OnFocusChangeComplete(e: number): void;
+    OnFocusChangeStart(source: EFocusSource, tree: CNavigationTree, from: CNavigationTreeNode | undefined, to: CNavigationTree): void;
+    OnMount(wnd: Window): void;
+    SetActive(isActive: boolean, activeWindow: Window, activeBrowserView?: CGamepadBrowserView): void;
+    SetActiveNavTree(tree: CNavigationTree | undefined, t: boolean): void;
+    UnregisterGamepadNavigationTree(tree: CNavigationTree): void;
+    get ActiveWindow(): Window;
+    get FocusChangedCallbacks(): CCallbackList<[EFocusSource, CNavigationTreeNode | undefined, CNavigationTree]>;
+    get IsActive(): SubscribableValue<boolean>;
+    get RootWindow(): Window;
+}
+export declare class CFocusNavController {
+    m_ActiveContext: CFocusNavigationContext | undefined;
+    m_DefaultContext: CFocusNavigationContext | undefined;
+    m_LastActiveContext: CFocusNavigationContext;
+    m_UnhandledButtonEventsCallbacks: CCallbackList<[GamepadButton]>;
+    m_bRestoringHistory: boolean;
+    m_bShowDebugFocusRing: SubscribableValue<boolean>;
+    m_fnCatchAllGamepadInput: ((button?: GamepadButton) => boolean) | null;
+    m_fnGamepadEventUpdateBatcher: typeof ReactDOM.unstable_batchedUpdates;
+    m_navigationSource: SubscribableValue<NavigationSource>;
+    m_navigationSourceSupportsFocus: MappedSubscribableValue<boolean>;
+    m_rgAllContexts: CFocusNavigationContext[];
+    m_rgGamepadInputSources: CGamepadInputSource[];
+    BGlobalGamepadButton(button: GamepadButton): boolean;
+    BIsInActiveContext(context: CFocusNavigationContext | undefined): boolean;
+    BIsRestoringHistory(): boolean;
+    BatchedUpdate(callback: typeof ReactDOM.unstable_batchedUpdates): void;
+    BlurNavTree(tree: CNavigationTree): void;
+    ChangeNavigationSource(eActivationSourceType: ENavigationSourceType, nActiveGamepadIndex: number): boolean;
+    CreateContext(wnd: Window, bIsGamepadInputSuppressed: boolean): CFocusNavigationContext;
+    DestroyContext(ctx: CFocusNavigationContext): void;
+    DispatchVirtualButtonClick(focusSource: EFocusSource, element: Element | null): void;
+    DispatchVirtualGamepad(param0: 'vgp_onbuttondown' | 'vgp_onbuttonup', param1: boolean): void;
+    FindAnActiveContext(): CFocusNavigationContext;
+    FireUnhandledGamepadEventCallbacks(ev: GamepadEvent): boolean;
+    GetActiveContext(): CFocusNavigationContext | undefined;
+    GetDefaultContext(): CFocusNavigationContext;
+    GetEventTarget(focusSource: EFocusSource, sourceType: ENavigationSourceType, takeFocus?: boolean): [Element | null, CFocusNavigationContext];
+    GetShowDebugFocusRing(): SubscribableValue<boolean>;
+    IsActiveFocusNavTree(tree: CNavigationTree | undefined): boolean;
+    IsActiveNavTree(tree: CNavigationTree | undefined): boolean;
+    NewGamepadNavigationTree(controller: CFocusNavController, context: CFocusNavigationContext, id: string): CNavigationTree;
+    OnButtonActionInternal(bTakeFocus: boolean, eButton: GamepadButton, eFocusSource: EFocusSource, nActiveGamepadIndex: number, bIsRepeat: boolean, element: Element | null, ctx: CFocusNavigationContext | null, bSuppressGamepadInput: boolean): void;
+    OnButtonDown(eButton: GamepadButton, eFocusSource: EFocusSource, nActiveGamepadIndex: number, bIsRepeat: boolean, element: Element | null, ctx: CFocusNavigationContext | null, bSuppressGamepadInput: boolean): void;
+    OnButtonUp(eButton: GamepadButton, eFocusSource: EFocusSource, nActiveGamepadIndex: number, bIsRepeat: boolean, element: Element | null, ctx: CFocusNavigationContext | null, bSuppressGamepadInput: boolean): void;
+    OnContextActivated(ctx: CFocusNavigationContext): void;
+    OnContextDeactivated(ctx: CFocusNavigationContext, param1: boolean): void;
+    OnGamepadNavigationTreeActivated(tree: CNavigationTree, param1: boolean): void;
+    OnGamepadNavigationTreeFocused(tree: CNavigationTree, focusSource: EFocusSource, param2?: boolean): void;
+    RegisterForUnhandledButtonDownEvents(callback: (ev: GamepadEvent) => void): Unsubscribable;
+    RegisterGamepadNavigationTree(tree: CNavigationTree, wnd: Window): () => void;
+    RegisterInputSource(value: CGamepadInputSource): () => void;
+    RestoreHistoryTransaction(callback: () => Promise<void>): Promise<void>;
+    SetCatchAllGamepadInput(callback: (button?: GamepadButton) => boolean): void;
+    SetGamepadEventUpdateBatcher(value: typeof ReactDOM.unstable_batchedUpdates): void;
+    SetShowDebugFocusRing(value: boolean): void;
+    SetSuppressGamepadInput(value: boolean): void;
+    TakeFocusChangingIFrame(): void;
+    UpdateSourceToGamepad(param0?: boolean): void;
+    get NavigationSource(): SubscribableValue<NavigationSource>;
+    get NavigationSourceSupportsFocus(): MappedSubscribableValue<boolean>;
+}
+export {};

package/dist/globals/stores/focusnavcontroller.js

@@ -0,0 +1,29 @@
+var EFlowChildrenLayout;
+(function (EFlowChildrenLayout) {
+    EFlowChildrenLayout[EFlowChildrenLayout["NONE"] = 0] = "NONE";
+    EFlowChildrenLayout[EFlowChildrenLayout["COLUMN"] = 1] = "COLUMN";
+    EFlowChildrenLayout[EFlowChildrenLayout["ROW"] = 2] = "ROW";
+    EFlowChildrenLayout[EFlowChildrenLayout["COLUMN_REVERSE"] = 3] = "COLUMN_REVERSE";
+    EFlowChildrenLayout[EFlowChildrenLayout["ROW_REVERSE"] = 4] = "ROW_REVERSE";
+    EFlowChildrenLayout[EFlowChildrenLayout["GRID"] = 5] = "GRID";
+    EFlowChildrenLayout[EFlowChildrenLayout["GEOMETRIC"] = 6] = "GEOMETRIC";
+})(EFlowChildrenLayout || (EFlowChildrenLayout = {}));
+var EFocusDirection;
+(function (EFocusDirection) {
+    EFocusDirection[EFocusDirection["INVALID"] = 0] = "INVALID";
+    EFocusDirection[EFocusDirection["FORWARD"] = 1] = "FORWARD";
+    EFocusDirection[EFocusDirection["BACKWARD"] = 2] = "BACKWARD";
+})(EFocusDirection || (EFocusDirection = {}));
+var EGamepadInputRepeatOnAxis;
+(function (EGamepadInputRepeatOnAxis) {
+    EGamepadInputRepeatOnAxis[EGamepadInputRepeatOnAxis["None"] = 0] = "None";
+    EGamepadInputRepeatOnAxis[EGamepadInputRepeatOnAxis["Horizontal"] = 1] = "Horizontal";
+    EGamepadInputRepeatOnAxis[EGamepadInputRepeatOnAxis["Vertical"] = 2] = "Vertical";
+})(EGamepadInputRepeatOnAxis || (EGamepadInputRepeatOnAxis = {}));
+var EScrollIntoViewType;
+(function (EScrollIntoViewType) {
+    EScrollIntoViewType[EScrollIntoViewType["Standard"] = 0] = "Standard";
+    EScrollIntoViewType[EScrollIntoViewType["NoTransform"] = 1] = "NoTransform";
+    EScrollIntoViewType[EScrollIntoViewType["NoTransformSparseContent"] = 2] = "NoTransformSparseContent";
+})(EScrollIntoViewType || (EScrollIntoViewType = {}));
+export {};

package/dist/globals/stores/friendstore/clanstore.d.ts

@@ -0,0 +1,75 @@
+import type { BrowserContext, CSteamID } from '../../shared';
+import type { CFriendStore } from '.';
+export declare enum EClanAccountFlags {
+    None = 0,
+    TrustedPress = 1,
+    AllowClanImages = 2,
+    AllowRSSFeed = 4,
+    AllowPartnerEventEditor = 8
+}
+export declare enum EClanRelationship {
+    None = 0,
+    Blocked = 1,
+    Invited = 2,
+    Member = 3,
+    Kicked = 4,
+    KickAcknowledged = 5,
+    PendingApproval = 6,
+    RequestDenied = 7
+}
+export interface CClan {
+    m_bChatRoomPrivate: boolean | undefined;
+    m_bGotInitialState: boolean;
+    m_bInitialized: boolean;
+    m_bPersonaStateDesired: boolean;
+    m_bPersonaStateLoadRequested: boolean;
+    m_cChatRoomMembers: number;
+    m_cMemberCount: number;
+    m_cUsersInGame: number;
+    m_cUsersOnline: number;
+    m_eClanAccountFlags: number;
+    m_eClanRelationship: EClanRelationship;
+    m_steamid: CSteamID;
+    m_strAvatarHash: string;
+    m_strClanName: string;
+    m_strClanTag: string;
+    m_ulChatRoomGroupID: string | undefined;
+    m_unOGGAppID: number | undefined;
+    BIsInvite(): boolean;
+    BIsMember(): boolean;
+    BIsOGG(): boolean;
+    BMatchesSearchString(s: string): boolean;
+    BNeedsToLoadPersonaStateData(): boolean;
+    BPersonaStateDesired(): boolean;
+    GetChatGroupIDIfLoaded(): CClan['m_ulChatRoomGroupID'];
+    GetChatRoomGroupID(): Promise<CClan['m_ulChatRoomGroupID'] | null>;
+    GetOGGAppID(): CClan['m_unOGGAppID'];
+    OpenChatDialog(browser?: BrowserContext, param1?: boolean): Promise<string | null>;
+    get avatar_url(): string;
+    get avatar_url_medium(): string;
+    get avatar_url_full(): string;
+    get chat_room_private(): boolean;
+    get clanid(): number;
+    get count_chat_room_members(): number;
+    get member_count(): number;
+    get name(): string;
+    get steamid(): CSteamID;
+    get users_ingame(): number;
+    get users_online(): number;
+}
+export declare class CClanStore {
+    m_FriendStore: CFriendStore;
+    m_iIntervalLoadClanData: number | undefined;
+    m_mapClans: Map<number, CClan>;
+    EnsureInitialStateForClanInvites(): void;
+    GetClan(id: number): CClan;
+    GetOrCreateClan(steamid: number | CSteamID, eClanRelationship: EClanRelationship): CClan;
+    JoinClanChatRoom(browser: BrowserContext, relationship: EClanRelationship): Promise<void>;
+    LoadClanPersonaIfNeeded(persona: CClan): void;
+    LoadMissingClanPersonas(): void;
+    RespondToClanInvite(steamid: CSteamID, accept: boolean): Promise<boolean>;
+    ScheduleLoadMissingClanPersonas(): void;
+    SetClanChatGroupID(clanID: number, groupID: string): string;
+    get clan_invite_count(): number;
+    get clan_invites(): CClan[];
+}

package/dist/globals/stores/friendstore/clanstore.js

@@ -0,0 +1,19 @@
+export var EClanAccountFlags;
+(function (EClanAccountFlags) {
+    EClanAccountFlags[EClanAccountFlags["None"] = 0] = "None";
+    EClanAccountFlags[EClanAccountFlags["TrustedPress"] = 1] = "TrustedPress";
+    EClanAccountFlags[EClanAccountFlags["AllowClanImages"] = 2] = "AllowClanImages";
+    EClanAccountFlags[EClanAccountFlags["AllowRSSFeed"] = 4] = "AllowRSSFeed";
+    EClanAccountFlags[EClanAccountFlags["AllowPartnerEventEditor"] = 8] = "AllowPartnerEventEditor";
+})(EClanAccountFlags || (EClanAccountFlags = {}));
+export var EClanRelationship;
+(function (EClanRelationship) {
+    EClanRelationship[EClanRelationship["None"] = 0] = "None";
+    EClanRelationship[EClanRelationship["Blocked"] = 1] = "Blocked";
+    EClanRelationship[EClanRelationship["Invited"] = 2] = "Invited";
+    EClanRelationship[EClanRelationship["Member"] = 3] = "Member";
+    EClanRelationship[EClanRelationship["Kicked"] = 4] = "Kicked";
+    EClanRelationship[EClanRelationship["KickAcknowledged"] = 5] = "KickAcknowledged";
+    EClanRelationship[EClanRelationship["PendingApproval"] = 6] = "PendingApproval";
+    EClanRelationship[EClanRelationship["RequestDenied"] = 7] = "RequestDenied";
+})(EClanRelationship || (EClanRelationship = {}));