@types/blessed

Version 0.1.25
Published 5 months ago
103 kB
1 dependency
MIT license

Install

npm i @types/blessed

yarn add @types/blessed

pnpm add @types/blessed

Overview

TypeScript definitions for blessed

Index

Variables

variable colors

const colors: { match(hexColor: string): string };

Functions

function bigtext

bigtext: (options?: Widgets.BigTextOptions) => Widgets.BigTextElement;

function box

box: (options?: Widgets.BoxOptions) => Widgets.BoxElement;

function button

button: (options?: Widgets.ButtonOptions) => Widgets.ButtonElement;

function checkbox

checkbox: (options?: Widgets.CheckboxOptions) => Widgets.CheckboxElement;

function cleanTags

cleanTags: (text: string) => string;

function escape

escape: (text: string) => string;

function filemanager

filemanager: (
    options?: Widgets.FileManagerOptions
) => Widgets.FileManagerElement;

function form

form: <TFormData>(
    options?: Widgets.FormOptions
) => Widgets.FormElement<TFormData>;

function generateTags

generateTags: (style: any, text: string) => string;

function input

input: (options?: Widgets.InputOptions) => Widgets.InputElement;

function layout

layout: (options?: Widgets.LayoutOptions) => Widgets.LayoutElement;

function line

line: (options?: Widgets.LineOptions) => Widgets.LineElement;

function list

list: (
    options?: Widgets.ListOptions<Widgets.ListElementStyle>
) => Widgets.ListElement;

function listbar

listbar: (options?: Widgets.ListbarOptions) => Widgets.ListbarElement;

function listtable

listtable: (options?: Widgets.ListTableOptions) => Widgets.ListTableElement;

function loading

loading: (options?: Widgets.LoadingOptions) => Widgets.LoadingElement;

function log

log: (options?: Widgets.LogOptions) => Widgets.Log;

function message

message: (options?: Widgets.MessageOptions) => Widgets.MessageElement;

function parseTags

parseTags: (text: string, screen?: Widgets.Screen) => string;

function program

program: (options?: Widgets.IScreenOptions) => BlessedProgram;

function progressbar

progressbar: (
    options?: Widgets.ProgressBarOptions
) => Widgets.ProgressBarElement;

function prompt

prompt: (options?: Widgets.PromptOptions) => Widgets.PromptElement;

function question

question: (options?: Widgets.QuestionOptions) => Widgets.QuestionElement;

function radiobutton

radiobutton: (
    options?: Widgets.RadioButtonOptions
) => Widgets.RadioButtonElement;

function radioset

radioset: (options?: Widgets.RadioSetOptions) => Widgets.RadioSetElement;

function screen

screen: (options?: Widgets.IScreenOptions) => Widgets.Screen;

function scrollablebox

scrollablebox: (options?: Widgets.BoxOptions) => Widgets.BoxElement;

function scrollabletext

scrollabletext: (options?: Widgets.BoxOptions) => Widgets.BoxElement;

function stripTags

stripTags: (text: string) => string;

function table

table: (options?: Widgets.TableOptions) => Widgets.TableElement;

function terminal

terminal: (options?: Widgets.TerminalOptions) => Widgets.TerminalElement;

function text

text: (options?: Widgets.TextOptions) => Widgets.TextElement;

function textarea

textarea: (options?: Widgets.TextareaOptions) => Widgets.TextareaElement;

function textbox

textbox: (options?: Widgets.TextboxOptions) => Widgets.TextboxElement;

Classes

class BlessedProgram

class BlessedProgram extends EventEmitter {}

constructor

constructor(options?: IBlessedProgramOptions);

property cols

cols: number;

property input

input: Readable;

property isiTerm2

isiTerm2: boolean;

property isLXDE

isLXDE: boolean;

property isOSXTerm

isOSXTerm: boolean;

property isRxvt

isRxvt: boolean;

property isTerminator

isTerminator: boolean;

property isVTE

isVTE: boolean;

property isXFCE

isXFCE: boolean;

property isXterm

isXterm: boolean;

property options

options: IBlessedProgramOptions;

property output

output: Writable;

property restoreReportedCursor

restoreReportedCursor: () => boolean;

property resume

resume: () => void;

property rows

rows: number;

property savedX

savedX: number;

property savedY

savedY: number;

property scrollBottom

scrollBottom: number;

property scrollTop

scrollTop: number;

property tmux

tmux: boolean;

property tmuxVersion

tmuxVersion: number;

property type

type: string;

property useBuffer

useBuffer: boolean;

property x

x: number;

property y

y: number;

property zero

zero: boolean;

method ae

ae: () => boolean;

method alternate

alternate: () => boolean;

method alternateBuffer

alternateBuffer: () => boolean;

method as

as: () => boolean;

method back

back: (param?: number) => boolean;

method backspace

backspace: () => boolean;

method bel

bel: () => boolean;

method bell

bell: () => boolean;

method bg

bg: (color: string, val?: boolean) => boolean;

method bindMouse

bindMouse: () => void;

method bindResponse

bindResponse: () => void;

method cbt

cbt: (param?: number) => boolean;

method cha

cha: (param?: number) => boolean;

method charAttributes

charAttributes: {
    (param: string, val?: boolean): boolean;
    (param: string[], val?: boolean): boolean;
};

method charPosAbsolute

charPosAbsolute: (param?: number) => boolean;

method charset

charset: (val?: string, level?: number) => boolean;

method cht

cht: (param?: number) => boolean;

method civis

civis: () => boolean;

method clear

clear: () => boolean;

method cnl

cnl: (param?: number) => boolean;

method copyRectangle

copyRectangle: (...args: string[]) => boolean;

method copyToClipboard

copyToClipboard: (text: string) => boolean;

method cpl

cpl: (param?: number) => boolean;

method cr

cr: () => boolean;

method csr

csr: (top: number, bottom: number) => boolean;

method cub

cub: (param?: number) => boolean;

method cud

cud: (param?: number) => boolean;

method cuf

cuf: (param?: number) => boolean;

method cup

cup: (row?: number, col?: number) => boolean;

method cursor_invisible

cursor_invisible: () => boolean;

method cursorBackward

cursorBackward: (param?: number) => boolean;

method cursorBackwardTab

cursorBackwardTab: (param?: number) => boolean;

method cursorCharAbsolute

cursorCharAbsolute: (param?: number) => boolean;

method cursorColor

cursorColor: (color: string) => boolean;

method cursorDown

cursorDown: (param?: number) => boolean;

method cursorForward

cursorForward: (param?: number) => boolean;

method cursorForwardTab

cursorForwardTab: (param?: number) => boolean;

method cursorNextLine

cursorNextLine: (param?: number) => boolean;

method cursorPos

cursorPos: (row?: number, col?: number) => boolean;

method cursorPrecedingLine

cursorPrecedingLine: (param?: number) => boolean;

method cursorReset

cursorReset: () => boolean;

method cursorShape

cursorShape: (shape: string, blink?: boolean) => boolean;

method cursorUp

cursorUp: (param?: number) => boolean;

method cuu

cuu: (param?: number) => boolean;

method da

da: (param?: number, callback?: Function) => boolean;

method dch

dch: (param?: number) => boolean;

method debug

debug: () => boolean;

method deccara

deccara: (...args: string[]) => boolean;

method deccra

deccra: (...args: string[]) => boolean;

method decdc

decdc: (...args: string[]) => boolean;

method decefr

decefr: (...args: string[]) => boolean;

method decelr

decelr: (...args: string[]) => boolean;

method decera

decera: (...args: string[]) => boolean;

method decfra

decfra: (...args: string[]) => boolean;

method decic

decic: (...args: string[]) => boolean;

method decll

decll: (param?: number) => boolean;

method decrara

decrara: (...args: string[]) => boolean;

method decreqtparm

decreqtparm: (param: number) => boolean;

method decrqlp

decrqlp: (param?: string, callback?: Function) => boolean;

method decrqm

decrqm: (param?: number) => boolean;

method decrqmp

decrqmp: (param?: number) => boolean;

method decrst

decrst: (...args: string[]) => boolean;

method decsace

decsace: (param?: number) => boolean;

method decsca

decsca: (param?: number) => boolean;

method decscl

decscl: (...args: string[]) => boolean;

method decscursr

decscursr: (param?: string) => boolean;

method decsera

decsera: (...args: string[]) => boolean;

method decset

decset: (...args: string[]) => boolean;

method decsle

decsle: (...args: string[]) => boolean;

method decstbm

decstbm: (top: number, bottom: number) => boolean;

method decstr

decstr: () => boolean;

method decswbv

decswbv: (param?: number) => boolean;

method dectcemh

dectcemh: () => boolean;

method deleteChars

deleteChars: (param?: number) => boolean;

method deleteColumns

deleteColumns: (...args: string[]) => boolean;

method deleteLines

deleteLines: (param?: number) => boolean;

method destroy

destroy: () => void;

method deviceStatuses

deviceStatuses: (
    param?: string,
    callback?: Function,
    dec?: boolean,
    noBypass?: boolean
) => boolean;

method disableGpm

disableGpm: () => void;

method disableModifieres

disableModifieres: (...args: string[]) => boolean;

method disableMouse

disableMouse: () => void;

method dl

dl: (param?: number) => boolean;

method down

down: (param?: number) => boolean;

method dsr

dsr: (
    param?: string,
    callback?: Function,
    dec?: boolean,
    noBypass?: boolean
) => boolean;

method dynamicColors

dynamicColors: (param?: string) => boolean;

method ech

ech: (param?: number) => boolean;

method echo

echo: (text: string, attr?: boolean) => boolean;

method ed

ed: (param?: string) => boolean;

method el

el: (param?: string) => boolean;

method enableFilterRectangle

enableFilterRectangle: (...args: string[]) => boolean;

method enableGpm

enableGpm: () => void;

method enableLocatorReporting

enableLocatorReporting: (...args: string[]) => boolean;

method enableMouse

enableMouse: () => void;

method enter_alt_charset_mode

enter_alt_charset_mode: () => boolean;

method eraseChars

eraseChars: (param?: number) => boolean;

method eraseInDisplay

eraseInDisplay: (param?: string) => boolean;

method eraseInLine

eraseInLine: (param?: string) => boolean;

method eraseRectangle

eraseRectangle: (...args: string[]) => boolean;

method exit_alt_charset_mode

exit_alt_charset_mode: () => boolean;

method feed

feed: () => boolean;

method ff

ff: () => boolean;

method fg

fg: (color: string, val?: boolean) => boolean;

method fillRectangle

fillRectangle: (...args: string[]) => boolean;

method flush

flush: () => void;

method form

form: () => boolean;

method forward

forward: (param?: number) => boolean;

method getCursor

getCursor: (callback: Function) => boolean;

method getCursorColor

getCursorColor: (callback: Function) => boolean;

method getTextParams

