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

package/dist/packem_shared/Renderer-zZ5O3vxc.js

@@ -1,31 +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 {
-  createRequire
-} = __cjs_getBuiltinModule("node:module");
-
-const require$1 = createRequire(import.meta.url);
-const native = require$1("../../index.js");
-const _native = native;
-const Renderer = _native.Renderer;
-const TerminalGuard = _native.TerminalGuard;
-const terminalSize = _native.terminalSize;
-
-export { Renderer, TerminalGuard, terminalSize };

package/dist/packem_shared/ResizeObserverEntry-Br4seLeQ.js

@@ -1,102 +0,0 @@
-class ResizeObserverEntry {
-  constructor(target, contentRect) {
-    this.target = target;
-    this.contentRect = contentRect;
-  }
-  target;
-  contentRect;
-}
-class ResizeObserver {
-  callback;
-  observedElements = /* @__PURE__ */ new Set();
-  constructor(callback) {
-    this.callback = callback;
-  }
-  observe(element) {
-    if (this.observedElements.has(element)) {
-      return;
-    }
-    this.observedElements.add(element);
-    element.resizeObservers ??= /* @__PURE__ */ new Set();
-    element.resizeObservers.add(this);
-    let lastMeasuredSize = element.internal_lastMeasuredSize;
-    if (lastMeasuredSize === void 0 && element.yogaNode) {
-      const width = element.yogaNode.getComputedWidth();
-      const height = element.yogaNode.getComputedHeight();
-      if (!Number.isNaN(width) && !Number.isNaN(height)) {
-        lastMeasuredSize = { height, width };
-        element.internal_lastMeasuredSize = lastMeasuredSize;
-      }
-    }
-    if (lastMeasuredSize) {
-      const entry = new ResizeObserverEntry(element, lastMeasuredSize);
-      try {
-        this.callback([entry], this);
-      } catch (error) {
-        console.error(error);
-      }
-    }
-  }
-  unobserve(element) {
-    this.observedElements.delete(element);
-    element.resizeObservers?.delete(this);
-  }
-  disconnect() {
-    for (const element of this.observedElements) {
-      element.resizeObservers?.delete(this);
-    }
-    this.observedElements.clear();
-  }
-  /**
-   * Internal method called by the layout engine after computing layout.
-   */
-  internalTrigger(entries) {
-    try {
-      this.callback(entries, this);
-    } catch (error) {
-      console.error(error);
-    }
-  }
-}
-function measureAndExtractObservers(node, observerEntries, forceCache = false) {
-  const hasObservers = node.resizeObservers && node.resizeObservers.size > 0;
-  if ((hasObservers || forceCache) && node.yogaNode) {
-    const width = node.yogaNode.getComputedWidth();
-    const height = node.yogaNode.getComputedHeight();
-    if (!Number.isNaN(width) && !Number.isNaN(height)) {
-      const lastSize = node.internal_lastMeasuredSize;
-      if (lastSize?.width !== width || lastSize.height !== height) {
-        node.internal_lastMeasuredSize = { height, width };
-        if (hasObservers) {
-          const entry = new ResizeObserverEntry(node, { height, width });
-          for (const observer of node.resizeObservers) {
-            if (!observerEntries.has(observer)) {
-              observerEntries.set(observer, []);
-            }
-            observerEntries.get(observer).push(entry);
-          }
-        }
-      }
-    }
-  }
-}
-function triggerResizeObservers(node, forceCache = false) {
-  const observerEntries = /* @__PURE__ */ new Map();
-  function traverse(n) {
-    measureAndExtractObservers(n, observerEntries, forceCache);
-    if (n.internal_static) {
-      return;
-    }
-    for (const child of n.childNodes) {
-      if (child.nodeName !== "#text") {
-        traverse(child);
-      }
-    }
-  }
-  traverse(node);
-  for (const [observer, entries] of observerEntries) {
-    observer.internalTrigger(entries);
-  }
-}
-
-export { ResizeObserverEntry, ResizeObserver as default, measureAndExtractObservers, triggerResizeObservers };

package/dist/packem_shared/ScrollBar-EWAs2Uc7.js

