@visulima/tui 0.0.1 → 1.0.0-alpha.2

package/dist/packem_shared/useTextBuffer-C8fEe9Ly.js

@@ -0,0 +1,398 @@
+import { useState, useRef, useCallback, useMemo } from 'react';
+
+const UNDO_COALESCE_MS = 300;
+const MAX_UNDO_STACK = 100;
+const KILL_WORD_PATTERN = /\S+\s*$/;
+const splitLines = (text) => {
+  const result = text.split("\n");
+  return result.length === 0 ? [""] : result;
+};
+const joinLines = (lines) => lines.join("\n");
+const snapOf = (s) => {
+  return {
+    anchor: s.anchor,
+    cursor: { ...s.cursor },
+    lines: [...s.lines]
+  };
+};
+const withSelection = (s, newCursor, selecting) => {
+  if (selecting) {
+    return { ...s, anchor: s.anchor ?? s.cursor, cursor: newCursor };
+  }
+  return { ...s, anchor: null, cursor: newCursor };
+};
+const getSelectionRange = (cursor, anchor) => {
+  if (anchor.line < cursor.line || anchor.line === cursor.line && anchor.col < cursor.col) {
+    return { end: cursor, start: anchor };
+  }
+  return { end: anchor, start: cursor };
+};
+const deleteSelectionFromState = (s) => {
+  if (!s.anchor) {
+    return null;
+  }
+  const { end, start } = getSelectionRange(s.cursor, s.anchor);
+  const lines = [...s.lines];
+  const before = lines[start.line].slice(0, start.col);
+  const after = lines[end.line].slice(end.col);
+  lines.splice(start.line, end.line - start.line + 1, before + after);
+  return { anchor: null, cursor: start, lines };
+};
+const insertIntoState = (s, text) => {
+  const base = deleteSelectionFromState(s) ?? s;
+  const lines = [...base.lines];
+  const { col, line } = base.cursor;
+  const before = lines[line].slice(0, col);
+  const after = lines[line].slice(col);
+  const inserted = splitLines(text);
+  if (inserted.length === 1) {
+    lines[line] = before + inserted[0] + after;
+    return { anchor: null, cursor: { col: col + inserted[0].length, line }, lines };
+  }
+  const firstLine = before + inserted[0];
+  const lastLine = inserted.at(-1) + after;
+  const middle = inserted.slice(1, -1);
+  lines.splice(line, 1, firstLine, ...middle, lastLine);
+  return {
+    anchor: null,
+    cursor: { col: inserted.at(-1).length, line: line + inserted.length - 1 },
+    lines
+  };
+};
+const useTextBuffer = (initialValue = "") => {
+  const [state, setState] = useState(() => {
+    const lines = splitLines(initialValue);
+    return {
+      anchor: null,
+      cursor: { col: lines.at(-1).length, line: lines.length - 1 },
+      lines
+    };
+  });
+  const undoStack = useRef([]);
+  const redoStack = useRef([]);
+  const lastEditTime = useRef(0);
+  const desiredCol = useRef(state.cursor.col);
+  desiredCol.current = state.cursor.col;
+  const stateRef = useRef(state);
+  stateRef.current = state;
+  const pushUndo = useCallback((snapshot) => {
+    const now = Date.now();
+    if (now - lastEditTime.current < UNDO_COALESCE_MS && undoStack.current.length > 0) ; else {
+      undoStack.current.push(snapshot);
+      if (undoStack.current.length > MAX_UNDO_STACK) {
+        undoStack.current.shift();
+      }
+    }
+    redoStack.current = [];
+    lastEditTime.current = now;
+  }, []);
+  const hasSelection = useCallback(() => stateRef.current.anchor !== null, []);
+  const getSelectedText = useCallback(() => {
+    const s = stateRef.current;
+    if (!s.anchor) {
+      return "";
+    }
+    const { end, start } = getSelectionRange(s.cursor, s.anchor);
+    if (start.line === end.line) {
+      return s.lines[start.line].slice(start.col, end.col);
+    }
+    const result = [];
+    result.push(s.lines[start.line].slice(start.col));
+    for (let index = start.line + 1; index < end.line; index++) {
+      result.push(s.lines[index]);
+    }
+    result.push(s.lines[end.line].slice(0, end.col));
+    return result.join("\n");
+  }, []);
+  const insert = useCallback(
+    (text) => {
+      setState((s) => {
+        pushUndo(snapOf(s));
+        return insertIntoState(s, text);
+      });
+    },
+    [pushUndo]
+  );
+  const newline = useCallback(() => {
+    setState((s) => {
+      pushUndo(snapOf(s));
+      const base = deleteSelectionFromState(s) ?? s;
+      const lines = [...base.lines];
+      const { col, line } = base.cursor;
+      const before = lines[line].slice(0, col);
+      const after = lines[line].slice(col);
+      lines.splice(line, 1, before, after);
+      return { anchor: null, cursor: { col: 0, line: line + 1 }, lines };
+    });
+  }, [pushUndo]);
+  const deleteBack = useCallback(() => {
+    setState((s) => {
+      if (s.anchor) {
+        pushUndo(snapOf(s));
+        return deleteSelectionFromState(s) ?? s;
+      }
+      const { col, line } = s.cursor;
+      if (col === 0 && line === 0) {
+        return s;
+      }
+      pushUndo(snapOf(s));
+      const lines = [...s.lines];
+      if (col === 0) {
+        const previousLine = lines[line - 1];
+        const newCol = previousLine.length;
+        lines[line - 1] = previousLine + lines[line];
+        lines.splice(line, 1);
+        return { anchor: null, cursor: { col: newCol, line: line - 1 }, lines };
+      }
+      lines[line] = lines[line].slice(0, col - 1) + lines[line].slice(col);
+      return { anchor: null, cursor: { col: col - 1, line }, lines };
+    });
+  }, [pushUndo]);
+  const deleteForward = useCallback(() => {
+    setState((s) => {
+      if (s.anchor) {
+        pushUndo(snapOf(s));
+        return deleteSelectionFromState(s) ?? s;
+      }
+      const { col, line } = s.cursor;
+      const currentLine = s.lines[line];
+      if (col === currentLine.length && line === s.lines.length - 1) {
+        return s;
+      }
+      pushUndo(snapOf(s));
+      const lines = [...s.lines];
+      if (col === currentLine.length) {
+        lines[line] = currentLine + lines[line + 1];
+        lines.splice(line + 1, 1);
+        return { anchor: null, cursor: s.cursor, lines };
+      }
+      lines[line] = currentLine.slice(0, col) + currentLine.slice(col + 1);
+      return { anchor: null, cursor: s.cursor, lines };
+    });
+  }, [pushUndo]);
+  const deleteLine = useCallback(() => {
+    setState((s) => {
+      pushUndo(snapOf(s));
+      const lines = [...s.lines];
+      const { line } = s.cursor;
+      if (lines.length === 1) {
+        return { anchor: null, cursor: { col: 0, line: 0 }, lines: [""] };
+      }
+      lines.splice(line, 1);
+      const newLine = Math.min(line, lines.length - 1);
+      return { anchor: null, cursor: { col: Math.min(s.cursor.col, lines[newLine].length), line: newLine }, lines };
+    });
+  }, [pushUndo]);
+  const deleteToLineEnd = useCallback(() => {
+    setState((s) => {
+      pushUndo(snapOf(s));
+      const lines = [...s.lines];
+      const { col, line } = s.cursor;
+      lines[line] = lines[line].slice(0, col);
+      return { ...s, anchor: null, lines };
+    });
+  }, [pushUndo]);
+  const deleteToLineStart = useCallback(() => {
+    setState((s) => {
+      pushUndo(snapOf(s));
+      const lines = [...s.lines];
+      const { col, line } = s.cursor;
+      lines[line] = lines[line].slice(col);
+      return { anchor: null, cursor: { col: 0, line }, lines };
+    });
+  }, [pushUndo]);
+  const deleteWord = useCallback(() => {
+    setState((s) => {
+      pushUndo(snapOf(s));
+      if (s.anchor) {
+        return deleteSelectionFromState(s) ?? s;
+      }
+      const { col, line } = s.cursor;
+      const before = s.lines[line].slice(0, col);
+      const trimmed = before.replace(KILL_WORD_PATTERN, "");
+      const lines = [...s.lines];
+      lines[line] = trimmed + s.lines[line].slice(col);
+      return { anchor: null, cursor: { col: trimmed.length, line }, lines };
+    });
+  }, [pushUndo]);
+  const moveCursor = useCallback((direction, selecting = false) => {
+    setState((s) => {
+      const { col, line } = s.cursor;
+      let newLine = line;
+      let newCol = col;
+      switch (direction) {
+        case "down": {
+          if (line < s.lines.length - 1) {
+            newLine = line + 1;
+            newCol = Math.min(desiredCol.current, s.lines[newLine].length);
+          }
+          break;
+        }
+        case "left": {
+          if (col > 0) {
+            newCol = col - 1;
+          } else if (line > 0) {
+            newLine = line - 1;
+            newCol = s.lines[newLine].length;
+          }
+          break;
+        }
+        case "right": {
+          const lineLength = s.lines[line].length;
+          if (col < lineLength) {
+            newCol = col + 1;
+          } else if (line < s.lines.length - 1) {
+            newLine = line + 1;
+            newCol = 0;
+          }
+          break;
+        }
+        case "up": {
+          if (line > 0) {
+            newLine = line - 1;
+            newCol = Math.min(desiredCol.current, s.lines[newLine].length);
+          }
+          break;
+        }
+      }
+      return withSelection(s, { col: newCol, line: newLine }, selecting);
+    });
+  }, []);
+  const moveToLineStart = useCallback((selecting = false) => {
+    setState((s) => withSelection(s, { col: 0, line: s.cursor.line }, selecting));
+  }, []);
+  const moveToLineEnd = useCallback((selecting = false) => {
+    setState((s) => withSelection(s, { col: s.lines[s.cursor.line].length, line: s.cursor.line }, selecting));
+  }, []);
+  const moveToStart = useCallback((selecting = false) => {
+    setState((s) => withSelection(s, { col: 0, line: 0 }, selecting));
+  }, []);
+  const moveToEnd = useCallback((selecting = false) => {
+    setState((s) => {
+      const lastLine = s.lines.length - 1;
+      return withSelection(s, { col: s.lines[lastLine].length, line: lastLine }, selecting);
+    });
+  }, []);
+  const selectAll = useCallback(() => {
+    setState((s) => {
+      const lastLine = s.lines.length - 1;
+      return {
+        ...s,
+        anchor: { col: 0, line: 0 },
+        cursor: { col: s.lines[lastLine].length, line: lastLine }
+      };
+    });
+  }, []);
+  const clearSelection = useCallback(() => {
+    setState((s) => s.anchor ? { ...s, anchor: null } : s);
+  }, []);
+  const deleteSelection = useCallback(() => {
+    setState((s) => {
+      if (!s.anchor) {
+        return s;
+      }
+      pushUndo(snapOf(s));
+      return deleteSelectionFromState(s) ?? s;
+    });
+  }, [pushUndo]);
+  const replaceSelection = useCallback(
+    (text) => {
+      setState((s) => {
+        if (!s.anchor) {
+          pushUndo(snapOf(s));
+          return insertIntoState(s, text);
+        }
+        pushUndo(snapOf(s));
+        const base = deleteSelectionFromState(s) ?? s;
+        return insertIntoState(base, text);
+      });
+    },
+    [pushUndo]
+  );
+  const setValue = useCallback((value2) => {
+    const lines = splitLines(value2);
+    setState({
+      anchor: null,
+      cursor: { col: lines.at(-1).length, line: lines.length - 1 },
+      lines
+    });
+    undoStack.current = [];
+    redoStack.current = [];
+  }, []);
+  const undo = useCallback(() => {
+    const previous = undoStack.current.pop();
+    if (!previous) {
+      return;
+    }
+    redoStack.current.push(snapOf(stateRef.current));
+    setState(previous);
+  }, []);
+  const redo = useCallback(() => {
+    const next = redoStack.current.pop();
+    if (!next) {
+      return;
+    }
+    undoStack.current.push(snapOf(stateRef.current));
+    setState(next);
+  }, []);
+  const value = useMemo(() => joinLines(state.lines), [state.lines]);
+  return useMemo(() => {
+    return {
+      anchor: state.anchor,
+      clearSelection,
+      cursor: state.cursor,
+      deleteBack,
+      deleteForward,
+      deleteLine,
+      deleteSelection,
+      deleteToLineEnd,
+      deleteToLineStart,
+      deleteWord,
+      getSelectedText,
+      hasSelection,
+      insert,
+      lines: state.lines,
+      moveCursor,
+      moveToEnd,
+      moveToLineEnd,
+      moveToLineStart,
+      moveToStart,
+      newline,
+      redo,
+      replaceSelection,
+      selectAll,
+      setValue,
+      undo,
+      value
+    };
+  }, [
+    state.anchor,
+    state.cursor,
+    state.lines,
+    value,
+    clearSelection,
+    deleteBack,
+    deleteForward,
+    deleteLine,
+    deleteSelection,
+    deleteToLineEnd,
+    deleteToLineStart,
+    deleteWord,
+    getSelectedText,
+    hasSelection,
+    insert,
+    moveCursor,
+    moveToEnd,
+    moveToLineEnd,
+    moveToLineStart,
+    moveToStart,
+    newline,
+    redo,
+    replaceSelection,
+    selectAll,
+    setValue,
+    undo
+  ]);
+};
+
+export { useTextBuffer as default };