getTextParams: (param: string, callback: Function) => boolean;

method getWindowSize

getWindowSize: (callback?: Function) => boolean;

method has

has: (name: string) => boolean;

method hideCursor

hideCursor: () => boolean;

method hpa

hpa: (param?: number) => boolean;

method HPositionRelative

HPositionRelative: (param?: number) => boolean;

method ht

ht: () => boolean;

method hvp

hvp: (row?: number, col?: number) => boolean;

method HVPosition

HVPosition: (row?: number, col?: number) => boolean;

method ich

ich: (param?: number) => boolean;

method il

il: (param?: number) => boolean;

method ind

ind: () => boolean;

method index

index: () => boolean;

method initMouseTracking

initMouseTracking: (...args: string[]) => boolean;

method insertChars

insertChars: (param?: number) => boolean;

method insertColumns

insertColumns: (...args: string[]) => boolean;

method insertLines

insertLines: (param?: number) => boolean;

method kbs

kbs: () => boolean;

method key

key: (key: string | string[], listener: Function) => void;

method left

left: (param?: number) => boolean;

method lineHeight

lineHeight: () => boolean;

method linePosAbsolute

linePosAbsolute: (param?: number) => boolean;

method listen

listen: () => void;

method loadLEDs

loadLEDs: (param?: number) => boolean;

method log

log: () => boolean;

method lrestoreCursor

lrestoreCursor: (key?: string, hide?: boolean) => void;

method lsaveCursor

lsaveCursor: (key?: string) => void;

method manipulateWindow

manipulateWindow: (...args: any[]) => boolean;

method mc

mc: (...args: string[]) => boolean;

method mc0

mc0: () => boolean;

method mc4

mc4: () => boolean;

method mc5

mc5: () => boolean;

method mc5p

mc5p: () => boolean;

method mediaCopy

mediaCopy: (...args: string[]) => boolean;

method move

move: (x: number, y: number) => boolean;

method newline

newline: () => boolean;

method nextLine

nextLine: () => boolean;

method nl

nl: () => boolean;

method normalBuffer

normalBuffer: () => boolean;

method nul

nul: () => boolean;

method omove

omove: (x: number, y: number) => void;

method onceKey

onceKey: (key: string | string[], listener: Function) => void;

method out

out: (param: string, ...args: any[]) => boolean;

method p0

p0: () => boolean;

method pause

pause: (callback?: Function) => Function;

method pf

pf: () => boolean;

method po

po: () => boolean;

method pos

pos: (row?: number, col?: number) => boolean;

method print

print: (text: string, attr?: boolean) => boolean;

method print_screen

print_screen: () => boolean;

method prtr_non

prtr_non: () => boolean;

method prtr_off

prtr_off: () => boolean;

method prtr_on

prtr_on: () => boolean;

method ps

ps: () => boolean;

method rc

rc: (key?: string, hide?: boolean) => boolean;

method rcA

rcA: () => boolean;

method removeKey

removeKey: (key: string | string[], listener: Function) => void;

method rep

rep: (param?: number) => boolean;

method repeat

repeat: (ch: string, i?: number) => string;

method repeatPrecedingCharacter

repeatPrecedingCharacter: (param?: number) => boolean;

method req_mouse_pos

req_mouse_pos: (param?: string, callback?: Function) => boolean;

method reqmp

reqmp: (param?: string, callback?: Function) => boolean;

method requestAnsiMode

requestAnsiMode: (param?: number) => boolean;

method requestLocatorPosition

requestLocatorPosition: (param?: string, callback?: Function) => boolean;

method requestParameters

requestParameters: (param?: number) => boolean;

method requestPrivateMode

requestPrivateMode: (param?: number) => boolean;

method reset

reset: () => boolean;

method resetColors

resetColors: (param?: string) => boolean;

method resetCursor

resetCursor: () => boolean;

method resetMode

resetMode: (...args: string[]) => boolean;

method resetTitleModes

resetTitleModes: (...args: string[]) => boolean;

method response

response: {
    (
        name: string,
        text: string,
        callback: Function,
        noBypass?: boolean
    ): boolean;
    (name: string, callback?: Function): boolean;
};

method restoreCursor

restoreCursor: (key?: string, hide?: boolean) => boolean;

method restoreCursorA

restoreCursorA: () => boolean;

method restorePrivateValues

restorePrivateValues: (...args: string[]) => boolean;

method return

return: () => boolean;

method reverse

reverse: () => boolean;

method reverseAttrInRectangle

reverseAttrInRectangle: (...args: string[]) => boolean;

method reverseIndex

reverseIndex: () => boolean;

method ri

ri: () => boolean;

method right

right: (param?: number) => boolean;

method rm

rm: (...args: string[]) => boolean;

method rmacs

rmacs: () => boolean;

method rmcup

rmcup: () => boolean;

method rmove

rmove: (x: number, y: number) => void;

method rs2

rs2: () => boolean;

method rsetx

rsetx: (x: number) => boolean;

method rsety

rsety: (y: number) => boolean;

method saveCursor

saveCursor: (key: string) => boolean;

method saveCursorA

saveCursorA: () => boolean;

method savePrivateValues

savePrivateValues: (...args: string[]) => boolean;

method saveReportedCursor

saveReportedCursor: (callback: Function) => void;

method sc

sc: (key: string) => boolean;

method scA

scA: () => boolean;

method scrollDown

scrollDown: (param?: number) => boolean;

method scrollUp

scrollUp: (param?: number) => boolean;

method sd

sd: (param?: number) => boolean;

method selData

selData: (a: string, b: string) => boolean;

method selectChangeExtent

selectChangeExtent: (param?: number) => boolean;

method selectiveEraseRectangle

selectiveEraseRectangle: (...args: string[]) => boolean;

method sendDeviceAttributes

sendDeviceAttributes: (param?: number, callback?: Function) => boolean;

method setAttrInRectangle

setAttrInRectangle: (...args: string[]) => boolean;

method setBackground

setBackground: (color: string, val?: boolean) => boolean;

method setCharProtectionAttr

setCharProtectionAttr: (param?: number) => boolean;

method setConformanceLevel

setConformanceLevel: (...args: string[]) => boolean;

method setCursorStyle

setCursorStyle: (param?: string) => boolean;

method setForeground

setForeground: (color: string, val?: boolean) => boolean;

method setG

setG: (val: number) => boolean;

method setLocatorEvents

setLocatorEvents: (...args: string[]) => boolean;

method setMarginBellVolume

setMarginBellVolume: (param?: number) => boolean;

method setMode

setMode: (...args: string[]) => boolean;

method setMouse

setMouse: (opt?: {}, enable?: boolean) => void;

method setPointerMode

setPointerMode: (...args: string[]) => boolean;

method setResources

setResources: (...args: string[]) => boolean;

method setScrollRegion

setScrollRegion: (top: number, bottom: number) => boolean;

method setTerminal

setTerminal: (terminal: string) => void;

method setTitle

setTitle: (title: string) => boolean;

method setTitleModeFeature

setTitleModeFeature: (...args: string[]) => boolean;

method setupDump

setupDump: () => void;

method setupTput

setupTput: () => void;

method setWarningBellVolume

setWarningBellVolume: (param?: number) => boolean;

method setx

setx: (x: number) => boolean;

method sety

sety: (y: number) => boolean;

method shiftIn

shiftIn: () => boolean;

method shiftOut

shiftOut: () => boolean;

method showCursor

showCursor: () => boolean;

method sigtstp

sigtstp: (callback?: Function) => boolean;

method simpleInsert

simpleInsert: (ch: string, i?: number, attr?: boolean) => boolean;

method sm

sm: (...args: string[]) => boolean;

method smacs

smacs: () => boolean;

method smcup

smcup: () => boolean;

method softReset

softReset: () => boolean;

method su

su: (param?: number) => boolean;

method tab

tab: () => boolean;

method tabClear

tabClear: (param?: number) => boolean;

method tabSet

tabSet: () => boolean;

method tbc

tbc: (param?: number) => boolean;

method term

term: (is: string) => boolean;

method unKey

unKey: (key: string | string[], listener: Function) => void;

method up

up: (param?: number) => boolean;

method vi

vi: () => boolean;

method vpa

vpa: (param?: number) => boolean;

method VPositionRelative

VPositionRelative: (param?: number) => boolean;

method vpr

vpr: (param?: number) => boolean;

method vtab

vtab: () => boolean;

method write

write: (text: string) => boolean;

Interfaces

interface IBlessedProgramOptions

interface IBlessedProgramOptions {}

property buffer

buffer?: boolean | undefined;

property debug

debug?: boolean | undefined;

property dump

dump?: boolean | undefined;

property input

input?: Readable | undefined;

property log

log?: string | undefined;

property output

output?: Writable | undefined;

property resizeTimeout

resizeTimeout?: boolean | undefined;

property term

term?: string | undefined;

property terminal

terminal?: string | undefined;

property tput

tput?: string | undefined;

property zero

zero?: boolean | undefined;

Namespaces

namespace widget {}

class Terminal extends Widgets.TerminalElement {}

namespace Widgets

namespace Widgets {}

class ANSIImageElement

class ANSIImageElement extends BoxElement implements IHasOptions<ANSIImageOptions> {}

Convert any .png file (or .gif, see below) to an ANSI image and display it as an element.

constructor

constructor(options?: ANSIImageOptions);

property img

img: Types.TImage;

Image object from the png reader.

property options

options: ANSIImageOptions;

method clearImage

clearImage: (callback: () => void) => void;

clear the current image.

method pause

pause: () => void;

Pause animation.

method play

play: () => void;

Play animation if it has been paused or stopped.

method setImage

setImage: (img: string, callback: () => void) => void;

set the image in the box to a new path.

method stop

stop: () => void;

Stop animation.

class BigTextElement

class BigTextElement extends BoxElement implements IHasOptions<BigTextOptions> {}

A box which can render content drawn as 8x14 cell characters using the terminus font.

constructor

constructor(opts: BigTextOptions);

property options

options: BigTextOptions;

Original options object.

class BlessedElement

abstract class BlessedElement
    extends NodeWithEvents
    implements IHasOptions<ElementOptions> {}

constructor

constructor(opts: ElementOptions);

property abottom

abottom: Types.TPosition;

Calculated absolute bottom offset.

property aleft

aleft: Types.TTopLeft;

Calculated absolute left offset.

property aright

aright: Types.TPosition;

Calculated absolute right offset.

property atop

atop: Types.TTopLeft;

Calculated absolute top offset.

property bg

bg: number;

Border foreground and background, must be numbers (-1 for default).

property bold

bold: string;

Border attributes.

property border

border: Border;

Border object.

property bottom

bottom: Types.TPosition;

Calculated relative bottom offset.

property content

content: string;

property detached

detached: boolean;

property draggable

draggable: boolean;

Whether the element is draggable. Set to true to allow dragging.

property fg

