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

package/src/input-parser.ts

@@ -0,0 +1,283 @@
+import { ESC, pasteStart, pasteEnd } from "./ansi/escapes.ts";
+
+const escape = ESC;
+
+export type InputEvent = string | { readonly paste: string };
+
+type ParsedInput = {
+  readonly events: InputEvent[];
+  readonly pending: string;
+};
+
+type ParsedSequence =
+  | {
+      readonly sequence: string;
+      readonly nextIndex: number;
+    }
+  | "pending"
+  | undefined;
+
+const isCsiParameterByte = (byte: number): boolean => {
+  return byte >= 0x30 && byte <= 0x3f;
+};
+
+const isCsiIntermediateByte = (byte: number): boolean => {
+  return byte >= 0x20 && byte <= 0x2f;
+};
+
+const isCsiFinalByte = (byte: number): boolean => {
+  return byte >= 0x40 && byte <= 0x7e;
+};
+
+const parseCsiSequence = (
+  input: string,
+  startIndex: number,
+  prefixLength: number,
+): ParsedSequence => {
+  const csiPayloadStart = startIndex + prefixLength + 1;
+  let index = csiPayloadStart;
+  for (; index < input.length; index++) {
+    const byte = input.codePointAt(index);
+    if (byte === undefined) {
+      return "pending";
+    }
+
+    if (isCsiParameterByte(byte) || isCsiIntermediateByte(byte)) {
+      continue;
+    }
+
+    // Preserve legacy terminal function-key sequences like ESC[[A and ESC[[5~.
+    if (byte === 0x5b && index === csiPayloadStart) {
+      continue;
+    }
+
+    if (isCsiFinalByte(byte)) {
+      return {
+        sequence: input.slice(startIndex, index + 1),
+        nextIndex: index + 1,
+      };
+    }
+
+    return;
+  }
+
+  return "pending";
+};
+
+const parseSs3Sequence = (
+  input: string,
+  startIndex: number,
+  prefixLength: number,
+): ParsedSequence => {
+  const nextIndex = startIndex + prefixLength + 2;
+  if (nextIndex > input.length) {
+    return "pending";
+  }
+
+  const finalByte = input.codePointAt(nextIndex - 1);
+  if (finalByte === undefined || !isCsiFinalByte(finalByte)) {
+    return;
+  }
+
+  return {
+    sequence: input.slice(startIndex, nextIndex),
+    nextIndex,
+  };
+};
+
+const parseControlSequence = (
+  input: string,
+  startIndex: number,
+  prefixLength: number,
+): ParsedSequence => {
+  const sequenceType = input[startIndex + prefixLength];
+  if (sequenceType === undefined) {
+    return "pending";
+  }
+
+  if (sequenceType === "[") {
+    return parseCsiSequence(input, startIndex, prefixLength);
+  }
+
+  if (sequenceType === "O") {
+    return parseSs3Sequence(input, startIndex, prefixLength);
+  }
+
+  return;
+};
+
+const parseEscapedCodePoint = (
+  input: string,
+  escapeIndex: number,
+): {
+  readonly sequence: string;
+  readonly nextIndex: number;
+} => {
+  const nextCodePoint = input.codePointAt(escapeIndex + 1);
+  const nextCodePointLength = nextCodePoint !== undefined && nextCodePoint > 0xff_ff ? 2 : 1;
+  const nextIndex = escapeIndex + 1 + nextCodePointLength;
+
+  return {
+    sequence: input.slice(escapeIndex, nextIndex),
+    nextIndex,
+  };
+};
+
+type ParsedEscapeSequence =
+  | {
+      readonly sequence: string;
+      readonly nextIndex: number;
+    }
+  | "pending";
+
+const parseEscapeSequence = (input: string, escapeIndex: number): ParsedEscapeSequence => {
+  if (escapeIndex === input.length - 1) {
+    return "pending";
+  }
+
+  const next = input[escapeIndex + 1]!;
+  if (next === escape) {
+    if (escapeIndex + 2 >= input.length) {
+      return "pending";
+    }
+
+    const doubleEscapeSequence = parseControlSequence(input, escapeIndex, 2);
+    if (doubleEscapeSequence === "pending") {
+      return "pending";
+    }
+
+    if (doubleEscapeSequence) {
+      return doubleEscapeSequence;
+    }
+
+    return {
+      sequence: input.slice(escapeIndex, escapeIndex + 2),
+      nextIndex: escapeIndex + 2,
+    };
+  }
+
+  const controlSequence = parseControlSequence(input, escapeIndex, 1);
+  if (controlSequence === "pending") {
+    return "pending";
+  }
+
+  if (controlSequence) {
+    return controlSequence;
+  }
+
+  return parseEscapedCodePoint(input, escapeIndex);
+};
+
+/**
+Split a chunk of non-escape text so that backspace bytes (`0x7F` and `0x08`) become individual events. When a user holds the backspace key, the terminal sends repeated bytes in a single stdin chunk. Without splitting, `parseKeypress` receives the multi-byte string and fails to recognize it as a key event, corrupting the input state.
+
+Other control characters like `\r` and `\t` are NOT split because they can legitimately appear inside pasted text.
+*/
+const splitBackspaceBytes = (text: string, events: InputEvent[]): void => {
+  let textSegmentStart = 0;
+
+  for (let index = 0; index < text.length; index++) {
+    const character = text[index]!;
+    if (character === "\u007F" || character === "\u0008") {
+      if (index > textSegmentStart) {
+        events.push(text.slice(textSegmentStart, index));
+      }
+
+      events.push(character);
+      textSegmentStart = index + 1;
+    }
+  }
+
+  if (textSegmentStart < text.length) {
+    events.push(text.slice(textSegmentStart));
+  }
+};
+
+const parseKeypresses = (input: string): ParsedInput => {
+  const events: InputEvent[] = [];
+  let index = 0;
+  const pendingFrom = (pendingStartIndex: number): ParsedInput => ({
+    events,
+    pending: input.slice(pendingStartIndex),
+  });
+
+  while (index < input.length) {
+    const escapeIndex = input.indexOf(escape, index);
+    if (escapeIndex === -1) {
+      splitBackspaceBytes(input.slice(index), events);
+      return {
+        events,
+        pending: "",
+      };
+    }
+
+    if (escapeIndex > index) {
+      splitBackspaceBytes(input.slice(index, escapeIndex), events);
+    }
+
+    const parsedEscapeSequence = parseEscapeSequence(input, escapeIndex);
+    if (parsedEscapeSequence === "pending") {
+      return pendingFrom(escapeIndex);
+    }
+
+    if (parsedEscapeSequence.sequence === pasteStart) {
+      const afterStart = parsedEscapeSequence.nextIndex;
+      const endIndex = input.indexOf(pasteEnd, afterStart);
+      if (endIndex === -1) {
+        return pendingFrom(escapeIndex);
+      }
+
+      events.push({ paste: input.slice(afterStart, endIndex) });
+      index = endIndex + pasteEnd.length;
+      continue;
+    }
+
+    events.push(parsedEscapeSequence.sequence);
+    index = parsedEscapeSequence.nextIndex;
+  }
+
+  return {
+    events,
+    pending: "",
+  };
+};
+
+export type InputParser = {
+  push: (chunk: string) => InputEvent[];
+  hasPendingEscape: () => boolean;
+  flushPendingEscape: () => string | undefined;
+  reset: () => void;
+};
+
+export const createInputParser = (): InputParser => {
+  let pending = "";
+
+  return {
+    push(chunk) {
+      const parsedInput = parseKeypresses(pending + chunk);
+      pending = parsedInput.pending;
+      return parsedInput.events;
+    },
+    hasPendingEscape() {
+      // Don't trigger the escape flush timer while assembling a paste start
+      // marker (`\u001B[200` and then `~`) or while waiting for paste end.
+      return (
+        pending.startsWith(escape) &&
+        !pending.startsWith(pasteStart) &&
+        pending !== pasteStart.slice(0, -1)
+      );
+    },
+    flushPendingEscape() {
+      if (!pending.startsWith(escape)) {
+        return;
+      }
+
+      const pendingEscape = pending;
+      pending = "";
+      return pendingEscape;
+    },
+    reset() {
+      pending = "";
+    },
+  };
+};

