feat: allow breaking line with ENTER as a multiline trigger

Signed-off-by: Snehil Shah <snehilshah.989@gmail.com>

Author: Snehil-Shah

lib/node_modules/@stdlib/repl/lib/multiline_handler.js

@@ -27,6 +27,7 @@ var logger = require( 'debug' );
 var Parser = require( 'acorn' ).Parser;
 var parseLoose = require( 'acorn-loose' ).parse;
 var setNonEnumerableReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
+var copy = require( '@stdlib/array/base/copy' );
 var min = require( '@stdlib/math/base/special/min' );
 var displayPrompt = require( './display_prompt.js' );
 var drain = require( './drain.js' );
@@ -84,10 +85,10 @@ function MultilineHandler( repl, ttyWrite ) {
 	// Cache the length of the input prompt:
 	this._promptLength = repl._inputPrompt.length;
 
-	// Initialize an internal status object for multi-line mode:
+	// Initialize an internal status object for multiline mode:
 	this._multiline = {};
 	this._multiline.active = false;
-	this._multiline.mode = 'incomplete_expression';
+	this._multiline.trigger = false;
 
 	// Initialize a buffer for caching input lines:
 	this._lines = [];
@@ -312,6 +313,74 @@ setNonEnumerableReadOnly( MultilineHandler.prototype, '_resetInput', function re
 	this._lines.length = 0;
 });
 
