@visulima/tui 0.0.1 → 1.0.0-alpha.2

package/dist/packem_shared/useTreeViewState-BpS_KZ-K.js

@@ -0,0 +1,502 @@
+import { useReducer, useState, useRef, useEffect, useMemo, useCallback } from 'react';
+import { TreeNodeMap } from './TreeNodeMap-CtJUvBnd.js';
+
+function buildVisibleIdIndex(visibleIds) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [index, visibleId] of visibleIds.entries()) {
+    map.set(visibleId, index);
+  }
+  return map;
+}
+function adjustViewport(state, targetIndex) {
+  if (state.visibleNodeCount >= state.visibleIds.length) {
+    return { viewportFromIndex: 0, viewportToIndex: state.visibleIds.length };
+  }
+  let from = state.viewportFromIndex;
+  let to = state.viewportToIndex;
+  if (targetIndex >= to) {
+    to = targetIndex + 1;
+    from = to - state.visibleNodeCount;
+  }
+  if (targetIndex < from) {
+    from = targetIndex;
+    to = from + state.visibleNodeCount;
+  }
+  return {
+    viewportFromIndex: Math.max(0, from),
+    viewportToIndex: Math.min(state.visibleIds.length, to)
+  };
+}
+function adjustViewportForNewVisible(state, newVisible) {
+  if (state.visibleNodeCount >= newVisible.length) {
+    return { viewportFromIndex: 0, viewportToIndex: newVisible.length };
+  }
+  const focusedIndex = state.focusedId ? newVisible.indexOf(state.focusedId) : -1;
+  if (focusedIndex < 0) {
+    return {
+      viewportFromIndex: 0,
+      viewportToIndex: Math.min(state.visibleNodeCount, newVisible.length)
+    };
+  }
+  let to = Math.min(state.viewportToIndex, newVisible.length);
+  let from = Math.max(0, to - state.visibleNodeCount);
+  if (focusedIndex >= to) {
+    to = focusedIndex + 1;
+    from = to - state.visibleNodeCount;
+  }
+  if (focusedIndex < from) {
+    from = focusedIndex;
+    to = from + state.visibleNodeCount;
+  }
+  return {
+    viewportFromIndex: Math.max(0, from),
+    viewportToIndex: Math.min(newVisible.length, to)
+  };
+}
+function reducer(state, action) {
+  switch (action.type) {
+    case "collapse": {
+      if (!state.focusedId) {
+        return state;
+      }
+      return reducer(state, { nodeId: state.focusedId, type: "collapse-node" });
+    }
+    case "collapse-all": {
+      const newExpanded = /* @__PURE__ */ new Set();
+      const newVisible = state.nodeMap.getVisibleIds(newExpanded);
+      return {
+        ...state,
+        expandedIds: newExpanded,
+        focusedId: newVisible[0],
+        previousExpandedIds: state.expandedIds,
+        viewportFromIndex: 0,
+        viewportToIndex: Math.min(state.visibleNodeCount, newVisible.length),
+        visibleIdIndex: buildVisibleIdIndex(newVisible),
+        visibleIds: newVisible
+      };
+    }
+    case "collapse-node": {
+      const { nodeId } = action;
+      if (!state.expandedIds.has(nodeId)) {
+        return state;
+      }
+      const newExpanded = new Set(state.expandedIds);
+      newExpanded.delete(nodeId);
+      const newVisible = state.nodeMap.getVisibleIds(newExpanded);
+      let newFocusedId = state.focusedId;
+      if (newFocusedId !== void 0 && newFocusedId !== nodeId && state.nodeMap.isDescendantOf(newFocusedId, nodeId)) {
+        newFocusedId = nodeId;
+      }
+      return {
+        ...state,
+        expandedIds: newExpanded,
+        focusedId: newFocusedId,
+        previousExpandedIds: state.expandedIds,
+        visibleIdIndex: buildVisibleIdIndex(newVisible),
+        visibleIds: newVisible,
+        ...adjustViewportForNewVisible({ ...state, focusedId: newFocusedId}, newVisible)
+      };
+    }
+    case "expand": {
+      if (!state.focusedId) {
+        return state;
+      }
+      return reducer(state, { nodeId: state.focusedId, type: "expand-node" });
+    }
+    case "expand-all": {
+      const allParentIds = /* @__PURE__ */ new Set();
+      for (const [id, flat] of state.nodeMap.entries()) {
+        if (flat.hasChildren) {
+          allParentIds.add(id);
+        }
+      }
+      const newVisible = state.nodeMap.getVisibleIds(allParentIds);
+      return {
+        ...state,
+        expandedIds: allParentIds,
+        previousExpandedIds: state.expandedIds,
+        visibleIdIndex: buildVisibleIdIndex(newVisible),
+        visibleIds: newVisible,
+        ...adjustViewportForNewVisible({ ...state}, newVisible)
+      };
+    }
+    case "expand-node": {
+      const { nodeId } = action;
+      const flat = state.nodeMap.get(nodeId);
+      if (!flat?.hasChildren) {
+        return state;
+      }
+      if (state.expandedIds.has(nodeId)) {
+        return state;
+      }
+      const newExpanded = new Set(state.expandedIds);
+      newExpanded.add(nodeId);
+      const newVisible = state.nodeMap.getVisibleIds(newExpanded);
+      return {
+        ...state,
+        expandedIds: newExpanded,
+        previousExpandedIds: state.expandedIds,
+        visibleIdIndex: buildVisibleIdIndex(newVisible),
+        visibleIds: newVisible,
+        ...adjustViewportForNewVisible({ ...state}, newVisible)
+      };
+    }
+    case "focus-first": {
+      if (state.visibleIds.length === 0) {
+        return state;
+      }
+      return {
+        ...state,
+        focusedId: state.visibleIds[0],
+        viewportFromIndex: 0,
+        viewportToIndex: Math.min(state.visibleNodeCount, state.visibleIds.length)
+      };
+    }
+    case "focus-first-child": {
+      if (!state.focusedId) {
+        return state;
+      }
+      const flat = state.nodeMap.get(state.focusedId);
+      if (!flat || flat.childrenIds.length === 0) {
+        return state;
+      }
+      if (!state.expandedIds.has(state.focusedId)) {
+        return state;
+      }
+      const firstChildId = flat.childrenIds[0];
+      const childIndex = state.visibleIdIndex.get(firstChildId) ?? -1;
+      if (childIndex < 0) {
+        return state;
+      }
+      return {
+        ...state,
+        focusedId: firstChildId,
+        ...adjustViewport(state, childIndex)
+      };
+    }
+    case "focus-last": {
+      if (state.visibleIds.length === 0) {
+        return state;
+      }
+      const lastIndex = state.visibleIds.length - 1;
+      return {
+        ...state,
+        focusedId: state.visibleIds[lastIndex],
+        ...adjustViewport(state, lastIndex)
+      };
+    }
+    case "focus-next": {
+      if (!state.focusedId) {
+        return state;
+      }
+      const index = state.visibleIdIndex.get(state.focusedId) ?? -1;
+      if (index < 0 || index >= state.visibleIds.length - 1) {
+        return state;
+      }
+      const nextId = state.visibleIds[index + 1];
+      return {
+        ...state,
+        focusedId: nextId,
+        ...adjustViewport(state, index + 1)
+      };
+    }
+    case "focus-parent": {
+      if (!state.focusedId) {
+        return state;
+      }
+      const flat = state.nodeMap.get(state.focusedId);
+      if (!flat?.parentId) {
+        return state;
+      }
+      const parentIndex = state.visibleIdIndex.get(flat.parentId) ?? -1;
+      if (parentIndex < 0) {
+        return state;
+      }
+      return {
+        ...state,
+        focusedId: flat.parentId,
+        ...adjustViewport(state, parentIndex)
+      };
+    }
+    case "focus-previous": {
+      if (!state.focusedId) {
+        return state;
+      }
+      const index = state.visibleIdIndex.get(state.focusedId) ?? -1;
+      if (index <= 0) {
+        return state;
+      }
+      const previousId = state.visibleIds[index - 1];
+      return {
+        ...state,
+        focusedId: previousId,
+        ...adjustViewport(state, index - 1)
+      };
+    }
+    case "insert-children": {
+      const parentFlat = state.nodeMap.get(action.parentId);
+      if (!parentFlat) {
+        return state;
+      }
+      const newNodeMap = state.nodeMap.withChildren(action.parentId, action.children);
+      const newVisible = newNodeMap.getVisibleIds(state.expandedIds);
+      return {
+        ...state,
+        nodeMap: newNodeMap,
+        visibleIdIndex: buildVisibleIdIndex(newVisible),
+        visibleIds: newVisible
+      };
+    }
+    case "reset": {
+      return action.state;
+    }
+    case "select": {
+      if (!state.focusedId) {
+        return state;
+      }
+      if (state.selectionMode === "none") {
+        return state;
+      }
+      if (state.selectionMode === "single") {
+        const newSelected2 = /* @__PURE__ */ new Set([state.focusedId]);
+        return {
+          ...state,
+          previousSelectedIds: state.selectedIds,
+          selectedIds: newSelected2
+        };
+      }
+      const newSelected = new Set(state.selectedIds);
+      if (newSelected.has(state.focusedId)) {
+        newSelected.delete(state.focusedId);
+      } else {
+        newSelected.add(state.focusedId);
+      }
+      return {
+        ...state,
+        previousSelectedIds: state.selectedIds,
+        selectedIds: newSelected
+      };
+    }
+    case "set-children-error": {
+      const newLoading = new Set(state.loadingIds);
+      newLoading.delete(action.nodeId);
+      return { ...state, loadingIds: newLoading };
+    }
+    case "set-loading": {
+      const newLoading = new Set(state.loadingIds);
+      if (action.isLoading) {
+        newLoading.add(action.nodeId);
+      } else {
+        newLoading.delete(action.nodeId);
+      }
+      return { ...state, loadingIds: newLoading };
+    }
+    case "toggle-expanded": {
+      if (!state.focusedId) {
+        return state;
+      }
+      if (state.expandedIds.has(state.focusedId)) {
+        return reducer(state, { type: "collapse" });
+      }
+      return reducer(state, { type: "expand" });
+    }
+    default: {
+      return state;
+    }
+  }
+}
+function createDefaultState({ data, defaultExpanded, defaultSelected, selectionMode, visibleNodeCount }) {
+  const nodeMap = new TreeNodeMap(data);
+  let expandedIds;
+  if (defaultExpanded === "all") {
+    expandedIds = /* @__PURE__ */ new Set();
+    for (const [id, flat] of nodeMap.entries()) {
+      if (flat.hasChildren) {
+        expandedIds.add(id);
+      }
+    }
+  } else if (defaultExpanded) {
+    expandedIds = new Set(defaultExpanded);
+  } else {
+    expandedIds = /* @__PURE__ */ new Set();
+  }
+  const visibleIds = nodeMap.getVisibleIds(expandedIds);
+  const selectedIds = selectionMode !== "none" && defaultSelected ? new Set(defaultSelected) : /* @__PURE__ */ new Set();
+  const nodeCount = Math.min(visibleNodeCount, visibleIds.length);
+  return {
+    expandedIds,
+    focusedId: visibleIds[0],
+    loadingIds: /* @__PURE__ */ new Set(),
+    nodeMap,
+    previousExpandedIds: expandedIds,
+    previousSelectedIds: selectedIds,
+    selectedIds,
+    selectionMode,
+    viewportFromIndex: 0,
+    viewportToIndex: nodeCount,
+    visibleIdIndex: buildVisibleIdIndex(visibleIds),
+    visibleIds,
+    visibleNodeCount
+  };
+}
+function useTreeViewState({
+  data,
+  defaultExpanded,
+  defaultSelected,
+  onExpandChange,
+  onFocusChange,
+  onSelectChange,
+  selectionMode = "none",
+  visibleNodeCount = Infinity
+}) {
+  const [state, dispatch] = useReducer(reducer, { data, defaultExpanded, defaultSelected, selectionMode, visibleNodeCount }, createDefaultState);
+  const [lastData, setLastData] = useState(data);
+  if (data !== lastData) {
+    dispatch({
+      state: createDefaultState({
+        data,
+        defaultExpanded,
+        defaultSelected,
+        selectionMode,
+        visibleNodeCount
+      }),
+      type: "reset"
+    });
+    setLastData(data);
+  }
+  const onFocusChangeReference = useRef(onFocusChange);
+  onFocusChangeReference.current = onFocusChange;
+  const onExpandChangeReference = useRef(onExpandChange);
+  onExpandChangeReference.current = onExpandChange;
+  const onSelectChangeReference = useRef(onSelectChange);
+  onSelectChangeReference.current = onSelectChange;
+  const isInitialMount = useRef(true);
+  useEffect(() => {
+    if (isInitialMount.current) {
+      isInitialMount.current = false;
+      return;
+    }
+    if (state.focusedId) {
+      onFocusChangeReference.current?.(state.focusedId);
+    }
+  }, [state.focusedId]);
+  useEffect(() => {
+    if (state.expandedIds !== state.previousExpandedIds) {
+      onExpandChangeReference.current?.(state.expandedIds);
+    }
+  }, [state.expandedIds, state.previousExpandedIds]);
+  useEffect(() => {
+    if (state.selectedIds !== state.previousSelectedIds) {
+      onSelectChangeReference.current?.(state.selectedIds);
+    }
+  }, [state.selectedIds, state.previousSelectedIds]);
+  const viewportNodes = useMemo(
+    () => state.visibleIds.slice(state.viewportFromIndex, state.viewportToIndex).map((id) => {
+      const flat = state.nodeMap.get(id);
+      return {
+        node: flat.node,
+        state: {
+          depth: flat.depth,
+          hasChildren: flat.hasChildren,
+          isExpanded: state.expandedIds.has(id),
+          isFocused: id === state.focusedId,
+          isLoading: state.loadingIds.has(id),
+          isSelected: state.selectedIds.has(id)
+        }
+      };
+    }),
+    [
+      state.visibleIds,
+      state.viewportFromIndex,
+      state.viewportToIndex,
+      state.focusedId,
+      state.expandedIds,
+      state.selectedIds,
+      state.nodeMap,
+      state.loadingIds
+    ]
+  );
+  const focusNext = useCallback(() => {
+    dispatch({ type: "focus-next" });
+  }, []);
+  const focusPrevious = useCallback(() => {
+    dispatch({ type: "focus-previous" });
+  }, []);
+  const focusFirst = useCallback(() => {
+    dispatch({ type: "focus-first" });
+  }, []);
+  const focusLast = useCallback(() => {
+    dispatch({ type: "focus-last" });
+  }, []);
+  const expand = useCallback(() => {
+    dispatch({ type: "expand" });
+  }, []);
+  const expandNode = useCallback((nodeId) => {
+    dispatch({ nodeId, type: "expand-node" });
+  }, []);
+  const collapse = useCallback(() => {
+    dispatch({ type: "collapse" });
+  }, []);
+  const collapseNode = useCallback((nodeId) => {
+    dispatch({ nodeId, type: "collapse-node" });
+  }, []);
+  const toggleExpanded = useCallback(() => {
+    dispatch({ type: "toggle-expanded" });
+  }, []);
+  const expandAll = useCallback(() => {
+    dispatch({ type: "expand-all" });
+  }, []);
+  const collapseAll = useCallback(() => {
+    dispatch({ type: "collapse-all" });
+  }, []);
+  const select = useCallback(() => {
+    dispatch({ type: "select" });
+  }, []);
+  const focusParent = useCallback(() => {
+    dispatch({ type: "focus-parent" });
+  }, []);
+  const focusFirstChild = useCallback(() => {
+    dispatch({ type: "focus-first-child" });
+  }, []);
+  const setLoading = useCallback((nodeId, isLoading) => {
+    dispatch({ isLoading, nodeId, type: "set-loading" });
+  }, []);
+  const setChildrenError = useCallback((nodeId) => {
+    dispatch({ nodeId, type: "set-children-error" });
+  }, []);
+  const insertChildren = useCallback((parentId, children) => {
+    dispatch({ children, parentId, type: "insert-children" });
+  }, []);
+  return {
+    collapse,
+    collapseAll,
+    collapseNode,
+    expand,
+    expandAll,
+    expandedIds: state.expandedIds,
+    expandNode,
+    focusedId: state.focusedId,
+    focusFirst,
+    focusFirstChild,
+    focusLast,
+    focusNext,
+    focusParent,
+    focusPrevious,
+    hasScrollDown: state.viewportToIndex < state.visibleIds.length,
+    hasScrollUp: state.viewportFromIndex > 0,
+    insertChildren,
+    loadingIds: state.loadingIds,
+    nodeMap: state.nodeMap,
+    select,
+    selectedIds: state.selectedIds,
+    setChildrenError,
+    setLoading,
+    toggleExpanded,
+    viewportFromIndex: state.viewportFromIndex,
+    viewportNodes,
+    viewportToIndex: state.viewportToIndex,
+    visibleCount: state.visibleIds.length
+  };
+}
+
+export { createDefaultState, reducer, useTreeViewState };

