@visulima/tui 0.0.1 → 1.0.0-alpha.2

package/dist/packem_shared/useMousePosition-BHBJ-kBk.js

@@ -0,0 +1,25 @@
+import { useState, useEffect } from 'react';
+import useMouseContext from './useMouseContext-D-rFy60Q.js';
+
+const useMousePosition = () => {
+  const mouse = useMouseContext();
+  const [position, setPosition] = useState({
+    x: mouse.position.x,
+    y: mouse.position.y
+  });
+  useEffect(() => {
+    const handler = (newPosition) => {
+      setPosition({
+        x: newPosition.x,
+        y: newPosition.y
+      });
+    };
+    mouse.events.on("position", handler);
+    return () => {
+      mouse.events.off("position", handler);
+    };
+  }, [mouse.events]);
+  return position;
+};
+
+export { useMousePosition as default };

package/dist/packem_shared/useOnMouseClick--ZIyBOBO.js

@@ -0,0 +1,35 @@
+import { useCallback, useEffect } from 'react';
+import isIntersecting from './isIntersecting-fEXHJN5R.js';
+import { getElementPosition, getElementDimensions } from './useElementDimensions-CAoKitVD.js';
+import useMouseContext from './useMouseContext-D-rFy60Q.js';
+
+const useOnMouseClick = (ref, onChange, options) => {
+  const mouse = useMouseContext();
+  const handler = useCallback(
+    (position, action, eventButton) => {
+      if (options?.button && eventButton !== options.button) {
+        return;
+      }
+      const elementPosition = getElementPosition(ref.current);
+      const elementDimensions = getElementDimensions(ref.current);
+      if (!elementPosition || !elementDimensions) {
+        return;
+      }
+      const element = {
+        ...elementPosition,
+        ...elementDimensions
+      };
+      onChange(isIntersecting({ element, mouse: position }) && action === "press", eventButton);
+    },
+    [ref, onChange, options?.button]
+  );
+  useEffect(() => {
+    const { events } = mouse;
+    events.on("click", handler);
+    return () => {
+      events.off("click", handler);
+    };
+  }, [mouse.events, handler]);
+};
+
+export { useOnMouseClick };

package/dist/packem_shared/useOnMouseHover-26diuXUC.js

@@ -0,0 +1,32 @@
+import { useCallback, useEffect } from 'react';
+import isIntersecting from './isIntersecting-fEXHJN5R.js';
+import { getElementPosition, getElementDimensions } from './useElementDimensions-CAoKitVD.js';
+import useMouseContext from './useMouseContext-D-rFy60Q.js';
+
+const useOnMouseHover = (ref, onChange) => {
+  const mouse = useMouseContext();
+  const handler = useCallback(
+    (position) => {
+      const elementPosition = getElementPosition(ref.current);
+      const elementDimensions = getElementDimensions(ref.current);
+      if (!elementPosition || !elementDimensions) {
+        return;
+      }
+      const element = {
+        ...elementPosition,
+        ...elementDimensions
+      };
+      onChange(isIntersecting({ element, mouse: position }));
+    },
+    [ref, onChange]
+  );
+  useEffect(() => {
+    const { events } = mouse;
+    events.on("position", handler);
+    return () => {
+      events.off("position", handler);
+    };
+  }, [mouse.events, handler]);
+};
+
+export { useOnMouseHover as default };

package/dist/packem_shared/useOnMouseState-NO_Kda_C.js

@@ -0,0 +1,13 @@
+import { useState } from 'react';
+import { useOnMouseClick } from './useOnMouseClick--ZIyBOBO.js';
+import useOnMouseHover from './useOnMouseHover-26diuXUC.js';
+
+const useOnMouseState = (ref) => {
+  const [hovering, setHovering] = useState(false);
+  const [clicking, setClicking] = useState(false);
+  useOnMouseClick(ref, setClicking);
+  useOnMouseHover(ref, setHovering);
+  return { clicking, hovering };
+};
+
+export { useOnMouseState as default };

package/dist/packem_shared/usePaste-Ct8J4AGR.js

