@proyecto-viviana/solid-stately 0.2.4 → 0.3.0

package/src/tooltip/createTooltipTriggerState.ts

@@ -1,183 +1,184 @@
-/**
- * Manages state for a tooltip trigger.
- * Based on @react-stately/tooltip useTooltipTriggerState.
- *
- * 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 { 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;
-const TOOLTIP_COOLDOWN = 500;
-
-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;
-}
-
-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;
-}
-
-// Global state for coordinating tooltips
-let tooltips: Record<string, (immediate?: boolean) => void> = {};
-let tooltipId = 0;
-let globalWarmedUp = false;
-let globalWarmUpTimeout: ReturnType<typeof setTimeout> | null = null;
-let globalCooldownTimeout: ReturnType<typeof setTimeout> | null = null;
-
-/**
- * Resets the global tooltip state. Useful for testing.
- * @internal
- */
-export function resetTooltipState(): void {
-  tooltips = {};
-  tooltipId = 0;
-  globalWarmedUp = false;
-  if (globalWarmUpTimeout) {
-    clearTimeout(globalWarmUpTimeout);
-    globalWarmUpTimeout = null;
-  }
-  if (globalCooldownTimeout) {
-    clearTimeout(globalCooldownTimeout);
-    globalCooldownTimeout = null;
-  }
-}
-
-/**
- * Manages state for a tooltip trigger. 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.
- */
-export function createTooltipTriggerState(
-  props: TooltipTriggerProps = {}
-): TooltipTriggerState {
-  const delay = () => props.delay ?? TOOLTIP_DELAY;
-  const closeDelay = () => props.closeDelay ?? TOOLTIP_COOLDOWN;
-
-  const overlayState = createOverlayTriggerState(props);
-  const id = `tooltip-${++tooltipId}`;
-
-  let closeTimeout: ReturnType<typeof setTimeout> | null = null;
-  const [closeCallback, setCloseCallback] = createSignal<() => void>(() => overlayState.close());
-
-  const ensureTooltipEntry = () => {
-    tooltips[id] = hideTooltip;
-  };
-
-  const closeOpenTooltips = () => {
-    for (const hideTooltipId in tooltips) {
-      if (hideTooltipId !== id) {
-        tooltips[hideTooltipId](true);
-        delete tooltips[hideTooltipId];
-      }
-    }
-  };
-
-  const showTooltip = () => {
-    if (closeTimeout) {
-      clearTimeout(closeTimeout);
-      closeTimeout = null;
-    }
-    closeOpenTooltips();
-    ensureTooltipEntry();
-    globalWarmedUp = true;
-    overlayState.open();
-
-    if (globalWarmUpTimeout) {
-      clearTimeout(globalWarmUpTimeout);
-      globalWarmUpTimeout = null;
-    }
-    if (globalCooldownTimeout) {
-      clearTimeout(globalCooldownTimeout);
-      globalCooldownTimeout = null;
-    }
-  };
-
-  const hideTooltip = (immediate?: boolean) => {
-    if (immediate || closeDelay() <= 0) {
-      if (closeTimeout) {
-        clearTimeout(closeTimeout);
-        closeTimeout = null;
-      }
-      closeCallback()();
-    } else if (!closeTimeout) {
-      closeTimeout = setTimeout(() => {
-        closeTimeout = null;
-        closeCallback()();
-      }, closeDelay());
-    }
-
-    if (globalWarmUpTimeout) {
-      clearTimeout(globalWarmUpTimeout);
-      globalWarmUpTimeout = null;
-    }
-
-    if (globalWarmedUp) {
-      if (globalCooldownTimeout) {
-        clearTimeout(globalCooldownTimeout);
-      }
-      globalCooldownTimeout = setTimeout(() => {
-        delete tooltips[id];
-        globalCooldownTimeout = null;
-        globalWarmedUp = false;
-      }, Math.max(TOOLTIP_COOLDOWN, closeDelay()));
-    }
-  };
-
-  const warmupTooltip = () => {
-    closeOpenTooltips();
-    ensureTooltipEntry();
-
-    if (!overlayState.isOpen() && !globalWarmUpTimeout && !globalWarmedUp) {
-      globalWarmUpTimeout = setTimeout(() => {
-        globalWarmUpTimeout = null;
-        globalWarmedUp = true;
-        showTooltip();
-      }, delay());
-    } else if (!overlayState.isOpen()) {
-      showTooltip();
-    }
-  };
-
-  // Update close callback when overlayState.close changes
-  setCloseCallback(() => overlayState.close);
-
-  // Cleanup on unmount
-  onCleanup(() => {
-    if (closeTimeout) {
-      clearTimeout(closeTimeout);
-    }
-    if (tooltips[id]) {
-      delete tooltips[id];
-    }
-  });
-
-  return {
-    isOpen: overlayState.isOpen,
-    open: (immediate?: boolean) => {
-      if (isServer) return;
-      if (!immediate && delay() > 0 && !closeTimeout) {
-        warmupTooltip();
-      } else {
-        showTooltip();
-      }
-    },
-    close: hideTooltip,
-  };
-}
+/**
+ * Manages state for a tooltip trigger.
+ * Based on @react-stately/tooltip useTooltipTriggerState.
+ *
+ * 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 { 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;
+const TOOLTIP_COOLDOWN = 500;
+
+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;
+}
+
+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;
+}
+
+// Global state for coordinating tooltips
+let tooltips: Record<string, (immediate?: boolean) => void> = {};
+let tooltipId = 0;
+let globalWarmedUp = false;
+let globalWarmUpTimeout: ReturnType<typeof setTimeout> | null = null;
+let globalCooldownTimeout: ReturnType<typeof setTimeout> | null = null;
+
+/**
+ * Resets the global tooltip state. Useful for testing.
+ * @internal
+ */
+export function resetTooltipState(): void {
+  tooltips = {};
+  tooltipId = 0;
+  globalWarmedUp = false;
+  if (globalWarmUpTimeout) {
+    clearTimeout(globalWarmUpTimeout);
+    globalWarmUpTimeout = null;
+  }
+  if (globalCooldownTimeout) {
+    clearTimeout(globalCooldownTimeout);
+    globalCooldownTimeout = null;
+  }
+}
+
+/**
+ * Manages state for a tooltip trigger. 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.
+ */
+export function createTooltipTriggerState(props: TooltipTriggerProps = {}): TooltipTriggerState {
+  const delay = () => props.delay ?? TOOLTIP_DELAY;
+  const closeDelay = () => props.closeDelay ?? TOOLTIP_COOLDOWN;
+
+  const overlayState = createOverlayTriggerState(props);
+  const id = `tooltip-${++tooltipId}`;
+
+  let closeTimeout: ReturnType<typeof setTimeout> | null = null;
+  const [closeCallback, setCloseCallback] = createSignal<() => void>(() => overlayState.close());
+
+  const ensureTooltipEntry = () => {
+    tooltips[id] = hideTooltip;
+  };
+
+  const closeOpenTooltips = () => {
+    for (const hideTooltipId in tooltips) {
+      if (hideTooltipId !== id) {
+        tooltips[hideTooltipId](true);
+        delete tooltips[hideTooltipId];
+      }
+    }
+  };
+
+  const showTooltip = () => {
+    if (closeTimeout) {
+      clearTimeout(closeTimeout);
+      closeTimeout = null;
+    }
+    closeOpenTooltips();
+    ensureTooltipEntry();
+    globalWarmedUp = true;
+    overlayState.open();
+
+    if (globalWarmUpTimeout) {
+      clearTimeout(globalWarmUpTimeout);
+      globalWarmUpTimeout = null;
+    }
+    if (globalCooldownTimeout) {
+      clearTimeout(globalCooldownTimeout);
+      globalCooldownTimeout = null;
+    }
+  };
+
+  const hideTooltip = (immediate?: boolean) => {
+    if (immediate || closeDelay() <= 0) {
+      if (closeTimeout) {
+        clearTimeout(closeTimeout);
+        closeTimeout = null;
+      }
+      closeCallback()();
+    } else if (!closeTimeout) {
+      closeTimeout = setTimeout(() => {
+        closeTimeout = null;
+        closeCallback()();
+      }, closeDelay());
+    }
+
+    if (globalWarmUpTimeout) {
+      clearTimeout(globalWarmUpTimeout);
+      globalWarmUpTimeout = null;
+    }
+
+    if (globalWarmedUp) {
+      if (globalCooldownTimeout) {
+        clearTimeout(globalCooldownTimeout);
+      }
+      globalCooldownTimeout = setTimeout(
+        () => {
+          delete tooltips[id];
+          globalCooldownTimeout = null;
+          globalWarmedUp = false;
+        },
+        Math.max(TOOLTIP_COOLDOWN, closeDelay()),
+      );
+    }
+  };
+
+  const warmupTooltip = () => {
+    closeOpenTooltips();
+    ensureTooltipEntry();
+
+    if (!overlayState.isOpen() && !globalWarmUpTimeout && !globalWarmedUp) {
+      globalWarmUpTimeout = setTimeout(() => {
+        globalWarmUpTimeout = null;
+        globalWarmedUp = true;
+        showTooltip();
+      }, delay());
+    } else if (!overlayState.isOpen()) {
+      showTooltip();
+    }
+  };
+
+  // Update close callback when overlayState.close changes
+  setCloseCallback(() => overlayState.close);
+
+  // Cleanup on unmount
+  onCleanup(() => {
+    if (closeTimeout) {
+      clearTimeout(closeTimeout);
+    }
+    if (tooltips[id]) {
+      delete tooltips[id];
+    }
+  });
+
+  return {
+    isOpen: overlayState.isOpen,
+    open: (immediate?: boolean) => {
+      if (isServer) return;
+      if (!immediate && delay() > 0 && !closeTimeout) {
+        warmupTooltip();
+      } else {
+        showTooltip();
+      }
+    },
+    close: hideTooltip,
+  };
+}

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

@@ -1,6 +1,6 @@
-export {
-  createTooltipTriggerState,
-  resetTooltipState,
-  type TooltipTriggerProps,
-  type TooltipTriggerState,
-} from './createTooltipTriggerState';
+export {
+  createTooltipTriggerState,
+  resetTooltipState,
+  type TooltipTriggerProps,
+  type TooltipTriggerState,
+} 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