@travetto/terminal 3.0.0-rc.5 → 3.0.0-rc.7

package/package.json

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

package/src/iterable.ts

@@ -45,14 +45,14 @@ export class IterableUtil {
   }
 
   static cycle<T>(items: T[]): StoppableIterable<T> {
-    let done = true;
+    let done = false;
     async function* buildStream(): AsyncIterable<T> {
       let i = -1;
       while (!done) {
         yield items[(i += 1) % items.length];
       }
     }
-    return { stream: buildStream(), stop: (): void => { done = false; } };
+    return { stream: buildStream(), stop: (): void => { done = true; } };
   }
 
   static async drain<T>(source: AsyncIterable<T>): Promise<T[]> {

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,16 +59,16 @@ 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,
       IterableUtil.DELAY(config),
-      (ch, i) => i === 0 ? `${ch} ${message}` : ch
+      (ch, i) => config.end ? `${message} ${ch}` : (i === 0 ? `${ch} ${message}` : ch)
     );
 
-    const final = this.streamToPosition(term, indicator, config.position ?? 'inline');
-    return () => Promise.resolve(() => stop()).then(() => final);
+    const final = this.streamToPosition(term, indicator, config.position ?? 'inline', curPos);
+    return async () => { stop(); return final; };
   }
 
   /**
@@ -92,4 +92,34 @@ export class TerminalOperation {
       return `${color(l)}${r}`;
     };
   }
+
+  /**
+   * Stream lines with a waiting indicator
+   */
+  static async streamLinesWithWaiting(term: TermState, lines: AsyncIterable<string>, cfg: TerminalWaitingConfig = {}): Promise<void> {
+    let writer: (() => Promise<unknown>) | undefined;
+    let line: string | undefined;
+
+    const commitLine = async (): Promise<void> => {
+      await writer?.();
+      if (line) {
+        const msg = `${String.fromCharCode(171)} ${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();
+        }
+      }
+    };
+
+    const pos = await term.getCursorPosition();
+
+    for await (let msg of lines) {
+      await commitLine();
+      msg = msg.replace(/\n$/, '');
+      writer = this.streamWaiting(term, msg, cfg, pos);
+      line = msg;
+    }
+    await commitLine();
+  }
 }

package/src/terminal.ts

@@ -8,7 +8,7 @@ import {
 import { TerminalOperation } from './operation';
 import { TerminalQuerier } from './query';
 import { TerminalWriter } from './writer';
-import { ColorOutputUtil, TermStyleInput } from './color-output';
+import { ColorOutputUtil, Prim, TermColorFn, TermColorPalette, TermColorPaletteInput, TermStyleInput } from './color-output';
 
 type TerminalStreamPositionConfig = {
   position?: TermLinePosition;
@@ -121,6 +121,23 @@ export class Terminal implements TermState {
     return res.finally(TerminalOperation.streamWaiting(this, message, config));
   }
 
+  /**
+   * Stream line output, showing a waiting indicator for each line until the next one occurs
+   *
+   * @param lines
+   * @param config
+   * @returns
+   */
+  async streamLinesWithWaiting(lines: AsyncIterable<string>, config: TerminalWaitingConfig): Promise<void> {
+    if (!this.interactive) {
+      for await (const line of lines) {
+        await this.writeLines(line);
+      }
+    } else {
+      return TerminalOperation.streamLinesWithWaiting(this, lines, { position: 'bottom', ...config });
+    }
+  }
+
   /**
    * Consumes a stream, of events, tied to specific list indices, and updates in place
    */
@@ -167,17 +184,22 @@ export class Terminal implements TermState {
     return this.streamToPosition(source, async (v, i) => render(await resolve(v, i)), config);
   }
 
-  /* eslint-disable @typescript-eslint/member-ordering */
   /** Creates a colorer function */
-  colorer = ColorOutputUtil.colorer.bind(ColorOutputUtil, this);
+  colorer(style: TermStyleInput | [light: TermStyleInput, dark: TermStyleInput]): TermColorFn {
+    return ColorOutputUtil.colorer(this, style);
+  }
 
   /** Creates a color palette based on input styles */
-  palette = ColorOutputUtil.palette.bind(ColorOutputUtil, this);
+  palette<P extends TermColorPaletteInput>(input: P): TermColorPalette<P> {
+    return ColorOutputUtil.palette(this, input);
+  }
 
   /** Convenience method to creates a color template function based on input styles */
-  templateFunction = ColorOutputUtil.templateFunction.bind(ColorOutputUtil, this);
-  /* eslint-enable @typescript-eslint/member-ordering */
+  templateFunction<P extends TermColorPaletteInput>(input: P): (key: keyof P, val: Prim) => string {
+    return ColorOutputUtil.templateFunction(this, input);
+  }
 }
+
 export const GlobalTerminal = new Terminal({ output: process.stdout });
 
 // Trigger

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 } & DelayedConfig;
+export type TerminalWaitingConfig = { position?: TermLinePosition, end?: boolean } & DelayedConfig;
 
 export type TermColorLevel = 0 | 1 | 2 | 3;
 export type TermColorScheme = 'dark' | 'light';