@@ -0,0 +1,35 @@
+import { useEffectEvent, useEffect } from 'react';
+import { r as reconcilerInstance } from './reconciler-gfmqURLy.js';
+import { useStdinContext } from './useStdin-X-O0kd-n.js';
+
+const usePaste = (handler, options = {}) => {
+  const { internal_eventEmitter, setBracketedPasteMode, setRawMode } = useStdinContext();
+  const stableHandler = useEffectEvent(handler);
+  useEffect(() => {
+    if (options.isActive === false) {
+      return;
+    }
+    setRawMode(true);
+    setBracketedPasteMode(true);
+    return () => {
+      setRawMode(false);
+      setBracketedPasteMode(false);
+    };
+  }, [options.isActive, setRawMode, setBracketedPasteMode]);
+  useEffect(() => {
+    if (options.isActive === false) {
+      return;
+    }
+    const handlePaste = (text) => {
+      reconcilerInstance.discreteUpdates(() => {
+        stableHandler(text);
+      });
+    };
+    internal_eventEmitter.on("paste", handlePaste);
+    return () => {
+      internal_eventEmitter.removeListener("paste", handlePaste);
+    };
+  }, [options.isActive, internal_eventEmitter]);
+};
+
+export { usePaste as default };

package/dist/packem_shared/useScrollAcceleration-R9LfrPVG.js

@@ -0,0 +1,73 @@
+import { useState, useRef, useEffect, useCallback, useMemo } from 'react';
+
+const RAPID_THRESHOLD_MS = 100;
+const TICK_INTERVAL_MS = 16;
+const MIN_VELOCITY = 0.5;
+const useScrollAcceleration = (options = {}) => {
+  const { acceleration = 1.5, decayRate = 0.92, isActive = true, maxVelocity = 20, onScroll } = options;
+  const [velocity, setVelocity] = useState(0);
+  const [isCoasting, setIsCoasting] = useState(false);
+  const velocityRef = useRef(0);
+  const lastScrollTimeRef = useRef(0);
+  const skipNextTickRef = useRef(false);
+  const tickTimerRef = useRef(void 0);
+  const onScrollRef = useRef(onScroll);
+  onScrollRef.current = onScroll;
+  useEffect(() => {
+    if (!isActive || !isCoasting) {
+      return;
+    }
+    const tick = () => {
+      if (skipNextTickRef.current) {
+        skipNextTickRef.current = false;
+        return;
+      }
+      const v = velocityRef.current;
+      if (Math.abs(v) < MIN_VELOCITY) {
+        velocityRef.current = 0;
+        setVelocity(0);
+        setIsCoasting(false);
+        return;
+      }
+      velocityRef.current *= decayRate;
+      const delta = Math.round(velocityRef.current);
+      if (delta !== 0) {
+        onScrollRef.current?.(delta);
+      }
+      setVelocity(velocityRef.current);
+    };
+    tickTimerRef.current = setInterval(tick, TICK_INTERVAL_MS);
+    return () => {
+      if (tickTimerRef.current) {
+        clearInterval(tickTimerRef.current);
+      }
+    };
+  }, [isActive, isCoasting, decayRate]);
+  const handleScroll = useCallback(
+    (direction) => {
+      if (!isActive) {
+        onScrollRef.current?.(direction === "down" ? 1 : -1);
+        return;
+      }
+      const now = Date.now();
+      const elapsed = now - lastScrollTimeRef.current;
+      const sign = direction === "down" ? 1 : -1;
+      lastScrollTimeRef.current = now;
+      if (elapsed < RAPID_THRESHOLD_MS && Math.sign(velocityRef.current) === sign) {
+        velocityRef.current = Math.min(Math.abs(velocityRef.current * acceleration), maxVelocity) * sign;
+      } else {
+        velocityRef.current = sign;
+      }
+      setVelocity(velocityRef.current);
+      setIsCoasting(true);
+      skipNextTickRef.current = true;
+      onScrollRef.current?.(sign);
+    },
+    [isActive, acceleration, maxVelocity]
+  );
+  return useMemo(() => {
+    return { handleScroll, isCoasting, velocity };
+  }, [handleScroll, isCoasting, velocity]);
+};
+
+export { useScrollAcceleration as default };

package/dist/packem_shared/useScrollInput-D3CpBq_a.js

