formatting

Author: phryneas

.github/workflows/pkg-pr-new-publish.yml

@@ -4,9 +4,9 @@ on:
   pull_request:
   push:
     branches:
-      - "**"
+      - '**'
     tags:
-      - "!**"
+      - '!**'
 
 jobs:
   prerelease:

src/assertable.ts

@@ -1,8 +1,8 @@
-import { RenderStream } from "./renderStream/createRenderStream.js";
+import {RenderStream} from './renderStream/createRenderStream.js'
 
 export const assertableSymbol = Symbol.for(
-  "@testing-library/react-render-stream:assertable"
-);
+  '@testing-library/react-render-stream:assertable',
+)
 
 /**
  * A function or object that can be used in assertions, like e.g.
@@ -13,14 +13,14 @@ export const assertableSymbol = Symbol.for(
  ```
  */
 export type Assertable = {
-  [assertableSymbol]: RenderStream<any>;
-};
+  [assertableSymbol]: RenderStream<any>
+}
 
 export function markAssertable<T extends {}>(
   assertable: T,
-  stream: RenderStream<any>
+  stream: RenderStream<any>,
 ): T & Assertable {
   return Object.assign(assertable, {
     [assertableSymbol]: stream,
-  });
+  })
 }

src/index.ts

@@ -3,18 +3,18 @@ export type {
   RenderStream,
   RenderStreamWithRenderFn,
   RenderStreamOptions,
-} from "./renderStream/createRenderStream.js";
+} from './renderStream/createRenderStream.js'
 export {
   createRenderStream,
   useTrackRenders,
   WaitForRenderTimeoutError,
-} from "./renderStream/createRenderStream.js";
+} from './renderStream/createRenderStream.js'
 
-export type { SyncScreen } from "./renderStream/Render.js";
+export type {SyncScreen} from './renderStream/Render.js'
 
-export { renderToRenderStream } from "./renderToRenderStream.js";
-export type { RenderStreamWithRenderResult } from "./renderToRenderStream.js";
-export { renderHookToSnapshotStream } from "./renderHookToSnapshotStream.js";
-export type { SnapshotStream } from "./renderHookToSnapshotStream.js";
+export {renderToRenderStream} from './renderToRenderStream.js'
+export type {RenderStreamWithRenderResult} from './renderToRenderStream.js'
+export {renderHookToSnapshotStream} from './renderHookToSnapshotStream.js'
+export type {SnapshotStream} from './renderHookToSnapshotStream.js'
 
-export type { Assertable } from "./assertable.js";
+export type {Assertable} from './assertable.js'

src/jest/index.ts

@@ -1,11 +1,11 @@
-import { expect } from "@jest/globals";
-import { toRerender, toRenderExactlyTimes } from "./renderStreamMatchers.js";
-import type { RenderStreamMatchers } from "./renderStreamMatchers.js";
+import {expect} from '@jest/globals'
+import {toRerender, toRenderExactlyTimes} from './renderStreamMatchers.js'
+import type {RenderStreamMatchers} from './renderStreamMatchers.js'
 
 expect.extend({
   toRerender,
   toRenderExactlyTimes,
-});
+})
 
 declare global {
   namespace jest {

src/jest/renderStreamMatchers.ts

@@ -1,42 +1,42 @@
-import type { MatcherFunction } from "expect";
-import { WaitForRenderTimeoutError } from "@testing-library/react-render-stream";
+import type {MatcherFunction} from 'expect'
+import {WaitForRenderTimeoutError} from '@testing-library/react-render-stream'
 import type {
   Assertable,
   NextRenderOptions,
   RenderStream,
-} from "@testing-library/react-render-stream";
+} from '@testing-library/react-render-stream'
 // explicitly imported the symbol from the internal file
 // this will bundle the `Symbol.for` call twice, but we keep it private
-import { assertableSymbol } from "../assertable.js";
+import {assertableSymbol} from '../assertable.js'
 
 export interface RenderStreamMatchers<R = void, T = {}> {
   toRerender: T extends RenderStream<any> | Assertable
     ? (options?: NextRenderOptions) => Promise<R>
     : {
-        error: "matcher needs to be called on a `takeRender` function, `takeSnapshot` function or `RenderStream` instance";
-      };
+        error: 'matcher needs to be called on a `takeRender` function, `takeSnapshot` function or `RenderStream` instance'
+      }
 
   toRenderExactlyTimes: T extends RenderStream<any> | Assertable
     ? (count: number, options?: NextRenderOptions) => Promise<R>
     : {
-        error: "matcher needs to be called on a `takeRender` function, `takeSnapshot` function or `RenderStream` instance";
-      };
+        error: 'matcher needs to be called on a `takeRender` function, `takeSnapshot` function or `RenderStream` instance'
+      }
 }
 
 export const toRerender: MatcherFunction<[options?: NextRenderOptions]> =
   async function (actual, options) {
-    const _stream = actual as RenderStream<any> | Assertable;
+    const _stream = actual as RenderStream<any> | Assertable
     const stream =
-      assertableSymbol in _stream ? _stream[assertableSymbol] : _stream;
-    const hint = this.utils.matcherHint("toRerender");
-    let pass = true;
+      assertableSymbol in _stream ? _stream[assertableSymbol] : _stream
+    const hint = this.utils.matcherHint('toRerender')
+    let pass = true
     try {
-      await stream.peekRender({ timeout: 100, ...options });
+      await stream.peekRender({timeout: 100, ...options})
     } catch (e) {
       if (e instanceof WaitForRenderTimeoutError) {
-        pass = false;
+        pass = false
       } else {
-        throw e;
+        throw e
       }
     }
 
@@ -45,60 +45,60 @@ export const toRerender: MatcherFunction<[options?: NextRenderOptions]> =
       message() {
         return (
           hint +
-          `\n\nExpected component to${pass ? " not" : ""} rerender, ` +
-          `but it did${pass ? "" : " not"}.`
-        );
+          `\n\nExpected component to${pass ? ' not' : ''} rerender, ` +
+          `but it did${pass ? '' : ' not'}.`
+        )
       },
