@testing-library/svelte 3.2.2 → 4.0.1

package/README.md

@@ -10,8 +10,7 @@
   />
 </a>
 
-<p>Simple and complete Svelte testing utilities that encourage good testing
-practices.</p>
+<p>Simple and complete Svelte testing utilities that encourage good testing practices.</p>
 
 [**Read The Docs**](https://testing-library.com/docs/svelte-testing-library/intro) |
 [Edit the docs](https://github.com/alexkrolick/testing-library-docs)

package/package.json

@@ -1,8 +1,14 @@
 {
   "name": "@testing-library/svelte",
-  "version": "3.2.2",
+  "version": "4.0.1",
   "description": "Simple and complete Svelte testing utilities that encourage good testing practices.",
-  "main": "dist/index.js",
+  "exports": {
+    ".": {
+      "default": "./src/index.js",
+      "types": "./types/index.d.ts"
+    }
+  },
+  "type": "module",
   "types": "types/index.d.ts",
   "license": "MIT",
   "homepage": "https://github.com/testing-library/svelte-testing-library#readme",
@@ -29,57 +35,50 @@
     "e2e"
   ],
   "files": [
-    "dist",
-    "dont-cleanup-after-each.js",
-    "pure.js",
+    "src/",
     "types/index.d.ts"
   ],
   "scripts": {
     "toc": "doctoc README.md",
     "lint": "eslint src --fix",
-    "clean": "rimraf dist",
-    "build": "npm run clean && babel src --out-dir dist --ignore '**/__tests__/**'",
-    "test": "jest src",
+    "test": "vitest run src",
     "test:watch": "npm run test -- --watch",
     "test:update": "npm run test -- --updateSnapshot --coverage",
     "setup": "npm install && npm run validate",
-    "validate": "npm run clean && npm-run-all lint test build",
+    "validate": "npm-run-all lint test",
     "contributors:add": "all-contributors add",
     "contributors:generate": "all-contributors generate"
   },
   "peerDependencies": {
-    "svelte": "3.x"
+    "svelte": "^3 || ^4"
   },
   "dependencies": {
     "@testing-library/dom": "^8.1.0"
   },
   "devDependencies": {
-    "@babel/cli": "^7.6.2",
-    "@babel/core": "^7.6.2",
-    "@babel/plugin-transform-modules-commonjs": "^7.6.0",
-    "@babel/preset-env": "^7.6.2",
     "@commitlint/cli": "^13.1.0",
     "@commitlint/config-conventional": "^13.1.0",
-    "@testing-library/jest-dom": "^5.0.2",
-    "@types/jest": "^27.0.0",
+    "@sveltejs/vite-plugin-svelte": "^2.4.1",
+    "@testing-library/jest-dom": "^5.16.5",
+    "@vitest/coverage-c8": "^0.32.0",
     "all-contributors-cli": "^6.9.0",
-    "babel-eslint": "^10.0.3",
-    "babel-jest": "^27.0.6",
     "doctoc": "^2.0.0",
-    "eslint": "^7.2.0",
-    "eslint-config-standard": "^16.0.0",
-    "eslint-plugin-import": "^2.18.2",
-    "eslint-plugin-node": "^11.0.0",
-    "eslint-plugin-promise": "^5.1.0",
-    "eslint-plugin-simple-import-sort": "^7.0.0",
-    "eslint-plugin-svelte3": "^3.0.0",
+    "eslint": "^8.42.0",
+    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-n": "^16.0.0",
+    "eslint-plugin-promise": "^6.1.1",
+    "eslint-plugin-simple-import-sort": "^10.0.0",
+    "eslint-config-standard": "^17.1.0",
+    "eslint-plugin-svelte": "^2.30.0",
+    "eslint-plugin-vitest-globals": "^1.3.1",
     "husky": "^7.0.1",
-    "jest": "^27.0.0",
+    "jsdom": "^22.1.0",
     "lint-staged": "^11.1.1",
     "npm-run-all": "^4.1.5",
     "prettier": "^2.0.1",
-    "svelte": "^3.0.0",
-    "svelte-jester": "^2.1.4"
+    "svelte": "^3.59.1",
+    "vite": "^4.3.9",
+    "vitest": "^0.32.0"
   },
   "husky": {
     "hooks": {
@@ -107,26 +106,5 @@
     "extends": [
       "@commitlint/config-conventional"
     ]
-  },
-  "jest": {
-    "testPathIgnorePatterns": [
-      "src/__tests__/fixtures"
-    ],
-    "collectCoverageFrom": [
-      "src/*.js"
-    ],
-    "setupFilesAfterEnv": [
-      "@testing-library/jest-dom/extend-expect"
-    ],
-    "testEnvironment": "jsdom",
-    "transform": {
-      "^.+\\.js$": "babel-jest",
-      "^.+\\.svelte$": "svelte-jester",
-      "^.+\\.html$": "svelte-jester"
-    },
-    "moduleFileExtensions": [
-      "js",
-      "svelte"
-    ]
   }
 }

package/src/__tests__/__snapshots__/auto-cleanup-skip.test.js.snap

@@ -0,0 +1,3 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`auto-cleanup-skip > second 1`] = `""`;

package/src/__tests__/__snapshots__/render.test.js.snap

@@ -0,0 +1,25 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`render > should accept svelte component options 1`] = `
+<body>
+  <div>
+    <h1
+      data-testid="test"
+    >
+      Hello 
+      World
+      !
+    </h1>
+     
+    <div>
+      we have context
+    </div>
+     
+    <button>
+      Button
+    </button>
+    <!--&lt;Comp&gt;-->
+    <div />
+  </div>
+</body>
+`;