@@ -0,0 +1,72 @@
+import useFocus from './useFocus-CNl5QHHf.js';
+import useInput from './useInput-Cfp5zB2s.js';
+
+const useScrollInput = (options) => {
+  const { getViewportHeight, isActive = true, scrollBy, scrollToBottom, scrollToTop, vimBindings = false } = options;
+  const { isFocused } = useFocus({ isActive });
+  useInput(
+    (input, key) => {
+      if (key.upArrow) {
+        scrollBy(-1);
+        return;
+      }
+      if (key.downArrow) {
+        scrollBy(1);
+        return;
+      }
+      if (key.pageUp) {
+        scrollBy(-getViewportHeight());
+        return;
+      }
+      if (key.pageDown) {
+        scrollBy(getViewportHeight());
+        return;
+      }
+      if (key.home) {
+        scrollToTop();
+        return;
+      }
+      if (key.end) {
+        scrollToBottom();
+        return;
+      }
+      if (key.ctrl && input === "u") {
+        scrollBy(-Math.floor(getViewportHeight() / 2));
+        return;
+      }
+      if (key.ctrl && input === "d") {
+        scrollBy(Math.floor(getViewportHeight() / 2));
+        return;
+      }
+      if (vimBindings) {
+        if (input === "k") {
+          scrollBy(-1);
+          return;
+        }
+        if (input === "j") {
+          scrollBy(1);
+          return;
+        }
+        if (input === "G" && key.shift) {
+          scrollToBottom();
+          return;
+        }
+        if (input === "g" && !key.shift) {
+          scrollToTop();
+          return;
+        }
+        if (input === "u" && !key.ctrl) {
+          scrollBy(-Math.floor(getViewportHeight() / 2));
+          return;
+        }
+        if (input === "d" && !key.ctrl) {
+          scrollBy(Math.floor(getViewportHeight() / 2));
+        }
+      }
+    },
+    { isActive }
+  );
+  return { isFocused };
+};
+
+export { useScrollInput as default };

package/dist/packem_shared/useStderr-CAOVUh4E.js

@@ -0,0 +1,6 @@
+import { useContext } from 'react';
+import { S as StderrContext } from './StderrContext-Bj4Mf7v7.js';
+
+const useStderr = () => useContext(StderrContext);
+
+export { useStderr as default };

package/dist/packem_shared/useStdin-X-O0kd-n.js

@@ -0,0 +1,7 @@
+import { useContext } from 'react';
+import { S as StdinContext } from './StdinContext-Bq_GNJ3z.js';
+
+const useStdin = () => useContext(StdinContext);
+const useStdinContext = () => useContext(StdinContext);
+
+export { useStdin as default, useStdinContext };

package/dist/packem_shared/useStdout-DyF6DSH0.js

@@ -0,0 +1,6 @@
+import { useContext } from 'react';
+import { S as StdoutContext } from './StdoutContext-CgjWeCdO.js';
+
+const useStdout = () => useContext(StdoutContext);
+
+export { useStdout as default };

package/dist/packem_shared/useStopwatch-qC4Beai4.js

@@ -0,0 +1,33 @@
+import { useState, useCallback, useRef } from 'react';
+import useAnimation from './useAnimation-kj31sA-T.js';
+
+function useStopwatch(options) {
+  const { autoStart = false, interval = 1e3 } = options ?? {};
+  const [running, setRunning] = useState(autoStart);
+  const [laps, setLaps] = useState([]);
+  const { reset: resetAnimation, time: elapsed } = useAnimation({ interval, isActive: running });
+  const start = useCallback(() => {
+    setRunning(true);
+  }, []);
+  const stop = useCallback(() => {
+    setRunning(false);
+  }, []);
+  const toggle = useCallback(() => {
+    setRunning((r) => !r);
+  }, []);
+  const reset = useCallback(() => {
+    setRunning(false);
+    setLaps([]);
+    resetAnimation();
+  }, [resetAnimation]);
+  const elapsedRef = useRef(elapsed);
+  elapsedRef.current = elapsed;
+  const lap = useCallback(() => {
+    const current = elapsedRef.current;
+    setLaps((previous) => [...previous, current]);
+    return current;
+  }, []);
+  return { elapsed, isRunning: running, lap, laps, reset, start, stop, toggle };
+}
+
+export { useStopwatch as default };

package/dist/packem_shared/useTerminalPalette-BaWO2c4Q.js

@@ -0,0 +1,38 @@
+import { useState, useMemo, useEffect } from 'react';
+import { isTerminalPaletteQuerySupported, queryTerminalPalette } from './isTerminalPaletteQuerySupported-EeiwMKbr.js';
+import { useStdinContext } from './useStdin-X-O0kd-n.js';
+import useStdout from './useStdout-DyF6DSH0.js';
+
+const useTerminalPalette = () => {
+  const { stdin } = useStdinContext();
+  const { stdout } = useStdout();
+  const [palette, setPalette] = useState(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const isSupported = useMemo(() => isTerminalPaletteQuerySupported(), []);
+  useEffect(() => {
+    if (!isSupported || !stdin || !stdout) {
+      setIsLoading(false);
+      return;
+    }
+    let cancelled = false;
+    void (async () => {
+      try {
+        const result = await queryTerminalPalette(stdin, stdout, 200);
+        if (!cancelled) {
+          setPalette(result);
+        }
+      } catch {
+      } finally {
+        if (!cancelled) {
+          setIsLoading(false);
+        }
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [isSupported, stdin, stdout]);
+  return { isLoading, isSupported, palette };
+};
+
+export { useTerminalPalette as default };