package/dist/packem_shared/useTextSelection-mXtxgsPK.js

@@ -0,0 +1,50 @@
+import { useRef, useState, useEffect, useCallback, useMemo } from 'react';
+import { Selection, Range } from './comparePoints-CGMDnd3_.js';
+import useClipboard from './useClipboard-B_9-adw1.js';
+
+const useTextSelection = (ref, options = {}) => {
+  const { copyOnSelect = false, isActive = true, onSelectionChange } = options;
+  const { copy } = useClipboard();
+  const selectionRef = useRef(new Selection());
+  const selection = selectionRef.current;
+  const [selectedText, setSelectedText] = useState("");
+  const onSelectionChangeRef = useRef(onSelectionChange);
+  onSelectionChangeRef.current = onSelectionChange;
+  useEffect(() => {
+    if (!isActive) {
+      return;
+    }
+    const unsubscribe = selection.onChange(() => {
+      const text = selection.toString();
+      setSelectedText(text);
+      onSelectionChangeRef.current?.(text);
+      if (copyOnSelect && text.length > 0) {
+        copy(text);
+      }
+    });
+    return unsubscribe;
+  }, [isActive, selection, copyOnSelect, copy]);
+  const selectAll = useCallback(() => {
+    const element = ref.current;
+    if (!element || !isActive) {
+      return;
+    }
+    selection.removeAllRanges();
+    const range = new Range();
+    range.selectNodeContents(element);
+    selection.addRange(range);
+  }, [ref, isActive, selection]);
+  const clearSelection = useCallback(() => {
+    selection.removeAllRanges();
+  }, [selection]);
+  return useMemo(() => {
+    return {
+      clearSelection,
+      selectAll,
+      selectedText,
+      selection
+    };
+  }, [clearSelection, selectedText, selectAll, selection]);
+};
+
+export { useTextSelection as default };