package/src/__tests__/act.test.js

@@ -0,0 +1,56 @@
+import { beforeEach, describe, expect, test } from 'vitest'
+
+import { act, fireEvent, render as stlRender } from '..'
+import Comp from './fixtures/Comp.svelte'
+
+describe('act', () => {
+  let props
+
+  const render = () => {
+    return stlRender(Comp, {
+      props
+    })
+  }
+
+  beforeEach(() => {
+    props = {
+      name: 'World'
+    }
+  })
+
+  test('state updates are flushed', async () => {
+    const { getByText } = render()
+    const button = getByText('Button')
+
+    expect(button).toHaveTextContent('Button')
+
+    await act(() => {
+      button.click()
+    })
+
+    expect(button).toHaveTextContent('Button Clicked')
+  })
+
+  test('findByTestId returns the element', async () => {
+    const { findByTestId } = render()
+
+    expect(await findByTestId('test')).toHaveTextContent(`Hello ${props.name}!`)
+  })
+
+  test('accepts async functions', async () => {
+    const sleep = (ms) =>
+      new Promise((resolve) => {
+        setTimeout(() => resolve(), ms)
+      })
+
+    const { getByText } = render()
+    const button = getByText('Button')
+
+    await act(async () => {
+      await sleep(100)
+      await fireEvent.click(button)
+    })
+
+    expect(button).toHaveTextContent('Button Clicked')
+  })
+})

package/src/__tests__/auto-cleanup-skip.test.js

@@ -0,0 +1,23 @@
+import { beforeAll, describe, expect, test } from 'vitest'
+
+import Comp from './fixtures/Comp.svelte'
+
+describe('auto-cleanup-skip', () => {
+  let render
+
+  beforeAll(async () => {
+    process.env.STL_SKIP_AUTO_CLEANUP = 'true'
+    const stl = await import('..')
+    render = stl.render
+  })
+
+  // This one verifies that if STL_SKIP_AUTO_CLEANUP is set
+  // then we DON'T auto-wire up the afterEach for folks
+  test('first', () => {
+    render(Comp, { props: { name: 'world' } })
+  })
+
+  test('second', () => {
+    expect(document.body.innerHTML).toMatchSnapshot()
+  })
+})

package/src/__tests__/auto-cleanup.test.js

