@decky/ui 4.0.0

package/dist/components/Dialog.js

@@ -0,0 +1,19 @@
+import { CommonUIModule } from '../webpack';
+const CommonDialogDivs = Object.values(CommonUIModule).filter((m) => typeof m === 'object' && m?.render?.toString().includes('"div",Object.assign({},'));
+const MappedDialogDivs = new Map(Object.values(CommonDialogDivs).map((m) => {
+    const renderedDiv = m.render({});
+    return [renderedDiv.props.className.split(' ')[0], m];
+}));
+export const DialogHeader = MappedDialogDivs.get('DialogHeader');
+export const DialogSubHeader = MappedDialogDivs.get('DialogSubHeader');
+export const DialogFooter = MappedDialogDivs.get('DialogFooter');
+export const DialogLabel = MappedDialogDivs.get('DialogLabel');
+export const DialogBodyText = MappedDialogDivs.get('DialogBodyText');
+export const DialogBody = MappedDialogDivs.get('DialogBody');
+export const DialogControlsSection = MappedDialogDivs.get('DialogControlsSection');
+export const DialogControlsSectionHeader = MappedDialogDivs.get('DialogControlsSectionHeader');
+export const DialogButtonPrimary = Object.values(CommonUIModule).find((mod) => mod?.render?.toString()?.includes('DialogButton') && mod?.render?.toString()?.includes('Primary'));
+export const DialogButtonSecondary = Object.values(CommonUIModule).find((mod) => mod?.render?.toString()?.includes('Object.assign({type:"button"') &&
+    mod?.render?.toString()?.includes('DialogButton') &&
+    mod?.render?.toString()?.includes('Secondary'));
+export const DialogButton = DialogButtonSecondary;

package/dist/components/DialogCheckbox.d.ts

@@ -0,0 +1,17 @@
+import { FC, ReactNode } from 'react';
+import { DialogCommonProps } from './Dialog';
+import { FooterLegendProps } from './FooterLegend';
+export interface DialogCheckboxProps extends DialogCommonProps, FooterLegendProps {
+    onChange?(checked: boolean): void;
+    label?: ReactNode;
+    description?: ReactNode;
+    disabled?: boolean;
+    tooltip?: string;
+    color?: string;
+    highlightColor?: string;
+    bottomSeparator?: 'standard' | 'thick' | 'none';
+    controlled?: boolean;
+    checked?: boolean;
+    onClick?(evt: Event): void;
+}
+export declare const DialogCheckbox: FC<DialogCheckboxProps>;

package/dist/components/DialogCheckbox.js

@@ -0,0 +1,14 @@
+import { findModule } from '../webpack';
+export const DialogCheckbox = Object.values(findModule((m) => {
+    if (typeof m !== 'object')
+        return false;
+    for (const prop in m) {
+        if (m[prop]?.prototype?.GetPanelElementProps)
+            return true;
+    }
+    return false;
+})).find((m) => m.contextType &&
+    m.prototype?.render.toString().includes('fallback:') &&
+    m?.prototype?.SetChecked &&
+    m?.prototype?.Toggle &&
+    m?.prototype?.GetPanelElementProps);

package/dist/components/Dropdown.d.ts

@@ -0,0 +1,34 @@
+import { ReactNode, VFC } from 'react';
+import { ItemProps } from './Item';
+export interface SingleDropdownOption {
+    data: any;
+    label: ReactNode;
+    options?: never;
+}
+export interface MultiDropdownOption {
+    label: ReactNode;
+    options: DropdownOption[];
+    data?: never;
+}
+export type DropdownOption = SingleDropdownOption | MultiDropdownOption;
+export interface DropdownMenuPositionOptions {
+    [_: string]: unknown;
+    bMatchWidth?: boolean;
+}
+export interface DropdownProps {
+    rgOptions: DropdownOption[];
+    selectedOption: any;
+    disabled?: boolean;
+    onMenuWillOpen?(showMenu: () => void): void;
+    onMenuOpened?(): void;
+    onChange?(data: SingleDropdownOption): void;
+    contextMenuPositionOptions?: DropdownMenuPositionOptions;
+    menuLabel?: string;
+    strDefaultLabel?: string;
+    renderButtonValue?(element: ReactNode): ReactNode;
+    focusable?: boolean;
+}
+export declare const Dropdown: VFC<DropdownProps>;
+export interface DropdownItemProps extends DropdownProps, ItemProps {
+}
+export declare const DropdownItem: VFC<DropdownItemProps>;

