@rvoh/psychic-spec-helpers 0.3.1-fgbeta-9 → 0.4.0

package/dist/esm/src/feature/helpers/{launchViteServer.js → launchDevServer.js}

@@ -1,14 +1,14 @@
 import { spawn } from 'child_process';
 import { createServer } from 'net';
 import sleep from '../../shared/sleep.js';
-let serverProcess = undefined;
-export default async function launchViteServer({ port = 3000, cmd = 'yarn client', timeout = 5000, } = {}) {
-    if (serverProcess)
+const devServerProcesses = {};
+export default async function launchDevServer(key, { port = 3000, cmd = 'yarn client', timeout = 5000, } = {}) {
+    if (devServerProcesses[key])
         return;
     if (process.env.DEBUG === '1')
         console.log('Starting server...');
     const [_cmd, ...args] = cmd.split(' ');
-    serverProcess = spawn(_cmd, args, {
+    const proc = spawn(_cmd, args, {
         detached: true,
         env: {
             ...process.env,
@@ -16,41 +16,46 @@ export default async function launchViteServer({ port = 3000, cmd = 'yarn client
             VITE_PSYCHIC_ENV: 'test',
         },
     });
-    await waitForPort(port, timeout);
-    serverProcess.stdout.on('data', data => {
-        if (process.env.DEBUG === '1')
-            console.log(`Server output: ${data}`);
-    });
-    serverProcess.on('error', err => {
+    await waitForPort(key, port, timeout);
+    proc.on('error', err => {
         throw err;
     });
-    serverProcess.stdout.on('data', data => {
+    proc.stdout.on('data', data => {
         if (process.env.DEBUG === '1')
             console.log(`Server output: ${data}`);
     });
-    serverProcess.stderr.on('data', data => {
+    proc.stderr.on('data', data => {
         if (process.env.DEBUG === '1')
             console.error(`Server error: ${data}`);
     });
-    serverProcess.on('error', err => {
+    proc.on('error', err => {
         console.error(`Server process error: ${err}`);
     });
-    serverProcess.on('close', code => {
+    proc.on('close', code => {
         if (process.env.DEBUG === '1')
             console.log(`Server process exited with code ${code}`);
     });
 }
-export function stopViteServer() {
-    if (serverProcess?.pid) {
+export function stopDevServer(key) {
+    const proc = devServerProcesses[key];
+    if (!proc) {
+        throw new Error(`Cannot find a dev server by the key: ${key}`);
+    }
+    if (proc?.pid) {
         if (process.env.DEBUG === '1')
             console.log('Stopping server...');
         // serverProcess.kill('SIGINT')
-        process.kill(-serverProcess.pid, 'SIGKILL');
-        serverProcess = undefined;
+        process.kill(-proc.pid, 'SIGKILL');
+        delete devServerProcesses[key];
         if (process.env.DEBUG === '1')
             console.log('server stopped');
     }
 }
+export function stopDevServers() {
+    Object.keys(devServerProcesses).forEach(key => {
+        stopDevServer(key);
+    });
+}
 async function isPortAvailable(port) {
     return new Promise(resolve => {
         const server = createServer()
@@ -69,7 +74,7 @@ async function isPortAvailable(port) {
             .listen(port, '127.0.0.1');
     });
 }
-async function waitForPort(port, timeout = 5000) {
+async function waitForPort(key, port, timeout = 5000) {
     if (await isPortAvailable(port)) {
         return true;
     }
@@ -79,7 +84,7 @@ async function waitForPort(port, timeout = 5000) {
             return true;
         }
         if (Date.now() > startTime + timeout) {
-            stopViteServer();
+            stopDevServer(key);
             throw new Error('waited too long for port: ' + port);
         }
         await sleep(50);

package/dist/esm/src/feature/helpers/metaOrControlKey.js

@@ -0,0 +1,4 @@
+export default function metaOrControlKey() {
+    // Use 'Meta' for macOS and 'Control' for Windows/Linux
+    return process.platform === 'darwin' ? 'Meta' : 'Control';
+}

package/dist/esm/src/feature/helpers/providePuppeteerViteMatchers.js

@@ -18,32 +18,32 @@ import toFill from '../matchers/toFill.js';
 export default function providePuppeteerViteMatchers() {
     ;
     global.expect.extend({
-        async toMatchTextContent(page, text) {
-            return await toMatchTextContent(page, text);
+        async toMatchTextContent(page, text, opts) {
+            return await toMatchTextContent(page, text, opts);
         },
         async toNotMatchTextContent(page, text) {
             return await toNotMatchTextContent(page, text);
         },
-        async toHaveSelector(page, cssSelector) {
-            return await toHaveSelector(page, cssSelector);
+        async toHaveSelector(page, cssSelector, opts) {
+            return await toHaveSelector(page, cssSelector, opts);
         },
-        async toNotHaveSelector(page, cssSelector) {
-            return await toNotHaveSelector(page, cssSelector);
+        async toNotHaveSelector(page, cssSelector, opts) {
+            return await toNotHaveSelector(page, cssSelector, opts);
         },
-        async toCheck(page, text) {
-            return await toCheck(page, text);
+        async toCheck(page, text, opts) {
+            return await toCheck(page, text, opts);
         },
-        async toClick(page, text) {
-            return await toClick(page, text);
+        async toClick(page, text, opts) {
+            return await toClick(page, text, opts);
         },
-        async toClickLink(page, text) {
-            return await toClickLink(page, text);
+        async toClickLink(page, text, opts) {
+            return await toClickLink(page, text, opts);
         },
-        async toClickButton(page, text) {
-            return await toClickButton(page, text);
+        async toClickButton(page, text, opts) {
+            return await toClickButton(page, text, opts);
         },
-        async toClickSelector(page, cssSelector) {
-            return await toClickSelector(page, cssSelector);
+        async toClickSelector(page, cssSelector, opts) {
+            return await toClickSelector(page, cssSelector, opts);
         },
         async toHavePath(page, path) {
             return await toHavePath(page, path);
@@ -51,20 +51,20 @@ export default function providePuppeteerViteMatchers() {
         async toHaveUrl(page, url) {
             return await toHaveUrl(page, url);
         },
-        async toHaveChecked(page, text) {
-            return await toHaveChecked(page, text);
+        async toHaveChecked(page, text, opts) {
+            return await toHaveChecked(page, text, opts);
         },
-        async toHaveUnchecked(page, checked) {
-            return await toHaveUnchecked(page, checked);
+        async toHaveUnchecked(page, checked, opts) {
+            return await toHaveUnchecked(page, checked, opts);
         },
-        async toHaveLink(page, text) {
-            return await toHaveLink(page, text);
+        async toHaveLink(page, text, opts) {
+            return await toHaveLink(page, text, opts);
         },
-        async toFill(page, cssSelector, text) {
-            return await toFill(page, cssSelector, text);
+        async toFill(page, cssSelector, text, opts) {
+            return await toFill(page, cssSelector, text, opts);
         },
-        async toUncheck(page, text) {
-            return await toUncheck(page, text);
+        async toUncheck(page, text, opts) {
+            return await toUncheck(page, text, opts);
         },
         async toEvaluate(argumentPassedToExpect, evaluationFn, opts) {
             return await evaluateWithRetryAndTimeout(argumentPassedToExpect, evaluationFn, opts);

package/dist/esm/src/feature/helpers/visit.js

@@ -1,4 +1,3 @@
 export default async function visit(path, { baseUrl = 'http://localhost:3000' } = {}) {
     await page.goto(`${baseUrl}/${path.replace(/^\//, '')}`);
-    return page;
 }

package/dist/esm/src/feature/matchers/toCheck.js

@@ -1,23 +1,18 @@
-import evaluateWithRetryAndTimeout from '../internal/evaluateWithRetryAndTimeout.js';
-import evaluationFailure from '../internal/evaluationFailure.js';
-import requirePuppeteerPage from '../internal/requirePuppeteerPage.js';
-export default async function toCheck(page, expectedText) {
-    return await evaluateWithRetryAndTimeout(page, async () => {
-        requirePuppeteerPage(page);
-        const checkbox = await page.$(`input[type="checkbox"][value="${expectedText}"]`);
-        if (!checkbox)
-            return evaluationFailure(`A checkbox was not found with "${expectedText}"`);
-        const isChecked = await page.evaluate(checkbox => checkbox.checked, checkbox);
-        if (isChecked)
-            return evaluationFailure(`A checkbox was found with "${expectedText}", but it is already checked`);
-        await checkbox.click();
-        const isCheckedNow = await page.evaluate(checkbox => checkbox.checked, checkbox);
+export default async function toCheck(page, expectedText, opts) {
+    try {
+        const el = await page.waitForSelector(`label::-p-text(${expectedText}`, opts);
+        await el.click();
         return {
-            pass: isCheckedNow,
-            actual: expectedText,
+            pass: true,
+            message: () => {
+                throw new Error('Cannot negate toCheck');
+            },
         };
-    }, {
-        successText: r => `Expected page to have checkable checkbox with text: "${expectedText}"`,
-        failureText: r => `Expected page not to have checkable checkbox with text: "${expectedText}"`,
-    });
+    }
+    catch (error) {
+        return {
+            pass: false,
+            message: `Expected page to have checkable element with text: "${expectedText}"`,
+        };
+    }
 }

package/dist/esm/src/feature/matchers/toClick.js

@@ -1,11 +1,11 @@
-export default async function toClick(page, expectedText) {
+export default async function toClick(page, expectedText, opts) {
     try {
-        const el = await page.waitForSelector(`*::-p-text(${expectedText})`);
+        const el = await page.waitForSelector(`*::-p-text(${expectedText})`, opts);
         await el.click();
         return {
             pass: true,
             message: () => {
-                throw new Error('Cannot negate toNotMatchTextContent, use toMatchTextContent instead');
+                throw new Error('Cannot negate toClick');
             },
         };
     }

package/dist/esm/src/feature/matchers/toClickButton.js

@@ -1,25 +1,18 @@
-import { TimeoutError } from 'puppeteer';
-import evaluateWithRetryAndTimeout from '../internal/evaluateWithRetryAndTimeout.js';
-import evaluationFailure from '../internal/evaluationFailure.js';
-import requirePuppeteerPage from '../internal/requirePuppeteerPage.js';
-export default async function toClickButton(page, expectedText) {
-    return await evaluateWithRetryAndTimeout(page, async () => {
-        requirePuppeteerPage(page);
-        try {
-            ;
-            (await page.$('button::-p-text(Submit)')).click();
-        }
-        catch (err) {
-            if (err instanceof TimeoutError)
-                return evaluationFailure(expectedText);
-            throw err;
-        }
+export default async function toClickButton(page, expectedText, opts) {
+    try {
+        const el = await page.waitForSelector('button::-p-text(Submit)', opts);
+        await el.click();
         return {
             pass: true,
-            actual: expectedText,
+            message: () => {
+                throw new Error('Cannot negate toClickLink');
+            },
         };
-    }, {
-        successText: () => `Expected page to have clickable button with text: "${expectedText}"`,
-        failureText: () => `Expected page not to have clickable button with text: "${expectedText}"`,
-    });
+    }
+    catch (error) {
+        return {
+            pass: false,
+            message: `Expected page to have clickable link with matching text: "${expectedText}"`,
+        };
+    }
 }

package/dist/esm/src/feature/matchers/toClickLink.js

@@ -1,25 +1,18 @@
-import { TimeoutError } from 'puppeteer';
-import evaluateWithRetryAndTimeout from '../internal/evaluateWithRetryAndTimeout.js';
-import evaluationFailure from '../internal/evaluationFailure.js';
-import requirePuppeteerPage from '../internal/requirePuppeteerPage.js';
-export default async function toClickLink(page, expectedText) {
-    return await evaluateWithRetryAndTimeout(page, async () => {
-        requirePuppeteerPage(page);
-        try {
-            ;
-            (await page.$(`a ::-p-text(${expectedText})`)).click();
-        }
-        catch (err) {
-            if (err instanceof TimeoutError)
-                return evaluationFailure(expectedText);
-            throw err;
-        }
+export default async function toClickLink(page, expectedText, opts) {
+    try {
+        const el = await page.waitForSelector(`a ::-p-text(${expectedText})`, opts);
+        await el.click();
         return {
             pass: true,
-            actual: expectedText,
+            message: () => {
+                throw new Error('Cannot negate toClickLink');
+            },
         };
-    }, {
-        successText: () => `Expected page to have clickable link with text: "${expectedText}"`,
-        failureText: () => `Expected page not to have clickable link with text: "${expectedText}"`,
-    });
+    }
+    catch (error) {
+        return {
+            pass: false,
+            message: `Expected page to have clickable link with matching text: "${expectedText}"`,
+        };
+    }
 }

package/dist/esm/src/feature/matchers/toClickSelector.js

@@ -1,25 +1,18 @@
-import { TimeoutError } from 'puppeteer';
-import evaluateWithRetryAndTimeout from '../internal/evaluateWithRetryAndTimeout.js';
-import evaluationFailure from '../internal/evaluationFailure.js';
-import requirePuppeteerPage from '../internal/requirePuppeteerPage.js';
-export default async function toClickSelector(page, cssSelector) {
-    return await evaluateWithRetryAndTimeout(page, async () => {
-        requirePuppeteerPage(page);
-        try {
-            ;
-            (await page.$(cssSelector)).click();
-        }
-        catch (err) {
-            if (err instanceof TimeoutError)
-                return evaluationFailure(cssSelector);
-            throw err;
-        }
+export default async function toClickSelector(page, cssSelector, opts) {
+    try {
+        const el = await page.waitForSelector(cssSelector, opts);
+        await el.click();
         return {
             pass: true,
-            actual: cssSelector,
+            message: () => {
+                throw new Error('Cannot negate toNotMatchTextContent, use toMatchTextContent instead');
+            },
         };
-    }, {
-        successText: () => `Expected page to have clickable selector with text: "${cssSelector}"`,
-        failureText: () => `Expected page not to have clickable selector with text: "${cssSelector}"`,
-    });
+    }
+    catch (error) {
+        return {
+            pass: false,
+            message: `Expected page to have clickable element with matching selector: "${cssSelector}"`,
+        };
+    }
 }

package/dist/esm/src/feature/matchers/toFill.js

@@ -1,21 +1,30 @@
-import evaluateWithRetryAndTimeout from '../internal/evaluateWithRetryAndTimeout.js';
-import evaluationFailure from '../internal/evaluationFailure.js';
-import requirePuppeteerPage from '../internal/requirePuppeteerPage.js';
-export default async function toFill(page, cssSelector, text) {
-    return await evaluateWithRetryAndTimeout(page, async () => {
-        requirePuppeteerPage(page);
-        try {
-            await page.type(cssSelector, text);
-        }
-        catch {
-            return evaluationFailure(text);
+import metaOrControlKey from '../helpers/metaOrControlKey.js';
+export default async function toFill(page, cssSelector, text, opts) {
+    try {
+        await page.waitForSelector(cssSelector, opts);
+        // unless the user opts out, clear the input
+        // before typing into it, since most of the
+        // time this is what people will expect to
+        // happen.
+        if (!opts?.bypassInputValueReset) {
+            await page.focus(cssSelector);
+            await page.keyboard.down(metaOrControlKey());
+            await page.keyboard.press('A');
+            await page.keyboard.up(metaOrControlKey());
+            await page.keyboard.press('Backspace');
         }
+        await page.type(cssSelector, text);
         return {
             pass: true,
-            actual: text,
+            message: () => {
+                throw new Error('cannot negate toFill');
+            },
+        };
+    }
+    catch {
+        return {
+            pass: false,
+            message: () => `failed to fill input matching selector ${cssSelector} with text "text"`,
         };
-    }, {
-        successText: () => `Expected page to have clickable link with text: "${text}"`,
-        failureText: () => `Expected page not to have clickable link with text: "${text}"`,
-    });
+    }
 }

package/dist/esm/src/feature/matchers/toHaveChecked.js

@@ -1,19 +1,18 @@
-import evaluateWithRetryAndTimeout from '../internal/evaluateWithRetryAndTimeout.js';
-import evaluationFailure from '../internal/evaluationFailure.js';
-import requirePuppeteerPage from '../internal/requirePuppeteerPage.js';
-export default async function toHaveChecked(page, expectedText) {
-    return await evaluateWithRetryAndTimeout(page, async () => {
-        requirePuppeteerPage(page);
-        const checkbox = await page.$(`input[type="checkbox"][value="${expectedText}"]`);
-        if (!checkbox)
-            return evaluationFailure(`A checkbox was not found with "${expectedText}"`);
+export default async function toHaveChecked(page, expectedText, opts) {
+    try {
+        const checkbox = await page.waitForSelector(`input[type="checkbox"][value="${expectedText}"]`, opts);
         const isChecked = await page.evaluate(checkbox => checkbox.checked, checkbox);
         return {
             pass: isChecked,
-            actual: expectedText,
+            message: () => {
+                throw new Error('cannot negate toHaveChecked, try toHaveUnchecked');
+            },
         };
-    }, {
-        successText: r => `Expected page to have checked checkbox with text: "${expectedText}"`,
-        failureText: r => `Expected page not to have checked checkbox with text: "${expectedText}"`,
-    });
+    }
+    catch {
+        return {
+            pass: false,
+            message: () => `Expected page to have checked checkbox with text: "${expectedText}"`,
+        };
+    }
 }

package/dist/esm/src/feature/matchers/toHaveLink.js

@@ -1,25 +1,17 @@
-import { TimeoutError } from 'puppeteer';
-import evaluateWithRetryAndTimeout from '../internal/evaluateWithRetryAndTimeout.js';
-import evaluationFailure from '../internal/evaluationFailure.js';
-import requirePuppeteerPage from '../internal/requirePuppeteerPage.js';
-export default async function toHaveLink(page, expectedText) {
-    return await evaluateWithRetryAndTimeout(page, async () => {
-        requirePuppeteerPage(page);
-        let el = undefined;
-        try {
-            el = await page.locator(`a ::-p-text(${expectedText})`).setTimeout(10).wait();
-        }
-        catch (err) {
-            if (err instanceof TimeoutError)
-                return evaluationFailure(expectedText);
-            throw err;
-        }
+export default async function toHaveLink(page, expectedText, opts) {
+    try {
+        await page.waitForSelector(`a ::-p-text(${expectedText})`, opts);
         return {
-            pass: !!el,
-            actual: expectedText,
+            pass: true,
+            message: () => {
+                throw new Error('cannot negate toFill');
+            },
         };
-    }, {
-        successText: () => `Expected page to have clickable link with text: "${expectedText}"`,
-        failureText: () => `Expected page not to have clickable link with text: "${expectedText}"`,
-    });
+    }
+    catch {
+        return {
+            pass: false,
+            message: () => `Expected page not to have checked checkbox with text: "${expectedText}"`,
+        };
+    }
 }

package/dist/esm/src/feature/matchers/toHavePath.js

@@ -9,7 +9,9 @@ export default async function toHavePath(page, expectedPath) {
             actual: expectedPath,
         };
     }, {
-        successText: () => `Expected page to have path: "${expectedPath}"`,
+        successText: () => {
+            throw new Error('cannot negate toHavePath');
+        },
         failureText: () => `Expected page not to have path: "${expectedPath}"`,
     });
 }

package/dist/esm/src/feature/matchers/toHaveSelector.js

@@ -1,6 +1,6 @@
-export default async function toHaveSelector(page, selector) {
+export default async function toHaveSelector(page, selector, opts) {
     try {
-        await page.waitForSelector(selector);
+        await page.waitForSelector(selector, opts);
         return {
             pass: true,
             message: () => {

package/dist/esm/src/feature/matchers/toHaveUnchecked.js

@@ -1,19 +1,18 @@
-import evaluateWithRetryAndTimeout from '../internal/evaluateWithRetryAndTimeout.js';
-import evaluationFailure from '../internal/evaluationFailure.js';
-import requirePuppeteerPage from '../internal/requirePuppeteerPage.js';
-export default async function toHaveUnchecked(page, expectedText) {
-    return await evaluateWithRetryAndTimeout(page, async () => {
-        requirePuppeteerPage(page);
-        const checkbox = await page.$(`input[type="checkbox"][value="${expectedText}"]`);
-        if (!checkbox)
-            return evaluationFailure(`A checkbox was not found with "${expectedText}"`);
+export default async function toHaveUnchecked(page, expectedText, opts) {
+    try {
+        const checkbox = await page.waitForSelector(`input[type="checkbox"][value="${expectedText}"]`, opts);
         const isChecked = await page.evaluate(checkbox => checkbox.checked, checkbox);
         return {
             pass: !isChecked,
-            actual: expectedText,
+            message: () => {
+                throw new Error('cannot negate toHaveUnchecked, try toHaveChecked');
+            },
         };
-    }, {
-        successText: r => `Expected page to have unchecked checkbox with text: "${expectedText}"`,
-        failureText: r => `Expected page not to have unchecked checkbox with text: "${expectedText}"`,
-    });
+    }
+    catch {
+        return {
+            pass: false,
+            message: () => `Expected page not to have checked checkbox with text: "${expectedText}"`,
+        };
+    }
 }

package/dist/esm/src/feature/matchers/toNotHaveSelector.js

@@ -1,16 +1,17 @@
-import evaluateWithRetryAndTimeout from '../internal/evaluateWithRetryAndTimeout.js';
-import requirePuppeteerPage from '../internal/requirePuppeteerPage.js';
-export default async function toNotHaveSelector(page, selector) {
-    return await evaluateWithRetryAndTimeout(page, async () => {
-        requirePuppeteerPage(page);
+export default async function toNotHaveSelector(page, selector, opts) {
+    try {
+        await page.waitForSelector(selector, { hidden: true, ...opts });
         return {
-            pass: !(await page.$(selector)),
-            actual: selector,
+            pass: true,
+            message: () => {
+                throw new Error('Cannot negate toNotHaveSelector, use toHaveSelector instead');
+            },
         };
-    }, {
-        successText: () => {
-            throw new Error('Cannot negate toNotHaveSelector, use toHaveSelector instead');
-        },
-        failureText: r => `Expected ${r} to have selector: ${selector}`,
-    });
+    }
+    catch {
+        return {
+            pass: false,
+            message: () => `Expected page to not have visible selector, but it did: ${selector}`,
+        };
+    }
 }

package/dist/esm/src/feature/matchers/toUncheck.js

@@ -1,23 +1,26 @@
-import evaluateWithRetryAndTimeout from '../internal/evaluateWithRetryAndTimeout.js';
-import evaluationFailure from '../internal/evaluationFailure.js';
-import requirePuppeteerPage from '../internal/requirePuppeteerPage.js';
-export default async function toUncheck(page, expectedText) {
-    return await evaluateWithRetryAndTimeout(page, async () => {
-        requirePuppeteerPage(page);
-        const checkbox = await page.$(`input[type="checkbox"][value="${expectedText}"]`);
-        if (!checkbox)
-            return evaluationFailure(`A checkbox was not found with "${expectedText}"`);
-        const isChecked = await page.evaluate(checkbox => checkbox.checked, checkbox);
+export default async function toUncheck(page, expectedText, opts) {
+    try {
+        const el = await page.waitForSelector(`label::-p-text(${expectedText}`, opts);
+        await el.click();
+        const isChecked = await page.evaluate(checkbox => checkbox.checked, el);
         if (!isChecked)
-            return evaluationFailure(`A checkbox was found with "${expectedText}", but it is already unchecked`);
-        await checkbox.click();
-        const isCheckedNow = await page.evaluate(checkbox => checkbox.checked, checkbox);
+            return {
+                pass: false,
+                message: () => `A checkbox was found with "${expectedText}", but it is already unchecked`,
+            };
+        await el.click();
+        const isUncheckedNow = await page.evaluate(checkbox => checkbox.checked, el);
         return {
-            pass: !isCheckedNow,
-            actual: expectedText,
+            pass: isUncheckedNow,
+            message: () => {
+                throw new Error('Cannot negate toUncheck, try toCheck');
+            },
         };
-    }, {
-        successText: r => `Expected page to have uncheckable checkbox with text: "${expectedText}"`,
-        failureText: r => `Expected page not to have uncheckable checkbox with text: "${expectedText}"`,
-    });
+    }
+    catch (error) {
+        return {
+            pass: false,
+            message: `Expected page to have checkable element with text: "${expectedText}"`,
+        };
+    }
 }

package/dist/esm/src/index.js

@@ -7,6 +7,6 @@ export { SpecSession } from './unit/SpecSession.js';
 export { default as providePuppeteerViteMatchers } from './feature/helpers/providePuppeteerViteMatchers.js';
 export { default as launchBrowser } from './feature/helpers/launchBrowser.js';
 export { default as launchPage } from './feature/helpers/launchPage.js';
-export { default as launchViteServer, stopViteServer } from './feature/helpers/launchViteServer.js';
+export { default as launchDevServer, stopDevServers, stopDevServer, } from './feature/helpers/launchDevServer.js';
 export { default as visit } from './feature/helpers/visit.js';
 export default {};

package/dist/types/src/feature/helpers/launchDevServer.d.ts

@@ -0,0 +1,7 @@
+export default function launchDevServer(key: string, { port, cmd, timeout, }?: {
+    port?: number;
+    cmd?: string;
+    timeout?: number;
+}): Promise<void>;
+export declare function stopDevServer(key: string): void;
+export declare function stopDevServers(): void;