@travetto/terminal 3.0.0-rc.6 → 3.0.0-rc.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/terminal",
-  "version": "3.0.0-rc.6",
+  "version": "3.0.0-rc.8",
   "description": "General terminal support",
   "keywords": [
     "terminal",

package/src/operation.ts

@@ -1,6 +1,6 @@
 import { IterableUtil } from './iterable';
 import { TerminalWriter } from './writer';
-import { Indexed, TerminalProgressRender, TerminalWaitingConfig, TermLinePosition, TermState } from './types';
+import { Indexed, TermCoord, TerminalProgressRender, TerminalWaitingConfig, TermLinePosition, TermState } from './types';
 import { ColorOutputUtil, TermStyleInput } from './color-output';
 
 const STD_WAIT_STATES = '⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏'.split('');
@@ -10,8 +10,8 @@ export class TerminalOperation {
   /**
    * Allows for writing at top, bottom, or current position while new text is added
    */
-  static async streamToPosition(term: TermState, source: AsyncIterable<string>, pos: TermLinePosition = 'inline'): Promise<void> {
-    const curPos = { ...await term.getCursorPosition() };
+  static async streamToPosition(term: TermState, source: AsyncIterable<string>, pos: TermLinePosition = 'inline', curPos?: TermCoord): Promise<void> {
+    curPos ??= { ...await term.getCursorPosition() };
     const writePos = pos === 'inline' ?
       { ...curPos, x: 0 } :
       { x: 0, y: pos === 'top' ? 0 : -1 };
@@ -59,7 +59,7 @@ export class TerminalOperation {
   /**
    * Waiting indicator, streamed to a specific position, can be canceled
    */
-  static streamWaiting(term: TermState, message: string, config: TerminalWaitingConfig = {}): () => Promise<void> {
+  static streamWaiting(term: TermState, message: string, config: TerminalWaitingConfig = {}, curPos?: TermCoord): () => Promise<void> {
     const { stop, stream } = IterableUtil.cycle(STD_WAIT_STATES);
     const indicator = IterableUtil.map(
       stream,
@@ -67,7 +67,7 @@ export class TerminalOperation {
       (ch, i) => config.end ? `${message} ${ch}` : (i === 0 ? `${ch} ${message}` : ch)
     );
 
-    const final = this.streamToPosition(term, indicator, config.position ?? 'inline');
+    const final = this.streamToPosition(term, indicator, config.position ?? 'inline', curPos);
     return async () => { stop(); return final; };
   }
 
@@ -96,23 +96,33 @@ export class TerminalOperation {
   /**
    * Stream lines with a waiting indicator
    */
-  static async streamLinesWithWaiting(term: TermState, lines: AsyncIterable<string>, cfg: TerminalWaitingConfig = {}): Promise<void> {
+  static async streamLinesWithWaiting(term: TermState, lines: AsyncIterable<string | undefined>, cfg: TerminalWaitingConfig = {}): Promise<void> {
     let writer: (() => Promise<unknown>) | undefined;
     let line: string | undefined;
 
     const commitLine = async (): Promise<void> => {
       await writer?.();
       if (line) {
-        await TerminalWriter.for(term).restoreOnCommit().changePosition({ y: -1 }).changePosition({ x: 0 }).writeLine(line).commit();
+        const msg = cfg.commitedPrefix ? `${cfg.commitedPrefix} ${line}` : line;
+        if (cfg.position === 'inline') {
+          await TerminalWriter.for(term).setPosition({ x: 0 }).changePosition({ y: -1 }).writeLine(msg).commit();
+        } else {
+          await TerminalWriter.for(term).writeLine(msg).commit();
+        }
+        line = undefined;
       }
     };
 
-    for await (const msg of lines) {
+    const pos = await term.getCursorPosition();
+
+    for await (let msg of lines) {
       await commitLine();
-      line = `${String.fromCharCode(171)} ${msg}`;
-      writer = this.streamWaiting(term, line, cfg);
+      if (msg !== undefined) {
+        msg = msg.replace(/\n$/, '');
+        writer = this.streamWaiting(term, msg, cfg, pos);
+        line = msg;
+      }
     }
-
     await commitLine();
   }
 }

package/src/query.ts

@@ -50,7 +50,16 @@ export class TerminalQuerier {
   }
 
   async #readInput(query: string): Promise<Buffer> {
+    const isRaw = this.#input.isRaw;
+    const isPaused = this.#input.isPaused();
+    const data = this.#input.listeners('data');
     try {
+      this.#input.removeAllListeners('data');
+
+      if (isPaused) {
+        this.#input.resume();
+      }
+
       this.#input.setRawMode(true);
       // Send data, but do not wait on it
       this.#output.write(query);
@@ -58,7 +67,14 @@ export class TerminalQuerier {
       const val: Buffer | string = this.#input.read();
       return typeof val === 'string' ? Buffer.from(val, 'utf8') : val;
     } finally {
-      this.#input.setRawMode(false);
+      if (isPaused) {
+        this.#input.pause();
+      }
+      this.#input.setRawMode(isRaw);
+      for (const fn of data) {
+        // @ts-ignore
+        this.#input.on('data', fn);
+      }
     }
   }
 

package/src/terminal.ts

@@ -128,13 +128,17 @@ export class Terminal implements TermState {
    * @param config
    * @returns
    */
-  async streamLinesWithWaiting(lines: AsyncIterable<string>, config: TerminalWaitingConfig = {}): Promise<void> {
+  async streamLinesWithWaiting(lines: AsyncIterable<string | undefined>, config: TerminalWaitingConfig): Promise<void> {
     if (!this.interactive) {
       for await (const line of lines) {
-        await this.writeLines(line);
+        if (line !== undefined) {
+          const out = config.commitedPrefix ? `${config.commitedPrefix} ${line}` : line;
+          await this.writeLines(out);
+        }
       }
+    } else {
+      return TerminalOperation.streamLinesWithWaiting(this, lines, { position: 'bottom', ...config });
     }
-    return TerminalOperation.streamLinesWithWaiting(this, lines, config);
   }
 
   /**

package/src/types.ts

@@ -13,7 +13,7 @@ export type TerminalTableEvent = { idx: number, text: string, done?: boolean };
 export type TerminalTableConfig = { header?: string[], forceNonInteractiveOrder?: boolean };
 export type TerminalProgressEvent = { idx: number, total?: number, text?: string };
 export type TerminalProgressRender = (ev: TerminalProgressEvent) => string;
-export type TerminalWaitingConfig = { position?: TermLinePosition, end?: boolean } & DelayedConfig;
+export type TerminalWaitingConfig = { position?: TermLinePosition, end?: boolean, commitedPrefix?: string } & DelayedConfig;
 
 export type TermColorLevel = 0 | 1 | 2 | 3;
 export type TermColorScheme = 'dark' | 'light';