@visulima/tui 0.0.1 → 1.0.0-alpha.2

package/dist/packem_shared/comparePoints-CGMDnd3_.js

@@ -0,0 +1,287 @@
+import { g as getPathToRoot } from './dom-DvzhsAez.js';
+import { t as toStyledLine } from './measure-text-DItZYotK.js';
+import { squashTextNodesWithMap } from './squashTextNodesWithMap-iqm6OMMT.js';
+
+const getPlainTextFromDomNode = (node) => {
+  if (node.nodeName === "#text") {
+    const styledLine2 = toStyledLine(node.nodeValue);
+    const charOffsetMap2 = /* @__PURE__ */ new Map([[node, { end: styledLine2.length, start: 0 }]]);
+    return { charOffsetMap: charOffsetMap2, styledLine: styledLine2 };
+  }
+  const charOffsetMap = /* @__PURE__ */ new Map();
+  const offsetRef = { current: 0 };
+  const text = squashTextNodesWithMap(node, charOffsetMap, offsetRef);
+  const styledLine = toStyledLine(text);
+  charOffsetMap.set(node, { end: styledLine.length, start: 0 });
+  return { charOffsetMap, styledLine };
+};
+const getRangeCharacterOffsets = (range, charOffsetMap) => {
+  if (!range.startContainer || !range.endContainer) {
+    return void 0;
+  }
+  const getOffset = (node, offset) => {
+    const nodeRange = charOffsetMap.get(node);
+    if (!nodeRange) {
+      return void 0;
+    }
+    if (node.nodeName === "#text") {
+      return nodeRange.start + offset;
+    }
+    const element = node;
+    if (offset >= element.childNodes.length) {
+      return nodeRange.end;
+    }
+    const child = element.childNodes[offset];
+    const childRange = charOffsetMap.get(child);
+    if (childRange) {
+      return childRange.start;
+    }
+    for (let index = offset - 1; index >= 0; index--) {
+      const sibling = element.childNodes[index];
+      const siblingRange = charOffsetMap.get(sibling);
+      if (siblingRange) {
+        return siblingRange.end;
+      }
+    }
+    return nodeRange.start;
+  };
+  const start = getOffset(range.startContainer, range.startOffset);
+  const end = getOffset(range.endContainer, range.endOffset);
+  if (start === void 0 || end === void 0) {
+    return void 0;
+  }
+  return { end, start };
+};
+const comparePoints = (nodeA, offsetA, nodeB, offsetB) => {
+  if (nodeA === nodeB) {
+    return offsetA === offsetB ? 0 : offsetA < offsetB ? -1 : 1;
+  }
+  const pathA = getPathToRoot(nodeA);
+  const pathB = getPathToRoot(nodeB);
+  let lca;
+  let index = 0;
+  while (index < pathA.length && index < pathB.length && pathA[index] === pathB[index]) {
+    lca = pathA[index];
+    index++;
+  }
+  if (!lca) {
+    return 0;
+  }
+  if (index === pathA.length) {
+    const childB2 = pathB[index];
+    const indexChildB2 = nodeA.childNodes.indexOf(childB2);
+    if (offsetA <= indexChildB2) {
+      return -1;
+    }
+    return 1;
+  }
+  if (index === pathB.length) {
+    const childA2 = pathA[index];
+    const indexChildA2 = nodeB.childNodes.indexOf(childA2);
+    if (indexChildA2 < offsetB) {
+      return -1;
+    }
+    return 1;
+  }
+  const childA = pathA[index];
+  const childB = pathB[index];
+  const indexChildA = lca.childNodes.indexOf(childA);
+  const indexChildB = lca.childNodes.indexOf(childB);
+  return indexChildA < indexChildB ? -1 : 1;
+};
+class Range {
+  startContainer = void 0;
+  startOffset = 0;
+  endContainer = void 0;
+  endOffset = 0;
+  collapsed = true;
+  commonAncestorContainer = void 0;
+  setStart(node, offset) {
+    this.startContainer = node;
+    this.startOffset = offset;
+    this.updateCollapsed();
+    this.updateCommonAncestor();
+  }
+  setEnd(node, offset) {
+    this.endContainer = node;
+    this.endOffset = offset;
+    this.updateCollapsed();
+    this.updateCommonAncestor();
+  }
+  collapse(toStart) {
+    if (toStart) {
+      this.endContainer = this.startContainer;
+      this.endOffset = this.startOffset;
+    } else {
+      this.startContainer = this.endContainer;
+      this.startOffset = this.endOffset;
+    }
+    this.collapsed = true;
+    this.updateCommonAncestor();
+  }
+  selectNode(node) {
+    if (!node.parentNode) {
+      throw new Error("Node has no parent");
+    }
+    const index = node.parentNode.childNodes.indexOf(node);
+    this.setStart(node.parentNode, index);
+    this.setEnd(node.parentNode, index + 1);
+  }
+  selectNodeContents(node) {
+    this.setStart(node, 0);
+    if (node.nodeName === "#text") {
+      this.setEnd(node, node.nodeValue.length);
+    } else {
+      this.setEnd(node, node.childNodes.length);
+    }
+  }
+  toString() {
+    if (this.collapsed || !this.startContainer || !this.endContainer) {
+      return "";
+    }
+    if (!this.commonAncestorContainer) {
+      return "";
+    }
+    const { charOffsetMap, styledLine } = getPlainTextFromDomNode(this.commonAncestorContainer);
+    const offsets = getRangeCharacterOffsets(this, charOffsetMap);
+    if (!offsets) {
+      return "";
+    }
+    const sliced = styledLine.slice(offsets.start, offsets.end);
+    return sliced.getTextRange(0, sliced.length);
+  }
+  updateCollapsed() {
+    this.collapsed = this.startContainer === this.endContainer && this.startOffset === this.endOffset;
+  }
+  updateCommonAncestor() {
+    if (!this.startContainer || !this.endContainer) {
+      this.commonAncestorContainer = void 0;
+      return;
+    }
+    if (this.startContainer === this.endContainer) {
+      this.commonAncestorContainer = this.startContainer;
+      return;
+    }
+    const startPath = getPathToRoot(this.startContainer);
+    const endPath = getPathToRoot(this.endContainer);
+    let common;
+    for (let index = 0; index < Math.min(startPath.length, endPath.length); index++) {
+      if (startPath[index] === endPath[index]) {
+        common = startPath[index];
+      } else {
+        break;
+      }
+    }
+    this.commonAncestorContainer = common;
+  }
+}
+class Selection {
+  anchorNode = void 0;
+  anchorOffset = 0;
+  focusNode = void 0;
+  focusOffset = 0;
+  isCollapsed = true;
+  rangeCount = 0;
+  ranges = [];
+  listeners = /* @__PURE__ */ new Set();
+  onChange(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  toString() {
+    return this.ranges.map((range) => range.toString()).join("");
+  }
+  getRangeAt(index) {
+    return this.ranges[index];
+  }
+  addRange(range) {
+    if (!this.ranges.includes(range)) {
+      this.ranges.push(range);
+      this.rangeCount = this.ranges.length;
+      if (this.rangeCount === 1) {
+        this.anchorNode = range.startContainer;
+        this.anchorOffset = range.startOffset;
+        this.focusNode = range.endContainer;
+        this.focusOffset = range.endOffset;
+        this.isCollapsed = range.collapsed;
+      }
+      this.notifyChange();
+    }
+  }
+  removeRange(range) {
+    const index = this.ranges.indexOf(range);
+    if (index !== -1) {
+      this.ranges.splice(index, 1);
+      this.rangeCount = this.ranges.length;
+      if (this.rangeCount === 0) {
+        this.clearState();
+      }
+      this.notifyChange();
+    }
+  }
+  removeAllRanges() {
+    this.ranges = [];
+    this.rangeCount = 0;
+    this.clearState();
+    this.notifyChange();
+  }
+  collapse(node, offset) {
+    this.removeAllRanges();
+    const range = new Range();
+    range.setStart(node, offset);
+    range.setEnd(node, offset);
+    this.addRange(range);
+  }
+  containsNode(node, allowPartialContainment = false) {
+    if (!node.parentNode) {
+      return false;
+    }
+    const parent = node.parentNode;
+    const index = parent.childNodes.indexOf(node);
+    const nodeStartContainer = parent;
+    const nodeStartOffset = index;
+    const nodeEndContainer = parent;
+    const nodeEndOffset = index + 1;
+    return this.ranges.some((range) => {
+      if (!range.startContainer || !range.endContainer) {
+        return false;
+      }
+      const startToStart = comparePoints(range.startContainer, range.startOffset, nodeStartContainer, nodeStartOffset);
+      const endToEnd = comparePoints(range.endContainer, range.endOffset, nodeEndContainer, nodeEndOffset);
+      if (allowPartialContainment) {
+        const startToEnd = comparePoints(range.startContainer, range.startOffset, nodeEndContainer, nodeEndOffset);
+        const endToStart = comparePoints(range.endContainer, range.endOffset, nodeStartContainer, nodeStartOffset);
+        return startToEnd < 0 && endToStart > 0;
+      }
+      return startToStart <= 0 && endToEnd >= 0;
+    });
+  }
+  clearState() {
+    this.anchorNode = void 0;
+    this.anchorOffset = 0;
+    this.focusNode = void 0;
+    this.focusOffset = 0;
+    this.isCollapsed = true;
+  }
+  notifyChange() {
+    for (const listener of this.listeners) {
+      listener();
+    }
+  }
+}
+const applySelectionToStyledLine = (line, range) => {
+  if (line.length === 0 || range.start >= range.end) {
+    return line;
+  }
+  const result = line.clone();
+  const selStart = Math.max(0, range.start);
+  const selEnd = Math.min(line.length, range.end);
+  for (let i = selStart; i < selEnd; i++) {
+    result.setInverted(i, true);
+  }
+  return result;
+};
+
+export { Range, Selection, applySelectionToStyledLine, comparePoints };

package/dist/packem_shared/createInlineLoop-BxMmcq9D.js

@@ -0,0 +1,93 @@
+import { terminalSize, Renderer } from './Renderer-zZ5O3vxc.js';
+
+const DEC_2026_ON = "\x1B[?2026h";
+const DEC_2026_OFF = "\x1B[?2026l";
+function createInlineLoop(paint, options = {}) {
+  const reservedRows = options.rows ?? 10;
+  const fps = options.fps ?? 60;
+  const onExit = options.onExit ?? "preserve";
+  let interval = null;
+  let renderer = null;
+  let buf = null;
+  let cols = 80;
+  let renderRows = 10;
+  let frame = 0;
+  let regionTopRow = 1;
+  function write(s) {
+    renderer.writeRaw(s);
+  }
+  function tick() {
+    buf.fill(0);
+    paint(buf, cols, renderRows, frame++);
+    write(DEC_2026_ON);
+    try {
+      renderer.render(buf);
+    } finally {
+      write(DEC_2026_OFF);
+    }
+  }
+  function startRendering(cursorRow) {
+    regionTopRow = cursorRow - renderRows;
+    write(`\x1B[${renderRows}A\x1B[1G`);
+    renderer.setRowOffset(regionTopRow);
+    tick();
+    interval = setInterval(
+      () => {
+        tick();
+      },
+      Math.round(1e3 / fps)
+    );
+  }
+  function start() {
+    const size = terminalSize();
+    cols = size.cols;
+    const termRows = size.rows;
+    renderRows = Math.min(reservedRows, termRows);
+    if (process.stdin.isTTY)
+      process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding("utf8");
+    renderer = new Renderer(cols, renderRows);
+    buf = new Uint32Array(cols * renderRows * 2);
+    write("\x1B[?25l");
+    write("\x1B[?2004h");
+    write("\n".repeat(renderRows));
+    write("\x1B[6n");
+    process.on("SIGINT", stop);
+    let cprBuf = "";
+    const onData = (chunk) => {
+      cprBuf += chunk;
+      const m = cprBuf.match(/\u001B\[(\d+);(\d+)R/);
+      if (m) {
+        process.stdin.off("data", onData);
+        startRendering(Number.parseInt(m[1], 10));
+      }
+    };
+    process.stdin.on("data", onData);
+  }
+  function stop() {
+    if (interval) {
+      clearInterval(interval);
+      interval = null;
+    }
+    if (renderer) {
+      if (onExit === "destroy") {
+        for (let i = 0; i < renderRows; i++) {
+          write(`\x1B[${regionTopRow + 1 + i};1H\x1B[2K`);
+        }
+        write(`\x1B[${regionTopRow + 1};1H`);
+      } else {
+        write(`\x1B[${regionTopRow + renderRows + 1};1H`);
+      }
+      write("\x1B[?2004l");
+      write("\x1B[?25h");
+    }
+    if (process.stdin.isTTY)
+      process.stdin.setRawMode(false);
+    process.stdin.pause();
+    process.exit(0);
+  }
+  return { start, stop };
+}
+
+export { createInlineLoop };

package/dist/packem_shared/createLinkedScrollGroup-Djw4Ceo0.js

@@ -0,0 +1,44 @@
+import { useRef, useState, useEffect, useCallback } from 'react';
+
+const createLinkedScrollGroup = () => {
+  const listeners = /* @__PURE__ */ new Set();
+  let broadcasting = false;
+  const useLinkedScroll = () => {
+    const scrollRef = useRef(null);
+    const [, setTick] = useState(0);
+    const listener = {
+      ref: scrollRef,
+      setOffset: () => {
+        setTick((t) => t + 1);
+      }
+    };
+    const listenerRef = useRef(listener);
+    listenerRef.current = listener;
+    useEffect(() => {
+      const { current } = listenerRef;
+      listeners.add(current);
+      return () => {
+        listeners.delete(current);
+      };
+    }, []);
+    const onScroll = useCallback((scrollOffset) => {
+      if (broadcasting) {
+        return;
+      }
+      broadcasting = true;
+      try {
+        for (const l of listeners) {
+          if (l.ref !== scrollRef) {
+            l.ref.current?.scrollTo(scrollOffset);
+          }
+        }
+      } finally {
+        broadcasting = false;
+      }
+    }, []);
+    return { onScroll, ref: scrollRef };
+  };
+  return { useLinkedScroll };
+};
+
+export { createLinkedScrollGroup as default };

package/dist/packem_shared/dom-DvzhsAez.js

@@ -0,0 +1,225 @@
+import Yoga from 'yoga-layout';
+import { m as measureText } from './measure-text-DItZYotK.js';
+import squashTextNodes from './squashTextNodesWithMap-iqm6OMMT.js';
+import { wordWrap, truncate } from '@visulima/string';
+
+const cache = {};
+const wrapWordMode = {
+  hard: "STRICT_WIDTH",
+  wrap: "BREAK_WORDS",
+  "wrap-anywhere": "BREAK_AT_CHARACTERS",
+  "wrap-preserve-words": "PRESERVE_WORDS",
+  "wrap-strict": "STRICT_WIDTH"
+};
+const wrapText = (text, maxWidth, wrapType) => {
+  const cacheKey = text + String(maxWidth) + String(wrapType);
+  const cachedText = cache[cacheKey];
+  if (cachedText) {
+    return cachedText;
+  }
+  let wrappedText = text;
+  const wordMode = wrapWordMode[wrapType];
+  if (wordMode) {
+    wrappedText = wordWrap(text, {
+      trim: false,
+      width: maxWidth,
+      wrapMode: wordMode
+    }).replace(/\n$/, "");
+  } else if (wrapType.startsWith("truncate")) {
+    let position = "end";
+    if (wrapType === "truncate-middle") {
+      position = "middle";
+    }
+    if (wrapType === "truncate-start") {
+      position = "start";
+    }
+    wrappedText = truncate(text, maxWidth, { position });
+  }
+  cache[cacheKey] = wrappedText;
+  return wrappedText;
+};
+
+let idCounter = 0;
+const createNode = (nodeName) => {
+  const node = {
+    attributes: {},
+    childNodes: [],
+    internal_accessibility: {},
+    internal_id: idCounter++,
+    nodeName,
+    parentNode: void 0,
+    style: {},
+    yogaNode: nodeName === "ink-virtual-text" || nodeName === "ink-cursor" ? void 0 : Yoga.Node.create()
+  };
+  if (nodeName === "ink-text") {
+    node.yogaNode?.setMeasureFunc(measureTextNode.bind(null, node));
+  }
+  return node;
+};
+const appendChildNode = (node, childNode) => {
+  if (childNode.parentNode) {
+    removeChildNode(childNode.parentNode, childNode);
+  }
+  childNode.parentNode = node;
+  node.childNodes.push(childNode);
+  if (childNode.yogaNode) {
+    node.yogaNode?.insertChild(childNode.yogaNode, node.yogaNode.getChildCount());
+  }
+  if (node.nodeName === "ink-text" || node.nodeName === "ink-virtual-text") {
+    markNodeAsDirty(node);
+  }
+};
+const insertBeforeNode = (node, newChildNode, beforeChildNode) => {
+  if (newChildNode.parentNode) {
+    removeChildNode(newChildNode.parentNode, newChildNode);
+  }
+  newChildNode.parentNode = node;
+  const index = node.childNodes.indexOf(beforeChildNode);
+  if (index === -1) {
+    node.childNodes.push(newChildNode);
+    if (newChildNode.yogaNode) {
+      node.yogaNode?.insertChild(newChildNode.yogaNode, node.yogaNode.getChildCount());
+    }
+  } else {
+    node.childNodes.splice(index, 0, newChildNode);
+    if (newChildNode.yogaNode) {
+      const yogaIndex = node.childNodes.slice(0, index).filter((childNode) => Boolean(childNode.yogaNode)).length;
+      node.yogaNode?.insertChild(newChildNode.yogaNode, yogaIndex);
+    }
+  }
+  if (node.nodeName === "ink-text" || node.nodeName === "ink-virtual-text") {
+    markNodeAsDirty(node);
+  }
+};
+const removeChildNode = (node, removeNode) => {
+  if (removeNode.yogaNode) {
+    const parentYogaNode = removeNode.yogaNode.getParent();
+    if (parentYogaNode) {
+      parentYogaNode.removeChild(removeNode.yogaNode);
+    }
+  }
+  removeNode.parentNode = void 0;
+  const index = node.childNodes.indexOf(removeNode);
+  if (index !== -1) {
+    node.childNodes.splice(index, 1);
+  }
+  if (node.nodeName === "ink-text" || node.nodeName === "ink-virtual-text") {
+    markNodeAsDirty(node);
+  }
+};
+const setAttribute = (node, key, value) => {
+  if (key === "internal_accessibility") {
+    node.internal_accessibility = value;
+    return;
+  }
+  node.attributes[key] = value;
+};
+const setStyle = (node, style) => {
+  node.style = style ?? {};
+};
+const createTextNode = (text) => {
+  const node = {
+    nodeName: "#text",
+    nodeValue: text,
+    parentNode: void 0,
+    style: {},
+    yogaNode: void 0
+  };
+  setTextNodeValue(node, text);
+  return node;
+};
+const measureTextNode = function(node, width) {
+  const text = node.nodeName === "#text" ? node.nodeValue : squashTextNodes(node);
+  const dimensions = measureText(text);
+  if (dimensions.width <= width) {
+    return dimensions;
+  }
+  if (dimensions.width >= 1 && width > 0 && width < 1) {
+    return dimensions;
+  }
+  const textWrap = node.style?.textWrap ?? "wrap";
+  const wrappedText = wrapText(text, width, textWrap);
+  return measureText(wrappedText);
+};
+const findClosestYogaNode = (node) => {
+  if (!node?.parentNode) {
+    return void 0;
+  }
+  return node.yogaNode ?? findClosestYogaNode(node.parentNode);
+};
+const markNodeAsDirty = (node) => {
+  const yogaNode = findClosestYogaNode(node);
+  yogaNode?.markDirty();
+  let current = node;
+  while (current) {
+    if (current.nodeName === "ink-text" || current.nodeName === "ink-virtual-text") {
+      current.internal_textCache = void 0;
+    }
+    if ("cachedRender" in current) {
+      current.cachedRender = void 0;
+    }
+    current = current.parentNode;
+  }
+};
+const setTextNodeValue = (node, text) => {
+  if (typeof text !== "string") {
+    text = String(text);
+  }
+  node.nodeValue = text;
+  markNodeAsDirty(node);
+};
+const addLayoutListener = (rootNode, listener) => {
+  if (rootNode.nodeName !== "ink-root") {
+    return () => {
+    };
+  }
+  rootNode.internal_layoutListeners ??= /* @__PURE__ */ new Set();
+  rootNode.internal_layoutListeners.add(listener);
+  return () => {
+    rootNode.internal_layoutListeners?.delete(listener);
+  };
+};
+const emitLayoutListeners = (rootNode) => {
+  if (rootNode.nodeName !== "ink-root" || !rootNode.internal_layoutListeners) {
+    return;
+  }
+  for (const listener of rootNode.internal_layoutListeners) {
+    listener();
+  }
+};
+const setCachedRender = (node, cachedRender) => {
+  node.cachedRender = cachedRender;
+  if (node.yogaNode) {
+    node.yogaNode.setWidth(cachedRender.width);
+    node.yogaNode.setHeight(cachedRender.height);
+    while (node.yogaNode.getChildCount() > 0) {
+      node.yogaNode.removeChild(node.yogaNode.getChild(0));
+    }
+    node.isYogaTreeDetached = true;
+  }
+};
+const getPathToRoot = (node) => {
+  const path = [];
+  let current = node;
+  while (current) {
+    path.unshift(current);
+    current = current.parentNode;
+  }
+  return path;
+};
+const isNodeSelectable = (node) => {
+  let current = node;
+  while (current) {
+    const { userSelect } = current.style;
+    if (userSelect === "none") {
+      return false;
+    }
+    if (userSelect === "text" || userSelect === "all") {
+      return true;
+    }
+    current = current.parentNode;
+  }
+  return true;
+};
+
+export { addLayoutListener as a, insertBeforeNode as b, createNode as c, appendChildNode as d, emitLayoutListeners as e, createTextNode as f, getPathToRoot as g, setStyle as h, isNodeSelectable as i, setAttribute as j, setCachedRender as k, markNodeAsDirty as m, removeChildNode as r, setTextNodeValue as s, wrapText as w };

package/dist/packem_shared/format-time-BGmnDukX.js

@@ -0,0 +1,12 @@
+function formatDuration(ms) {
+  const totalSeconds = Math.max(0, Math.floor(ms / 1e3));
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  if (hours > 0) {
+    return `${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
+  }
+  return `${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
+}
+
+export { formatDuration as f };

package/dist/packem_shared/getPathToRoot-a1wbwxfL.js

@@ -0,0 +1,4 @@
+import 'yoga-layout';
+import './measure-text-DItZYotK.js';
+import './squashTextNodesWithMap-iqm6OMMT.js';
+export { a as addLayoutListener, d as appendChildNode, c as createNode, f as createTextNode, e as emitLayoutListeners, g as getPathToRoot, b as insertBeforeNode, i as isNodeSelectable, m as markNodeAsDirty, r as removeChildNode, j as setAttribute, k as setCachedRender, h as setStyle, s as setTextNodeValue } from './dom-DvzhsAez.js';