package/dist/components/Dropdown.js

@@ -0,0 +1,3 @@
+import { CommonUIModule } from '../webpack';
+export const Dropdown = Object.values(CommonUIModule).find((mod) => mod?.prototype?.SetSelectedOption && mod?.prototype?.BuildMenu);
+export const DropdownItem = Object.values(CommonUIModule).find((mod) => mod?.toString()?.includes('"dropDownControlRef","description"'));

package/dist/components/Field.d.ts

@@ -0,0 +1,22 @@
+import { FC, ReactNode, RefAttributes } from 'react';
+import { FooterLegendProps } from './FooterLegend';
+export interface FieldProps extends FooterLegendProps {
+    label?: ReactNode;
+    bottomSeparator?: 'standard' | 'thick' | 'none';
+    description?: ReactNode;
+    disabled?: boolean;
+    icon?: ReactNode;
+    inlineWrap?: 'keep-inline' | 'shift-children-below';
+    childrenLayout?: 'below' | 'inline';
+    childrenContainerWidth?: 'min' | 'max' | 'fixed';
+    spacingBetweenLabelAndChild?: 'none';
+    padding?: 'none' | 'standard' | 'compact';
+    className?: string;
+    highlightOnFocus?: boolean;
+    indentLevel?: number;
+    verticalAlignment?: 'center' | 'none';
+    focusable?: boolean;
+    onActivate?: (e: CustomEvent | MouseEvent) => void;
+    onClick?: (e: CustomEvent | MouseEvent) => void;
+}
+export declare const Field: FC<FieldProps & RefAttributes<HTMLDivElement>>;

package/dist/components/Field.js

@@ -0,0 +1,2 @@
+import { findModuleExport } from '../webpack';
+export const Field = findModuleExport((e) => e?.render?.toString().includes('"shift-children-below"'));

package/dist/components/FocusRing.d.ts

@@ -0,0 +1,9 @@
+import { ElementType, FC, ReactNode } from 'react';
+export interface FocusRingProps {
+    className?: string;
+    rootClassName?: string;
+    render?: ElementType;
+    children?: ReactNode;
+    NavigationManager?: any;
+}
+export declare const FocusRing: FC<FocusRingProps>;

package/dist/components/FocusRing.js

@@ -0,0 +1,2 @@
+import { findModuleExport } from '../webpack';
+export const FocusRing = findModuleExport((e) => e?.toString()?.includes('.GetShowDebugFocusRing())'));

package/dist/components/Focusable.d.ts

@@ -0,0 +1,12 @@
+import { HTMLAttributes, ReactNode, RefAttributes, VFC } from 'react';
+import { FooterLegendProps } from './FooterLegend';
+export interface FocusableProps extends HTMLAttributes<HTMLDivElement>, FooterLegendProps {
+    children: ReactNode;
+    'flow-children'?: string;
+    focusClassName?: string;
+    focusWithinClassName?: string;
+    noFocusRing?: boolean;
+    onActivate?: (e: CustomEvent) => void;
+    onCancel?: (e: CustomEvent) => void;
+}
+export declare const Focusable: VFC<FocusableProps & RefAttributes<HTMLDivElement>>;

package/dist/components/Focusable.js

@@ -0,0 +1,2 @@
+import { findModuleExport } from '../webpack';
+export const Focusable = findModuleExport((e) => e?.render?.toString()?.includes('["flow-children","onActivate","onCancel","focusClassName",'));

package/dist/components/FooterLegend.d.ts

