@proyecto-viviana/solid-stately 0.2.7 → 0.3.0

package/src/toggle/createToggleState.d.ts

@@ -5,30 +5,30 @@
  *
  * This is a 1:1 port of @react-stately/toggle's useToggleState.
  */
-import { Accessor } from 'solid-js';
-import { type MaybeAccessor } from '../utils';
+import { Accessor } from "solid-js";
+import { type MaybeAccessor } from "../utils";
 export interface ToggleStateOptions {
-    /** Whether the element should be selected (controlled). */
-    isSelected?: boolean;
-    /** Whether the element should be selected by default (uncontrolled). */
-    defaultSelected?: boolean;
-    /** Handler that is called when the element's selection state changes. */
-    onChange?: (isSelected: boolean) => void;
-    /** Whether the element is read only. */
-    isReadOnly?: boolean;
+  /** Whether the element should be selected (controlled). */
+  isSelected?: boolean;
+  /** Whether the element should be selected by default (uncontrolled). */
+  defaultSelected?: boolean;
+  /** Handler that is called when the element's selection state changes. */
+  onChange?: (isSelected: boolean) => void;
+  /** Whether the element is read only. */
+  isReadOnly?: boolean;
 }
 export interface ToggleState {
-    /** Whether the toggle is selected. */
-    readonly isSelected: Accessor<boolean>;
-    /** Whether the toggle is selected by default. */
-    readonly defaultSelected: boolean;
-    /** Updates selection state. */
-    setSelected(isSelected: boolean): void;
-    /** Toggle the selection state. */
-    toggle(): void;
+  /** Whether the toggle is selected. */
+  readonly isSelected: Accessor<boolean>;
+  /** Whether the toggle is selected by default. */
+  readonly defaultSelected: boolean;
+  /** Updates selection state. */
+  setSelected(isSelected: boolean): void;
+  /** Toggle the selection state. */
+  toggle(): void;
 }
 /**
  * Provides state management for toggle components like checkboxes and switches.
  */
 export declare function createToggleState(props?: MaybeAccessor<ToggleStateOptions>): ToggleState;
-//# sourceMappingURL=createToggleState.d.ts.map
+//# sourceMappingURL=createToggleState.d.ts.map

package/src/toggle/createToggleState.ts

@@ -6,12 +6,8 @@
  * This is a 1:1 port of @react-stately/toggle's useToggleState.
  */
 
