fix: linear output from function commands

Author: schummar

.eslintrc.cjs

@@ -11,5 +11,6 @@ module.exports = {
     '@typescript-eslint/no-explicit-any': 'off',
     '@typescript-eslint/no-empty-interface': 'off',
     'prettier/prettier': 'warn',
+    '@typescript-eslint/no-this-alias': 'off',
   },
 };

package.json

@@ -1,5 +1,6 @@
 {
   "name": "@schummar/runp",
+  "type": "commonjs",
   "version": "0.0.0-develop",
   "description": "Neat parallel task execution",
   "keywords": [
@@ -45,7 +46,7 @@
     "@vitejs/plugin-react": "4.3.3",
     "chalk": "^5.3.0",
     "cleye": "1.3.2",
-    "cross-state": "0.41.3",
+    "cross-state": "0.48.0",
     "esbuild": "0.24.0",
     "eslint": "8.57.0",
     "eslint-config-prettier": "9.1.0",

pnpm-lock.yaml

@@ -1,59 +1,12 @@
 import { RenderOptions, createRoot } from '@schummar/react-terminal';
-import { Store } from 'cross-state';
-import { Task, TaskState } from '../task';
+import { Task } from '../task';
 import { TaskList } from './taskList';
-
-export type WriteLineGrouped = (text: string, taskState: Store<TaskState>) => void;
+import { trackLinearOutput } from '../trackLinearOutput';
 
 export function renderTaskList(tasks: Task[], options?: RenderOptions) {
   const { render, writeLine } = createRoot(options);
 
-  let currentTask: Store<TaskState> | undefined;
-
-  const endTask = () => {
-    if (!currentTask) {
-      return;
-    }
-
-    writeLine('');
-    writeLine(`<- [${currentTask.get().title}] --`, {
-      grow: 1,
-      shrink: 1,
-      ellipsis: true,
-      bold: true,
-      backgroundColor: 'blue',
-    });
-  };
-
-  const writeLineGrouped: WriteLineGrouped = (text, taskState) => {
-    if (taskState !== currentTask) {
-      endTask();
-
-      writeLine('');
-      writeLine(`-- [${taskState.get().title}] ->`, {
-        grow: 1,
-        shrink: 1,
-        ellipsis: true,
-        bold: true,
-        backgroundColor: 'blue',
-      });
-      writeLine('');
-    }
-
-    currentTask = taskState;
-    writeLine(text);
-  };
-
-  tasks.forEach((task) =>
-    task.result
-      .catch(() => undefined)
-      .finally(() => {
-        if (task.state === currentTask) {
-          endTask();
-          currentTask = undefined;
-        }
-      }),
-  );
+  trackLinearOutput(tasks, writeLine);
 
-  return render(<TaskList tasks={tasks} writeLine={writeLineGrouped} />);
+  return render(<TaskList tasks={tasks} />);
 }

src/components/renderTaskList.tsx

@@ -1,13 +1,12 @@
 import { Paragraph } from '@schummar/react-terminal';
 import { Task } from '../task';
-import { WriteLineGrouped } from './renderTaskList';
 import { TaskListEntry } from './taskListEntry';
 
-export function TaskList({ tasks, writeLine }: { tasks: Task[]; writeLine: WriteLineGrouped }) {
+export function TaskList({ tasks }: { tasks: Task[] }) {
   return (
     <Paragraph margin={[1, 0, 0, 0]}>
       {tasks.map((task, index) => (
-        <TaskListEntry key={index} writeLine={writeLine} {...task} />
+        <TaskListEntry key={index} {...task} />
       ))}
     </Paragraph>
   );

src/components/taskList.tsx

@@ -1,16 +1,10 @@
 import { Paragraph, Text } from '@schummar/react-terminal';
 import { useStore } from 'cross-state/react';
-import { useEffect } from 'react';
 import { statusIcons } from '../statusIcons';
 import { Task } from '../task';
-import { WriteLineGrouped } from './renderTaskList';
 import { Spinner } from './spinner';
 
-export function TaskListEntry({
-  command: { keepOutput, forever, outputLength, displayTimeOver = -Infinity, linearOutput },
-  state,
-  writeLine,
-}: Task & { writeLine: WriteLineGrouped }) {
+export function TaskListEntry({ command: { keepOutput, forever, outputLength, displayTimeOver = -Infinity, linearOutput }, state }: Task) {
   const status = useStore(state, (x) => x.status);
   const statusString = useStore(state, (x) => x.statusString);
   const title = useStore(state, (x) => x.title);
@@ -31,24 +25,6 @@ export function TaskListEntry({
     return undefined;
   });
 
-  useEffect(() => {
-    if (!linearOutput) {
-      return;
-    }
-
-    let offset = 0;
-
-    return state
-      .map((x) => x.output)
-      .subscribe((output) => {
-        const newOutput = output.slice(offset);
-        if (newOutput) {
-          writeLine(newOutput, state);
-        }
-        offset = output.length;
-      });
-  }, [linearOutput, state]);
-
   return (
     <Paragraph>
       {statusString !== undefined ? (
@@ -92,7 +68,7 @@ export function TaskListEntry({
 
       {subTasks?.map((task, index) => (
         <Paragraph key={index} margin={[0, 0, 0, 2]}>
-          <TaskListEntry writeLine={writeLine} {...task} />
+          <TaskListEntry {...task} />
         </Paragraph>
       ))}
     </Paragraph>

src/components/taskListEntry.tsx

@@ -6,6 +6,7 @@ import { renderTaskList } from './components/renderTaskList';
 import { loadNpmWorkspaceScripts } from './npmUtils';
 import { statusIcons } from './statusIcons';
 import { Task, task } from './task';
+import { trackLinearOutput } from './trackLinearOutput';
 import { formatTime, indent } from './util';
 import wildcardMatch from './wildcardMatch';
 
@@ -58,9 +59,12 @@ export interface RunpCommandRaw extends Omit<Partial<RunpCommand>, 'args' | 'dep
   dependsOn?: string | number | Array<string | number>;
 }
 
-export interface RunpOptions extends RunpCommonOptions {
+type Commands = (string | [cmd: string, ...args: string[]] | RunpCommandRaw | false | undefined | null)[];
+export type RunpResult = { result: 'success'; output: string } | { result: 'error'; output: string };
+
+export interface RunpOptions<TCommands extends Commands = Commands> extends RunpCommonOptions {
   /** A list of command to execute in parallel */
-  commands: (string | [cmd: string, ...args: string[]] | RunpCommandRaw | false | undefined | null)[];
+  commands: TCommands;
   /** Maximum number of parallel tasks */
   parallelTasks?: number;
   target?: RenderOptions['target'];
@@ -72,7 +76,9 @@ export const RUNP_TASK_DELEGATE = `__runp_task__${RUNP_TASK_V}__`;
 
 const switchRegexp = /s|p|f(=(true|false))?|k(=(true|false))?|n=\d+/g;
 
-export async function runp(options: RunpOptions) {
+export async function runp<const TCommands extends Commands = Commands>(
+  options: RunpOptions<TCommands>,
+): Promise<{ [K in keyof TCommands]: RunpResult }> {
   const resolvedCommands = await resolveCommands(options);
 
   if (process.env.RUNP === RUNP_TASK_V) {
@@ -98,32 +104,12 @@ export async function runp(options: RunpOptions) {
   if (process.stdout.isTTY || options.target) {
     stop = renderTTY(tasks, options.target);
   } else {
-    await renderNonTTY(tasks);
+    stop = await renderNonTTY(tasks);
   }
 
-  const results = await Promise.all(
-    tasks.map((task) =>
-      task.result
-        .then(
-          (output) =>
-            ({
-              result: 'success',
-              output,
-            }) as const,
-        )
-        .catch(
-          (output: string) =>
-            ({
-              result: 'error',
-              output,
-            }) as const,
-        ),
-    ),
-  );
-
+  const results = await Promise.all(tasks.map((task) => task.result));
   stop?.();
-
-  return results;
+  return results as { [K in keyof TCommands]: RunpResult };
 }
 
 export async function resolveCommands(options: RunpOptions) {
@@ -324,15 +310,14 @@ function renderTTY(tasks: ReturnType<typeof task>[], target?: RenderOptions['tar
 }
 
 async function renderNonTTY(tasks: ReturnType<typeof task>[], margin = 0) {
-  for (const {
-    command: { keepOutput, displayTimeOver = -Infinity },
-    result,
-    state,
-  } of tasks) {
-    await result.catch(() => undefined);
+  trackLinearOutput(tasks, (line: string) => console.log(line));
+
+  for (const { command, result, state } of tasks) {
+    const { linearOutput, keepOutput, displayTimeOver = -Infinity } = command;
+    await result;
     const { status, statusString = statusIcons[status], title, subTasks, time } = state.get();
     const output = state.get().output.trim();
-    const showOutput = (status === 'error' || keepOutput) && output.length > 0;
+    const showOutput = !linearOutput && (status === 'error' || keepOutput) && output.length > 0;
     const timeString = time !== undefined && time >= displayTimeOver ? ` [${formatTime(time)}]` : '';
 
     console.info(indent(`${statusString} ${title}${timeString}`, margin));

src/index.ts

@@ -19,6 +19,8 @@ export async function loadNpmPackage(pkg: string): Promise<{ name: string; scrip
   }
 }
 
+const supportedNpmRunners = ['npm', 'pnpm', 'yarn'] as const;
+
 export async function loadNpmWorkspaceScripts(cwd: string): Promise<{ scriptName: string; scriptCommand: (args: string[]) => string[] }[]> {
   const npmRunner = await whichNpmRunner(cwd);
   const workspaceRoot = resolve(cwd);
@@ -67,6 +69,10 @@ export async function loadNpmWorkspaceScripts(cwd: string): Promise<{ scriptName
 }
 
 export async function whichNpmRunner(cwd: string) {
+  if ((supportedNpmRunners as unknown as string[]).includes(process.env.RUNP_PACKAGE_MANAGER ?? '')) {
+    return process.env.RUNP_PACKAGE_MANAGER as (typeof supportedNpmRunners)[number];
+  }
+
   if (process.env.npm_config_user_agent?.startsWith('yarn/')) {
     return 'yarn';
   } else if (process.env.npm_config_user_agent?.startsWith('pnpm/')) {