@@ -0,0 +1,66 @@
+import { ReactNode } from 'react';
+export declare enum GamepadButton {
+    INVALID = 0,
+    OK = 1,
+    CANCEL = 2,
+    SECONDARY = 3,
+    OPTIONS = 4,
+    BUMPER_LEFT = 5,
+    BUMPER_RIGHT = 6,
+    TRIGGER_LEFT = 7,
+    TRIGGER_RIGHT = 8,
+    DIR_UP = 9,
+    DIR_DOWN = 10,
+    DIR_LEFT = 11,
+    DIR_RIGHT = 12,
+    SELECT = 13,
+    START = 14,
+    LSTICK_CLICK = 15,
+    RSTICK_CLICK = 16,
+    LSTICK_TOUCH = 17,
+    RSTICK_TOUCH = 18,
+    LPAD_TOUCH = 19,
+    LPAD_CLICK = 20,
+    RPAD_TOUCH = 21,
+    RPAD_CLICK = 22,
+    REAR_LEFT_UPPER = 23,
+    REAR_LEFT_LOWER = 24,
+    REAR_RIGHT_UPPER = 25,
+    REAR_RIGHT_LOWER = 26,
+    STEAM_GUIDE = 27,
+    STEAM_QUICK_MENU = 28
+}
+export declare enum NavEntryPositionPreferences {
+    FIRST,
+    LAST,
+    MAINTAIN_X,
+    MAINTAIN_Y,
+    PREFERRED_CHILD
+}
+export interface GamepadEventDetail {
+    button: number;
+    is_repeat?: boolean;
+    source: number;
+}
+export declare type ActionDescriptionMap = {
+    [key in GamepadButton]?: ReactNode;
+};
+export declare type GamepadEvent = CustomEvent<GamepadEventDetail>;
+export interface FooterLegendProps {
+    actionDescriptionMap?: ActionDescriptionMap;
+    onOKActionDescription?: ReactNode;
+    onCancelActionDescription?: ReactNode;
+    onSecondaryActionDescription?: ReactNode;
+    onOptionsActionDescription?: ReactNode;
+    onMenuActionDescription?: ReactNode;
+    onButtonDown?: (evt: GamepadEvent) => void;
+    onButtonUp?: (evt: GamepadEvent) => void;
+    onOKButton?: (evt: GamepadEvent) => void;
+    onCancelButton?: (evt: GamepadEvent) => void;
+    onSecondaryButton?: (evt: GamepadEvent) => void;
+    onOptionsButton?: (evt: GamepadEvent) => void;
+    onGamepadDirection?: (evt: GamepadEvent) => void;
+    onGamepadFocus?: (evt: GamepadEvent) => void;
+    onGamepadBlur?: (evt: GamepadEvent) => void;
+    onMenuButton?: (evt: GamepadEvent) => void;
+}

package/dist/components/FooterLegend.js

