@visulima/tui 1.0.0-alpha.6 → 1.0.0-alpha.8

package/dist/packem_shared/useTextBuffer-C8fEe9Ly.js

@@ -1,398 +0,0 @@
-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-ChrYZXsn.js

@@ -1,50 +0,0 @@
-import { useRef, useState, useEffect, useCallback, useMemo } from 'react';
-import { Selection, Range } from './comparePoints-CAAlhiMS.js';
-import useClipboard from './useClipboard-MNj6MNR-.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/useTimeout-DuCqgWPX.js

@@ -1,34 +0,0 @@
-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-DnBtbhB5.js

@@ -1,46 +0,0 @@
-import { useState, useRef, useEffect, useCallback } from 'react';
-import useAnimation from './useAnimation-DV22qxiJ.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-mkN5Di7w.js

@@ -1,101 +0,0 @@
-import { useRef, useCallback } from 'react';
-import useInput from './useInput-DKZbqMRc.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 };