jest-watch-typeahead 0.1.0-2 → 0.2.1

package/build/lib/utils.js

@@ -1,95 +1,90 @@
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.formatTestNameByPattern = exports.highlight = exports.getTerminalWidth = exports.trimAndFormatPath = undefined;
+exports.formatTestNameByPattern = exports.highlight = exports.getTerminalWidth = exports.trimAndFormatPath = void 0;
 
-var _path = require('path');
+var _path = _interopRequireDefault(require("path"));
 
-var _path2 = _interopRequireDefault(_path);
+var _chalk = _interopRequireDefault(require("chalk"));
 
-var _chalk = require('chalk');
+var _slash = _interopRequireDefault(require("slash"));
 
-var _chalk2 = _interopRequireDefault(_chalk);
+var _stripAnsi = _interopRequireDefault(require("strip-ansi"));
 
-var _slash = require('slash');
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var _slash2 = _interopRequireDefault(_slash);
+/* eslint-disable no-param-reassign */
+const relativePath = (config, testPath) => {
+  testPath = _path.default.relative(config.cwd || config.rootDir, testPath);
 
-var _stripAnsi = require('strip-ansi');
+  const dirname = _path.default.dirname(testPath);
 
-var _stripAnsi2 = _interopRequireDefault(_stripAnsi);
+  const basename = _path.default.basename(testPath);
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/* eslint-disable no-param-reassign */
-var relativePath = function relativePath(config, testPath) {
-  testPath = _path2.default.relative(config.cwd || config.rootDir, testPath);
-  var dirname = _path2.default.dirname(testPath);
-  var basename = _path2.default.basename(testPath);
-  return { basename, dirname };
+  return {
+    basename,
+    dirname
+  };
 };
 
-var colorize = function colorize(str, start, end) {
-  return _chalk2.default.dim(str.slice(0, start)) + _chalk2.default.reset(str.slice(start, end)) + _chalk2.default.dim(str.slice(end));
-};
+const colorize = (str, start, end) => _chalk.default.dim(str.slice(0, start)) + _chalk.default.reset(str.slice(start, end)) + _chalk.default.dim(str.slice(end));
 
-var trimAndFormatPath = exports.trimAndFormatPath = function trimAndFormatPath(pad, config, testPath, columns) {
-  var maxLength = columns - pad;
-  var relative = relativePath(config, testPath);
-  var basename = relative.basename;
-  var dirname = relative.dirname;
+const trimAndFormatPath = (pad, config, testPath, columns) => {
+  const maxLength = columns - pad;
+  const relative = relativePath(config, testPath);
+  const basename = relative.basename;
+  let dirname = relative.dirname; // length is ok
 
-  // length is ok
+  if ((dirname + _path.default.sep + basename).length <= maxLength) {
+    return (0, _slash.default)(_chalk.default.dim(dirname + _path.default.sep) + _chalk.default.bold(basename));
+  } // we can fit trimmed dirname and full basename
 
-  if ((dirname + _path2.default.sep + basename).length <= maxLength) {
-    return (0, _slash2.default)(_chalk2.default.dim(dirname + _path2.default.sep) + _chalk2.default.bold(basename));
-  }
 
-  // we can fit trimmed dirname and full basename
-  var basenameLength = basename.length;
+  const basenameLength = basename.length;
+
   if (basenameLength + 4 < maxLength) {
-    var dirnameLength = maxLength - 4 - basenameLength;
+    const dirnameLength = maxLength - 4 - basenameLength;
     dirname = `...${dirname.slice(dirname.length - dirnameLength, dirname.length)}`;
-    return (0, _slash2.default)(_chalk2.default.dim(dirname + _path2.default.sep) + _chalk2.default.bold(basename));
+    return (0, _slash.default)(_chalk.default.dim(dirname + _path.default.sep) + _chalk.default.bold(basename));
   }
 
   if (basenameLength + 4 === maxLength) {
-    return (0, _slash2.default)(_chalk2.default.dim(`...${_path2.default.sep}`) + _chalk2.default.bold(basename));
-  }
+    return (0, _slash.default)(_chalk.default.dim(`...${_path.default.sep}`) + _chalk.default.bold(basename));
+  } // can't fit dirname, but can fit trimmed basename
 
-  // can't fit dirname, but can fit trimmed basename
-  return (0, _slash2.default)(_chalk2.default.bold(`...${basename.slice(basename.length - maxLength - 4, basename.length)}`));
-};
 
-// $FlowFixMe
-var getTerminalWidth = exports.getTerminalWidth = function getTerminalWidth() {
-  return process.stdout.columns;
+  return (0, _slash.default)(_chalk.default.bold(`...${basename.slice(basename.length - maxLength - 4, basename.length)}`));
 };
 
-var highlight = exports.highlight = function highlight(rawPath, filePath, pattern, rootDir) {
-  var trim = '...';
-  var relativePathHead = './';
+exports.trimAndFormatPath = trimAndFormatPath;
+
+const getTerminalWidth = (pipe = process.stdout) => pipe.columns;
+
+exports.getTerminalWidth = getTerminalWidth;
 
-  var regexp = void 0;
+const highlight = (rawPath, filePath, pattern, rootDir) => {
+  const trim = '...';
+  const relativePathHead = './';
+  let regexp;
 
   try {
     regexp = new RegExp(pattern, 'i');
   } catch (e) {
-    return _chalk2.default.dim(filePath);
+    return _chalk.default.dim(filePath);
   }
 
-  rawPath = (0, _stripAnsi2.default)(rawPath);
-  filePath = (0, _stripAnsi2.default)(filePath);
-  var match = rawPath.match(regexp);
+  rawPath = (0, _stripAnsi.default)(rawPath);
+  filePath = (0, _stripAnsi.default)(filePath);
+  const match = rawPath.match(regexp);
 
   if (!match) {
-    return _chalk2.default.dim(filePath);
+    return _chalk.default.dim(filePath);
   }
 
-  var offset = void 0;
-  var trimLength = void 0;
+  let offset;
+  let trimLength;
 
   if (filePath.startsWith(trim)) {
     offset = rawPath.length - filePath.length;
@@ -98,51 +93,54 @@ var highlight = exports.highlight = function highlight(rawPath, filePath, patter
     offset = rawPath.length - filePath.length;
     trimLength = relativePathHead.length;
   } else {
-    offset = rootDir.length + _path2.default.sep.length;
+    offset = rootDir.length + _path.default.sep.length;
     trimLength = 0;
   }
 
-  var start = match.index - offset;
-  var end = start + match[0].length;
+  const start = match.index - offset;
+  const end = start + match[0].length;
   return colorize(filePath, Math.max(start, 0), Math.max(end, trimLength));
 };
 
-var DOTS = '...';
-var ENTER = '⏎';
+exports.highlight = highlight;
+const DOTS = '...';
+const ENTER = '⏎';
 
-var formatTestNameByPattern = exports.formatTestNameByPattern = function formatTestNameByPattern(testName, pattern, width) {
-  var inlineTestName = testName.replace(/(\r\n|\n|\r)/gm, ENTER);
-
-  var regexp = void 0;
+const formatTestNameByPattern = (testName, pattern, width) => {
+  const inlineTestName = testName.replace(/(\r\n|\n|\r)/gm, ENTER);
+  let regexp;
 
   try {
     regexp = new RegExp(pattern, 'i');
   } catch (e) {
-    return _chalk2.default.dim(inlineTestName);
+    return _chalk.default.dim(inlineTestName);
   }
 
-  var match = inlineTestName.match(regexp);
+  const match = inlineTestName.match(regexp);
 
   if (!match) {
-    return _chalk2.default.dim(inlineTestName);
-  }
+    return _chalk.default.dim(inlineTestName);
+  } // $FlowFixMe
 
-  // $FlowFixMe
-  var startPatternIndex = Math.max(match.index, 0);
-  var endPatternIndex = startPatternIndex + match[0].length;
+
+  const startPatternIndex = Math.max(match.index, 0);
+  const endPatternIndex = startPatternIndex + match[0].length;
 
   if (inlineTestName.length <= width) {
     return colorize(inlineTestName, startPatternIndex, endPatternIndex);
   }
 
-  var slicedTestName = inlineTestName.slice(0, width - DOTS.length);
+  const slicedTestName = inlineTestName.slice(0, width - DOTS.length);
 
   if (startPatternIndex < slicedTestName.length) {
     if (endPatternIndex > slicedTestName.length) {
       return colorize(slicedTestName + DOTS, startPatternIndex, slicedTestName.length + DOTS.length);
     }
+
     return colorize(slicedTestName + DOTS, Math.min(startPatternIndex, slicedTestName.length), endPatternIndex);
   }
 
-  return `${_chalk2.default.dim(slicedTestName)}${_chalk2.default.reset(DOTS)}`;
-};
+  return `${_chalk.default.dim(slicedTestName)}${_chalk.default.reset(DOTS)}`;
+};
+
+exports.formatTestNameByPattern = formatTestNameByPattern;

package/build/shared/pattern_mode_helpers.js

@@ -3,73 +3,42 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.formatTypeaheadSelection = exports.printTypeaheadItem = exports.printMore = exports.printStartTyping = exports.printRestoredPatternCaret = exports.printPatternCaret = exports.printPatternMatches = undefined;
+exports.formatTypeaheadSelection = exports.printTypeaheadItem = exports.printMore = exports.printStartTyping = exports.printPatternMatches = undefined;
 
 var _chalk = require('chalk');
 
 var _chalk2 = _interopRequireDefault(_chalk);
 
-var _ansiEscapes = require('ansi-escapes');
-
-var _ansiEscapes2 = _interopRequireDefault(_ansiEscapes);
-
-var _stringLength = require('string-length');
-
-var _stringLength2 = _interopRequireDefault(_stringLength);
-
 var _stripAnsi = require('strip-ansi');
 
 var _stripAnsi2 = _interopRequireDefault(_stripAnsi);
 
-var _Prompt = require('../shared/Prompt');
-
-var _Prompt2 = _interopRequireDefault(_Prompt);
+var _jestWatcher = require('jest-watcher');
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var pluralize = function pluralize(count, text) {
-  return count === 1 ? text : `${text}s`;
-};
-
-var printPatternMatches = exports.printPatternMatches = function printPatternMatches(count, entity, pipe) {
-  var extraText = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '';
+const pluralize = (count, text) => count === 1 ? text : `${text}s`;
 
-  var pluralized = pluralize(count, entity);
-  var result = count ? `\n\n Pattern matches ${count} ${pluralized}` : `\n\n Pattern matches no ${pluralized}`;
+const printPatternMatches = exports.printPatternMatches = (count, entity, pipe, extraText = '') => {
+  const pluralized = pluralize(count, entity);
+  const result = count ? `\n\n Pattern matches ${count} ${pluralized}` : `\n\n Pattern matches no ${pluralized}`;
 
   pipe.write(result + extraText);
 };
 
-var printPatternCaret = exports.printPatternCaret = function printPatternCaret(pattern, pipe) {
-  var inputText = `${_chalk2.default.dim(' pattern \u203A')} ${pattern}`;
-
-  pipe.write(_ansiEscapes2.default.eraseDown);
-  pipe.write(inputText);
-  pipe.write(_ansiEscapes2.default.cursorSavePosition);
-};
-
-var printRestoredPatternCaret = exports.printRestoredPatternCaret = function printRestoredPatternCaret(pattern, currentUsageRows, pipe) {
-  var inputText = `${_chalk2.default.dim(' pattern \u203A')} ${pattern}`;
-
-  pipe.write(_ansiEscapes2.default.cursorTo((0, _stringLength2.default)(inputText), currentUsageRows - 1));
-  pipe.write(_ansiEscapes2.default.cursorRestorePosition);
-};
-
-var printStartTyping = exports.printStartTyping = function printStartTyping(entity, pipe) {
+const printStartTyping = exports.printStartTyping = (entity, pipe) => {
   pipe.write(`\n\n ${_chalk2.default.italic.yellow(`Start typing to filter by a ${entity} regex pattern.`)}`);
 };
 
-var printMore = exports.printMore = function printMore(entity, pipe, more) {
+const printMore = exports.printMore = (entity, pipe, more) => {
   pipe.write(`\n   ${_chalk2.default.dim(`...and ${more} more ${pluralize(more, entity)}`)}`);
 };
 
-var printTypeaheadItem = exports.printTypeaheadItem = function printTypeaheadItem(item, pipe) {
-  return pipe.write(`\n ${_chalk2.default.dim('\u203A')} ${item}`);
-};
+const printTypeaheadItem = exports.printTypeaheadItem = (item, pipe) => pipe.write(`\n ${_chalk2.default.dim('\u203A')} ${item}`);
 
-var formatTypeaheadSelection = exports.formatTypeaheadSelection = function formatTypeaheadSelection(item, index, activeIndex, prompt) {
+const formatTypeaheadSelection = exports.formatTypeaheadSelection = (item, index, activeIndex, prompt) => {
   if (index === activeIndex) {
-    prompt.setTypheadheadSelection((0, _stripAnsi2.default)(item));
+    prompt.setPromptSelection((0, _stripAnsi2.default)(item));
     return _chalk2.default.black.bgYellow((0, _stripAnsi2.default)(item));
   }
   return item;

package/build/shared/scroll.js

@@ -5,14 +5,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 
 
-var scroll = function scroll(size, _ref) {
-  var offset = _ref.offset,
-      max = _ref.max;
+const scroll = (size, { offset, max }) => {
+  let start = 0;
+  let index = Math.min(offset, size);
 
-  var start = 0;
-  var index = Math.min(offset, size);
-
-  var halfScreen = max / 2;
+  const halfScreen = max / 2;
 
   if (index <= halfScreen) {
     start = 0;

package/build/test_name_pattern_prompt.js

@@ -1,131 +1,91 @@
 'use strict';
 
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
-
 var _chalk = require('chalk');
 
 var _chalk2 = _interopRequireDefault(_chalk);
 
+var _jestWatcher = require('jest-watcher');
+
 var _scroll2 = require('./shared/scroll');
 
 var _scroll3 = _interopRequireDefault(_scroll2);
 
 var _utils = require('./lib/utils');
 
-var _Prompt = require('./shared/Prompt');
-
-var _Prompt2 = _interopRequireDefault(_Prompt);
-
 var _pattern_mode_helpers = require('./shared/pattern_mode_helpers');
 
-var _pattern_prompt = require('./shared/pattern_prompt');
-
-var _pattern_prompt2 = _interopRequireDefault(_pattern_prompt);
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+class TestNamePatternPrompt extends _jestWatcher.PatternPrompt {
 
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+  constructor(pipe, prompt) {
+    super(pipe, prompt);
+    this._entityName = 'tests';
+    this._cachedTestResults = [];
+  }
 
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+  _onChange(pattern, options) {
+    super._onChange(pattern, options);
+    this._printTypeahead(pattern, options);
+  }
 
-var TestNamePatternPrompt = function (_PatternPrompt) {
-  _inherits(TestNamePatternPrompt, _PatternPrompt);
+  _printTypeahead(pattern, options) {
+    const matchedTests = this._getMatchedTests(pattern);
+    const total = matchedTests.length;
+    const pipe = this._pipe;
+    const prompt = this._prompt;
 
-  function TestNamePatternPrompt(pipe, prompt) {
-    _classCallCheck(this, TestNamePatternPrompt);
+    (0, _jestWatcher.printPatternCaret)(pattern, pipe);
 
-    var _this = _possibleConstructorReturn(this, (TestNamePatternPrompt.__proto__ || Object.getPrototypeOf(TestNamePatternPrompt)).call(this, pipe, prompt));
+    if (pattern) {
+      (0, _pattern_mode_helpers.printPatternMatches)(total, 'test', pipe, ` from ${_chalk2.default.yellow('cached')} test suites`);
 
-    _this._entityName = 'tests';
-    _this._cachedTestResults = [];
-    return _this;
-  }
+      const width = (0, _utils.getTerminalWidth)();
 
-  _createClass(TestNamePatternPrompt, [{
-    key: '_onChange',
-    value: function _onChange(pattern, options) {
-      _get(TestNamePatternPrompt.prototype.__proto__ || Object.getPrototypeOf(TestNamePatternPrompt.prototype), '_onChange', this).call(this, pattern, options);
-      this._printTypeahead(pattern, options);
-    }
-  }, {
-    key: '_printTypeahead',
-    value: function _printTypeahead(pattern, options) {
-      var matchedTests = this._getMatchedTests(pattern);
-      var total = matchedTests.length;
-      var pipe = this._pipe;
-      var prompt = this._prompt;
+      var _scroll = (0, _scroll3.default)(total, options);
 
-      (0, _pattern_mode_helpers.printPatternCaret)(pattern, pipe);
+      const start = _scroll.start,
+            end = _scroll.end,
+            index = _scroll.index;
 
-      if (pattern) {
-        (0, _pattern_mode_helpers.printPatternMatches)(total, 'test', pipe, ` from ${_chalk2.default.yellow('cached')} test suites`);
 
-        var width = (0, _utils.getTerminalWidth)();
+      prompt.setPromptLength(total);
 
-        var _scroll = (0, _scroll3.default)(total, options),
-            start = _scroll.start,
-            end = _scroll.end,
-            index = _scroll.index;
+      matchedTests.slice(start, end).map(name => (0, _utils.formatTestNameByPattern)(name, pattern, width - 4)).map((item, i) => (0, _pattern_mode_helpers.formatTypeaheadSelection)(item, i, index, prompt)).forEach(item => (0, _pattern_mode_helpers.printTypeaheadItem)(item, pipe));
 
-        prompt.setTypeaheadLength(total);
-
-        matchedTests.slice(start, end).map(function (name) {
-          return (0, _utils.formatTestNameByPattern)(name, pattern, width - 4);
-        }).map(function (item, i) {
-          return (0, _pattern_mode_helpers.formatTypeaheadSelection)(item, i, index, prompt);
-        }).forEach(function (item) {
-          return (0, _pattern_mode_helpers.printTypeaheadItem)(item, pipe);
-        });
-
-        if (total > end) {
-          (0, _pattern_mode_helpers.printMore)('test', pipe, total - end);
-        }
-      } else {
-        (0, _pattern_mode_helpers.printStartTyping)('test name', pipe);
+      if (total > end) {
+        (0, _pattern_mode_helpers.printMore)('test', pipe, total - end);
       }
-
-      (0, _pattern_mode_helpers.printRestoredPatternCaret)(pattern, this._currentUsageRows, pipe);
+    } else {
+      (0, _pattern_mode_helpers.printStartTyping)('test name', pipe);
     }
-  }, {
-    key: '_getMatchedTests',
-    value: function _getMatchedTests(pattern) {
-      var regex = void 0;
-
-      try {
-        regex = new RegExp(pattern, 'i');
-      } catch (e) {
-        return [];
-      }
-
-      var matchedTests = [];
 
-      this._cachedTestResults.forEach(function (_ref) {
-        var testResults = _ref.testResults;
-        return testResults.forEach(function (_ref2) {
-          var title = _ref2.title;
+    (0, _jestWatcher.printRestoredPatternCaret)(pattern, this._currentUsageRows, pipe);
+  }
 
-          if (regex.test(title)) {
-            matchedTests.push(title);
-          }
-        });
-      });
+  _getMatchedTests(pattern) {
+    let regex;
 
-      return matchedTests;
+    try {
+      regex = new RegExp(pattern, 'i');
+    } catch (e) {
+      return [];
     }
-  }, {
-    key: 'updateCachedTestResults',
-    value: function updateCachedTestResults() {
-      var testResults = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
 
-      this._cachedTestResults = testResults;
-    }
-  }]);
+    const matchedTests = [];
+
+    this._cachedTestResults.forEach(({ testResults }) => testResults.forEach(({ title }) => {
+      if (regex.test(title)) {
+        matchedTests.push(title);
+      }
+    }));
 
-  return TestNamePatternPrompt;
-}(_pattern_prompt2.default);
+    return matchedTests;
+  }
+
+  updateCachedTestResults(testResults = []) {
+    this._cachedTestResults = testResults;
+  }
+}
 
 module.exports = TestNamePatternPrompt;

package/build/test_name_plugin/plugin.js

@@ -0,0 +1,57 @@
+"use strict";
+
+var _jestWatcher = require("jest-watcher");
+
+var _prompt = _interopRequireDefault(require("./prompt"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class TestNamePlugin {
+  constructor({
+    stdin,
+    stdout,
+    config = {}
+  }) {
+    this._stdin = stdin;
+    this._stdout = stdout;
+    this._prompt = new _jestWatcher.Prompt();
+    this._testResults = [];
+    this._usageInfo = {
+      key: config.key || 't',
+      prompt: config.prompt || 'filter by a test name regex pattern'
+    };
+  }
+
+  apply(jestHooks) {
+    jestHooks.onTestRunComplete(({
+      testResults
+    }) => {
+      this._testResults = testResults;
+    });
+  }
+
+  onKey(key) {
+    this._prompt.put(key);
+  }
+
+  run(globalConfig, updateConfigAndRun) {
+    const p = new _prompt.default(this._stdout, this._prompt);
+    p.updateCachedTestResults(this._testResults);
+    return new Promise((res, rej) => {
+      p.run(value => {
+        updateConfigAndRun({
+          mode: 'watch',
+          testNamePattern: value
+        });
+        res();
+      }, rej);
+    });
+  }
+
+  getUsageInfo() {
+    return this._usageInfo;
+  }
+
+}
+
+module.exports = TestNamePlugin;

package/build/test_name_plugin/prompt.js

@@ -0,0 +1,87 @@
+"use strict";
+
+var _chalk = _interopRequireDefault(require("chalk"));
+
+var _ansiEscapes = _interopRequireDefault(require("ansi-escapes"));
+
+var _jestWatcher = require("jest-watcher");
+
+var _scroll2 = _interopRequireDefault(require("../lib/scroll"));
+
+var _utils = require("../lib/utils");
+
+var _pattern_mode_helpers = require("../lib/pattern_mode_helpers");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class TestNamePatternPrompt extends _jestWatcher.PatternPrompt {
+  constructor(pipe, prompt) {
+    super(pipe, prompt);
+    this._entityName = 'tests';
+    this._cachedTestResults = [];
+  }
+
+  _onChange(pattern, options) {
+    super._onChange(pattern, options);
+
+    this._printTypeahead(pattern, options);
+  }
+
+  _printTypeahead(pattern, options) {
+    const matchedTests = this._getMatchedTests(pattern);
+
+    const total = matchedTests.length;
+    const pipe = this._pipe;
+    const prompt = this._prompt;
+    (0, _jestWatcher.printPatternCaret)(pattern, pipe);
+    pipe.write(_ansiEscapes.default.cursorLeft);
+
+    if (pattern) {
+      (0, _pattern_mode_helpers.printPatternMatches)(total, 'test', pipe, ` from ${_chalk.default.yellow('cached')} test suites`);
+      const width = (0, _utils.getTerminalWidth)(pipe);
+
+      const _scroll = (0, _scroll2.default)(total, options),
+            start = _scroll.start,
+            end = _scroll.end,
+            index = _scroll.index;
+
+      prompt.setPromptLength(total);
+      matchedTests.slice(start, end).map(name => (0, _utils.formatTestNameByPattern)(name, pattern, width - 4)).map((item, i) => (0, _pattern_mode_helpers.formatTypeaheadSelection)(item, i, index, prompt)).forEach(item => (0, _pattern_mode_helpers.printTypeaheadItem)(item, pipe));
+
+      if (total > end) {
+        (0, _pattern_mode_helpers.printMore)('test', pipe, total - end);
+      }
+    } else {
+      (0, _pattern_mode_helpers.printStartTyping)('test name', pipe);
+    }
+
+    (0, _jestWatcher.printRestoredPatternCaret)(pattern, this._currentUsageRows, pipe);
+  }
+
+  _getMatchedTests(pattern) {
+    let regex;
+
+    try {
+      regex = new RegExp(pattern, 'i');
+    } catch (e) {
+      return [];
+    }
+
+    return this._cachedTestResults.reduce((matchedTests, {
+      testResults
+    }) => {
+      return matchedTests.concat(testResults.filter(({
+        title
+      }) => regex.test(title)).map(({
+        title
+      }) => title));
+    }, []);
+  }
+
+  updateCachedTestResults(testResults = []) {
+    this._cachedTestResults = testResults;
+  }
+
+}
+
+module.exports = TestNamePatternPrompt;