@@ -0,0 +1,32 @@
+export var GamepadButton;
+(function (GamepadButton) {
+    GamepadButton[GamepadButton["INVALID"] = 0] = "INVALID";
+    GamepadButton[GamepadButton["OK"] = 1] = "OK";
+    GamepadButton[GamepadButton["CANCEL"] = 2] = "CANCEL";
+    GamepadButton[GamepadButton["SECONDARY"] = 3] = "SECONDARY";
+    GamepadButton[GamepadButton["OPTIONS"] = 4] = "OPTIONS";
+    GamepadButton[GamepadButton["BUMPER_LEFT"] = 5] = "BUMPER_LEFT";
+    GamepadButton[GamepadButton["BUMPER_RIGHT"] = 6] = "BUMPER_RIGHT";
+    GamepadButton[GamepadButton["TRIGGER_LEFT"] = 7] = "TRIGGER_LEFT";
+    GamepadButton[GamepadButton["TRIGGER_RIGHT"] = 8] = "TRIGGER_RIGHT";
+    GamepadButton[GamepadButton["DIR_UP"] = 9] = "DIR_UP";
+    GamepadButton[GamepadButton["DIR_DOWN"] = 10] = "DIR_DOWN";
+    GamepadButton[GamepadButton["DIR_LEFT"] = 11] = "DIR_LEFT";
+    GamepadButton[GamepadButton["DIR_RIGHT"] = 12] = "DIR_RIGHT";
+    GamepadButton[GamepadButton["SELECT"] = 13] = "SELECT";
+    GamepadButton[GamepadButton["START"] = 14] = "START";
+    GamepadButton[GamepadButton["LSTICK_CLICK"] = 15] = "LSTICK_CLICK";
+    GamepadButton[GamepadButton["RSTICK_CLICK"] = 16] = "RSTICK_CLICK";
+    GamepadButton[GamepadButton["LSTICK_TOUCH"] = 17] = "LSTICK_TOUCH";
+    GamepadButton[GamepadButton["RSTICK_TOUCH"] = 18] = "RSTICK_TOUCH";
+    GamepadButton[GamepadButton["LPAD_TOUCH"] = 19] = "LPAD_TOUCH";
+    GamepadButton[GamepadButton["LPAD_CLICK"] = 20] = "LPAD_CLICK";
+    GamepadButton[GamepadButton["RPAD_TOUCH"] = 21] = "RPAD_TOUCH";
+    GamepadButton[GamepadButton["RPAD_CLICK"] = 22] = "RPAD_CLICK";
+    GamepadButton[GamepadButton["REAR_LEFT_UPPER"] = 23] = "REAR_LEFT_UPPER";
+    GamepadButton[GamepadButton["REAR_LEFT_LOWER"] = 24] = "REAR_LEFT_LOWER";
+    GamepadButton[GamepadButton["REAR_RIGHT_UPPER"] = 25] = "REAR_RIGHT_UPPER";
+    GamepadButton[GamepadButton["REAR_RIGHT_LOWER"] = 26] = "REAR_RIGHT_LOWER";
+    GamepadButton[GamepadButton["STEAM_GUIDE"] = 27] = "STEAM_GUIDE";
+    GamepadButton[GamepadButton["STEAM_QUICK_MENU"] = 28] = "STEAM_QUICK_MENU";
+})(GamepadButton || (GamepadButton = {}));

package/dist/components/Item.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from 'react';
+export interface ItemProps {
+    label?: ReactNode;
+    description?: ReactNode;
+    layout?: 'below' | 'inline';
+    icon?: ReactNode;
+    bottomSeparator?: 'standard' | 'thick' | 'none';
+    indentLevel?: number;
+    tooltip?: string;
+    highlightOnFocus?: boolean;
+}

package/dist/components/Item.js

@@ -0,0 +1 @@
+export {};

package/dist/components/Marquee.d.ts

@@ -0,0 +1,14 @@
+import { CSSProperties, FC } from 'react';
+export interface MarqueeProps {
+    play?: boolean;
+    direction?: 'left' | 'right';
+    speed?: number;
+    delay?: number;
+    fadeLength?: number;
+    center?: boolean;
+    resetOnPause?: boolean;
+    style?: CSSProperties;
+    className?: string;
+    children: React.ReactNode;
+}
+export declare const Marquee: FC<MarqueeProps>;

package/dist/components/Marquee.js

@@ -0,0 +1,2 @@
+import { findModuleExport } from '../webpack';
+export const Marquee = findModuleExport((e) => e?.toString && e.toString().includes('.Marquee') && e.toString().includes('--fade-length'));

package/dist/components/Menu.d.ts