@@ -0,0 +1,31 @@
+import { describe, expect, test } from 'vitest'
+
+import { render } from '..'
+import Comp from './fixtures/Comp.svelte'
+
+describe('auto-cleanup', () => {
+  // This just verifies that by importing STL in an
+  // environment which supports afterEach (like jest)
+  // we'll get automatic cleanup between tests.
+  test('first', () => {
+    render(Comp, { props: { name: 'world' } })
+  })
+
+  test('second', () => {
+    expect(document.body.innerHTML).toEqual('')
+  })
+})
+
+describe('cleanup of two components', () => {
+  // This just verifies that by importing STL in an
+  // environment which supports afterEach (like jest)
+  // we'll get automatic cleanup between tests.
+  test('first', () => {
+    render(Comp, { props: { name: 'world' } })
+    render(Comp, { props: { name: 'universe' } })
+  })
+
+  test('second', () => {
+    expect(document.body.innerHTML).toEqual('')
+  })
+})

package/src/__tests__/debug.test.js

@@ -0,0 +1,24 @@
+import { prettyDOM } from '@testing-library/dom'
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
+
+import { render } from '..'
+import Comp from './fixtures/Comp.svelte'
+
+describe('debug', () => {
+  beforeEach(() => {
+    vi.spyOn(console, 'log').mockImplementation(() => { })
+  })
+
+  afterEach(() => {
+    console.log.mockRestore()
+  })
+
+  test('pretty prints the container', () => {
+    const { container, debug } = render(Comp, { props: { name: 'world' } })
+
+    debug()
+
+    expect(console.log).toHaveBeenCalledTimes(1)
+    expect(console.log).toHaveBeenCalledWith(prettyDOM(container))
+  })
+})

package/src/__tests__/events.test.js

@@ -0,0 +1,30 @@
+import { describe, expect, test } from 'vitest'
+
+import { fireEvent, render } from '..'
+import Comp from './fixtures/Comp.svelte'
+
+describe('events', () => {
+  test('state changes are flushed after firing an event', async () => {
+    const { getByText } = render(Comp, { props: { name: 'World' } })
+    const button = getByText('Button')
+
+    await fireEvent.click(button)
+
+    expect(button).toHaveTextContent('Button Clicked')
+  })
+
+  test('calling `fireEvent` directly works too', async () => {
+    const { getByText } = render(Comp, { props: { name: 'World' } })
+    const button = getByText('Button')
+
+    await fireEvent(
+      button,
+      new MouseEvent('click', {
+        bubbles: true,
+        cancelable: true
+      })
+    )
+
+    expect(button).toHaveTextContent('Button Clicked')
+  })
+})

package/src/__tests__/fixtures/Comp.svelte

@@ -0,0 +1,23 @@
+<svelte:options accessors />
+
+<script>
+  import { getContext } from 'svelte'
+
+  export let name
+
+  let buttonText = 'Button'
+
+  const contextName = getContext('name')
+
+  function handleClick () {
+    buttonText = 'Button Clicked'
+  }
+</script>
+
+<h1 data-testid="test">Hello {name}!</h1>
+
+<div>we have {contextName}</div>
+
+<button on:click={handleClick}>{buttonText}</button>
+
+<style></style>

package/src/__tests__/fixtures/Comp2.svelte

@@ -0,0 +1,15 @@
+<script>
+  export let name
+
+  let buttonText = 'Button Text'
+
+  function handleClick () {
+    buttonText = 'Button Clicked'
+  }
+</script>
+
+<style></style>
+
+<h1>Hello {name}!</h1>
+
+<button on:click={handleClick}>{buttonText}</button>

package/src/__tests__/fixtures/Stopwatch.svelte

@@ -0,0 +1,40 @@
+<script>
+  import { onDestroy } from 'svelte'
+
+  let timer
+  let lapse = 0
+  let running = false
+
+  function handleRunClick () {
+    if (running) {
+      clearInterval(timer)
+    } else {
+      const startTime = Date.now() - lapse
+
+      timer = setInterval(() => {
+        lapse = Date.now() - startTime
+      }, 1)
+    }
+    running = true
+  }
+
+  function handleClearClick () {
+    clearInterval(timer)
+    lapse = 0
+    running = false
+  }
+
+  onDestroy(() => {
+    clearInterval(timer)
+  })
+</script>
+
+<style></style>
+
+<span>{lapse}ms</span>
+
+<button on:click={handleRunClick}>
+  {running ? 'Stop' : 'Start'}
+</button>
+
+<button on:click={handleClearClick}>Clear</button>

package/src/__tests__/multi-base.test.js

