@decky/ui 3.26.0

package/src/components/SidebarNavigation.ts

@@ -0,0 +1,30 @@
+import { ReactNode, FC } from 'react';
+
+import { Export, findModuleExport } from '../webpack';
+import { createPropListRegex } from '../utils';
+
+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;
+}
+
+const sidebarNavigationRegex = createPropListRegex(["pages", "fnSetNavigateToPage", "disableRouteReporting"]);
+export const SidebarNavigation = findModuleExport((e: Export) =>
+  e?.toString && sidebarNavigationRegex.test(e.toString()),
+) as FC<SidebarNavigationProps>;

package/src/components/SliderField.ts

@@ -0,0 +1,33 @@
+import { FC } from 'react';
+
+import { CommonUIModule } from '../webpack';
+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 const SliderField = Object.values(CommonUIModule).find((mod: any) =>
+  mod?.toString()?.includes('SliderField,fallback'),
+) as FC<SliderFieldProps>;

package/src/components/Spinner.ts

@@ -0,0 +1,8 @@
+import { FC, SVGAttributes } from 'react';
+
+import { IconsModule } from '../webpack';
+
+// TODO type this and other icons?
+export const Spinner = Object.values(IconsModule)?.find(
+  (mod: any) => mod?.toString && /Spinner\)}\)?,.\.createElement\(\"path\",{d:\"M18 /.test(mod.toString()),
+) as FC<SVGAttributes<SVGElement>>;

package/src/components/SteamSpinner.ts

@@ -0,0 +1,7 @@
+import { FC, SVGAttributes } from 'react';
+
+import { Export, findModuleExport } from '../webpack';
+
+export const SteamSpinner = findModuleExport(
+  (e: Export) => e?.toString?.()?.includes('Steam Spinner') && e?.toString?.()?.includes('src'),
+) as FC<SVGAttributes<SVGElement>>;

package/src/components/Tabs.tsx

