jest-watch-typeahead 2.1.0 → 2.1.1

package/build/file_name_plugin/plugin.js

@@ -0,0 +1,49 @@
+import { Prompt } from 'jest-watcher';
+import FileNamePatternPrompt from "./prompt.js";
+export default class FileNamePlugin {
+  constructor({
+    stdin,
+    stdout,
+    config = {}
+  }) {
+    this._stdin = stdin;
+    this._stdout = stdout;
+    this._prompt = new Prompt();
+    this._projects = [];
+    this._usageInfo = {
+      key: config.key || 'p',
+      prompt: config.prompt || 'filter by a filename regex pattern'
+    };
+  }
+
+  apply(jestHooks) {
+    jestHooks.onFileChange(({
+      projects
+    }) => {
+      this._projects = projects;
+    });
+  }
+
+  onKey(key) {
+    this._prompt.put(key);
+  }
+
+  run(globalConfig, updateConfigAndRun) {
+    const p = new FileNamePatternPrompt(this._stdout, this._prompt);
+    p.updateSearchSources(this._projects);
+    return new Promise((res, rej) => {
+      p.run(testPathPattern => {
+        updateConfigAndRun({
+          mode: 'watch',
+          testPathPattern
+        });
+        res();
+      }, rej);
+    });
+  }
+
+  getUsageInfo() {
+    return this._usageInfo;
+  }
+
+}

package/build/file_name_plugin/prompt.js

@@ -0,0 +1,92 @@
+import chalk from 'chalk';
+import ansiEscapes from 'ansi-escapes';
+import stringLength from 'string-length';
+import { PatternPrompt, printPatternCaret, printRestoredPatternCaret } from 'jest-watcher';
+import { escapeStrForRegex } from 'jest-regex-util';
+import { highlight, getTerminalWidth, trimAndFormatPath, removeTrimmingDots } from "../lib/utils.js";
+import { formatTypeaheadSelection, printMore, printPatternMatches, printStartTyping, printTypeaheadItem } from "../lib/pattern_mode_helpers.js";
+import scroll from "../lib/scroll.js";
+export default class FileNamePatternPrompt extends PatternPrompt {
+  constructor(pipe, prompt) {
+    super(pipe, prompt);
+    this._entityName = 'filenames';
+    this._searchSources = [];
+  }
+
+  _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;
+    printPatternCaret(pattern, pipe);
+    pipe.write(ansiEscapes.cursorLeft);
+
+    if (pattern) {
+      printPatternMatches(total, 'file', pipe);
+      const prefix = `  ${chalk.dim('\u203A')} `;
+      const padding = stringLength(prefix) + 2;
+      const width = getTerminalWidth(pipe);
+      const {
+        start,
+        end,
+        index
+      } = scroll(total, options);
+      prompt.setPromptLength(total);
+      matchedTests.slice(start, end).map(({
+        path,
+        context
+      }) => {
+        const filePath = trimAndFormatPath(padding, context.config, path, width);
+        return highlight(path, filePath, pattern);
+      }).map((item, i) => formatTypeaheadSelection(item, i, index, prompt)).forEach(item => printTypeaheadItem(item, pipe));
+
+      if (total > end) {
+        printMore('file', pipe, total - end);
+      }
+    } else {
+      printStartTyping('filename', pipe);
+    }
+
+    printRestoredPatternCaret(pattern, this._currentUsageRows, pipe);
+  }
+
+  _getMatchedTests(pattern) {
+    let regex;
+
+    try {
+      regex = new RegExp(pattern, 'i');
+    } catch (e) {
+      return [];
+    }
+
+    return this._searchSources.reduce((tests, {
+      testPaths,
+      config
+    }) => {
+      return tests.concat(testPaths.filter(testPath => regex.test(testPath)).map(path => ({
+        path,
+        context: {
+          config
+        }
+      })));
+    }, []);
+  }
+
+  updateSearchSources(searchSources) {
+    this._searchSources = searchSources;
+  }
+
+  run(onSuccess, onCancel, options) {
+    super.run(value => {
+      onSuccess(removeTrimmingDots(value).split('/').map(escapeStrForRegex).join('/'));
+    }, onCancel, options);
+  }
+
+}

package/build/index.js

@@ -0,0 +1,8 @@
+throw new Error(`
+jest-watch-typeahead includes two watch plugins: The filename plugin and the testname plugin.
+Please configure Jest as follows:
+"watchPlugins": [
+  "jest-watch-typeahead/filename",
+  "jest-watch-typeahead/testname"
+]
+`);

package/build/lib/pattern_mode_helpers.js

@@ -0,0 +1,27 @@
+import chalk from 'chalk';
+import stripAnsi from 'strip-ansi';
+
+const pluralize = (count, text) => count === 1 ? text : `${text}s`;
+
+export const 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);
+};
+export const printStartTyping = (entity, pipe) => {
+  pipe.write(`\n\n ${chalk.italic.yellow(`Start typing to filter by a ${entity} regex pattern.`)}`);
+};
+export const printMore = (entity, pipe, more) => {
+  pipe.write(`\n   ${chalk.dim(`...and ${more} more ${pluralize(more, entity)}`)}`);
+};
+export const printTypeaheadItem = (item, pipe) => {
+  pipe.write(`\n ${chalk.dim('\u203A')} ${item}`);
+};
+export const formatTypeaheadSelection = (item, index, activeIndex, prompt) => {
+  if (index === activeIndex) {
+    prompt.setPromptSelection(stripAnsi(item));
+    return chalk.black.bgYellow(stripAnsi(item));
+  }
+
+  return item;
+};