fg: number;

property height

height: string | number;

Calculated height.

property hidden

hidden: boolean;

property iheight

iheight: Types.TPosition;

property ileft

ileft: Types.TTopLeft;

property itop

itop: Types.TTopLeft;

property iwidth

iwidth: Types.TPosition;

property left

left: Types.TTopLeft;

Calculated relative left offset.

property lpos

lpos: PositionCoords;

property name

name: string;

Name of the element. Useful for form submission.

property options

options: ElementOptions;

Original options object.

property position

position: Position;

property rbottom

rbottom: Types.TPosition;

Calculated relative bottom offset.

property right

right: Types.TPosition;

Calculated relative right offset.

property rleft

rleft: Types.TTopLeft;

Calculated relative left offset.

property rright

rright: Types.TPosition;

Calculated relative right offset.

property rtop

rtop: Types.TTopLeft;

Calculated relative top offset.

property style

style: any;

property top

top: Types.TTopLeft;

Calculated relative top offset.

property underline

underline: string;

property visible

visible: boolean;

property width

width: string | number;

Calculated width.

method clearBaseLine

clearBaseLine: (i: number) => void;

Clear a line from the box's content from the visible top.

method clearLine

clearLine: (i: number) => void;

Clear a line from the box's content.

method deleteBottom

deleteBottom: () => void;

Delete a line at the bottom of the box.

method deleteLine

deleteLine: (i: number) => void;

Delete a line from the box's content.

method deleteTop

deleteTop: () => void;

Delete a line at the top of the box.

method destroy

destroy: () => void;

Same as the detach() method, except this will automatically call free() and unbind any screen events to prevent memory leaks. for use with onScreenEvent(), removeScreenEvent(), and free().

method disableDrag

disableDrag: () => void;

Disable dragging of the element.

method enableDrag

enableDrag: () => void;

Enable dragging of the element.

method enableInput

enableInput: () => void;

Enable key and mouse events. Calls both enableMouse() and enableKeys().

method enableKeys

enableKeys: () => void;

Enable keypress events for the element (automatically called when a form of on('keypress') is bound).

method enableMouse

enableMouse: () => void;

Enable mouse events for the element (automatically called when a form of on('mouse') is bound).

method focus

focus: () => void;

Focus element.

method free

free: () => void;

Free up the element. Automatically unbind all events that may have been bound to the screen object. This prevents memory leaks. For use with onScreenEvent(), removeScreenEvent(), and destroy().

method getBaseLine

getBaseLine: (i: number) => string;

Get a line from the box's content from the visible top.

method getContent

getContent: () => string;

Return content, slightly different from el.content. Assume the above formatting.

method getLine

getLine: (i: number) => string;

Get a line from the box's content.

method getLines

getLines: () => string[];

An array containing the content lines.

method getScreenLines

getScreenLines: () => string[];

An array containing the lines as they are displayed on the screen.

method getText

getText: () => string;

Similar to getContent, but return content with tags and escape codes removed.

method hide

hide: () => void;

Hide element.

method insertBottom

insertBottom: (lines: string | string[]) => void;

Insert a line at the bottom of the box.

method insertLine

insertLine: (i: number, lines: string | string[]) => void;

Insert a line into the box's content.

method insertTop

insertTop: (lines: string | string[]) => void;

Insert a line at the top of the box.

method onScreenEvent

onScreenEvent: (type: string, handler: (...args: any[]) => void) => void;

Same asel.on('screen', ...) except this will automatically keep track of which listeners are bound to the screen object. For use with removeScreenEvent(), free(), and destroy().

method popLine

popLine: (i: number) => string;

Pop a line off the bottom of the content.

method pushLine

pushLine: (lines: string | string[]) => void;

Push a line onto the bottom of the content.

method removeHover

removeHover: () => void;

Remove the hover label completely.

method removeLabel

removeLabel: () => any;

Remove the label completely.

method removeScreenEvent

removeScreenEvent: (type: string, handler: (...args: any[]) => void) => void;

Same asel.removeListener('screen', ...) except this will automatically keep track of which listeners are bound to the screen object. For use with onScreenEvent(), free(), and destroy().

method render

render: () => Coords;

Write content and children to the screen buffer.

method screenshot

screenshot: {
    (xi: number, xl: number, yi: number, yl: number): string;
    (): void;
};

Take an SGR screenshot of the screen within the region. Returns a string containing only characters and SGR codes. Can be displayed by simply echoing it in a terminal.

method setBack

setBack: () => void;

Put the element in back of its siblings.

method setBaseLine

setBaseLine: (i: number, line: string | string[]) => void;

Set a line in the box's content from the visible top.

method setContent

setContent: (text: string) => void;

Set the content. Note: When text is input, it will be stripped of all non-SGR escape codes, tabs will be replaced with 8 spaces, and tags will be replaced with SGR codes (if enabled).

method setFront

setFront: () => void;

Put the element in front of its siblings.

method setHover

setHover: (arg: string | LabelOptions) => void;

text/options - Set a hover text box to follow the cursor. Similar to the "title" DOM attribute in the browser. Example options: {text:'foo'}

method setIndex

setIndex: (z: number) => void;

Set the z-index of the element (changes rendering order).

method setLabel

setLabel: (arg: string | LabelOptions) => void;

text/options - Set the label text for the top-left corner. Example options: {text:'foo',side:'left'}

method setLine

setLine: (i: number, line: string | string[]) => void;

Set a line in the box's content.

method setText

setText: (text: string) => void;

Similar to setContent, but ignore tags and remove escape codes.

method shiftLine

shiftLine: (i: number) => void;

Shift a line off the top of the content.

method show

show: () => void;

Show element.

method strWidth

strWidth: (text: string) => string;

Get a string's displayed width, taking into account double-width, surrogate pairs, combining characters, tags, and SGR escape codes.

method toggle

toggle: () => void;

Toggle hidden/shown.

method unshiftLine

unshiftLine: (lines: string | string[]) => void;

Unshift a line onto the top of the content.

class BoxElement

class BoxElement extends ScrollableTextElement implements IHasOptions<BoxOptions> {}

A box element which draws a simple box containing content or other elements.

constructor

constructor(opts: BoxOptions);

property options

options: BoxOptions;

Original options object.

class ButtonElement

class ButtonElement extends InputElement implements IHasOptions<ButtonOptions> {}

constructor

constructor(opts: ButtonOptions);

property options

options: ButtonOptions;

Original options object.

method on

on: {
    (event: string, listener: (...args: any[]) => void): this;
    (event: 'press', callback: () => void): this;
};

method press

press: () => void;

Press button. Emits press.

class CheckboxElement

class CheckboxElement extends InputElement implements IHasOptions<CheckboxOptions> {}

A checkbox which can be used in a form element.

constructor

constructor(options?: CheckboxOptions);

property checked

checked: boolean;

whether the element is checked or not.

property options

options: CheckboxOptions;

Original options object.

property text

text: string;

the text next to the checkbox (do not use setcontent, use check.text = '').

property value

value: boolean;

same as checked.

method check

check: () => void;

check the element.

method toggle

toggle: () => void;

toggle checked state.

method uncheck

uncheck: () => void;

uncheck the element.

class FileManagerElement

class FileManagerElement
    extends ListElement
    implements IHasOptions<FileManagerOptions> {}

constructor

constructor(opts: FileManagerOptions);

property cwd

cwd: string;

Current working directory.

property options

options: FileManagerOptions;

Original options object.

method on

on: {
    (event: string, listener: (...args: any[]) => void): this;
    (event: 'cd', callback: (file: string, cwd: string) => void): this;
    (event: 'file', callback: (file: string) => void): this;
    (event: 'error', callback: (err: any, file: string) => void): this;
    (event: 'refresh', callback: () => void): this;
};

Received when an item is selected.

method pick

pick: {
    (cwd: string, callback: () => void): void;
    (callback: () => void): void;
};

Pick a single file and return the path in the callback.

method refresh

refresh: {
    (cwd: string, callback: () => void): void;
    (callback?: () => void): void;
};

Refresh the file list (perform a readdir on cwd and update the list items).

method reset

reset: {
    (cwd: string, callback: () => void): void;
    (callback?: () => void): void;
};

Reset back to original cwd.

class FormElement

class FormElement<TFormData>
    extends BoxElement
    implements IHasOptions<FormOptions> {}

constructor

constructor(opts: FormOptions);

property options

options: FormOptions;

Original options object.

property submission

submission: {};

Last submitted data.

method cancel

cancel: () => void;

Discard the form.

method focusNext

focusNext: () => void;

Focus next form element.

method focusPrevious

focusPrevious: () => void;

Focus previous form element.

method on

on: {
    (event: string, listener: (...args: any[]) => void): this;
    (event: 'submit', callback: (out: TFormData) => void): this;
    (event: 'cancel' | 'reset', callback: () => void): this;
};

Form is submitted. Receives a data object.

method reset

reset: () => void;

Clear the form.

method submit

submit: () => void;

Submit the form.

class ImageElement

class ImageElement extends BoxElement implements IHasOptions<ImageOptions> {}

Display an image in the terminal (jpeg, png, gif) using w3mimgdisplay. Requires w3m to be installed. X11 required: works in xterm, urxvt, and possibly other terminals.

constructor

constructor(options?: ImageOptions);

property options

options: ImageOptions;

class InputElement

abstract class InputElement extends BoxElement {}

constructor

constructor(opts: InputOptions);

class LayoutElement

class LayoutElement extends BlessedElement implements IHasOptions<LayoutOptions> {}

constructor

constructor(options?: LayoutOptions);

property options

options: LayoutOptions;

method getLast

getLast: (i: number) => BlessedElement;

Get the last rendered and visible child element based on an index. This is useful for basing the position of the current child element on the position of the last child element.

method getLastCoords

getLastCoords: (i: number) => PositionCoords;

Get the last rendered and visible child element coords based on an index. This is useful for basing the position of the current child element on the position of the last child element. See the example below.

method isRendered

isRendered: (el: BlessedElement) => boolean;

Check to see if a previous child element has been rendered and is visible on screen. This is only useful for checking child elements that have already been attempted to be rendered! see the example below.

method renderer

renderer: (coords: PositionCoords) => void;

A callback which is called right before the children are iterated over to be rendered. Should return an iterator callback which is called on each child element: iterator(el, i).

class LineElement

class LineElement extends BoxElement implements IHasOptions<LineOptions> {}

A simple line which can be line or bg styled.

constructor

constructor(opts: LineOptions);

property options

options: LineOptions;

Original options object.

class ListbarElement

class ListbarElement extends BoxElement implements IHasOptions<ListbarOptions> {}

constructor

constructor(opts: ListbarOptions);

property options

options: ListbarOptions;

Original options object.

method add

add: (item: Types.ListbarCommand, callback: () => void) => void;

Append an item to the bar.

method addItem