@@ -0,0 +1,127 @@
+import { FC, ReactNode, createElement, useEffect, useState } from 'react';
+
+import { fakeRenderComponent, findInReactTree, sleep } from '../utils';
+import { Export, findModuleByExport } from '../webpack';
+import { FooterLegendProps } from './FooterLegend';
+import { SteamSpinner } from './SteamSpinner';
+
+/**
+ * Individual tab objects for the Tabs component
+ *
+ * `id` ID of this tab, can be used with activeTab to auto-focus a given tab
+ * `title` Title shown in the header bar
+ * `renderTabAddon` Return a {@link ReactNode} to render it next to the tab title, i.e. the counts for each tab on the Media page
+ * `content` Content of the tab
+ * `footer` Sets up button handlers and labels
+ */
+export interface Tab {
+  id: string;
+  title: string;
+  renderTabAddon?: () => ReactNode;
+  content: ReactNode;
+  footer?: FooterLegendProps;
+}
+
+/**
+ * Props for the {@link Tabs}
+ *
+ * `tabs` array of {@link Tab}
+ * `activeTab` tab currently active, needs to be one of the tabs {@link Tab.id}, must be set using a `useState` in the `onShowTab` handler
+ * `onShowTab` Called when the active tab should change, needs to set `activeTab`. See example.
+ * `autoFocusContents` Whether to automatically focus the tab contents or not.
+ * `footer` Sets up button handlers and labels
+ *
+ * @example
+ * const Component: FC = () => {
+ * const [currentTab, setCurrentTab] = useState<string>("Tab1");
+ *
+ * return (
+ *   <Tabs
+ *     title="Theme Manager"
+ *     activeTab={currentTabRoute}
+ *     onShowTab={(tabID: string) => {
+ *        setCurrentTabRoute(tabID);
+ *     }}
+ *     tabs={[
+ *       {
+ *         title: "Tab 1",
+ *         content: <Tab1Component />,
+ *         id: "Tab1",
+ *       },
+ *       {
+ *         title: "Tab 2",
+ *         content: <Tab2Component />,
+ *         id: "Tab2",
+ *       },
+ *     ]}
+ *   />
+ *  );
+ * };
+ */
+export interface TabsProps {
+  tabs: Tab[];
+  activeTab: string;
+  onShowTab: (tab: string) => void;
+  autoFocusContents?: boolean;
+}
+
+let tabsComponent: any;
+
+const getTabs = async () => {
+  if (tabsComponent) return tabsComponent;
+  // @ts-ignore
+  while (!window?.DeckyPluginLoader?.routerHook?.routes) {
+    console.debug('[DFL:Tabs]: Waiting for Decky router...');
+    await sleep(500);
+  }
+  return (tabsComponent = fakeRenderComponent(
+    () => {
+      return findInReactTree(
+        findInReactTree(
+          // @ts-ignore
+          window.DeckyPluginLoader.routerHook.routes
+            .find((x: any) => 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: any;
+
+try {
+  const oldTabsModule = findModuleByExport((e: Export) => e.Unbleed);
+  if (oldTabsModule)
+    oldTabs = Object.values(oldTabsModule).find((x: any) => x?.type?.toString()?.includes('((function(){'));
+} catch (e) {
+  console.error('Error finding oldTabs:', e);
+}
+
+/**
+ * Tabs component as used in the library and media tabs. See {@link TabsProps}.
+ * Unlike other components in `decky-frontend-lib`, this requires Decky Loader to be running.
+ */
+export const Tabs = (oldTabs ||
+  ((props: TabsProps) => {
+    const found = tabsComponent;
+    const [tc, setTC] = useState<FC<TabsProps>>(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) : <SteamSpinner />;
+  })) as FC<TabsProps>;

package/src/components/TextField.ts

@@ -0,0 +1,28 @@
+import { ChangeEventHandler, HTMLAttributes, ReactNode, FC } from 'react';
+
+import { CommonUIModule, Module } from '../webpack';
+
+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 const TextField = Object.values(CommonUIModule).find(
+  (mod: Module) => mod?.validateUrl && mod?.validateEmail,
+) as FC<TextFieldProps>;

package/src/components/Toggle.ts

@@ -0,0 +1,14 @@
+import { FC } from 'react';
+
+import { CommonUIModule } from '../webpack';
+
+export interface ToggleProps {
+  value: boolean;
+  disabled?: boolean;
+  onChange?(checked: boolean): void;
+  navRef?: any; // TODO figure out what this is
+}
+
+export const Toggle = Object.values(CommonUIModule).find((mod: any) =>
+  mod?.render?.toString()?.includes('.ToggleOff)'),
+) as FC<ToggleProps>;

package/src/components/ToggleField.ts

@@ -0,0 +1,15 @@
+import { FC } from 'react';
+
+import { CommonUIModule } from '../webpack';
+import { ItemProps } from './Item';
+
+export interface ToggleFieldProps extends ItemProps {
+  highlightOnFocus?: boolean;
+  checked: boolean;
+  disabled?: boolean;
+  onChange?(checked: boolean): void;
+}
+
+export const ToggleField = Object.values(CommonUIModule).find((mod: any) =>
+  mod?.render?.toString()?.includes('ToggleField,fallback'),
+) as FC<ToggleFieldProps>;

package/src/components/index.ts

@@ -0,0 +1,25 @@
+export * from './Button';
+export * from './ButtonItem';
+export * from './Carousel';
+export * from './ControlsList';
+export * from './Dialog';
+export * from './DialogCheckbox';
+export * from './Dropdown';
+export * from './Field';
+export * from './Focusable';
+export * from './FocusRing';
+export * from './FooterLegend';
+export * from './Marquee';
+export * from './Menu';
+export * from './Modal';
+export * from './Panel';
+export * from './ProgressBar';
+export * from './SidebarNavigation';
+export * from './SliderField';
+export * from './Spinner';
+export * from './SteamSpinner';
+export * from './Tabs';
+export * from './TextField';
+export * from './Toggle';
+export * from './ToggleField';
+export * from './Scroll';

package/src/custom-components/ColorPickerModal.tsx

@@ -0,0 +1,132 @@
+import { CSSProperties, FC, useState } from 'react';
+
+import { ConfirmModal, SliderField } from '../components';
+import { gamepadSliderClasses } from '../utils/static-classes';
+
+interface ColorPickerModalProps {
+  closeModal: () => void;
+  onConfirm?(HSLString: string): any;
+  title?: string;
+  defaultH?: number;
+  defaultS?: number;
+  defaultL?: number;
+  defaultA?: number;
+}
+
+export const ColorPickerModal: FC<ColorPickerModalProps> = ({
+  closeModal,
+  onConfirm = () => {},
+  title = 'Color Picker',
+  defaultH = 0,
+  defaultS = 100,
+  defaultL = 50,
+  defaultA = 1,
+}) => {
+  const [H, setH] = useState<number>(defaultH);
+  const [S, setS] = useState<number>(defaultS);
+  const [L, setL] = useState<number>(defaultL);
+  const [A, setA] = useState<number>(defaultA);
+
+  const colorPickerCSSVars = {
+    '--decky-color-picker-hvalue': `${H}`,
+    '--decky-color-picker-svalue': `${S}%`,
+    '--decky-color-picker-lvalue': `${L}%`,
+    '--decky-color-picker-avalue': `${A}`,
+  } as CSSProperties;
+
+  return (
+    <ConfirmModal
+      bAllowFullSize
+      onCancel={closeModal}
+      onOK={() => {
+        onConfirm(`hsla(${H}, ${S}%, ${L}%, ${A})`);
+        closeModal();
+      }}
+    >
+      <style>
+        {`
+        /* This removes the cyan track color that is behind the slider head */
+        .ColorPicker_Container .${gamepadSliderClasses.SliderTrack} {
+          --left-track-color: #0000;
+          /* This is for compatibility with the "Colored Toggles" CSSLoader Theme*/
+          --colored-toggles-main-color: #0000;
+        }
+
+        .ColorPicker_HSlider .${gamepadSliderClasses.SliderTrack} {
+          background: linear-gradient(
+            270deg,
+            hsla(360, var(--decky-color-picker-svalue), var(--decky-color-picker-lvalue), var(--decky-color-picker-avalue)),
+            hsla(270, var(--decky-color-picker-svalue), var(--decky-color-picker-lvalue), var(--decky-color-picker-avalue)),
+            hsla(180, var(--decky-color-picker-svalue), var(--decky-color-picker-lvalue), var(--decky-color-picker-avalue)),
+            hsla(90, var(--decky-color-picker-svalue), var(--decky-color-picker-lvalue), var(--decky-color-picker-avalue)),
+            hsla(0, var(--decky-color-picker-svalue), var(--decky-color-picker-lvalue), var(--decky-color-picker-avalue))
+          );
+        }
+
+        .ColorPicker_SSlider .${gamepadSliderClasses.SliderTrack} {
+          background: linear-gradient(
+            90deg,
+            hsla(var(--decky-color-picker-hvalue), 0%, var(--decky-color-picker-lvalue), var(--decky-color-picker-avalue)),
+            hsla(var(--decky-color-picker-hvalue), 100%, var(--decky-color-picker-lvalue), var(--decky-color-picker-avalue))
+          );
+        }
+
+        .ColorPicker_LSlider .${gamepadSliderClasses.SliderTrack} {
+          background: linear-gradient(
+            90deg,
+            hsla(var(--decky-color-picker-hvalue), var(--decky-color-picker-svalue), 0%, var(--decky-color-picker-avalue)),
+            hsla(var(--decky-color-picker-hvalue), var(--decky-color-picker-svalue), 50%, var(--decky-color-picker-avalue)),
+            hsla(var(--decky-color-picker-hvalue), var(--decky-color-picker-svalue), 100%, var(--decky-color-picker-avalue))
+          );
+        }
+
+        .ColorPicker_ASlider .${gamepadSliderClasses.SliderTrack} {
+          background: linear-gradient(
+            90deg,
+            hsla(var(--decky-color-picker-hvalue), var(--decky-color-picker-svalue), var(--decky-color-picker-lvalue), 0),
+            hsla(var(--decky-color-picker-hvalue), var(--decky-color-picker-svalue), var(--decky-color-picker-lvalue), 1)
+          );
+        }
+        `}
+      </style>
+      <div
+        className="ColorPicker_ColorDisplayContainer"
+        style={{
+          display: 'flex',
+          justifyContent: 'space-between',
+          alignItems: 'center',
+          marginBottom: '1em',
+          // theres a large header by default on the modal, so this just pushes it up into that unused space
+          marginTop: '-2.5em',
+        }}
+      >
+        <div>
+          <span style={{ fontSize: '1.5em' }}>
+            <b>{title}</b>
+          </span>
+        </div>
+        <div
+          style={{
+            backgroundColor: `hsla(${H}, ${S}%, ${L}%, ${A})`,
+            width: '40px',
+            height: '40px',
+          }}
+        ></div>
+      </div>
+      <div className="ColorPicker_Container" style={colorPickerCSSVars}>
+        <div className="ColorPicker_HSlider">
+          <SliderField showValue editableValue label="Hue" value={H} min={0} max={360} onChange={setH} />
+        </div>
+        <div className="ColorPicker_SSlider">
+          <SliderField showValue editableValue label="Saturation" value={S} min={0} max={100} onChange={setS} />
+        </div>
+        <div className="ColorPicker_LSlider">
+          <SliderField showValue editableValue label="Lightness" value={L} min={0} max={100} onChange={setL} />
+        </div>
+        <div className="ColorPicker_ASlider">
+          <SliderField showValue editableValue label="Alpha" value={A} step={0.1} min={0} max={1} onChange={setA} />
+        </div>
+      </div>
+    </ConfirmModal>
+  );
+};

package/src/custom-components/ReorderableList.tsx

@@ -0,0 +1,183 @@
+import { Fragment, JSXElementConstructor, ReactElement, ReactNode, useEffect, useState } from 'react';
+
+import { Field, FieldProps, Focusable, GamepadButton } from '../components';
+
+/**
+ * A ReorderableList entry of type <T>.
+ * @param label The name of this entry in the list.
+ * @param data Optional data to connect to this entry.
+ * @param position The position of this entry in the list.
+ */
+export type ReorderableEntry<T> = {
+  label: ReactNode;
+  data?: T;
+  position: number;
+};
+
+/**
+ * Properties for a ReorderableList component of type <T>.
+ *
+ * @param animate If the list should animate. @default true
+ */
+export type ReorderableListProps<T> = {
+  entries: ReorderableEntry<T>[];
+  onSave: (entries: ReorderableEntry<T>[]) => void;
+  interactables?: JSXElementConstructor<{ entry: ReorderableEntry<T> }>;
+  fieldProps?: FieldProps;
+  animate?: boolean;
+};
+
+/**
+ * A component for creating reorderable lists.
+ *
+ * See an example implementation {@linkplain https://github.com/Tormak9970/Component-Testing-Plugin/blob/main/src/testing-window/ReorderableListTest.tsx here}.
+ */
+export function ReorderableList<T>(props: ReorderableListProps<T>) {
+  if (props.animate === undefined) props.animate = true;
+  const [entryList, setEntryList] = useState<ReorderableEntry<T>[]>(
+    props.entries.sort((a: ReorderableEntry<T>, b: ReorderableEntry<T>) => a.position - b.position),
+  );
+  const [reorderEnabled, setReorderEnabled] = useState<boolean>(false);
+
+  useEffect(() => {
+    setEntryList(props.entries.sort((a: ReorderableEntry<T>, b: ReorderableEntry<T>) => a.position - b.position));
+  }, [props.entries]);
+
+  function toggleReorderEnabled(): void {
+    let newReorderValue = !reorderEnabled;
+    setReorderEnabled(newReorderValue);
+
+    if (!newReorderValue) {
+      props.onSave(entryList);
+    }
+  }
+
+  function saveOnBackout(e: Event) {
+    const event = e as CustomEvent;
+    if (event.detail.button == GamepadButton.CANCEL && reorderEnabled) {
+      setReorderEnabled(!reorderEnabled);
+      props.onSave(entryList);
+    }
+  }
+
+  return (
+    <Fragment>
+      <div
+        style={{
+          width: 'inherit',
+          height: 'inherit',
+          flex: '1 1 1px',
+          scrollPadding: '48px 0px',
+          display: 'flex',
+          flexDirection: 'column',
+          justifyContent: 'flex-start',
+          alignContent: 'stretch',
+        }}
+      >
+        <Focusable
+          onSecondaryButton={toggleReorderEnabled}
+          onSecondaryActionDescription={reorderEnabled ? 'Save Order' : 'Reorder'}
+          onClick={toggleReorderEnabled}
+          onButtonDown={saveOnBackout}
+        >
+          {entryList.map((entry: ReorderableEntry<T>) => (
+            <ReorderableItem
+              animate={props.animate!}
+              listData={entryList}
+              entryData={entry}
+              reorderEntryFunc={setEntryList}
+              reorderEnabled={reorderEnabled}
+              fieldProps={props.fieldProps}
+            >
+              {props.interactables ? <props.interactables entry={entry} /> : null}
+            </ReorderableItem>
+          ))}
+        </Focusable>
+      </div>
+    </Fragment>
+  );
+}
+
+/**
+ * Properties for a ReorderableItem component of type <T>
+ */
+export type ReorderableListEntryProps<T> = {
+  fieldProps?: FieldProps;
+  listData: ReorderableEntry<T>[];
+  entryData: ReorderableEntry<T>;
+  reorderEntryFunc: CallableFunction;
+  reorderEnabled: boolean;
+  animate: boolean;
+  children: ReactElement | null;
+};
+
+function ReorderableItem<T>(props: ReorderableListEntryProps<T>) {
+  const [isSelected, _setIsSelected] = useState<boolean>(false);
+  const [isSelectedLastFrame, setIsSelectedLastFrame] = useState<boolean>(false);
+  const listEntries = props.listData;
+
+  function onReorder(e: Event): void {
+    if (!props.reorderEnabled) return;
+
+    const event = e as CustomEvent;
+    const currentIdx = listEntries.findIndex((entryData: ReorderableEntry<T>) => entryData === props.entryData);
+    const currentIdxValue = listEntries[currentIdx];
+    if (currentIdx < 0) return;
+
+    let targetPosition: number = -1;
+    if (event.detail.button == GamepadButton.DIR_DOWN) {
+      targetPosition = currentIdxValue.position + 1;
+    } else if (event.detail.button == GamepadButton.DIR_UP) {
+      targetPosition = currentIdxValue.position - 1;
+    }
+
+    if (targetPosition >= listEntries.length || targetPosition < 0) return;
+
+    let otherToUpdate = listEntries.find((entryData: ReorderableEntry<T>) => entryData.position === targetPosition);
+    if (!otherToUpdate) return;
+
+    let currentPosition = currentIdxValue.position;
+
+    currentIdxValue.position = otherToUpdate.position;
+    otherToUpdate.position = currentPosition;
+
+    props.reorderEntryFunc(
+      [...listEntries].sort((a: ReorderableEntry<T>, b: ReorderableEntry<T>) => a.position - b.position),
+    );
+  }
+
+  async function setIsSelected(val: boolean) {
+    _setIsSelected(val);
+    // Wait 3 frames, then set. I have no idea why, but if you dont wait long enough it doesn't work.
+    for (let i = 0; i < 3; i++) await new Promise((res) => requestAnimationFrame(res));
+    setIsSelectedLastFrame(val);
+  }
+
+  return (
+    <div
+      style={
+        props.animate
+          ? {
+              transition:
+                isSelected || isSelectedLastFrame
+                  ? ''
+                  : 'transform 0.3s cubic-bezier(0.25, 1, 0.5, 1), opacity 0.3s cubic-bezier(0.25, 1, 0.5, 1)', // easeOutQuart https://easings.net/#easeOutQuart
+              transform: !props.reorderEnabled || isSelected ? 'scale(1)' : 'scale(0.9)',
+              opacity: !props.reorderEnabled || isSelected ? 1 : 0.7,
+            }
+          : {}
+      }
+    >
+      <Field
+        label={props.entryData.label}
+        {...props.fieldProps}
+        focusable={!props.children}
+        onButtonDown={onReorder}
+        onGamepadBlur={() => setIsSelected(false)}
+        onGamepadFocus={() => setIsSelected(true)}
+      >
+        <Focusable style={{ display: 'flex', width: '100%', position: 'relative' }}>{props.children}</Focusable>
+      </Field>
+    </div>
+  );
+}

package/src/custom-components/SuspensefulImage.tsx

@@ -0,0 +1,44 @@
+import { useEffect } from 'react';
+import { FC, ImgHTMLAttributes, useState } from 'react';
+
+import { Spinner } from '../components';
+
+interface SuspensefulImageProps extends ImgHTMLAttributes<HTMLImageElement> {
+  suspenseWidth?: string | number;
+  suspenseHeight?: string | number;
+}
+
+export const SuspensefulImage: FC<SuspensefulImageProps> = (props) => {
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(false);
+
+  useEffect(() => {
+    setLoading(true);
+    setError(false);
+    const img = new Image();
+    img.src = props.src || '';
+    img.addEventListener('load', () => {
+      setLoading(false);
+    });
+    img.addEventListener('error', () => {
+      setError(true);
+    });
+  }, [props.src]);
+
+  return loading ? (
+    <div
+      style={{
+        width: props.suspenseWidth || props.style?.width,
+        height: props.suspenseHeight || props.style?.height,
+        background: 'rgba(255, 255, 255, 0.2)',
+        display: 'flex',
+        alignItems: 'center',
+        justifyContent: 'center',
+      }}
+    >
+      {error ? 'Missing image' : <Spinner style={{ height: '48px' }} />}
+    </div>
+  ) : (
+    <img {...props} />
+  );
+};

package/src/custom-components/index.ts

@@ -0,0 +1,3 @@
+export * from './SuspensefulImage';
+export * from './ColorPickerModal';
+export * from './ReorderableList';

package/src/custom-hooks/index.ts

@@ -0,0 +1 @@
+export * from './useQuickAccessVisible';