@proyecto-viviana/solid-stately 0.2.7 → 0.3.0

package/src/checkbox/createCheckboxGroupState.d.ts

@@ -6,66 +6,68 @@
  *
  * This is a 1:1 port of @react-stately/checkbox's useCheckboxGroupState.
  */
-import { Accessor } from 'solid-js';
-import { type MaybeAccessor } from '../utils';
+import { Accessor } from "solid-js";
+import { type MaybeAccessor } from "../utils";
 export interface CheckboxGroupProps {
-    /** The current selected values (controlled). */
-    value?: string[];
-    /** The default selected values (uncontrolled). */
-    defaultValue?: string[];
-    /** Handler that is called when the value changes. */
-    onChange?: (value: string[]) => void;
-    /** Whether the checkbox group is disabled. */
-    isDisabled?: boolean;
-    /** Whether the checkbox group is read only. */
-    isReadOnly?: boolean;
-    /** Whether the checkbox group is required. */
-    isRequired?: boolean;
-    /** Whether the checkbox group is invalid. */
-    isInvalid?: boolean;
-    /** The name of the checkbox group, used when submitting an HTML form. */
-    name?: string;
-    /** The form to associate the checkbox group with. */
-    form?: string;
-    /** The label for the checkbox group. */
-    label?: string;
-    /** Handler that is called when the checkbox group receives focus. */
-    onFocus?: (e: FocusEvent) => void;
-    /** Handler that is called when the checkbox group loses focus. */
-    onBlur?: (e: FocusEvent) => void;
-    /** Handler that is called when the checkbox group's focus status changes. */
-    onFocusChange?: (isFocused: boolean) => void;
+  /** The current selected values (controlled). */
+  value?: string[];
+  /** The default selected values (uncontrolled). */
+  defaultValue?: string[];
+  /** Handler that is called when the value changes. */
+  onChange?: (value: string[]) => void;
+  /** Whether the checkbox group is disabled. */
+  isDisabled?: boolean;
+  /** Whether the checkbox group is read only. */
+  isReadOnly?: boolean;
+  /** Whether the checkbox group is required. */
+  isRequired?: boolean;
+  /** Whether the checkbox group is invalid. */
+  isInvalid?: boolean;
+  /** The name of the checkbox group, used when submitting an HTML form. */
+  name?: string;
+  /** The form to associate the checkbox group with. */
+  form?: string;
+  /** The label for the checkbox group. */
+  label?: string;
+  /** Handler that is called when the checkbox group receives focus. */
+  onFocus?: (e: FocusEvent) => void;
+  /** Handler that is called when the checkbox group loses focus. */
+  onBlur?: (e: FocusEvent) => void;
+  /** Handler that is called when the checkbox group's focus status changes. */
+  onFocusChange?: (isFocused: boolean) => void;
 }
 export interface CheckboxGroupState {
-    /** Current selected values. */
-    readonly value: Accessor<readonly string[]>;
-    /** Default selected values. */
-    readonly defaultValue: readonly string[];
-    /** Whether the checkbox group is disabled. */
-    readonly isDisabled: boolean;
-    /** Whether the checkbox group is read only. */
-    readonly isReadOnly: boolean;
-    /** Whether the checkbox group is invalid. */
-    readonly isInvalid: boolean;
-    /**
-     * Whether the checkboxes in the group are required.
-     * This changes to false once at least one item is selected.
-     */
-    readonly isRequired: Accessor<boolean>;
-    /** Returns whether the given value is selected. */
-    isSelected(value: string): boolean;
-    /** Sets the selected values. */
-    setValue(value: string[]): void;
-    /** Adds a value to the set of selected values. */
-    addValue(value: string): void;
-    /** Removes a value from the set of selected values. */
-    removeValue(value: string): void;
-    /** Toggles a value in the set of selected values. */
-    toggleValue(value: string): void;
+  /** Current selected values. */
+  readonly value: Accessor<readonly string[]>;
+  /** Default selected values. */
+  readonly defaultValue: readonly string[];
+  /** Whether the checkbox group is disabled. */
+  readonly isDisabled: boolean;
+  /** Whether the checkbox group is read only. */
+  readonly isReadOnly: boolean;
+  /** Whether the checkbox group is invalid. */
+  readonly isInvalid: boolean;
+  /**
+   * Whether the checkboxes in the group are required.
+   * This changes to false once at least one item is selected.
+   */
+  readonly isRequired: Accessor<boolean>;
+  /** Returns whether the given value is selected. */
+  isSelected(value: string): boolean;
+  /** Sets the selected values. */
+  setValue(value: string[]): void;
+  /** Adds a value to the set of selected values. */
+  addValue(value: string): void;
+  /** Removes a value from the set of selected values. */
+  removeValue(value: string): void;
+  /** Toggles a value in the set of selected values. */
+  toggleValue(value: string): void;
 }
 /**
  * Provides state management for a checkbox group component.
  * Provides a name for the group, and manages selection and focus state.
  */