package/build/lib/scroll.js

@@ -0,0 +1,26 @@
+const scroll = (size, {
+  offset,
+  max
+}) => {
+  let start = 0;
+  let index = Math.min(offset, size);
+  const halfScreen = max / 2;
+
+  if (index <= halfScreen) {
+    start = 0;
+  } else {
+    if (size >= max) {
+      start = Math.min(index - halfScreen - 1, size - max);
+    }
+
+    index = Math.min(index - start, size);
+  }
+
+  return {
+    end: Math.min(size, start + max),
+    index,
+    start
+  };
+};
+
+export default scroll;

package/build/lib/utils.js

@@ -0,0 +1,126 @@
+import path from 'path';
+import chalk from 'chalk';
+import slash from 'slash';
+import stripAnsi from 'strip-ansi';
+const TRIMMING_DOTS = '...';
+const ENTER = '⏎';
+
+const relativePath = (config, testPath) => {
+  const relativeTestPath = path.relative(config.cwd || config.rootDir, testPath);
+  const dirname = path.dirname(relativeTestPath);
+  const basename = path.basename(relativeTestPath);
+  return {
+    basename,
+    dirname
+  };
+};
+
+const colorize = (str, start, end) => chalk.dim(str.slice(0, start)) + chalk.reset(str.slice(start, end)) + chalk.dim(str.slice(end));
+
+export const trimAndFormatPath = (pad, config, testPath, columns) => {
+  const maxLength = columns - pad;
+  const relative = relativePath(config, testPath);
+  const {
+    basename
+  } = relative;
+  let {
+    dirname
+  } = relative; // length is ok
+
+  if ((dirname + path.sep + basename).length <= maxLength) {
+    return slash(chalk.dim(dirname + path.sep) + chalk.bold(basename));
+  } // we can fit trimmed dirname and full basename
+
+
+  const basenameLength = basename.length;
+
+  if (basenameLength + 4 < maxLength) {
+    const dirnameLength = maxLength - 4 - basenameLength;
+    dirname = `${TRIMMING_DOTS}${dirname.slice(dirname.length - dirnameLength, dirname.length)}`;
+    return slash(chalk.dim(dirname + path.sep) + chalk.bold(basename));
+  }
+
+  if (basenameLength + 4 === maxLength) {
+    return slash(chalk.dim(`${TRIMMING_DOTS}${path.sep}`) + chalk.bold(basename));
+  } // can't fit dirname, but can fit trimmed basename
+
+
+  return slash(chalk.bold(`${TRIMMING_DOTS}${basename.slice(-maxLength + 3)}`));
+};
+export const getTerminalWidth = (pipe = process.stdout) => pipe.columns;
+export const highlight = (rawPath, filePath, pattern) => {
+  const relativePathHead = './';
+  let regexp;
+
+  try {
+    regexp = new RegExp(pattern, 'i');
+  } catch (e) {
+    return chalk.dim(filePath);
+  }
+
+  const strippedRawPath = stripAnsi(rawPath);
+  const strippedFilePath = stripAnsi(filePath);
+  const match = strippedRawPath.match(regexp);
+
+  if (!match || match.index == null) {
+    return chalk.dim(strippedFilePath);
+  }
+
+  const offset = strippedRawPath.length - strippedFilePath.length;
+  let trimLength;
+
+  if (strippedFilePath.startsWith(TRIMMING_DOTS)) {
+    trimLength = TRIMMING_DOTS.length;
+  } else if (strippedFilePath.startsWith(relativePathHead)) {
+    trimLength = relativePathHead.length;
+  } else {
+    trimLength = 0;
+  }
+
+  const start = match.index - offset;
+  const end = start + match[0].length;
+  return colorize(strippedFilePath, Math.max(start, 0), Math.max(end, trimLength));
+};
+export 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 chalk.dim(inlineTestName);
+  }
+
+  const match = inlineTestName.match(regexp);
+
+  if (!match || match.index == null) {
+    return chalk.dim(inlineTestName);
+  }
+
+  const startPatternIndex = Math.max(match.index, 0);
+  const endPatternIndex = startPatternIndex + match[0].length;
+  const testNameFitsInTerminal = inlineTestName.length <= width;
+
+  if (testNameFitsInTerminal) {
+    return colorize(inlineTestName, startPatternIndex, endPatternIndex);
+  }
+
+  const numberOfTruncatedChars = TRIMMING_DOTS.length + inlineTestName.length - width;
+  const end = Math.max(endPatternIndex - numberOfTruncatedChars, 0);
+  const truncatedTestName = inlineTestName.slice(numberOfTruncatedChars);
+  const shouldHighlightDots = startPatternIndex <= numberOfTruncatedChars;
+
+  if (shouldHighlightDots) {
+    return colorize(TRIMMING_DOTS + truncatedTestName, 0, end + TRIMMING_DOTS.length);
+  }
+
+  const start = startPatternIndex - numberOfTruncatedChars;
+  return colorize(TRIMMING_DOTS + truncatedTestName, start + TRIMMING_DOTS.length, end + TRIMMING_DOTS.length);
+};
+export const removeTrimmingDots = value => {
+  if (value.startsWith(TRIMMING_DOTS)) {
+    return value.slice(TRIMMING_DOTS.length);
+  }
+
+  return value;
+};