@@ -1,106 +0,0 @@
-import { jsx, jsxs } from 'react/jsx-runtime';
-import { useMemo } from 'react';
-import Box from './Box-D_pSJ9Jp.js';
-import Text from './Text-DvAUdZcK.js';
-
-const STYLE_CHARS = {
-  arrow: { lowerThumb: "╽", thumb: "┃", track: "|", upperThumb: "╿" },
-  block: { thumb: "█", track: "░" },
-  bold: { lowerThumb: "╿", thumb: "│", track: "┃", upperThumb: "╽" },
-  classic: { thumb: "┃", track: "|" },
-  dots: { thumb: "●", track: "·" },
-  double: { thumb: "┃", track: "║" },
-  doubleSingle: { lowerThumb: "╽", thumb: "┃", track: "│", upperThumb: "╿" },
-  line: { thumb: "│", track: " " },
-  round: { lowerThumb: "╽", thumb: "┃", track: "│", upperThumb: "╿" },
-  single: { lowerThumb: "╽", thumb: "┃", track: "│", upperThumb: "╿" },
-  singleDouble: { thumb: "┃", track: "║" },
-  thick: { thumb: "┃", track: "╏" }
-};
-const CORNER_CHARS = {
-  arrow: { bottomLeft: "└", bottomRight: "┘", topLeft: "┌", topRight: "┐" },
-  bold: { bottomLeft: "┗", bottomRight: "┛", topLeft: "┏", topRight: "┓" },
-  classic: { bottomLeft: "+", bottomRight: "+", topLeft: "+", topRight: "+" },
-  double: { bottomLeft: "╚", bottomRight: "╝", topLeft: "╔", topRight: "╗" },
-  doubleSingle: { bottomLeft: "╘", bottomRight: "╛", topLeft: "╒", topRight: "╕" },
-  round: { bottomLeft: "╰", bottomRight: "╯", topLeft: "╭", topRight: "╮" },
-  single: { bottomLeft: "└", bottomRight: "┘", topLeft: "┌", topRight: "┐" },
-  singleDouble: { bottomLeft: "╙", bottomRight: "╜", topLeft: "╓", topRight: "╖" }
-};
-const getStyleChars = (style) => {
-  const key = typeof style === "string" ? style : "single";
-  return STYLE_CHARS[key] ?? STYLE_CHARS["single"] ?? { thumb: "┃", track: "│" };
-};
-const getCornerChars = (style) => {
-  const key = typeof style === "string" ? style : "single";
-  return CORNER_CHARS[key] ?? CORNER_CHARS["single"] ?? { bottomLeft: "└", bottomRight: "┘", topLeft: "┌", topRight: "┐" };
-};
-const ScrollBar = ({
-  autoHide = false,
-  color,
-  contentHeight,
-  dimColor,
-  placement = "right",
-  scrollOffset,
-  style,
-  thumbChar,
-  trackChar,
-  viewportHeight
-}) => {
-  const chars = useMemo(() => {
-    const effectiveContentHeight = Math.max(contentHeight, viewportHeight);
-    if (autoHide && effectiveContentHeight <= viewportHeight) {
-      return null;
-    }
-    const styleChars = getStyleChars(style);
-    const resolvedThumbChar = thumbChar ?? styleChars.thumb;
-    const resolvedTrackChar = trackChar ?? styleChars.track;
-    const totalHalfSteps = viewportHeight * 2;
-    const viewportRatio = Math.min(viewportHeight / effectiveContentHeight, 1);
-    const thumbLengthHalf = Math.max(2, Math.round(totalHalfSteps * viewportRatio));
-    const maxScrollOffset = effectiveContentHeight - viewportHeight;
-    const scrollProgress = maxScrollOffset > 0 ? Math.min(Math.max(scrollOffset / maxScrollOffset, 0), 1) : 0;
-    const maxThumbStartHalf = totalHalfSteps - thumbLengthHalf;
-    const thumbStartHalf = Math.round(scrollProgress * maxThumbStartHalf);
-    const thumbEndHalf = thumbStartHalf + thumbLengthHalf;
-    const result = [];
-    for (let row = 0; row < viewportHeight; row += 1) {
-      const upperHalf = row * 2;
-      const lowerHalf = row * 2 + 1;
-      const upperIsThumb = upperHalf >= thumbStartHalf && upperHalf < thumbEndHalf;
-      const lowerIsThumb = lowerHalf >= thumbStartHalf && lowerHalf < thumbEndHalf;
-      if (upperIsThumb && lowerIsThumb) {
-        result.push(resolvedThumbChar);
-      } else if (upperIsThumb && !lowerIsThumb) {
-        result.push(styleChars.lowerThumb ?? resolvedThumbChar);
-      } else if (!upperIsThumb && lowerIsThumb) {
-        result.push(styleChars.upperThumb ?? resolvedThumbChar);
-      } else {
-        result.push(resolvedTrackChar);
-      }
-    }
-    return result;
-  }, [contentHeight, viewportHeight, scrollOffset, style, thumbChar, trackChar, autoHide]);
-  if (chars === null) {
-    return null;
-  }
-  if (placement === "inset") {
-    return jsx(Box, { flexDirection: "column", flexShrink: 0, width: 1, children: chars.map((char, index) => (
-      // eslint-disable-next-line react-x/no-array-index-key
-      jsx(Text, { color, dimColor, children: char }, index)
-    )) });
-  }
-  const cornerChars = getCornerChars(style);
-  const topCorner = placement === "left" ? cornerChars.topLeft : cornerChars.topRight;
-  const bottomCorner = placement === "left" ? cornerChars.bottomLeft : cornerChars.bottomRight;
-  return jsxs(Box, { flexDirection: "column", flexShrink: 0, width: 1, children: [
-    jsx(Text, { color, dimColor, children: topCorner }),
-    chars.map((char, index) => (
-      // eslint-disable-next-line react-x/no-array-index-key
-      jsx(Text, { color, dimColor, children: char }, index)
-    )),
-    jsx(Text, { color, dimColor, children: bottomCorner })
-  ] });
-};
-
-export { ScrollBar, ScrollBar as default };

