feat: added typing event and better types

Author: crutchcorn

src/__tests__/execute-scripts/stdio-inquirer-input.js

@@ -0,0 +1,10 @@
+const inquirer = require('inquirer')
+
+inquirer
+  .prompt([
+      {
+          type: "input",
+          name: "name",
+          message: "What is your name?",
+      },
+  ]);

src/__tests__/render-basics.js

@@ -1,7 +1,7 @@
 const {resolve} = require('path')
+const isRunning = require('is-running')
 const {render} = require('../pure')
 const {fireEvent} = require('../events')
-const isRunning = require('is-running')
 const {waitFor} = require("../wait-for");
 
 test('Should handle stderr outputs with rejection', async () => {
@@ -69,7 +69,6 @@ test('fireEvent works when bound', async () => {
   cleanup();
 })
 
-
 test('SigTerm works', async () => {
   const {findByText, cleanup} = await render('node', [
     resolve(__dirname, './execute-scripts/stdio-inquirer.js'),
@@ -86,3 +85,19 @@ test('SigTerm works', async () => {
   await waitFor(() => expect(isRunning(instance.pid)).toBeFalsy())
 })
 
+test('input works', async () => {
+  const {findByText, fireEvent: fireEventLocal, cleanup} = await render('node', [
+    resolve(__dirname, './execute-scripts/stdio-inquirer-input.js'),
+  ])
+
+  expect(await findByText('What is your name?')).toBeTruthy()
+
+  fireEventLocal.type("Corbin");
+
+  expect(await findByText('Corbin')).toBeTruthy()
+
+  fireEventLocal.enter();
+
+  cleanup()
+})
+

src/event-map.js

@@ -0,0 +1,14 @@
+import kill from 'tree-kill';
+
+import {TestInstance} from "../types/pure";
+
+const eventMap = {
+  down: (instance: TestInstance) => instance.stdin.write('\x1B\x5B\x42'),
+  up: (instance: TestInstance) => instance.stdin.write('\x1B\x5B\x41'),
+  enter: (instance: TestInstance) => instance.stdin.write('\x0D'),
+  sigterm: (instance: TestInstance) => instance.pid && kill(instance.pid),
+  sigkill: (instance: TestInstance) => instance.pid && kill(instance.pid, 'SIGKILL'),
+  type: (instance: TestInstance, text: string) => instance.stdin.write(text)
+}
+
+export {eventMap}

src/event-map.ts

@@ -0,0 +1,24 @@
+import {eventMap} from './event-map'
+
+const fireEvent = Object.entries(eventMap).reduce(
+  (prev, [eventName, eventFn]) => {
+    prev[eventName] = ((instance, ...props) => {
+        eventFn(instance, ...(props))
+    })
+    return prev
+  },
+  {}
+)
+
+function getFireEventForElement (
+    instance
+) {
+    return {
+        fireEvent: Object.entries(fireEvent).reduce((prev, [eventName, eventFn]) => {
+            prev[eventName] = (...props) => eventFn(instance, ...(props))
+            return prev;
+        }, {})
+    }
+}
+
+export {fireEvent, getFireEventForElement}

src/events.js

@@ -6,7 +6,7 @@
  */
 import childProcess from 'child_process'
 import stripFinalNewline from 'strip-final-newline'
-import {RenderOptions, TestInstance} from '../types/pure'
+import {RenderOptions, RenderResult, TestInstance} from '../types/pure'
 import {_runObservers} from './mutation-observer'
 import {getQueriesForElement} from './get-queries-for-instance'
 import {getFireEventForElement} from './events'
@@ -16,7 +16,7 @@ async function render(
   command: string,
   args: string[] = [],
   opts: Partial<RenderOptions> = {},
-): Promise<TestInstance> {
+): Promise<RenderResult> {
   const {cwd = __dirname} = opts
 
   const exec = childProcess.spawn(command, args, {
@@ -88,8 +88,8 @@ async function render(
       pid: exec.pid
     },
     getQueriesForElement(execOutputAPI),
-    getFireEventForElement(execOutputAPI as unknown as TestInstance)
-  )
+    getFireEventForElement(execOutputAPI)
+  ) as TestInstance as RenderResult
 }
 
 export {render}

src/events.ts

@@ -7,9 +7,9 @@ import type {
   WithSuggest,
   Variant,
 } from '../types'
+import {TestInstance} from "../types/pure";
 import {getSuggestedQuery} from './suggestions'
 import {waitFor} from './wait-for'
-import {TestInstance} from "../types/pure";
 import {getConfig} from "./config";
 
 function getInstanceError(message: string | null, instance: TestInstance) {

src/pure.ts

@@ -0,0 +1,11 @@
+import {eventMap} from "../src/event-map";
+import {ShiftArgs} from "./helpers";
+import {TestInstance} from "./pure";
+
+export const fireEvent = typeof eventMap;
+
+export function getFireEventForElement (
+    instance: TestInstance
+): {
+    [key in keyof FireEventRecord]: ShiftArgs<FireEventRecord[key]>;
+};

src/query-helpers.ts

@@ -0,0 +1,47 @@
+import {TestInstance} from "./pure";
+import * as queries from './queries'
+
+export type BoundFunction<T> = T extends (
+        container: TestInstance,
+        ...args: infer P
+    ) => infer R
+    ? (...args: P) => R
+    : never
+
+export type BoundFunctions<Q> = Q extends typeof queries
+    ? {
+    getByText<T extends TestInstance = TestInstance>(
+        ...args: Parameters<BoundFunction<queries.GetByText<T>>>
+    ): ReturnType<queries.GetByText<T>>
+    queryByText<T extends TestInstance = TestInstance>(
+        ...args: Parameters<BoundFunction<queries.QueryByText<T>>>
+    ): ReturnType<queries.QueryByText<T>>
+    findByText<T extends TestInstance = TestInstance>(
+        ...args: Parameters<BoundFunction<queries.FindByText<T>>>
+    ): ReturnType<queries.FindByText<T>>
+} & {
+    [P in keyof Q]: BoundFunction<Q[P]>
+}
+    : {
+        [P in keyof Q]: BoundFunction<Q[P]>
+    }
+
+export type Query = (
+    container: TestInstance,
+    ...args: any[]
+) =>
+    | Error
+    | TestInstance
+    | TestInstance[]
+    | Promise<TestInstance[]>
+    | Promise<TestInstance>
+    | null
+
+export interface Queries {
+    [T: string]: Query
+}
+
+export function getQueriesForInstance<T extends Queries = typeof queries>(
+    instance: TestInstance,
+    queriesToBind?: T,
+): BoundFunctions<T>