@@ -0,0 +1,29 @@
+import { FC, ReactNode } from 'react';
+import { FooterLegendProps } from './FooterLegend';
+export declare const showContextMenu: (children: ReactNode, parent?: EventTarget) => void;
+export interface MenuProps extends FooterLegendProps {
+    label: string;
+    onCancel?(): void;
+    cancelText?: string;
+    children?: ReactNode;
+}
+export declare const Menu: FC<MenuProps>;
+export interface MenuGroupProps {
+    label: string;
+    disabled?: boolean;
+    children?: ReactNode;
+}
+export declare const MenuGroup: FC<MenuGroupProps>;
+export interface MenuItemProps extends FooterLegendProps {
+    bInteractableItem?: boolean;
+    onClick?(evt: Event): void;
+    onSelected?(evt: Event): void;
+    onMouseEnter?(evt: MouseEvent): void;
+    onMoveRight?(): void;
+    selected?: boolean;
+    disabled?: boolean;
+    bPlayAudio?: boolean;
+    tone?: 'positive' | 'emphasis' | 'destructive';
+    children?: ReactNode;
+}
+export declare const MenuItem: FC<MenuItemProps>;

package/dist/components/Menu.js

@@ -0,0 +1,8 @@
+import { fakeRenderComponent } from '../utils';
+import { findModuleExport } from '../webpack';
+export const showContextMenu = findModuleExport((e) => typeof e === 'function' && e.toString().includes('stopPropagation))'));
+export const Menu = findModuleExport((e) => e?.prototype?.HideIfSubmenu && e?.prototype?.HideMenu);
+export const MenuGroup = findModuleExport((e) => (e?.toString()?.includes?.('bInGamepadUI:') &&
+    fakeRenderComponent(() => e({ overview: { appid: 7 } }))?.type?.prototype?.RenderSubMenu) ||
+    (e?.prototype?.RenderSubMenu && e?.prototype?.ShowSubMenu));
+export const MenuItem = findModuleExport((e) => e?.render?.toString()?.includes('bPlayAudio:') || (e?.prototype?.OnOKButton && e?.prototype?.OnMouseEnter));

package/dist/components/Modal.d.ts

@@ -0,0 +1,52 @@
+import { FC, ReactNode } from 'react';
+export interface ShowModalProps {
+    browserContext?: unknown;
+    bForcePopOut?: boolean;
+    bHideActionIcons?: boolean;
+    bHideMainWindowForPopouts?: boolean;
+    bNeverPopOut?: boolean;
+    fnOnClose?: () => void;
+    popupHeight?: number;
+    popupWidth?: number;
+    promiseRenderComplete?: Promise<void>;
+    strTitle?: string;
+}
+export interface ShowModalResult {
+    Close: () => void;
+    Update: (modal: ReactNode) => void;
+}
+export declare const showModal: (modal: ReactNode, parent?: EventTarget, props?: ShowModalProps) => ShowModalResult;
+export interface ModalRootProps {
+    children?: ReactNode;
+    onCancel?(): void;
+    closeModal?(): void;
+    onOK?(): void;
+    onEscKeypress?(): void;
+    className?: string;
+    modalClassName?: string;
+    bAllowFullSize?: boolean;
+    bDestructiveWarning?: boolean;
+    bDisableBackgroundDismiss?: boolean;
+    bHideCloseIcon?: boolean;
+    bOKDisabled?: boolean;
+    bCancelDisabled?: boolean;
+}
+export interface ConfirmModalProps extends ModalRootProps {
+    onMiddleButton?(): void;
+    strTitle?: ReactNode;
+    strDescription?: ReactNode;
+    strOKButtonText?: ReactNode;
+    strCancelButtonText?: ReactNode;
+    strMiddleButtonText?: ReactNode;
+    bAlertDialog?: boolean;
+    bMiddleDisabled?: boolean;
+}
+export declare const ConfirmModal: FC<ConfirmModalProps>;
+export declare const ModalRoot: FC<ModalRootProps>;
+interface SimpleModalProps {
+    active?: boolean;
+    children: ReactNode;
+}
+export declare const SimpleModal: FC<SimpleModalProps>;
+export declare const ModalPosition: FC<SimpleModalProps>;
+export {};

package/dist/components/Modal.js