-export declare function createCheckboxGroupState(props?: MaybeAccessor<CheckboxGroupProps>): CheckboxGroupState;
-//# sourceMappingURL=createCheckboxGroupState.d.ts.map
+export declare function createCheckboxGroupState(
+  props?: MaybeAccessor<CheckboxGroupProps>,
+): CheckboxGroupState;
+//# sourceMappingURL=createCheckboxGroupState.d.ts.map

package/src/checkbox/createCheckboxGroupState.ts

@@ -7,18 +7,14 @@
  * This is a 1:1 port of @react-stately/checkbox's useCheckboxGroupState.
  */
 
-import { createSignal, Accessor } from 'solid-js';
-import { type MaybeAccessor, access } from '../utils';
+import { createMemo, createSignal, Accessor } from "solid-js";
+import { type MaybeAccessor, access } from "../utils";
 import {
   createFormValidationState,
   type FormValidationState,
   type ValidationFunction,
   type ValidationResult,
-} from '../form';
-
-// ============================================
-// TYPES
-// ============================================
+} from "../form";
 
 export interface CheckboxGroupProps {
   /** The current selected values (controlled). */
@@ -48,14 +44,21 @@ export interface CheckboxGroupProps {
   /** Handler that is called when the checkbox group's focus status changes. */
   onFocusChange?: (isFocused: boolean) => void;
   /** Backward-compatible controlled validation state. */
-  validationState?: 'valid' | 'invalid';
+  validationState?: "valid" | "invalid";
   /** Custom validation function. */
   validate?: ValidationFunction<readonly string[]>;
   /** Validation behavior for the checkbox group. */
-  validationBehavior?: 'aria' | 'native';
+  validationBehavior?: "aria" | "native";
 }
 
-export interface CheckboxGroupState extends Pick<FormValidationState, 'realtimeValidation' | 'displayValidation' | 'updateValidation' | 'resetValidation' | 'commitValidation'> {
+export interface CheckboxGroupState extends Pick<
+  FormValidationState,
+  | "realtimeValidation"
+  | "displayValidation"
+  | "updateValidation"
+  | "resetValidation"
+  | "commitValidation"
+> {
   /** Current selected values. */
   readonly value: Accessor<readonly string[]>;
   /** Default selected values. */
@@ -86,36 +89,29 @@ export interface CheckboxGroupState extends Pick<FormValidationState, 'realtimeV
   readonly displayValidation: Accessor<ValidationResult>;
 }
 
-// ============================================
-// IMPLEMENTATION
-// ============================================
-
 /**
  * Provides state management for a checkbox group component.
  * Provides a name for the group, and manages selection and focus state.
  */
 export function createCheckboxGroupState(
-  props: MaybeAccessor<CheckboxGroupProps> = {}
+  props: MaybeAccessor<CheckboxGroupProps> = {},
 ): CheckboxGroupState {
   const getProps = () => access(props);
 
-  // Get initial values
   const initialProps = getProps();
   const initialValue = initialProps.value ?? initialProps.defaultValue ?? [];
 
-  // Create internal signal for uncontrolled mode
   const [internalValue, setInternalValue] = createSignal<readonly string[]>(initialValue);
 
-  // Determine if controlled
-  const isControlled = () => getProps().value !== undefined;
+  const controlledValue = createMemo<readonly string[] | undefined>(() => getProps().value);
+
+  const isControlled = () => controlledValue() !== undefined;
 
-  // Get current value
   const value: Accessor<readonly string[]> = () => {
-    const p = getProps();
-    return isControlled() ? (p.value ?? []) : internalValue();
+    const controlled = controlledValue();
+    return controlled !== undefined ? controlled : internalValue();
   };
 
-  // Check if required (true if isRequired and no items selected)
   const isRequired: Accessor<boolean> = () => {
     const p = getProps();
     return !!p.isRequired && value().length === 0;
@@ -135,14 +131,13 @@ export function createCheckboxGroupState(
       return getProps().validate;
     },
     get validationBehavior() {
-      return getProps().validationBehavior ?? 'aria';
+      return getProps().validationBehavior ?? "native";
     },
     get name() {
       return getProps().name;
     },
   });
 
-  // Set value
   function setValue(newValue: string[]): void {
     const p = getProps();
     if (p.isReadOnly || p.isDisabled) {
@@ -156,12 +151,10 @@ export function createCheckboxGroupState(
     p.onChange?.(newValue);
   }
 
-  // Check if value is selected
   function isSelected(checkValue: string): boolean {
     return value().includes(checkValue);
   }
 
-  // Add value
   function addValue(addVal: string): void {
     const p = getProps();
     if (p.isReadOnly || p.isDisabled) {
@@ -174,7 +167,6 @@ export function createCheckboxGroupState(
     }
   }
 
-  // Remove value
   function removeValue(removeVal: string): void {
     const p = getProps();
     if (p.isReadOnly || p.isDisabled) {
@@ -187,7 +179,6 @@ export function createCheckboxGroupState(
     }
   }
 
-  // Toggle value
   function toggleValue(toggleVal: string): void {
     const p = getProps();
     if (p.isReadOnly || p.isDisabled) {

package/src/checkbox/index.d.ts

@@ -1,2 +1,6 @@
-export { createCheckboxGroupState, type CheckboxGroupProps, type CheckboxGroupState, } from './createCheckboxGroupState';
-//# sourceMappingURL=index.d.ts.map
+export {
+  createCheckboxGroupState,
+  type CheckboxGroupProps,
+  type CheckboxGroupState,
+} from "./createCheckboxGroupState";
+//# sourceMappingURL=index.d.ts.map

package/src/checkbox/index.ts

@@ -2,4 +2,4 @@ export {
   createCheckboxGroupState,
   type CheckboxGroupProps,
   type CheckboxGroupState,
-} from './createCheckboxGroupState';
+} from "./createCheckboxGroupState";

package/src/collections/ListCollection.d.ts

@@ -2,36 +2,39 @@
  * A simple list collection implementation.
  * Provides a Collection interface over an array of nodes.
  */
-import type { Collection, CollectionNode, Key } from './types';
+import type { Collection, CollectionNode, Key } from "./types";
 /**
  * A basic implementation of Collection for list-based components.
  */
 export declare class ListCollection<T = unknown> implements Collection<T> {
-    private nodes;
-    private keyMap;
-    constructor(nodes: CollectionNode<T>[]);
-    get size(): number;
-    [Symbol.iterator](): Iterator<CollectionNode<T>>;
-    getKeys(): Iterable<Key>;
-    getItem(key: Key): CollectionNode<T> | null;
-    at(index: number): CollectionNode<T> | null;
-    getKeyBefore(key: Key): Key | null;
-    getKeyAfter(key: Key): Key | null;
-    getFirstKey(): Key | null;
-    getLastKey(): Key | null;
-    getChildren(key: Key): Iterable<CollectionNode<T>>;
-    getTextValue(key: Key): string;
-    /**
-     * Get all items (excluding sections, including items within sections).
-     */
-    private getAllItems;
+  private nodes;
+  private keyMap;
+  constructor(nodes: CollectionNode<T>[]);
+  get size(): number;
+  [Symbol.iterator](): Iterator<CollectionNode<T>>;
+  getKeys(): Iterable<Key>;
+  getItem(key: Key): CollectionNode<T> | null;
+  at(index: number): CollectionNode<T> | null;
+  getKeyBefore(key: Key): Key | null;
+  getKeyAfter(key: Key): Key | null;
+  getFirstKey(): Key | null;
+  getLastKey(): Key | null;
+  getChildren(key: Key): Iterable<CollectionNode<T>>;
+  getTextValue(key: Key): string;
+  /**
+   * Get all items (excluding sections, including items within sections).
+   */
+  private getAllItems;
 }
 /**
  * Create a collection from an array of items.
  */
-export declare function createListCollection<T>(items: T[], options?: {
+export declare function createListCollection<T>(
+  items: T[],
+  options?: {
     getKey?: (item: T, index: number) => Key;
     getTextValue?: (item: T) => string;
     getDisabled?: (item: T) => boolean;
-}): ListCollection<T>;
-//# sourceMappingURL=ListCollection.d.ts.map
+  },
+): ListCollection<T>;
+//# sourceMappingURL=ListCollection.d.ts.map

package/src/collections/ListCollection.ts

@@ -3,7 +3,7 @@
  * Provides a Collection interface over an array of nodes.
  */
 
-import type { Collection, CollectionItemLike, CollectionNode, Key } from './types';
+import type { Collection, CollectionItemLike, CollectionNode, Key } from "./types";
 
 /**
  * A basic implementation of Collection for list-based components.
@@ -87,7 +87,7 @@ export class ListCollection<T = unknown> implements Collection<T> {
   }
 
   getTextValue(key: Key): string {
-    return this.getItem(key)?.textValue ?? '';
+    return this.getItem(key)?.textValue ?? "";
   }
 
   /**
@@ -98,9 +98,9 @@ export class ListCollection<T = unknown> implements Collection<T> {
 
     const addItems = (nodes: CollectionNode<T>[]) => {
       for (const node of nodes) {
-        if (node.type === 'item') {
+        if (node.type === "item") {
           items.push(node);
-        } else if (node.type === 'section' && node.childNodes) {
+        } else if (node.type === "section" && node.childNodes) {
           addItems(node.childNodes);
         }
       }
@@ -120,7 +120,7 @@ export function createListCollection<T>(
     getKey?: (item: T, index: number) => Key;
     getTextValue?: (item: T) => string;
     getDisabled?: (item: T) => boolean;
-  } = {}
+  } = {},
 ): ListCollection<T> {
   const {
     getKey = (item: T, index: number) => {
@@ -135,7 +135,7 @@ export function createListCollection<T>(
   } = options;
 
   const nodes: CollectionNode<T>[] = items.map((item, index) => ({
-    type: 'item' as const,
+    type: "item" as const,
     key: getKey(item, index),
     value: item,
     textValue: getTextValue(item),

package/src/collections/createListState.d.ts

@@ -3,77 +3,92 @@
  * Combines collection and selection state.
  * Based on @react-stately/list.
  */
-import { type Accessor } from 'solid-js';
-import { type MaybeAccessor } from '../utils';
-import { type SelectionState } from './createSelectionState';
-import type { Collection, CollectionNode, DisabledBehavior, FocusStrategy, Key, SelectionBehavior, SelectionMode } from './types';
+import { type Accessor } from "solid-js";
+import { type MaybeAccessor } from "../utils";
+import { type SelectionState } from "./createSelectionState";
+import type {
+  Collection,
+  CollectionNode,
+  DisabledBehavior,
+  FocusStrategy,
+  Key,
+  SelectionBehavior,
+  SelectionMode,
+} from "./types";
 export interface ListStateProps<T = unknown> {
-    /** The items in the list (for dynamic rendering). */
-    items?: T[];
-    /** Function to get a key from an item. */
-    getKey?: (item: T) => Key;
-    /** Function to get text value from an item. */
-    getTextValue?: (item: T) => string;
-    /** Function to check if an item is disabled. */
-    getDisabled?: (item: T) => boolean;
-    /** Keys of disabled items. */
-    disabledKeys?: Iterable<Key>;
-    /** How disabled keys behave. */
-    disabledBehavior?: DisabledBehavior;
-    /** The selection mode. */
-    selectionMode?: SelectionMode;
-    /** How selection behaves on interaction. */
-    selectionBehavior?: SelectionBehavior;
-    /** Whether empty selection is disallowed. */
-    disallowEmptySelection?: boolean;
-    /** Currently selected keys (controlled). */
-    selectedKeys?: 'all' | Iterable<Key>;
-    /** Default selected keys (uncontrolled). */
-    defaultSelectedKeys?: 'all' | Iterable<Key>;
-    /** Handler for selection changes. */
-    onSelectionChange?: (keys: 'all' | Set<Key>) => void;
-    /** Whether to allow duplicate selection events. */
-    allowDuplicateSelectionEvents?: boolean;
+  /** The items in the list (for dynamic rendering). */
+  items?: T[];
+  /** Function to get a key from an item. */
+  getKey?: (item: T) => Key;
+  /** Function to get text value from an item. */
+  getTextValue?: (item: T) => string;
+  /** Function to check if an item is disabled. */
+  getDisabled?: (item: T) => boolean;
+  /** Keys of disabled items. */
+  disabledKeys?: Iterable<Key>;
+  /** How disabled keys behave. */
+  disabledBehavior?: DisabledBehavior;
+  /** The selection mode. */
+  selectionMode?: SelectionMode;
+  /** How selection behaves on interaction. */
+  selectionBehavior?: SelectionBehavior;
+  /** Whether empty selection is disallowed. */
+  disallowEmptySelection?: boolean;
+  /** Currently selected keys (controlled). */
+  selectedKeys?: "all" | Iterable<Key>;
+  /** Default selected keys (uncontrolled). */
+  defaultSelectedKeys?: "all" | Iterable<Key>;
+  /** Handler for selection changes. */
+  onSelectionChange?: (keys: "all" | Set<Key>) => void;
+  /** Whether to allow duplicate selection events. */
+  allowDuplicateSelectionEvents?: boolean;
 }
 export interface ListState<T = unknown> extends SelectionState {
-    /** The collection of items. */
-    readonly collection: Accessor<Collection<T>>;
-    /** Whether the collection is focused. */
-    readonly isFocused: Accessor<boolean>;
-    /** Set the focused state. */
-    setFocused(isFocused: boolean): void;
-    /** The currently focused key. */
-    readonly focusedKey: Accessor<Key | null>;
-    /** Set the focused key. */
-    setFocusedKey(key: Key | null, childStrategy?: FocusStrategy): void;
-    /** The child focus strategy. */
-    readonly childFocusStrategy: Accessor<FocusStrategy | null>;
+  /** The collection of items. */
+  readonly collection: Accessor<Collection<T>>;
+  /** Whether the collection is focused. */
+  readonly isFocused: Accessor<boolean>;
+  /** Set the focused state. */
+  setFocused(isFocused: boolean): void;
+  /** The currently focused key. */
+  readonly focusedKey: Accessor<Key | null>;
+  /** Set the focused key. */
+  setFocusedKey(key: Key | null, childStrategy?: FocusStrategy): void;
+  /** The child focus strategy. */
+  readonly childFocusStrategy: Accessor<FocusStrategy | null>;
 }
 /**
  * Creates state for a list component with selection.
  */
-export declare function createListState<T = unknown>(props: MaybeAccessor<ListStateProps<T>>): ListState<T>;
+export declare function createListState<T = unknown>(
+  props: MaybeAccessor<ListStateProps<T>>,
+): ListState<T>;
 /**
  * Props for single selection list state.
  */
-export interface SingleSelectListStateProps<T = unknown> extends Omit<ListStateProps<T>, 'selectionMode' | 'selectedKeys' | 'defaultSelectedKeys' | 'onSelectionChange'> {
-    /** The currently selected key (controlled). */
-    selectedKey?: Key | null;
-    /** The default selected key (uncontrolled). */
-    defaultSelectedKey?: Key;
-    /** Handler for selection changes. */
-    onSelectionChange?: (key: Key | null) => void;
+export interface SingleSelectListStateProps<T = unknown> extends Omit<
+  ListStateProps<T>,
+  "selectionMode" | "selectedKeys" | "defaultSelectedKeys" | "onSelectionChange"
+> {
+  /** The currently selected key (controlled). */
+  selectedKey?: Key | null;
+  /** The default selected key (uncontrolled). */
+  defaultSelectedKey?: Key;
+  /** Handler for selection changes. */
+  onSelectionChange?: (key: Key | null) => void;
 }
 export interface SingleSelectListState<T = unknown> extends ListState<T> {
-    /** The currently selected key. */
-    readonly selectedKey: Accessor<Key | null>;
-    /** Set the selected key. */
-    setSelectedKey(key: Key | null): void;
-    /** The currently selected item. */
-    readonly selectedItem: Accessor<CollectionNode<T> | null>;
+  /** The currently selected key. */
+  readonly selectedKey: Accessor<Key | null>;
+  /** Set the selected key. */
+  setSelectedKey(key: Key | null): void;
+  /** The currently selected item. */
+  readonly selectedItem: Accessor<CollectionNode<T> | null>;
 }
 /**
  * Creates state for a single-select list component.
  */
-export declare function createSingleSelectListState<T = unknown>(props: MaybeAccessor<SingleSelectListStateProps<T>>): SingleSelectListState<T>;
-//# sourceMappingURL=createListState.d.ts.map
+export declare function createSingleSelectListState<T = unknown>(
+  props: MaybeAccessor<SingleSelectListStateProps<T>>,
+): SingleSelectListState<T>;
+//# sourceMappingURL=createListState.d.ts.map

package/src/collections/createListState.ts

@@ -4,10 +4,10 @@
  * Based on @react-stately/list.
  */
 
-import { createSignal, createMemo, type Accessor } from 'solid-js';
-import { access, type MaybeAccessor } from '../utils';
-import { ListCollection } from './ListCollection';
-import { createSelectionState, type SelectionState } from './createSelectionState';
+import { createSignal, createMemo, type Accessor } from "solid-js";
+import { access, type MaybeAccessor } from "../utils";
+import { ListCollection } from "./ListCollection";
+import { createSelectionState, type SelectionState } from "./createSelectionState";
 import type {
   Collection,
   CollectionItemLike,
@@ -17,7 +17,7 @@ import type {
   Key,
   SelectionBehavior,
   SelectionMode,
-} from './types';
+} from "./types";
 
 export interface ListStateProps<T = unknown> {
   /** The items in the list (for dynamic rendering). */
@@ -39,11 +39,11 @@ export interface ListStateProps<T = unknown> {
   /** Whether empty selection is disallowed. */
   disallowEmptySelection?: boolean;
   /** Currently selected keys (controlled). */
-  selectedKeys?: 'all' | Iterable<Key>;
+  selectedKeys?: "all" | Iterable<Key>;
   /** Default selected keys (uncontrolled). */
-  defaultSelectedKeys?: 'all' | Iterable<Key>;
+  defaultSelectedKeys?: "all" | Iterable<Key>;
   /** Handler for selection changes. */
-  onSelectionChange?: (keys: 'all' | Set<Key>) => void;
+  onSelectionChange?: (keys: "all" | Set<Key>) => void;
   /** Whether to allow duplicate selection events. */
   allowDuplicateSelectionEvents?: boolean;
 }
@@ -67,7 +67,7 @@ export interface ListState<T = unknown> extends SelectionState {
  * Creates state for a list component with selection.
  */
 export function createListState<T = unknown>(
-  props: MaybeAccessor<ListStateProps<T>>
+  props: MaybeAccessor<ListStateProps<T>>,
 ): ListState<T> {
   const getProps = () => access(props);
 
@@ -79,12 +79,11 @@ export function createListState<T = unknown>(
     const nodes: CollectionNode<T>[] = items.map((item, index) => {
       const o = item as CollectionItemLike;
       const key = p.getKey?.(item) ?? o.key ?? o.id ?? index;
-      const textValue =
-        p.getTextValue?.(item) ?? o.textValue ?? o.label ?? String(item);
+      const textValue = p.getTextValue?.(item) ?? o.textValue ?? o.label ?? String(item);
       const isDisabled = p.getDisabled?.(item) ?? o.isDisabled ?? false;
 
       return {
-        type: 'item' as const,
+        type: "item" as const,
         key,
         value: item,
         textValue,
@@ -172,8 +171,10 @@ export function createListState<T = unknown>(
 /**
  * Props for single selection list state.
  */
-export interface SingleSelectListStateProps<T = unknown>
-  extends Omit<ListStateProps<T>, 'selectionMode' | 'selectedKeys' | 'defaultSelectedKeys' | 'onSelectionChange'> {
+export interface SingleSelectListStateProps<T = unknown> extends Omit<
+  ListStateProps<T>,
+  "selectionMode" | "selectedKeys" | "defaultSelectedKeys" | "onSelectionChange"
+> {
   /** The currently selected key (controlled). */
   selectedKey?: Key | null;
   /** The default selected key (uncontrolled). */
@@ -195,7 +196,7 @@ export interface SingleSelectListState<T = unknown> extends ListState<T> {
  * Creates state for a single-select list component.
  */
 export function createSingleSelectListState<T = unknown>(
-  props: MaybeAccessor<SingleSelectListStateProps<T>>
+  props: MaybeAccessor<SingleSelectListStateProps<T>>,
 ): SingleSelectListState<T> {
   const getProps = () => access(props);
 
@@ -219,7 +220,7 @@ export function createSingleSelectListState<T = unknown>(
     get disabledBehavior() {
       return getProps().disabledBehavior;
     },
-    selectionMode: 'single',
+    selectionMode: "single",
     disallowEmptySelection: true,
     allowDuplicateSelectionEvents: true,
     get selectedKeys() {
@@ -231,7 +232,7 @@ export function createSingleSelectListState<T = unknown>(
       return key != null ? [key] : undefined;
     },
     onSelectionChange(keys) {
-      if (keys === 'all') return;
+      if (keys === "all") return;
       const key = keys.values().next().value ?? null;
       getProps().onSelectionChange?.(key);
     },
@@ -239,7 +240,7 @@ export function createSingleSelectListState<T = unknown>(
 
   const selectedKey: Accessor<Key | null> = () => {
     const keys = listState.selectedKeys();
-    if (keys === 'all') return null;
+    if (keys === "all") return null;
     return keys.values().next().value ?? null;
   };