+/**
+* Updates flags and buffers before to trigger multiline mode.
+*
+* @private
+* @name _triggerMultiline
+* @memberof MultilineHandler.prototype
+* @type {Function}
+* @returns {void}
+*/
+setNonEnumerableReadOnly( MultilineHandler.prototype, '_triggerMultiline', function triggerMultiline() {
+	// Update flag:
+	this._multiline.trigger = true;
+
+	// Save expression after cursor in buffer:
+	readline.clearLine( this._ostream, 1 ); // clear line after cursor
+	this._remainingLine = this._rli.line.substring( this._rli.cursor );
+	this._rli.line = this._rli.line.substring( 0, this._rli.cursor );
+});
+
+/**
+* Checks if the command is incomplete and a multiline input.
+*
+* @private
+* @name _isMultilineInput
+* @memberof MultilineHandler.prototype
+* @type {Function}
+* @param {string} cmd - command
+* @returns {boolean} boolean indicating whether the command is a multiline input
+*/
+setNonEnumerableReadOnly( MultilineHandler.prototype, '_isMultilineInput', function isMultilineInput( cmd ) {
+	var node;
+	var tmp;
+	var ast;
+
+	debug( 'Attempting to detect multi-line input...' );
+	if ( RE_WHITESPACE.test( cmd ) ) {
+		debug( 'Detected multi-line input. Triggering multiline mode...' );
+		return true;
+	}
+	if ( RE_SINGLE_LINE_COMMENT.test( cmd ) || RE_MULTI_LINE_COMMENT.test( cmd ) ) { // eslint-disable-line max-len
+		debug( 'Multi-line input not detected.' );
+		return false;
+	}
+	// Check if the command has valid syntax...
+	tmp = processCommand( cmd );
+	if ( !( tmp instanceof Error ) ) {
+		return false;
+	}
+	if ( hasMultilineError( cmd, AOPTS ) ) {
+		debug( 'Detected multi-line input. Triggering multiline mode...' );
+		return true;
+	}
+	// Still possible that a user is attempting to enter an object literal across multiple lines...
+	ast = parseLoose( cmd, AOPTS );
+
+	// Check for a trailing node which is being interpreted as a block statement, as this could be an object literal...
+	node = ast.body[ ast.body.length-1 ];
+	if ( node.type === 'BlockStatement' && node.end === ast.end ) {
+		tmp = cmd.slice( node.start, node.end );
+		if ( hasMultilineError( tmp, AOPTS ) ) {
+			debug( 'Detected multi-line input. Triggering multiline mode...' );
+			return true;
+		}
+	}
+	debug( 'Multi-line input not detected.' );
+	return false;
+});
+
 /**
 * Updates current input line in buffer.
 *
@@ -336,20 +405,17 @@ setNonEnumerableReadOnly( MultilineHandler.prototype, 'updateLine', function upd
 */
 setNonEnumerableReadOnly( MultilineHandler.prototype, 'processLine', function processLine( line ) {
 	var code;
-	var node;
-	var ast;
 	var cmd;
 	var tmp;
 	var dy;
 
+	// Save line:
 	debug( 'Line: %s', line );
+	this._cmd[ this._lineIndex ] = line;
 
-	// Check for manual newline input...
-	if ( this._multiline.active && this._multiline.mode === 'manual' ) {
-		debug( 'Detected newline input via modifier-key. Waiting for additional lines...' );
-
-		// Update current line:
-		this._cmd[ this._lineIndex ] = line;
+	// Check for multiline triggers...
+	if ( this._multiline.trigger ) {
+		debug( 'Detected multiline trigger input. Waiting for additional lines...' );
 
 		// Insert a newline:
 		this._lineIndex += 1;
@@ -362,18 +428,14 @@ setNonEnumerableReadOnly( MultilineHandler.prototype, 'processLine', function pr
 		readline.cursorTo( this._ostream, 0 );
 		this._rli.line = this._remainingLine;
 
-		// Clear buffer:
+		// Update flags and buffers:
 		this._remainingLine = '';
-		this._multiline.mode = 'incomplete_expression'; // reset flag
+		this._multiline.trigger = false;
+		this._multiline.active = true;
 		return;
 	}
 	this._multiline.active = false; // false until proven otherwise
-	this._cmd[ this._lineIndex ] = line;
 	cmd = this._cmd.join( '\n' );
-	if ( RE_WHITESPACE.test( cmd ) ) {
-		displayPrompt( this._repl, false );
-		return;
-	}
 	if ( RE_SINGLE_LINE_COMMENT.test( cmd ) || RE_MULTI_LINE_COMMENT.test( cmd ) ) { // eslint-disable-line max-len
 		debug( 'Detected single-line comment.' );
 		tmp = cmd;
@@ -382,45 +444,6 @@ setNonEnumerableReadOnly( MultilineHandler.prototype, 'processLine', function pr
 		debug( 'Processing command...' );
 		tmp = processCommand( cmd );
 		if ( tmp instanceof Error ) {
-			debug( 'Unable to process command.' );
-			debug( 'Error: %s', tmp.message );
-			debug( 'Attempting to detect multi-line input...' );
-			if ( hasMultilineError( cmd, AOPTS ) ) {
-				debug( 'Detected multi-line input. Waiting for additional lines...' );
-				this._multiline.active = true;
-
-				// Insert a newline:
-				this._lineIndex += 1;
-				this._cmd.splice( this._lineIndex, 0, '' );
-				this._lines.splice( this._lineIndex, 0, '' );
-
-				// Display next prompt:
-				displayPrompt( this._repl, false );
-				return;
-			}
-			// Still possible that a user is attempting to enter an object literal across multiple lines...
-			ast = parseLoose( cmd, AOPTS );
-
-			// Check for a trailing node which is being interpreted as a block statement, as this could be an object literal...
-			node = ast.body[ ast.body.length-1 ];
-			if ( node.type === 'BlockStatement' && node.end === ast.end ) {
-				tmp = cmd.slice( node.start, node.end );
-				if ( hasMultilineError( tmp, AOPTS ) ) {
-					debug( 'Detected multi-line input. Waiting for additional lines...' );
-					this._multiline.active = true;
-
-					// Insert a newline:
-					this._lineIndex += 1;
-					this._cmd.splice( this._lineIndex, 0, '' );
-					this._lines.splice( this._lineIndex, 0, '' );
-
-					// Display next prompt:
-					displayPrompt( this._repl, false );
-					return;
-				}
-			}
-			debug( 'Multi-line input not detected.' );
-
 			// Move cursor to the output row:
 			dy = this._lines.length - this._lineIndex - 1;
 			readline.moveCursor( this._ostream, 0, dy );
@@ -479,15 +502,8 @@ setNonEnumerableReadOnly( MultilineHandler.prototype, 'onKeypress', function onK
 		return;
 	}
 	// Add manual newline when encountering `CTRL+E` keybinding...
-	if ( key.name === 'e' && key.ctrl ) {
-		// Update flags:
-		this._multiline.active = true;
-		this._multiline.mode = 'manual';
-
-		// Save expression after cursor in buffer:
-		readline.clearLine( this._ostream, 1 ); // clear line after cursor
-		this._remainingLine = this._rli.line.substring( this._rli.cursor );
-		this._rli.line = this._rli.line.substring( 0, this._rli.cursor );
+	if ( key.name === 'o' && key.ctrl ) {
+		this._triggerMultiline();
 
 		// Simulate `line` event:
 		this._rli.write( '\n' );
@@ -509,10 +525,33 @@ setNonEnumerableReadOnly( MultilineHandler.prototype, 'onKeypress', function onK
 * @returns {void}
 */
 setNonEnumerableReadOnly( MultilineHandler.prototype, 'beforeKeypress', function beforeKeypress( data, key ) {
-	if ( !key || !this._multiline.active ) {
+	var cmd;
+
+	if ( !key ) {
+		this._ttyWrite.call( this._rli, data, key );
+		return;
+	}
+	// Check whether to trigger multiline mode or execute the command when `return` key is encountered...
+	if ( key.name === 'return' ) {
+		cmd = copy( this._cmd );
+		cmd[ this._lineIndex ] = this._rli.line;
+
+		// If command is incomplete, trigger multiline mode...
+		if ( !this._isMultilineInput( cmd.join( '\n' ) ) ) {
+			this._ttyWrite.call( this._rli, data, key );
+			return;
+		}
+		this._triggerMultiline();
+
+		// Trigger `line` event:
+		this._ttyWrite.call( this._rli, data, key );
+		return;
+	}
+	if ( !this._multiline.active ) {
 		this._ttyWrite.call( this._rli, data, key );
 		return;
 	}
+	// If multiline mode is active, enable navigation...
 	switch ( key.name ) {
 	case 'up':
 		this._moveUp();