package/dist/packem_shared/ScrollBarBox-DTNNlh7R.js

@@ -1,72 +0,0 @@
-import { jsxs, jsx } from 'react/jsx-runtime';
-import Box from './Box-D_pSJ9Jp.js';
-import { ScrollBar } from './ScrollBar-EWAs2Uc7.js';
-
-const ScrollBarBox = ({
-  borderColor,
-  borderDimColor,
-  borderLeftColor,
-  borderLeftDimColor,
-  borderRightColor,
-  borderRightDimColor,
-  borderStyle = "single",
-  children,
-  contentHeight,
-  height,
-  scrollBarAutoHide = false,
-  scrollBarPosition = "right",
-  scrollOffset,
-  thumbChar,
-  viewportHeight,
-  ...boxProps
-}) => {
-  const isLeft = scrollBarPosition === "left";
-  const scrollBarPlacement = isLeft ? "left" : "right";
-  const scrollBarColor = isLeft ? borderLeftColor ?? borderColor : borderRightColor ?? borderColor;
-  const scrollBarDimColor = isLeft ? borderLeftDimColor ?? borderDimColor : borderRightDimColor ?? borderDimColor;
-  return jsxs(Box, { flexDirection: "row", height, ...boxProps, children: [
-    isLeft && jsx(
-      ScrollBar,
-      {
-        autoHide: scrollBarAutoHide,
-        color: scrollBarColor,
-        contentHeight,
-        dimColor: scrollBarDimColor,
-        placement: scrollBarPlacement,
-        scrollOffset,
-        style: borderStyle,
-        thumbChar,
-        viewportHeight
-      }
-    ),
-    jsx(
-      Box,
-      {
-        borderColor,
-        borderDimColor,
-        borderLeft: !isLeft,
-        borderRight: isLeft,
-        borderStyle,
-        flexGrow: 1,
-        overflow: "hidden",
-        children
-      }
-    ),
-    !isLeft && jsx(
-      ScrollBar,
-      {
-        autoHide: scrollBarAutoHide,
-        color: scrollBarColor,
-        contentHeight,
-        dimColor: scrollBarDimColor,
-        placement: scrollBarPlacement,
-        scrollOffset,
-        style: borderStyle,
-        thumbChar,
-        viewportHeight
-      }
-    )
-  ] });
-};
-
-export { ScrollBarBox, ScrollBarBox as default };

package/dist/packem_shared/ScrollList-DCeIFL8M.js