@@ -0,0 +1,42 @@
+import { describe, expect, test } from 'vitest'
+
+import { render } from '..'
+import Comp from './fixtures/Comp.svelte'
+
+describe('multi-base', () => {
+  const treeA = document.createElement('div')
+  const treeB = document.createElement('div')
+
+  test('container isolates trees from one another', () => {
+    const { getByText: getByTextInA } = render(
+      Comp,
+      {
+        target: treeA,
+        props: {
+          name: 'Tree A'
+        }
+      },
+      {
+        container: treeA
+      }
+    )
+
+    const { getByText: getByTextInB } = render(
+      Comp,
+      {
+        target: treeB,
+        props: {
+          name: 'Tree B'
+        }
+      },
+      {
+        container: treeB
+      }
+    )
+
+    expect(() => getByTextInA('Hello Tree A!')).not.toThrow()
+    expect(() => getByTextInB('Hello Tree A!')).toThrow()
+    expect(() => getByTextInA('Hello Tree B!')).toThrow()
+    expect(() => getByTextInB('Hello Tree B!')).not.toThrow()
+  })
+})

package/src/__tests__/render.test.js

@@ -0,0 +1,104 @@
+import { beforeEach, describe, expect, test } from 'vitest'
+
+import { act, render as stlRender } from '..'
+import Comp from './fixtures/Comp.svelte'
+import CompDefault from './fixtures/Comp2.svelte'
+
+describe('render', () => {
+  let props
+
+  const render = (additional = {}) => {
+    return stlRender(Comp, {
+      target: document.body,
+      props,
+      ...additional
+    })
+  }
+
+  beforeEach(() => {
+    props = {
+      name: 'World'
+    }
+  })
+
+  test('renders component into the document', () => {
+    const { getByText } = render()
+
+    expect(getByText('Hello World!')).toBeInTheDocument()
+  })
+
+  // Dear reader, this is not something you generally want to do in your tests.
+  test('programmatically change props', async () => {
+    const { component, getByText } = render()
+
+    expect(getByText('Hello World!')).toBeInTheDocument()
+
+    await act(() => {
+      component.$set({ name: 'Worlds' })
+    })
+
+    expect(getByText('Hello Worlds!')).toBeInTheDocument()
+  })
+
+  test('change props with accessors', async () => {
+    const { component, getByText } = render({ accessors: true })
+
+    expect(getByText('Hello World!')).toBeInTheDocument()
+
+    expect(component.name).toBe('World')
+
+    await act(() => {
+      component.value = 'Planet'
+    })
+
+    expect(getByText('Hello World!')).toBeInTheDocument()
+  })
+
+  test('should accept props directly', () => {
+    const { getByText } = stlRender(Comp, { name: 'World' })
+    expect(getByText('Hello World!')).toBeInTheDocument()
+  })
+
+  test('should accept svelte component options', () => {
+    const target = document.createElement('div')
+    const div = document.createElement('div')
+    document.body.appendChild(target)
+    target.appendChild(div)
+    const { container } = stlRender(Comp, {
+      target,
+      anchor: div,
+      props: { name: 'World' },
+      context: new Map([['name', 'context']])
+    })
+    expect(container).toMatchSnapshot()
+  })
+
+  test('should throw error when mixing svelte component options and props', () => {
+    expect(() => {
+      stlRender(Comp, { anchor: '', name: 'World' })
+    }).toThrow(/Unknown options were found/)
+  })
+
+  test('should return a container object, which contains the DOM of the rendered component', () => {
+    const { container } = render()
+
+    expect(container.innerHTML).toBe(document.body.innerHTML)
+  })
+
+  test('correctly find component constructor on the default property', () => {
+    const { getByText } = render(CompDefault, { props: { name: 'World' } })
+
+    expect(getByText('Hello World!')).toBeInTheDocument()
+  })
+
+  test("accept the 'context' option", () => {
+    const { getByText } = stlRender(Comp, {
+      props: {
+        name: 'Universe'
+      },
+      context: new Map([['name', 'context']])
+    })
+
+    expect(getByText('we have context')).toBeInTheDocument()
+  })
+})

package/src/__tests__/rerender.test.js

