Merge branch 'researchML' into 'dev'

Research ml

See merge request igrannonica/neuronstellar!6

10 files changed, 1647 insertions, 0 deletions

diff --git a/sandbox/testAppNevena/Front/node_modules/inquirer/lib/prompts/base.js b/sandbox/testAppNevena/Front/node_modules/inquirer/lib/prompts/base.js
new file mode 100644
index 00000000..ec503eec
--- /dev/null
+++ b/sandbox/testAppNevena/Front/node_modules/inquirer/lib/prompts/base.js
@@ -0,0 +1,181 @@
+'use strict';
+/**
+ * Base prompt implementation
+ * Should be extended by prompt types.
+ */
+const _ = {
+  assign: require('lodash/assign'),
+  defaults: require('lodash/defaults'),
+  clone: require('lodash/clone'),
+};
+const chalk = require('chalk');
+const runAsync = require('run-async');
+const { filter, flatMap, share, take, takeUntil } = require('rxjs/operators');
+const Choices = require('../objects/choices');
+const ScreenManager = require('../utils/screen-manager');
+
+class Prompt {
+  constructor(question, rl, answers) {
+    // Setup instance defaults property
+    _.assign(this, {
+      answers,
+      status: 'pending',
+    });
+
+    // Set defaults prompt options
+    this.opt = _.defaults(_.clone(question), {
+      validate: () => true,
+      validatingText: '',
+      filter: (val) => val,
+      filteringText: '',
+      when: () => true,
+      suffix: '',
+      prefix: chalk.green('?'),
+    });
+
+    // Make sure name is present
+    if (!this.opt.name) {
+      this.throwParamError('name');
+    }
+
+    // Set default message if no message defined
+    if (!this.opt.message) {
+      this.opt.message = this.opt.name + ':';
+    }
+
+    // Normalize choices
+    if (Array.isArray(this.opt.choices)) {
+      this.opt.choices = new Choices(this.opt.choices, answers);
+    }
+
+    this.rl = rl;
+    this.screen = new ScreenManager(this.rl);
+  }
+
+  /**
+   * Start the Inquiry session and manage output value filtering
+   * @return {Promise}
+   */
+
+  run() {
+    return new Promise((resolve, reject) => {
+      this._run(
+        (value) => resolve(value),
+        (error) => reject(error)
+      );
+    });
+  }
+
+  // Default noop (this one should be overwritten in prompts)
+  _run(cb) {
+    cb();
+  }
+
+  /**
+   * Throw an error telling a required parameter is missing
+   * @param  {String} name Name of the missing param
+   * @return {Throw Error}
+   */
+
+  throwParamError(name) {
+    throw new Error('You must provide a `' + name + '` parameter');
+  }
+
+  /**
+   * Called when the UI closes. Override to do any specific cleanup necessary
+   */
+  close() {
+    this.screen.releaseCursor();
+  }
+
+  /**
+   * Run the provided validation method each time a submit event occur.
+   * @param  {Rx.Observable} submit - submit event flow
+   * @return {Object}        Object containing two observables: `success` and `error`
+   */
+  handleSubmitEvents(submit) {
+    const self = this;
+    const validate = runAsync(this.opt.validate);
+    const asyncFilter = runAsync(this.opt.filter);
+    const validation = submit.pipe(
+      flatMap((value) => {
+        this.startSpinner(value, this.opt.filteringText);
+        return asyncFilter(value, self.answers).then(
+          (filteredValue) => {
+            this.startSpinner(filteredValue, this.opt.validatingText);
+            return validate(filteredValue, self.answers).then(
+              (isValid) => ({ isValid, value: filteredValue }),
+              (err) => ({ isValid: err, value: filteredValue })
+            );
+          },
+          (err) => ({ isValid: err })
+        );
+      }),
+      share()
+    );
+
+    const success = validation.pipe(
+      filter((state) => state.isValid === true),
+      take(1)
+    );
+    const error = validation.pipe(
+      filter((state) => state.isValid !== true),
+      takeUntil(success)
+    );
+
+    return {
+      success,
+      error,
+    };
+  }
+
+  startSpinner(value, bottomContent) {
+    value = this.getSpinningValue(value);
+    // If the question will spin, cut off the prefix (for layout purposes)
+    const content = bottomContent
+      ? this.getQuestion() + value
+      : this.getQuestion().slice(this.opt.prefix.length + 1) + value;
+
+    this.screen.renderWithSpinner(content, bottomContent);
+  }
+
+  /**
+   * Allow override, e.g. for password prompts
+   * See: https://github.com/SBoudrias/Inquirer.js/issues/1022
+   *
+   * @return {String} value to display while spinning
+   */
+  getSpinningValue(value) {
+    return value;
+  }
+
+  /**
+   * Generate the prompt question string
+   * @return {String} prompt question string
+   */
+  getQuestion() {
+    let message =
+      (this.opt.prefix ? this.opt.prefix + ' ' : '') +
+      chalk.bold(this.opt.message) +
+      this.opt.suffix +
+      chalk.reset(' ');
+
+    // Append the default if available, and if question isn't touched/answered
+    if (
+      this.opt.default != null &&
+      this.status !== 'touched' &&
+      this.status !== 'answered'
+    ) {
+      // If default password is supplied, hide it
+      if (this.opt.type === 'password') {
+        message += chalk.italic.dim('[hidden] ');
+      } else {
+        message += chalk.dim('(' + this.opt.default + ') ');
+      }
+    }
+
+    return message;
+  }
+}
+
+module.exports = Prompt;
diff --git a/sandbox/testAppNevena/Front/node_modules/inquirer/lib/prompts/checkbox.js b/sandbox/testAppNevena/Front/node_modules/inquirer/lib/prompts/checkbox.js
new file mode 100644
index 00000000..4f60b77e
--- /dev/null
+++ b/sandbox/testAppNevena/Front/node_modules/inquirer/lib/prompts/checkbox.js
@@ -0,0 +1,278 @@
+'use strict';
+/**
+ * `list` type prompt
+ */
+
+const _ = {
+  isArray: require('lodash/isArray'),
+  map: require('lodash/map'),
+  isString: require('lodash/isString'),
+};
+const chalk = require('chalk');
+const cliCursor = require('cli-cursor');
+const figures = require('figures');
+const { map, takeUntil } = require('rxjs/operators');
+const Base = require('./base');
+const observe = require('../utils/events');
+const Paginator = require('../utils/paginator');
+const incrementListIndex = require('../utils/incrementListIndex');
+
+class CheckboxPrompt extends Base {
+  constructor(questions, rl, answers) {
+    super(questions, rl, answers);
+
+    if (!this.opt.choices) {
+      this.throwParamError('choices');
+    }
+
+    if (_.isArray(this.opt.default)) {
+      this.opt.choices.forEach(function (choice) {
+        if (this.opt.default.indexOf(choice.value) >= 0) {
+          choice.checked = true;
+        }
+      }, this);
+    }
+
+    this.pointer = 0;
+
+    // Make sure no default is set (so it won't be printed)
+    this.opt.default = null;
+
+    const shouldLoop = this.opt.loop === undefined ? true : this.opt.loop;
+    this.paginator = new Paginator(this.screen, { isInfinite: shouldLoop });
+  }
+
+  /**
+   * Start the Inquiry session
+   * @param  {Function} cb      Callback when prompt is done
+   * @return {this}
+   */
+
+  _run(cb) {
+    this.done = cb;
+
+    const events = observe(this.rl);
+
+    const validation = this.handleSubmitEvents(
+      events.line.pipe(map(this.getCurrentValue.bind(this)))
+    );
+    validation.success.forEach(this.onEnd.bind(this));
+    validation.error.forEach(this.onError.bind(this));
+
+    events.normalizedUpKey
+      .pipe(takeUntil(validation.success))
+      .forEach(this.onUpKey.bind(this));
+    events.normalizedDownKey
+      .pipe(takeUntil(validation.success))
+      .forEach(this.onDownKey.bind(this));
+    events.numberKey
+      .pipe(takeUntil(validation.success))
+      .forEach(this.onNumberKey.bind(this));
+    events.spaceKey
+      .pipe(takeUntil(validation.success))
+      .forEach(this.onSpaceKey.bind(this));
+    events.aKey.pipe(takeUntil(validation.success)).forEach(this.onAllKey.bind(this));
+    events.iKey.pipe(takeUntil(validation.success)).forEach(this.onInverseKey.bind(this));
+
+    // Init the prompt
+    cliCursor.hide();
+    this.render();
+    this.firstRender = false;
+
+    return this;
+  }
+
+  /**
+   * Render the prompt to screen
+   * @return {CheckboxPrompt} self
+   */
+
+  render(error) {
+    // Render question
+    let message = this.getQuestion();
+    let bottomContent = '';
+
+    if (!this.dontShowHints) {
+      message +=
+        '(Press ' +
+        chalk.cyan.bold('<space>') +
+        ' to select, ' +
+        chalk.cyan.bold('<a>') +
+        ' to toggle all, ' +
+        chalk.cyan.bold('<i>') +
+        ' to invert selection, and ' +
+        chalk.cyan.bold('<enter>') +
+        ' to proceed)';
+    }
+
+    // Render choices or answer depending on the state
+    if (this.status === 'answered') {
+      message += chalk.cyan(this.selection.join(', '));
+    } else {
+      const choicesStr = renderChoices(this.opt.choices, this.pointer);
+      const indexPosition = this.opt.choices.indexOf(
+        this.opt.choices.getChoice(this.pointer)
+      );
+      const realIndexPosition =
+        this.opt.choices.reduce((acc, value, i) => {
+          // Dont count lines past the choice we are looking at
+          if (i > indexPosition) {
+            return acc;
+          }
+          // Add line if it's a separator
+          if (value.type === 'separator') {
+            return acc + 1;
+          }
+
+          let l = value.name;
+          // Non-strings take up one line
+          if (typeof l !== 'string') {
+            return acc + 1;
+          }
+
+          // Calculate lines taken up by string
+          l = l.split('\n');
+          return acc + l.length;
+        }, 0) - 1;
+      message +=
+        '\n' + this.paginator.paginate(choicesStr, realIndexPosition, this.opt.pageSize);
+    }
+
+    if (error) {
+      bottomContent = chalk.red('>> ') + error;
+    }
+
+    this.screen.render(message, bottomContent);
+  }
+
+  /**
+   * When user press `enter` key
+   */
+
+  onEnd(state) {
+    this.status = 'answered';
+    this.dontShowHints = true;
+    // Rerender prompt (and clean subline error)
+    this.render();
+
+    this.screen.done();
+    cliCursor.show();
+    this.done(state.value);
+  }
+
+  onError(state) {
+    this.render(state.isValid);
+  }
+
+  getCurrentValue() {
+    const choices = this.opt.choices.filter(
+      (choice) => Boolean(choice.checked) && !choice.disabled
+    );
+
+    this.selection = _.map(choices, 'short');
+    return _.map(choices, 'value');
+  }
+
+  onUpKey() {
+    this.pointer = incrementListIndex(this.pointer, 'up', this.opt);
+    this.render();
+  }
+
+  onDownKey() {
+    this.pointer = incrementListIndex(this.pointer, 'down', this.opt);
+    this.render();
+  }
+
+  onNumberKey(input) {
+    if (input <= this.opt.choices.realLength) {
+      this.pointer = input - 1;
+      this.toggleChoice(this.pointer);
+    }
+
+    this.render();
+  }
+
+  onSpaceKey() {
+    this.toggleChoice(this.pointer);
+    this.render();
+  }
+
+  onAllKey() {
+    const shouldBeChecked = Boolean(
+      this.opt.choices.find((choice) => choice.type !== 'separator' && !choice.checked)
+    );
+
+    this.opt.choices.forEach((choice) => {
+      if (choice.type !== 'separator') {
+        choice.checked = shouldBeChecked;
+      }
+    });
+
+    this.render();
+  }
+
+  onInverseKey() {
+    this.opt.choices.forEach((choice) => {
+      if (choice.type !== 'separator') {
+        choice.checked = !choice.checked;
+      }
+    });
+
+    this.render();
+  }
+
+  toggleChoice(index) {
+    const item = this.opt.choices.getChoice(index);
+    if (item !== undefined) {
+      this.opt.choices.getChoice(index).checked = !item.checked;
+    }
+  }
+}
+
+/**
+ * Function for rendering checkbox choices
+ * @param  {Number} pointer Position of the pointer
+ * @return {String}         Rendered content
+ */
+
+function renderChoices(choices, pointer) {
+  let output = '';
+  let separatorOffset = 0;
+
+  choices.forEach((choice, i) => {
+    if (choice.type === 'separator') {
+      separatorOffset++;
+      output += ' ' + choice + '\n';
+      return;
+    }
+
+    if (choice.disabled) {
+      separatorOffset++;
+      output += ' - ' + choice.name;
+      output += ' (' + (_.isString(choice.disabled) ? choice.disabled : 'Disabled') + ')';
+    } else {
+      const line = getCheckbox(choice.checked) + ' ' + choice.name;
+      if (i - separatorOffset === pointer) {
+        output += chalk.cyan(figures.pointer + line);
+      } else {
+        output += ' ' + line;
+      }
+    }
+
+    output += '\n';
+  });
+
+  return output.replace(/\n$/, '');
+}
+
+/**
+ * Get the checkbox
+ * @param  {Boolean} checked - add a X or not to the checkbox
+ * @return {String} Composited checkbox string
+ */
+
+function getCheckbox(checked) {
+  return checked ? chalk.green(figures.radioOn) : figures.radioOff;
+}
+
+module.exports = CheckboxPrompt;
diff --git a/sandbox/testAppNevena/Front/node_modules/inquirer/lib/prompts/confirm.js b/sandbox/testAppNevena/Front/node_modules/inquirer/lib/prompts/confirm.js
new file mode 100644
index 00000000..8171aab5
--- /dev/null
+++ b/sandbox/testAppNevena/Front/node_modules/inquirer/lib/prompts/confirm.js
@@ -0,0 +1,102 @@
+'use strict';
+/**
+ * `confirm` type prompt
+ */
+
+const _ = {
+  extend: require('lodash/extend'),
+  isBoolean: require('lodash/isBoolean'),
+};
+const chalk = require('chalk');
+const { take, takeUntil } = require('rxjs/operators');
+const Base = require('./base');
+const observe = require('../utils/events');
+
+class ConfirmPrompt extends Base {
+  constructor(questions, rl, answers) {
+    super(questions, rl, answers);
+
+    let rawDefault = true;
+
+    _.extend(this.opt, {
+      filter(input) {
+        let value = rawDefault;
+        if (input != null && input !== '') {
+          value = /^y(es)?/i.test(input);
+        }
+
+        return value;
+      },
+    });
+
+    if (_.isBoolean(this.opt.default)) {
+      rawDefault = this.opt.default;
+    }
+
+    this.opt.default = rawDefault ? 'Y/n' : 'y/N';
+  }
+
+  /**
+   * Start the Inquiry session
+   * @param  {Function} cb   Callback when prompt is done
+   * @return {this}
+   */
+
+  _run(cb) {
+    this.done = cb;
+
+    // Once user confirm (enter key)
+    const events = observe(this.rl);
+    events.keypress.pipe(takeUntil(events.line)).forEach(this.onKeypress.bind(this));
+
+    events.line.pipe(take(1)).forEach(this.onEnd.bind(this));
+
+    // Init
+    this.render();
+
+    return this;
+  }
+
+  /**
+   * Render the prompt to screen
+   * @return {ConfirmPrompt} self
+   */
+
+  render(answer) {
+    let message = this.getQuestion();
+
+    if (typeof answer === 'boolean') {
+      message += chalk.cyan(answer ? 'Yes' : 'No');
+    } else {
+      message += this.rl.line;
+    }
+
+    this.screen.render(message);
+
+    return this;
+  }
+
+  /**
+   * When user press `enter` key
+   */
+
+  onEnd(input) {
+    this.status = 'answered';
+
+    const output = this.opt.filter(input);
+    this.render(output);
+
+    this.screen.done();
+    this.done(output);
+  }
+
+  /**
+   * When user press a key
+   */
+
+  onKeypress() {
+    this.render();
+  }
+}
+
+module.exports = ConfirmPrompt;
diff --git a/sandbox/testAppNevena/Front/node_modules/inquirer/lib/prompts/editor.js b/sandbox/testAppNevena/Front/node_modules/inquirer/lib/prompts/editor.js
new file mode 100644
index 00000000..600e0745
--- /dev/null
+++ b/sandbox/testAppNevena/Front/node_modules/inquirer/lib/prompts/editor.js
@@ -0,0 +1,100 @@
+'use strict';
+/**
+ * `editor` type prompt
+ */
+
+const chalk = require('chalk');
+const { editAsync } = require('external-editor');
+const Base = require('./base');
+const observe = require('../utils/events');
+const { Subject } = require('rxjs');
+
+class EditorPrompt extends Base {
+  /**
+   * Start the Inquiry session
+   * @param  {Function} cb      Callback when prompt is done
+   * @return {this}
+   */
+
+  _run(cb) {
+    this.done = cb;
+
+    this.editorResult = new Subject();
+
+    // Open Editor on "line" (Enter Key)
+    const events = observe(this.rl);
+    this.lineSubscription = events.line.subscribe(this.startExternalEditor.bind(this));
+
+    // Trigger Validation when editor closes
+    const validation = this.handleSubmitEvents(this.editorResult);
+    validation.success.forEach(this.onEnd.bind(this));
+    validation.error.forEach(this.onError.bind(this));
+
+    // Prevents default from being printed on screen (can look weird with multiple lines)
+    this.currentText = this.opt.default;
+    this.opt.default = null;
+
+    // Init
+    this.render();
+
+    return this;
+  }
+
+  /**
+   * Render the prompt to screen
+   * @return {EditorPrompt} self
+   */
+
+  render(error) {
+    let bottomContent = '';
+    let message = this.getQuestion();
+
+    if (this.status === 'answered') {
+      message += chalk.dim('Received');
+    } else {
+      message += chalk.dim('Press <enter> to launch your preferred editor.');
+    }
+
+    if (error) {
+      bottomContent = chalk.red('>> ') + error;
+    }
+
+    this.screen.render(message, bottomContent);
+  }
+
+  /**
+   * Launch $EDITOR on user press enter
+   */
+
+  startExternalEditor() {
+    // Pause Readline to prevent stdin and stdout from being modified while the editor is showing
+    this.rl.pause();
+    editAsync(this.currentText, this.endExternalEditor.bind(this));
+  }
+
+  endExternalEditor(error, result) {
+    this.rl.resume();
+    if (error) {
+      this.editorResult.error(error);
+    } else {
+      this.editorResult.next(result);
+    }
+  }
+
+  onEnd(state) {
+    this.editorResult.unsubscribe();
+    this.lineSubscription.unsubscribe();
+    this.answer = state.value;
+    this.status = 'answered';
+    // Re-render prompt
+    this.render();
+    this.screen.done();
+    this.done(this.answer);
+  }
+
+  onError(state) {
+    this.render(state.isValid);
+  }
+}
+
+module.exports = EditorPrompt;
diff --git a/sandbox/testAppNevena/Front/node_modules/inquirer/lib/prompts/expand.js b/sandbox/testAppNevena/Front/node_modules/inquirer/lib/prompts/expand.js
new file mode 100644
index 00000000..af1ad810
--- /dev/null
+++ b/sandbox/testAppNevena/Front/node_modules/inquirer/lib/prompts/expand.js
@@ -0,0 +1,282 @@
+'use strict';
+/**
+ * `rawlist` type prompt
+ */
+
+const _ = {
+  uniq: require('lodash/uniq'),
+  isString: require('lodash/isString'),
+  isNumber: require('lodash/isNumber'),
+  findIndex: require('lodash/findIndex'),
+};
+const chalk = require('chalk');
+const { map, takeUntil } = require('rxjs/operators');
+const Base = require('./base');
+const Separator = require('../objects/separator');
+const observe = require('../utils/events');
+const Paginator = require('../utils/paginator');
+
+class ExpandPrompt extends Base {
+  constructor(questions, rl, answers) {
+    super(questions, rl, answers);
+
+    if (!this.opt.choices) {
+      this.throwParamError('choices');
+    }
+
+    this.validateChoices(this.opt.choices);
+
+    // Add the default `help` (/expand) option
+    this.opt.choices.push({
+      key: 'h',
+      name: 'Help, list all options',
+      value: 'help',
+    });
+
+    this.opt.validate = (choice) => {
+      if (choice == null) {
+        return 'Please enter a valid command';
+      }
+
+      return choice !== 'help';
+    };
+
+    // Setup the default string (capitalize the default key)
+    this.opt.default = this.generateChoicesString(this.opt.choices, this.opt.default);
+
+    this.paginator = new Paginator(this.screen);
+  }
+
+  /**
+   * Start the Inquiry session
+   * @param  {Function} cb      Callback when prompt is done
+   * @return {this}
+   */
+
+  _run(cb) {
+    this.done = cb;
+
+    // Save user answer and update prompt to show selected option.
+    const events = observe(this.rl);
+    const validation = this.handleSubmitEvents(
+      events.line.pipe(map(this.getCurrentValue.bind(this)))
+    );
+    validation.success.forEach(this.onSubmit.bind(this));
+    validation.error.forEach(this.onError.bind(this));
+    this.keypressObs = events.keypress
+      .pipe(takeUntil(validation.success))
+      .forEach(this.onKeypress.bind(this));
+
+    // Init the prompt
+    this.render();
+
+    return this;
+  }
+
+  /**
+   * Render the prompt to screen
+   * @return {ExpandPrompt} self
+   */
+
+  render(error, hint) {
+    let message = this.getQuestion();
+    let bottomContent = '';
+
+    if (this.status === 'answered') {
+      message += chalk.cyan(this.answer);
+    } else if (this.status === 'expanded') {
+      const choicesStr = renderChoices(this.opt.choices, this.selectedKey);
+      message += this.paginator.paginate(choicesStr, this.selectedKey, this.opt.pageSize);
+      message += '\n  Answer: ';
+    }
+
+    message += this.rl.line;
+
+    if (error) {
+      bottomContent = chalk.red('>> ') + error;
+    }
+
+    if (hint) {
+      bottomContent = chalk.cyan('>> ') + hint;
+    }
+
+    this.screen.render(message, bottomContent);
+  }
+
+  getCurrentValue(input) {
+    if (!input) {
+      input = this.rawDefault;
+    }
+
+    const selected = this.opt.choices.where({ key: input.toLowerCase().trim() })[0];
+    if (!selected) {
+      return null;
+    }
+
+    return selected.value;
+  }
+
+  /**
+   * Generate the prompt choices string
+   * @return {String}  Choices string
+   */
+
+  getChoices() {
+    let output = '';
+
+    this.opt.choices.forEach((choice) => {
+      output += '\n  ';
+
+      if (choice.type === 'separator') {
+        output += ' ' + choice;
+        return;
+      }
+
+      let choiceStr = choice.key + ') ' + choice.name;
+      if (this.selectedKey === choice.key) {
+        choiceStr = chalk.cyan(choiceStr);
+      }
+
+      output += choiceStr;
+    });
+
+    return output;
+  }
+
+  onError(state) {
+    if (state.value === 'help') {
+      this.selectedKey = '';
+      this.status = 'expanded';
+      this.render();
+      return;
+    }
+
+    this.render(state.isValid);
+  }
+
+  /**
+   * When user press `enter` key
+   */
+
+  onSubmit(state) {
+    this.status = 'answered';
+    const choice = this.opt.choices.where({ value: state.value })[0];
+    this.answer = choice.short || choice.name;
+
+    // Re-render prompt
+    this.render();
+    this.screen.done();
+    this.done(state.value);
+  }
+
+  /**
+   * When user press a key
+   */
+
+  onKeypress() {
+    this.selectedKey = this.rl.line.toLowerCase();
+    const selected = this.opt.choices.where({ key: this.selectedKey })[0];
+    if (this.status === 'expanded') {
+      this.render();
+    } else {
+      this.render(null, selected ? selected.name : null);
+    }
+  }
+
+  /**
+   * Validate the choices
+   * @param {Array} choices
+   */
+
+  validateChoices(choices) {
+    let formatError;
+    const errors = [];
+    const keymap = {};
+    choices.filter(Separator.exclude).forEach((choice) => {
+      if (!choice.key || choice.key.length !== 1) {
+        formatError = true;
+      }
+
+      choice.key = String(choice.key).toLowerCase();
+
+      if (keymap[choice.key]) {
+        errors.push(choice.key);
+      }
+
+      keymap[choice.key] = true;
+    });
+
+    if (formatError) {
+      throw new Error(
+        'Format error: `key` param must be a single letter and is required.'
+      );
+    }
+
+    if (keymap.h) {
+      throw new Error(
+        'Reserved key error: `key` param cannot be `h` - this value is reserved.'
+      );
+    }
+
+    if (errors.length) {
+      throw new Error(
+        'Duplicate key error: `key` param must be unique. Duplicates: ' +
+          _.uniq(errors).join(', ')
+      );
+    }
+  }
+
+  /**
+   * Generate a string out of the choices keys
+   * @param  {Array}  choices
+   * @param  {Number|String} default - the choice index or name to capitalize
+   * @return {String} The rendered choices key string
+   */
+  generateChoicesString(choices, defaultChoice) {
+    let defIndex = choices.realLength - 1;
+    if (_.isNumber(defaultChoice) && this.opt.choices.getChoice(defaultChoice)) {
+      defIndex = defaultChoice;
+    } else if (_.isString(defaultChoice)) {
+      const index = _.findIndex(
+        choices.realChoices,
+        ({ value }) => value === defaultChoice
+      );
+      defIndex = index === -1 ? defIndex : index;
+    }
+
+    const defStr = this.opt.choices.pluck('key');
+    this.rawDefault = defStr[defIndex];
+    defStr[defIndex] = String(defStr[defIndex]).toUpperCase();
+    return defStr.join('');
+  }
+}
+
+/**
+ * Function for rendering checkbox choices
+ * @param  {String} pointer Selected key
+ * @return {String}         Rendered content
+ */
+
+function renderChoices(choices, pointer) {
+  let output = '';
+
+  choices.forEach((choice) => {
+    output += '\n  ';
+
+    if (choice.type === 'separator') {
+      output += ' ' + choice;
+      return;
+    }
+
+    let choiceStr = choice.key + ') ' + choice.name;
+    if (pointer === choice.key) {
+      choiceStr = chalk.cyan(choiceStr);
+    }
+
+    output += choiceStr;
+  });
+
+  return output;
+}
+
+module.exports = ExpandPrompt;
diff --git a/sandbox/testAppNevena/Front/node_modules/inquirer/lib/prompts/input.js b/sandbox/testAppNevena/Front/node_modules/inquirer/lib/prompts/input.js
new file mode 100644
index 00000000..87f68b92
--- /dev/null
+++ b/sandbox/testAppNevena/Front/node_modules/inquirer/lib/prompts/input.js
@@ -0,0 +1,110 @@
+'use strict';
+/**
+ * `input` type prompt
+ */
+
+const chalk = require('chalk');
+const { map, takeUntil } = require('rxjs/operators');
+const Base = require('./base');
+const observe = require('../utils/events');
+
+class InputPrompt extends Base {
+  /**
+   * Start the Inquiry session
+   * @param  {Function} cb      Callback when prompt is done
+   * @return {this}
+   */
+
+  _run(cb) {
+    this.done = cb;
+
+    // Once user confirm (enter key)
+    const events = observe(this.rl);
+    const submit = events.line.pipe(map(this.filterInput.bind(this)));
+
+    const validation = this.handleSubmitEvents(submit);
+    validation.success.forEach(this.onEnd.bind(this));
+    validation.error.forEach(this.onError.bind(this));
+
+    events.keypress
+      .pipe(takeUntil(validation.success))
+      .forEach(this.onKeypress.bind(this));
+
+    // Init
+    this.render();
+
+    return this;
+  }
+
+  /**
+   * Render the prompt to screen
+   * @return {InputPrompt} self
+   */
+
+  render(error) {
+    let bottomContent = '';
+    let appendContent = '';
+    let message = this.getQuestion();
+    const { transformer } = this.opt;
+    const isFinal = this.status === 'answered';
+
+    if (isFinal) {
+      appendContent = this.answer;
+    } else {
+      appendContent = this.rl.line;
+    }
+
+    if (transformer) {
+      message += transformer(appendContent, this.answers, { isFinal });
+    } else {
+      message += isFinal ? chalk.cyan(appendContent) : appendContent;
+    }
+
+    if (error) {
+      bottomContent = chalk.red('>> ') + error;
+    }
+
+    this.screen.render(message, bottomContent);
+  }
+
+  /**
+   * When user press `enter` key
+   */
+
+  filterInput(input) {
+    if (!input) {
+      return this.opt.default == null ? '' : this.opt.default;
+    }
+
+    return input;
+  }
+
+  onEnd(state) {
+    this.answer = state.value;
+    this.status = 'answered';
+
+    // Re-render prompt
+    this.render();
+
+    this.screen.done();
+    this.done(state.value);
+  }
+
+  onError({ value = '', isValid }) {
+    this.rl.line += value;
+    this.rl.cursor += value.length;
+    this.render(isValid);
+  }
+
+  /**
+   * When user press a key
+   */
+
+  onKeypress() {
+    this.state = 'touched';
+
+    this.render();
+  }
+}
+
+module.exports = InputPrompt;
diff --git a/sandbox/testAppNevena/Front/node_modules/inquirer/lib/prompts/list.js b/sandbox/testAppNevena/Front/node_modules/inquirer/lib/prompts/list.js
new file mode 100644
index 00000000..486c030e
--- /dev/null
+++ b/sandbox/testAppNevena/Front/node_modules/inquirer/lib/prompts/list.js
@@ -0,0 +1,214 @@
+'use strict';
+/**
+ * `list` type prompt
+ */
+
+const _ = {
+  isNumber: require('lodash/isNumber'),
+  findIndex: require('lodash/findIndex'),
+  isString: require('lodash/isString'),
+};
+const chalk = require('chalk');
+const figures = require('figures');
+const cliCursor = require('cli-cursor');
+const runAsync = require('run-async');
+const { flatMap, map, take, takeUntil } = require('rxjs/operators');
+const Base = require('./base');
+const observe = require('../utils/events');
+const Paginator = require('../utils/paginator');
+const incrementListIndex = require('../utils/incrementListIndex');
+
+class ListPrompt extends Base {
+  constructor(questions, rl, answers) {
+    super(questions, rl, answers);
+
+    if (!this.opt.choices) {
+      this.throwParamError('choices');
+    }
+
+    this.firstRender = true;
+    this.selected = 0;
+
+    const def = this.opt.default;
+
+    // If def is a Number, then use as index. Otherwise, check for value.
+    if (_.isNumber(def) && def >= 0 && def < this.opt.choices.realLength) {
+      this.selected = def;
+    } else if (!_.isNumber(def) && def != null) {
+      const index = _.findIndex(
+        this.opt.choices.realChoices,
+        ({ value }) => value === def
+      );
+      this.selected = Math.max(index, 0);
+    }
+
+    // Make sure no default is set (so it won't be printed)
+    this.opt.default = null;
+
+    const shouldLoop = this.opt.loop === undefined ? true : this.opt.loop;
+    this.paginator = new Paginator(this.screen, { isInfinite: shouldLoop });
+  }
+
+  /**
+   * Start the Inquiry session
+   * @param  {Function} cb      Callback when prompt is done
+   * @return {this}
+   */
+
+  _run(cb) {
+    this.done = cb;
+
+    const self = this;
+
+    const events = observe(this.rl);
+    events.normalizedUpKey.pipe(takeUntil(events.line)).forEach(this.onUpKey.bind(this));
+    events.normalizedDownKey
+      .pipe(takeUntil(events.line))
+      .forEach(this.onDownKey.bind(this));
+    events.numberKey.pipe(takeUntil(events.line)).forEach(this.onNumberKey.bind(this));
+    events.line
+      .pipe(
+        take(1),
+        map(this.getCurrentValue.bind(this)),
+        flatMap((value) =>
+          runAsync(self.opt.filter)(value, self.answers).catch((err) => err)
+        )
+      )
+      .forEach(this.onSubmit.bind(this));
+
+    // Init the prompt
+    cliCursor.hide();
+    this.render();
+
+    return this;
+  }
+
+  /**
+   * Render the prompt to screen
+   * @return {ListPrompt} self
+   */
+
+  render() {
+    // Render question
+    let message = this.getQuestion();
+
+    if (this.firstRender) {
+      message += chalk.dim('(Use arrow keys)');
+    }
+
+    // Render choices or answer depending on the state
+    if (this.status === 'answered') {
+      message += chalk.cyan(this.opt.choices.getChoice(this.selected).short);
+    } else {
+      const choicesStr = listRender(this.opt.choices, this.selected);
+      const indexPosition = this.opt.choices.indexOf(
+        this.opt.choices.getChoice(this.selected)
+      );
+      const realIndexPosition =
+        this.opt.choices.reduce((acc, value, i) => {
+          // Dont count lines past the choice we are looking at
+          if (i > indexPosition) {
+            return acc;
+          }
+          // Add line if it's a separator
+          if (value.type === 'separator') {
+            return acc + 1;
+          }
+
+          let l = value.name;
+          // Non-strings take up one line
+          if (typeof l !== 'string') {
+            return acc + 1;
+          }
+
+          // Calculate lines taken up by string
+          l = l.split('\n');
+          return acc + l.length;
+        }, 0) - 1;
+      message +=
+        '\n' + this.paginator.paginate(choicesStr, realIndexPosition, this.opt.pageSize);
+    }
+
+    this.firstRender = false;
+
+    this.screen.render(message);
+  }
+
+  /**
+   * When user press `enter` key
+   */
+
+  onSubmit(value) {
+    this.status = 'answered';
+
+    // Rerender prompt
+    this.render();
+
+    this.screen.done();
+    cliCursor.show();
+    this.done(value);
+  }
+
+  getCurrentValue() {
+    return this.opt.choices.getChoice(this.selected).value;
+  }
+
+  /**
+   * When user press a key
+   */
+  onUpKey() {
+    this.selected = incrementListIndex(this.selected, 'up', this.opt);
+    this.render();
+  }
+
+  onDownKey() {
+    this.selected = incrementListIndex(this.selected, 'down', this.opt);
+    this.render();
+  }
+
+  onNumberKey(input) {
+    if (input <= this.opt.choices.realLength) {
+      this.selected = input - 1;
+    }
+
+    this.render();
+  }
+}
+
+/**
+ * Function for rendering list choices
+ * @param  {Number} pointer Position of the pointer
+ * @return {String}         Rendered content
+ */
+function listRender(choices, pointer) {
+  let output = '';
+  let separatorOffset = 0;
+
+  choices.forEach((choice, i) => {
+    if (choice.type === 'separator') {
+      separatorOffset++;
+      output += '  ' + choice + '\n';
+      return;
+    }
+
+    if (choice.disabled) {
+      separatorOffset++;
+      output += '  - ' + choice.name;
+      output += ' (' + (_.isString(choice.disabled) ? choice.disabled : 'Disabled') + ')';
+      output += '\n';
+      return;
+    }
+
+    const isSelected = i - separatorOffset === pointer;
+    let line = (isSelected ? figures.pointer + ' ' : '  ') + choice.name;
+    if (isSelected) {
+      line = chalk.cyan(line);
+    }
+
+    output += line + ' \n';
+  });
+
+  return output.replace(/\n$/, '');
+}
+
+module.exports = ListPrompt;
diff --git a/sandbox/testAppNevena/Front/node_modules/inquirer/lib/prompts/number.js b/sandbox/testAppNevena/Front/node_modules/inquirer/lib/prompts/number.js
new file mode 100644
index 00000000..ccabc018
--- /dev/null
+++ b/sandbox/testAppNevena/Front/node_modules/inquirer/lib/prompts/number.js
@@ -0,0 +1,29 @@
+'use strict';
+/**
+ * `input` type prompt
+ */
+
+const Input = require('./input');
+
+/**
+ * Extention of the Input prompt specifically for use with number inputs.
+ */
+
+class NumberPrompt extends Input {
+  filterInput(input) {
+    if (input && typeof input === 'string') {
+      input = input.trim();
+      // Match a number in the input
+      const numberMatch = input.match(/(^-?\d+|^\d+\.\d*|^\d*\.\d+)(e\d+)?$/);
+      // If a number is found, return that input.
+      if (numberMatch) {
+        return Number(numberMatch[0]);
+      }
+    }
+
+    // If the input was invalid return the default value.
+    return this.opt.default == null ? NaN : this.opt.default;
+  }
+}
+
+module.exports = NumberPrompt;
diff --git a/sandbox/testAppNevena/Front/node_modules/inquirer/lib/prompts/password.js b/sandbox/testAppNevena/Front/node_modules/inquirer/lib/prompts/password.js
new file mode 100644
index 00000000..840249d3
--- /dev/null
+++ b/sandbox/testAppNevena/Front/node_modules/inquirer/lib/prompts/password.js
@@ -0,0 +1,127 @@
+'use strict';
+/**
+ * `password` type prompt
+ */
+
+const chalk = require('chalk');
+const { map, takeUntil } = require('rxjs/operators');
+const Base = require('./base');
+const observe = require('../utils/events');
+
+function mask(input, maskChar) {
+  input = String(input);
+  maskChar = typeof maskChar === 'string' ? maskChar : '*';
+  if (input.length === 0) {
+    return '';
+  }
+
+  return new Array(input.length + 1).join(maskChar);
+}
+
+class PasswordPrompt extends Base {
+  /**
+   * Start the Inquiry session
+   * @param  {Function} cb      Callback when prompt is done
+   * @return {this}
+   */
+
+  _run(cb) {
+    this.done = cb;
+
+    const events = observe(this.rl);
+
+    // Once user confirm (enter key)
+    const submit = events.line.pipe(map(this.filterInput.bind(this)));
+
+    const validation = this.handleSubmitEvents(submit);
+    validation.success.forEach(this.onEnd.bind(this));
+    validation.error.forEach(this.onError.bind(this));
+
+    events.keypress
+      .pipe(takeUntil(validation.success))
+      .forEach(this.onKeypress.bind(this));
+
+    // Init
+    this.render();
+
+    return this;
+  }
+
+  /**
+   * Render the prompt to screen
+   * @return {PasswordPrompt} self
+   */
+
+  render(error) {
+    let message = this.getQuestion();
+    let bottomContent = '';
+
+    if (this.status === 'answered') {
+      message += this.getMaskedValue(this.answer);
+    } else {
+      message += this.getMaskedValue(this.rl.line || '');
+    }
+
+    if (error) {
+      bottomContent = '\n' + chalk.red('>> ') + error;
+    }
+
+    this.screen.render(message, bottomContent);
+  }
+
+  getMaskedValue(value) {
+    if (this.status === 'answered') {
+      return this.opt.mask
+        ? chalk.cyan(mask(value, this.opt.mask))
+        : chalk.italic.dim('[hidden]');
+    }
+    return this.opt.mask
+      ? mask(value, this.opt.mask)
+      : chalk.italic.dim('[input is hidden] ');
+  }
+
+  /**
+   * Mask value during async filter/validation.
+   */
+  getSpinningValue(value) {
+    return this.getMaskedValue(value);
+  }
+
+  /**
+   * When user press `enter` key
+   */
+
+  filterInput(input) {
+    if (!input) {
+      return this.opt.default == null ? '' : this.opt.default;
+    }
+
+    return input;
+  }
+
+  onEnd(state) {
+    this.status = 'answered';
+    this.answer = state.value;
+
+    // Re-render prompt
+    this.render();
+
+    this.screen.done();
+    this.done(state.value);
+  }
+
+  onError(state) {
+    this.render(state.isValid);
+  }
+
+  onKeypress() {
+    // If user press a key, just clear the default value
+    if (this.opt.default) {
+      this.opt.default = undefined;
+    }
+
+    this.render();
+  }
+}
+
+module.exports = PasswordPrompt;
diff --git a/sandbox/testAppNevena/Front/node_modules/inquirer/lib/prompts/rawlist.js b/sandbox/testAppNevena/Front/node_modules/inquirer/lib/prompts/rawlist.js
new file mode 100644
index 00000000..06036eaf
--- /dev/null
+++ b/sandbox/testAppNevena/Front/node_modules/inquirer/lib/prompts/rawlist.js
@@ -0,0 +1,224 @@
+'use strict';
+/**
+ * `rawlist` type prompt
+ */
+
+const _ = {
+  extend: require('lodash/extend'),
+  isNumber: require('lodash/isNumber'),
+  findIndex: require('lodash/findIndex'),
+};
+const chalk = require('chalk');
+const { map, takeUntil } = require('rxjs/operators');
+const Base = require('./base');
+const Separator = require('../objects/separator');
+const observe = require('../utils/events');
+const Paginator = require('../utils/paginator');
+const incrementListIndex = require('../utils/incrementListIndex');
+
+class RawListPrompt extends Base {
+  constructor(questions, rl, answers) {
+    super(questions, rl, answers);
+
+    if (!this.opt.choices) {
+      this.throwParamError('choices');
+    }
+
+    this.opt.validChoices = this.opt.choices.filter(Separator.exclude);
+
+    this.selected = 0;
+    this.rawDefault = 0;
+
+    _.extend(this.opt, {
+      validate(val) {
+        return val != null;
+      },
+    });
+
+    const def = this.opt.default;
+    if (_.isNumber(def) && def >= 0 && def < this.opt.choices.realLength) {
+      this.selected = def;
+      this.rawDefault = def;
+    } else if (!_.isNumber(def) && def != null) {
+      const index = _.findIndex(
+        this.opt.choices.realChoices,
+        ({ value }) => value === def
+      );
+      const safeIndex = Math.max(index, 0);
+      this.selected = safeIndex;
+      this.rawDefault = safeIndex;
+    }
+
+    // Make sure no default is set (so it won't be printed)
+    this.opt.default = null;
+
+    const shouldLoop = this.opt.loop === undefined ? true : this.opt.loop;
+    this.paginator = new Paginator(undefined, { isInfinite: shouldLoop });
+  }
+
+  /**
+   * Start the Inquiry session
+   * @param  {Function} cb      Callback when prompt is done
+   * @return {this}
+   */
+
+  _run(cb) {
+    this.done = cb;
+
+    // Once user confirm (enter key)
+    const events = observe(this.rl);
+    const submit = events.line.pipe(map(this.getCurrentValue.bind(this)));
+
+    const validation = this.handleSubmitEvents(submit);
+    validation.success.forEach(this.onEnd.bind(this));
+    validation.error.forEach(this.onError.bind(this));
+
+    events.normalizedUpKey
+      .pipe(takeUntil(validation.success))
+      .forEach(this.onUpKey.bind(this));
+    events.normalizedDownKey
+      .pipe(takeUntil(validation.success))
+      .forEach(this.onDownKey.bind(this));
+    events.keypress
+      .pipe(takeUntil(validation.success))
+      .forEach(this.onKeypress.bind(this));
+    // Init the prompt
+    this.render();
+
+    return this;
+  }
+
+  /**
+   * Render the prompt to screen
+   * @return {RawListPrompt} self
+   */
+
+  render(error) {
+    // Render question
+    let message = this.getQuestion();
+    let bottomContent = '';
+
+    if (this.status === 'answered') {
+      message += chalk.cyan(this.opt.choices.getChoice(this.selected).short);
+    } else {
+      const choicesStr = renderChoices(this.opt.choices, this.selected);
+      message +=
+        '\n' + this.paginator.paginate(choicesStr, this.selected, this.opt.pageSize);
+      message += '\n  Answer: ';
+    }
+    message += this.rl.line;
+
+    if (error) {
+      bottomContent = '\n' + chalk.red('>> ') + error;
+    }
+
+    this.screen.render(message, bottomContent);
+  }
+
+  /**
+   * When user press `enter` key
+   */
+
+  getCurrentValue(index) {
+    if (index == null) {
+      index = this.rawDefault;
+    } else if (index === '') {
+      this.selected = this.selected === undefined ? -1 : this.selected;
+      index = this.selected;
+    } else {
+      index -= 1;
+    }
+
+    const choice = this.opt.choices.getChoice(index);
+    return choice ? choice.value : null;
+  }
+
+  onEnd(state) {
+    this.status = 'answered';
+    this.answer = state.value;
+
+    // Re-render prompt
+    this.render();
+
+    this.screen.done();
+    this.done(state.value);
+  }
+
+  onError() {
+    this.render('Please enter a valid index');
+  }
+
+  /**
+   * When user press a key
+   */
+
+  onKeypress() {
+    const index = this.rl.line.length ? Number(this.rl.line) - 1 : 0;
+
+    if (this.opt.choices.getChoice(index)) {
+      this.selected = index;
+    } else {
+      this.selected = undefined;
+    }
+    this.render();
+  }
+
+  /**
+   * When user press up key
+   */
+
+  onUpKey() {
+    this.onArrowKey('up');
+  }
+
+  /**
+   * When user press down key
+   */
+
+  onDownKey() {
+    this.onArrowKey('down');
+  }
+
+  /**
+   * When user press up or down key
+   * @param {String} type Arrow type: up or down
+   */
+
+  onArrowKey(type) {
+    this.selected = incrementListIndex(this.selected, type, this.opt);
+    this.rl.line = String(this.selected + 1);
+  }
+}
+
+/**
+ * Function for rendering list choices
+ * @param  {Number} pointer Position of the pointer
+ * @return {String}         Rendered content
+ */
+
+function renderChoices(choices, pointer) {
+  let output = '';
+  let separatorOffset = 0;
+
+  choices.forEach((choice, i) => {
+    output += '\n  ';
+
+    if (choice.type === 'separator') {
+      separatorOffset++;
+      output += ' ' + choice;
+      return;
+    }
+
+    const index = i - separatorOffset;
+    let display = index + 1 + ') ' + choice.name;
+    if (index === pointer) {
+      display = chalk.cyan(display);
+    }
+
+    output += display;
+  });
+
+  return output;
+}
+
+module.exports = RawListPrompt;