@alchemy.run/sigil 0.0.0-alpha.3 → 0.0.0-alpha.5

package/src/log-update.ts

@@ -1,370 +0,0 @@
-import { cliCursor } from "./ansi/cursor.ts";
-import { ansiEscapes } from "./ansi/escapes.ts";
-import {
-  type CursorPosition,
-  cursorPositionChanged,
-  buildCursorSuffix,
-  buildCursorOnlySequence,
-  buildReturnToBottomPrefix,
-  hideCursorEscape,
-} from "./cursor-position.ts";
-
-export type { CursorPosition } from "./cursor-position.ts";
-
-export type LogUpdate = {
-  clear: () => void;
-  done: () => void;
-  reset: () => void;
-  sync: (str: string) => void;
-  setCursorPosition: (position: CursorPosition | undefined) => void;
-  isCursorDirty: () => boolean;
-  willRender: (str: string) => boolean;
-  (str: string): boolean;
-};
-
-// Count visible lines in a string, ignoring the trailing empty element
-// that `split('\n')` produces when the string ends with '\n'.
-const visibleLineCount = (lines: string[], str: string): number =>
-  str.endsWith("\n") ? lines.length - 1 : lines.length;
-
-const createStandard = (stream: NodeJS.WritableStream, { showCursor = false } = {}): LogUpdate => {
-  let previousLineCount = 0;
-  let previousOutput = "";
-  let hasHiddenCursor = false;
-  let cursorPosition: CursorPosition | undefined;
-  let cursorDirty = false;
-  let previousCursorPosition: CursorPosition | undefined;
-  let cursorWasShown = false;
-
-  const getActiveCursor = () => (cursorDirty ? cursorPosition : undefined);
-  const hasChanges = (str: string, activeCursor: CursorPosition | undefined): boolean => {
-    const cursorChanged = cursorPositionChanged(activeCursor, previousCursorPosition);
-    return str !== previousOutput || cursorChanged;
-  };
-
-  const render = (str: string) => {
-    if (!showCursor && !hasHiddenCursor) {
-      cliCursor.hide(stream);
-      hasHiddenCursor = true;
-    }
-
-    // Only use cursor if setCursorPosition was called since last render.
-    // This ensures stale positions don't persist after component unmount.
-    const activeCursor = getActiveCursor();
-    cursorDirty = false;
-    const cursorChanged = cursorPositionChanged(activeCursor, previousCursorPosition);
-
-    if (!hasChanges(str, activeCursor)) {
-      return false;
-    }
-
-    const lines = str.split("\n");
-    const cursorSuffix = buildCursorSuffix(lines.length - 1, activeCursor);
-
-    if (str === previousOutput && cursorChanged) {
-      stream.write(
-        buildCursorOnlySequence({
-          cursorWasShown,
-          previousLineCount,
-          previousCursorPosition,
-          cursorPosition: activeCursor,
-        }),
-      );
-    } else {
-      previousOutput = str;
-      const returnPrefix = buildReturnToBottomPrefix(
-        cursorWasShown,
-        previousLineCount,
-        previousCursorPosition,
-      );
-      stream.write(returnPrefix + ansiEscapes.eraseLines(previousLineCount) + str + cursorSuffix);
-      previousLineCount = lines.length;
-    }
-
-    previousCursorPosition = activeCursor ? { ...activeCursor } : undefined;
-    cursorWasShown = activeCursor !== undefined;
-    return true;
-  };
-
-  render.clear = () => {
-    const prefix = buildReturnToBottomPrefix(
-      cursorWasShown,
-      previousLineCount,
-      previousCursorPosition,
-    );
-    stream.write(prefix + ansiEscapes.eraseLines(previousLineCount));
-    previousOutput = "";
-    previousLineCount = 0;
-    previousCursorPosition = undefined;
-    cursorWasShown = false;
-  };
-
-  render.done = () => {
-    previousOutput = "";
-    previousLineCount = 0;
-    previousCursorPosition = undefined;
-    cursorWasShown = false;
-
-    if (!showCursor) {
-      cliCursor.show(stream);
-      hasHiddenCursor = false;
-    }
-  };
-
-  render.reset = () => {
-    previousOutput = "";
-    previousLineCount = 0;
-    previousCursorPosition = undefined;
-    cursorWasShown = false;
-  };
-
-  render.sync = (str: string) => {
-    const activeCursor = cursorDirty ? cursorPosition : undefined;
-    cursorDirty = false;
-
-    const lines = str.split("\n");
-    previousOutput = str;
-    previousLineCount = lines.length;
-
-    if (!activeCursor && cursorWasShown) {
-      stream.write(hideCursorEscape);
-    }
-
-    if (activeCursor) {
-      stream.write(buildCursorSuffix(lines.length - 1, activeCursor));
-    }
-
-    previousCursorPosition = activeCursor ? { ...activeCursor } : undefined;
-    cursorWasShown = activeCursor !== undefined;
-  };
-
-  render.setCursorPosition = (position: CursorPosition | undefined) => {
-    cursorPosition = position;
-    cursorDirty = true;
-  };
-
-  render.isCursorDirty = () => cursorDirty;
-  render.willRender = (str: string) => hasChanges(str, getActiveCursor());
-
-  return render;
-};
-
-const createIncremental = (
-  stream: NodeJS.WritableStream,
-  { showCursor = false } = {},
-): LogUpdate => {
-  let previousLines: string[] = [];
-  let previousOutput = "";
-  let hasHiddenCursor = false;
-  let cursorPosition: CursorPosition | undefined;
-  let cursorDirty = false;
-  let previousCursorPosition: CursorPosition | undefined;
-  let cursorWasShown = false;
-
-  const getActiveCursor = () => (cursorDirty ? cursorPosition : undefined);
-  const hasChanges = (str: string, activeCursor: CursorPosition | undefined): boolean => {
-    const cursorChanged = cursorPositionChanged(activeCursor, previousCursorPosition);
-    return str !== previousOutput || cursorChanged;
-  };
-
-  const render = (str: string) => {
-    if (!showCursor && !hasHiddenCursor) {
-      cliCursor.hide(stream);
-      hasHiddenCursor = true;
-    }
-
-    // Only use cursor if setCursorPosition was called since last render.
-    // This ensures stale positions don't persist after component unmount.
-    const activeCursor = getActiveCursor();
-    cursorDirty = false;
-    const cursorChanged = cursorPositionChanged(activeCursor, previousCursorPosition);
-
-    if (!hasChanges(str, activeCursor)) {
-      return false;
-    }
-
-    const nextLines = str.split("\n");
-    const visibleCount = visibleLineCount(nextLines, str);
-    const previousVisible = visibleLineCount(previousLines, previousOutput);
-
-    if (str === previousOutput && cursorChanged) {
-      stream.write(
-        buildCursorOnlySequence({
-          cursorWasShown,
-          previousLineCount: previousLines.length,
-          previousCursorPosition,
-          cursorPosition: activeCursor,
-        }),
-      );
-      previousCursorPosition = activeCursor ? { ...activeCursor } : undefined;
-      cursorWasShown = activeCursor !== undefined;
-      return true;
-    }
-
-    const returnPrefix = buildReturnToBottomPrefix(
-      cursorWasShown,
-      previousLines.length,
-      previousCursorPosition,
-    );
-
-    if (str === "\n" || previousOutput.length === 0) {
-      const cursorSuffix = buildCursorSuffix(nextLines.length - 1, activeCursor);
-      stream.write(
-        returnPrefix + ansiEscapes.eraseLines(previousLines.length) + str + cursorSuffix,
-      );
-      cursorWasShown = activeCursor !== undefined;
-      previousCursorPosition = activeCursor ? { ...activeCursor } : undefined;
-      previousOutput = str;
-      previousLines = nextLines;
-      return true;
-    }
-
-    // A frame that grew may need rows past the bottom margin. The
-    // incremental walk moves over unchanged lines with cursorNextLine,
-    // which clamps at the bottom margin instead of scrolling (only a
-    // line feed scrolls), so a grown frame that reaches the bottom
-    // desynchronizes the tracked cursor position from the terminal.
-    // Rewrite the whole frame instead — every line is emitted with a
-    // newline, which scrolls correctly at the bottom.
-    if (visibleCount > previousVisible) {
-      const cursorSuffix = buildCursorSuffix(visibleCount, activeCursor);
-      stream.write(
-        returnPrefix + ansiEscapes.eraseLines(previousLines.length) + str + cursorSuffix,
-      );
-      cursorWasShown = activeCursor !== undefined;
-      previousCursorPosition = activeCursor ? { ...activeCursor } : undefined;
-      previousOutput = str;
-      previousLines = nextLines;
-      return true;
-    }
-
-    const hasTrailingNewline = str.endsWith("\n");
-
-    // We aggregate all chunks for incremental rendering into a buffer, and then write them to stdout at the end.
-    const buffer: string[] = [];
-
-    buffer.push(returnPrefix);
-
-    // Clear extra lines if the current content's line count is lower than the previous.
-    if (visibleCount < previousVisible) {
-      const previousHadTrailingNewline = previousOutput.endsWith("\n");
-      const extraSlot = previousHadTrailingNewline ? 1 : 0;
-      buffer.push(
-        ansiEscapes.eraseLines(previousVisible - visibleCount + extraSlot),
-        ansiEscapes.cursorUp(visibleCount),
-      );
-    } else {
-      buffer.push(ansiEscapes.cursorUp(previousLines.length - 1));
-    }
-
-    for (let i = 0; i < visibleCount; i++) {
-      const isLastLine = i === visibleCount - 1;
-
-      // We do not write lines if the contents are the same. This prevents flickering during renders.
-      if (nextLines[i] === previousLines[i]) {
-        // Don't move past the last line when there's no trailing newline,
-        // otherwise the cursor overshoots the rendered block.
-        if (!isLastLine || hasTrailingNewline) {
-          buffer.push(ansiEscapes.cursorNextLine);
-        }
-
-        continue;
-      }
-
-      buffer.push(
-        ansiEscapes.cursorTo(0) +
-          nextLines[i] +
-          ansiEscapes.eraseEndLine +
-          // Don't append newline after the last line when the input
-          // has no trailing newline (fullscreen mode).
-          (isLastLine && !hasTrailingNewline ? "" : "\n"),
-      );
-    }
-
-    const cursorSuffix = buildCursorSuffix(nextLines.length - 1, activeCursor);
-    buffer.push(cursorSuffix);
-
-    stream.write(buffer.join(""));
-
-    cursorWasShown = activeCursor !== undefined;
-    previousCursorPosition = activeCursor ? { ...activeCursor } : undefined;
-    previousOutput = str;
-    previousLines = nextLines;
-    return true;
-  };
-
-  render.clear = () => {
-    const prefix = buildReturnToBottomPrefix(
-      cursorWasShown,
-      previousLines.length,
-      previousCursorPosition,
-    );
-    stream.write(prefix + ansiEscapes.eraseLines(previousLines.length));
-    previousOutput = "";
-    previousLines = [];
-    previousCursorPosition = undefined;
-    cursorWasShown = false;
-  };
-
-  render.done = () => {
-    previousOutput = "";
-    previousLines = [];
-    previousCursorPosition = undefined;
-    cursorWasShown = false;
-
-    if (!showCursor) {
-      cliCursor.show(stream);
-      hasHiddenCursor = false;
-    }
-  };
-
-  render.reset = () => {
-    previousOutput = "";
-    previousLines = [];
-    previousCursorPosition = undefined;
-    cursorWasShown = false;
-  };
-
-  render.sync = (str: string) => {
-    const activeCursor = cursorDirty ? cursorPosition : undefined;
-    cursorDirty = false;
-
-    const lines = str.split("\n");
-    previousOutput = str;
-    previousLines = lines;
-
-    if (!activeCursor && cursorWasShown) {
-      stream.write(hideCursorEscape);
-    }
-
-    if (activeCursor) {
-      stream.write(buildCursorSuffix(lines.length - 1, activeCursor));
-    }
-
-    previousCursorPosition = activeCursor ? { ...activeCursor } : undefined;
-    cursorWasShown = activeCursor !== undefined;
-  };
-
-  render.setCursorPosition = (position: CursorPosition | undefined) => {
-    cursorPosition = position;
-    cursorDirty = true;
-  };
-
-  render.isCursorDirty = () => cursorDirty;
-  render.willRender = (str: string) => hasChanges(str, getActiveCursor());
-
-  return render;
-};
-
-const create = (
-  stream: NodeJS.WritableStream,
-  { showCursor = false, incremental = false } = {},
-): LogUpdate => {
-  if (incremental) {
-    return createIncremental(stream, { showCursor });
-  }
-
-  return createStandard(stream, { showCursor });
-};
-
-export const logUpdate = { create };