addItem: (item: Types.ListbarCommand, callback: () => void) => void;

Append an item to the bar.

method appendItem

appendItem: (item: Types.ListbarCommand, callback: () => void) => void;

Append an item to the bar.

method move

move: (offset: number) => void;

Move relatively across the bar.

method moveLeft

moveLeft: (offset: number) => void;

Move left relatively across the bar.

method moveRight

moveRight: (offset: number) => void;

Move right relatively across the bar.

method on

on: {
    (event: string, listener: (...args: any[]) => void): this;
    (
        event: 'remove item' | 'set items' | 'select tab',
        callback: () => void
    ): this;
};

method removeItem

removeItem: (child: BlessedElement) => void;

Remove item from the bar.

method select

select: (offset: number) => void;

Select an item on the bar.

method selectTab

selectTab: (index: number) => void;

Select button and execute its callback.

method setItems

setItems: (commands: Types.ListbarCommand[]) => void;

Set commands (see commands option above).

class ListElement

class ListElement
    extends BoxElement
    implements IHasOptions<ListOptions<ListElementStyle>> {}

constructor

constructor(opts: ListOptions<ListElementStyle>);

property options

options: ListOptions<ListElementStyle>;

Original options object.

method add

add: (text: string) => void;

Add an item based on a string.

method addItem

addItem: (text: string) => void;

Add an item based on a string.

method clearItems

clearItems: () => void;

Clears all items from the list.

method down

down: (amount: number) => void;

Select item below selected.

method fuzzyFind

fuzzyFind: (arg: string | RegExp | (() => void)) => void;

Find an item based on its text content.

method getItem

getItem: (child: BlessedElement | number | string) => BlessedElement;

Returns the item element. Child can be an element, index, or string.

method getItemIndex

getItemIndex: (child: BlessedElement | number | string) => number;

Returns the item index from the list. Child can be an element, index, or string.

method insertItem

insertItem: (i: number, child: BlessedElement | number | string) => void;

Inserts an item to the list. Child can be an element, index, or string.

method move

move: (offset: number) => void;

Select item based on current offset.

method on

on: {
    (event: string, listener: (...args: any[]) => void): this;
    (event: 'select', callback: (item: BoxElement, index: number) => void): this;
    (event: ListElementEventType, callback: () => void): this;
    (
        event: 'select item',
        callback: (item: BlessedElement, index: number) => void
    ): this;
};

Received when an item is selected.

method pick

pick: (callback: () => void) => void;

Show/focus list and pick an item. The callback is executed with the result.

method popItem

popItem: () => BlessedElement;

Pop an item off the list.

method pushItem

pushItem: (child: BlessedElement) => number;

Push an item onto the list.

method removeItem

removeItem: (child: BlessedElement | number | string) => BlessedElement;

Removes an item from the list. Child can be an element, index, or string.

method select

select: (index: number) => void;

Select an index of an item.

method setItem

setItem: (child: BlessedElement, content: BlessedElement | string) => void;

Set item to content.

method setItems

setItems: (items: BlessedElement[] | string[]) => void;

Sets the list items to multiple strings.

method shiftItem

shiftItem: () => BlessedElement;

Shift an item off the list.

method spliceItem

spliceItem: (i: number, n: number, ...items: BlessedElement[]) => void;

Remove and insert items to the list.

method unshiftItem

unshiftItem: (child: BlessedElement) => number;

Unshift an item onto the list.

method up

up: (amount: number) => void;

Select item above selected.

class ListTableElement

class ListTableElement
    extends ListElement
    implements IHasOptions<ListTableOptions> {}

constructor

constructor(opts: ListTableOptions);

property options

options: ListTableOptions;

Original options object.

method setData

setData: (rows: string[][]) => void;

Set rows in table. Array of arrays of strings.
Example 1
table.setData([ [ 'Animals', 'Foods' ], [ 'Elephant', 'Apple' ], [ 'Bird', 'Orange' ] ]);

method setRows

setRows: (rows: string[][]) => void;

Set rows in table. Array of arrays of strings.
Example 1
table.setData([ [ 'Animals', 'Foods' ], [ 'Elephant', 'Apple' ], [ 'Bird', 'Orange' ] ]);

class LoadingElement

class LoadingElement extends BoxElement implements IHasOptions<LoadingOptions> {}

A box with a spinning line to denote loading (automatically hidden).

constructor

constructor(opts: LoadingOptions);

property options

options: LoadingOptions;

method load

load: (text: string) => void;

Display the loading box with a message. Will lock keys until stop is called.

method stop

stop: () => void;

Hide loading box. Unlock keys.

class Log

class Log extends ScrollableTextElement implements IHasOptions<LogOptions> {}

A log permanently scrolled to the bottom.

constructor

constructor(options?: LogOptions);

property options

options: LogOptions;

property scrollback

scrollback: number;

amount of scrollback allowed. default: Infinity.

property scrollOnInput

scrollOnInput: boolean;

scroll to bottom on input even if the user has scrolled up. default: false.

method add

add: (text: string) => void;

add a log line.

method log

log: (text: string) => void;

add a log line.

class MessageElement

class MessageElement extends BoxElement implements IHasOptions<MessageOptions> {}

A box containing a message to be displayed (automatically hidden).

constructor

constructor(opts: MessageOptions);

property options

options: MessageOptions;

method display

display: {
    (text: string, time: number, callback: (err: any) => void): void;
    (text: string, callback: (err: any) => void): void;
};

method error

error: {
    (text: string, time: number, callback: () => void): void;
    (text: string, callback: () => void): void;
};

Display an error in the same way.

method log

log: {
    (text: string, time: number, callback: (err: any) => void): void;
    (text: string, callback: (err: any) => void): void;
};

Display a message for a time (default is 3 seconds). Set time to 0 for a perpetual message that is dismissed on keypress.

class Node

abstract class Node
    extends EventEmitter
    implements IHasOptions<INodeOptions>, IDestroyable {}

constructor

constructor(options: INodeOptions);

property $

$: { [index: string]: any };

An object for any miscellanous user data.

property children

children: Node[];

Array of node's children.

property data

data: { [index: string]: any };

An object for any miscellanous user data.

property focusable

focusable: boolean;

property index

index: number;

Render index (document order index) of the last render call.

property options

options: INodeOptions;

Original options object.

property parent

parent: Node;

Parent node.

property screen

screen: Screen;

Parent screen.

property type

type: string;

Type of the node (e.g. box).

method append

append: (node: Node) => void;

Append a node to this node's children.

method collectAncestors

collectAncestors: (s: any) => void;

method collectDescendants

collectDescendants: (s: any) => void;

method destroy

destroy: () => void;

method detach

detach: () => void;

Remove node from its parent.

method emitAncestors

emitAncestors: () => void;

method emitDescendants

emitDescendants: (type?: string, ...args: any[]) => void;

Emit event for element, and recursively emit same event for all descendants.

method forAncestors

forAncestors: (iter: (node: Node) => void, s: any) => void;

method forDescendants

forDescendants: (iter: (node: Node) => void, s: any) => void;

method free

free: () => void;

method get

get: <T>(name: string, def: T) => T;

Get user property with a potential default value.

method hasAncestor

hasAncestor: (target: Node) => boolean;

method hasDescendant

hasDescendant: (target: Node) => void;

method insert

insert: (node: Node, index: number) => void;

Insert a node to this node's children at index i.

method insertAfter

insertAfter: (node: Node, refNode: Node) => void;

Insert a node from node after the reference node.

method insertBefore

insertBefore: (node: Node, refNode: Node) => void;

Insert a node to this node's children before the reference node.

method on

on: {
    (event: string, listener: (...args: any[]) => void): this;
    (event: NodeEventType, callback: (arg: Node) => void): this;
};

method prepend

prepend: (node: Node) => void;

Prepend a node to this node's children.

method remove

remove: (node: Node) => void;

Remove child node from node.

method set

set: (name: string, value: any) => void;

Set user property to value.

class NodeWithEvents

class NodeWithEvents extends Node {}

method key

key: (
    name: string | string[],
    listener: (ch: any, key: Events.IKeyEventArg) => void
) => void;

Bind a keypress listener for a specific key.

method on

on: {
    (event: string, listener: (ch: any, key: Events.IKeyEventArg) => void): this;
    (
        event: NodeMouseEventType,
        callback: (arg: Events.IMouseEventArg) => void
    ): this;
    (
        event: 'keypress',
        callback: (ch: string, key: Events.IKeyEventArg) => void
    ): this;
    (event: NodeScreenEventType, callback: (arg: Screen) => void): this;
    (event: 'warning', callback: (text: string) => void): this;
    (event: NodeGenericEventType, callback: () => void): this;
};

Received on mouse events.
Received on key events.
Received when blessed notices something untoward (output is not a tty, terminfo not found, etc).

method onceKey

onceKey: (
    name: string,
    listener: (ch: any, key: Events.IKeyEventArg) => void
) => void;

Bind a keypress listener for a specific key once.

method removeKey

removeKey: (
    name: string,
    listener: (ch: any, key: Events.IKeyEventArg) => void
) => void;

method unkey

unkey: (
    name: string,
    listener: (ch: any, key: Events.IKeyEventArg) => void
) => void;

Remove a keypress listener for a specific key.

class OverlayImageElement

class OverlayImageElement
    extends BoxElement
    implements IHasOptions<OverlayImageOptions> {}

Convert any .png file (or .gif, see below) to an ANSI image and display it as an element.

constructor

constructor(options?: OverlayImageOptions);

property options

options: OverlayImageOptions;

method clearImage

clearImage: (callback: () => void) => void;

clear the current image.

method getPixelRatio

getPixelRatio: (callback: () => void) => void;

get the pixel to cell ratio for the terminal.

method imageSize

imageSize: (img: string, callback: () => void) => void;

get the size of an image file in pixels.

method setImage

setImage: (img: string, callback: () => void) => void;

set the image in the box to a new path.

method termSize

termSize: (callback: () => void) => void;

get the size of the terminal in pixels.

class PositionCoords

class PositionCoords {}

property xi

xi: number;

property xl

xl: number;

property yi

yi: number;

property yl

yl: number;

class Program

class Program {}

method text

text: (text: string, attr: string) => string;

Wrap the given text in terminal formatting codes corresponding to the given attribute name. The attr string can be of the form red fg or 52 bg where 52 is a 0-255 integer color number.

class ProgressBarElement

class ProgressBarElement
    extends InputElement
    implements IHasOptions<ProgressBarOptions> {}

A progress bar allowing various styles. This can also be used as a form input.

constructor

constructor(options?: ProgressBarOptions);

property options

options: ProgressBarOptions;

method on

on: {
    (event: string, listener: (...args: any[]) => void): this;
    (event: 'reset' | 'complete', callback: () => void): this;
};

method progress

progress: (amount: number) => void;

progress the bar by a fill amount.

method reset