-    };
-  };
+    }
+  }
 
 /** to be thrown to "break" test execution and fail it */
-const failed = {};
+const failed = {}
 
 export const toRenderExactlyTimes: MatcherFunction<
   [times: number, options?: NextRenderOptions]
 > = async function (actual, times, optionsPerRender) {
-  const _stream = actual as RenderStream<any> | Assertable;
+  const _stream = actual as RenderStream<any> | Assertable
   const stream =
-    assertableSymbol in _stream ? _stream[assertableSymbol] : _stream;
-  const options = { timeout: 100, ...optionsPerRender };
-  const hint = this.utils.matcherHint("toRenderExactlyTimes");
-  let pass = true;
+    assertableSymbol in _stream ? _stream[assertableSymbol] : _stream
+  const options = {timeout: 100, ...optionsPerRender}
+  const hint = this.utils.matcherHint('toRenderExactlyTimes')
+  let pass = true
   try {
     if (stream.totalRenderCount() > times) {
-      throw failed;
+      throw failed
     }
     try {
       while (stream.totalRenderCount() < times) {
-        await stream.waitForNextRender(options);
+        await stream.waitForNextRender(options)
       }
     } catch (e) {
       // timeouts here should just fail the test, rethrow other errors
-      throw e instanceof WaitForRenderTimeoutError ? failed : e;
+      throw e instanceof WaitForRenderTimeoutError ? failed : e
     }
     try {
-      await stream.waitForNextRender(options);
+      await stream.waitForNextRender(options)
     } catch (e) {
       // we are expecting a timeout here, so swallow that error, rethrow others
       if (!(e instanceof WaitForRenderTimeoutError)) {
-        throw e;
+        throw e
       }
     }
   } catch (e) {
     if (e === failed) {
-      pass = false;
+      pass = false
     } else {
-      throw e;
+      throw e
     }
   }
   return {
     pass,
     message() {
       return (
         hint +
-        ` Expected component to${pass ? " not" : ""} render exactly ${times}.` +
+        ` Expected component to${pass ? ' not' : ''} render exactly ${times}.` +
         ` It rendered ${stream.totalRenderCount()} times.`
-      );
+      )
     },
-  };
-};
+  }
+}

src/renderHookToSnapshotStream.tsx

@@ -1,88 +1,88 @@
-import { RenderHookOptions } from "@testing-library/react";
-import { createRenderStream } from "./renderStream/createRenderStream.js";
-import type { NextRenderOptions } from "./renderStream/createRenderStream.js";
+import {RenderHookOptions} from '@testing-library/react'
+import {createRenderStream} from './renderStream/createRenderStream.js'
+import type {NextRenderOptions} from './renderStream/createRenderStream.js'
 