@@ -0,0 +1,29 @@
+import { findSP } from '../utils';
+import { findModule, findModuleByExport, findModuleExport } from '../webpack';
+const showModalRaw = findModuleExport((e) => typeof e === 'function' && e.toString().includes('props.bDisableBackgroundDismiss') && !e?.prototype?.Cancel);
+export const showModal = (modal, parent, props = {
+    strTitle: 'Decky Dialog',
+    bHideMainWindowForPopouts: false,
+}) => {
+    return showModalRaw(modal, parent || findSP(), props.strTitle, props, undefined, {
+        bHideActions: props.bHideActionIcons,
+    });
+};
+export const ConfirmModal = findModuleExport((e) => !e?.prototype?.OK && e?.prototype?.Cancel && e?.prototype?.render);
+export const ModalRoot = Object.values(findModule((m) => {
+    if (typeof m !== 'object')
+        return false;
+    for (let prop in m) {
+        if (m[prop]?.m_mapModalManager && Object.values(m)?.find((x) => x?.type)) {
+            return true;
+        }
+    }
+    return false;
+}) || {})?.find((x) => x?.type?.toString()?.includes('((function(){'));
+const ModalModule = findModuleByExport((e) => e?.toString().includes('.ModalPosition,fallback:'), 5);
+const ModalModuleProps = ModalModule ? Object.values(ModalModule) : [];
+export const SimpleModal = ModalModuleProps.find((prop) => {
+    const string = prop?.toString();
+    return string?.includes('.ShowPortalModal()') && string?.includes('.OnElementReadyCallbacks.Register(');
+});
+export const ModalPosition = ModalModuleProps.find((prop) => prop?.toString().includes('.ModalPosition,fallback:'));

package/dist/components/Panel.d.ts

@@ -0,0 +1,11 @@
+import { FC, ReactNode } from 'react';
+export interface PanelSectionProps {
+    title?: string;
+    spinner?: boolean;
+    children?: ReactNode;
+}
+export declare const PanelSection: FC<PanelSectionProps>;
+export interface PanelSectionRowProps {
+    children?: ReactNode;
+}
+export declare const PanelSectionRow: FC<PanelSectionRowProps>;

package/dist/components/Panel.js

@@ -0,0 +1,4 @@
+import { findModuleDetailsByExport } from '../webpack';
+const [mod, panelSection] = findModuleDetailsByExport((e) => e.toString()?.includes('.PanelSection'));
+export const PanelSection = panelSection;
+export const PanelSectionRow = Object.values(mod).filter((exp) => !exp?.toString()?.includes('.PanelSection'))[0];

package/dist/components/ProgressBar.d.ts

@@ -0,0 +1,21 @@
+import { ReactNode, VFC } from 'react';
+import { ItemProps } from './Item';
+export interface ProgressBarItemProps extends ItemProps {
+    indeterminate?: boolean;
+    nTransitionSec?: number;
+    nProgress?: number;
+    focusable?: boolean;
+}
+export interface ProgressBarProps {
+    indeterminate?: boolean;
+    nTransitionSec?: number;
+    nProgress?: number;
+    focusable?: boolean;
+}
+export interface ProgressBarWithInfoProps extends ProgressBarItemProps {
+    sTimeRemaining?: ReactNode;
+    sOperationText?: ReactNode;
+}
+export declare const ProgressBar: VFC<ProgressBarProps>;
+export declare const ProgressBarWithInfo: VFC<ProgressBarWithInfoProps>;
+export declare const ProgressBarItem: VFC<ProgressBarItemProps>;

package/dist/components/ProgressBar.js

@@ -0,0 +1,4 @@
+import { findModuleExport } from '../webpack';
+export const ProgressBar = findModuleExport((e) => e?.toString()?.includes('.ProgressBar,"standard"=='));
+export const ProgressBarWithInfo = findModuleExport((e) => e?.toString()?.includes('.ProgressBarFieldStatus},'));
+export const ProgressBarItem = findModuleExport((e) => e?.toString()?.includes('"indeterminate","nTransitionSec"'));

package/dist/components/Scroll.d.ts

