Task

Reset all colors and styles.

Make the text bold.

Make the text dim.

Make the text italic.

Underline the text.

Invert the text and background colors.

Hide the text.

Strike through the text.

Set the text color to black.

Set the text color to red.

Set the text color to green.

Set the text color to yellow.

Set the text color to blue.

Set the text color to magenta.

Set the text color to cyan.

Set the text color to white.

Set the text background to black.

Set the text background to red.

Set the text background to green.

Set the text background to yellow.

Set the text background to blue.

Set the text background to magenta.

Set the text background to cyan.

Set the text background to white.

Set the text color to gray.

Hide the cursor.

Show the cursor.

Restore the cursor if it was hidden.

Move the cursor.

Move the cursor to the given column.

Move the cursor up by the given number of lines.

Reset cursor state to defaults.

Clears worker-wide cursor visibility tracking; concurrent prompts may restore cursor state differently depending on timing.

Erase the given number of lines downwards from the cursor position.

Erase from cursor until end of screen.

Register an event listener.

Emit an event.

Clean the event listeners.

Fake the terminal and queue key presses to be simulated.

Swaps prompt terminal and output state for the worker lifetime.

Implementation of the looping mechanism for simulating key presses.

By ignoring the $callable parameter which contains the default logic for simulating fake key presses, we can use a custom implementation to emit key presses instead, allowing us to use different inputs.

Assert that the output contains the given string.

Assert that the output doesn't contain the given string.

Assert that the stripped output contains the given string.

Assert that the stripped output doesn't contain the given string.

Get the buffered console output.

Get the buffered console output, stripped of escape sequences.

Enable the fallback implementation.

Whether the prompt should fallback to a custom implementation.

Set the fallback implementation.

Call the registered fallback implementation.

Reset fallback state to defaults.

Clears worker-wide prompt fallback configuration; concurrent prompts may render with different fallback behavior depending on timing.

Set interactive mode.

Determine if the prompt is interactive.

Reset interactivity state to defaults.

Clears worker-wide prompt interactivity configuration; concurrent prompts may render with different interactivity depending on timing.

Return the default value if it passes validation.

Get or set the active theme.

A given theme persists in a static property for the worker lifetime and applies to every subsequent prompt render.

Add a new theme.

Themes persist in a static property for the worker lifetime and are available to every subsequent prompt render.

Get the renderer for the current prompt.

Render the prompt using the active theme.

Reset theme state to defaults.

Clears worker-wide prompt theme configuration; concurrent prompts may render with different themes depending on timing.

Get the current value of the prompt.

Validate rules intrinsic to the prompt type.

Disable prompting for input.

Implementation of the prompt looping mechanism.

Register a callback to be invoked when a user cancels a prompt.

The callback persists in a static property for the worker lifetime and runs on every subsequent prompt cancellation.

How many new lines were written by the last output.

Capture the number of new lines written by the last output.

Set the output instance.

Get the current output instance.

Write output directly, bypassing newline capture.

Get the terminal instance.

Restore terminal state changed by the prompt operation.

Set the custom validation callback.

Get the custom validation callback.

Revert the prompt using the given callback.

Clear any previous revert callback.

Render the prompt.

Write a rendered frame using the output's decoration setting.

Submit the prompt.

Get the transformed value of the prompt.

Determine whether the given value is invalid when the prompt is required.

Flush all static state.

Clean up after the task.

Multi-byte version of wordwrap.

Word wrap text while preserving ANSI escape sequences.

Truncate visible ANSI text without cutting a control sequence.

Parse text into segments with their associated ANSI codes.

Update the bounded set of active SGR attributes.

Get the length of the longest line.

Pad text ignoring ANSI escape sequences.

Replace the last visible grapheme while preserving trailing formatting.

Strip ANSI escape sequences from the given text.

Add a complete logical log message.

Replace the in-progress partial with a complete supplied prefix.

Create a new Task instance.

Render the task and execute the callback.

Receive and process messages from the parent process.

Apply one decoded Task message.

Recompute the stable-message budget based on the current sub-label state.

Trim stable messages to the current display budget.

Reset state owned by one task operation.

Determine whether the final task summary should remain visible.

Finish rendering the task and clear it unless the summary should remain.

Reset the terminal after process rendering.

Print a single-line completion indicator after the task has finished.

Render the task using a child process for the animation loop.

Create the process renderer socket pair.

Subclasses and tests override this seam to exercise socket setup failures without replacing the process-rendering lifecycle.

Fork the process renderer.

Subclasses and tests override this seam to exercise fork and reaping failures without injecting a process abstraction.

Run the child process renderer.

When the caller ignores SIGCHLD or sets SA_NOCLDWAIT, the parent cannot obtain an exit status. Subclasses that complete settlement must write static::RENDERER_ACKNOWLEDGEMENT before closing their socket or the renderer will be reported as failed in that configuration.

Capture and replace the process renderer's signal state.

Restore signal state replaced by the process renderer.

Wait for the child renderer to close its socket.

Close the parent process socket.

Terminate the owned child renderer.

Reap the owned child renderer.

Render a static version of the task.

Render the task using a coroutine for the animation loop.

Uses the same in-process Task instance instead of socket IPC.

Clear the lines rendered by the task.