@visulima/tui 1.0.0-alpha.2 → 1.0.0-alpha.4

package/dist/packem_shared/{setEnableStyledLineCache-BpskngSJ.js → setEnableStyledLineCache-D5f4favX.js}

@@ -1,2 +1,2 @@
 import '@visulima/string';
-export { c as clearStringWidthCache, a as clearStyledLineCache, m as default, i as inkCharacterWidth, k as measureStyledLine, s as setEnableStyledLineCache, b as setStringWidthFunction, l as splitStyledLineByNewline, d as styledLineWidth, t as toStyledLine } from './measure-text-DItZYotK.js';
+export { c as clearStringWidthCache, a as clearStyledLineCache, m as default, i as inkCharacterWidth, k as measureStyledLine, s as setEnableStyledLineCache, b as setStringWidthFunction, l as splitStyledLineByNewline, d as styledLineWidth, t as toStyledLine } from './measure-text-BdOhbOeh.js';

package/dist/packem_shared/{text-width-DhuarWcB.js → text-width-Db-AxMea.js}

@@ -32,8 +32,9 @@ function measureTextBlock(text, wrapWidth) {
   let wrappedRows = 0;
   for (const line of lines) {
     const lineWidth = getStringWidth(line);
-    if (lineWidth > maxLineWidth)
+    if (lineWidth > maxLineWidth) {
       maxLineWidth = lineWidth;
+    }
     wrappedRows += wrapWidth > 0 ? countWrappedRowsForLine(line, wrapWidth) : 0;
   }
   return { maxLineWidth, wrappedRows };

package/dist/packem_shared/{token-to-elements-BRFl_rzw.js → token-to-elements-CK4s8MJd.js}

@@ -1,6 +1,6 @@
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
-import Box from './Box-D_pSJ9Jp.js';
-import Text from './Text-DvAUdZcK.js';
+import Box from './Box-W1w_NGin.js';
+import Text from './Text-CtUwV89_.js';
 
 const LANGUAGE_IMPORT_MAP = {
   bash: () => import('@shikijs/langs/bash'),

package/dist/packem_shared/{useAnimation-kj31sA-T.js → useAnimation-DV22qxiJ.js}

@@ -1,5 +1,5 @@
 import { useContext, useState, useRef, useCallback, useLayoutEffect } from 'react';
-import { a as animationContext } from './AnimationContext-BcJg8Jr6.js';
+import { a as animationContext } from './animation-context-BcJg8Jr6.js';
 
 const defaultAnimationInterval = 100;
 const maximumTimerInterval = 2147483647;
@@ -20,7 +20,7 @@ function useAnimation(options) {
   }, []);
   useLayoutEffect(() => {
     if (!isActive) {
-      return;
+      return void 0;
     }
     setAnimState(zeroAnimState);
     let startTime = 0;

package/dist/packem_shared/{useApp-DPQlRzi5.js → useApp-Cbi788rV.js}

@@ -1,5 +1,5 @@
 import { useContext } from 'react';
-import { A as AppContext } from './AppContext-CP0U6H7O.js';
+import { A as AppContext } from './app-context-CP0U6H7O.js';
 
 const useApp = () => useContext(AppContext);
 

package/dist/packem_shared/{useBoxMetrics-rBjKc-g4.js → useBoxMetrics-_5icypir.js}

@@ -1,6 +1,6 @@
 import { useState, useCallback, useEffect, useMemo } from 'react';
-import { a as addLayoutListener } from './dom-DvzhsAez.js';
-import useStdout from './useStdout-DyF6DSH0.js';
+import { a as addLayoutListener } from './dom-CrbpQgat.js';
+import useStdout from './useStdout-B5yRcg9N.js';
 
 const emptyMetrics = {
   height: 0,

package/dist/packem_shared/{useClipboard-B_9-adw1.js → useClipboard-MNj6MNR-.js}

@@ -1,6 +1,6 @@
 import { useMemo, useCallback } from 'react';
 import { isOsc52Supported, writeOsc52 } from './isOsc52Supported-G0k4sXJx.js';
-import useStdout from './useStdout-DyF6DSH0.js';
+import useStdout from './useStdout-B5yRcg9N.js';
 
 const useClipboard = (options = {}) => {
   const { target = "c" } = options;

package/dist/packem_shared/{useCursor-BIJzc8k9.js → useCursor-DS6LjIgv.js}

@@ -1,5 +1,5 @@
 import { useContext, useRef, useCallback, useInsertionEffect } from 'react';
-import { C as CursorContext } from './CursorContext-JxRzlqAx.js';
+import { C as CursorContext } from './cursor-context-JxRzlqAx.js';
 
 const useCursor = () => {
   const context = useContext(CursorContext);

package/dist/packem_shared/{useFocus-CNl5QHHf.js → useFocus-DLoGQJd9.js}

@@ -1,6 +1,6 @@
 import { useContext, useMemo, useEffect } from 'react';
-import { F as FocusContext } from './FocusContext-CWkYtgcm.js';
-import useStdin from './useStdin-X-O0kd-n.js';
+import { F as FocusContext } from './focus-context-CWkYtgcm.js';
+import useStdin from './useStdin-Rf0zPzVA.js';
 
 const useFocus = ({ autoFocus = false, id: customId, isActive = true } = {}) => {
   const { isRawModeSupported, setRawMode } = useStdin();

package/dist/packem_shared/{useFocusManager-BPYaUuKQ.js → useFocusManager-UeZWtnNc.js}

@@ -1,5 +1,5 @@
 import { useContext } from 'react';
-import { F as FocusContext } from './FocusContext-CWkYtgcm.js';
+import { F as FocusContext } from './focus-context-CWkYtgcm.js';
 
 const useFocusManager = () => {
   const focusContext = useContext(FocusContext);

package/dist/packem_shared/useForm-sQENbEuv.js

@@ -0,0 +1,88 @@
+import { useMemo, useState, useRef, useCallback } from 'react';
+
+const deriveInitialValues = (fields) => {
+  const values = {};
+  for (const name of Object.keys(fields)) {
+    values[name] = fields[name].initialValue;
+  }
+  return values;
+};
+const useForm = (options) => {
+  const { fields, onSubmit } = options;
+  const initialValues = useMemo(() => deriveInitialValues(fields), [fields]);
+  const [values, setValues] = useState(initialValues);
+  const [errors, setErrors] = useState({});
+  const [touched, setTouchedState] = useState({});
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const valuesRef = useRef(values);
+  valuesRef.current = values;
+  const validateField = useCallback(
+    (name, value, allValues = valuesRef.current) => {
+      const config = fields[name];
+      return config?.validate?.(value, allValues);
+    },
+    [fields]
+  );
+  const setValue = useCallback(
+    (name, value) => {
+      const nextValues = { ...valuesRef.current, [name]: value };
+      valuesRef.current = nextValues;
+      setValues(nextValues);
+      const error = validateField(name, value, nextValues);
+      setErrors((previous) => {
+        if (error === void 0) {
+          const next = { ...previous };
+          delete next[name];
+          return next;
+        }
+        return { ...previous, [name]: error };
+      });
+    },
+    [validateField]
+  );
+  const setTouched = useCallback((name, isTouched = true) => {
+    setTouchedState((previous) => {
+      return { ...previous, [name]: isTouched };
+    });
+  }, []);
+  const reset = useCallback(() => {
+    setValues(initialValues);
+    setErrors({});
+    setTouchedState({});
+  }, [initialValues]);
+  const submit = useCallback(async () => {
+    const nextErrors = {};
+    const nextTouched = {};
+    for (const key of Object.keys(fields)) {
+      nextTouched[key] = true;
+      const error = validateField(key, valuesRef.current[key]);
+      if (error !== void 0) {
+        nextErrors[key] = error;
+      }
+    }
+    setErrors(nextErrors);
+    setTouchedState(nextTouched);
+    if (Object.keys(nextErrors).length > 0) {
+      return false;
+    }
+    try {
+      setIsSubmitting(true);
+      await onSubmit?.(valuesRef.current);
+      return true;
+    } finally {
+      setIsSubmitting(false);
+    }
+  }, [fields, validateField, onSubmit]);
+  return {
+    errors,
+    isSubmitting,
+    reset,
+    setTouched,
+    setValue,
+    submit,
+    touched,
+    values
+  };
+};
+
+export { useForm as default };

package/dist/packem_shared/useHotkey-D9giUX3q.js

@@ -0,0 +1,112 @@
+import { useCallback } from 'react';
+import useInput from './useInput-DKZbqMRc.js';
+
+const NAMED_KEYS = /* @__PURE__ */ new Set([
+  "backspace",
+  "delete",
+  "downArrow",
+  "end",
+  "escape",
+  "home",
+  "leftArrow",
+  "pageDown",
+  "pageUp",
+  "return",
+  "rightArrow",
+  "tab",
+  "upArrow"
+]);
+const parseShortcut = (shortcut) => {
+  const parts = shortcut.split("+").map((part) => part.trim()).filter((part) => part.length > 0);
+  const descriptor = {};
+  for (const part of parts) {
+    const lower = part.toLowerCase();
+    switch (lower) {
+      case "alt":
+      case "cmd":
+      case "meta": {
+        descriptor.meta = true;
+        break;
+      }
+      case "control":
+      case "ctrl": {
+        descriptor.ctrl = true;
+        break;
+      }
+      case "shift": {
+        descriptor.shift = true;
+        break;
+      }
+      default: {
+        if (NAMED_KEYS.has(lower)) {
+          descriptor.name = lower;
+        } else {
+          switch (lower) {
+            case "down": {
+              descriptor.name = "downArrow";
+              break;
+            }
+            case "enter": {
+              descriptor.name = "return";
+              break;
+            }
+            case "esc": {
+              descriptor.name = "escape";
+              break;
+            }
+            case "left": {
+              descriptor.name = "leftArrow";
+              break;
+            }
+            case "right": {
+              descriptor.name = "rightArrow";
+              break;
+            }
+            case "up": {
+              descriptor.name = "upArrow";
+              break;
+            }
+            default: {
+              descriptor.input = part;
+            }
+          }
+        }
+      }
+    }
+  }
+  return descriptor;
+};
+const matches = (descriptor, input, key) => {
+  if (descriptor.ctrl !== void 0 && descriptor.ctrl !== key.ctrl) {
+    return false;
+  }
+  if (descriptor.shift !== void 0 && descriptor.shift !== key.shift) {
+    return false;
+  }
+  if (descriptor.meta !== void 0 && descriptor.meta !== key.meta) {
+    return false;
+  }
+  if (descriptor.name !== void 0) {
+    return Boolean(key[descriptor.name]);
+  }
+  if (descriptor.input !== void 0) {
+    return input === descriptor.input;
+  }
+  return false;
+};
+const useHotkey = (shortcut, callback, options) => {
+  const descriptor = typeof shortcut === "string" ? parseShortcut(shortcut) : shortcut;
+  useInput(
+    useCallback(
+      (input, key) => {
+        if (matches(descriptor, input, key)) {
+          callback();
+        }
+      },
+      [shortcut, callback]
+    ),
+    { isActive: options?.isActive ?? true }
+  );
+};
+
+export { useHotkey as default };

package/dist/packem_shared/{useInput-Cfp5zB2s.js → useInput-DKZbqMRc.js}

@@ -23,8 +23,8 @@ const {
   Buffer
 } = __cjs_getBuiltinModule("node:buffer");
 import { kittyModifiers } from './kittyFlags-bNNf_9kX.js';
-import { r as reconcilerInstance } from './reconciler-gfmqURLy.js';
-import { useStdinContext } from './useStdin-X-O0kd-n.js';
+import { r as reconcilerInstance } from './reconciler-Dd7Z0A97.js';
+import { useStdinContext } from './useStdin-Rf0zPzVA.js';
 
 const metaKeyCodeRe = /^\u001B([a-z0-9])$/i;
 const functionKeyRe = /^\u001B+([ON[]|\[\[)(?:(\d+)(?:;(\d+))?([~^$])|(?:1;)?(\d+)?([a-zA-Z]))/;

package/dist/packem_shared/useInterval-CSXM8c2I.js

@@ -0,0 +1,32 @@
+import { useRef, useLayoutEffect, useEffect, useCallback } from 'react';
+
+const useInterval = (callback, interval, options) => {
+  const { isActive = true } = options ?? {};
+  const callbackRef = useRef(callback);
+  const timerRef = useRef(void 0);
+  useLayoutEffect(() => {
+    callbackRef.current = callback;
+  }, [callback]);
+  useEffect(() => {
+    if (!isActive || interval <= 0 || !Number.isFinite(interval)) {
+      return void 0;
+    }
+    const id = setInterval(() => {
+      callbackRef.current();
+    }, interval);
+    timerRef.current = id;
+    return () => {
+      clearInterval(id);
+      timerRef.current = void 0;
+    };
+  }, [interval, isActive]);
+  const clear = useCallback(() => {
+    if (timerRef.current !== void 0) {
+      clearInterval(timerRef.current);
+      timerRef.current = void 0;
+    }
+  }, []);
+  return { clear };
+};
+
+export { useInterval as default };

package/dist/packem_shared/{useIsScreenReaderEnabled-CnGKCe0f.js → useIsScreenReaderEnabled-BeoVqo1R.js}

@@ -1,5 +1,5 @@
 import { useContext } from 'react';
-import { a as accessibilityContext } from './AccessibilityContext-BLelHhNU.js';
+import { a as accessibilityContext } from './accessibility-context-BLelHhNU.js';
 
 const useIsScreenReaderEnabled = () => {
   const { isScreenReaderEnabled } = useContext(accessibilityContext);

package/dist/packem_shared/{useKeyBindings-B78l1E1n.js → useKeyBindings-S4fSIEAk.js}

@@ -1,5 +1,5 @@
 import { useRef, useCallback, useMemo } from 'react';
-import useInput from './useInput-Cfp5zB2s.js';
+import useInput from './useInput-DKZbqMRc.js';
 
 const specialKeyFields = /* @__PURE__ */ new Set([
   "backspace",
@@ -16,7 +16,7 @@ const specialKeyFields = /* @__PURE__ */ new Set([
   "tab",
   "upArrow"
 ]);
-const modifierFields = /* @__PURE__ */ new Set(["ctrl", "meta", "shift", "super", "hyper"]);
+const modifierFields = /* @__PURE__ */ new Set(["ctrl", "hyper", "meta", "shift", "super"]);
 function matchesKey(spec, input, key) {
   const plusIndex = spec.indexOf("+");
   if (plusIndex !== -1) {

package/dist/packem_shared/useKeyChord-BmXGNuEO.js

@@ -0,0 +1,114 @@
+import { useRef, useCallback } from 'react';
+import useInput from './useInput-DKZbqMRc.js';
+
+const resolveKeyName = (input, key) => {
+  if (key.escape) {
+    return "escape";
+  }
+  if (key.return) {
+    return "return";
+  }
+  if (key.tab) {
+    return "tab";
+  }
+  if (key.backspace) {
+    return "backspace";
+  }
+  if (key.delete) {
+    return "delete";
+  }
+  if (key.home) {
+    return "home";
+  }
+  if (key.end) {
+    return "end";
+  }
+  if (key.pageUp) {
+    return "pageup";
+  }
+  if (key.pageDown) {
+    return "pagedown";
+  }
+  if (key.upArrow) {
+    return "up";
+  }
+  if (key.downArrow) {
+    return "down";
+  }
+  if (key.leftArrow) {
+    return "left";
+  }
+  if (key.rightArrow) {
+    return "right";
+  }
+  if (input === " ") {
+    return "space";
+  }
+  if (!input || input.length === 0) {
+    return void 0;
+  }
+  return input;
+};
+const keyToString = (input, key) => {
+  const name = resolveKeyName(input, key);
+  if (name === void 0) {
+    return void 0;
+  }
+  const parts = [];
+  if (key.ctrl) {
+    parts.push("ctrl");
+  }
+  if (key.meta) {
+    parts.push("meta");
+  }
+  if (key.shift) {
+    parts.push("shift");
+  }
+  parts.push(name);
+  return parts.join("+");
+};
+const normalizeStep = (step) => step.trim().toLowerCase();
+const useKeyChord = (sequence, callback, options) => {
+  const { isActive = true, resetAfter = 1e3 } = options ?? {};
+  const progressRef = useRef(0);
+  const lastStepAtRef = useRef(0);
+  const callbackRef = useRef(callback);
+  callbackRef.current = callback;
+  useInput(
+    useCallback(
+      (input, key) => {
+        const now = Date.now();
+        if (resetAfter > 0 && progressRef.current > 0 && now - lastStepAtRef.current > resetAfter) {
+          progressRef.current = 0;
+        }
+        const pressed = keyToString(input, key);
+        if (pressed === void 0 || sequence.length === 0) {
+          return;
+        }
+        const expected = sequence[progressRef.current];
+        if (expected === void 0) {
+          progressRef.current = 0;
+          return;
+        }
+        if (normalizeStep(pressed) === normalizeStep(expected)) {
+          progressRef.current += 1;
+          lastStepAtRef.current = now;
+          if (progressRef.current >= sequence.length) {
+            progressRef.current = 0;
+            callbackRef.current();
+          }
+          return;
+        }
+        progressRef.current = 0;
+        if (normalizeStep(pressed) === normalizeStep(sequence[0] ?? "")) {
+          progressRef.current = 1;
+          lastStepAtRef.current = now;
+        }
+      },
+      [sequence, resetAfter]
+    ),
+    { isActive }
+  );
+};
+
+export { useKeyChord as default };

package/dist/packem_shared/{usePaste-Ct8J4AGR.js → usePaste-png73gvT.js}

@@ -1,6 +1,6 @@
 import { useEffectEvent, useEffect } from 'react';
-import { r as reconcilerInstance } from './reconciler-gfmqURLy.js';
-import { useStdinContext } from './useStdin-X-O0kd-n.js';
+import { r as reconcilerInstance } from './reconciler-Dd7Z0A97.js';
+import { useStdinContext } from './useStdin-Rf0zPzVA.js';
 
 const usePaste = (handler, options = {}) => {
   const { internal_eventEmitter, setBracketedPasteMode, setRawMode } = useStdinContext();

package/dist/packem_shared/{useScrollInput-D3CpBq_a.js → useScrollInput-DfzRGQFe.js}

@@ -1,5 +1,5 @@
-import useFocus from './useFocus-CNl5QHHf.js';
-import useInput from './useInput-Cfp5zB2s.js';
+import useFocus from './useFocus-DLoGQJd9.js';
+import useInput from './useInput-DKZbqMRc.js';
 
 const useScrollInput = (options) => {
   const { getViewportHeight, isActive = true, scrollBy, scrollToBottom, scrollToTop, vimBindings = false } = options;

package/dist/packem_shared/{useStderr-CAOVUh4E.js → useStderr-BSWerMZ7.js}

@@ -1,5 +1,5 @@
 import { useContext } from 'react';
-import { S as StderrContext } from './StderrContext-Bj4Mf7v7.js';
+import { S as StderrContext } from './stderr-context-Bj4Mf7v7.js';
 
 const useStderr = () => useContext(StderrContext);
 

package/dist/packem_shared/{useStdin-X-O0kd-n.js → useStdin-Rf0zPzVA.js}

@@ -1,5 +1,5 @@
 import { useContext } from 'react';
-import { S as StdinContext } from './StdinContext-Bq_GNJ3z.js';
+import { S as StdinContext } from './stdin-context-Bq_GNJ3z.js';
 
 const useStdin = () => useContext(StdinContext);
 const useStdinContext = () => useContext(StdinContext);

package/dist/packem_shared/{useStdout-DyF6DSH0.js → useStdout-B5yRcg9N.js}

@@ -1,5 +1,5 @@
 import { useContext } from 'react';
-import { S as StdoutContext } from './StdoutContext-CgjWeCdO.js';
+import { S as StdoutContext } from './stdout-context-CgjWeCdO.js';
 
 const useStdout = () => useContext(StdoutContext);
 

package/dist/packem_shared/{useStopwatch-qC4Beai4.js → useStopwatch-C__Zu6hd.js}

@@ -1,5 +1,5 @@
 import { useState, useCallback, useRef } from 'react';
-import useAnimation from './useAnimation-kj31sA-T.js';
+import useAnimation from './useAnimation-DV22qxiJ.js';
 
 function useStopwatch(options) {
   const { autoStart = false, interval = 1e3 } = options ?? {};
@@ -23,7 +23,7 @@ function useStopwatch(options) {
   const elapsedRef = useRef(elapsed);
   elapsedRef.current = elapsed;
   const lap = useCallback(() => {
-    const current = elapsedRef.current;
+    const { current } = elapsedRef;
     setLaps((previous) => [...previous, current]);
     return current;
   }, []);

package/dist/packem_shared/{useTerminalPalette-BaWO2c4Q.js → useTerminalPalette-CtFG2JTq.js}

@@ -1,7 +1,7 @@
 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';
+import { useStdinContext } from './useStdin-Rf0zPzVA.js';
+import useStdout from './useStdout-B5yRcg9N.js';
 
 const useTerminalPalette = () => {
   const { stdin } = useStdinContext();

package/dist/packem_shared/{useTextSelection-mXtxgsPK.js → useTextSelection-ChrYZXsn.js}

@@ -1,6 +1,6 @@
 import { useRef, useState, useEffect, useCallback, useMemo } from 'react';
-import { Selection, Range } from './comparePoints-CGMDnd3_.js';
-import useClipboard from './useClipboard-B_9-adw1.js';
+import { Selection, Range } from './comparePoints-CAAlhiMS.js';
+import useClipboard from './useClipboard-MNj6MNR-.js';
 
 const useTextSelection = (ref, options = {}) => {
   const { copyOnSelect = false, isActive = true, onSelectionChange } = options;

package/dist/packem_shared/useTimeout-DuCqgWPX.js

@@ -0,0 +1,34 @@
+import { useRef, useState, useCallback, useEffect } from 'react';
+
+const useTimeout = (callback, delay, options) => {
+  const { isActive = true } = options ?? {};
+  const callbackRef = useRef(callback);
+  const timerRef = useRef(void 0);
+  const [bump, setBump] = useState(0);
+  callbackRef.current = callback;
+  const cancel = useCallback(() => {
+    if (timerRef.current !== void 0) {
+      clearTimeout(timerRef.current);
+      timerRef.current = void 0;
+    }
+  }, []);
+  const reset = useCallback(() => {
+    setBump((previous) => previous + 1);
+  }, []);
+  useEffect(() => {
+    if (!isActive || delay < 0 || !Number.isFinite(delay)) {
+      return void 0;
+    }
+    const id = setTimeout(() => {
+      callbackRef.current();
+    }, delay);
+    timerRef.current = id;
+    return () => {
+      clearTimeout(id);
+      timerRef.current = void 0;
+    };
+  }, [delay, isActive, bump]);
+  return { cancel, reset };
+};
+
+export { useTimeout as default };

package/dist/packem_shared/{useTimer-CPQ7j827.js → useTimer-DnBtbhB5.js}

@@ -1,5 +1,5 @@
 import { useState, useRef, useEffect, useCallback } from 'react';
-import useAnimation from './useAnimation-kj31sA-T.js';
+import useAnimation from './useAnimation-DV22qxiJ.js';
 
 function useTimer(options) {
   const { autoStart = false, duration, interval = 1e3, onTimeout } = options;

package/dist/packem_shared/{useTreeView-BT57P3Kx.js → useTreeView-mkN5Di7w.js}

@@ -1,5 +1,5 @@
 import { useRef, useCallback } from 'react';
-import useInput from './useInput-Cfp5zB2s.js';
+import useInput from './useInput-DKZbqMRc.js';
 
 function useTreeView({ isDisabled = false, loadChildren, onLoadError, selectionMode, state }) {
   const loadingReference = useRef(/* @__PURE__ */ new Set());

package/dist/packem_shared/{useWindowSize-ugEmGZJm.js → useWindowSize-D3UU41mv.js}

@@ -1,6 +1,6 @@
 import { useState, useEffect } from 'react';
 import { g as getWindowSize } from './utils-BgdlrbOH.js';
-import useStdout from './useStdout-DyF6DSH0.js';
+import useStdout from './useStdout-B5yRcg9N.js';
 
 const useWindowSize = () => {
   const { stdout } = useStdout();

package/dist/packem_shared/waitFor-Cv9M2jKA.js

@@ -0,0 +1,39 @@
+const waitFor = async (condition, screenText, options = {}) => {
+  const timeout = options.timeout ?? 3e3;
+  const interval = options.interval ?? 50;
+  const start = Date.now();
+  let lastError = new Error("waitFor timed out");
+  const check = () => {
+    if (typeof condition === "string") {
+      const current = screenText();
+      if (!current.includes(condition)) {
+        throw new Error(`Timed out waiting for text: "${condition}"
+
+Screen content:
+${current}`);
+      }
+    } else {
+      condition();
+    }
+  };
+  while (Date.now() - start < timeout) {
+    try {
+      check();
+      return;
+    } catch (error) {
+      lastError = error;
+    }
+    await new Promise((resolve) => {
+      setTimeout(resolve, interval);
+    });
+  }
+  try {
+    check();
+    return;
+  } catch (error) {
+    lastError = error;
+  }
+  throw lastError;
+};
+
+export { waitFor };