@@ -0,0 +1,38 @@
+/**
+ * @jest-environment jsdom
+ */
+import { describe, expect, test } from 'vitest'
+
+import { render } from '..'
+import Comp from './fixtures/Comp.svelte'
+
+describe('rerender', () => {
+  test('mounts new component successfully', () => {
+    const { container, rerender } = render(Comp, { props: { name: 'World 1' } })
+
+    expect(container.firstChild).toHaveTextContent('Hello World 1!')
+    rerender({ props: { name: 'World 2' } })
+    expect(container.firstChild).toHaveTextContent('Hello World 2!')
+  })
+
+  test('destroys old component', () => {
+    let isDestroyed
+
+    const { rerender, component } = render(Comp, { props: { name: '' } })
+
+    component.$$.on_destroy.push(() => {
+      isDestroyed = true
+    })
+    rerender({ props: { name: '' } })
+    expect(isDestroyed).toBeTruthy()
+  })
+
+  test('destroys old components on multiple rerenders', () => {
+    const { rerender, queryByText } = render(Comp, { props: { name: 'Neil' } })
+
+    rerender({ props: { name: 'Alex' } })
+    expect(queryByText('Hello Neil!')).not.toBeInTheDocument()
+    rerender({ props: { name: 'Geddy' } })
+    expect(queryByText('Hello Alex!')).not.toBeInTheDocument()
+  })
+})

package/src/__tests__/unmount.test.js

@@ -0,0 +1,35 @@
+import { describe, expect, test, vi } from 'vitest'
+
+import { act, fireEvent, render } from '..'
+import Stopwatch from './fixtures/Stopwatch.svelte'
+
+describe('unmount', () => {
+  test('unmounts component successfully', async () => {
+    console.warn = vi.fn()
+
+    const { unmount, getByText, container } = render(Stopwatch)
+
+    await fireEvent.click(getByText('Start'))
+
+    unmount()
+
+    // Hey there reader! You don't need to have an assertion like this one
+    // this is just me making sure that the unmount function works.
+    // You don't need to do this in your apps. Just rely on the fact that this works.
+    expect(container.innerHTML).toBe('<div></div>')
+
+    await act()
+    expect(console.warn).not.toHaveBeenCalled()
+  })
+
+  test('destroying component directly and calling unmount does not log warning', async () => {
+    console.warn = vi.fn()
+
+    const { unmount, component } = render(Stopwatch)
+
+    component.$destroy()
+    unmount()
+
+    expect(console.warn).not.toHaveBeenCalled()
+  })
+})

package/src/index.js

@@ -0,0 +1,15 @@
+import { act, cleanup } from './pure'
+
+// If we're running in a test runner that supports afterEach
+// then we'll automatically run cleanup afterEach test
+// this ensures that tests run in isolation from each other
+// if you don't like this then either import the `pure` module
+// or set the STL_SKIP_AUTO_CLEANUP env variable to 'true'.
+if (typeof afterEach === 'function' && !process.env.STL_SKIP_AUTO_CLEANUP) {
+  afterEach(async () => {
+    await act()
+    cleanup()
+  })
+}
+
+export * from './pure'

package/src/pure.js