-import { createSignal, Accessor } from 'solid-js';
-import { type MaybeAccessor, access } from '../utils';
-
-// ============================================
-// TYPES
-// ============================================
+import { createSignal, Accessor } from "solid-js";
+import { type MaybeAccessor, access } from "../utils";
 
 export interface ToggleStateOptions {
   /** Whether the element should be selected (controlled). */
@@ -35,33 +31,24 @@ export interface ToggleState {
   toggle(): void;
 }
 
-// ============================================
-// IMPLEMENTATION
-// ============================================
-
 /**
  * Provides state management for toggle components like checkboxes and switches.
  */
 export function createToggleState(props: MaybeAccessor<ToggleStateOptions> = {}): ToggleState {
   const getProps = () => access(props);
 
-  // Get initial values
   const initialProps = getProps();
   const initialSelected = initialProps.isSelected ?? initialProps.defaultSelected ?? false;
 
-  // Create internal signal for uncontrolled mode
   const [internalSelected, setInternalSelected] = createSignal(initialSelected);
 
-  // Determine if controlled
   const isControlled = () => getProps().isSelected !== undefined;
 
-  // Get current selection state
   const isSelected: Accessor<boolean> = () => {
     const p = getProps();
     return isControlled() ? (p.isSelected ?? false) : internalSelected();
   };
 
-  // Update selection state
   function setSelected(value: boolean): void {
     const p = getProps();
     if (p.isReadOnly) {
@@ -75,7 +62,6 @@ export function createToggleState(props: MaybeAccessor<ToggleStateOptions> = {})
     p.onChange?.(value);
   }
 
-  // Toggle selection state
   function toggle(): void {
     const p = getProps();
     if (p.isReadOnly) {

package/src/toggle/index.d.ts

@@ -1,2 +1,2 @@
-export { createToggleState, type ToggleStateOptions, type ToggleState, } from './createToggleState';
-//# sourceMappingURL=index.d.ts.map
+export { createToggleState, type ToggleStateOptions, type ToggleState } from "./createToggleState";
+//# sourceMappingURL=index.d.ts.map

package/src/toggle/index.ts

@@ -1,11 +1,7 @@
-export {
-  createToggleState,
-  type ToggleStateOptions,
-  type ToggleState,
-} from './createToggleState';
+export { createToggleState, type ToggleStateOptions, type ToggleState } from "./createToggleState";
 
 export {
   createToggleGroupState,
   type ToggleGroupProps,
   type ToggleGroupState,
-} from './createToggleGroupState';
+} from "./createToggleGroupState";

package/src/tooltip/createTooltipTriggerState.d.ts

@@ -5,25 +5,25 @@
  * Tracks whether the tooltip is open, and provides methods to toggle this state.
  * Ensures only one tooltip is open at a time and controls the delay for showing a tooltip.
  */
-import { type Accessor } from 'solid-js';
-import { type OverlayTriggerProps } from '../overlays';
+import { type Accessor } from "solid-js";
+import { type OverlayTriggerProps } from "../overlays";
 export interface TooltipTriggerProps extends OverlayTriggerProps {
-    /** The delay time in milliseconds for the tooltip to show up. */
-    delay?: number;
-    /** The delay time in milliseconds for the tooltip to close. */
-    closeDelay?: number;
+  /** The delay time in milliseconds for the tooltip to show up. */
+  delay?: number;
+  /** The delay time in milliseconds for the tooltip to close. */
+  closeDelay?: number;
 }
 export interface TooltipTriggerState {
-    /** Whether the tooltip is currently showing. */
-    readonly isOpen: Accessor<boolean>;
-    /**
-     * Shows the tooltip. By default, the tooltip becomes visible after a delay
-     * depending on a global warmup timer. The `immediate` option shows the
-     * tooltip immediately instead.
-     */
-    open(immediate?: boolean): void;
-    /** Hides the tooltip. */
-    close(immediate?: boolean): void;
+  /** Whether the tooltip is currently showing. */
+  readonly isOpen: Accessor<boolean>;
+  /**
+   * Shows the tooltip. By default, the tooltip becomes visible after a delay
+   * depending on a global warmup timer. The `immediate` option shows the
+   * tooltip immediately instead.
+   */
+  open(immediate?: boolean): void;
+  /** Hides the tooltip. */
+  close(immediate?: boolean): void;
 }
 /**
  * Resets the global tooltip state. Useful for testing.
@@ -36,4 +36,4 @@ export declare function resetTooltipState(): void;
  * the delay for showing a tooltip.
  */
 export declare function createTooltipTriggerState(props?: TooltipTriggerProps): TooltipTriggerState;
-//# sourceMappingURL=createTooltipTriggerState.d.ts.map
+//# sourceMappingURL=createTooltipTriggerState.d.ts.map

package/src/tooltip/createTooltipTriggerState.ts

@@ -6,9 +6,9 @@
  * Ensures only one tooltip is open at a time and controls the delay for showing a tooltip.
  */
 
-import { createSignal, onCleanup, type Accessor } from 'solid-js';
-import { createOverlayTriggerState, type OverlayTriggerProps } from '../overlays';
-import { isServer } from '../ssr';
+import { createSignal, onCleanup, type Accessor } from "solid-js";
+import { createOverlayTriggerState, type OverlayTriggerProps } from "../overlays";
+import { isServer } from "../ssr";
 
 // Default delays (in ms)
 const TOOLTIP_DELAY = 1500;
@@ -64,9 +64,7 @@ export function resetTooltipState(): void {
  * methods to toggle this state. Ensures only one tooltip is open at a time and controls
  * the delay for showing a tooltip.
  */
-export function createTooltipTriggerState(
-  props: TooltipTriggerProps = {}
-): TooltipTriggerState {
+export function createTooltipTriggerState(props: TooltipTriggerProps = {}): TooltipTriggerState {
   const delay = () => props.delay ?? TOOLTIP_DELAY;
   const closeDelay = () => props.closeDelay ?? TOOLTIP_COOLDOWN;
 
@@ -132,11 +130,14 @@ export function createTooltipTriggerState(
       if (globalCooldownTimeout) {
         clearTimeout(globalCooldownTimeout);
       }
-      globalCooldownTimeout = setTimeout(() => {
-        delete tooltips[id];
-        globalCooldownTimeout = null;
-        globalWarmedUp = false;
-      }, Math.max(TOOLTIP_COOLDOWN, closeDelay()));
+      globalCooldownTimeout = setTimeout(
+        () => {
+          delete tooltips[id];
+          globalCooldownTimeout = null;
+          globalWarmedUp = false;
+        },
+        Math.max(TOOLTIP_COOLDOWN, closeDelay()),
+      );
     }
   };
 

package/src/tooltip/index.d.ts

@@ -1,2 +1,7 @@
-export { createTooltipTriggerState, resetTooltipState, type TooltipTriggerProps, type TooltipTriggerState, } from './createTooltipTriggerState';
-//# sourceMappingURL=index.d.ts.map
+export {
+  createTooltipTriggerState,
+  resetTooltipState,
+  type TooltipTriggerProps,
+  type TooltipTriggerState,
+} from "./createTooltipTriggerState";
+//# sourceMappingURL=index.d.ts.map

package/src/tooltip/index.ts

@@ -3,4 +3,4 @@ export {
   resetTooltipState,
   type TooltipTriggerProps,
   type TooltipTriggerState,
-} from './createTooltipTriggerState';
+} from "./createTooltipTriggerState";

package/src/tree/TreeCollection.d.ts

@@ -5,36 +5,39 @@
  * A flattened view of tree nodes that respects expanded state.
  * Only visible nodes (root + expanded children) are included in iteration.
  */
-import type { Key } from '../collections/types';
-import type { TreeCollection as ITreeCollection, TreeNode, TreeItemData } from './types';
+import type { Key } from "../collections/types";
+import type { TreeCollection as ITreeCollection, TreeNode, TreeItemData } from "./types";
 /**
  * Creates a TreeCollection from hierarchical data.
  * The collection is flattened based on expanded keys.
  */
 export declare class TreeCollection<T> implements ITreeCollection<T> {
-    private keyMap;
-    private visibleKeys;
-    private _rows;
-    constructor(items: TreeItemData<T>[], expandedKeys: Set<Key>);
-    private buildCollection;
-    get size(): number;
-    get rows(): TreeNode<T>[];
-    get rowCount(): number;
-    getKeys(): Iterable<Key>;
-    getItem(key: Key): TreeNode<T> | null;
-    at(index: number): TreeNode<T> | null;
-    getKeyBefore(key: Key): Key | null;
-    getKeyAfter(key: Key): Key | null;
-    getFirstKey(): Key | null;
-    getLastKey(): Key | null;
-    getChildren(key: Key): Iterable<TreeNode<T>>;
-    getTextValue(key: Key): string;
-    getParentKey(key: Key): Key | null;
-    [Symbol.iterator](): Iterator<TreeNode<T>>;
+  private keyMap;
+  private visibleKeys;
+  private _rows;
+  constructor(items: TreeItemData<T>[], expandedKeys: Set<Key>);
+  private buildCollection;
+  get size(): number;
+  get rows(): TreeNode<T>[];
+  get rowCount(): number;
+  getKeys(): Iterable<Key>;
+  getItem(key: Key): TreeNode<T> | null;
+  at(index: number): TreeNode<T> | null;
+  getKeyBefore(key: Key): Key | null;
+  getKeyAfter(key: Key): Key | null;
+  getFirstKey(): Key | null;
+  getLastKey(): Key | null;
+  getChildren(key: Key): Iterable<TreeNode<T>>;
+  getTextValue(key: Key): string;
+  getParentKey(key: Key): Key | null;
+  [Symbol.iterator](): Iterator<TreeNode<T>>;
 }
 /**
  * Factory function to create a TreeCollection.
  * Useful for the collectionFactory pattern in TreeStateOptions.
  */
-export declare function createTreeCollection<T>(items: TreeItemData<T>[], expandedKeys: Set<Key>): TreeCollection<T>;
-//# sourceMappingURL=TreeCollection.d.ts.map
+export declare function createTreeCollection<T>(
+  items: TreeItemData<T>[],
+  expandedKeys: Set<Key>,
+): TreeCollection<T>;
+//# sourceMappingURL=TreeCollection.d.ts.map

package/src/tree/TreeCollection.ts

@@ -6,8 +6,16 @@
  * Only visible nodes (root + expanded children) are included in iteration.
  */
 
-import type { Key } from '../collections/types';
-import type { TreeCollection as ITreeCollection, TreeNode, TreeItemData } from './types';
+import type { Key } from "../collections/types";
+import type { TreeCollection as ITreeCollection, TreeNode, TreeItemData } from "./types";
+
+function getItemKey<T>(item: TreeItemData<T>): Key {
+  const key = item.key ?? item.id;
+  if (key == null) {
+    throw new Error("Tree items must define either a key or id.");
+  }
+  return key;
+}
 
 /**
  * Creates a TreeCollection from hierarchical data.
@@ -19,10 +27,7 @@ export class TreeCollection<T> implements ITreeCollection<T> {
   private firstKey: Key | null = null;
   private lastKey: Key | null = null;
 
-  constructor(
-    items: TreeItemData<T>[],
-    expandedKeys: Set<Key>
-  ) {
+  constructor(items: TreeItemData<T>[], expandedKeys: Set<Key>) {
     this.buildCollection(items, expandedKeys);
   }
 
@@ -34,25 +39,27 @@ export class TreeCollection<T> implements ITreeCollection<T> {
       item: TreeItemData<T>,
       level: number,
       parentKey: Key | null,
-      indexInParent: number
+      indexInParent: number,
     ): TreeNode<T> => {
-      const hasChildren = item.children && item.children.length > 0;
-      const isExpanded = hasChildren && expandedKeys.has(item.key);
+      const key = getItemKey(item);
+      const hasLoadedChildren = Boolean(item.children && item.children.length > 0);
+      const hasChildren = hasLoadedChildren || !!item.hasChildItems;
+      const isExpanded = hasChildren && expandedKeys.has(key);
 
       // Build child nodes first (even if not visible, for the map)
       const childNodes: TreeNode<T>[] = [];
-      if (hasChildren && item.children) {
+      if (hasLoadedChildren && item.children) {
         for (let i = 0; i < item.children.length; i++) {
-          const childNode = visit(item.children[i], level + 1, item.key, i);
+          const childNode = visit(item.children[i], level + 1, key, i);
           childNodes.push(childNode);
         }
       }
 
       const node: TreeNode<T> = {
-        type: 'item',
-        key: item.key,
-        value: item.value,
-        textValue: item.textValue || String(item.key),
+        type: "item",
+        key,
+        value: (item.value ?? item) as T,
+        textValue: item.textValue || String(key),
         level,
         index: indexInParent,
         parentKey,
@@ -64,7 +71,7 @@ export class TreeCollection<T> implements ITreeCollection<T> {
       };
 
       // Always add to keyMap (for getItem lookups)
-      this.keyMap.set(item.key, node);
+      this.keyMap.set(key, node);
 
       return node;
     };
@@ -136,7 +143,7 @@ export class TreeCollection<T> implements ITreeCollection<T> {
     while (previousKey != null) {
       const candidate = this.keyMap.get(previousKey);
       if (!candidate) break;
-      if (candidate.type !== 'content') {
+      if (candidate.type !== "content") {
         return candidate.key;
       }
       previousKey = candidate.prevKey ?? null;
@@ -150,7 +157,7 @@ export class TreeCollection<T> implements ITreeCollection<T> {
     while (nextKey != null) {
       const candidate = this.keyMap.get(nextKey);
       if (!candidate) break;
-      if (candidate.type !== 'content') {
+      if (candidate.type !== "content") {
         return candidate.key;
       }
       nextKey = candidate.nextKey ?? null;
@@ -161,7 +168,7 @@ export class TreeCollection<T> implements ITreeCollection<T> {
   getFirstKey(): Key | null {
     if (this.firstKey == null) return null;
     const candidate = this.keyMap.get(this.firstKey);
-    if (candidate?.type === 'content') {
+    if (candidate?.type === "content") {
       return this.getKeyAfter(candidate.key);
     }
     return this.firstKey;
@@ -170,7 +177,7 @@ export class TreeCollection<T> implements ITreeCollection<T> {
   getLastKey(): Key | null {
     if (this.lastKey == null) return null;
     const candidate = this.keyMap.get(this.lastKey);
-    if (candidate?.type === 'content') {
+    if (candidate?.type === "content") {
       return this.getKeyBefore(candidate.key);
     }
     return this.lastKey;
@@ -183,7 +190,7 @@ export class TreeCollection<T> implements ITreeCollection<T> {
 
   getTextValue(key: Key): string {
     const node = this.keyMap.get(key);
-    return node?.textValue ?? '';
+    return node?.textValue ?? "";
   }
 
   getParentKey(key: Key): Key | null {
@@ -202,7 +209,7 @@ export class TreeCollection<T> implements ITreeCollection<T> {
  */
 export function createTreeCollection<T>(
   items: TreeItemData<T>[],
-  expandedKeys: Set<Key>
+  expandedKeys: Set<Key>,
 ): TreeCollection<T> {
   return new TreeCollection(items, expandedKeys);
 }

package/src/tree/createTreeState.d.ts

@@ -4,11 +4,14 @@
  *
  * Manages expansion state, selection, and focus for hierarchical tree data.
  */
-import { type Accessor } from 'solid-js';
-import type { TreeState, TreeStateOptions, TreeCollection } from './types';
+import { type Accessor } from "solid-js";
+import type { TreeState, TreeStateOptions, TreeCollection } from "./types";
 /**
  * Creates state management for a tree component.
  * Handles expansion, selection, focus management, and keyboard navigation state.
  */
-export declare function createTreeState<T extends object, C extends TreeCollection<T> = TreeCollection<T>>(options: Accessor<TreeStateOptions<T, C>>): TreeState<T, C>;
-//# sourceMappingURL=createTreeState.d.ts.map
+export declare function createTreeState<
+  T extends object,
+  C extends TreeCollection<T> = TreeCollection<T>,
+>(options: Accessor<TreeStateOptions<T, C>>): TreeState<T, C>;
+//# sourceMappingURL=createTreeState.d.ts.map