@valyrianjs/terminal 0.1.0 → 0.1.2

package/src/mouse.ts

@@ -0,0 +1,68 @@
+import { parseTerminalKey } from "./events.js";
+
+import type { ParsedTerminalInput, TerminalHitbox } from "./types.js";
+
+const nestedParentTags = new Set(["terminal-box", "terminal-view"]);
+
+function containsHitbox(parent: TerminalHitbox, child: TerminalHitbox) {
+  return child.x1 >= parent.x1 && child.x2 <= parent.x2 && child.y1 >= parent.y1 && child.y2 <= parent.y2;
+}
+
+function samePointerLayer(left: TerminalHitbox, right: TerminalHitbox) {
+  return (left.pointerLayer ?? 0) === (right.pointerLayer ?? 0);
+}
+
+export function parseTerminalInput(chunk: string | Uint8Array): ParsedTerminalInput {
+  const value = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+  const match = /^\u001b\[<(\d+);(\d+);(\d+)([Mm])$/.exec(value);
+  if (match) {
+    const code = Number(match[1]);
+    let action: "press" | "release" | "drag" | "wheel-up" | "wheel-down" = match[4] === "M" ? "press" : "release";
+    if (code >= 64) {
+      action = code === 64 ? "wheel-up" : "wheel-down";
+    } else if (code >= 32 && match[4] === "M") {
+      action = "drag";
+    }
+    return {
+      type: "mouse",
+      button: code,
+      x: Number(match[2]),
+      y: Number(match[3]),
+      action
+    };
+  }
+  return { type: "key", key: parseTerminalKey(value) };
+}
+
+export function findHitboxAt(hitboxes: TerminalHitbox[], x: number, y: number) {
+  let target: TerminalHitbox | null = null;
+
+  for (const box of hitboxes) {
+    if (y < box.y1 || y > box.y2 || x < box.x1 || x > box.x2) {
+      continue;
+    }
+
+    if (!target) {
+      target = box;
+      continue;
+    }
+
+    if (nestedParentTags.has(target.tag) && samePointerLayer(target, box) && containsHitbox(target, box)) {
+      target = box;
+    }
+  }
+
+  return target;
+}
+
+export function resolvePointerTarget(hitboxes: TerminalHitbox[], x: number, y: number) {
+  return findHitboxAt(hitboxes, x, y);
+}
+
+export function cursorFromHitbox(hitbox: TerminalHitbox, x: number) {
+  if (typeof hitbox.textStartX !== "number") {
+    return 0;
+  }
+  const textLength = Number(hitbox.textLength || 0);
+  return Math.max(0, Math.min(textLength, x - hitbox.textStartX));
+}

package/src/output-writer.ts

@@ -0,0 +1,93 @@
+import type { TerminalOutputStream } from "./types.js";
+
+export interface OutputWriter {
+  write(chunk: string, options?: { force?: boolean }): void;
+  destroy(): void;
+}
+
+export function createOutputWriter(stream: TerminalOutputStream | undefined): OutputWriter {
+  const queue: string[] = [];
+  let blocked = false;
+  let destroyed = false;
+  let listeningForDrain = false;
+
+  const onDrain = () => {
+    removeDrainListener();
+    blocked = false;
+    flushQueue();
+  };
+
+  function canListenForDrain() {
+    return (
+      !!stream &&
+      typeof stream.on === "function" &&
+      (typeof stream.off === "function" || typeof stream.removeListener === "function")
+    );
+  }
+
+  function addDrainListener() {
+    if (listeningForDrain || !canListenForDrain()) {
+      return;
+    }
+    const target = stream;
+    if (!target) {
+      return;
+    }
+    listeningForDrain = true;
+    target.on!("drain", onDrain);
+  }
+
+  function removeDrainListener() {
+    if (!stream || !listeningForDrain) {
+      return;
+    }
+    if (typeof stream.off === "function") {
+      stream.off("drain", onDrain);
+    } else if (typeof stream.removeListener === "function") {
+      stream.removeListener("drain", onDrain);
+    }
+    listeningForDrain = false;
+  }
+
+  function writeNow(chunk: string) {
+    if (!stream || destroyed) {
+      return;
+    }
+    const accepted = stream.write(chunk);
+    if (accepted === false && canListenForDrain()) {
+      blocked = true;
+      addDrainListener();
+    }
+  }
+
+  function flushQueue() {
+    while (!destroyed && !blocked && queue.length > 0) {
+      writeNow(queue.shift() as string);
+    }
+  }
+
+  return {
+    write(chunk: string, options?: { force?: boolean }) {
+      if (destroyed || !stream) {
+        return;
+      }
+      if (options?.force) {
+        stream.write(chunk);
+        return;
+      }
+      if (blocked) {
+        queue.push(chunk);
+        return;
+      }
+      writeNow(chunk);
+    },
+    destroy() {
+      if (destroyed) {
+        return;
+      }
+      destroyed = true;
+      queue.length = 0;
+      removeDrainListener();
+    }
+  };
+}

package/src/paste.ts

@@ -0,0 +1,23 @@
+const BRACKETED_PASTE_START = "\u001b[200~";
+const BRACKETED_PASTE_END = "\u001b[201~";
+
+export type TerminalPasteEvent = { type: "paste"; text: string; rest: string };
+
+function normalizePasteLineEndings(value: string) {
+  return value.replace(/\r\n?/g, "\n");
+}
+
+export function parseBracketedPaste(value: string): TerminalPasteEvent | null {
+  if (!value.startsWith(BRACKETED_PASTE_START)) {
+    return null;
+  }
+
+  const textStart = BRACKETED_PASTE_START.length;
+  const textEnd = value.indexOf(BRACKETED_PASTE_END, textStart);
+  if (textEnd === -1) {
+    return null;
+  }
+
+  const restStart = textEnd + BRACKETED_PASTE_END.length;
+  return { type: "paste", text: normalizePasteLineEndings(value.slice(textStart, textEnd)), rest: value.slice(restStart) };
+}

package/src/primitives.ts

@@ -0,0 +1,52 @@
+import { v } from "valyrian.js";
+
+import type {
+  AnyProps,
+  TerminalBoxProps,
+  TerminalButtonProps,
+  TerminalEditorProps,
+  TerminalFocusScopeProps,
+  TerminalFixedProps,
+  TerminalInputProps,
+  TerminalListProps,
+  TerminalLogViewProps,
+  TerminalOverlayProps,
+  TerminalPaneProps,
+  TerminalPrimitiveTag,
+  TerminalRowProps,
+  TerminalScreenProps,
+  TerminalScrollViewProps,
+  TerminalSplitProps,
+  TerminalTableProps,
+  TerminalTdProps,
+  TerminalTextProps,
+  TerminalViewProps
+} from "./types.js";
+
+type TerminalPrimitiveComponent<P> = (props: P | AnyProps, children: any[]) => any;
+
+function primitive<P = Record<string, any>>(tag: TerminalPrimitiveTag): TerminalPrimitiveComponent<P> {
+  return function TerminalPrimitive(props: P | AnyProps, children: any[]) {
+    const nextProps = { ...(props || {}) } as Record<string, any>;
+    return v(tag, nextProps, ...children);
+  };
+}
+
+export const Screen = primitive<TerminalScreenProps>("terminal-screen");
+export const Box = primitive<TerminalBoxProps>("terminal-box");
+export const View = primitive<TerminalViewProps>("terminal-view");
+export const Pane = primitive<TerminalPaneProps>("terminal-pane");
+export const Split = primitive<TerminalSplitProps>("terminal-split");
+export const Fixed = primitive<TerminalFixedProps>("terminal-fixed");
+export const Overlay = primitive<TerminalOverlayProps>("terminal-overlay");
+export const FocusScope = primitive<TerminalFocusScopeProps>("terminal-focus-scope");
+export const Text = primitive<TerminalTextProps>("terminal-text");
+export const Input = primitive<TerminalInputProps>("terminal-input");
+export const Editor = primitive<TerminalEditorProps>("terminal-editor");
+export const Button = primitive<TerminalButtonProps>("terminal-button");
+export const ScrollView = primitive<TerminalScrollViewProps>("terminal-scroll");
+export const LogView = primitive<TerminalLogViewProps>("terminal-log-view");
+export const List = primitive<TerminalListProps<any>>("terminal-list");
+export const Table = primitive<TerminalTableProps>("terminal-table");
+export const Row = primitive<TerminalRowProps>("terminal-row");
+export const Td = primitive<TerminalTdProps>("terminal-td");