@@ -0,0 +1,138 @@
+import {
+  fireEvent as dtlFireEvent,
+  getQueriesForElement,
+  prettyDOM
+} from '@testing-library/dom'
+import { tick } from 'svelte'
+
+const containerCache = new Set()
+const componentCache = new Set()
+
+const svelteComponentOptions = [
+  'accessors',
+  'anchor',
+  'props',
+  'hydrate',
+  'intro',
+  'context'
+]
+
+const render = (
+  Component,
+  { target, ...options } = {},
+  { container, queries } = {}
+) => {
+  container = container || document.body
+  target = target || container.appendChild(document.createElement('div'))
+
+  const ComponentConstructor = Component.default || Component
+
+  const checkProps = (options) => {
+    const isProps = !Object.keys(options).some((option) =>
+      svelteComponentOptions.includes(option)
+    )
+
+    // Check if any props and Svelte options were accidentally mixed.
+    if (!isProps) {
+      const unrecognizedOptions = Object.keys(options).filter(
+        (option) => !svelteComponentOptions.includes(option)
+      )
+
+      if (unrecognizedOptions.length > 0) {
+        throw Error(`
+          Unknown options were found [${unrecognizedOptions}]. This might happen if you've mixed
+          passing in props with Svelte options into the render function. Valid Svelte options
+          are [${svelteComponentOptions}]. You can either change the prop names, or pass in your
+          props for that component via the \`props\` option.\n\n
+          Eg: const { /** Results **/ } = render(MyComponent, { props: { /** props here **/ } })\n\n
+        `)
+      }
+
+      return options
+    }
+
+    return { props: options }
+  }
+
+  let component = new ComponentConstructor({
+    target,
+    ...checkProps(options)
+  })
+
+  containerCache.add({ container, target, component })
+  componentCache.add(component)
+
+  component.$$.on_destroy.push(() => {
+    componentCache.delete(component)
+  })
+
+  return {
+    container,
+    component,
+    debug: (el = container) => console.log(prettyDOM(el)),
+    rerender: (options) => {
+      if (componentCache.has(component)) component.$destroy()
+
+      // eslint-disable-next-line no-new
+      component = new ComponentConstructor({
+        target,
+        ...checkProps(options)
+      })
+
+      containerCache.add({ container, target, component })
+      componentCache.add(component)
+
+      component.$$.on_destroy.push(() => {
+        componentCache.delete(component)
+      })
+    },
+    unmount: () => {
+      if (componentCache.has(component)) component.$destroy()
+    },
+    ...getQueriesForElement(container, queries)
+  }
+}
+
+const cleanupAtContainer = (cached) => {
+  const { target, component } = cached
+
+  if (componentCache.has(component)) component.$destroy()
+
+  if (target.parentNode === document.body) {
+    document.body.removeChild(target)
+  }
+
+  containerCache.delete(cached)
+}
+
+const cleanup = () => {
+  Array.from(containerCache.keys()).forEach(cleanupAtContainer)
+}
+
+const act = (fn) => {
+  const value = fn && fn()
+  if (value !== undefined && typeof value.then === 'function') {
+    return value.then(() => tick())
+  }
+  return tick()
+}
+
+const fireEvent = async (...args) => {
+  const event = dtlFireEvent(...args)
+  await tick()
+  return event
+}
+
+Object.keys(dtlFireEvent).forEach((key) => {
+  fireEvent[key] = async (...args) => {
+    const event = dtlFireEvent[key](...args)
+    await tick()
+    return event
+  }
+})
+
+/* eslint-disable import/export */
+
+export * from '@testing-library/dom'
+
+export { render, cleanup, fireEvent, act }

package/src/test-setup.js

@@ -0,0 +1,11 @@
+import * as matchers from '@testing-library/jest-dom/dist/matchers'
+import { afterEach, expect } from 'vitest'
+
+import { act, cleanup } from './pure'
+
+expect.extend(matchers)
+
+afterEach(async () => {
+  await act()
+  cleanup()
+})

package/types/index.d.ts

@@ -3,7 +3,7 @@
 // Definitions by: Rahim Alwer <https://github.com/mihar-22>
 
 import {queries, Queries, BoundFunction, EventType} from '@testing-library/dom'
-import { SvelteComponent, ComponentProps } from 'svelte/types/runtime'
+import { SvelteComponent, ComponentProps } from 'svelte'
 
 export * from '@testing-library/dom'
 

package/dist/index.js

@@ -1,30 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-
-var _pure = require("./pure");
-
-Object.keys(_pure).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _pure[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _pure[key];
-    }
-  });
-});
-
-// If we're running in a test runner that supports afterEach
-// then we'll automatically run cleanup afterEach test
-// this ensures that tests run in isolation from each other
-// if you don't like this then either import the `pure` module
-// or set the STL_SKIP_AUTO_CLEANUP env variable to 'true'.
-if (typeof afterEach === 'function' && !process.env.STL_SKIP_AUTO_CLEANUP) {
-  afterEach(async () => {
-    await (0, _pure.act)();
-    (0, _pure.cleanup)();
-  });
-}

package/dist/pure.js