@@ -1,227 +0,0 @@
-import { jsx } from 'react/jsx-runtime';
-import { useRef, useState, useEffect, useCallback, useImperativeHandle } from 'react';
-import useScrollInput from './useScrollInput-D3CpBq_a.js';
-import { C as ControlledScrollView } from './ControlledScrollView-BlOaxcsN.js';
-
-const ScrollList = (props) => {
-  const {
-    children,
-    keyboard = false,
-    onContentHeightChange,
-    onItemHeightChange,
-    onScroll,
-    onViewportSizeChange,
-    overscan,
-    ref,
-    scrollAlignment = "auto",
-    selectedIndex,
-    vimBindings = false,
-    virtualize,
-    ...boxProps
-  } = props;
-  const scrollViewRef = useRef(null);
-  const [scrollOffset, setScrollOffset] = useState(0);
-  const scrollOffsetRef = useRef(0);
-  useEffect(() => {
-    scrollOffsetRef.current = scrollOffset;
-  }, [scrollOffset]);
-  const updateScroll = useCallback(
-    (newOffset) => {
-      if (newOffset !== scrollOffsetRef.current) {
-        setScrollOffset(newOffset);
-        onScroll?.(newOffset);
-      }
-    },
-    [onScroll]
-  );
-  const selectedIndexRef = useRef(selectedIndex);
-  selectedIndexRef.current = selectedIndex;
-  const getSelectionVisibleBounds = useCallback(() => {
-    const currentSelectedIndex = selectedIndexRef.current;
-    if (currentSelectedIndex === void 0 || currentSelectedIndex < 0) {
-      return null;
-    }
-    const position = scrollViewRef.current?.getItemPosition(currentSelectedIndex);
-    if (!position) {
-      return null;
-    }
-    const viewportHeight = scrollViewRef.current?.getViewportHeight() ?? 0;
-    const contentHeight = scrollViewRef.current?.getContentHeight() ?? 0;
-    let minOffset = position.top + position.height - viewportHeight;
-    let maxOffset = position.top;
-    if (minOffset > maxOffset) {
-      [minOffset, maxOffset] = [maxOffset, minOffset];
-    }
-    const globalMaxScroll = Math.max(0, contentHeight - viewportHeight);
-    return {
-      max: Math.min(globalMaxScroll, maxOffset),
-      min: Math.max(0, minOffset)
-    };
-  }, []);
-  const clampToSelectionBounds = useCallback(
-    (targetOffset) => {
-      const contentHeight = scrollViewRef.current?.getContentHeight() ?? 0;
-      const viewportHeight = scrollViewRef.current?.getViewportHeight() ?? 0;
-      const globalMaxScroll = Math.max(0, contentHeight - viewportHeight);
-      let clampedOffset = Math.max(0, Math.min(targetOffset, globalMaxScroll));
-      const selectionBounds = getSelectionVisibleBounds();
-      if (selectionBounds) {
-        clampedOffset = Math.max(selectionBounds.min, Math.min(clampedOffset, selectionBounds.max));
-      }
-      return clampedOffset;
-    },
-    [getSelectionVisibleBounds]
-  );
-  const getConstrainedScrollOffset = useCallback((index, currentOffset, mode, viewportHeightOverride) => {
-    const position = scrollViewRef.current?.getItemPosition(index);
-    if (!position) {
-      return currentOffset;
-    }
-    const viewportHeight = viewportHeightOverride ?? scrollViewRef.current?.getViewportHeight() ?? 0;
-    const contentHeight = scrollViewRef.current?.getContentHeight() ?? 0;
-    let target = currentOffset;
-    switch (mode) {
-      case "bottom": {
-        target = position.top + position.height - viewportHeight;
-        break;
-      }
-      case "center": {
-        target = position.top + position.height / 2 - viewportHeight / 2;
-        break;
-      }
-      case "top": {
-        target = position.top;
-        break;
-      }
-      default: {
-        const itemBottom = position.top + position.height;
-        const isFillingViewport = position.top <= currentOffset && itemBottom >= currentOffset + viewportHeight;
-        if (isFillingViewport) {
-          target = currentOffset;
-        } else if (position.top < currentOffset) {
-          target = position.top;
-        } else if (itemBottom > currentOffset + viewportHeight) {
-          target = itemBottom - viewportHeight;
-        }
-      }
-    }
-    const maxScroll = Math.max(0, contentHeight - viewportHeight);
-    return Math.max(0, Math.min(target, maxScroll));
-  }, []);
-  let renderScrollOffset = scrollOffset;
-  if (selectedIndex !== void 0 && selectedIndex >= 0) {
-    renderScrollOffset = getConstrainedScrollOffset(selectedIndex, scrollOffset, scrollAlignment);
-  }
-  useEffect(() => {
-    if (renderScrollOffset !== scrollOffset) {
-      updateScroll(renderScrollOffset);
-    }
-  }, [renderScrollOffset, scrollOffset, updateScroll]);
-  const handleViewportSizeChange = useCallback(
-    (size, previousSize) => {
-      if (selectedIndexRef.current !== void 0 && selectedIndexRef.current >= 0) {
-        const newOffset = getConstrainedScrollOffset(selectedIndexRef.current, scrollOffset, scrollAlignment, size.height);
-        updateScroll(newOffset);
-      }
-      onViewportSizeChange?.(size, previousSize);
-    },
-    [onViewportSizeChange, getConstrainedScrollOffset, scrollOffset, scrollAlignment, updateScroll]
-  );
-  const handleItemHeightChange = useCallback(
-    (index, height, previousHeight) => {
-      const currentSelectedIndex = selectedIndexRef.current;
-      if (currentSelectedIndex !== void 0 && currentSelectedIndex >= 0) {
-        if (index < currentSelectedIndex) {
-          const newOffset = clampToSelectionBounds(scrollOffset + (height - previousHeight));
-          updateScroll(newOffset);
-        } else if (index === currentSelectedIndex) {
-          const newOffset = getConstrainedScrollOffset(index, scrollOffset, scrollAlignment);
-          updateScroll(newOffset);
-        }
-      }
-      onItemHeightChange?.(index, height, previousHeight);
-    },
-    [onItemHeightChange, getConstrainedScrollOffset, scrollAlignment, scrollOffset, clampToSelectionBounds, updateScroll]
-  );
-  const handleContentHeightChange = useCallback(
-    (height, previousHeight) => {
-      if (selectedIndexRef.current !== void 0 && selectedIndexRef.current >= 0) {
-        const newOffset = getConstrainedScrollOffset(selectedIndexRef.current, scrollOffset, scrollAlignment);
-        updateScroll(newOffset);
-      }
-      onContentHeightChange?.(height, previousHeight);
-    },
-    [onContentHeightChange, getConstrainedScrollOffset, scrollOffset, scrollAlignment, updateScroll]
-  );
-  const viewportHeightRef = useRef(0);
-  const scrollByImperative = useCallback(
-    (delta) => {
-      const currentOffset = scrollOffsetRef.current;
-      const clampedY = clampToSelectionBounds(currentOffset + delta);
-      updateScroll(clampedY);
-    },
-    [clampToSelectionBounds, updateScroll]
-  );
-  const scrollToBottomImperative = useCallback(() => {
-    const contentHeight = scrollViewRef.current?.getContentHeight() ?? 0;
-    const viewportHeight = scrollViewRef.current?.getViewportHeight() ?? 0;
-    const maxScroll = Math.max(0, contentHeight - viewportHeight);
-    const clampedY = clampToSelectionBounds(maxScroll);
-    updateScroll(clampedY);
-  }, [clampToSelectionBounds, updateScroll]);
-  const scrollToTopImperative = useCallback(() => {
-    const clampedY = clampToSelectionBounds(0);
-    updateScroll(clampedY);
-  }, [clampToSelectionBounds, updateScroll]);
-  const getViewportHeight = useCallback(() => viewportHeightRef.current, []);
-  useScrollInput({
-    getViewportHeight,
-    isActive: keyboard,
-    scrollBy: scrollByImperative,
-    scrollToBottom: scrollToBottomImperative,
-    scrollToTop: scrollToTopImperative,
-    vimBindings
-  });
-  useImperativeHandle(ref, () => {
-    return {
-      getBottomOffset: () => scrollViewRef.current?.getBottomOffset() ?? 0,
-      getContentHeight: () => scrollViewRef.current?.getContentHeight() ?? 0,
-      getItemHeight: (index) => scrollViewRef.current?.getItemHeight(index) ?? 0,
-      getItemPosition: (index) => scrollViewRef.current?.getItemPosition(index) ?? null,
-      getScrollOffset: () => scrollOffsetRef.current,
-      getViewportHeight: () => scrollViewRef.current?.getViewportHeight() ?? 0,
-      remeasure: () => scrollViewRef.current?.remeasure(),
-      remeasureItem: (index) => scrollViewRef.current?.remeasureItem(index),
-      scrollBy: scrollByImperative,
-      scrollTo: (y) => {
-        const clampedY = clampToSelectionBounds(y);
-        updateScroll(clampedY);
-      },
-      scrollToBottom: scrollToBottomImperative,
-      scrollToTop: scrollToTopImperative
-    };
-  }, [clampToSelectionBounds, updateScroll, scrollByImperative, scrollToBottomImperative, scrollToTopImperative]);
-  const handleViewportSizeChangeWithTracking = useCallback(
-    (size, previousSize) => {
-      viewportHeightRef.current = size.height;
-      handleViewportSizeChange(size, previousSize);
-    },
-    [handleViewportSizeChange]
-  );
-  return jsx(
-    ControlledScrollView,
-    {
-      onContentHeightChange: handleContentHeightChange,
-      onItemHeightChange: handleItemHeightChange,
-      onViewportSizeChange: handleViewportSizeChangeWithTracking,
-      overscan,
-      ref: scrollViewRef,
-      scrollOffset: renderScrollOffset,
-      virtualize,
-      ...boxProps,
-      children
-    }
-  );
-};
-
-export { ScrollList };