reset: () => void;

reset the bar.

method setProgress

setProgress: (amount: number) => void;

set progress to specific amount.

class PromptElement

class PromptElement extends BoxElement implements IHasOptions<PromptOptions> {}

A prompt box containing a text input, okay, and cancel buttons (automatically hidden).

constructor

constructor(opts: PromptOptions);

property options

options: PromptOptions;

method input

input: (
    text: string,
    value: string,
    callback: (err: any, value: string) => void
) => void;

Show the prompt and wait for the result of the textbox. Set text and initial value.

method readInput

readInput: (
    text: string,
    value: string,
    callback: (err: any, value: string) => void
) => void;

method setInput

setInput: (
    text: string,
    value: string,
    callback: (err: any, value: string) => void
) => void;

class QuestionElement

class QuestionElement extends BoxElement implements IHasOptions<QuestionOptions> {}

A question box containing okay and cancel buttons (automatically hidden).

constructor

constructor(opts: QuestionOptions);

property options

options: QuestionOptions;

method ask

ask: (question: string, callback: (err: any, value: string) => void) => void;

Ask a question. callback will yield the result.

class RadioButtonElement

abstract class RadioButtonElement extends CheckboxElement {}

A radio button which can be used in a form element.

constructor

constructor(opts: RadioButtonOptions);

class RadioSetElement

abstract class RadioSetElement extends BoxElement {}

An element wrapping RadioButtons. RadioButtons within this element will be mutually exclusive with each other.

constructor

constructor(opts: RadioSetOptions);

class Screen

class Screen extends NodeWithEvents implements IHasOptions<IScreenOptions> {}

constructor

constructor(opts: IScreenOptions);

property abottom

abottom: Types.TPosition;

Absolute bottom offset, always zero.

property aleft

aleft: Types.TTopLeft;

Absolute left offset, always zero.

property aright

aright: Types.TPosition;

Absolute right offset, always zero.

property atop

atop: Types.TTopLeft;

Absolute top offset, always zero.

property autoPadding

autoPadding: boolean;

Automatically position child elements with border and padding in mind (NOTE: this is a recommended option. It may become default in the future).

property bottom

bottom: Types.TPosition;

Relative bottom offset, always zero.

property clickable

clickable: BlessedElement[];

Array of Element instances that may receive click/mouse events.

property cols

cols: number;

Same as screen.width.

property cursor

cursor: Types.TCursor;

property dockBorders

dockBorders: boolean;

Automatically "dock" borders with other elements instead of overlapping, depending on position (experimental). For example: These border-overlapped elements:

property dump

dump: string;

Dump all output and input to desired file. Can be used together with log option if set as a boolean.

property fastCSR

fastCSR: boolean;

Do CSR on any element within 20 cols of the screen edge on either side. Faster than smartCSR, but may cause flickering depending on what is on each side of the element.

property focused

focused: BlessedElement;

Top of the focus history stack.

property forceUnicode

forceUnicode: boolean;

Force blessed to use unicode even if it is not detected via terminfo, env variables, or windows code page. If value is true unicode is forced. If value is false non-unicode is forced (default: null).

property fullUnicode

fullUnicode: boolean;

