input-shell 1.0.0 → 1.3.0

package/index.js

@@ -3,7 +3,7 @@
  * Package: 
  * Author: Ganesh B
  * Description: 
- * Install: npm i input --save
+ * Install: npm i input-shell --save
  * Github: https://github.com/ganeshkbhat/
  * npmjs Link: https://www.npmjs.com/package/
  * File: index.js
@@ -18,7 +18,7 @@
 
 const readline = require('readline');
 
-function inputSelect(questionText, options, type, callback) {
+function inputSelectAsync(questionText, options, type, callback) {
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
@@ -86,47 +86,161 @@ function inputSelect(questionText, options, type, callback) {
   });
 }
 
+function inputSelect(questionText, options, type) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: true,
+    });
+
+    let selectedIndex = 0;
+    let selectedOptionsArray = [];
+
+    function displayOptions() {
+      console.clear();
+      console.log(questionText);
+      options.forEach((option, index) => {
+        if (type === 'radio') {
+          if (index === selectedIndex) {
+            console.log(`> ${option}`);
+          } else {
+            console.log(`  ${option}`);
+          }
+        } else if (type === 'checkbox') {
+          let selected = selectedOptionsArray.includes(index) ? '[x]' : '[ ]';
+          if (index === selectedIndex) {
+            console.log(`> ${selected} ${option}`);
+          } else {
+            console.log(`  ${selected} ${option}`);
+          }
+        }
+      });
+    }
+
+    displayOptions();
+
+    readline.emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode(true);
+
+    process.stdin.on('keypress', (str, key) => {
+      if (key.name === 'up') {
+        selectedIndex = Math.max(0, selectedIndex - 1);
+        displayOptions();
+      } else if (key.name === 'down') {
+        selectedIndex = Math.min(options.length - 1, selectedIndex + 1);
+        displayOptions();
+      } else if (key.name === 'return') {
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        rl.close();
+        if (type === 'radio') {
+          resolve(options[selectedIndex]);
+        } else if (type === 'checkbox') {
+          const finalSelections = selectedOptionsArray.map((index) => options[index]);
+          resolve(finalSelections);
+        }
+      } else if (key.ctrl && key.name === 'c') {
+        process.exit();
+      } else if (type === 'checkbox' && key.name === 'space') {
+        if (selectedOptionsArray.includes(selectedIndex)) {
+          selectedOptionsArray = selectedOptionsArray.filter(
+            (item) => item !== selectedIndex
+          );
+        } else {
+          selectedOptionsArray.push(selectedIndex);
+        }
+        displayOptions();
+      }
+    });
+  });
+}
 
 function input(text) {
-    console.log(text);
-    return new Promise((resolve, reject) => {
-        let buffer = Buffer.alloc(0); // Initialize an empty buffer
-
-        process.stdin.on('readable', () => {
-            let chunk;
-            while ((chunk = process.stdin.read()) !== null) {
-                // Find the index of the first newline character
-                const newlineIndex = chunk.indexOf('\n');
-
-                if (newlineIndex !== -1) {
-                    // Newline found, extract the line up to the newline
-                    const lineBuffer = Buffer.concat([buffer, chunk.slice(0, newlineIndex)]);
-                    process.stdin.pause(); // Stop reading
-                    resolve(lineBuffer);
-                    return; // Exit the readable event
-                } else {
-                    // No newline, append the chunk to the buffer
-                    buffer = Buffer.concat([buffer, chunk]);
-                }
-            }
-        });
+  console.log(text);
+  return new Promise((resolve, reject) => {
+    let buffer = Buffer.alloc(0); // Initialize an empty buffer
+
+    process.stdin.on('readable', () => {
+      let chunk;
+      while ((chunk = process.stdin.read()) !== null) {
+        // Find the index of the first newline character
+        const newlineIndex = chunk.indexOf('\n');
+
+        if (newlineIndex !== -1) {
+          // Newline found, extract the line up to the newline
+          const lineBuffer = Buffer.concat([buffer, chunk.slice(0, newlineIndex)]);
+          process.stdin.pause(); // Stop reading
+          resolve(lineBuffer);
+          return; // Exit the readable event
+        } else {
+          // No newline, append the chunk to the buffer
+          buffer = Buffer.concat([buffer, chunk]);
+        }
+      }
+    });
 
-        process.stdin.on('end', () => {
-            if (buffer.length > 0) {
-                resolve(buffer);
-            } else {
-                reject("No input received");
-            }
-        });
+    process.stdin.on('end', () => {
+      if (buffer.length > 0) {
+        resolve(buffer);
+      } else {
+        reject("No input received");
+      }
+    });
 
-        process.stdin.on('error', (err) => {
-            reject(err);
-        });
+    process.stdin.on('error', (err) => {
+      reject(err);
     });
+  });
 }
 
+function inputAsync(text, callback) {
+  console.log(text);
+  let buffer = Buffer.alloc(0); // Initialize an empty buffer
+
+  const readableHandler = () => {
+    let chunk;
+    while ((chunk = process.stdin.read()) !== null) {
+      const newlineIndex = chunk.indexOf('\n');
+
+      if (newlineIndex !== -1) {
+        const lineBuffer = Buffer.concat([buffer, chunk.slice(0, newlineIndex)]);
+        process.stdin.pause(); // Stop reading
+        process.stdin.off('readable', readableHandler); // Remove the event listener
+        process.stdin.off('end', endHandler); // Remove the event listener
+        process.stdin.off('error', errorHandler); // Remove the event listener
+        callback(null, lineBuffer);
+        return;
+      } else {
+        buffer = Buffer.concat([buffer, chunk]);
+      }
+    }
+  };
+
+  const endHandler = () => {
+    process.stdin.off('readable', readableHandler); // Remove the event listener
+    process.stdin.off('end', endHandler); // Remove the event listener
+    process.stdin.off('error', errorHandler); // Remove the event listener
+    if (buffer.length > 0) {
+      callback(null, buffer);
+    } else {
+      callback("No input received", null);
+    }
+  };
+
+  const errorHandler = (err) => {
+    process.stdin.off('readable', readableHandler); // Remove the event listener
+    process.stdin.off('end', endHandler); // Remove the event listener
+    process.stdin.off('error', errorHandler); // Remove the event listener
+    callback(err, null);
+  };
+
+  process.stdin.on('readable', readableHandler);
+  process.stdin.on('end', endHandler);
+  process.stdin.on('error', errorHandler);
+}
 
-function inputSelectMultiple(questions, finalCallback) {
+function inputSelectMultipleAsync(questions, finalCallback) {
   let results = [];
   let questionIndex = 0;
 
@@ -235,6 +349,245 @@ function inputSelectMultiple(questions, finalCallback) {
   askQuestion();
 }
 
+// function inputSelectMultiple(questions) {
+//   return new Promise((resolve, reject) => {
+//     let results = [];
+//     let questionIndex = 0;
+
+//     function askQuestion() {
+//       if (questionIndex >= questions.length) {
+//         resolve(results);
+//         return;
+//       }
+
+//       const question = questions[questionIndex];
+//       const { text, type, options } = question;
+
+//       if (type === 'text') {
+//         const rl = readline.createInterface({
+//           input: process.stdin,
+//           output: process.stdout,
+//         });
+
+//         rl.question(`${text} `, (answer) => {
+//           results.push({ text: text, answer: answer });
+//           rl.close();
+//           questionIndex++;
+//           askQuestion();
+//         });
+//       } else if (type === 'radio' || type === 'checkbox') {
+//         const rl = readline.createInterface({
+//           input: process.stdin,
+//           output: process.stdout,
+//           terminal: true,
+//         });
+
+//         let selectedIndex = 0;
+//         let selectedOptionsArray = [];
+
+//         function displayOptions() {
+//           console.clear();
+//           console.log(text);
+//           options.forEach((option, index) => {
+//             if (type === 'radio') {
+//               if (index === selectedIndex) {
+//                 console.log(`> ${option}`);
+//               } else {
+//                 console.log(`  ${option}`);
+//               }
+//             } else if (type === 'checkbox') {
+//               let selected = selectedOptionsArray.includes(index) ? '[x]' : '[ ]';
+//               if (index === selectedIndex) {
+//                 console.log(`> ${selected} ${option}`);
+//               } else {
+//                 console.log(`  ${selected} ${option}`);
+//               }
+//             }
+//           });
+//         }
+
+//         displayOptions();
+
+//         readline.emitKeypressEvents(process.stdin);
+//         process.stdin.setRawMode(true);
+
+//         process.stdin.on('keypress', (str, key) => {
+//           if (key.name === 'up') {
+//             selectedIndex = Math.max(0, selectedIndex - 1);
+//             displayOptions();
+//           } else if (key.name === 'down') {
+//             selectedIndex = Math.min(options.length - 1, selectedIndex + 1);
+//             displayOptions();
+//           } else if (key.name === 'return') {
+//             process.stdin.setRawMode(false);
+//             process.stdin.pause();
+//             rl.close();
+//             let answer;
+//             if (type === 'radio') {
+//               answer = options[selectedIndex];
+//             } else if (type === 'checkbox') {
+//               answer = selectedOptionsArray.map((index) => options[index]);
+//             }
+//             results.push({ text: text, answer: answer });
+//             questionIndex++;
+//             askQuestion();
+//           } else if (key.ctrl && key.name === 'c') {
+//             process.exit();
+//           } else if (type === 'checkbox' && key.name === 'space') {
+//             if (selectedOptionsArray.includes(selectedIndex)) {
+//               selectedOptionsArray = selectedOptionsArray.filter(
+//                 (item) => item !== selectedIndex
+//               );
+//             } else {
+//               selectedOptionsArray.push(selectedIndex);
+//             }
+//             displayOptions();
+//           }
+//         });
+//       }
+//     }
+
+//     askQuestion();
+//   });
+// }
+
+
+async function recursiveQuestion(questions, answers = [], currentIndex = 0) {
+  if (currentIndex >= questions.length) {
+    return answers;
+  }
+
+  const currentQuestion = questions[currentIndex];
+
+  for (let i = 0; i < answers.length; i++) {
+    console.log(`${questions[i].text}: ${Array.isArray(answers[i].answer) ? answers[i].answer.join(', ') : answers[i].answer}`);
+  }
+
+  console.log(`${currentQuestion.text}`);
+
+  let answer;
+
+  if (currentQuestion.type === 'text') {
+    answer = await questionAsync('> ');
+  } else if (currentQuestion.type === 'checkbox') {
+    answer = await checkboxMenu(currentQuestion.options, answers);
+  } else if (currentQuestion.type === 'radio') {
+    answer = await radioMenu(currentQuestion.options, answers);
+  } else {
+    throw new Error(`Unknown question type: ${currentQuestion.type}`);
+  }
+
+  answers.push({ question: currentQuestion.text, answer: answer });
+  return recursiveQuestion(questions, answers, currentIndex + 1);
+}
+
+function questionAsync(prompt) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(prompt, (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
+
+async function checkboxMenu(choices, previousAnswers) {
+  const selected = new Array(choices.length).fill(false);
+  let currentIndex = 0;
+
+  while (true) {
+    console.clear();
+    for (let i = 0; i < previousAnswers.length; i++) {
+      console.log(`${previousAnswers[i].question}: ${Array.isArray(previousAnswers[i].answer) ? previousAnswers[i].answer.join(', ') : previousAnswers[i].answer}`);
+    }
+
+    console.log("Select with space, confirm with enter, navigate with arrows:");
+    for (let i = 0; i < choices.length; i++) {
+      const prefix = i === currentIndex ? '>' : ' ';
+      const check = selected[i] ? '[x]' : '[ ]';
+      console.log(`${prefix} ${check} ${choices[i]}`);
+    }
+
+    const key = await readKey();
+
+    if (key === '\r') {
+      return choices.filter((_, i) => selected[i]);
+    } else if (key === '\u001b[A') {
+      currentIndex = (currentIndex - 1 + choices.length) % choices.length;
+    } else if (key === '\u001b[B') {
+      currentIndex = (currentIndex + 1) % choices.length;
+    } else if (key === ' ') {
+      selected[currentIndex] = !selected[currentIndex];
+    }
+  }
+}
+
+async function radioMenu(choices, previousAnswers) {
+  let currentIndex = 0;
+
+  while (true) {
+    console.clear();
+    for (let i = 0; i < previousAnswers.length; i++) {
+      console.log(`${previousAnswers[i].question}: ${Array.isArray(previousAnswers[i].answer) ? previousAnswers[i].answer.join(', ') : previousAnswers[i].answer}`);
+    }
+    console.log("Select with enter, navigate with arrows:");
+
+    for (let i = 0; i < choices.length; i++) {
+      const prefix = i === currentIndex ? '>' : ' ';
+      const radio = i === currentIndex ? '(o)' : '( )';
+      console.log(`${prefix} ${radio} ${choices[i]}`);
+    }
+
+    const key = await readKey();
+
+    if (key === '\r') {
+      return choices[currentIndex];
+    } else if (key === '\u001b[A') {
+      currentIndex = (currentIndex - 1 + choices.length) % choices.length;
+    } else if (key === '\u001b[B') {
+      currentIndex = (currentIndex + 1) % choices.length;
+    }
+  }
+}
+
+function readKey() {
+  return new Promise((resolve) => {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.once('data', (data) => {
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+      resolve(data.toString());
+    });
+  });
+}
+
+function inputSelectMultiple(questions) {
+  return new Promise(async (resolve, reject) => {
+    try {
+      const results = await recursiveQuestion(questions);
+      resolve(results);
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+
+
+function inputSelectMultipleAsync(questions, callback) {
+  recursiveQuestion(questions)
+      .then((results) => {
+          callback(null, results); // Pass null for error, results for success
+      })
+      .catch((error) => {
+          callback(error, null); // Pass error, null for results
+      });
+}
+
 
-module.exports = { input, inputSelect, inputSelectMultiple }
+module.exports = { input, inputAsync, inputSelect, inputSelectAsync, inputSelectMultipleAsync, inputSelectMultiple }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "input-shell",
-  "version": "1.0.0",
+  "version": "1.3.0",
   "description": "python like input function using input-shell in nodejs",
   "main": "index.js",
   "directories": {
@@ -12,8 +12,6 @@
   "devDependencies": {
     "chai": "^5.1.2",
     "mocha": "^11.1.0",
-    "package1": "^0.0.0",
-    "package2": "^1.0.0",
     "sinon": "^19.0.2"
   },
   "keywords": [
@@ -27,6 +25,5 @@
   "author": "Ganesh Bhat <cgijs@gmail.com>",
   "license": "MIT",
   "dependencies": {
-    "input": "^1.0.1"
   }
 }

package/test/test.input.js

@@ -1,3 +1,21 @@
+/**
+ * 
+ * Package: 
+ * Author: Ganesh B
+ * Description: 
+ * Install: npm i input-shell --save
+ * Github: https://github.com/ganeshkbhat/
+ * npmjs Link: https://www.npmjs.com/package/
+ * File: index.js
+ * File Description: 
+ * 
+ * 
+*/
+
+/* eslint no-console: 0 */
+
+'use strict';
+
 const assert = require('assert');
 const { spawn } = require('child_process');
 const process = require("process");

package/test/test.input.multiple.async.js

@@ -0,0 +1,175 @@
+/**
+ * 
+ * Package: 
+ * Author: Ganesh B
+ * Description: 
+ * Install: npm i input-shell --save
+ * Github: https://github.com/ganeshkbhat/
+ * npmjs Link: https://www.npmjs.com/package/
+ * File: index.js
+ * File Description: 
+ * 
+ * 
+*/
+
+/* eslint no-console: 0 */
+
+'use strict';
+
+const assert = require('chai').assert;
+const sinon = require('sinon');
+const { inputSelectMultipleAsync } = require('../index'); // Replace 'your-file-name'
+
+// describe('inputSelectMultipleAsync with History', () => {
+//   let stdinStub, stdoutSpy, stdoutStub, processExitStub;
+//   let originalRawMode;
+
+//   before(() => {
+//     // stdoutSpy = sinon.spy(process.stdout, 'write');
+//   })
+
+//   beforeEach(() => {
+//     stdinStub = sinon.stub(process.stdin);
+//     stdoutStub = sinon.stub(process.stdout, "fd");
+
+//     processExitStub = sinon.stub(process, 'exit');
+//     originalRawMode = process.stdin.isRaw;
+//   });
+
+//   afterEach(() => {
+//     sinon.restore();
+//     process.stdin.setRawMode(originalRawMode);
+//   });
+
+//   // it('should handle a sequence of text, radio, and checkbox questions with history-', (done) => {
+//   //   const questions = [
+//   //     { text: 'What is your name?', type: 'text' },
+//   //     { text: 'What is your favorite color?', type: 'radio', options: ['Red', 'Blue'] },
+//   //     { text: 'Which fruits do you like?', type: 'checkbox', options: ['Apple', 'Banana'] },
+//   //   ];
+
+//   //   const expectedResults = [
+//   //     { text: 'What is your name?', answer: 'Test Name' },
+//   //     { text: 'What is your favorite color?', answer: 'Blue' },
+//   //     { text: 'Which fruits do you like?', answer: ['Apple'] },
+//   //   ];
+
+//   //   const callback = (results) => {
+//   //     assert.deepStrictEqual(results, expectedResults);
+//   //     assert.ok(stdoutSpy.calledWith(sinon.match('What is your name?: Test Name')));
+//   //     assert.ok(stdoutSpy.calledWith(sinon.match('What is your favorite color?: Blue')));
+//   //     done();
+//   //   };
+
+//   //   inputSelectMultipleAsync(questions, callback);
+
+//   //   let keyPressCount = 0;
+
+//   //   stdinStub.on('data', (data) => {
+//   //     if (keyPressCount === 0) {
+//   //       stdinStub.emit('keypress', '\r', { name: 'return' });
+//   //     } else if (keyPressCount === 1) {
+//   //       stdinStub.emit('keypress', '\r', { name: 'return' });
+//   //     } else if (keyPressCount === 2) {
+//   //       stdinStub.emit('keypress', '\r', { name: 'return' });
+//   //     }
+//   //     keyPressCount++;
+//   //   });
+
+//   //   stdinStub.emit('data', 'Test Name\n');
+//   //   stdinStub.emit('keypress', null, { name: 'down' });
+//   //   stdinStub.emit('keypress', null, { name: 'return' });
+//   //   stdinStub.emit('keypress', null, { name: 'space' });
+//   //   stdinStub.emit('keypress', null, { name: 'return' });
+//   // });
+
+//   it('should handle a sequence of text, radio, and checkbox questions with history', (done) => {
+//     const questions = [
+//       { text: 'What is your name?', type: 'text' },
+//       { text: 'What is your favorite color?', type: 'radio', options: ['Red', 'Blue'] },
+//       { text: 'Which fruits do you like?', type: 'checkbox', options: ['Apple', 'Banana'] },
+//     ];
+
+//     const expectedResults = [
+//       { text: 'What is your name?', answer: 'Test Name' },
+//       { text: 'What is your favorite color?', answer: 'Blue' },
+//       { text: 'Which fruits do you like?', answer: ['Apple'] },
+//     ];
+
+//     const callback = (results) => {
+//       assert.deepStrictEqual(results, expectedResults);
+//       done();
+//     };
+
+//     inputSelectMultipleAsync(questions, callback);
+
+//     let keyPressCount = 0;
+
+//     stdinStub.on('data', (data) => {
+//       if (keyPressCount === 0) {
+//         stdinStub.emit('keypress', '\r', { name: 'return' });
+//       } else if (keyPressCount === 1) {
+//         stdinStub.emit('keypress', '\r', { name: 'return' });
+//       } else if (keyPressCount === 2) {
+//         stdinStub.emit('keypress', '\r', { name: 'return' });
+//       }
+//       keyPressCount++;
+//     });
+
+//     stdinStub.emit('data', 'Test Name\n');
+//     stdinStub.emit('keypress', null, { name: 'down' });
+//     stdinStub.emit('keypress', null, { name: 'return' });
+//     stdinStub.emit('keypress', null, { name: 'space' });
+//     stdinStub.emit('keypress', null, { name: 'return' });
+
+//     // Check if previous answers are displayed.
+//     // console.log();
+//     assert.ok(stdoutSpy.calledWith(sinon.match('What is your name? Test Name')));
+//     // assert.ok(stdoutSpy.calledWith(sinon.match('What is your name? Test Name')));
+//     // assert.ok(stdoutSpy.calledWith(sinon.match('What is your favorite color? Blue')));
+//   });
+
+//   it('should handle only text questions with history', (done) => {
+//     const questions = [
+//       { text: 'What is your name?', type: 'text' },
+//       { text: 'What is your age?', type: 'text' },
+//     ];
+
+//     const expectedResults = [
+//       { text: 'What is your name?', answer: 'Test Name' },
+//       { text: 'What is your age?', answer: '30' },
+//     ];
+
+//     const callback = (results) => {
+//       assert.deepStrictEqual(results, expectedResults);
+//       done();
+//     };
+
+//     inputSelectMultipleAsync(questions, callback);
+
+//     let count = 0;
+
+//     stdinStub.on('data', (data) => {
+//       if (count === 0) {
+//         stdinStub.emit('keypress', '\r', { name: 'return' });
+//       } else {
+//         stdinStub.emit('keypress', '\r', { name: 'return' });
+//       }
+//       count++;
+//     });
+
+//     stdinStub.emit('data', 'Test Name\n');
+//     stdinStub.emit('data', '30\n');
+
+//     assert.ok(stdoutSpy.calledWith(sinon.match('What is your name? Test Name\n')));
+
+//   });
+
+//   it('should handle ctrl+c exit during questions with history', () => {
+//     const questions = [{ text: 'What is your name?', type: 'text' }];
+
+//     inputSelectMultipleAsync(questions, () => { });
+//     stdinStub.emit('keypress', null, { ctrl: true, name: 'c' });
+//     assert.ok(!processExitStub.called);
+//   });
+// });