@remix-run/test 0.1.0 → 0.2.0

package/src/lib/runner-browser.ts

@@ -0,0 +1,165 @@
+import * as path from 'node:path'
+import type { Browser, Page, Request } from 'playwright'
+import { colors } from './colors.ts'
+import { getBrowserTestRootDir } from './config.ts'
+import {
+  collectCoverageMapFromPlaywright,
+  type CoverageMap,
+  type V8CoverageEntry,
+} from './coverage.ts'
+import {
+  getBrowserLauncher,
+  getPlaywrightLaunchOptions,
+  getPlaywrightPageOptions,
+  type PlaywrightUseOpts,
+} from './playwright.ts'
+import type { Reporter } from './reporters/index.ts'
+import type { TestResults } from './reporters/results.ts'
+
+// The harness reports each test result with `filePath` set to the
+// `/scripts/<rel>` URL the iframe loaded. Reporters expect a real filesystem
+// path so they can compute `path.relative(cwd, ...)` cleanly; otherwise they
+// produce noisy `../../../scripts/...` strings.
+function urlPathToFilePath(urlPath: string, rootDir: string): string {
+  if (!urlPath.startsWith('/scripts/')) return urlPath
+  return path.resolve(rootDir, urlPath.slice('/scripts/'.length))
+}
+
+export interface TestRunOptions {
+  baseUrl: string
+  console?: boolean
+  coverage?: boolean
+  open?: boolean
+  playwrightUseOpts?: PlaywrightUseOpts
+  projectName?: string
+  reporter: Reporter
+  // Test file paths so coverage collection can skip them when mapping V8
+  // entries back to filesystem files.
+  testFiles?: string[]
+}
+
+export async function runBrowserTests(options: TestRunOptions): Promise<{
+  results: TestResults
+  coverageMap: CoverageMap | null
+  close: () => Promise<void>
+  disconnected: Promise<void>
+}> {
+  let envLabel = options.projectName ? `browser:${options.projectName}` : 'browser'
+  let browser: Browser | undefined
+  let page: Page | undefined
+  let close = async () => {
+    await page?.close()
+    await browser?.close()
+    browser = undefined
+    page = undefined
+  }
+  let results: TestResults
+  let coverageMap: CoverageMap | null = null
+
+  try {
+    browser = await getBrowserLauncher(options.playwrightUseOpts).launch(
+      getPlaywrightLaunchOptions(options.playwrightUseOpts),
+    )
+    page = await browser.newPage(getPlaywrightPageOptions(options.playwrightUseOpts))
+
+    if (options.console) {
+      page.on('console', (msg) => console.log(`${colors.dim('[browser console]')} ${msg.text()}`))
+    }
+
+    // Playwright's JS coverage is Chromium-only. Start before navigation so
+    // the harness scripts and test modules are instrumented from first parse.
+    let coverageEnabled = options.coverage && browser.browserType().name() === 'chromium'
+    if (coverageEnabled) {
+      await page.coverage.startJSCoverage({ resetOnNavigation: false })
+    }
+
+    let totalPassed = 0
+    let totalFailed = 0
+    let totalSkipped = 0
+    let totalTodo = 0
+    let rootDir = getBrowserTestRootDir()
+
+    await page.route('**/file-results', async (route) => {
+      let results = route.request().postDataJSON() as TestResults
+      for (let test of results.tests) {
+        if (test.filePath) test.filePath = urlPathToFilePath(test.filePath, rootDir)
+      }
+      options.reporter.onResult(results, envLabel)
+      totalPassed += results.passed
+      totalFailed += results.failed
+      totalSkipped += results.skipped
+      totalTodo += results.todo
+      await route.fulfill({ status: 200 })
+    })
+
+    // Fail the tests if any /scripts/ request fails (harness scripts, test
+    // modules, or their transitive imports — all served via the same prefix).
+    let errorPromise = new Promise((_, reject) => {
+      let isScriptRequest = (request: Request) =>
+        new URL(request.url()).pathname.startsWith('/scripts/')
+      page!.on('response', (response) => {
+        if (!response.ok() && isScriptRequest(response.request())) {
+          reject(new Error(`Failed to load script: ${response.request().url()}`))
+        }
+      })
+      page!.on('requestfailed', (request) => {
+        if (isScriptRequest(request)) {
+          reject(new Error(`Failed to load script: ${request.url()}`))
+        }
+      })
+    })
+
+    // Prevent unhandled rejection if we fail before setting up the listener
+    errorPromise.catch(() => {})
+
+    await page.goto(options.baseUrl)
+    await Promise.race([page.waitForFunction('window.__testsDone'), errorPromise])
+
+    if (coverageEnabled) {
+      let entries = (await page.coverage.stopJSCoverage()) as unknown as V8CoverageEntry[]
+      if (entries.length > 0) {
+        coverageMap = await collectCoverageMapFromPlaywright(
+          entries,
+          getBrowserTestRootDir(),
+          new Set(options.testFiles ?? []),
+          async (urlPath) =>
+            urlPath.startsWith('/scripts/') ? urlPath.slice('/scripts/'.length) : null,
+        )
+      }
+    }
+
+    results = {
+      passed: totalPassed,
+      failed: totalFailed,
+      skipped: totalSkipped,
+      todo: totalTodo,
+      tests: [],
+    }
+  } catch (error) {
+    console.error('Browser tests failed to run:', error)
+    results = {
+      passed: 0,
+      failed: 1,
+      skipped: 0,
+      todo: 0,
+      tests: [],
+    }
+  }
+
+  if (options.open) {
+    return {
+      results,
+      coverageMap,
+      close,
+      disconnected: new Promise((r) => browser!.on('disconnected', () => r())),
+    }
+  } else {
+    await close()
+    return {
+      results,
+      coverageMap,
+      close,
+      disconnected: Promise.resolve(),
+    }
+  }
+}