package/dist/packem_shared/useTimer-CPQ7j827.js

@@ -0,0 +1,46 @@
+import { useState, useRef, useEffect, useCallback } from 'react';
+import useAnimation from './useAnimation-kj31sA-T.js';
+
+function useTimer(options) {
+  const { autoStart = false, duration, interval = 1e3, onTimeout } = options;
+  const [running, setRunning] = useState(autoStart);
+  const onTimeoutRef = useRef(onTimeout);
+  onTimeoutRef.current = onTimeout;
+  const firedRef = useRef(false);
+  const { reset: resetAnimation, time } = useAnimation({ interval, isActive: running });
+  const remaining = Math.max(0, duration - time);
+  const isFinished = remaining <= 0;
+  useEffect(() => {
+    if (isFinished && running) {
+      setRunning(false);
+      if (!firedRef.current) {
+        firedRef.current = true;
+        onTimeoutRef.current?.();
+      }
+    }
+  }, [isFinished, running]);
+  const start = useCallback(() => {
+    if (!isFinished) {
+      setRunning(true);
+    }
+  }, [isFinished]);
+  const stop = useCallback(() => {
+    setRunning(false);
+  }, []);
+  const toggle = useCallback(() => {
+    setRunning((r) => {
+      if (r) {
+        return false;
+      }
+      return remaining > 0;
+    });
+  }, [remaining]);
+  const reset = useCallback(() => {
+    setRunning(false);
+    firedRef.current = false;
+    resetAnimation();
+  }, [resetAnimation]);
+  return { isFinished, isRunning: running, remaining, reset, start, stop, toggle };
+}
+
+export { useTimer as default };