@@ -0,0 +1,7 @@
+import { FC, ReactNode } from 'react';
+export declare const ScrollPanel: FC<{
+    children?: ReactNode;
+}>;
+export declare const ScrollPanelGroup: FC<{
+    children?: ReactNode;
+}>;

package/dist/components/Scroll.js

@@ -0,0 +1,5 @@
+import { findModuleByExport, findModuleExport } from '../webpack';
+const ScrollingModule = findModuleByExport((e) => e?.render?.toString?.().includes('{case"x":'));
+const ScrollingModuleProps = ScrollingModule ? Object.values(ScrollingModule) : [];
+export const ScrollPanel = ScrollingModuleProps.find((prop) => prop?.render?.toString?.().includes('{case"x":'));
+export const ScrollPanelGroup = findModuleExport((e) => e?.render?.toString().includes('.FocusVisibleChild()),[])'));

package/dist/components/SidebarNavigation.d.ts

@@ -0,0 +1,21 @@
+import { ReactNode, VFC } from 'react';
+export interface SidebarNavigationPage {
+    title: ReactNode;
+    content: ReactNode;
+    icon?: ReactNode;
+    visible?: boolean;
+    hideTitle?: boolean;
+    identifier?: string;
+    route?: string;
+    link?: string;
+    padding?: 'none' | 'compact';
+}
+export interface SidebarNavigationProps {
+    title?: string;
+    pages: (SidebarNavigationPage | 'separator')[];
+    showTitle?: boolean;
+    disableRouteReporting?: boolean;
+    page?: string;
+    onPageRequested?: (page: string) => void;
+}
+export declare const SidebarNavigation: VFC<SidebarNavigationProps>;

package/dist/components/SidebarNavigation.js

@@ -0,0 +1,2 @@
+import { findModuleExport } from '../webpack';
+export const SidebarNavigation = findModuleExport((e) => e?.toString()?.includes('"disableRouteReporting"'));

package/dist/components/SliderField.d.ts

@@ -0,0 +1,26 @@
+import { FC } from 'react';
+import { ItemProps } from './Item';
+export interface NotchLabel {
+    notchIndex: number;
+    label: string;
+    value?: number;
+}
+export interface SliderFieldProps extends ItemProps {
+    value: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    notchCount?: number;
+    notchLabels?: NotchLabel[];
+    notchTicksVisible?: boolean;
+    showValue?: boolean;
+    resetValue?: number;
+    disabled?: boolean;
+    editableValue?: boolean;
+    validValues?: 'steps' | 'range' | ((value: number) => boolean);
+    valueSuffix?: string;
+    minimumDpadGranularity?: number;
+    onChange?(value: number): void;
+    className?: string;
+}
+export declare const SliderField: FC<SliderFieldProps>;

package/dist/components/SliderField.js

@@ -0,0 +1,2 @@
+import { CommonUIModule } from '../webpack';
+export const SliderField = Object.values(CommonUIModule).find((mod) => mod?.toString()?.includes('SliderField,fallback'));

package/dist/components/Spinner.d.ts

@@ -0,0 +1,2 @@
+import { FC, SVGAttributes } from 'react';
+export declare const Spinner: FC<SVGAttributes<SVGElement>>;

package/dist/components/Spinner.js