-import { Render } from "./renderStream/Render.js";
-import { createElement } from "rehackt";
-import { Assertable, assertableSymbol, markAssertable } from "./assertable.js";
+import {Render} from './renderStream/Render.js'
+import {createElement} from 'rehackt'
+import {Assertable, assertableSymbol, markAssertable} from './assertable.js'
 
 export interface SnapshotStream<Snapshot, Props> extends Assertable {
   /**
    * An array of all renders that have happened so far.
    * Errors thrown during component render will be captured here, too.
    */
   renders: Array<
-    | Render<{ value: Snapshot }>
-    | { phase: "snapshotError"; count: number; error: unknown }
-  >;
+    | Render<{value: Snapshot}>
+    | {phase: 'snapshotError'; count: number; error: unknown}
+  >
   /**
    * Peeks the next render from the current iterator position, without advancing the iterator.
    * If no render has happened yet, it will wait for the next render to happen.
    * @throws {WaitForRenderTimeoutError} if no render happens within the timeout
    */
-  peekSnapshot(options?: NextRenderOptions): Promise<Snapshot>;
+  peekSnapshot(options?: NextRenderOptions): Promise<Snapshot>
   /**
    * Iterates to the next render and returns it.
    * If no render has happened yet, it will wait for the next render to happen.
    * @throws {WaitForRenderTimeoutError} if no render happens within the timeout
    */
   takeSnapshot: Assertable &
-    ((options?: NextRenderOptions) => Promise<Snapshot>);
+    ((options?: NextRenderOptions) => Promise<Snapshot>)
   /**
    * Returns the total number of renders.
    */
-  totalSnapshotCount(): number;
+  totalSnapshotCount(): number
   /**
    * Returns the current render.
    * @throws {Error} if no render has happened yet
    */
-  getCurrentSnapshot(): Snapshot;
+  getCurrentSnapshot(): Snapshot
   /**
    * Waits for the next render to happen.
    * Does not advance the render iterator.
    */
-  waitForNextSnapshot(options?: NextRenderOptions): Promise<Snapshot>;
-  rerender: (rerenderCallbackProps: Props) => void;
-  unmount: () => void;
+  waitForNextSnapshot(options?: NextRenderOptions): Promise<Snapshot>
+  rerender: (rerenderCallbackProps: Props) => void
+  unmount: () => void
 }
 
 export function renderHookToSnapshotStream<ReturnValue, Props extends {}>(
   renderCallback: (props: Props) => ReturnValue,
-  { initialProps, ...options }: RenderHookOptions<Props> = {}
+  {initialProps, ...options}: RenderHookOptions<Props> = {},
 ): SnapshotStream<ReturnValue, Props> {
-  const { render, ...stream } = createRenderStream<{ value: ReturnValue }>();
+  const {render, ...stream} = createRenderStream<{value: ReturnValue}>()
 
-  const HookComponent: React.FC<Props> = (props) => {
-    stream.replaceSnapshot({ value: renderCallback(props) });
-    return null;
-  };
+  const HookComponent: React.FC<Props> = props => {
+    stream.replaceSnapshot({value: renderCallback(props)})
+    return null
+  }
 
-  const { rerender: baseRerender, unmount } = render(
+  const {rerender: baseRerender, unmount} = render(
     createElement(HookComponent, initialProps),
-    options
-  );
+    options,
+  )
 
   function rerender(rerenderCallbackProps: Props) {
-    return baseRerender(createElement(HookComponent, rerenderCallbackProps));
+    return baseRerender(createElement(HookComponent, rerenderCallbackProps))
   }
 
   return {
     [assertableSymbol]: stream,
     renders: stream.renders,
     totalSnapshotCount: stream.totalRenderCount,
     async peekSnapshot(options) {
-      return (await stream.peekRender(options)).snapshot.value;
+      return (await stream.peekRender(options)).snapshot.value
     },
     takeSnapshot: markAssertable(async function takeSnapshot(options) {
-      return (await stream.takeRender(options)).snapshot.value;
+      return (await stream.takeRender(options)).snapshot.value
     }, stream),
     getCurrentSnapshot() {
-      return stream.getCurrentRender().snapshot.value;
+      return stream.getCurrentRender().snapshot.value
     },
     async waitForNextSnapshot(options) {
-      return (await stream.waitForNextRender(options)).snapshot.value;
+      return (await stream.waitForNextRender(options)).snapshot.value
     },
     rerender,
     unmount,
-  };
+  }
 }