@@ -1,170 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-var _exportNames = {
-  render: true,
-  cleanup: true,
-  fireEvent: true,
-  act: true
-};
-exports.render = exports.fireEvent = exports.cleanup = exports.act = void 0;
-
-var _dom = require("@testing-library/dom");
-
-Object.keys(_dom).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
-  if (key in exports && exports[key] === _dom[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _dom[key];
-    }
-  });
-});
-
-var _svelte = require("svelte");
-
-const _excluded = ["target"];
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
-
-function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
-
-const containerCache = new Set();
-const componentCache = new Set();
-const svelteComponentOptions = ['accessors', 'anchor', 'props', 'hydrate', 'intro', 'context'];
-
-const render = (Component, _ref = {}, {
-  container,
-  queries
-} = {}) => {
-  let {
-    target
-  } = _ref,
-      options = _objectWithoutProperties(_ref, _excluded);
-
-  container = container || document.body;
-  target = target || container.appendChild(document.createElement('div'));
-  const ComponentConstructor = Component.default || Component;
-
-  const checkProps = options => {
-    const isProps = !Object.keys(options).some(option => svelteComponentOptions.includes(option)); // Check if any props and Svelte options were accidentally mixed.
-
-    if (!isProps) {
-      const unrecognizedOptions = Object.keys(options).filter(option => !svelteComponentOptions.includes(option));
-
-      if (unrecognizedOptions.length > 0) {
-        throw Error(`
-          Unknown options were found [${unrecognizedOptions}]. This might happen if you've mixed
-          passing in props with Svelte options into the render function. Valid Svelte options
-          are [${svelteComponentOptions}]. You can either change the prop names, or pass in your
-          props for that component via the \`props\` option.\n\n
-          Eg: const { /** Results **/ } = render(MyComponent, { props: { /** props here **/ } })\n\n
-        `);
-      }
-
-      return options;
-    }
-
-    return {
-      props: options
-    };
-  };
-
-  let component = new ComponentConstructor(_objectSpread({
-    target
-  }, checkProps(options)));
-  containerCache.add({
-    container,
-    target,
-    component
-  });
-  componentCache.add(component);
-  component.$$.on_destroy.push(() => {
-    componentCache.delete(component);
-  });
-  return _objectSpread({
-    container,
-    component,
-    debug: (el = container) => console.log((0, _dom.prettyDOM)(el)),
-    rerender: options => {
-      if (componentCache.has(component)) component.$destroy(); // eslint-disable-next-line no-new
-
-      component = new ComponentConstructor(_objectSpread({
-        target
-      }, checkProps(options)));
-      containerCache.add({
-        container,
-        target,
-        component
-      });
-      componentCache.add(component);
-      component.$$.on_destroy.push(() => {
-        componentCache.delete(component);
-      });
-    },
-    unmount: () => {
-      if (componentCache.has(component)) component.$destroy();
-    }
-  }, (0, _dom.getQueriesForElement)(container, queries));
-};
-
-exports.render = render;
-
-const cleanupAtContainer = cached => {
-  const {
-    target,
-    component
-  } = cached;
-  if (componentCache.has(component)) component.$destroy();
-
-  if (target.parentNode === document.body) {
-    document.body.removeChild(target);
-  }
-
-  containerCache.delete(cached);
-};
-
-const cleanup = () => {
-  Array.from(containerCache.keys()).forEach(cleanupAtContainer);
-};
-
-exports.cleanup = cleanup;
-
-const act = fn => {
-  const value = fn && fn();
-
-  if (value !== undefined && typeof value.then === 'function') {
-    return value.then(() => (0, _svelte.tick)());
-  }
-
-  return (0, _svelte.tick)();
-};
-
-exports.act = act;
-
-const fireEvent = async (...args) => {
-  const event = (0, _dom.fireEvent)(...args);
-  await (0, _svelte.tick)();
-  return event;
-};
-
-exports.fireEvent = fireEvent;
-Object.keys(_dom.fireEvent).forEach(key => {
-  fireEvent[key] = async (...args) => {
-    const event = _dom.fireEvent[key](...args);
-
-    await (0, _svelte.tick)();
-    return event;
-  };
-});
-/* eslint-disable import/export */

package/pure.js

@@ -1,2 +0,0 @@
-// Makes it so people can import from '@testing-library/svelte/pure'
-module.exports = require('./dist/pure')