package/src/output.ts

@@ -1,308 +0,0 @@
-import { sliceAnsi } from "./ansi/slice.ts";
-import { stringWidth } from "./ansi/string-width.ts";
-import {
-  type StyledChar,
-  styledCharsFromTokens,
-  styledCharsToString,
-  tokenize,
-} from "./ansi/tokenize.ts";
-import { type OutputTransformer } from "./render-node-to-output.ts";
-
-/**
-"Virtual" output class
-
-Handles the positioning and saving of the output of each node in the tree. Also responsible for applying transformations to each character of the output.
-
-Used to generate the final output of all nodes before writing it to actual output stream (e.g. stdout)
-*/
-
-type Options = {
-  width: number;
-  height: number;
-};
-
-type Operation = WriteOperation | ClipOperation | UnclipOperation;
-
-type WriteOperation = {
-  type: "write";
-  x: number;
-  y: number;
-  text: string;
-  transformers: OutputTransformer[];
-};
-
-type ClipOperation = {
-  type: "clip";
-  clip: Clip;
-};
-
-type Clip = {
-  x1: number | undefined;
-  x2: number | undefined;
-  y1: number | undefined;
-  y2: number | undefined;
-};
-
-type UnclipOperation = {
-  type: "unclip";
-};
-
-class OutputCaches {
-  widths = new Map<string, number>();
-  blockWidths = new Map<string, number>();
-  styledChars = new Map<string, StyledChar[]>();
-
-  getStyledChars(line: string): StyledChar[] {
-    let cached = this.styledChars.get(line);
-    if (cached === undefined) {
-      cached = styledCharsFromTokens(tokenize(line));
-      this.styledChars.set(line, cached);
-    }
-
-    return cached;
-  }
-
-  getStringWidth(text: string): number {
-    let cached = this.widths.get(text);
-    if (cached === undefined) {
-      cached = stringWidth(text);
-      this.widths.set(text, cached);
-    }
-
-    return cached;
-  }
-
-  getWidestLine(text: string): number {
-    let cached = this.blockWidths.get(text);
-    if (cached === undefined) {
-      let lineWidth = 0;
-      for (const line of text.split("\n")) {
-        lineWidth = Math.max(lineWidth, this.getStringWidth(line));
-      }
-
-      cached = lineWidth;
-      this.blockWidths.set(text, cached);
-    }
-
-    return cached;
-  }
-}
-
-export class Output {
-  width: number;
-  height: number;
-
-  private readonly operations: Operation[] = [];
-  private readonly caches: OutputCaches = new OutputCaches();
-
-  constructor(options: Options) {
-    const { width, height } = options;
-
-    this.width = width;
-    this.height = height;
-  }
-
-  write(x: number, y: number, text: string, options: { transformers: OutputTransformer[] }): void {
-    const { transformers } = options;
-
-    if (!text) {
-      return;
-    }
-
-    this.operations.push({
-      type: "write",
-      x,
-      y,
-      text,
-      transformers,
-    });
-  }
-
-  clip(clip: Clip) {
-    this.operations.push({
-      type: "clip",
-      clip,
-    });
-  }
-
-  unclip() {
-    this.operations.push({
-      type: "unclip",
-    });
-  }
-
-  get(): { output: string; height: number } {
-    // Initialize output array with a specific set of rows, so that margin/padding at the bottom is preserved
-    const output: StyledChar[][] = [];
-
-    for (let y = 0; y < this.height; y++) {
-      const row: StyledChar[] = [];
-
-      for (let x = 0; x < this.width; x++) {
-        row.push({
-          type: "char",
-          value: " ",
-          fullWidth: false,
-          styles: [],
-        });
-      }
-
-      output.push(row);
-    }
-
-    const clips: Clip[] = [];
-
-    for (const operation of this.operations) {
-      if (operation.type === "clip") {
-        clips.push(operation.clip);
-      }
-
-      if (operation.type === "unclip") {
-        clips.pop();
-      }
-
-      if (operation.type === "write") {
-        const { text, transformers } = operation;
-        let { x, y } = operation;
-        let lines = text.split("\n");
-
-        const clip = clips.at(-1);
-
-        if (clip) {
-          const clipHorizontally = typeof clip?.x1 === "number" && typeof clip?.x2 === "number";
-
-          const clipVertically = typeof clip?.y1 === "number" && typeof clip?.y2 === "number";
-
-          // If text is positioned outside of clipping area altogether,
-          // skip to the next operation to avoid unnecessary calculations
-          if (clipHorizontally) {
-            const width = this.caches.getWidestLine(text);
-
-            if (x + width < clip.x1! || x > clip.x2!) {
-              continue;
-            }
-          }
-
-          if (clipVertically) {
-            const height = lines.length;
-
-            if (y + height < clip.y1! || y > clip.y2!) {
-              continue;
-            }
-          }
-
-          if (clipHorizontally) {
-            lines = lines.map((line) => {
-              const from = x < clip.x1! ? clip.x1! - x : 0;
-              const width = this.caches.getStringWidth(line);
-              const to = x + width > clip.x2! ? clip.x2! - x : width;
-
-              return sliceAnsi(line, from, to);
-            });
-
-            if (x < clip.x1!) {
-              x = clip.x1!;
-            }
-          }
-
-          if (clipVertically) {
-            const from = y < clip.y1! ? clip.y1! - y : 0;
-            const height = lines.length;
-            const to = y + height > clip.y2! ? clip.y2! - y : height;
-
-            lines = lines.slice(from, to);
-
-            if (y < clip.y1!) {
-              y = clip.y1!;
-            }
-          }
-        }
-
-        let offsetY = 0;
-
-        for (let [index, line] of lines.entries()) {
-          const currentLine = output[y + offsetY];
-
-          // Line can be missing if `text` is taller than height of pre-initialized `this.output`
-          if (!currentLine) {
-            continue;
-          }
-
-          for (const transformer of transformers) {
-            line = transformer(line, index);
-          }
-
-          const characters = this.caches.getStyledChars(line);
-          let offsetX = x;
-
-          // Nothing to write (e.g. line was clipped away).
-          if (characters.length === 0) {
-            offsetY++;
-            continue;
-          }
-
-          const spaceCell: StyledChar = {
-            type: "char",
-            value: " ",
-            fullWidth: false,
-            styles: [],
-          };
-
-          // Wide characters (e.g. CJK) occupy two cells: a leading
-          // cell with the character and a trailing placeholder with
-          // value ''. When an overlapping write lands in the middle
-          // of a wide character, the boundary cells need cleanup so
-          // the terminal never renders a half-visible wide character.
-          if (
-            currentLine[offsetX]?.value === "" &&
-            offsetX > 0 &&
-            this.caches.getStringWidth(currentLine[offsetX - 1]?.value ?? "") > 1
-          ) {
-            currentLine[offsetX - 1] = spaceCell;
-          }
-
-          for (const character of characters) {
-            currentLine[offsetX] = character;
-
-            // Determine printed width using string-width to align with measurement
-            const characterWidth = Math.max(1, this.caches.getStringWidth(character.value));
-
-            // For multi-column characters, clear following cells to avoid stray spaces/artifacts
-            if (characterWidth > 1) {
-              for (let columnOffset = 1; columnOffset < characterWidth; columnOffset++) {
-                currentLine[offsetX + columnOffset] = {
-                  type: "char",
-                  value: "",
-                  fullWidth: false,
-                  styles: character.styles,
-                };
-              }
-            }
-
-            offsetX += characterWidth;
-          }
-
-          if (currentLine[offsetX]?.value === "") {
-            currentLine[offsetX] = spaceCell;
-          }
-
-          offsetY++;
-        }
-      }
-    }
-
-    const generatedOutput = output
-      .map((line) => {
-        // See https://github.com/vadimdemedes/ink/pull/564#issuecomment-1637022742
-        const lineWithoutEmptyItems = line.filter((item) => item !== undefined);
-
-        return styledCharsToString(lineWithoutEmptyItems).trimEnd();
-      })
-      .join("\n");
-
-    return {
-      output: generatedOutput,
-      height: output.length,
-    };
-  }
-}