package/dist/packem_shared/useWindowSize-ugEmGZJm.js

@@ -0,0 +1,20 @@
+import { useState, useEffect } from 'react';
+import { g as getWindowSize } from './utils-BgdlrbOH.js';
+import useStdout from './useStdout-DyF6DSH0.js';
+
+const useWindowSize = () => {
+  const { stdout } = useStdout();
+  const [size, setSize] = useState(() => getWindowSize(stdout));
+  useEffect(() => {
+    const onResize = () => {
+      setSize(getWindowSize(stdout));
+    };
+    stdout.on("resize", onResize);
+    return () => {
+      stdout.off("resize", onResize);
+    };
+  }, [stdout]);
+  return size;
+};
+
+export { useWindowSize as default };

package/dist/packem_shared/utils-BgdlrbOH.js

@@ -0,0 +1,140 @@
+import { createRequire as __cjs_createRequire } from "node:module";
+
+const __cjs_require = __cjs_createRequire(import.meta.url);
+
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+
+const __cjs_getBuiltinModule = (module) => {
+    // Check if we're in Node.js and version supports getBuiltinModule
+    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+        // Node.js 20.16.0+ and 22.3.0+
+        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
+            return __cjs_getProcess.getBuiltinModule(module);
+        }
+    }
+    // Fallback to createRequire
+    return __cjs_require(module);
+};
+
+const process = __cjs_getProcess;
+const {
+  execFileSync
+} = __cjs_getBuiltinModule("node:child_process");
+const fs = __cjs_getBuiltinModule("node:fs");
+const tty = __cjs_getBuiltinModule("node:tty");
+
+const defaultColumns = 80;
+const defaultRows = 24;
+const exec = (command, arguments_, { shell, env } = {}) => execFileSync(command, arguments_, {
+  encoding: "utf8",
+  stdio: ["ignore", "pipe", "ignore"],
+  timeout: 500,
+  shell,
+  env
+}).trim();
+const create = (columns, rows) => ({
+  columns: Number.parseInt(columns, 10),
+  rows: Number.parseInt(rows, 10)
+});
+const createIfNotDefault = (maybeColumns, maybeRows) => {
+  const { columns, rows } = create(maybeColumns, maybeRows);
+  if (Number.isNaN(columns) || Number.isNaN(rows)) {
+    return;
+  }
+  if (columns === defaultColumns && rows === defaultRows) {
+    return;
+  }
+  return { columns, rows };
+};
+const isForegroundProcess = () => {
+  if (process.platform !== "linux") {
+    return true;
+  }
+  try {
+    const statContents = fs.readFileSync("/proc/self/stat", "utf8");
+    const closingParenthesisIndex = statContents.lastIndexOf(") ");
+    if (closingParenthesisIndex === -1) {
+      return false;
+    }
+    const statFields = statContents.slice(closingParenthesisIndex + 2).trim().split(/\s+/);
+    const processGroupId = Number.parseInt(statFields[2], 10);
+    const foregroundProcessGroupId = Number.parseInt(statFields[5], 10);
+    if (Number.isNaN(processGroupId) || Number.isNaN(foregroundProcessGroupId)) {
+      return false;
+    }
+    if (foregroundProcessGroupId <= 0) {
+      return false;
+    }
+    return processGroupId === foregroundProcessGroupId;
+  } catch {
+    return false;
+  }
+};
+function terminalSize() {
+  const { env, stdout, stderr } = process;
+  if (stdout?.columns && stdout?.rows) {
+    return create(stdout.columns, stdout.rows);
+  }
+  if (stderr?.columns && stderr?.rows) {
+    return create(stderr.columns, stderr.rows);
+  }
+  if (env.COLUMNS && env.LINES) {
+    return create(env.COLUMNS, env.LINES);
+  }
+  const fallback = {
+    columns: defaultColumns,
+    rows: defaultRows
+  };
+  if (process.platform === "win32") {
+    return tput() ?? fallback;
+  }
+  if (process.platform === "darwin") {
+    return devTty() ?? tput() ?? fallback;
+  }
+  return devTty() ?? tput() ?? resize() ?? fallback;
+}
+const devTty = () => {
+  try {
+    const flags = process.platform === "darwin" ? fs.constants.O_EVTONLY | fs.constants.O_NONBLOCK : fs.constants.O_NONBLOCK;
+    const { columns, rows } = tty.WriteStream(fs.openSync("/dev/tty", flags));
+    return { columns, rows };
+  } catch {
+  }
+};
+const tput = () => {
+  try {
+    const columns = exec("tput", ["cols"], { env: { TERM: "dumb", ...process.env } });
+    const rows = exec("tput", ["lines"], { env: { TERM: "dumb", ...process.env } });
+    if (columns && rows) {
+      return createIfNotDefault(columns, rows);
+    }
+  } catch {
+  }
+};
+const resize = () => {
+  try {
+    if (!isForegroundProcess()) {
+      return;
+    }
+    const size = exec("resize", ["-u"]).match(/\d+/g);
+    if (size.length === 2) {
+      return createIfNotDefault(size[0], size[1]);
+    }
+  } catch {
+  }
+};
+
+const getWindowSize = (stdout) => {
+  const { columns, rows } = stdout;
+  if (columns && rows) {
+    return { columns, rows };
+  }
+  const fallbackSize = terminalSize();
+  return {
+    columns: columns || fallbackSize.columns || 80,
+    rows: rows || fallbackSize.rows || 24
+  };
+};
+
+export { getWindowSize as g };

package/dist/packem_shared/variant-config-DSZoX5TM.js

@@ -0,0 +1,8 @@
+const VARIANT_CONFIG = {
+  error: { color: "red", icon: "✖" },
+  info: { color: "blue", icon: "ℹ" },
+  success: { color: "green", icon: "✔" },
+  warning: { color: "yellow", icon: "⚠" }
+};
+
+export { VARIANT_CONFIG as V };