package/build/test_name_plugin/plugin.js

@@ -0,0 +1,49 @@
+import { Prompt } from 'jest-watcher';
+import TestNamePatternPrompt from "./prompt.js";
+export default class TestNamePlugin {
+  constructor({
+    stdin,
+    stdout,
+    config = {}
+  }) {
+    this._stdin = stdin;
+    this._stdout = stdout;
+    this._prompt = new 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 TestNamePatternPrompt(this._stdout, this._prompt);
+    p.updateCachedTestResults(this._testResults);
+    return new Promise((res, rej) => {
+      p.run(testNamePattern => {
+        updateConfigAndRun({
+          mode: 'watch',
+          testNamePattern
+        });
+        res();
+      }, rej);
+    });
+  }
+
+  getUsageInfo() {
+    return this._usageInfo;
+  }
+
+}

package/build/test_name_plugin/prompt.js

@@ -0,0 +1,86 @@
+import chalk from 'chalk';
+import ansiEscapes from 'ansi-escapes';
+import { PatternPrompt, printPatternCaret, printRestoredPatternCaret } from 'jest-watcher';
+import { escapeStrForRegex } from 'jest-regex-util';
+import scroll from "../lib/scroll.js";
+import { formatTestNameByPattern, getTerminalWidth, removeTrimmingDots } from "../lib/utils.js";
+import { formatTypeaheadSelection, printMore, printPatternMatches, printStartTyping, printTypeaheadItem } from "../lib/pattern_mode_helpers.js";
+export default class TestNamePatternPrompt extends PatternPrompt {
+  constructor(pipe, prompt) {
+    super(pipe, prompt);
+    this._entityName = 'tests';
+    this._cachedTestResults = [];
+    this._offset = -1;
+  }
+
+  _onChange(pattern, options) {
+    super._onChange(pattern, options);
+
+    this._offset = options.offset;
+
+    this._printTypeahead(pattern, options);
+  }
+
+  _printTypeahead(pattern, options) {
+    const matchedTests = this._getMatchedTests(pattern);
+
+    const total = matchedTests.length;
+    const pipe = this._pipe;
+    const prompt = this._prompt;
+    printPatternCaret(pattern, pipe);
+    pipe.write(ansiEscapes.cursorLeft);
+
+    if (pattern) {
+      printPatternMatches(total, 'test', pipe, ` from ${chalk.yellow('cached')} test suites`);
+      const width = getTerminalWidth(pipe);
+      const {
+        start,
+        end,
+        index
+      } = scroll(total, options);
+      prompt.setPromptLength(total);
+      matchedTests.slice(start, end).map(name => formatTestNameByPattern(name, pattern, width - 4)).map((item, i) => formatTypeaheadSelection(item, i, index, prompt)).forEach(item => printTypeaheadItem(item, pipe));
+
+      if (total > end) {
+        printMore('test', pipe, total - end);
+      }
+    } else {
+      printStartTyping('test name', pipe);
+    }
+
+    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(({
+        fullName
+      }) => regex.test(fullName)).map(({
+        fullName
+      }) => fullName));
+    }, []);
+  }
+
+  updateCachedTestResults(testResults = []) {
+    this._cachedTestResults = testResults;
+  }
+
+  run(onSuccess, onCancel, options) {
+    super.run(value => {
+      const preparedPattern = escapeStrForRegex(removeTrimmingDots(value));
+      const useExactMatch = this._offset !== -1;
+      onSuccess(useExactMatch ? `^${preparedPattern}$` : preparedPattern);
+    }, onCancel, options);
+  }
+
+}

package/build/types/Config.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jest-watch-typeahead",
-  "version": "2.1.0",
+  "version": "2.1.1",
   "main": "build/index.js",
   "exports": {
     ".": "./build/index.js",
@@ -26,8 +26,8 @@
     "test": "cross-env NODE_OPTIONS=\"--experimental-vm-modules\" jest",
     "lint": "eslint .",
     "prebuild": "rimraf build",
-    "build": "babel --extensions .js,.ts src -d build && rimraf **/*.test.{js,ts},integration build/**/__tests__ build/test_utils",
-    "prepublish": "yarn build",
+    "build": "babel --extensions .js,.ts src -d build && rimraf 'build/**/*.test.{js,ts},integration' 'build/**/__tests__' build/test_utils",
+    "prepack": "yarn build",
     "format": "prettier --write \"**/*.js\" \"**/*.md\" \"**/*.ts\"",
     "typecheck": "yarn tsc -p ."
   },