@alchemy.run/sigil 0.0.0-alpha.1 → 0.0.0-alpha.11

package/src/stream.ts

@@ -0,0 +1,28 @@
+import { isTty } from "#/env.ts";
+
+export type OutputStream = NodeJS.WritableStream & {
+  isTTY?: boolean;
+  columns?: number;
+  rows?: number;
+  destroyed?: boolean;
+  writableEnded?: boolean;
+};
+
+type RawModeStream = NodeJS.ReadableStream & {
+  isTTY: true;
+  setRawMode: (mode: boolean) => void;
+  ref?: () => void;
+  unref?: () => void;
+};
+
+const isRawModeStream = (stdin: NodeJS.ReadableStream): stdin is RawModeStream => {
+  return isTty(stdin) && "setRawMode" in stdin && typeof stdin.setRawMode === "function";
+};
+
+export const getRawModeStream = (stdin: NodeJS.ReadableStream): RawModeStream | undefined => {
+  if (!isRawModeStream(stdin)) {
+    return;
+  }
+
+  return stdin;
+};

package/src/structured-text.ts

@@ -0,0 +1,325 @@
+import { tokenizeAnsi } from "#/ansi-tokenizer.ts";
+import { graphemes } from "#/ansi/graphemes.ts";
+import { stringWidth } from "#/ansi/string-width.ts";
+import { stripAnsi } from "#/ansi/strip.ts";
+import { samplePaint, type PaintContext } from "#/color/index.ts";
+import type { Paint } from "#/color/paint.ts";
+import type { DOMElement, DOMNode } from "#/dom.ts";
+import { cellsFromAnsi } from "#/screen/ansi.ts";
+import { createCell, type Cell, type CellStyle } from "#/screen/cell.ts";
+import type { Rect } from "#/screen/geometry.ts";
+import {
+  emptySemanticTextStyle,
+  mergeSemanticTextStyles,
+  semanticTextStyleToCellStyle,
+  type SemanticTextStyle,
+} from "#/semantic-text-style.ts";
+import type { Styles } from "#/styles.ts";
+
+type SemanticCell = Cell & {
+  readonly foregroundPaint?: Paint;
+  readonly backgroundPaint?: Paint;
+};
+
+/** Whether a text subtree must retain the ANSI compatibility pipeline. */
+export function hasCompatibilityText(node: DOMElement): boolean {
+  if (node.internal_transform && !node.internal_textStyle) {
+    return true;
+  }
+
+  return node.childNodes.some((child) => child.nodeName !== "#text" && hasCompatibilityText(child));
+}
+
+/** Rasterizes an unwrapped native Text subtree into semantic cell lines. */
+export function structuredTextLines(node: DOMElement): readonly (readonly SemanticCell[])[] {
+  const lines: SemanticCell[][] = [[]];
+  appendNode(node, emptySemanticTextStyle, lines, false);
+  return lines;
+}
+
+/** Samples semantic paints only after wrapping and final layout are known. */
+export function sampleStructuredText(
+  lines: readonly (readonly SemanticCell[])[],
+  bounds: Rect,
+  context: PaintContext,
+): readonly (readonly Cell[])[] {
+  return lines.map((line, row) => {
+    let column = 0;
+    return line.map((cell) => {
+      const foreground = cell.foregroundPaint
+        ? samplePaint(cell.foregroundPaint, bounds.x + column, bounds.y + row, bounds, context)
+        : cell.style.foreground;
+      const background = cell.backgroundPaint
+        ? samplePaint(cell.backgroundPaint, bounds.x + column, bounds.y + row, bounds, context)
+        : cell.style.background;
+      column += cell.width;
+      return createCell(
+        cell.grapheme,
+        cell.width,
+        {
+          ...cell.style,
+          ...(foreground ? { foreground } : {}),
+          ...(background ? { background } : {}),
+        },
+        cell.hyperlink,
+        cell.reset,
+      );
+    });
+  });
+}
+
+export function structuredTextBaseStyle(node: DOMElement): CellStyle {
+  return semanticTextStyleToCellStyle(
+    mergeSemanticTextStyles(emptySemanticTextStyle, node.internal_textStyle),
+  );
+}
+
+/** Wraps or truncates semantic cells without converting them through ANSI. */
+export function wrapStructuredText(
+  input: readonly (readonly Cell[])[],
+  maxWidth: number,
+  wrap: Styles["textWrap"],
+  baseStyle?: CellStyle,
+): readonly (readonly Cell[])[] {
+  if (wrap === "none") {
+    return input.map((line) => [...line]);
+  }
+
+  if (maxWidth < 1) {
+    return [[]];
+  }
+
+  return input.flatMap((line) => {
+    if (lineWidth(line) <= maxWidth) {
+      return [[...line]];
+    }
+
+    if (wrap === "hard") {
+      return hardWrap(line, maxWidth);
+    }
+
+    if (wrap === "wrap") {
+      return wordWrap(line, maxWidth);
+    }
+
+    return [truncate(line, maxWidth, wrap, baseStyle)];
+  });
+}
+
+function wordWrap(line: readonly Cell[], maxWidth: number): Cell[][] {
+  const words: Cell[][] = [[]];
+  const spaces: Cell[] = [];
+
+  for (const cell of line) {
+    if (cell.grapheme === " ") {
+      spaces.push(cell);
+      words.push([]);
+    } else {
+      words.at(-1)!.push(cell);
+    }
+  }
+
+  const output: Cell[][] = [[]];
+  appendHard(output, words[0]!, maxWidth);
+
+  for (let index = 1; index < words.length; index++) {
+    appendHard(output, [spaces[index - 1]!], maxWidth);
+    const word = words[index]!;
+    const current = output.at(-1)!;
+    const wordWidth = lineWidth(word);
+    const currentWidth = lineWidth(current);
+
+    if (wordWidth <= maxWidth && currentWidth + wordWidth > maxWidth) {
+      output.push([]);
+    } else if (wordWidth > maxWidth && currentWidth > 0) {
+      const remaining = maxWidth - currentWidth;
+      const breaksHere = 1 + Math.floor((wordWidth - remaining - 1) / maxWidth);
+      const breaksNext = Math.floor((wordWidth - 1) / maxWidth);
+      if (breaksNext < breaksHere) {
+        output.push([]);
+      }
+    }
+
+    appendHard(output, word, maxWidth);
+  }
+
+  return output;
+}
+
+function hardWrap(line: readonly Cell[], maxWidth: number): Cell[][] {
+  const output: Cell[][] = [[]];
+  appendHard(output, line, maxWidth);
+  return output;
+}
+
+function appendHard(output: Cell[][], cells: readonly Cell[], maxWidth: number): void {
+  for (const cell of cells) {
+    const current = output.at(-1)!;
+    if (current.length > 0 && lineWidth(current) + cell.width > maxWidth) {
+      output.push([]);
+    }
+
+    output.at(-1)!.push(cell);
+  }
+}
+
+function truncate(
+  line: readonly Cell[],
+  maxWidth: number,
+  wrap: Styles["textWrap"],
+  baseStyle: CellStyle | undefined,
+): Cell[] {
+  if (maxWidth === 1) {
+    return [ellipsis(baseStyle ?? cellStyleIntersection(line.at(0), line.at(-1)))];
+  }
+
+  if (wrap === "truncate-start") {
+    const right = sliceCells(line, lineWidth(line) - maxWidth + 1, lineWidth(line));
+    return [ellipsis(right[0]?.style), ...right];
+  }
+
+  if (wrap === "truncate-middle") {
+    const half = Math.min(Math.floor(maxWidth / 2), maxWidth - 1);
+    const left = sliceCells(line, 0, half);
+    const rightWidth = maxWidth - half - 1;
+    const right = sliceCells(line, lineWidth(line) - rightWidth, lineWidth(line));
+    return [
+      ...left,
+      ellipsis(baseStyle ?? cellStyleIntersection(left.at(-1), right.at(0))),
+      ...right,
+    ];
+  }
+
+  const left = sliceCells(line, 0, maxWidth - 1);
+  return [...left, ellipsis(left.at(-1)?.style)];
+}
+
+function sliceCells(line: readonly Cell[], start: number, end: number): Cell[] {
+  const output: Cell[] = [];
+  let column = 0;
+
+  for (const cell of line) {
+    const nextColumn = column + cell.width;
+    if (column >= start && nextColumn <= end) {
+      output.push(cell);
+    }
+
+    column = nextColumn;
+  }
+
+  return output;
+}
+
+function ellipsis(style = semanticTextStyleToCellStyle(emptySemanticTextStyle)): Cell {
+  return createCell("…", 1, style);
+}
+
+function cellStyleIntersection(left: Cell | undefined, right: Cell | undefined): Cell["style"] {
+  if (!left) {
+    return right?.style ?? semanticTextStyleToCellStyle(emptySemanticTextStyle);
+  }
+
+  if (!right) {
+    return left.style;
+  }
+
+  return {
+    ...(sameColor(left.style.foreground, right.style.foreground)
+      ? { foreground: left.style.foreground }
+      : {}),
+    ...(sameColor(left.style.background, right.style.background)
+      ? { background: left.style.background }
+      : {}),
+    ...(sameColor(left.style.underlineColor, right.style.underlineColor)
+      ? { underlineColor: left.style.underlineColor }
+      : {}),
+    underline: left.style.underline === right.style.underline ? left.style.underline : "none",
+    // eslint-disable-next-line no-bitwise
+    attributes: left.style.attributes & right.style.attributes,
+  };
+}
+
+function sameColor(left: Cell["style"]["foreground"], right: Cell["style"]["foreground"]): boolean {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+
+function lineWidth(line: readonly Cell[]): number {
+  return line.reduce((width, cell) => width + cell.width, 0);
+}
+
+function appendNode(
+  node: DOMNode,
+  inherited: SemanticTextStyle,
+  lines: SemanticCell[][],
+  ansi: boolean,
+): void {
+  if (node.nodeName === "#text") {
+    if (ansi) appendAnsiText(node.nodeValue, inherited, lines);
+    else appendText(node.nodeValue, inherited, lines);
+    return;
+  }
+
+  const style = mergeSemanticTextStyles(inherited, node.internal_textStyle);
+  for (const child of node.childNodes) {
+    appendNode(child, style, lines, ansi || node.internal_ansi === true);
+  }
+}
+
+function appendAnsiText(text: string, semantic: SemanticTextStyle, lines: SemanticCell[][]): void {
+  const base = semanticTextStyleToCellStyle(semantic);
+  for (const cell of cellsFromAnsi(text)) {
+    if (cell.grapheme === "\n" || cell.grapheme === "\r\n") {
+      lines.push([]);
+      continue;
+    }
+
+    const hasForeground = cell.style.foreground !== undefined;
+    const hasBackground = cell.style.background !== undefined;
+    lines.at(-1)!.push({
+      ...cell,
+      style: {
+        ...((cell.style.foreground ?? base.foreground)
+          ? { foreground: cell.style.foreground ?? base.foreground }
+          : {}),
+        ...((cell.style.background ?? base.background)
+          ? { background: cell.style.background ?? base.background }
+          : {}),
+        ...(cell.style.underlineColor ? { underlineColor: cell.style.underlineColor } : {}),
+        underline: cell.style.underline === "none" ? base.underline : cell.style.underline,
+        // eslint-disable-next-line no-bitwise
+        attributes: base.attributes | cell.style.attributes,
+      },
+      ...(!hasForeground && semantic.foreground ? { foregroundPaint: semantic.foreground } : {}),
+      ...(!hasBackground && semantic.background ? { backgroundPaint: semantic.background } : {}),
+    });
+  }
+}
+
+function appendText(text: string, style: SemanticTextStyle, lines: SemanticCell[][]): void {
+  const cellStyle = semanticTextStyleToCellStyle(style);
+
+  const plainText = tokenizeAnsi(text)
+    .filter((token) => token.type === "text")
+    .map((token) => token.value)
+    .join("");
+  for (const segment of graphemes(stripAnsi(plainText))) {
+    if (segment === "\n" || segment === "\r\n") {
+      lines.push([]);
+      continue;
+    }
+
+    lines.at(-1)!.push({
+      ...createCell(
+        segment,
+        Math.max(1, stringWidth(segment)),
+        cellStyle,
+        undefined,
+        style.resetForeground || style.resetBackground
+          ? { foreground: style.resetForeground, background: style.resetBackground }
+          : undefined,
+      ),
+      ...(style.foreground ? { foregroundPaint: style.foreground } : {}),
+      ...(style.background ? { backgroundPaint: style.background } : {}),
+    });
+  }
+}