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

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

@@ -1,502 +0,0 @@
-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-D3UU41mv.js

@@ -1,20 +0,0 @@
-import { useState, useEffect } from 'react';
-import { g as getWindowSize } from './utils-BgdlrbOH.js';
-import useStdout from './useStdout-B5yRcg9N.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

@@ -1,140 +0,0 @@
-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

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

package/dist/packem_shared/waitFor-Cv9M2jKA.js

@@ -1,39 +0,0 @@
-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 };