@@ -0,0 +1,2 @@
+import { IconsModule } from '../webpack';
+export const Spinner = Object.values(IconsModule).find((mod) => mod?.toString && /Spinner\)}\),.\.createElement\(\"path\",{d:\"M18 /.test(mod.toString()));

package/dist/components/SteamSpinner.d.ts

@@ -0,0 +1,2 @@
+import { FC, SVGAttributes } from 'react';
+export declare const SteamSpinner: FC<SVGAttributes<SVGElement>>;

package/dist/components/SteamSpinner.js

@@ -0,0 +1,2 @@
+import { findModuleExport } from '../webpack';
+export const SteamSpinner = findModuleExport((e) => e?.toString?.()?.includes('Steam Spinner') && e?.toString?.()?.includes('src'));

package/dist/components/Tabs.d.ts

@@ -0,0 +1,16 @@
+import { FC, ReactNode } from 'react';
+import { FooterLegendProps } from './FooterLegend';
+export interface Tab {
+    id: string;
+    title: string;
+    renderTabAddon?: () => ReactNode;
+    content: ReactNode;
+    footer?: FooterLegendProps;
+}
+export interface TabsProps {
+    tabs: Tab[];
+    activeTab: string;
+    onShowTab: (tab: string) => void;
+    autoFocusContents?: boolean;
+}
+export declare const Tabs: FC<TabsProps>;

package/dist/components/Tabs.js

@@ -0,0 +1,48 @@
+import { createElement, useEffect, useState } from 'react';
+import { fakeRenderComponent, findInReactTree, sleep } from '../utils';
+import { findModuleByExport } from '../webpack';
+import { SteamSpinner } from './SteamSpinner';
+let tabsComponent;
+const getTabs = async () => {
+    if (tabsComponent)
+        return tabsComponent;
+    while (!window?.DeckyPluginLoader?.routerHook?.routes) {
+        console.debug('[DFL:Tabs]: Waiting for Decky router...');
+        await sleep(500);
+    }
+    return (tabsComponent = fakeRenderComponent(() => {
+        return findInReactTree(findInReactTree(window.DeckyPluginLoader.routerHook.routes
+            .find((x) => x.props.path == '/library/app/:appid/achievements')
+            .props.children.type(), (x) => x?.props?.scrollTabsTop).type({ appid: 1 }), (x) => x?.props?.tabs).type;
+    }, {
+        useRef: () => ({ current: { reaction: { track: () => { } } } }),
+        useContext: () => ({ match: { params: { appid: 1 } } }),
+        useMemo: () => ({ data: {} }),
+    }));
+};
+let oldTabs;
+try {
+    const oldTabsModule = findModuleByExport((e) => e.Unbleed);
+    if (oldTabsModule)
+        oldTabs = Object.values(oldTabsModule).find((x) => x?.type?.toString()?.includes('((function(){'));
+}
+catch (e) {
+    console.error('Error finding oldTabs:', e);
+}
+export const Tabs = (oldTabs ||
+    ((props) => {
+        const found = tabsComponent;
+        const [tc, setTC] = useState(found);
+        useEffect(() => {
+            if (found)
+                return;
+            (async () => {
+                console.debug('[DFL:Tabs]: Finding component...');
+                const t = await getTabs();
+                console.debug('[DFL:Tabs]: Found!');
+                setTC(t);
+            })();
+        }, []);
+        console.log('tc', tc);
+        return tc ? createElement(tc, props) : window.SP_REACT.createElement(SteamSpinner, null);
+    }));

package/dist/components/TextField.d.ts

@@ -0,0 +1,22 @@
+import { ChangeEventHandler, HTMLAttributes, ReactNode, VFC } from 'react';
+export interface TextFieldProps extends HTMLAttributes<HTMLInputElement> {
+    label?: ReactNode;
+    requiredLabel?: ReactNode;
+    description?: ReactNode;
+    disabled?: boolean;
+    bShowCopyAction?: boolean;
+    bShowClearAction?: boolean;
+    bAlwaysShowClearAction?: boolean;
+    bIsPassword?: boolean;
+    rangeMin?: number;
+    rangeMax?: number;
+    mustBeNumeric?: boolean;
+    mustBeURL?: boolean;
+    mustBeEmail?: boolean;
+    focusOnMount?: boolean;
+    tooltip?: string;
+    inlineControls?: ReactNode;
+    onChange?: ChangeEventHandler<HTMLInputElement>;
+    value?: string;
+}
+export declare const TextField: VFC<TextFieldProps>;

package/dist/components/TextField.js

@@ -0,0 +1,2 @@
+import { CommonUIModule } from '../webpack';
+export const TextField = Object.values(CommonUIModule).find((mod) => mod?.validateUrl && mod?.validateEmail);