package/src/instances.ts

@@ -0,0 +1,9 @@
+// Store all instances of Ink (instance.js) to ensure that consecutive render() calls
+// use the same instance of Ink and don't create a new one
+//
+// This map has to be stored in a separate file, because render.js creates instances,
+// but instance.js should delete itself from the map on unmount
+
+import type { Ink } from "./ink.tsx";
+
+export const instances = new WeakMap<NodeJS.WritableStream, Ink>();

package/src/is-in-ci.ts

@@ -0,0 +1,7 @@
+// Derived from `is-in-ci` (MIT, Sindre Sorhus).
+import process from "node:process";
+
+const check = (key: string): boolean =>
+  key in process.env && process.env[key] !== "0" && process.env[key] !== "false";
+
+export const isInCi = check("CI") || check("CONTINUOUS_INTEGRATION");

package/src/kitty-keyboard.ts

@@ -0,0 +1,57 @@
+// Kitty keyboard protocol flags.
+// @see https://sw.kovidgoyal.net/kitty/keyboard-protocol/
+export const kittyFlags = {
+  disambiguateEscapeCodes: 1,
+  reportEventTypes: 2,
+  reportAlternateKeys: 4,
+  reportAllKeysAsEscapeCodes: 8,
+  reportAssociatedText: 16,
+} as const;
+
+// Valid flag names for the kitty keyboard protocol.
+export type KittyFlagName = keyof typeof kittyFlags;
+
+// Converts an array of flag names to the corresponding bitmask value.
+export function resolveFlags(flags: KittyFlagName[]): number {
+  let result = 0;
+  for (const flag of flags) {
+    // eslint-disable-next-line no-bitwise
+    result |= kittyFlags[flag];
+  }
+
+  return result;
+}
+
+// Kitty keyboard modifier bits.
+// These are used in the modifier parameter of CSI u sequences.
+// Note: The actual modifier value is (modifiers - 1) as per the protocol.
+export const kittyModifiers = {
+  shift: 1,
+  alt: 2,
+  ctrl: 4,
+  super: 8,
+  hyper: 16,
+  meta: 32,
+  capsLock: 64,
+  numLock: 128,
+} as const;
+
+// Options for configuring kitty keyboard protocol.
+export type KittyKeyboardOptions = {
+  // Mode for kitty keyboard protocol support.
+  // - 'auto': Attempt to detect terminal support (default)
+  // - 'enabled': Force enable the protocol
+  // - 'disabled': Never enable the protocol
+  mode?: "auto" | "enabled" | "disabled";
+
+  // Protocol flags to request from the terminal.
+  // Pass an array of flag name strings.
+  //
+  // Available flags:
+  // - 'disambiguateEscapeCodes' - Disambiguate escape codes (default)
+  // - 'reportEventTypes' - Report key press, repeat, and release events
+  // - 'reportAlternateKeys' - Report alternate key encodings
+  // - 'reportAllKeysAsEscapeCodes' - Report all keys as escape codes
+  // - 'reportAssociatedText' - Report associated text with key events
+  flags?: KittyFlagName[];
+};