Allow for rendering of East Asian double-width characters, utf-16 surrogate pairs, and unicode combining characters. This allows you to display text above the basic multilingual plane. This is behind an option because it may affect performance slightly negatively. Without this option enabled, all double-width, surrogate pair, and combining characters will be replaced by '??', '?', '' respectively. (NOTE: iTerm2 cannot display combining characters properly. Blessed simply removes them from an element's content if iTerm2 is detected).

property grabKeys

grabKeys: boolean;

Whether the focused element grabs all keypresses.

property height

height: Types.TPosition;

Height of the screen (same as program.rows).

property hover

hover: BlessedElement;

The currently hovered element. Only set if mouse events are bound.

property ignoreDockContrast

ignoreDockContrast: boolean;

Normally, dockable borders will not dock if the colors or attributes are different. This option will allow them to dock regardless. It may produce some odd looking multi-colored borders though.

property ignoreLocked

ignoreLocked: boolean;

Array of keys in their full format (e.g. C-c) to ignore when keys are locked or grabbed. Useful for creating a key that will always exit no matter whether the keys are locked.

property input

input: Writable;

Input and output streams. process.stdin/process.stdout by default, however, it could be a net.Socket if you want to make a program that runs over telnet or something of that nature.

property keyable

keyable: BlessedElement[];

Array of Element instances that may receive key events.

property left

left: Types.TTopLeft;

Relative left offset, always zero.

property lockKeys

lockKeys: boolean;

Prevent keypresses from being received by any element.

property options

options: IScreenOptions;

Original options object.

property output

output: Readable;

Input and output streams. process.stdin/process.stdout by default, however, it could be a net.Socket if you want to make a program that runs over telnet or something of that nature.

property program

program: BlessedProgram;

The blessed Program to be associated with. Will be automatically instantiated if none is provided.

property resizeTimeout

resizeTimeout: number;

Amount of time (in ms) to redraw the screen after the terminal is resized (Default: 300).

property right

right: Types.TPosition;

Relative right offset, always zero.

property rows

rows: number;

Same as screen.height.

property sendFocus

sendFocus: boolean;

Send focus events after mouse is enabled.

property smartCSR

smartCSR: boolean;

Attempt to perform CSR optimization on all possible elements (not just full-width ones, elements with uniform cells to their sides). This is known to cause flickering with elements that are not full-width, however, it is more optimal for terminal rendering.

property tabSize

tabSize: number;

The width of tabs within an element's content.

property terminal

terminal: string;

Set or get terminal name. Set calls screen.setTerminal() internally.

property title

title: string;

Set or get window title.

property top

top: Types.TTopLeft;

Relative top offset, always zero.

property tput

tput: Tput;

The blessed Tput object (only available if you passed tput: true to the Program constructor.)

property useBCE

useBCE: boolean;

Attempt to perform back_color_erase optimizations for terminals that support it. It will also work with terminals that don't support it, but only on lines with the default background color. As it stands with the current implementation, it's uncertain how much terminal performance this adds at the cost of overhead within node.

property warnings

warnings: boolean;

Display warnings (such as the output not being a TTY, similar to ncurses).

property width

width: Types.TPosition;

Width of the screen (same as program.cols).

method alloc

alloc: () => void;

Allocate a new pending screen buffer and a new output screen buffer.

method cleanSides

cleanSides: (el: Widgets.BlessedElement) => boolean;

Parse the sides of an element to determine whether an element has uniform cells on both sides. If it does, we can use CSR to optimize scrolling on a scrollable element.

method clearRegion

clearRegion: (x1: number, x2: number, y1: number, y2: number) => void;

Clear any region on the screen.

method copyToClipboard

copyToClipboard: (text: string) => void;

Attempt to copy text to clipboard using iTerm2's proprietary sequence. Returns true if successful.

method cursorColor

cursorColor: (color: string) => void;

Attempt to change cursor color. Returns true if successful.

method cursorReset

cursorReset: () => void;

Attempt to reset cursor. Returns true if successful.

method cursorShape

cursorShape: (shape: boolean, blink: boolean) => any;

Attempt to change cursor shape. Will not work in all terminals (see artificial cursors for a solution to this). Returns true if successful.

method debug

debug: (...msg: string[]) => void;

Same as the log method, but only gets called if the debug option was set.

method deleteBottom

deleteBottom: (top: number, bottom: number) => void;

Delete a line at the bottom of the screen.

method deleteLine

deleteLine: (n: number, y: number, top: number, bottom: number) => void;

Delete a line from the screen (using csr: this bypasses the output buffer).

method deleteTop

deleteTop: (top: number, bottom: number) => void;

Delete a line at the top of the screen.

method destroy

destroy: () => void;

Destroy the screen object and remove it from the global list. Also remove all global events relevant to the screen object. If all screen objects are destroyed, the node process is essentially reset to its initial state.

method draw

draw: (start: number, end: number) => void;

Draw the screen based on the contents of the screen buffer.

method enableInput

enableInput: (el?: BlessedElement) => void;

Enable key and mouse events. Calls bot enableMouse and enableKeys.

method enableKeys

enableKeys: (el?: BlessedElement) => void;

Enable keypress events for the screen and optionally an element (automatically called when a form of on('keypress') is bound).

method enableMouse

enableMouse: (el?: BlessedElement) => void;

Enable mouse events for the screen and optionally an element (automatically called when a form of on('mouse') is bound).

method exec

exec: (
    file: string,
    args: string[],
    options: NodeChildProcessExecOptions,
    callback: (...args: any[]) => void
) => child_process.ChildProcess;

Spawn a process in the foreground, return to blessed app after exit. Executes callback on error or exit.

method fillRegion

fillRegion: (
    attr: string,
    ch: string,
    x1: number,
    x2: number,
    y1: number,
    y2: number
) => void;

Fill any region with a character of a certain attribute.

method focusNext

focusNext: () => void;

Focus next element in the index.

method focusOffset

focusOffset: (offset: number) => void;

Focus element by offset of focusable elements.

method focusPop

focusPop: () => BlessedElement;

Pop element off the focus stack.

method focusPrevious

focusPrevious: () => void;

Focus previous element in the index.

method focusPush

focusPush: (element: BlessedElement) => void;

Push element on the focus stack (equivalent to screen.focused = el).

method insertBottom

insertBottom: (top: number, bottom: number) => void;

Insert a line at the bottom of the screen.

method insertLine

insertLine: (n: number, y: number, top: number, bottom: number) => void;

Insert a line into the screen (using csr: this bypasses the output buffer).

method insertTop

insertTop: (top: number, bottom: number) => void;

Insert a line at the top of the screen.

method log

log: (...msg: any[]) => void;

Write string to the log file if one was created.

method readEditor

readEditor: {
    (
        options: any,
        callback: (err: NodeJS.ErrnoException, data: Buffer) => void
    ): void;
    (callback: (err: NodeJS.ErrnoException, data: Buffer) => void): void;
};

Read data from text editor.

method realloc

realloc: () => void;

Reallocate the screen buffers and clear the screen.

method render

render: () => void;

Render all child elements, writing all data to the screen buffer and drawing the screen.

method restoreFocus

restoreFocus: () => BlessedElement;

Restore the saved focused element.

method rewindFocus

rewindFocus: () => BlessedElement;

"Rewind" focus to the last visible and attached element.

method saveFocus

saveFocus: () => BlessedElement;

Save the focused element.

method screenshot

screenshot: {
    (xi: number, xl: number, yi: number, yl: number): string;
    (): void;
};

Take an SGR screenshot of the screen within the region. Returns a string containing only characters and SGR codes. Can be displayed by simply echoing it in a terminal.

method setEffects

setEffects: (
    el: BlessedElement,
    fel: BlessedElement,
    over: string,
    out: string,
    effects: any,
    temp: any
) => void;

Set effects based on two events and attributes.

method setTerminal

setTerminal: (term: string) => void;

Reset the terminal to term. Reloads terminfo.

method spawn

spawn: (
    file: string,
    args?: string[],
    options?: NodeChildProcessExecOptions
) => child_process.ChildProcess;

Spawn a process in the foreground, return to blessed app after exit.

class ScrollableBoxElement

class ScrollableBoxElement extends BlessedElement {}

DEPRECATED - Use Box with the scrollable option instead. A box with scrollable content.

property childBase

childBase: number;

The offset of the top of the scroll content.

property childOffset

childOffset: number;

The offset of the chosen item/line.

method getScroll

getScroll: () => number;

Get the current scroll index in lines.

method getScrollHeight

getScrollHeight: () => number;

Get the actual height of the scrolling area.

method getScrollPerc

getScrollPerc: () => number;

Get the current scroll index in percentage.

method on

on: {
    (event: string, listener: (...args: any[]) => void): this;
    (event: 'scroll', callback: () => void): this;
};

Received when the element is scrolled.

method resetScroll

resetScroll: () => void;

Reset the scroll index to its initial state.

method scroll

scroll: (offset: number, always?: boolean) => void;

Scroll the content by a relative offset.

method scrollTo

scrollTo: (index: number) => void;

Scroll the content to an absolute index.

method setScroll

setScroll: (index: number) => void;

Same as scrollTo.

method setScrollPerc

setScrollPerc: (perc: number) => void;

Set the current scroll index in percentage (0-100).

class ScrollableTextElement

class ScrollableTextElement extends ScrollableBoxElement {}

DEPRECATED - Use Box with the scrollable and alwaysScroll options instead. A scrollable text box which can display and scroll text, as well as handle pre-existing newlines and escape codes.

class TableElement

class TableElement extends BoxElement implements IHasOptions<TableOptions> {}

A stylized table of text elements.

constructor

constructor(opts: TableOptions);

property options

options: TableOptions;

method setData

setData: (rows: string[][]) => void;

set rows in table. array of arrays of strings.

method setRows

setRows: (rows: string[][]) => void;

set rows in table. array of arrays of strings.

class TerminalElement

class TerminalElement extends BoxElement implements IHasOptions<TerminalOptions> {}

constructor

constructor(opts: TerminalOptions);

property options

options: TerminalOptions;

property pty

pty: any;

reference to the pty.js pseudo terminal.

property term

term: any;

reference to the headless term.js terminal.

method screenshot

screenshot: (xi?: number, xl?: number, yi?: number, yl?: number) => string;

nearly identical to element.screenshot, however, the specified region includes the terminal's _entire_ scrollback, rather than just what is visible on the screen.

method write

write: (data: string) => void;

write data to the terminal.

class TextareaElement

class TextareaElement extends InputElement implements IHasOptions<TextareaOptions> {}

constructor

constructor(opts: TextareaOptions);

property options

options: TextareaOptions;

Original options object.

property value

value: string;

The input text. read-only.

method cancel

cancel: () => void;

Cancel the textarea (emits cancel).

method clearValue

clearValue: () => void;

Clear input.

method editor

editor: (callback: (err: any, value?: string) => void) => void;

Open text editor in $EDITOR, read the output from the resulting file. Takes a callback which receives the final value.

method getValue

getValue: () => string;

The same as this.value, for now.

method input

input: (callback: (err: any, value?: string) => void) => void;

Grab key events and start reading text from the keyboard. Takes a callback which receives the final value.

method on

on: {
    (event: string, listener: (...args: any[]) => void): this;
    (event: TextareaElementEventType, callback: (err: any) => void): this;
};

method readEditor

readEditor: (callback: (err: any, value?: string) => void) => void;

Open text editor in $EDITOR, read the output from the resulting file. Takes a callback which receives the final value.

method readInput

readInput: (callback?: (err: any, value?: string) => void) => void;

Grab key events and start reading text from the keyboard. Takes a callback which receives the final value.

method setEditor

setEditor: (callback: (err: any, value?: string) => void) => void;

Open text editor in $EDITOR, read the output from the resulting file. Takes a callback which receives the final value.

method setInput

setInput: (callback: (err: any, value?: string) => void) => void;

Grab key events and start reading text from the keyboard. Takes a callback which receives the final value.

method setValue

setValue: (text: string) => void;

Set value.

method submit

submit: () => void;

Submit the textarea (emits submit).

class TextboxElement

class TextboxElement
    extends TextareaElement
    implements IHasOptions<TextboxOptions> {}

constructor

constructor(opts: TextboxOptions);

property censor

censor: boolean;

Replace text with asterisks (*).

property options

options: TextboxOptions;

Original options object.

property secret

secret: boolean;

Completely hide text.

class TextElement

class TextElement extends BlessedElement implements IHasOptions<TextOptions> {}

An element similar to Box, but geared towards rendering simple text elements.

constructor

constructor(opts: TextOptions);

property options

options: TextOptions;

Original options object.

class Tput

class Tput implements IHasOptions<TputsOptions> {}

constructor

constructor(opts: TputsOptions);

property debug

debug: boolean;

property error

error: Error;

property extended

extended: boolean;

property options

options: TputsOptions;

Original options object.

property padding

padding: boolean;

property printf

printf: boolean;

property termcap

termcap: string;

property termcapFile

termcapFile: string;

property terminal

terminal: string;

property terminfoFile

terminfoFile: string;

property terminfoPrefix

terminfoPrefix: string;

method parseTerminfo

parseTerminfo: (
    data: any,
    file: string
) => {
    header: {
        dataSize: number;
        headerSize: number;
        magicNumber: boolean;
        namesSize: number;
        boolCount: number;
        numCount: number;
        strCount: number;
        strTableSize: number;
        extended: {
            dataSize: number;
            headerSize: number;
            boolCount: number;
            numCount: number;
            strCount: number;
            strTableSize: number;
            lastStrTableOffset: number;
        };
    };
    name: string;
    names: string[];
    desc: string;
    bools: any;
    numbers: any;
    strings: any;
};

method readTerminfo

readTerminfo: (term: string) => string;

method setup

setup: () => void;

method term

term: (is: any) => boolean;

class VideoElement

class VideoElement extends BoxElement implements IHasOptions<VideoOptions> {}

constructor

constructor(options?: VideoOptions);

property options

options: VideoOptions;

property tty

tty: any;

The terminal element running mplayer or mpv.

interface ANSIImageOptions

interface ANSIImageOptions extends BoxOptions {}

property animate

animate: boolean;

Whether to animate if the image is an APNG/animating GIF. If false, only display the first frame or IDAT (Default: true).

property ascii

ascii: string;

Add various "density" ASCII characters over the rendering to give the image more detail, similar to libcaca/libcucul (the library mplayer uses to display videos in the terminal).

property file

file: string;

URL or path to PNG/GIF file. Can also be a buffer.

property height

height: number | string;

property optimization

optimization: 'mem' | 'cpu';

mem or cpu. If optimizing for memory, animation frames will be rendered to bitmaps as the animation plays, using less memory. Optimizing for cpu will precompile all bitmaps beforehand, which may be faster, but might also OOM the process on large images. (Default: mem).

property scale

scale: number;

Scale cellmap down (0-1.0) from its original pixel width/height (Default: 1.0).

property speed

speed: number;

Set the speed of animation. Slower: 0.0-1.0. Faster: 1-1000. It cannot go faster than 1 frame per millisecond, so 1000 is the fastest. (Default: 1.0)

property width

width: number | string;

This differs from other element's width or height in that only one of them is needed: blessed will maintain the aspect ratio of the image as it scales down to the proper number of cells. NOTE: PNG/GIF's are always automatically shrunken to size (based on scale) if a width or height is not given.

interface BigTextOptions

interface BigTextOptions extends BoxOptions {}

property fch

fch?: string | undefined;

foreground character. (default: ' ')

property font

font?: string | undefined;

bdf->json font file to use (see ttystudio for instructions on compiling BDFs to JSON).

property fontBold

fontBold?: string | undefined;

bdf->json bold font file to use (see ttystudio for instructions on compiling BDFs to JSON).

interface Border

interface Border {}

property bg

bg?: number | undefined;

Border foreground and background, must be numbers (-1 for default).

property bold

bold?: string | undefined;

Border attributes.

property ch

ch?: string | undefined;

Character to use if bg type, default is space.

property fg

fg?: number | undefined;

property type

type?: 'line' | 'bg' | undefined;

Type of border (line or bg). bg by default.

property underline

underline?: string | undefined;

interface BoxOptions

interface BoxOptions extends ScrollableTextOptions {}

property bindings

bindings?: any;

interface ButtonOptions

interface ButtonOptions extends BoxOptions {}

interface CheckboxOptions

interface CheckboxOptions extends BoxOptions {}

property checked

checked?: boolean | undefined;

whether the element is checked or not.

property mouse

mouse?: boolean | undefined;

enable mouse support.

interface Coords

interface Coords {}

property base

base: number;

property nobot

nobot: Types.TPosition;

property noleft

noleft: Types.TTopLeft;

property noright

noright: Types.TPosition;

property notop

notop: Types.TTopLeft;

property xi

xi: number;

property xl

xl: number;

property yi

yi: number;

property yl

yl: number;

interface ElementOptions

interface ElementOptions extends INodeOptions {}

property align

align?: 'left' | 'center' | 'right' | undefined;

Text alignment: left, center, or right.

property bg

bg?: string | undefined;

property bold

bold?: string | undefined;

property border

border?: Border | 'line' | 'bg' | undefined;

Border object, see below.

property bottom

bottom?: Types.TPosition | undefined;

property ch

ch?: string | undefined;

Background character (default is whitespace ).

property clickable

clickable?: boolean | undefined;

Element is clickable.

property content

content?: string | undefined;

Element's text content.

property draggable

draggable?: boolean | undefined;

Allow the element to be dragged with the mouse.

property fg

fg?: string | undefined;

property focused

focused?: BlessedElement | undefined;

Element is focused.

property height

height?: number | string | undefined;

Offsets of the element relative to its parent. Can be a number, percentage (0-100%), or keyword (center). right and bottom do not accept keywords. Percentages can also have offsets (50%+1, 50%-1).

property hidden

hidden?: boolean | undefined;

Whether the element is hidden.

property hoverText

hoverText?: string | undefined;

A floating text label for the element which appears on mouseover.

property input

input?: boolean | undefined;

Element is focusable and can receive key input.

property keyable

keyable?: boolean | undefined;

property label

label?: string | undefined;

A simple text label for the element.

property left

left?: Types.TTopLeft | undefined;

property padding

padding?: number | Padding | undefined;

Amount of padding on the inside of the element. Can be a number or an object containing the properties: left, right, top, and bottom.

property position

position?: Position | undefined;

Can contain the above options.

property right

right?: Types.TPosition | undefined;

property scrollable

scrollable?: boolean | undefined;

Whether the element is scrollable or not.

property shadow

shadow?: boolean | undefined;

Draw a translucent offset shadow behind the element.

property shrink

shrink?: boolean | undefined;

Shrink/flex/grow to content and child elements. Width/height during render.

property style

style?: any;

property tags

tags?: boolean | undefined;

property top

top?: Types.TTopLeft | undefined;

property underline

underline?: string | undefined;

property valign

valign?: 'top' | 'middle' | 'bottom' | undefined;

Vertical text alignment: top, middle, or bottom.

property width

width?: number | string | undefined;

Width/height of the element, can be a number, percentage (0-100%), or keyword (half or shrink). Percentages can also have offsets (50%+1, 50%-1).

interface FileManagerOptions

interface FileManagerOptions extends ListOptions<ListElementStyle> {}

property cwd

cwd?: string | undefined;

Current working directory.

interface FormOptions

interface FormOptions extends BoxOptions {}

property keys

keys?: any;

Allow default keys (tab, vi keys, enter).

property vi

vi?: boolean | undefined;

Allow vi keys.

interface IDestroyable

interface IDestroyable {}

method destroy

destroy: { (): void; (): void };

interface IDestroyable

interface IDestroyable {}

method destroy

destroy: { (): void; (): void };

interface IHasOptions

interface IHasOptions<T extends IOptions> {}

property options

options: T;

interface ImageOptions

interface ImageOptions extends BoxOptions {}

property file

file: string;

path to image.

property type

type: 'ansi' | 'overlay' | 'w3m';

path to w3mimgdisplay. if a proper w3mimgdisplay path is not given, blessed will search the entire disk for the binary.

interface INodeOptions

interface INodeOptions extends IOptions {}

property children

children?: Node[] | undefined;

property focusable

focusable?: boolean | undefined;

property name

name?: string | undefined;

property parent

parent?: Node | undefined;

property screen

screen?: Screen | undefined;

interface InputOptions

interface InputOptions extends BoxOptions {}

interface IOptions

interface IOptions {}

index signature

[name: string]: any;

interface IScreenOptions

interface IScreenOptions extends INodeOptions {}

property abottom

abottom?: Types.TPosition | undefined;

Absolute bottom offset, always zero.

property aleft

aleft?: Types.TTopLeft | undefined;

Absolute left offset, always zero.

property aright

aright?: Types.TPosition | undefined;

Absolute right offset, always zero.

property atop

atop?: Types.TTopLeft | undefined;

Absolute top offset, always zero.

property autoPadding

autoPadding?: boolean | undefined;

Automatically position child elements with border and padding in mind (NOTE: this is a recommended option. It may become default in the future).

property bottom

bottom?: Types.TPosition | undefined;

Relative bottom offset, always zero.

property cols

cols?: number | undefined;

Same as screen.width.

property cursor

cursor?: Types.TCursor | undefined;

property debug

debug?: boolean | undefined;

Debug mode. Enables usage of the debug method. Also creates a debug console which will display when pressing F12. It will display all log and debug messages.

property dockBorders

dockBorders?: boolean | undefined;

Automatically "dock" borders with other elements instead of overlapping, depending on position (experimental). For example: These border-overlapped elements:

property dump

dump?: string | boolean | undefined;

Dump all output and input to desired file. Can be used together with log option if set as a boolean.

property fastCSR

fastCSR?: boolean | undefined;

Do CSR on any element within 20 cols of the screen edge on either side. Faster than smartCSR, but may cause flickering depending on what is on each side of the element.

property focused

focused?: BlessedElement | undefined;

Top of the focus history stack.

property forceUnicode

forceUnicode?: boolean | undefined;

Force blessed to use unicode even if it is not detected via terminfo, env variables, or windows code page. If value is true unicode is forced. If value is false non-unicode is forced (default: null).

property fullUnicode

fullUnicode?: boolean | undefined;

Allow for rendering of East Asian double-width characters, utf-16 surrogate pairs, and unicode combining characters. This allows you to display text above the basic multilingual plane. This is behind an option because it may affect performance slightly negatively. Without this option enabled, all double-width, surrogate pair, and combining characters will be replaced by '??', '?', '' respectively. (NOTE: iTerm2 cannot display combining characters properly. Blessed simply removes them from an element's content if iTerm2 is detected).

property grabKeys

grabKeys?: boolean | undefined;

Whether the focused element grabs all keypresses.

property height

height?: Types.TPosition | undefined;

Height of the screen (same as program.rows).

property hover

hover?: any;

The currently hovered element. Only set if mouse events are bound.

property ignoreDockContrast

ignoreDockContrast?: boolean | undefined;

Normally, dockable borders will not dock if the colors or attributes are different. This option will allow them to dock regardless. It may produce some odd looking multi-colored borders though.

property ignoreLocked

ignoreLocked?: string[] | undefined;

Array of keys in their full format (e.g. C-c) to ignore when keys are locked or grabbed. Useful for creating a key that will always exit no matter whether the keys are locked.

property input

input?: Writable | undefined;

Input and output streams. process.stdin/process.stdout by default, however, it could be a net.Socket if you want to make a program that runs over telnet or something of that nature.

property left

left?: Types.TTopLeft | undefined;

Relative left offset, always zero.

property lockKeys

lockKeys?: boolean | undefined;

Prevent keypresses from being received by any element.

property log

log?: string | undefined;

Create a log file. See log method.

property output

output?: Readable | undefined;

Input and output streams. process.stdin/process.stdout by default, however, it could be a net.Socket if you want to make a program that runs over telnet or something of that nature.

property program

program?: BlessedProgram | undefined;

The blessed Program to be associated with. Will be automatically instantiated if none is provided.

property resizeTimeout

resizeTimeout?: number | undefined;

Amount of time (in ms) to redraw the screen after the terminal is resized (Default: 300).

property right

right?: Types.TPosition | undefined;

Relative right offset, always zero.

property rows

rows?: number | undefined;

Same as screen.height.

property sendFocus

sendFocus?: boolean | undefined;

Send focus events after mouse is enabled.

property smartCSR

smartCSR?: boolean | undefined;

Attempt to perform CSR optimization on all possible elements (not just full-width ones, elements with uniform cells to their sides). This is known to cause flickering with elements that are not full-width, however, it is more optimal for terminal rendering.

property tabSize

tabSize?: number | undefined;

The width of tabs within an element's content.

property terminal

terminal?: string | undefined;

Set or get terminal name. Set calls screen.setTerminal() internally.

property title

title?: string | undefined;

Set or get window title.

property top

top?: Types.TTopLeft | undefined;

Relative top offset, always zero.

property tput

tput?: Tput | undefined;

The blessed Tput object (only available if you passed tput: true to the Program constructor.)

property useBCE

useBCE?: boolean | undefined;

Attempt to perform back_color_erase optimizations for terminals that support it. It will also work with terminals that don't support it, but only on lines with the default background color. As it stands with the current implementation, it's uncertain how much terminal performance this adds at the cost of overhead within node.

property warnings

warnings?: boolean | undefined;

Display warnings (such as the output not being a TTY, similar to ncurses).

property width

width?: Types.TPosition | undefined;

Width of the screen (same as program.cols).

interface LabelOptions

interface LabelOptions {}

property side

side: Types.TAlign;

property text

text: string;

interface LayoutOptions

interface LayoutOptions extends ElementOptions {}

property layout

layout: 'inline' | 'inline-block' | 'grid';

Using the default renderer, it provides two layouts: inline, and grid. inline is the default and will render akin to inline-block. grid will create an automatic grid based on element dimensions. The grid cells' width and height are always determined by the largest children in the layout.

method renderer

renderer: () => void;

A callback which is called right before the children are iterated over to be rendered. Should return an iterator callback which is called on each child element: iterator(el, i).

interface LineOptions

interface LineOptions extends BoxOptions {}

A simple line which can be line or bg styled.

property bg

bg?: string | undefined;

property ch

ch?: string | undefined;

property fg

fg?: string | undefined;

property orientation

orientation?: 'vertical' | 'horizontal' | undefined;

Can be vertical or horizontal.

property type

type?: string | undefined;

Treated the same as a border object. (attributes can be contained in style).

interface ListbarOptions

interface ListbarOptions extends BoxOptions {}

property autoCommandKeys

autoCommandKeys: boolean;

Automatically bind list buttons to keys 0-9.

property commands

commands: Types.ListbarCommand[];

Set buttons using an object with keys as titles of buttons, containing of objects containing keys of keys and callback.

property items

items: Types.ListbarCommand[];

property style

style?: ListElementStyle | undefined;

interface ListOptions

interface ListOptions<TStyle extends ListElementStyle> extends BoxOptions {}

property interactive

interactive?: boolean | undefined;

Whether the list is interactive and can have items selected (Default: true).

property invertSelected

invertSelected?: boolean | undefined;

Whether to automatically override tags and invert fg of item when selected (Default: true).

property items

items?: string[] | undefined;

An array of strings which become the list's items.

property style

style?: TStyle | undefined;

Style for a selected item. Style for an unselected item.

method search

search: (err: any, value?: string) => void;

A function that is called when vi mode is enabled and the key / is pressed. This function accepts a callback function which should be called with the search string. The search string is then used to jump to an item that is found in items.

interface ListTableOptions

interface ListTableOptions extends ListOptions<StyleListTable> {}

property data

data?: string[][] | undefined;

property noCellBorders

noCellBorders?: boolean | undefined;

Do not draw inner cells.

property pad

pad?: number | undefined;

Spaces to attempt to pad on the sides of each cell. 2 by default: one space on each side (only useful if the width is shrunken).

property rows

rows?: string[] | undefined;

Array of array of strings representing rows.

property style

style?: StyleListTable | undefined;

interface LoadingOptions

interface LoadingOptions extends BoxOptions {}

interface LogOptions

interface LogOptions extends ScrollableTextOptions {}

property scrollback

scrollback?: number | undefined;

amount of scrollback allowed. default: Infinity.

property scrollOnInput

scrollOnInput?: boolean | undefined;

scroll to bottom on input even if the user has scrolled up. default: false.

interface MessageOptions

interface MessageOptions extends BoxOptions {}

interface NodeChildProcessExecOptions

interface NodeChildProcessExecOptions {}

property customFds

customFds?: any;

property cwd

cwd?: string | undefined;

property encoding

encoding?: string | undefined;

property env

env?: any;

property killSignal

killSignal?: string | undefined;

property maxBuffer

maxBuffer?: number | undefined;

property stdio

stdio?: any;

property timeout

timeout?: number | undefined;

interface OverlayImageOptions

interface OverlayImageOptions extends BoxOptions {}

property ansi

ansi: boolean;

Render the file as ANSI art instead of using w3m to overlay Internally uses the ANSIImage element. See the ANSIImage element for more information/options. (Default: true).

property file

file: string;

Path to image.

property search

search: string;

Whether to search /usr, /bin, and /lib for w3mimgdisplay (Default: true).

property w3m

w3m: string;

Path to w3mimgdisplay. If a proper w3mimgdisplay path is not given, blessed will search the entire disk for the binary.

interface Padding

interface Padding {}

property bottom

bottom?: number | undefined;

property left

left?: number | undefined;

property right

right?: number | undefined;

property top

top?: number | undefined;

interface Position

interface Position {}

property bottom

bottom: number | string;

property left

left: number | string;

property right

right: number | string;

property top

top: number | string;

interface ProgressBarOptions

interface ProgressBarOptions extends BoxOptions {}

property filled

filled?: number | undefined;

the amount filled (0 - 100).

property keys

keys?: boolean | undefined;

enable key support.

property mouse

mouse?: boolean | undefined;

enable mouse support.

property orientation

orientation?: string | undefined;

can be horizontal or vertical.

property pch

pch?: string | undefined;

the character to fill the bar with (default is space).

property value

value?: number | undefined;

same as filled.

interface PromptOptions

interface PromptOptions extends BoxOptions {}

interface QuestionOptions

interface QuestionOptions extends BoxOptions {}

interface RadioButtonOptions

interface RadioButtonOptions extends BoxOptions {}

interface RadioSetOptions

interface RadioSetOptions extends BoxOptions {}

interface ScrollableBoxOptions

interface ScrollableBoxOptions extends ElementOptions {}

property alwaysScroll

alwaysScroll?: boolean | undefined;

A option which causes the ignoring of childOffset. This in turn causes the childBase to change every time the element is scrolled.

property baseLimit

baseLimit?: number | undefined;

A limit to the childBase. Default is Infinity.

property scrollbar

scrollbar?: { style?: any; track?: any; ch?: string | undefined } | undefined;

Object enabling a scrollbar. Style of the scrollbar track if present (takes regular style options).

interface ScrollableTextOptions

interface ScrollableTextOptions extends ScrollableBoxOptions {}

property keys

keys?: string | string[] | boolean | undefined;

Use pre-defined keys (i or enter for insert, e for editor, C-e for editor while inserting).

property mouse

mouse?: boolean | (() => void) | undefined;

Whether to enable automatic mouse support for this element. Use pre-defined mouse events (right-click for editor).

property vi

vi?: boolean | undefined;

Use vi keys with the keys option.

interface StyleListTable

interface StyleListTable extends ListElementStyle {}

property cell

cell?: any;

Cell style.

header?: any;

Header style.

interface TableOptions

interface TableOptions extends BoxOptions {}

property data

data?: string[][] | undefined;

array of array of strings representing rows (same as rows).

property fillCellBorders

fillCellBorders?: boolean | undefined;

fill cell borders with the adjacent background color.

property noCellBorders

noCellBorders?: boolean | undefined;

do not draw inner cells.

property pad

pad?: number | undefined;

spaces to attempt to pad on the sides of each cell. 2 by default: one space on each side (only useful if the width is shrunken).

property rows

rows?: string[][] | undefined;

array of array of strings representing rows (same as data).

interface TerminalOptions

interface TerminalOptions extends BoxOptions {}

property args

args?: any;

args for shell.

property cursor

cursor?: 'line' | 'underline' | 'block' | undefined;

can be line, underline, and block.

property env

env?: any;

Object for process env.

property shell

shell?: string | undefined;

name of shell. $SHELL by default.

property terminal

terminal?: string | undefined;

method handler

handler: (userInput: Buffer) => void;

handler for input data.

interface TextareaOptions

interface TextareaOptions extends InputOptions {}

A box which allows multiline text input.

property inputOnFocus

inputOnFocus?: boolean | undefined;

Call readInput() when the element is focused. Automatically unfocus.

interface TextboxOptions

interface TextboxOptions extends TextareaOptions {}

property censor

censor?: boolean | undefined;

Replace text with asterisks (*).

property secret

secret?: boolean | undefined;

Completely hide text.

interface TextOptions

interface TextOptions extends ElementOptions {}

property align

align?: Types.TAlign | undefined;

Text alignment: left, center, or right.

property fill

fill?: boolean | undefined;

Fill the entire line with chosen bg until parent bg ends, even if there is not enough text to fill the entire width.

interface TputsOptions

interface TputsOptions extends IOptions {}

property debug

debug?: boolean | undefined;

property extended

extended?: boolean | undefined;

property termcap

termcap?: string | undefined;

property termcapFile

termcapFile?: string | undefined;

property terminal

terminal?: string | undefined;

property terminfoFile

terminfoFile?: string | undefined;

property terminfoPrefix

terminfoPrefix?: string | undefined;

interface VideoOptions

interface VideoOptions extends BoxOptions {}

property file

file: string;

Video to play.

property start

start: number;

Start time in seconds.

type ListElementEventType

type ListElementEventType =
    /** List was canceled (when esc is pressed with the keys option). */
    | 'cancel'
    /** Either a select or a cancel event was received. */
    | 'action'
    | 'create item'
    | 'add item'
    | 'remove item'
    | 'insert item'
    | 'set items';

type ListElementStyle

type ListElementStyle = {
    selected?: any;
    item?: any;
} & Types.TStyle;

type NodeEventType

type NodeEventType =
    /** Received when node is added to a parent. */
    | 'adopt'
    /** Received when node is removed from it's current parent. */
    | 'remove'
    /** Received when node gains a new parent. */
    | 'reparent'
    /** Received when node is attached to the screen directly or somewhere in its ancestry. */
    | 'attach'
    /** Received when node is detached from the screen directly or somewhere in its ancestry. */
    | 'detach';

type NodeGenericEventType

type NodeGenericEventType =
    /** Received on screen resize. */
    | 'resize'
    /** Received before render. */
    | 'prerender'
    /** Received on render. */
    | 'render'
    /** Received when the screen is destroyed (only useful when using multiple screens). */
    | 'destroy'
    /** Received when the element is moved. */
    | 'move'
    /** Received when element is shown. */
    | 'show'
    /** Received when element becomes hidden. */
    | 'hide'
    | 'set content'
    | 'parsed content';

type NodeMouseEventType

type NodeMouseEventType =
    | 'mouse'
    | 'mouseout'
    | 'mouseover'
    | 'mousedown'
    | 'mouseup'
    | 'mousewheel'
    | 'wheeldown'
    | 'wheelup'
    | 'mousemove';

type NodeScreenEventType

type NodeScreenEventType =
    /**
     * Received when the terminal window focuses/blurs. Requires a terminal supporting the
     * focus protocol and focus needs to be passed to program.enableMouse().
     */
    | 'focus'
    /**
     * Received when the terminal window focuses/blurs. Requires a terminal supporting the
     * focus protocol and focus needs to be passed to program.enableMouse().
     */
    | 'blur'
    /**
     * Element was clicked (slightly smarter than mouseup).
     */
    | 'click'
    | 'element click'
    | 'element mouseover'
    | 'element mouseout'
    | 'element mouseup';

type TextareaElementEventType

type TextareaElementEventType =
    /** Value is an error. */
    | 'error'
    /** Value is submitted (enter). */
    | 'submit'
    /** Value is discared (escape). */
    | 'cancel'
    /** Either submit or cancel. */
    | 'action';

namespace Widgets.Events

namespace Widgets.Events {}

interface IKeyEventArg

interface IKeyEventArg {}

property ctrl

ctrl: boolean;

property full

full: string;

property meta

meta: boolean;

property name

name: string;

property sequence

sequence: string;

property shift

shift: boolean;

interface IMouseEventArg

interface IMouseEventArg {}

property action

action: Types.TMouseAction;

property x

x: number;

property y

y: number;

namespace Widgets.Types

namespace Widgets.Types {}

interface Cursor

interface Cursor {}

property artificial

artificial: boolean;

Have blessed draw a custom cursor and hide the terminal cursor (experimental).

property blink

blink: boolean;

Whether the cursor blinks.

property color

color: string;

Color of the color. Accepts any valid color value (null is default).

property shape

shape: boolean;

Shape of the cursor. Can be: block, underline, or line.

interface Effects

interface Effects {}

property bg

bg?: string;

property border

border?: TStyleBorder | undefined;

property fg

fg?: string;

interface ListbarCommand

interface ListbarCommand {}

property key

key: string;

method callback

callback: () => void;

interface TBorder

interface TBorder {}

property bg

bg?: number | undefined;

Border foreground and background, must be numbers (-1 for default).

property bold

bold?: string | undefined;

Border attributes.

property ch

ch?: string | undefined;

Character to use if bg type, default is space.

property fg

fg?: number | undefined;

property type

type?: 'line' | 'bg' | undefined;

Type of border (line or bg). bg by default.

property underline

underline?: string | undefined;

interface TCursor

interface TCursor {}

property artificial

artificial: boolean;

Have blessed draw a custom cursor and hide the terminal cursor (experimental).

property blink

blink: boolean;

Whether the cursor blinks.

property color

color: string;

Color of the color. Accepts any valid color value (null is default).

property shape

shape: 'block' | 'underline' | 'line';

Shape of the cursor. Can be: block, underline, or line.

interface TImage

interface TImage {}

property bmp

bmp: any;

Image bitmap.

property cellmap

cellmap: any;

Image cellmap (bitmap scaled down to cell size).

property height

height: number;

Pixel height.

property width

width: number;

Pixel width.

interface TStyle

interface TStyle {}

property bg

bg?: string | undefined;

property blink

blink?: boolean | undefined;

property bold

bold?: boolean | undefined;

property border

border?: TStyleBorder;

property ch

ch?: string | undefined;

property fg

fg?: string | undefined;

property focus

focus?: Effects | undefined;

property hover

hover?: Effects | undefined;

property inverse

inverse?: boolean | undefined;

property invisible

invisible?: boolean | undefined;

property label

label?: string | undefined;

property scrollbar

scrollbar?: { bg?: string | undefined; fg?: string | undefined } | undefined;

property track

track?: { bg?: string | undefined; fg?: string | undefined } | undefined;

property transparent

transparent?: boolean | undefined;

property underline

underline?: boolean | undefined;

interface TStyleBorder

interface TStyleBorder {}

property bg

bg?: string | undefined;

property fg

fg?: string | undefined;

type TAlign

type TAlign = 'left' | 'center' | 'right';

type TMouseAction

type TMouseAction = 'mousedown' | 'mouseup' | 'mousemove';

type TPosition

type TPosition = string | number;

type TTopLeft

type TTopLeft = string | number | 'center';

Package Files (1)

index.d.ts

Dependencies (1)

@types/node

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/blessed.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/blessed)

HTML

<a href="https://www.jsdocs.io/package/@types/blessed"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 5 months ago.
Package analyzed in 9804 ms.
Missing or incorrect documentation? Open an issue for this package.