package/dist/packem_shared/useTreeView-BT57P3Kx.js

@@ -0,0 +1,101 @@
+import { useRef, useCallback } from 'react';
+import useInput from './useInput-Cfp5zB2s.js';
+
+function useTreeView({ isDisabled = false, loadChildren, onLoadError, selectionMode, state }) {
+  const loadingReference = useRef(/* @__PURE__ */ new Set());
+  const stateReference = useRef(state);
+  stateReference.current = state;
+  const loadChildrenReference = useRef(loadChildren);
+  loadChildrenReference.current = loadChildren;
+  const onLoadErrorReference = useRef(onLoadError);
+  onLoadErrorReference.current = onLoadError;
+  const triggerLoad = useCallback(async (nodeId) => {
+    if (loadingReference.current.has(nodeId)) {
+      return;
+    }
+    const currentLoadChildren = loadChildrenReference.current;
+    if (!currentLoadChildren) {
+      return;
+    }
+    const flat = stateReference.current.nodeMap.get(nodeId);
+    if (!flat || flat.childrenIds.length > 0) {
+      return;
+    }
+    loadingReference.current.add(nodeId);
+    stateReference.current.setLoading(nodeId, true);
+    try {
+      const children = await currentLoadChildren(flat.node);
+      stateReference.current.insertChildren(nodeId, children);
+      stateReference.current.expandNode(nodeId);
+    } catch (error) {
+      const normalizedError = error instanceof Error ? error : new Error(String(error));
+      stateReference.current.setChildrenError(nodeId);
+      onLoadErrorReference.current?.(nodeId, normalizedError);
+    } finally {
+      stateReference.current.setLoading(nodeId, false);
+      loadingReference.current.delete(nodeId);
+    }
+  }, []);
+  useInput(
+    (input, key) => {
+      if (key.downArrow) {
+        state.focusNext();
+        return;
+      }
+      if (key.upArrow) {
+        state.focusPrevious();
+        return;
+      }
+      if (key.rightArrow) {
+        if (state.focusedId && state.expandedIds.has(state.focusedId)) {
+          state.focusFirstChild();
+        } else if (state.focusedId) {
+          if (loadChildren) {
+            const flat = state.nodeMap.get(state.focusedId);
+            if (flat && flat.hasChildren && flat.childrenIds.length === 0) {
+              triggerLoad(state.focusedId).catch(() => {
+              });
+              return;
+            }
+          }
+          state.expand();
+        }
+        return;
+      }
+      if (key.leftArrow) {
+        if (state.focusedId && state.expandedIds.has(state.focusedId)) {
+          state.collapse();
+        } else {
+          state.focusParent();
+        }
+        return;
+      }
+      if (key.return) {
+        if (selectionMode === "none") {
+          state.toggleExpanded();
+        } else {
+          state.select();
+        }
+        return;
+      }
+      if (input === " ") {
+        if (selectionMode === "multiple") {
+          state.select();
+        } else {
+          state.toggleExpanded();
+        }
+        return;
+      }
+      if (input === "\x1B[H" || input === "\x1B[1~" || input === "\x1BOH") {
+        state.focusFirst();
+        return;
+      }
+      if (input === "\x1B[F" || input === "\x1B[4~" || input === "\x1BOF") {
+        state.focusLast();
+      }
+    },
+    { isActive: !isDisabled }
+  );
+}
+
+export { useTreeView };