package/src/lib/runner.ts

@@ -1,12 +1,22 @@
+import * as fsp from 'node:fs/promises'
 import * as path from 'node:path'
 import { pathToFileURL } from 'node:url'
 import { Worker } from 'node:worker_threads'
-import type { TestResults } from './executor.ts'
+import { IS_RUNNING_FROM_SRC } from './config.ts'
+import {
+  collectCoverageMapFromPlaywright,
+  collectServerCoverageMap,
+  type CoverageConfig,
+  type CoverageMap,
+  type V8CoverageEntry,
+} from './coverage.ts'
 import { type PlaywrightUseOpts } from './playwright.ts'
 import type { Reporter } from './reporters/index.ts'
-import type { Counts } from './utils.ts'
+import type { Counts, TestResults } from './reporters/results.ts'
 
-const ext = path.extname(import.meta.url)
+// Ensure we load the right file whether we're running in the monorepo (TS) or
+// from a published package (JS)
+const ext = IS_RUNNING_FROM_SRC ? '.ts' : '.js'
 const workerUrl = new URL(`./worker${ext}`, import.meta.url)
 const workerE2EUrl = new URL(`./worker-e2e${ext}`, import.meta.url)
 
@@ -16,12 +26,16 @@ export async function runServerTests(
   concurrency: number,
   type: 'server' | 'e2e',
   options: {
+    cwd?: string
     open?: boolean
     playwrightUseOpts?: PlaywrightUseOpts
     projectName?: string
+    coverage?: CoverageConfig
   } = {},
-): Promise<Counts> {
+): Promise<Counts & { coverageMap: CoverageMap | null }> {
   let counts: Counts = { passed: 0, failed: 0, skipped: 0, todo: 0 }
+  let coverageMap: CoverageMap | null = null
+  let cwd = options.cwd ?? process.cwd()
   let envLabel = options.projectName ? `${type}:${options.projectName}` : type
 
   function accumulate(results: TestResults, file: string) {
@@ -36,26 +50,60 @@ export async function runServerTests(
   }
 
   if (type === 'e2e') {
+    let allBrowserCoverageEntries: Array<{ entries: V8CoverageEntry[]; baseUrl: string }> = []
+
     await runInConcurrentWorkers(
       files,
       concurrency,
       (file) =>
-        runFileInWorker(file, type, (results) => accumulate(results, file), {
-          ...options,
-          playwrightUseOpts: options.playwrightUseOpts,
-        }),
+        runFileInWorker(
+          file,
+          type,
+          (results) => {
+            accumulate(results, file)
+            if (results.e2eBrowserCoverageEntries) {
+              allBrowserCoverageEntries.push(...results.e2eBrowserCoverageEntries)
+            }
+          },
+          {
+            ...options,
+            playwrightUseOpts: options.playwrightUseOpts,
+          },
+        ),
       () => counts.failed++,
     )
+
+    if (options.coverage && allBrowserCoverageEntries.length > 0) {
+      coverageMap = await collectCoverageMapFromPlaywright(
+        allBrowserCoverageEntries.flatMap((e) => e.entries),
+        cwd,
+        new Set(files),
+        async (urlPath) => (urlPath.startsWith('/') ? urlPath.slice(1) : urlPath),
+      )
+    }
   } else {
+    let coverageDataDir: string | undefined
+    if (options.coverage) {
+      coverageDataDir = path.resolve(cwd, options.coverage.dir)
+      await fsp.mkdir(coverageDataDir, { recursive: true })
+      process.env.NODE_V8_COVERAGE = coverageDataDir
+    }
+
     await runInConcurrentWorkers(
       files,
       concurrency,
-      (file) => runFileInWorker(file, type, (results) => accumulate(results, file)),
+      (file) => runFileInWorker(file, type, (results) => accumulate(results, file), options),
       () => counts.failed++,
     )
+
+    if (coverageDataDir) {
+      delete process.env.NODE_V8_COVERAGE
+      let serverMap = await collectServerCoverageMap(coverageDataDir, cwd, new Set(files))
+      coverageMap = serverMap
+    }
   }
 
-  return { ...counts }
+  return { ...counts, coverageMap }
 }
 
 async function runInConcurrentWorkers(
@@ -106,6 +154,8 @@ function runFileInWorker(
   type: 'server' | 'e2e',
   onResults: (results: TestResults) => void,
   options: {
+    cwd?: string
+    coverage?: CoverageConfig
     open?: boolean
     playwrightUseOpts?: PlaywrightUseOpts
   } = {},
@@ -117,6 +167,7 @@ function runFileInWorker(
             workerData: {
               file: pathToFileURL(file).href,
               type,
+              coverage: options.coverage,
               open: options.open,
               playwrightUseOpts: options.playwrightUseOpts,
             },
@@ -125,6 +176,7 @@ function runFileInWorker(
             workerData: {
               file: pathToFileURL(file).href,
               type,
+              coverage: options.coverage,
             },
           })
     worker.once('message', (msg: TestResults) => onResults(msg))

package/src/lib/runtime.ts

@@ -0,0 +1,2 @@
+// https://bun.com/docs/guides/util/detect-bun
+export const IS_BUN = typeof process.versions.bun === 'string'

package/src/lib/ts-transform.ts

@@ -0,0 +1,36 @@
+import { transform, type TsconfigRaw } from 'esbuild'
+import { getTsconfig, type TsConfigResult } from 'get-tsconfig'
+import * as path from 'node:path'
+
+const tsconfigCache = new Map<string, TsConfigResult | null>()
+
+/*
+ * Transform a TypeScript file to JavaScript using esbuild with an inline
+ * source map and no minification. Used by the coverage ESM loader hook (so V8
+ * instruments readable JS), the coverage collector (so byte offsets can be
+ * re-derived and mapped back to TypeScript lines), and the browser harness
+ * server (so the bytes V8 sees in the browser match what the collector
+ * re-derives). Identical inputs must produce identical outputs across all
+ * call sites or coverage offsets won't line up.
+ *
+ * Compiler options (notably JSX) are taken from the nearest `tsconfig.json`
+ * walking up from the file's directory, so each project picks up its own
+ * `jsxImportSource` etc. Discovery results are cached by directory.
+ */
+export async function transformTypeScript(
+  source: string,
+  filePath: string,
+): Promise<{ code: string }> {
+  let loader: 'ts' | 'tsx' = filePath.endsWith('.tsx') ? 'tsx' : 'ts'
+
+  let tsConfig = getTsconfig(path.dirname(filePath), 'tsconfig.json', tsconfigCache)
+
+  let result = await transform(source, {
+    loader,
+    sourcemap: 'inline',
+    sourcesContent: true,
+    sourcefile: filePath,
+    tsconfigRaw: { compilerOptions: tsConfig?.config.compilerOptions ?? {} },
+  })
+  return { code: result.code }
+}

package/src/lib/worker-e2e.ts

@@ -1,15 +1,15 @@
 import { workerData, parentPort } from 'node:worker_threads'
-import { tsImport } from 'tsx/esm/api'
-import { createServer } from './e2e-server.ts'
-import { runTests, type TestResults } from './executor.ts'
+import { runTests } from './executor.ts'
+import { importModule } from './import-module.ts'
 import {
   getBrowserLauncher,
   getPlaywrightLaunchOptions,
   getPlaywrightPageOptions,
 } from './playwright.ts'
+import type { TestResults } from './reporters/results.ts'
 
 try {
-  await tsImport(workerData.file, import.meta.url)
+  await importModule(workerData.file, import.meta)
 
   let launcher = await getBrowserLauncher(workerData.playwrightUseOpts)
   let opts = getPlaywrightLaunchOptions(workerData.playwrightUseOpts)
@@ -17,9 +17,9 @@ try {
   try {
     let results = await runTests({
       browser,
-      createServer,
       open: workerData.open,
       playwrightPageOptions: getPlaywrightPageOptions(workerData.playwrightUseOpts),
+      coverage: workerData.coverage,
     })
     parentPort!.postMessage(results)
     if (workerData.open) {
@@ -29,6 +29,7 @@ try {
   } finally {
     await browser.close()
   }
+  process.exit(0)
 } catch (e) {
   let results: TestResults = {
     passed: 0,
@@ -49,4 +50,5 @@ try {
     ],
   }
   parentPort!.postMessage(results)
+  process.exit(0)
 }

package/src/lib/worker.ts

@@ -1,12 +1,31 @@
-import { workerData, parentPort } from 'node:worker_threads'
-import { tsImport } from 'tsx/esm/api'
-import { runTests, type TestResults } from './executor.ts'
+import * as mod from 'node:module'
+import * as path from 'node:path'
+import { parentPort, workerData } from 'node:worker_threads'
+import { runTests } from './executor.ts'
+import { importModule } from './import-module.ts'
+import type { TestResults } from './reporters/results.ts'
+import { IS_BUN } from './runtime.ts'
+import { IS_RUNNING_FROM_SRC } from './config.ts'
 
 try {
-  await tsImport(workerData.file, import.meta.url)
+  // When coverage is enabled in Node, we use a coverage-friendly TypeScript loader which
+  // replaces tsx's minified transformation with a non-minified esbuild transform
+  // so V8 coverage byte offsets align with readable source lines. This hook runs
+  // before the inherited tsx hook (hooks are LIFO), so it intercepts .ts imports and
+  // short-circuits before tsx transforms them.
+  if (workerData.coverage && !IS_BUN) {
+    // Ensure we load the right file whether we're running in the monorepo (TS) or
+    // from a published package (JS)
+    let ext = IS_RUNNING_FROM_SRC ? '.ts' : '.js'
+    mod.register(new URL(`./coverage-loader${ext}`, import.meta.url), import.meta.url)
+    await import(workerData.file)
+  } else {
+    await importModule(workerData.file, import.meta)
+  }
 
   let results = await runTests()
   parentPort!.postMessage(results)
+  process.exit(0)
 } catch (e) {
   let results: TestResults = {
     passed: 0,
@@ -27,4 +46,5 @@ try {
     ],
   }
   parentPort!.postMessage(results)
+  process.exit(0)
 }

package/src/test/coverage/fixture.ts

@@ -0,0 +1,34 @@
+// This file exists solely to validate coverage accuracy.
+// Each function has a known expected coverage profile based on
+// which paths the associated tests exercise.
+
+// Fully covered — both statements and the single branch
+export function add(a: number, b: number): number {
+  return a + b
+}
+
+// Partially covered — only the `n > 0` branch is tested
+export function classify(n: number): string {
+  if (n > 0) {
+    return 'positive'
+  } else if (n < 0) {
+    return 'negative'
+  } else {
+    return 'zero'
+  }
+}
+
+// Never called — 0% across the board
+export function uncalledFunction(): string {
+  let result = 'never'
+  result += ' reached'
+  return result
+}
+
+// Partially covered — only the truthy `name` branch is tested
+export function greet(name?: string): string {
+  if (name) {
+    return `Hello, ${name}!`
+  }
+  return 'Hello, stranger!'
+}

package/src/test/coverage/test-browser.ts

@@ -0,0 +1,29 @@
+import * as assert from '@remix-run/assert'
+import { describe, it } from '../../lib/framework.ts'
+import { add, classify, greet } from './fixture.ts'
+
+// Expected coverage for coverage-fixture.ts (same as the server/e2e fixture
+// tests):
+//
+//   add             — 100% functions, statements, lines, branches
+//   classify        — function covered, but only the `n > 0` branch is hit
+//                     (the `n < 0` and `else` branches are uncovered)
+//   uncalledFunction — 0% across the board (never imported)
+//   greet           — function covered, but only the truthy `name` branch is hit
+//                     (the fallback `Hello, stranger!` line is uncovered)
+
+describe('browser coverage fixture', () => {
+  it('exercises some but not all code paths in the browser', () => {
+    assert.equal(add(2, 3), 5)
+    assert.equal(add(-1, 1), 0)
+
+    assert.equal(classify(42), 'positive')
+    assert.equal(classify(1), 'positive')
+    // deliberately NOT testing classify(-1) or classify(0)
+
+    assert.equal(greet('World'), 'Hello, World!')
+    // deliberately NOT testing greet() without an argument
+
+    // deliberately NOT importing or calling uncalledFunction
+  })
+})

package/src/test/coverage/test-e2e.ts

@@ -0,0 +1,70 @@
+import * as assert from '@remix-run/assert'
+import { createTestServer } from '@remix-run/node-fetch-server/test'
+import * as fsp from 'node:fs/promises'
+import * as path from 'node:path'
+import { describe, it } from '../../lib/framework.ts'
+import { transformTypeScript } from '../../lib/ts-transform.ts'
+
+// Expected coverage for coverage/fixture.ts (same as the server fixture test):
+//
+//   add             — 100% functions, statements, lines, branches
+//   classify        — function covered, but only the `n > 0` branch is hit
+//   uncalledFunction — 0% across the board (never called)
+//   greet           — function covered, but only the truthy `name` branch is hit
+
+describe('e2e coverage fixture', () => {
+  it('exercises some but not all code paths in the browser', async (t) => {
+    // Compile the fixture TypeScript to browser-ready JS
+    let fixturePath = path.resolve(import.meta.dirname, './fixture.ts')
+    let fixtureSource = await fsp.readFile(fixturePath, 'utf-8')
+    let { code: fixtureJs } = await transformTypeScript(fixtureSource, fixturePath)
+
+    let handler: (request: Request) => Response = (req) => {
+      let url = new URL(req.url)
+
+      if (url.pathname === '/') {
+        return new Response(
+          [
+            `<!doctype html>`,
+            `<html>`,
+            `<body>`,
+            `  <div id="result"></div>`,
+            `  <script type="module">`,
+            `    import { add, classify, greet } from '/src/test/coverage/fixture.ts'`,
+            `    // Exercise the same paths as the server fixture test:`,
+            `    // - add: fully covered`,
+            `    // - classify: only positive branch`,
+            `    // - greet: only with a name`,
+            `    // - uncalledFunction: never imported`,
+            `    let results = [`,
+            `      add(2, 3),`,
+            `      add(-1, 1),`,
+            `      classify(42),`,
+            `      classify(1),`,
+            `      greet('World'),`,
+            `    ]`,
+            `    document.getElementById('result').textContent = results.join(',')`,
+            `  </script>`,
+            `</body>`,
+            `</html>`,
+          ].join('\n'),
+          { headers: { 'Content-Type': 'text/html' } },
+        )
+      }
+
+      // Serve the compiled fixture at the path the import expects
+      if (url.pathname === '/src/test/coverage/fixture.ts') {
+        return new Response(fixtureJs, {
+          headers: { 'Content-Type': 'application/javascript' },
+        })
+      }
+
+      return new Response('Not found', { status: 404 })
+    }
+    let page = await t.serve(await createTestServer(handler))
+
+    await page.goto('/')
+    let result = await page.locator('#result').textContent()
+    assert.equal(result, '5,0,positive,positive,Hello, World!')
+  })
+})

package/src/test/coverage/test-unit.ts

@@ -0,0 +1,32 @@
+import * as assert from '@remix-run/assert'
+import { describe, it } from '../../lib/framework.ts'
+import { add, classify, greet } from './fixture.ts'
+
+// Expected coverage for coverage-fixture.ts:
+//
+//   add             — 100% functions, statements, lines, branches
+//   classify        — function covered, but only the `n > 0` branch is hit
+//                     (the `n < 0` and `else` branches are uncovered)
+//   uncalledFunction — 0% across the board (never imported)
+//   greet           — function covered, but only the truthy `name` branch is hit
+//                     (the fallback `Hello, stranger!` line is uncovered)
+
+describe('coverage/fixture.ts', () => {
+  it('add returns the sum', () => {
+    assert.equal(add(2, 3), 5)
+    assert.equal(add(-1, 1), 0)
+  })
+
+  it('classify identifies positive numbers only', () => {
+    assert.equal(classify(42), 'positive')
+    assert.equal(classify(1), 'positive')
+    // deliberately NOT testing classify(-1) or classify(0)
+  })
+
+  // deliberately NOT importing or calling uncalledFunction
+
+  it('greet with a name only', () => {
+    assert.equal(greet('World'), 'Hello, World!')
+    // deliberately NOT testing greet() without an argument
+  })
+})

package/tsconfig.json

@@ -2,13 +2,15 @@
   "compilerOptions": {
     "strict": true,
     "lib": ["ES2024", "DOM", "DOM.Iterable"],
+    "types": ["node", "dom-navigation"],
     "module": "ES2022",
     "moduleResolution": "Bundler",
     "target": "ESNext",
     "allowImportingTsExtensions": true,
     "rewriteRelativeImportExtensions": true,
     "verbatimModuleSyntax": true,
+    "skipLibCheck": true,
     "jsx": "react-jsx",
-    "jsxImportSource": "@remix-run/component"
+    "jsxImportSource": "@remix-run/ui"
   }
 }

package/dist/lib/e2e-server.d.ts

@@ -1,11 +0,0 @@
-export interface CreateServerFunction {
-    (handler: (req: Request) => Promise<Response>): Promise<{
-        baseUrl: string;
-        close(): Promise<void>;
-    }>;
-}
-export declare function createServer(handler: (req: Request) => Promise<Response>): Promise<{
-    baseUrl: string;
-    close(): Promise<void>;
-}>;
-//# sourceMappingURL=e2e-server.d.ts.map

package/dist/lib/e2e-server.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"e2e-server.d.ts","sourceRoot":"","sources":["../../src/lib/e2e-server.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,oBAAoB;IACnC,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC;QACtD,OAAO,EAAE,MAAM,CAAA;QACf,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;KACvB,CAAC,CAAA;CACH;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC;IAClF,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACvB,CAAC,CAcD"}

package/dist/lib/e2e-server.js

@@ -1,15 +0,0 @@
-import * as http from 'node:http';
-import { createRequestListener } from '@remix-run/node-fetch-server';
-export function createServer(handler) {
-    return new Promise((resolve, reject) => {
-        let server = http.createServer(createRequestListener(handler));
-        server.listen(0, '127.0.0.1', () => {
-            let addr = server.address();
-            resolve({
-                baseUrl: `http://127.0.0.1:${addr.port}`,
-                close: () => new Promise((r, rj) => server.close((e) => (e ? rj(e) : r()))),
-            });
-        });
-        server.on('error', reject);
-    });
-}

package/dist/lib/framework.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=framework.test.d.ts.map

package/dist/lib/framework.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"framework.test.d.ts","sourceRoot":"","sources":["../../src/lib/framework.test.tsx"],"names":[],"mappings":""}

package/dist/lib/framework.test.e2e.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"framework.test.e2e.d.ts","sourceRoot":"","sources":["../../src/lib/framework.test.e2e.tsx"],"names":[],"mappings":""}